X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=tests%2Fthreads.pure.lisp;h=3d6d119b4e8e9f0533c93de0f6c34887b513e732;hb=40bea2551744d3cdc05a79a923fbff79a5755845;hp=9b6e91e224b1d55c56219eac2c174f476f9bff87;hpb=94b4d570ffa374e2adf2e27340472c13a487d1f5;p=sbcl.git diff --git a/tests/threads.pure.lisp b/tests/threads.pure.lisp index 9b6e91e..3d6d119 100644 --- a/tests/threads.pure.lisp +++ b/tests/threads.pure.lisp @@ -29,15 +29,6 @@ (release-mutex mutex)) (assert (not (mutex-value mutex))))) -(with-test (:name spinlock-owner) - ;; Make sure basics are sane on unithreaded ports as well - (let ((spinlock (sb-thread::make-spinlock))) - (sb-thread::get-spinlock spinlock) - (assert (eq *current-thread* (sb-thread::spinlock-value spinlock))) - (handler-bind ((warning #'error)) - (sb-thread::release-spinlock spinlock)) - (assert (not (sb-thread::spinlock-value spinlock))))) - ;;; Terminating a thread that's waiting for the terminal. #+sb-thread @@ -51,9 +42,8 @@ ;;; Condition-wait should not be interruptible under WITHOUT-INTERRUPTS -#+sb-thread (with-test (:name without-interrupts+condition-wait - :fails-on :sb-lutex) + :skipped-on '(not :sb-thread)) (let* ((lock (make-mutex)) (queue (make-waitqueue)) (thread (make-thread (lambda () @@ -71,8 +61,7 @@ ;;; GET-MUTEX should not be interruptible under WITHOUT-INTERRUPTS -#+sb-thread -(with-test (:name without-interrupts+get-mutex) +(with-test (:name without-interrupts+get-mutex :skipped-on '(not :sb-thread)) (let* ((lock (make-mutex)) (bar (progn (get-mutex lock) nil)) (thread (make-thread (lambda () @@ -90,8 +79,7 @@ (assert (eq :aborted (join-thread thread :default :aborted))) (assert bar))) -#+sb-thread -(with-test (:name parallel-find-class) +(with-test (:name parallel-find-class :skipped-on '(not :sb-thread)) (let* ((oops nil) (threads (loop repeat 10 collect (make-thread (lambda () @@ -103,8 +91,7 @@ (mapcar #'sb-thread:join-thread threads) (assert (not oops)))) -#+sb-thread -(with-test (:name :semaphore-multiple-waiters) +(with-test (:name :semaphore-multiple-waiters :skipped-on '(not :sb-thread)) (let ((semaphore (make-semaphore :name "test sem"))) (labels ((make-readers (n i) (values @@ -159,8 +146,7 @@ ;;;; Printing waitqueues -#+sb-thread -(with-test (:name :waitqueue-circle-print) +(with-test (:name :waitqueue-circle-print :skipped-on '(not :sb-thread)) (let* ((*print-circle* nil) (lock (sb-thread:make-mutex)) (wq (sb-thread:make-waitqueue))) @@ -178,8 +164,7 @@ (assert (= 123 (symbol-value-in-thread '* *current-thread*))) (assert (= 123 *)))) -#+sb-thread -(with-test (:name symbol-value-in-thread.2) +(with-test (:name symbol-value-in-thread.2 :skipped-on '(not :sb-thread)) (let* ((parent *current-thread*) (semaphore (make-semaphore)) (child (make-thread (lambda () @@ -196,8 +181,9 @@ ;;; wich _appear_ to be caused by malloc() and free() not being thread safe: an ;;; interrupted malloc in one thread can apparently block a free in another. There ;;; are also some indications that pthread_mutex_lock is not re-entrant. -#+(and sb-thread (not darwin)) -(with-test (:name symbol-value-in-thread.3) +(with-test (:name symbol-value-in-thread.3 + :skipped-on '(not :sb-thread) + :broken-on :darwin) (let* ((parent *current-thread*) (semaphore (make-semaphore)) (running t) @@ -230,8 +216,7 @@ (setf running nil) (join-thread noise))) -#+sb-thread -(with-test (:name symbol-value-in-thread.4) +(with-test (:name symbol-value-in-thread.4 :skipped-on '(not :sb-thread)) (let* ((parent *current-thread*) (semaphore (make-semaphore)) (child (make-thread (lambda () @@ -240,8 +225,7 @@ (signal-semaphore semaphore) (assert (equal '(nil nil) (multiple-value-list (join-thread child)))))) -#+sb-thread -(with-test (:name symbol-value-in-thread.5) +(with-test (:name symbol-value-in-thread.5 :skipped-on '(not :sb-thread)) (let* ((parent *current-thread*) (semaphore (make-semaphore)) (child (make-thread (lambda () @@ -256,8 +240,7 @@ (assert (equal (list *current-thread* 'this-is-new (list :read :unbound-in-thread)) (join-thread child))))) -#+sb-thread -(with-test (:name symbol-value-in-thread.6) +(with-test (:name symbol-value-in-thread.6 :skipped-on '(not :sb-thread)) (let* ((parent *current-thread*) (semaphore (make-semaphore)) (name (gensym)) @@ -275,8 +258,7 @@ (unless (equal res want) (error "wanted ~S, got ~S" want res))))) -#+sb-thread -(with-test (:name symbol-value-in-thread.7) +(with-test (:name symbol-value-in-thread.7 :skipped-on '(not :sb-thread)) (let ((child (make-thread (lambda ()))) (error-occurred nil)) (join-thread child) @@ -290,8 +272,7 @@ (sb-thread::symbol-value-in-thread-error-info e))))) (assert error-occurred))) -#+sb-thread -(with-test (:name symbol-value-in-thread.8) +(with-test (:name symbol-value-in-thread.8 :skipped-on '(not :sb-thread)) (let ((child (make-thread (lambda ()))) (error-occurred nil)) (join-thread child) @@ -305,8 +286,7 @@ (sb-thread::symbol-value-in-thread-error-info e))))) (assert error-occurred))) -#+sb-thread -(with-test (:name deadlock-detection.1) +(with-test (:name deadlock-detection.1 :skipped-on '(not :sb-thread)) (loop repeat 1000 do (flet ((test (ma mb sa sb) @@ -335,8 +315,7 @@ (equal '(:ok :deadlock) res) (equal '(:deadlock :deadlock) res)))))))) -#+sb-thread -(with-test (:name deadlock-detection.2) +(with-test (:name deadlock-detection.2 :skipped-on '(not :sb-thread)) (let* ((m1 (sb-thread:make-mutex :name "M1")) (m2 (sb-thread:make-mutex :name "M2")) (s1 (sb-thread:make-semaphore :name "S1")) @@ -371,8 +350,7 @@ (assert (stringp err))) (assert (eq :ok (sb-thread:join-thread t1))))) -#+sb-thread -(with-test (:name deadlock-detection.3) +(with-test (:name deadlock-detection.3 :skipped-on '(not :sb-thread)) (let* ((m1 (sb-thread:make-mutex :name "M1")) (m2 (sb-thread:make-mutex :name "M2")) (s1 (sb-thread:make-semaphore :name "S1")) @@ -386,10 +364,8 @@ :ok))) :name "T1"))) ;; Currently we don't consider it a deadlock - ;; if there is a timeout in the chain. No - ;; Timeouts on lutex builds, though. - (assert (eq #-sb-lutex :deadline - #+sb-lutex :deadlock + ;; if there is a timeout in the chain. + (assert (eq :deadline (handler-case (sb-thread:with-mutex (m2) (sb-thread:signal-semaphore s2) @@ -405,96 +381,117 @@ (assert (eq :ok (join-thread t1))))) #+sb-thread -(with-test (:name deadlock-detection.4) - (loop - repeat 1000 - do (flet ((test (ma mb sa sb) - (lambda () - (handler-case - (sb-thread::with-spinlock (ma) - (sb-thread:signal-semaphore sa) - (sb-thread:wait-on-semaphore sb) - (sb-thread::with-spinlock (mb) - :ok)) - (sb-thread:thread-deadlock (e) - (princ e) - :deadlock))))) - (let* ((m1 (sb-thread::make-spinlock :name "M1")) - (m2 (sb-thread::make-spinlock :name "M2")) - (s1 (sb-thread:make-semaphore :name "S1")) - (s2 (sb-thread:make-semaphore :name "S2")) - (t1 (sb-thread:make-thread (test m1 m2 s1 s2) :name "T1")) - (t2 (sb-thread:make-thread (test m2 m1 s2 s1) :name "T2"))) - ;; One will deadlock, and the other will then complete normally - ;; ...except sometimes, when we get unlucky, and both will do - ;; the deadlock detection in parallel and both signal. - (let ((res (list (sb-thread:join-thread t1) - (sb-thread:join-thread t2)))) - (assert (or (equal '(:deadlock :ok) res) - (equal '(:ok :deadlock) res) - (equal '(:deadlock :deadlock) res)))))))) +(with-test (:name :pass-arguments-to-thread) + (assert (= 3 (join-thread (make-thread #'+ :arguments '(1 2)))))) #+sb-thread -(with-test (:name deadlock-detection.5) - (let* ((m1 (sb-thread::make-spinlock :name "M1")) - (m2 (sb-thread::make-spinlock :name "M2")) - (s1 (sb-thread:make-semaphore :name "S1")) - (s2 (sb-thread:make-semaphore :name "S2")) - (t1 (sb-thread:make-thread - (lambda () - (sb-thread::with-spinlock (m1) - (sb-thread:signal-semaphore s1) - (sb-thread:wait-on-semaphore s2) - (sb-thread::with-spinlock (m2) - :ok))) - :name "T1"))) - (prog (err) - :retry - (handler-bind ((sb-thread:thread-deadlock - (lambda (e) - (unless err - ;; Make sure we can print the condition - ;; while it's active - (let ((*print-circle* nil)) - (setf err (princ-to-string e))) - (go :retry))))) - (when err - (sleep 1)) - (assert (eq :ok (sb-thread::with-spinlock (m2) - (unless err - (sb-thread:signal-semaphore s2) - (sb-thread:wait-on-semaphore s1) - (sleep 1)) - (sb-thread::with-spinlock (m1) - :ok))))) - (assert (stringp err))) - (assert (eq :ok (sb-thread:join-thread t1))))) +(with-test (:name :pass-atom-to-thread) + (assert (= 1/2 (join-thread (make-thread #'/ :arguments 2))))) #+sb-thread -(with-test (:name deadlock-detection.7) - (let* ((m1 (sb-thread::make-spinlock :name "M1")) - (m2 (sb-thread::make-spinlock :name "M2")) - (s1 (sb-thread:make-semaphore :name "S1")) - (s2 (sb-thread:make-semaphore :name "S2")) - (t1 (sb-thread:make-thread - (lambda () - (sb-thread::with-spinlock (m1) - (sb-thread:signal-semaphore s1) - (sb-thread:wait-on-semaphore s2) - (sb-thread::with-spinlock (m2) - :ok))) - :name "T1"))) - (assert (eq :deadlock - (handler-case - (sb-thread::with-spinlock (m2) - (sb-thread:signal-semaphore s2) - (sb-thread:wait-on-semaphore s1) - (sleep 1) - (sb-sys:with-deadline (:seconds 0.1) - (sb-thread::with-spinlock (m1) - :ok))) - (sb-sys:deadline-timeout () - :deadline) - (sb-thread:thread-deadlock () - :deadlock)))) - (assert (eq :ok (join-thread t1))))) +(with-test (:name :pass-nil-to-thread) + (assert (= 1 (join-thread (make-thread #'* :arguments '()))))) + +#+sb-thread +(with-test (:name :pass-nothing-to-thread) + (assert (= 1 (join-thread (make-thread #'*))))) + +#+sb-thread +(with-test (:name :pass-improper-list-to-thread) + (multiple-value-bind (value error) + (ignore-errors (make-thread #'+ :arguments '(1 . 1))) + (when value + (join-thread value)) + (assert (and (null value) + error)))) + +(with-test (:name (:wait-for :basics)) + (assert (not (sb-ext:wait-for nil :timeout 0.1))) + (assert (eql 42 (sb-ext:wait-for 42))) + (let ((n 0)) + (assert (eql 100 (sb-ext:wait-for (when (= 100 (incf n)) + n)))))) + +(with-test (:name (:wait-for :deadline)) + (assert (eq :ok + (sb-sys:with-deadline (:seconds 10) + (assert (not (sb-ext:wait-for nil :timeout 0.1))) + :ok))) + (assert (eq :deadline + (handler-case + (sb-sys:with-deadline (:seconds 0.1) + (sb-ext:wait-for nil :timeout 10) + (error "oops")) + (sb-sys:deadline-timeout () :deadline))))) + +(with-test (:name (:condition-wait :timeout :one-thread)) + (let ((mutex (make-mutex)) + (waitqueue (make-waitqueue))) + (assert (not (with-mutex (mutex) + (condition-wait waitqueue mutex :timeout 0.01)))))) + +(with-test (:name (:condition-wait :timeout :many-threads) + :skipped-on '(not :sb-thread)) + (let* ((mutex (make-mutex)) + (waitqueue (make-waitqueue)) + (sem (make-semaphore)) + (data nil) + (workers + (loop repeat 100 + collect (make-thread + (lambda () + (wait-on-semaphore sem) + (block thread + (with-mutex (mutex) + (loop until data + do (or (condition-wait waitqueue mutex :timeout 0.01) + (return-from thread nil))) + (assert (eq t (pop data))) + t))))))) + (loop repeat 50 + do (with-mutex (mutex) + (push t data) + (condition-notify waitqueue))) + (signal-semaphore sem 100) + (let ((ok (count-if #'join-thread workers))) + (unless (eql 50 ok) + (error "Wanted 50, got ~S" ok))))) + +(with-test (:name (:wait-on-semaphore :timeout :one-thread)) + (let ((sem (make-semaphore)) + (n 0)) + (signal-semaphore sem 10) + (loop repeat 100 + do (when (wait-on-semaphore sem :timeout 0.001) + (incf n))) + (assert (= n 10)))) + +(with-test (:name (:wait-on-semaphore :timeout :many-threads) + :skipped-on '(not :sb-thread)) + (let* ((sem (make-semaphore)) + (threads + (progn + (signal-semaphore sem 10) + (loop repeat 100 + collect (make-thread + (lambda () + (sleep (random 0.02)) + (wait-on-semaphore sem :timeout 0.01))))))) + (loop repeat 5 + do (signal-semaphore sem 2)) + (let ((ok (count-if #'join-thread threads))) + (unless (eql 20 ok) + (error "Wanted 20, got ~S" ok))))) + +(with-test (:name (:join-thread :timeout) + :skipped-on '(not :sb-thread)) + (assert (eq :error + (handler-case + (join-thread (make-thread (lambda () (sleep 10))) :timeout 0.01) + (join-thread-error () + :error)))) + (let ((cookie (cons t t))) + (assert (eq cookie + (join-thread (make-thread (lambda () (sleep 10))) + :timeout 0.01 + :default cookie)))))