X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=tests%2Fthreads.pure.lisp;h=0816e51ec389c576fe5f841d317ae69f94de6f9d;hb=d6f9676ae94419cb5544c45821a8d31adbc1fbe8;hp=8bfeea8cd136c2a909f893504e6a093caad39c19;hpb=b18df732481502bca0040c56685979712ec58754;p=sbcl.git diff --git a/tests/threads.pure.lisp b/tests/threads.pure.lisp index 8bfeea8..0816e51 100644 --- a/tests/threads.pure.lisp +++ b/tests/threads.pure.lisp @@ -51,9 +51,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 +70,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 +88,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 +100,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 @@ -157,6 +153,17 @@ (sb-ext:timeout () :timeout))))))) +;;;; Printing waitqueues + +(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))) + (sb-thread:with-recursive-lock (lock) + (sb-thread:condition-notify wq)) + ;; Used to blow stack due to recursive structure. + (assert (princ-to-string wq)))) + ;;;; SYMBOL-VALUE-IN-THREAD (with-test (:name symbol-value-in-thread.1) @@ -166,8 +173,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 () @@ -184,8 +190,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) @@ -218,8 +225,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 () @@ -228,8 +234,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 () @@ -244,8 +249,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)) @@ -263,24 +267,260 @@ (unless (equal res want) (error "wanted ~S, got ~S" want res))))) -#+sb-thread -(with-test (:name symbol-value-in-thread.7) - (let ((child (make-thread (lambda ())))) +(with-test (:name symbol-value-in-thread.7 :skipped-on '(not :sb-thread)) + (let ((child (make-thread (lambda ()))) + (error-occurred nil)) + (join-thread child) (handler-case (symbol-value-in-thread 'this-is-new child) (symbol-value-in-thread-error (e) + (setf error-occurred t) (assert (eq child (thread-error-thread e))) (assert (eq 'this-is-new (cell-error-name e))) (assert (equal (list :read :thread-dead) - (sb-thread::symbol-value-in-thread-error-info e))))))) + (sb-thread::symbol-value-in-thread-error-info e))))) + (assert error-occurred))) -#+sb-thread -(with-test (:name symbol-value-in-thread.8) - (let ((child (make-thread (lambda ())))) +(with-test (:name symbol-value-in-thread.8 :skipped-on '(not :sb-thread)) + (let ((child (make-thread (lambda ()))) + (error-occurred nil)) + (join-thread child) (handler-case (setf (symbol-value-in-thread 'this-is-new child) t) (symbol-value-in-thread-error (e) + (setf error-occurred t) (assert (eq child (thread-error-thread e))) (assert (eq 'this-is-new (cell-error-name e))) (assert (equal (list :write :thread-dead) - (sb-thread::symbol-value-in-thread-error-info e))))))) + (sb-thread::symbol-value-in-thread-error-info e))))) + (assert error-occurred))) + +(with-test (:name deadlock-detection.1 :skipped-on '(not :sb-thread)) + (loop + repeat 1000 + do (flet ((test (ma mb sa sb) + (lambda () + (handler-case + (sb-thread:with-mutex (ma) + (sb-thread:signal-semaphore sa) + (sb-thread:wait-on-semaphore sb) + (sb-thread:with-mutex (mb) + :ok)) + (sb-thread:thread-deadlock (e) + (princ e) + :deadlock))))) + (let* ((m1 (sb-thread:make-mutex :name "M1")) + (m2 (sb-thread:make-mutex :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 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")) + (s2 (sb-thread:make-semaphore :name "S2")) + (t1 (sb-thread:make-thread + (lambda () + (sb-thread:with-mutex (m1) + (sb-thread:signal-semaphore s1) + (sb-thread:wait-on-semaphore s2) + (sb-thread:with-mutex (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-mutex (m2) + (unless err + (sb-thread:signal-semaphore s2) + (sb-thread:wait-on-semaphore s1) + (sleep 1)) + (sb-thread:with-mutex (m1) + :ok))))) + (assert (stringp err))) + (assert (eq :ok (sb-thread:join-thread t1))))) + +(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")) + (s2 (sb-thread:make-semaphore :name "S2")) + (t1 (sb-thread:make-thread + (lambda () + (sb-thread:with-mutex (m1) + (sb-thread:signal-semaphore s1) + (sb-thread:wait-on-semaphore s2) + (sb-thread:with-mutex (m2) + :ok))) + :name "T1"))) + ;; Currently we don't consider it a deadlock + ;; if there is a timeout in the chain. + (assert (eq :deadline + (handler-case + (sb-thread:with-mutex (m2) + (sb-thread:signal-semaphore s2) + (sb-thread:wait-on-semaphore s1) + (sleep 1) + (sb-sys:with-deadline (:seconds 0.1) + (sb-thread:with-mutex (m1) + :ok))) + (sb-sys:deadline-timeout () + :deadline) + (sb-thread:thread-deadlock () + :deadlock)))) + (assert (eq :ok (join-thread t1))))) + +(with-test (:name deadlock-detection.4 :skipped-on '(not :sb-thread)) + (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 deadlock-detection.5 :skipped-on '(not :sb-thread)) + (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 deadlock-detection.7 :skipped-on '(not :sb-thread)) + (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))))) + +#+sb-thread +(with-test (:name :pass-arguments-to-thread) + (assert (= 3 (join-thread (make-thread #'+ :arguments '(1 2)))))) + +#+sb-thread +(with-test (:name :pass-atom-to-thread) + (assert (= 1/2 (join-thread (make-thread #'/ :arguments 2))))) + +#+sb-thread +(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)))))