X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Ftarget-thread.lisp;h=015ebd1865a1c93e1146537225f85d29e8159eed;hb=bbbe40be1052fe7d46dacbfeb2e13041e5c9b293;hp=c7d40d901f86bd3bbeddfb5b583bca4810e08f9e;hpb=8ee426cacceebd52f18232cd748ba8a1f211e9fd;p=sbcl.git diff --git a/src/code/target-thread.lisp b/src/code/target-thread.lisp index c7d40d9..015ebd1 100644 --- a/src/code/target-thread.lisp +++ b/src/code/target-thread.lisp @@ -1,373 +1,1042 @@ +;;;; support for threads in the target machine + +;;;; This software is part of the SBCL system. See the README file for +;;;; more information. +;;;; +;;;; This software is derived from the CMU CL system, which was +;;;; written at Carnegie Mellon University and released into the +;;;; public domain. The software is in the public domain and is +;;;; provided with absolutely no warranty. See the COPYING and CREDITS +;;;; files for more information. + (in-package "SB!THREAD") -(sb!alien::define-alien-routine ("create_thread" %create-thread) - sb!alien:unsigned-long - (lisp-fun-address sb!alien:unsigned-long)) - -(defun make-thread (function) - (let ((real-function (coerce function 'function))) - (%create-thread - (sb!kernel:get-lisp-obj-address - (lambda () - ;; in time we'll move some of the binding presently done in C - ;; here too - (let ((sb!kernel::*restart-clusters* nil) - (sb!impl::*descriptor-handlers* nil); serve-event - (sb!impl::*available-buffers* nil)) ;for fd-stream - ;; can't use handling-end-of-the-world, because that flushes - ;; output streams, and we don't necessarily have any (or we - ;; could be sharing them) - (sb!sys:enable-interrupt :sigint :ignore) - (sb!unix:unix-exit - (catch 'sb!impl::%end-of-the-world - (with-simple-restart - (destroy-thread - (format nil "~~@" - (current-thread-id))) - (funcall real-function)) - 0)))))))) - -(defun destroy-thread (thread-id) - (sb!unix:unix-kill thread-id :sigterm) - ;; may have been stopped for some reason, so now wake it up to - ;; deliver the TERM - (sb!unix:unix-kill thread-id :sigcont)) - -;; Conventional wisdom says that it's a bad idea to use these unless -;; you really need to. Use a lock or a waitqueue instead -(defun suspend-thread (thread-id) - (sb!unix:unix-kill thread-id :sigstop)) -(defun resume-thread (thread-id) - (sb!unix:unix-kill thread-id :sigcont)) - -(defun current-thread-id () - (sb!sys:sap-int - (sb!vm::current-thread-offset-sap sb!vm::thread-pid-slot))) - -;;;; iterate over the in-memory threads - -(defun mapcar-threads (function) - "Call FUNCTION once for each known thread, giving it the thread structure as argument" - (let ((function (coerce function 'function))) - (loop for thread = (alien-sap (extern-alien "all_threads" (* t))) - then (sb!sys:sap-ref-sap thread (* 4 sb!vm::thread-next-slot)) - until (sb!sys:sap= thread (sb!sys:int-sap 0)) - collect (funcall function thread)))) - -;;;; queues, locks - -;; spinlocks use 0 as "free" value: higher-level locks use NIL -(defun get-spinlock (lock offset new-value) +;;; Of the WITH-PINNED-OBJECTS in this file, not every single one is +;;; necessary because threads are only supported with the conservative +;;; gencgc and numbers on the stack (returned by GET-LISP-OBJ-ADDRESS) +;;; are treated as references. + +;;; set the doc here because in early-thread FDOCUMENTATION is not +;;; available, yet +#!+sb-doc +(setf (fdocumentation '*current-thread* 'variable) + "Bound in each thread to the thread itself.") + +(defstruct (thread (:constructor %make-thread)) + #!+sb-doc + "Thread type. Do not rely on threads being structs as it may change +in future versions." + name + %alive-p + os-thread + interruptions + (interruptions-lock (make-mutex :name "thread interruptions lock")) + result + (result-lock (make-mutex :name "thread result lock"))) + +#!+sb-doc +(setf (fdocumentation 'thread-name 'function) + "The name of the thread. Setfable.") + +(def!method print-object ((thread thread) stream) + (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 + "Check if THREAD is running." + (thread-%alive-p thread)) + +;; A thread is eligible for gc iff it has finished and there are no +;; more references to it. This list is supposed to keep a reference to +;; all running threads. +(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) + `(with-system-mutex (*all-threads-lock*) + ,@body)) + +(defun list-all-threads () + #!+sb-doc + "Return a list of the live threads." + (with-all-threads-lock + (copy-list *all-threads*))) + +(declaim (inline current-thread-sap)) +(defun current-thread-sap () + (sb!vm::current-thread-offset-sap sb!vm::thread-this-slot)) + +(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))) + +(defun init-initial-thread () + (/show0 "Entering INIT-INITIAL-THREAD") + (let ((initial-thread (%make-thread :name "initial thread" + :%alive-p t + :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 + ;; threads doesn't work. + (setq *all-threads* (list initial-thread)))) + + +;;;; Aliens, low level stuff + +#!+sb-thread +(progn + ;; FIXME it would be good to define what a thread id is or isn't + ;; (our current assumption is that it's a fixnum). It so happens + ;; that on Linux it's a pid, but it might not be on posix thread + ;; implementations. + (define-alien-routine ("create_thread" %create-thread) + unsigned-long (lisp-fun-address unsigned-long)) + + (define-alien-routine "signal_interrupt_thread" + integer (os-thread unsigned-long)) + + (define-alien-routine "block_deferrable_signals" + void) + + #!+sb-lutex + (progn + (declaim (inline %lutex-init %lutex-wait %lutex-wake + %lutex-lock %lutex-unlock)) + + (define-alien-routine ("lutex_init" %lutex-init) + int (lutex unsigned-long)) + + (define-alien-routine ("lutex_wait" %lutex-wait) + int (queue-lutex unsigned-long) (mutex-lutex unsigned-long)) + + (define-alien-routine ("lutex_wake" %lutex-wake) + int (lutex unsigned-long) (n int)) + + (define-alien-routine ("lutex_lock" %lutex-lock) + int (lutex unsigned-long)) + + (define-alien-routine ("lutex_trylock" %lutex-trylock) + int (lutex unsigned-long)) + + (define-alien-routine ("lutex_unlock" %lutex-unlock) + int (lutex unsigned-long)) + + (define-alien-routine ("lutex_destroy" %lutex-destroy) + int (lutex unsigned-long)) + + ;; FIXME: Defining a whole bunch of alien-type machinery just for + ;; passing primitive lutex objects directly to foreign functions + ;; doesn't seem like fun right now. So instead we just manually + ;; pin the lutex, get its address, and let the callee untag it. + (defmacro with-lutex-address ((name lutex) &body body) + `(let ((,name ,lutex)) + (with-pinned-objects (,name) + (let ((,name (get-lisp-obj-address ,name))) + ,@body)))) + + (defun make-lutex () + (/show0 "Entering MAKE-LUTEX") + ;; Suppress GC until the lutex has been properly registered with + ;; the GC. + (without-gcing + (let ((lutex (sb!vm::%make-lutex))) + (/show0 "LUTEX=..") + (/hexstr lutex) + (with-lutex-address (lutex lutex) + (%lutex-init lutex)) + lutex)))) + + #!-sb-lutex + (progn + (declaim (inline futex-wait %futex-wait futex-wake)) + + (define-alien-routine ("futex_wait" %futex-wait) + int (word unsigned-long) (old-value unsigned-long) + (to-sec long) (to-usec unsigned-long)) + + (defun futex-wait (word old to-sec to-usec) + (with-interrupts + (%futex-wait word old to-sec to-usec))) + + (define-alien-routine "futex_wake" + int (word unsigned-long) (n unsigned-long)))) + +;;; used by debug-int.lisp to access interrupt contexts +#!-(or sb-fluid sb-thread) (declaim (inline sb!vm::current-thread-offset-sap)) +#!-sb-thread +(defun sb!vm::current-thread-offset-sap (n) + (declare (type (unsigned-byte 27) n)) + (sap-ref-sap (alien-sap (extern-alien "all_threads" (* t))) + (* n sb!vm:n-word-bytes))) + +#!+sb-thread +(defun sb!vm::current-thread-offset-sap (n) + (declare (type (unsigned-byte 27) n)) + (sb!vm::current-thread-offset-sap n)) + + +;;;; Spinlocks + +(declaim (inline get-spinlock release-spinlock)) + +;;; Should always be called with interrupts disabled. +(defun get-spinlock (spinlock) + (declare (optimize (speed 3) (safety 0))) + (let* ((new *current-thread*) + (old (sb!ext:compare-and-swap (spinlock-value spinlock) nil new))) + (when old + (when (eq old new) + (error "Recursive lock attempt on ~S." spinlock)) + #!+sb-thread + (flet ((cas () + (if (sb!ext:compare-and-swap (spinlock-value spinlock) nil new) + (thread-yield) + (return-from get-spinlock t)))) + (if (and (not *interrupts-enabled*) *allow-with-interrupts*) + ;; If interrupts are disabled, but we are allowed to + ;; enabled them, check for pending interrupts every once + ;; in a while. + (loop + (loop repeat 128 do (cas)) ; 128 is arbitrary here + (sb!unix::%check-interrupts)) + (loop (cas))))) + t)) + +(defun release-spinlock (spinlock) (declare (optimize (speed 3) (safety 0))) - (loop until - (eql (sb!vm::%instance-set-conditional lock offset 0 new-value) 0))) - -(defmacro with-spinlock ((queue) &body body) - (with-unique-names (pid) - `(unwind-protect - (let ((,pid (current-thread-id))) - (get-spinlock ,queue 2 ,pid) - ,@body) - (setf (waitqueue-lock ,queue) 0)))) - -;;;; the higher-level locking operations are based on waitqueues - -(defstruct waitqueue - (name nil :type (or null simple-base-string)) - (lock 0) + ;; On x86 and x86-64 we can get away with no memory barriers, (see + ;; Linux kernel mailing list "spin_unlock optimization(i386)" + ;; thread, summary at + ;; http://kt.iserv.nl/kernel-traffic/kt19991220_47.html#1. + ;; + ;; If the compiler may reorder this with other instructions, insert + ;; compiler barrier here. + ;; + ;; FIXME: this does not work on SMP Pentium Pro and OOSTORE systems, + ;; neither on most non-x86 architectures (but we don't have threads + ;; on those). + (setf (spinlock-value spinlock) nil)) + + +;;;; Mutexes + +#!+sb-doc +(setf (fdocumentation 'make-mutex 'function) + "Create a mutex." + (fdocumentation 'mutex-name 'function) + "The name of the mutex. Setfable.") + +#!+(and sb-thread (not sb-lutex)) +(progn + (define-structure-slot-addressor mutex-state-address + :structure mutex + :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 mutex-owner (mutex) + "Current owner of the mutex, NIL if the mutex is free. Naturally, +this is racy by design (another thread may acquire the mutex after +this function returns), it is intended for informative purposes. For +testing whether the current thread is holding a mutex see +HOLDING-MUTEX-P." + ;; Make sure to get the current value. + (sb!ext:compare-and-swap (mutex-%owner mutex) nil nil)) + +(defun get-mutex (mutex &optional (new-owner *current-thread*) (waitp t)) + #!+sb-doc + "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*)) + (let ((old (mutex-%owner mutex))) + (when (eq new-owner old) + (error "Recursive lock attempt ~S." mutex)) + #!-sb-thread + (when old + (error "Strange deadlock on ~S in an unithreaded build?" mutex))) + #!-sb-thread + (setf (mutex-%owner mutex) new-owner) + #!+sb-thread + (progn + ;; 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 + ;; functions on Darwin. + ;; + ;; 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 owner. + #!+sb-lutex + (when (zerop (with-lutex-address (lutex (mutex-lutex mutex)) + (if waitp + (with-interrupts (%lutex-lock lutex)) + (%lutex-trylock lutex)))) + (setf (mutex-%owner mutex) new-owner) + t) + #!-sb-lutex + ;; This is a direct tranlation of the Mutex 2 algorithm from + ;; "Futexes are Tricky" by Ulrich Drepper. + (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. + +RELEASE-MUTEX is not interrupt safe: interrupts should be disabled +around calls to it. + +Signals a WARNING if current thread is not the current owner of the +mutex." + (declare (type mutex mutex)) + ;; 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 + ;; FIXME: once ATOMIC-INCF supports struct slots with word sized + ;; unsigned-byte type this can be used: + ;; + ;; (let ((old (sb!ext:atomic-incf (mutex-state mutex) -1))) + ;; (unless (eql old +lock-free+) + ;; (setf (mutex-state mutex) +lock-free+) + ;; (with-pinned-objects (mutex) + ;; (futex-wake (mutex-state-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 + +(defstruct (waitqueue (:constructor %make-waitqueue)) + #!+sb-doc + "Waitqueue type." + (name nil :type (or null simple-string)) + #!+(and sb-lutex sb-thread) + (lutex (make-lutex)) + #!-sb-lutex (data nil)) -(defstruct (mutex (:include waitqueue)) - (value nil)) - -(sb!alien:define-alien-routine "block_sigcont" void) -(sb!alien:define-alien-routine "unblock_sigcont_and_sleep" void) - -;;; this should only be called while holding the queue spinlock. -;;; it releases the spinlock before sleeping -(defun wait-on-queue (queue &optional lock) - (let ((pid (current-thread-id))) - ;; FIXME what should happen if we get interrupted when we've blocked - ;; the sigcont? For that matter, can we get interrupted? - (block-sigcont) - (when lock (release-mutex lock)) - (sb!sys:without-interrupts - (pushnew pid (waitqueue-data queue))) - (setf (waitqueue-lock queue) 0) - (unblock-sigcont-and-sleep))) - -;;; this should only be called while holding the queue spinlock. It doesn't -;;; release it -(defun dequeue (queue) - (let ((pid (current-thread-id))) - (sb!sys:without-interrupts - (setf (waitqueue-data queue) - (delete pid (waitqueue-data queue)))))) - -;;; this should probably only be called while holding the queue spinlock. -;;; not sure -(defun signal-queue-head (queue) - (let ((p (car (waitqueue-data queue)))) - (when p (sb!unix:unix-kill p :sigcont)))) - -;;;; mutex - -(defun get-mutex (lock &optional new-value (wait-p t)) - (declare (type mutex lock)) - (let ((pid (current-thread-id))) - (unless new-value (setf new-value pid)) - (assert (not (eql new-value (mutex-value lock)))) - (get-spinlock lock 2 pid) - (loop - (unless - ;; args are object slot-num old-value new-value - (sb!vm::%instance-set-conditional lock 4 nil new-value) - (dequeue lock) - (setf (waitqueue-lock lock) 0) - (return t)) - (unless wait-p - (setf (waitqueue-lock lock) 0) - (return nil)) - (wait-on-queue lock nil)))) - -(defun release-mutex (lock &optional (new-value nil)) - (declare (type mutex lock)) - ;; we assume the lock is ours to release - (with-spinlock (lock) - (setf (mutex-value lock) new-value) - (signal-queue-head lock))) - - -(defmacro with-mutex ((mutex &key value (wait-p t)) &body body) - (with-unique-names (got) - `(let ((,got (get-mutex ,mutex ,value ,wait-p))) - (when ,got - (unwind-protect - (progn ,@body) - (release-mutex ,mutex)))))) - - -;;;; condition variables - -(defun condition-wait (queue lock) - "Atomically release LOCK and enqueue ourselves on QUEUE. Another +(defun make-waitqueue (&key name) + #!+sb-doc + "Create a waitqueue." + (%make-waitqueue :name name)) + +#!+sb-doc +(setf (fdocumentation 'waitqueue-name 'function) + "The name of the waitqueue. Setfable.") + +#!+(and sb-thread (not sb-lutex)) +(define-structure-slot-addressor waitqueue-data-address + :structure waitqueue + :slot data) + +(defun condition-wait (queue mutex) + #!+sb-doc + "Atomically release MUTEX and enqueue ourselves on QUEUE. Another thread may subsequently notify us using CONDITION-NOTIFY, at which -time we reacquire LOCK and return to the caller." - (unwind-protect - (progn - (get-spinlock queue 2 (current-thread-id)) - (wait-on-queue queue lock)) - ;; If we are interrupted while waiting, we should do these things - ;; before returning. Ideally, in the case of an unhandled signal, - ;; we should do them before entering the debugger, but this is - ;; better than nothing. - (with-spinlock (queue) - (dequeue queue)) - (get-mutex lock))) +time we reacquire MUTEX and return to the caller." + #!-sb-thread (declare (ignore queue)) + (assert mutex) + #!-sb-thread (error "Not supported in unithread builds.") + #!+sb-thread + (let ((me *current-thread*)) + (assert (eq me (mutex-%owner mutex))) + (/show0 "CONDITION-WAITing") + #!+sb-lutex + ;; Need to disable interrupts so that we don't miss setting the + ;; owner on our way out. (pthread_cond_wait handles the actual + ;; re-acquisition.) + (without-interrupts + (unwind-protect + (progn + (setf (mutex-%owner mutex) nil) + (with-lutex-address (queue-lutex-address (waitqueue-lutex queue)) + (with-lutex-address (mutex-lutex-address (mutex-lutex mutex)) + (with-local-interrupts + (%lutex-wait queue-lutex-address mutex-lutex-address))))) + (setf (mutex-%owner mutex) me))) + #!-sb-lutex + ;; Need to disable interrupts so that we don't miss grabbing the + ;; mutex on our way out. + (without-interrupts + (unwind-protect + (let ((me *current-thread*)) + ;; This setf becomes visible to other CPUS due to the + ;; usual memory barrier semantics of lock + ;; acquire/release. + (setf (waitqueue-data queue) me) + (release-mutex mutex) + ;; Now we go to sleep using futex-wait. If anyone else + ;; manages to grab MUTEX and call CONDITION-NOTIFY during + ;; this comment, it will change queue->data, and so + ;; futex-wait returns immediately instead of sleeping. + ;; Ergo, no lost wakeup. We may get spurious wakeups, but + ;; that's ok. + (multiple-value-bind (to-sec to-usec) (decode-timeout nil) + (when (= 1 (with-pinned-objects (queue me) + (allow-with-interrupts + (futex-wait (waitqueue-data-address queue) + (get-lisp-obj-address me) + ;; our way if saying "no + ;; timeout": + (or to-sec -1) + (or to-usec 0))))) + (signal-deadline)))) + ;; If we are interrupted while waiting, we should do these + ;; things 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))))) -(defun condition-notify (queue) - "Notify one of the processes waiting on QUEUE" - (signal-queue-head queue)) +(defun condition-notify (queue &optional (n 1)) + #!+sb-doc + "Notify N threads waiting on QUEUE. The same mutex that is used in +the correspoinding condition-wait must be held by this thread during +this call." + #!-sb-thread (declare (ignore queue n)) + #!-sb-thread (error "Not supported in unithread builds.") + #!+sb-thread + (declare (type (and fixnum (integer 1)) n)) + (/show0 "Entering CONDITION-NOTIFY") + #!+sb-thread + (progn + #!+sb-lutex + (with-lutex-address (lutex (waitqueue-lutex queue)) + (%lutex-wake lutex n)) + ;; no problem if >1 thread notifies during the comment in + ;; condition-wait: as long as the value in queue-data isn't the + ;; waiting thread's id, it matters not what it is + ;; XXX we should do something to ensure that the result of this setf + ;; is visible to all CPUs + #!-sb-lutex + (let ((me *current-thread*)) + (progn + (setf (waitqueue-data queue) me) + (with-pinned-objects (queue) + (futex-wake (waitqueue-data-address queue) n)))))) +(defun condition-broadcast (queue) + #!+sb-doc + "Notify all threads waiting on QUEUE." + (condition-notify queue + ;; On a 64-bit platform truncating M-P-F to an int + ;; results in -1, which wakes up only one thread. + (ldb (byte 29 0) + most-positive-fixnum))) + -;;;; multiple independent listeners +;;;; Semaphores -(defvar *session-lock* nil) +(defstruct (semaphore (:constructor %make-semaphore (name %count))) + #!+sb-doc + "Semaphore type. The fact that a SEMAPHORE is a STRUCTURE-OBJECT +should be considered an implementation detail, and may change in the +future." + (name nil :type (or null simple-string)) + (%count 0 :type (integer 0)) + (waitcount 0 :type (integer 0)) + (mutex (make-mutex)) + (queue (make-waitqueue))) -(defun make-listener-thread (tty-name) - (assert (probe-file tty-name)) - ;; FIXME probably still need to do some tty stuff to get signals - ;; delivered correctly. - ;; FIXME - (let* ((in (sb!unix:unix-open (namestring tty-name) sb!unix:o_rdwr #o666)) - (out (sb!unix:unix-dup in)) - (err (sb!unix:unix-dup in))) - (labels ((thread-repl () - (sb!unix::unix-setsid) - (let* ((*session-lock* - (make-mutex :name (format nil "lock for ~A" tty-name))) - (sb!impl::*stdin* - (sb!sys:make-fd-stream in :input t :buffering :line)) - (sb!impl::*stdout* - (sb!sys:make-fd-stream out :output t :buffering :line)) - (sb!impl::*stderr* - (sb!sys:make-fd-stream err :output t :buffering :line)) - (sb!impl::*tty* - (sb!sys:make-fd-stream err :input t :output t :buffering :line)) - (sb!impl::*descriptor-handlers* nil)) - (get-mutex *session-lock*) - (sb!sys:enable-interrupt :sigint #'sb!unix::sigint-handler) - (unwind-protect - (sb!impl::toplevel-repl nil) - (sb!int:flush-standard-output-streams))))) - (make-thread #'thread-repl)))) - -;;;; job control +(setf (fdocumentation 'semaphore-name 'function) + "The name of the semaphore INSTANCE. Setfable.") + +(declaim (inline semaphore-count)) +(defun semaphore-count (instance) + "Returns the current count of the semaphore INSTANCE." + (semaphore-%count instance)) + +(defun make-semaphore (&key name (count 0)) + #!+sb-doc + "Create a semaphore with the supplied COUNT and NAME." + (%make-semaphore name count)) + +(defun wait-on-semaphore (semaphore) + #!+sb-doc + "Decrement the count of SEMAPHORE if the count would not be +negative. Else blocks until the semaphore can be decremented." + ;; A more direct implementation based directly on futexes should be + ;; possible. + ;; + ;; We need to disable interrupts so that we don't forget to + ;; decrement the waitcount (which would happen if an asynch + ;; interrupt should catch us on our way out from the loop.) + (with-system-mutex ((semaphore-mutex semaphore) :allow-with-interrupts t) + ;; Quick check: is it positive? If not, enter the wait loop. + (let ((count (semaphore-%count semaphore))) + (if (plusp count) + (setf (semaphore-%count semaphore) (1- count)) + (unwind-protect + (progn + (incf (semaphore-waitcount semaphore)) + (loop until (plusp (setf count (semaphore-%count semaphore))) + do (condition-wait (semaphore-queue semaphore) + (semaphore-mutex semaphore))) + (setf (semaphore-%count semaphore) (1- count))) + (decf (semaphore-waitcount semaphore))))))) + +(defun signal-semaphore (semaphore &optional (n 1)) + #!+sb-doc + "Increment the count of SEMAPHORE by N. If there are threads waiting +on this semaphore, then N of them is woken up." + (declare (type (integer 1) n)) + ;; Need to disable interrupts so that we don't lose a wakeup after + ;; we have incremented the count. + (with-system-mutex ((semaphore-mutex semaphore)) + (let ((waitcount (semaphore-waitcount semaphore)) + (count (incf (semaphore-%count semaphore) n))) + (when (plusp waitcount) + (condition-notify (semaphore-queue semaphore) (min waitcount count)))))) + + +;;;; Job control, independent listeners + +(defstruct session + (lock (make-mutex :name "session lock")) + (threads nil) + (interactive-threads nil) + (interactive-threads-queue (make-waitqueue))) -(defvar *background-threads-wait-for-debugger* t) -;;; may be T, NIL, or a function called with a stream and thread id -;;; as its two arguments, returning NIl or T +(defvar *session* nil) + +;;; The debugger itself tries to acquire the session lock, don't let +;;; funny situations (like getting a sigint while holding the session +;;; 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) + `(with-system-mutex ((session-lock ,session) :allow-with-interrupts t) + ,@body)) + +(defun new-session () + (make-session :threads (list *current-thread*) + :interactive-threads (list *current-thread*))) + +(defun init-job-control () + (/show0 "Entering INIT-JOB-CONTROL") + (setf *session* (new-session)) + (/show0 "Exiting INIT-JOB-CONTROL")) + +(defun %delete-thread-from-session (thread session) + (with-session-lock (session) + (setf (session-threads session) + (delete thread (session-threads session)) + (session-interactive-threads session) + (delete thread (session-interactive-threads session))))) + +(defun call-with-new-session (fn) + (%delete-thread-from-session *current-thread* *session*) + (let ((*session* (new-session))) + (funcall fn))) + +(defmacro with-new-session (args &body forms) + (declare (ignore args)) ;for extensibility + (sb!int:with-unique-names (fb-name) + `(labels ((,fb-name () ,@forms)) + (call-with-new-session (function ,fb-name))))) + +;;; Remove thread from its session, if it has one. +#!+sb-thread +(defun handle-thread-exit (thread) + (/show0 "HANDLING THREAD EXIT") + ;; Lisp-side cleanup + (with-all-threads-lock + (setf (thread-%alive-p thread) nil) + (setf (thread-os-thread thread) nil) + (setq *all-threads* (delete thread *all-threads*)) + (when *session* + (%delete-thread-from-session thread *session*))) + #!+sb-lutex + (without-gcing + (/show0 "FREEING MUTEX LUTEX") + (with-lutex-address (lutex (mutex-lutex (thread-interruptions-lock thread))) + (%lutex-destroy lutex)))) + +(defun terminate-session () + #!+sb-doc + "Kill all threads in session except for this one. Does nothing if current +thread is not the foreground thread." + ;; FIXME: threads created in other threads may escape termination + (let ((to-kill + (with-session-lock (*session*) + (and (eq *current-thread* + (car (session-interactive-threads *session*))) + (session-threads *session*))))) + ;; do the kill after dropping the mutex; unwind forms in dying + ;; threads may want to do session things + (dolist (thread to-kill) + (unless (eq thread *current-thread*) + ;; terminate the thread but don't be surprised if it has + ;; exited in the meantime + (handler-case (terminate-thread thread) + (interrupt-thread-error ())))))) ;;; called from top of invoke-debugger (defun debugger-wait-until-foreground-thread (stream) "Returns T if thread had been running in background, NIL if it was -already the foreground thread, or transfers control to the first applicable -restart if *BACKGROUND-THREADS-WAIT-FOR-DEBUGGER* says to do that instead" - (let* ((wait-p *background-threads-wait-for-debugger*) - (*background-threads-wait-for-debugger* nil) - (lock *session-lock*)) - (when (not (eql (mutex-value lock) (CURRENT-THREAD-ID))) - (when (functionp wait-p) - (setf wait-p - (funcall wait-p stream (CURRENT-THREAD-ID)))) - (cond (wait-p (get-foreground)) - (t (invoke-restart (car (compute-restarts)))))))) - -;;; install this with (setf SB!INT:*REPL-PROMPT-FUN* #'thread-prompt-fun) -;;; One day it will be default -(defun thread-repl-prompt-fun (out-stream) - (let ((lock *session-lock*)) - (get-foreground) - (let ((stopped-threads (waitqueue-data lock))) - (when stopped-threads - (format out-stream "~{~&Thread ~A suspended~}~%" stopped-threads)) - (sb!impl::repl-prompt-fun out-stream)))) - -(defun resume-stopped-thread (id) - (let ((pid (current-thread-id)) - (lock *session-lock*)) - (with-spinlock (lock) - (setf (waitqueue-data lock) - (cons id (delete id (waitqueue-data lock))))) - (release-foreground))) - -(defstruct rwlock - (name nil :type (or null simple-base-string)) - (value 0 :type fixnum) - (max-readers nil :type (or fixnum null)) - (max-writers 1 :type fixnum)) -#+nil -(macrolet - ((make-rwlocking-function (lock-fn unlock-fn increment limit test) - (let ((do-update '(when (eql old-value - (sb!vm::%instance-set-conditional - lock 2 old-value new-value)) - (return (values t old-value)))) - (vars `((timeout (and timeout (+ (get-internal-real-time) timeout))) - old-value - new-value - (limit ,limit)))) - (labels ((do-setfs (v) `(setf old-value (rwlock-value lock) - new-value (,v old-value ,increment)))) - `(progn - (defun ,lock-fn (lock timeout) - (declare (type rwlock lock)) - (let ,vars - (loop - ,(do-setfs '+) - (when ,test - ,do-update) - (when (sleep-a-bit timeout) (return nil)) ;expired - ))) - ;; unlock doesn't need timeout or test-in-range - (defun ,unlock-fn (lock) - (declare (type rwlock lock)) - (declare (ignorable limit)) - (let ,(cdr vars) - (loop - ,(do-setfs '-) - ,do-update)))))))) - - (make-rwlocking-function %lock-for-reading %unlock-for-reading 1 - (rwlock-max-readers lock) - (and (>= old-value 0) - (or (null limit) (<= new-value limit)))) - (make-rwlocking-function %lock-for-writing %unlock-for-writing -1 - (- (rwlock-max-writers lock)) - (and (<= old-value 0) - (>= new-value limit)))) -#+nil -(defun get-rwlock (lock direction &optional timeout) - (ecase direction - (:read (%lock-for-reading lock timeout)) - (:write (%lock-for-writing lock timeout)))) -#+nil -(defun free-rwlock (lock direction) - (ecase direction - (:read (%unlock-for-reading lock)) - (:write (%unlock-for-writing lock)))) - -;;;; beyond this point all is commented. - -;;; Lock-Wait-With-Timeout -- Internal -;;; -;;; Wait with a timeout for the lock to be free and acquire it for the -;;; *current-process*. -;;; -#+nil -(defun lock-wait-with-timeout (lock whostate timeout) - (declare (type lock lock)) - (process-wait-with-timeout - whostate timeout - #'(lambda () - (declare (optimize (speed 3))) - #-i486 - (unless (lock-process lock) - (setf (lock-process lock) *current-process*)) - #+i486 - (null (kernel:%instance-set-conditional - lock 2 nil *current-process*))))) - -;;; With-Lock-Held -- Public -;;; -#+nil -(defmacro with-lock-held ((lock &optional (whostate "Lock Wait") - &key (wait t) timeout) - &body body) - "Execute the body with the lock held. If the lock is held by another - process then the current process waits until the lock is released or - an optional timeout is reached. The optional wait timeout is a time in - seconds acceptable to process-wait-with-timeout. The results of the - body are return upon success and NIL is return if the timeout is - reached. When the wait key is NIL and the lock is held by another - process then NIL is return immediately without processing the body." - (let ((have-lock (gensym))) - `(let ((,have-lock (eq (lock-process ,lock) *current-process*))) - (unwind-protect - ,(cond ((and timeout wait) - `(progn - (when (and (error-check-lock-p ,lock) ,have-lock) - (error "Dead lock")) - (when (or ,have-lock - #+i486 (null (kernel:%instance-set-conditional - ,lock 2 nil *current-process*)) - #-i486 (seize-lock ,lock) - (if ,timeout - (lock-wait-with-timeout - ,lock ,whostate ,timeout) - (lock-wait ,lock ,whostate))) - ,@body))) - (wait - `(progn - (when (and (error-check-lock-p ,lock) ,have-lock) - (error "Dead lock")) - (unless (or ,have-lock - #+i486 (null (kernel:%instance-set-conditional - ,lock 2 nil *current-process*)) - #-i486 (seize-lock ,lock)) - (lock-wait ,lock ,whostate)) - ,@body)) - (t - `(when (or (and (recursive-lock-p ,lock) ,have-lock) - #+i486 (null (kernel:%instance-set-conditional - ,lock 2 nil *current-process*)) - #-i486 (seize-lock ,lock)) - ,@body))) - (unless ,have-lock - #+i486 (kernel:%instance-set-conditional - ,lock 2 *current-process* nil) - #-i486 (when (eq (lock-process ,lock) *current-process*) - (setf (lock-process ,lock) nil))))))) +interactive." + (declare (ignore stream)) + #!-sb-thread nil + #!+sb-thread + (prog1 + (with-session-lock (*session*) + (not (member *current-thread* + (session-interactive-threads *session*)))) + (get-foreground))) + +(defun get-foreground () + #!-sb-thread t + #!+sb-thread + (let ((was-foreground t)) + (loop + (/show0 "Looping in GET-FOREGROUND") + (with-session-lock (*session*) + (let ((int-t (session-interactive-threads *session*))) + (when (eq (car int-t) *current-thread*) + (unless was-foreground + (format *query-io* "Resuming thread ~A~%" *current-thread*)) + (return-from get-foreground t)) + (setf was-foreground nil) + (unless (member *current-thread* int-t) + (setf (cdr (last int-t)) + (list *current-thread*))) + (condition-wait + (session-interactive-threads-queue *session*) + (session-lock *session*))))))) + +(defun release-foreground (&optional next) + #!+sb-doc + "Background this thread. If NEXT is supplied, arrange for it to +have the foreground next." + #!-sb-thread (declare (ignore next)) + #!-sb-thread nil + #!+sb-thread + (with-session-lock (*session*) + (when (rest (session-interactive-threads *session*)) + (setf (session-interactive-threads *session*) + (delete *current-thread* (session-interactive-threads *session*)))) + (when next + (setf (session-interactive-threads *session*) + (list* next + (delete next (session-interactive-threads *session*))))) + (condition-broadcast (session-interactive-threads-queue *session*)))) + +(defun foreground-thread () + (car (session-interactive-threads *session*))) + +(defun make-listener-thread (tty-name) + (assert (probe-file tty-name)) + (let* ((in (sb!unix:unix-open (namestring tty-name) sb!unix:o_rdwr #o666)) + (out (sb!unix:unix-dup in)) + (err (sb!unix:unix-dup in))) + (labels ((thread-repl () + (sb!unix::unix-setsid) + (let* ((sb!impl::*stdin* + (make-fd-stream in :input t :buffering :line + :dual-channel-p t)) + (sb!impl::*stdout* + (make-fd-stream out :output t :buffering :line + :dual-channel-p t)) + (sb!impl::*stderr* + (make-fd-stream err :output t :buffering :line + :dual-channel-p t)) + (sb!impl::*tty* + (make-fd-stream err :input t :output t + :buffering :line + :dual-channel-p t)) + (sb!impl::*descriptor-handlers* nil)) + (with-new-session () + (unwind-protect + (sb!impl::toplevel-repl nil) + (sb!int:flush-standard-output-streams)))))) + (make-thread #'thread-repl)))) + + +;;;; The beef + +(defun make-thread (function &key name) + #!+sb-doc + "Create a new thread of NAME that runs FUNCTION. When the function +returns the thread exits. The return values of FUNCTION are kept +around and can be retrieved by JOIN-THREAD." + #!-sb-thread (declare (ignore function name)) + #!-sb-thread (error "Not supported in unithread builds.") + #!+sb-thread + (let* ((thread (%make-thread :name name)) + (setup-sem (make-semaphore :name "Thread setup semaphore")) + (real-function (coerce function 'function)) + (initial-function + (lambda () + ;; In time we'll move some of the binding presently done in C + ;; here too. + ;; + ;; KLUDGE: Here we have a magic list of variables that are + ;; not thread-safe for one reason or another. As people + ;; report problems with the thread safety of certain + ;; variables, (e.g. "*print-case* in multiple threads + ;; broken", sbcl-devel 2006-07-14), we add a few more + ;; bindings here. The Right Thing is probably some variant + ;; of Allegro's *cl-default-special-bindings*, as that is at + ;; least accessible to users to secure their own libraries. + ;; --njf, 2006-07-15 + ;; + ;; As it is, this lambda must not cons until we are ready + ;; to run GC. Be very careful. + (let* ((*current-thread* thread) + (*restart-clusters* nil) + (*handler-clusters* (sb!kernel::initial-handler-clusters)) + (*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*)) + (with-session-lock (*session*) + (push thread (session-threads *session*))) + (setf (thread-%alive-p thread) t) + (signal-semaphore setup-sem) + ;; can't use handling-end-of-the-world, because that flushes + ;; output streams, and we don't necessarily have any (or we + ;; could be sharing them) + (catch 'sb!impl::toplevel-catcher + (catch 'sb!impl::%end-of-the-world + (with-simple-restart + (terminate-thread + (format nil + "~~@" + *current-thread*)) + (without-interrupts + (unwind-protect + (with-local-interrupts + ;; Now that most things have a chance + ;; to work properly without messing up + ;; other threads, it's time to enable + ;; signals. + (sb!unix::unblock-deferrable-signals) + (setf (thread-result thread) + (cons t + (multiple-value-list + (funcall real-function)))) + ;; Try to block deferrables. An + ;; interrupt may unwind it, but for a + ;; normal exit it prevents interrupt + ;; loss. + (block-deferrable-signals)) + ;; We're going down, can't handle interrupts + ;; sanely anymore. GC remains enabled. + (block-deferrable-signals) + ;; We don't want to run interrupts in a dead + ;; thread when we leave WITHOUT-INTERRUPTS. + ;; This potentially causes important + ;; interupts to be lost: SIGINT comes to + ;; mind. + (setq *interrupt-pending* nil) + (handle-thread-exit thread)))))))) + (values)))) + ;; If the starting thread is stopped for gc before it signals the + ;; semaphore then we'd be stuck. + (assert (not *gc-inhibit*)) + ;; Keep INITIAL-FUNCTION pinned until the child thread is + ;; initialized properly. Wrap the whole thing in + ;; WITHOUT-INTERRUPTS because we pass INITIAL-FUNCTION to another + ;; thread. + (without-interrupts + (with-pinned-objects (initial-function) + (let ((os-thread + (%create-thread + (get-lisp-obj-address initial-function)))) + (when (zerop os-thread) + (error "Can't create a new thread")) + (wait-on-semaphore setup-sem) + thread))))) + +(define-condition join-thread-error (error) + ((thread :reader join-thread-error-thread :initarg :thread)) + #!+sb-doc + (:documentation "Joining thread failed.") + (:report (lambda (c s) + (format s "Joining thread failed: thread ~A ~ + has not returned normally." + (join-thread-error-thread c))))) + +#!+sb-doc +(setf (fdocumentation 'join-thread-error-thread 'function) + "The thread that we failed to join.") + +(defun join-thread (thread &key (default nil defaultp)) + #!+sb-doc + "Suspend current thread until THREAD exits. Returns the result +values of the thread function. If the thread does not exit normally, +return DEFAULT if given or else signal JOIN-THREAD-ERROR." + (with-system-mutex ((thread-result-lock thread) :allow-with-interrupts t) + (cond ((car (thread-result thread)) + (return-from join-thread + (values-list (cdr (thread-result thread))))) + (defaultp + (return-from join-thread default)))) + (error 'join-thread-error :thread thread)) + +(defun destroy-thread (thread) + #!+sb-doc + "Deprecated. Same as TERMINATE-THREAD." + (terminate-thread thread)) + +(define-condition interrupt-thread-error (error) + ((thread :reader interrupt-thread-error-thread :initarg :thread)) + #!+sb-doc + (:documentation "Interrupting thread failed.") + (:report (lambda (c s) + (format s "Interrupt thread failed: thread ~A has exited." + (interrupt-thread-error-thread c))))) + +#!+sb-doc +(setf (fdocumentation 'interrupt-thread-error-thread 'function) + "The thread that was not interrupted.") + +(defmacro with-interruptions-lock ((thread) &body body) + `(with-system-mutex ((thread-interruptions-lock ,thread)) + ,@body)) + +;;; Called from the signal handler in C. +(defun run-interruption () + (in-interruption () + (loop + (let ((interruption (with-interruptions-lock (*current-thread*) + (pop (thread-interruptions *current-thread*))))) + ;; Resignalling after popping one works fine, because from the + ;; OS's point of view we have returned from the signal handler + ;; (thanks to arrange_return_to_lisp_function) so at least one + ;; more signal will be delivered. + (when (thread-interruptions *current-thread*) + (signal-interrupt-thread (thread-os-thread *current-thread*))) + (if interruption + (with-interrupts + (funcall interruption)) + (return)))))) + +;;; The order of interrupt execution is peculiar. If thread A +;;; interrupts thread B with I1, I2 and B for some reason receives I1 +;;; when FUN2 is already on the list, then it is FUN2 that gets to run +;;; first. But when FUN2 is run SIG_INTERRUPT_THREAD is enabled again +;;; and I2 hits pretty soon in FUN2 and run FUN1. This is of course +;;; just one scenario, and the order of thread interrupt execution is +;;; undefined. +(defun interrupt-thread (thread function) + #!+sb-doc + "Interrupt the live THREAD and make it run FUNCTION. A moderate +degree of care is expected for use of INTERRUPT-THREAD, due to its +nature: if you interrupt a thread that was holding important locks +then do something that turns out to need those locks, you probably +won't like the effect." + #!-sb-thread (declare (ignore thread)) + #!-sb-thread + (with-interrupt-bindings + (with-interrupts (funcall function))) + #!+sb-thread + (if (eq thread *current-thread*) + (with-interrupt-bindings + (with-interrupts (funcall function))) + (let ((os-thread (thread-os-thread thread))) + (cond ((not os-thread) + (error 'interrupt-thread-error :thread thread)) + (t + (with-interruptions-lock (thread) + (push function (thread-interruptions thread))) + (when (minusp (signal-interrupt-thread os-thread)) + (error 'interrupt-thread-error :thread thread))))))) + +(defun terminate-thread (thread) + #!+sb-doc + "Terminate the thread identified by THREAD, by causing it to run +SB-EXT:QUIT - the usual cleanup forms will be evaluated" + (interrupt-thread thread 'sb!ext:quit)) + +(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 +(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)) + +;;;; Stepping +(defun thread-stepping () + (make-lisp-obj + (sap-ref-word (current-thread-sap) + (* sb!vm::thread-stepping-slot sb!vm:n-word-bytes)))) +(defun (setf thread-stepping) (value) + (setf (sap-ref-word (current-thread-sap) + (* sb!vm::thread-stepping-slot sb!vm:n-word-bytes)) + (get-lisp-obj-address value)))