(def %compare-and-swap-symbol-value (symbol) symbol-value)
(def %compare-and-swap-svref (vector index) svref))
+(defun expand-atomic-frob (name place diff)
+ (flet ((invalid-place ()
+ (error "Invalid first argument to ~S: ~S" name place)))
+ (unless (consp place)
+ (invalid-place))
+ (destructuring-bind (op &rest args) place
+ (case op
+ (aref
+ (when (cddr args)
+ (invalid-place))
+ #!+(or x86 x86-64 ppc)
+ (with-unique-names (array)
+ `(let ((,array (the (simple-array sb!ext:word (*)) ,(car args))))
+ (%array-atomic-incf/word
+ ,array
+ (%check-bound ,array (array-dimension ,array 0) ,(cadr args))
+ (logand #.(1- (ash 1 sb!vm:n-word-bits))
+ ,(ecase name
+ (atomic-incf
+ `(the sb!vm:signed-word ,diff))
+ (atomic-decf
+ `(- (the sb!vm:signed-word ,diff))))))))
+ #!-(or x86 x86-64 ppc)
+ (with-unique-names (array index old-value)
+ (let ((incremented-value
+ (ecase name
+ (atomic-incf
+ `(+ ,old-value (the sb!vm:signed-word ,diff)))
+ (atomic-decf
+ `(- ,old-value (the sb!vm:signed-word ,diff))))))
+ `(sb!sys:without-interrupts
+ (let* ((,array ,(car args))
+ (,index ,(cadr args))
+ (,old-value (aref ,array ,index)))
+ (setf (aref ,array ,index)
+ (logand #.(1- (ash 1 sb!vm:n-word-bits))
+ ,incremented-value))
+ ,old-value)))))
+ (t
+ (when (cdr args)
+ (invalid-place))
+ (let ((dd (info :function :structure-accessor op)))
+ (if dd
+ (let* ((structure (dd-name dd))
+ (slotd (find op (dd-slots dd) :key #'dsd-accessor-name))
+ (index (dsd-index slotd))
+ (type (dsd-type slotd)))
+ (declare (ignorable structure index))
+ (unless (and (eq 'sb!vm:word (dsd-raw-type slotd))
+ (type= (specifier-type type) (specifier-type 'sb!vm:word)))
+ (error "~S requires a slot of type (UNSIGNED-BYTE ~S), not ~S: ~S"
+ name sb!vm:n-word-bits type place))
+ (when (dsd-read-only slotd)
+ (error "Cannot use ~S with structure accessor for a read-only slot: ~S"
+ name place))
+ #!+(or x86 x86-64 ppc)
+ `(truly-the sb!vm:word
+ (%raw-instance-atomic-incf/word
+ (the ,structure ,@args) ,index
+ (logand #.(1- (ash 1 sb!vm:n-word-bits))
+ ,(ecase name
+ (atomic-incf
+ `(the sb!vm:signed-word ,diff))
+ (atomic-decf
+ `(- (the sb!vm:signed-word ,diff)))))))
+ ;; No threads outside x86 and x86-64 for now, so this is easy...
+ #!-(or x86 x86-64 ppc)
+ (with-unique-names (structure old)
+ `(sb!sys:without-interrupts
+ (let* ((,structure ,@args)
+ (,old (,op ,structure)))
+ (setf (,op ,structure)
+ (logand #.(1- (ash 1 sb!vm:n-word-bits))
+ ,(ecase name
+ (atomic-incf
+ `(+ ,old (the sb!vm:signed-word ,diff)))
+ (atomic-decf
+ `(- ,old (the sb!vm:signed-word ,diff))))))
+ ,old))))
+ (invalid-place))))))))
+
(defmacro atomic-incf (place &optional (diff 1))
#!+sb-doc
"Atomically increments PLACE by DIFF, and returns the value of PLACE before
PLACE must be an accessor form whose CAR is the name of a DEFSTRUCT accessor
whose declared type is (UNSIGNED-BYTE 32) on 32 bit platforms,
-and (UNSIGNED-BYTE 64) on 64 bit platforms.
+and (UNSIGNED-BYTE 64) on 64 bit platforms or an AREF of a (SIMPLE-ARRAY
+SB-EXT:WORD (*) -- the type SB-EXT:WORD can be used for this purpose.
DIFF defaults to 1, and must be a (SIGNED-BYTE 32) on 32 bit platforms,
and (SIGNED-BYTE 64) on 64 bit platforms.
EXPERIMENTAL: Interface subject to change."
- (flet ((invalid-place ()
- (error "Invalid first argument to ATOMIC-INCF: ~S" place)))
- (unless (consp place)
- (invalid-place))
- (destructuring-bind (op &rest args) place
- (when (cdr args)
- (invalid-place))
- (let ((dd (info :function :structure-accessor op)))
- (if dd
- (let* ((structure (dd-name dd))
- (slotd (find op (dd-slots dd) :key #'dsd-accessor-name))
- (index (dsd-index slotd))
- (type (dsd-type slotd)))
- (declare (ignorable structure index))
- (unless (and (eq 'sb!vm:word (dsd-raw-type slotd))
- (type= (specifier-type type) (specifier-type 'sb!vm:word)))
- (error "ATOMIC-INCF requires a slot of type (UNSIGNED-BYTE ~S), not ~S: ~S"
- sb!vm:n-word-bits type place))
- (when (dsd-read-only slotd)
- (error "Cannot use ATOMIC-INCF with structure accessor for a read-only slot: ~S"
- place))
- #!+(or x86 x86-64)
- `(truly-the sb!vm:word
- (%raw-instance-atomic-incf/word (the ,structure ,@args)
- ,index
- (the sb!vm:signed-word ,diff)))
- ;; No threads outside x86 and x86-64 for now, so this is easy...
- #!-(or x86 x86-64)
- (with-unique-names (structure old)
- `(sb!sys:without-interrupts
- (let* ((,structure ,@args)
- (,old (,op ,structure)))
- (setf (,op ,structure) (logand #.(1- (ash 1 sb!vm:n-word-bits))
- (+ ,old (the sb!vm:signed-word ,diff))))
- ,old))))
- (invalid-place))))))
+ (expand-atomic-frob 'atomic-incf place diff))
+
+(defmacro atomic-decf (place &optional (diff 1))
+ #!+sb-doc
+ "Atomically decrements PLACE by DIFF, and returns the value of PLACE before
+the increment.
+
+The decrementation is done using word-size modular arithmetic: on 32 bit
+platforms ATOMIC-DECF of #x0 by one results in #xFFFFFFFF being stored in
+PLACE.
+
+PLACE must be an accessor form whose CAR is the name of a DEFSTRUCT accessor
+whose declared type is (UNSIGNED-BYTE 32) on 32 bit platforms,
+and (UNSIGNED-BYTE 64) on 64 bit platforms or an AREF of a (SIMPLE-ARRAY
+SB-EXT:WORD (*) -- the type SB-EXT:WORD can be used for this purpose.
+
+DIFF defaults to 1, and must be a (SIGNED-BYTE 32) on 32 bit platforms,
+and (SIGNED-BYTE 64) on 64 bit platforms.
+
+EXPERIMENTAL: Interface subject to change."
+ (expand-atomic-frob 'atomic-decf place diff))
+
+;; Interpreter stubs for ATOMIC-INCF.
+#!+(or x86 x86-64 ppc)
+(defun %array-atomic-incf/word (array index diff)
+ (declare (type (simple-array word (*)) array)
+ (fixnum index)
+ (type sb!vm:signed-word diff))
+ (%array-atomic-incf/word array index diff))
+
+(defun spin-loop-hint ()
+ #!+sb-doc
+ "Hints the processor that the current thread is spin-looping."
+ (spin-loop-hint))
(defun call-hooks (kind hooks &key (on-error :error))
(dolist (hook hooks)
(sb!c:with-source-location (source-location)
(setf (info :source-location :variable name) source-location))
name)
+
+;;;; WAIT-FOR -- waiting on arbitrary conditions
+
+(defun %%wait-for (test stop-sec stop-usec)
+ (declare (function test))
+ (labels ((try ()
+ (declare (optimize (safety 0)))
+ (awhen (funcall test)
+ (return-from %%wait-for it)))
+ (tick (sec usec)
+ (declare (fixnum sec usec))
+ ;; TICK is microseconds
+ (+ usec (* 1000000 sec)))
+ (get-tick ()
+ (multiple-value-call #'tick
+ (decode-internal-time (get-internal-real-time)))))
+ (let* ((timeout-tick (when stop-sec (tick stop-sec stop-usec)))
+ (start (get-tick))
+ ;; Rough estimate of how long a single attempt takes.
+ (try-ticks (progn
+ (try) (try) (try)
+ (max 1 (truncate (- (get-tick) start) 3)))))
+ ;; Scale sleeping between attempts:
+ ;;
+ ;; Start by sleeping for as many ticks as an average attempt
+ ;; takes, then doubling for each attempt.
+ ;;
+ ;; Max out at 0.1 seconds, or the 2 x time of a single try,
+ ;; whichever is longer -- with a hard cap of 10 seconds.
+ ;;
+ ;; FIXME: Maybe the API should have a :MAX-SLEEP argument?
+ (loop with max-ticks = (max 100000 (min (* 2 try-ticks)
+ (expt 10 7)))
+ for scale of-type fixnum = 1
+ then (let ((x (logand most-positive-fixnum (* 2 scale))))
+ (if (> scale x)
+ most-positive-fixnum
+ x))
+ do (try)
+ (let* ((now (get-tick))
+ (sleep-ticks (min (* try-ticks scale) max-ticks))
+ (sleep
+ (if timeout-tick
+ ;; If sleep would take us past the
+ ;; timeout, shorten it so it's just
+ ;; right.
+ (if (>= (+ now sleep-ticks) timeout-tick)
+ (- timeout-tick now)
+ sleep-ticks)
+ sleep-ticks)))
+ (declare (fixnum sleep))
+ (cond ((plusp sleep)
+ ;; microseconds to seconds and nanoseconds
+ (multiple-value-bind (sec nsec)
+ (truncate (* 1000 sleep) (expt 10 9))
+ (with-interrupts
+ (sb!unix:nanosleep sec nsec))))
+ (t
+ (return-from %%wait-for nil))))))))
+
+(defun %wait-for (test timeout)
+ (declare (function test))
+ (tagbody
+ :restart
+ (multiple-value-bind (to-sec to-usec stop-sec stop-usec deadlinep)
+ (decode-timeout timeout)
+ (declare (ignore to-sec to-usec))
+ (return-from %wait-for
+ (or (%%wait-for test stop-sec stop-usec)
+ (when deadlinep
+ (signal-deadline)
+ (go :restart)))))))
+
+(defmacro wait-for (test-form &key timeout)
+ "Wait until TEST-FORM evaluates to true, then return its primary value.
+If TIMEOUT is provided, waits at most approximately TIMEOUT seconds before
+returning NIL.
+
+If WITH-DEADLINE has been used to provide a global deadline, signals a
+DEADLINE-TIMEOUT if TEST-FORM doesn't evaluate to true before the
+deadline.
+
+Experimental: subject to change without prior notice."
+ `(dx-flet ((wait-for-test () (progn ,test-form)))
+ (%wait-for #'wait-for-test ,timeout)))
projects / sbcl.git / blobdiff