"The name of the thread. Setfable.")
(def!method print-object ((thread thread) stream)
- (if (thread-name thread)
- (print-unreadable-object (thread stream :type t :identity t)
- (prin1 (thread-name thread) stream))
- (print-unreadable-object (thread stream :type t :identity t)
- ;; body is empty => there is only one space between type and
- ;; identity
- ))
- thread)
+ (print-unreadable-object (thread stream :type t :identity t)
+ (let* ((cookie (list thread))
+ (info (if (thread-alive-p thread)
+ :running
+ (multiple-value-list (join-thread thread :default cookie))))
+ (state (if (eq :running info)
+ info
+ (if (eq cookie (car info))
+ :aborted
+ :finished)))
+ (values (when (eq :finished state) info)))
+ (format stream "~@[~S ~]~:[~A~;~A~:[ no values~; values: ~:*~{~S~^, ~}~]~]"
+ (thread-name thread)
+ (eq :finished state)
+ state
+ values))))
(defun thread-alive-p (thread)
#!+sb-doc
(defvar *all-threads* ())
(defvar *all-threads-lock* (make-mutex :name "all threads lock"))
+(defvar *default-alloc-signal* nil)
+
(defmacro with-all-threads-lock (&body body)
- `(call-with-system-mutex (lambda () ,@body) *all-threads-lock*))
+ `(with-system-mutex (*all-threads-lock*)
+ ,@body))
(defun list-all-threads ()
#!+sb-doc
(defun current-thread-sap ()
(sb!vm::current-thread-offset-sap sb!vm::thread-this-slot))
-(declaim (inline current-thread-sap-id))
-(defun current-thread-sap-id ()
+(declaim (inline current-thread-os-thread))
+(defun current-thread-os-thread ()
(sap-int
(sb!vm::current-thread-offset-sap sb!vm::thread-os-thread-slot)))
(/show0 "Entering INIT-INITIAL-THREAD")
(let ((initial-thread (%make-thread :name "initial thread"
:%alive-p t
- :os-thread (current-thread-sap-id))))
+ :os-thread (current-thread-os-thread))))
(setq *current-thread* initial-thread)
;; Either *all-threads* is empty or it contains exactly one thread
;; in case we are in reinit since saving core with multiple
(setf (fdocumentation 'make-mutex 'function)
"Create a mutex."
(fdocumentation 'mutex-name 'function)
- "The name of the mutex. Setfable."
- (fdocumentation 'mutex-value 'function)
- "The value of the mutex. NIL if the mutex is free. Setfable.")
+ "The name of the mutex. Setfable.")
#!+(and sb-thread (not sb-lutex))
-(define-structure-slot-addressor mutex-value-address
+(progn
+ (define-structure-slot-addressor mutex-state-address
:structure mutex
- :slot value)
-
-(defun get-mutex (mutex &optional (new-value *current-thread*) (waitp t))
+ :slot state)
+ ;; Important: current code assumes these are fixnums or other
+ ;; lisp objects that don't need pinning.
+ (defconstant +lock-free+ 0)
+ (defconstant +lock-taken+ 1)
+ (defconstant +lock-contested+ 2))
+
+(defun get-mutex (mutex &optional (new-owner *current-thread*) (waitp t))
#!+sb-doc
- "Acquire MUTEX, setting it to NEW-VALUE or some suitable default value if
-NIL. If WAITP is non-NIL and the mutex is in use, sleep until it is available."
- (declare (type mutex mutex) (optimize (speed 3)))
- (/show0 "Entering GET-MUTEX")
- (unless new-value
- (setq new-value *current-thread*))
- #!-sb-thread
- (let ((old (mutex-value mutex)))
- (when (and old waitp)
- (error "In unithread mode, mutex ~S was requested with WAITP ~S and ~
- new-value ~S, but has already been acquired (with value ~S)."
- mutex waitp new-value old))
- (setf (mutex-value mutex) new-value)
- t)
+ "Acquire MUTEX for NEW-OWNER, which must be a thread or NIL. If
+NEW-OWNER is NIL, it defaults to the current thread. If WAITP is
+non-NIL and the mutex is in use, sleep until it is available.
+
+Note: using GET-MUTEX to assign a MUTEX to another thread then the
+current one is not recommended, and liable to be deprecated.
+
+GET-MUTEX is not interrupt safe. The correct way to call it is:
+
+ (WITHOUT-INTERRUPTS
+ ...
+ (ALLOW-WITH-INTERRUPTS (GET-MUTEX ...))
+ ...)
+
+WITHOUT-INTERRUPTS is necessary to avoid an interrupt unwinding the
+call while the mutex is in an inconsistent state while
+ALLOW-WITH-INTERRUPTS allows the call to be interrupted from sleep.
+
+It is recommended that you use WITH-MUTEX instead of calling GET-MUTEX
+directly."
+ (declare (type mutex mutex) (optimize (speed 3))
+ #!-sb-thread (ignore waitp))
+ (unless new-owner
+ (setq new-owner *current-thread*))
+ (when (eql new-owner (mutex-%owner mutex))
+ (error "Recursive lock attempt ~S." mutex))
#!+sb-thread
(progn
- (when (eql new-value (mutex-value mutex))
- (warn "recursive lock attempt ~S~%" mutex)
- (format *debug-io* "Thread: ~A~%" *current-thread*)
- (sb!debug:backtrace most-positive-fixnum *debug-io*)
- (force-output *debug-io*))
;; FIXME: Lutexes do not currently support deadlines, as at least
;; on Darwin pthread_foo_timedbar functions are not supported:
;; this means that we probably need to use the Carbon multiprocessing
;; FIXME: This is definitely not interrupt safe: what happens if
;; we get hit (1) during the lutex calls (ok, they may be safe,
;; but has that been checked?) (2) after the lutex call, but
- ;; before setting the mutex value.
+ ;; before setting the mutex owner.
#!+sb-lutex
(when (zerop (with-lutex-address (lutex (mutex-lutex mutex))
(if waitp
(with-interrupts (%lutex-lock lutex))
(%lutex-trylock lutex))))
- (setf (mutex-value mutex) new-value))
+ (setf (mutex-%owner mutex) new-owner)
+ t)
#!-sb-lutex
- (let (old)
- (when (and (setf old (sb!ext:compare-and-swap (mutex-value mutex) nil new-value))
- waitp)
- (loop while old
- do (multiple-value-bind (to-sec to-usec) (decode-timeout nil)
- (when (= 1 (with-pinned-objects (mutex old)
- (futex-wait (mutex-value-address mutex)
- (get-lisp-obj-address old)
- (or to-sec -1)
- (or to-usec 0))))
- (signal-deadline)))
- (setf old (sb!ext:compare-and-swap (mutex-value mutex) nil new-value))))
- (not old))))
+ (let ((old (sb!ext:compare-and-swap (mutex-state mutex)
+ +lock-free+
+ +lock-taken+)))
+ (unless (or (eql +lock-free+ old) (not waitp))
+ (tagbody
+ :retry
+ (when (or (eql +lock-contested+ old)
+ (not (eql +lock-free+
+ (sb!ext:compare-and-swap (mutex-state mutex)
+ +lock-taken+
+ +lock-contested+))))
+ ;; Wait on the contested lock.
+ (multiple-value-bind (to-sec to-usec) (decode-timeout nil)
+ (when (= 1 (with-pinned-objects (mutex)
+ (futex-wait (mutex-state-address mutex)
+ (get-lisp-obj-address +lock-contested+)
+ (or to-sec -1)
+ (or to-usec 0))))
+ (signal-deadline))))
+ (setf old (sb!ext:compare-and-swap (mutex-state mutex)
+ +lock-free+
+ +lock-contested+))
+ ;; Did we get it?
+ (unless (eql +lock-free+ old)
+ (go :retry))))
+ (cond ((eql +lock-free+ old)
+ (let ((prev (sb!ext:compare-and-swap (mutex-%owner mutex)
+ nil new-owner)))
+ (when prev
+ (bug "Old owner in free mutex: ~S" prev))
+ t))
+ (waitp
+ (bug "Failed to acquire lock with WAITP."))))))
(defun release-mutex (mutex)
#!+sb-doc
"Release MUTEX by setting it to NIL. Wake up threads waiting for
-this mutex."
+this mutex.
+
+RELEASE-MUTEX is not interrupt safe: interrupts should be disabled
+around calls to it.
+
+Signals a WARNING is current thread is not the current owner of the
+mutex."
(declare (type mutex mutex))
- (/show0 "Entering RELEASE-MUTEX")
- (setf (mutex-value mutex) nil)
+ ;; Order matters: set owner to NIL before releasing state.
+ (let* ((self *current-thread*)
+ (old-owner (sb!ext:compare-and-swap (mutex-%owner mutex) self nil)))
+ (unless (eql self old-owner)
+ (warn "Releasing ~S, owned by another thread: ~S" mutex old-owner)
+ (setf (mutex-%owner mutex) nil)))
#!+sb-thread
(progn
#!+sb-lutex
(with-lutex-address (lutex (mutex-lutex mutex))
(%lutex-unlock lutex))
#!-sb-lutex
- (futex-wake (mutex-value-address mutex) 1)))
+ (let ((old (sb!ext:compare-and-swap (mutex-state mutex)
+ +lock-taken+ +lock-free+)))
+ (when (eql old +lock-contested+)
+ (sb!ext:compare-and-swap (mutex-state mutex)
+ +lock-contested+ +lock-free+)
+ (with-pinned-objects (mutex)
+ (futex-wake (mutex-state-address mutex) 1))))
+ nil))
;;;; waitqueues/condition variables
(assert mutex)
#!-sb-thread (error "Not supported in unithread builds.")
#!+sb-thread
- (let ((value (mutex-value mutex)))
+ (let ((owner (mutex-%owner mutex)))
(/show0 "CONDITION-WAITing")
#!+sb-lutex
(progn
;; FIXME: This doesn't look interrupt safe!
- (setf (mutex-value mutex) nil)
+ (setf (mutex-%owner mutex) nil)
(with-lutex-address (queue-lutex-address (waitqueue-lutex queue))
(with-lutex-address (mutex-lutex-address (mutex-lutex mutex))
(%lutex-wait queue-lutex-address mutex-lutex-address)))
- (setf (mutex-value mutex) value))
+ (setf (mutex-%owner mutex) owner))
#!-sb-lutex
(unwind-protect
(let ((me *current-thread*))
;; before returning. Ideally, in the case of an unhandled signal,
;; we should do them before entering the debugger, but this is
;; better than nothing.
- (get-mutex mutex value))))
+ (get-mutex mutex owner))))
(defun condition-notify (queue &optional (n 1))
#!+sb-doc
(defvar *session* nil)
-;;; the debugger itself tries to acquire the session lock, don't let
+;;; The debugger itself tries to acquire the session lock, don't let
;;; funny situations (like getting a sigint while holding the session
-;;; lock) occur
+;;; lock) occur. At the same time we need to allow interrupts while
+;;; *waiting* for the session lock for things like GET-FOREGROUND
+;;; to be interruptible.
+;;;
+;;; Take care: we sometimes need to obtain the session lock while holding
+;;; on to *ALL-THREADS-LOCK*, so we must _never_ obtain it _after_ getting
+;;; a session lock! (Deadlock risk.)
+;;;
+;;; FIXME: It would be good to have ordered locks to ensure invariants like
+;;; the above.
(defmacro with-session-lock ((session) &body body)
- `(call-with-system-mutex (lambda () ,@body) (session-lock ,session)))
+ `(with-system-mutex ((session-lock ,session) :allow-with-interrupts t)
+ ,@body))
(defun new-session ()
(make-session :threads (list *current-thread*)
;; of Allegro's *cl-default-special-bindings*, as that is at
;; least accessible to users to secure their own libraries.
;; --njf, 2006-07-15
- (let ((*current-thread* thread)
- (*restart-clusters* nil)
- (*handler-clusters* nil)
- (*condition-restarts* nil)
- (sb!impl::*step-out* nil)
- ;; internal printer variables
- (sb!impl::*previous-case* nil)
- (sb!impl::*previous-readtable-case* nil)
- (sb!impl::*merge-sort-temp-vector* (vector)) ; keep these small!
- (sb!impl::*zap-array-data-temp* (vector)) ;
- (sb!impl::*internal-symbol-output-fun* nil)
- (sb!impl::*descriptor-handlers* nil)) ; serve-event
- (setf (thread-os-thread thread) (current-thread-sap-id))
+ (let* ((*current-thread* thread)
+ (*restart-clusters* nil)
+ (*handler-clusters* nil)
+ (*condition-restarts* nil)
+ (sb!impl::*deadline* nil)
+ (sb!impl::*step-out* nil)
+ ;; internal printer variables
+ (sb!impl::*previous-case* nil)
+ (sb!impl::*previous-readtable-case* nil)
+ (empty (vector))
+ (sb!impl::*merge-sort-temp-vector* empty)
+ (sb!impl::*zap-array-data-temp* empty)
+ (sb!impl::*internal-symbol-output-fun* nil)
+ (sb!impl::*descriptor-handlers* nil)) ; serve-event
+ ;; Binding from C
+ (setf sb!vm:*alloc-signal* *default-alloc-signal*)
+ (setf (thread-os-thread thread) (current-thread-os-thread))
(with-mutex ((thread-result-lock thread))
(with-all-threads-lock
(push thread *all-threads*))
"The thread that was not interrupted.")
(defmacro with-interruptions-lock ((thread) &body body)
- `(call-with-system-mutex (lambda () ,@body) (thread-interruptions-lock ,thread)))
+ `(with-system-mutex ((thread-interruptions-lock ,thread))
+ ,@body))
;; Called from the signal handler in C.
(defun run-interruption ()
SB-EXT:QUIT - the usual cleanup forms will be evaluated"
(interrupt-thread thread 'sb!ext:quit))
-;;; internal use only. If you think you need to use this, either you
+(define-alien-routine "thread_yield" int)
+
+#!+sb-doc
+(setf (fdocumentation 'thread-yield 'function)
+ "Yield the processor to other threads.")
+
+;;; internal use only. If you think you need to use these, either you
;;; are an SBCL developer, are doing something that you should discuss
;;; with an SBCL developer first, or are doing something that you
;;; should probably discuss with a professional psychiatrist first
#!+sb-thread
-(defun thread-sap-for-id (id)
- (let ((thread-sap (alien-sap (extern-alien "all_threads" (* t)))))
- (loop
- (when (sap= thread-sap (int-sap 0)) (return nil))
- (let ((os-thread (sap-ref-word thread-sap
- (* sb!vm:n-word-bytes
- sb!vm::thread-os-thread-slot))))
- (when (= os-thread id) (return thread-sap))
- (setf thread-sap
- (sap-ref-sap thread-sap (* sb!vm:n-word-bytes
- sb!vm::thread-next-slot)))))))
-
-#!+sb-thread
-(defun symbol-value-in-thread (symbol thread-sap)
- (let* ((index (sb!vm::symbol-tls-index symbol))
- (tl-val (sap-ref-word thread-sap
- (* sb!vm:n-word-bytes index))))
- (if (eql tl-val sb!vm::no-tls-value-marker-widetag)
- (sb!vm::symbol-global-value symbol)
- (make-lisp-obj tl-val))))
+(progn
+ (defun %thread-sap (thread)
+ (let ((thread-sap (alien-sap (extern-alien "all_threads" (* t))))
+ (target (thread-os-thread thread)))
+ (loop
+ (when (sap= thread-sap (int-sap 0)) (return nil))
+ (let ((os-thread (sap-ref-word thread-sap
+ (* sb!vm:n-word-bytes
+ sb!vm::thread-os-thread-slot))))
+ (when (= os-thread target) (return thread-sap))
+ (setf thread-sap
+ (sap-ref-sap thread-sap (* sb!vm:n-word-bytes
+ sb!vm::thread-next-slot)))))))
+
+ (defun %symbol-value-in-thread (symbol thread)
+ (tagbody
+ ;; Prevent the dead from dying completely while we look for the TLS area...
+ (with-all-threads-lock
+ (if (thread-alive-p thread)
+ (let* ((offset (* sb!vm:n-word-bytes (sb!vm::symbol-tls-index symbol)))
+ (tl-val (sap-ref-word (%thread-sap thread) offset)))
+ (if (eql tl-val sb!vm::no-tls-value-marker-widetag)
+ (go :unbound)
+ (return-from %symbol-value-in-thread (values (make-lisp-obj tl-val) t))))
+ (return-from %symbol-value-in-thread (values nil nil))))
+ :unbound
+ (error "Cannot read thread-local symbol value: ~S unbound in ~S" symbol thread)))
+
+ (defun %set-symbol-value-in-thread (symbol thread value)
+ (tagbody
+ (with-pinned-objects (value)
+ ;; Prevent the dead from dying completely while we look for the TLS area...
+ (with-all-threads-lock
+ (if (thread-alive-p thread)
+ (let* ((offset (* sb!vm:n-word-bytes (sb!vm::symbol-tls-index symbol)))
+ (sap (%thread-sap thread))
+ (tl-val (sap-ref-word sap offset)))
+ (if (eql tl-val sb!vm::no-tls-value-marker-widetag)
+ (go :unbound)
+ (setf (sap-ref-word sap offset) (get-lisp-obj-address value)))
+ (return-from %set-symbol-value-in-thread (values value t)))
+ (return-from %set-symbol-value-in-thread (values nil nil)))))
+ :unbound
+ (error "Cannot set thread-local symbol value: ~S unbound in ~S" symbol thread))))
(defun sb!vm::locked-symbol-global-value-add (symbol-name delta)
(sb!vm::locked-symbol-global-value-add symbol-name delta))
projects / sbcl.git / blobdiff