X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=tests%2Fthreads.pure.lisp;h=1b2ea7f31aa5709faed1d0a293e09c092c54f0f4;hb=31f68584d0732dc0d17f379773e5f87f1e5a78ad;hp=e785e736c77e96769d1bd229a3cf3812bb79d081;hpb=126b9cfb25799ca41210c1a1658de30e1ff372e7;p=sbcl.git diff --git a/tests/threads.pure.lisp b/tests/threads.pure.lisp index e785e73..1b2ea7f 100644 --- a/tests/threads.pure.lisp +++ b/tests/threads.pure.lisp @@ -20,21 +20,23 @@ (use-package :test-util) -(with-test (:name atomic-update) - (let ((x (cons :count 0))) +(with-test (:name atomic-update + :skipped-on '(not :sb-thread)) + (let ((x (cons :count 0)) + (nthreads (ecase sb-vm:n-word-bits (32 100) (64 1000)))) (mapc #'sb-thread:join-thread - (loop repeat 1000 + (loop repeat nthreads collect (sb-thread:make-thread (lambda () (loop repeat 1000 do (atomic-update (cdr x) #'1+) (sleep 0.00001)))))) - (assert (equal x '(:count . 1000000))))) + (assert (equal x `(:count ,@(* 1000 nthreads)))))) (with-test (:name mutex-owner) ;; Make sure basics are sane on unithreaded ports as well (let ((mutex (make-mutex))) - (get-mutex mutex) + (grab-mutex mutex) (assert (eq *current-thread* (mutex-value mutex))) (handler-bind ((warning #'error)) (release-mutex mutex)) @@ -53,8 +55,9 @@ ;;; Condition-wait should not be interruptible under WITHOUT-INTERRUPTS -(with-test (:name without-interrupts+condition-wait - :skipped-on '(not :sb-thread)) +(with-test (:name :without-interrupts+condition-wait + :skipped-on '(not :sb-thread) + :fails-on '(and :win32 :sb-futex)) (let* ((lock (make-mutex)) (queue (make-waitqueue)) (thread (make-thread (lambda () @@ -70,11 +73,11 @@ (sleep 1) (assert (not (thread-alive-p thread))))) -;;; GET-MUTEX should not be interruptible under WITHOUT-INTERRUPTS +;;; GRAB-MUTEX should not be interruptible under WITHOUT-INTERRUPTS -(with-test (:name without-interrupts+get-mutex :skipped-on '(not :sb-thread)) +(with-test (:name :without-interrupts+grab-mutex :skipped-on '(not :sb-thread)) (let* ((lock (make-mutex)) - (bar (progn (get-mutex lock) nil)) + (bar (progn (grab-mutex lock) nil)) (thread (make-thread (lambda () (sb-sys:without-interrupts (with-mutex (lock) @@ -90,7 +93,7 @@ (assert (eq :aborted (join-thread thread :default :aborted))) (assert bar))) -(with-test (:name parallel-find-class :skipped-on '(not :sb-thread)) +(with-test (:name :parallel-find-class :skipped-on '(not :sb-thread)) (let* ((oops nil) (threads (loop repeat 10 collect (make-thread (lambda () @@ -168,14 +171,14 @@ ;;;; SYMBOL-VALUE-IN-THREAD -(with-test (:name symbol-value-in-thread.1) +(with-test (:name :symbol-value-in-thread.1) (let ((* (cons t t))) (assert (eq * (symbol-value-in-thread '* *current-thread*))) (setf (symbol-value-in-thread '* *current-thread*) 123) (assert (= 123 (symbol-value-in-thread '* *current-thread*))) (assert (= 123 *)))) -(with-test (:name symbol-value-in-thread.2 :skipped-on '(not :sb-thread)) +(with-test (:name :symbol-value-in-thread.2 :skipped-on '(not :sb-thread)) (let* ((parent *current-thread*) (semaphore (make-semaphore)) (child (make-thread (lambda () @@ -191,7 +194,7 @@ ;;; Disabled on Darwin due to deadlocks caused by apparent OS specific deadlocks, ;;; 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. -(with-test (:name symbol-value-in-thread.3 +(with-test (:name :symbol-value-in-thread.3 :skipped-on '(not :sb-thread)) (let* ((parent *current-thread*) (semaphore (make-semaphore)) @@ -206,7 +209,7 @@ (loop repeat (random 128) do (setf ** *))))))) (write-string "; ") - (dotimes (i 15000) + (dotimes (i #+win32 2000 #-win32 15000) (when (zerop (mod i 200)) (write-char #\.) (force-output)) @@ -225,7 +228,7 @@ (setf running nil) (join-thread noise))) -(with-test (:name symbol-value-in-thread.4 :skipped-on '(not :sb-thread)) +(with-test (:name :symbol-value-in-thread.4 :skipped-on '(not :sb-thread)) (let* ((parent *current-thread*) (semaphore (make-semaphore)) (child (make-thread (lambda () @@ -234,7 +237,7 @@ (signal-semaphore semaphore) (assert (equal '(nil nil) (multiple-value-list (join-thread child)))))) -(with-test (:name symbol-value-in-thread.5 :skipped-on '(not :sb-thread)) +(with-test (:name :symbol-value-in-thread.5 :skipped-on '(not :sb-thread)) (let* ((parent *current-thread*) (semaphore (make-semaphore)) (child (make-thread (lambda () @@ -249,7 +252,7 @@ (assert (equal (list *current-thread* 'this-is-new (list :read :unbound-in-thread)) (join-thread child))))) -(with-test (:name symbol-value-in-thread.6 :skipped-on '(not :sb-thread)) +(with-test (:name :symbol-value-in-thread.6 :skipped-on '(not :sb-thread)) (let* ((parent *current-thread*) (semaphore (make-semaphore)) (name (gensym)) @@ -267,7 +270,7 @@ (unless (equal res want) (error "wanted ~S, got ~S" want res))))) -(with-test (:name symbol-value-in-thread.7 :skipped-on '(not :sb-thread)) +(with-test (:name :symbol-value-in-thread.7 :skipped-on '(not :sb-thread)) (let ((child (make-thread (lambda ()))) (error-occurred nil)) (join-thread child) @@ -281,7 +284,7 @@ (sb-thread::symbol-value-in-thread-error-info e))))) (assert error-occurred))) -(with-test (:name symbol-value-in-thread.8 :skipped-on '(not :sb-thread)) +(with-test (:name :symbol-value-in-thread.8 :skipped-on '(not :sb-thread)) (let ((child (make-thread (lambda ()))) (error-occurred nil)) (join-thread child) @@ -295,7 +298,7 @@ (sb-thread::symbol-value-in-thread-error-info e))))) (assert error-occurred))) -(with-test (:name deadlock-detection.1 :skipped-on '(not :sb-thread)) +(with-test (:name :deadlock-detection.1 :skipped-on '(not :sb-thread)) (loop repeat 1000 do (flet ((test (ma mb sa sb) @@ -321,7 +324,7 @@ (assert (or (equal '(:deadlock :ok) res) (equal '(:ok :deadlock) res)))))))) -(with-test (:name deadlock-detection.2 :skipped-on '(not :sb-thread)) +(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")) @@ -356,7 +359,7 @@ (assert (stringp err))) (assert (eq :ok (sb-thread:join-thread t1))))) -(with-test (:name deadlock-detection.3 :skipped-on '(not :sb-thread)) +(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")) @@ -493,15 +496,63 @@ :skipped-on '(not :sb-thread)) (assert (eq :error (handler-case - (join-thread (make-thread (lambda () (sleep 10))) :timeout 0.01) + (join-thread (make-join-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))) + (join-thread (make-join-thread (lambda () (sleep 10))) :timeout 0.01 :default cookie))))) +(with-test (:name (:semaphore-notification :wait-on-semaphore :lp-1038034) + :skipped-on '(not :sb-thread) + :fails-on :sb-thread) + ;; Test robustness of semaphore acquisition and notification with + ;; asynchronous thread termination... Which we know is currently + ;; fragile. + (dotimes (run 180) + (let ((sem (make-semaphore))) + ;; In CRITICAL, WAIT-ON-SEMAPHORE and SLEEP can be interrupted + ;; by TERMINATE-THREAD below. But the SIGNAL-SEMAPHORE cleanup + ;; cannot be interrupted. + (flet ((critical (sleep) + (let ((note (make-semaphore-notification))) + (sb-sys:without-interrupts + (unwind-protect + (sb-sys:with-local-interrupts + (wait-on-semaphore sem :notification note) + (sleep sleep)) + ;; Re-increment on exit if we decremented it. + (when (semaphore-notification-status note) + (signal-semaphore sem))))))) + ;; Create /parallel/ threads trying to acquire and then signal + ;; the semaphore. Try to asynchronously abort T2 just as T1 is + ;; exiting. + (destructuring-bind (t1 t2 t3) + (loop for i from 1 + for sleep in '(0.01 0.02 0.02) + collect (make-thread #'critical :arguments sleep + :name (format nil "T~A" i))) + (signal-semaphore sem) + (sleep 0.01) + (ignore-errors + (terminate-thread t2)) + (flet ((safe-join-thread (thread &key timeout) + (assert timeout) + (when (eq :timeout + (join-thread thread + :timeout timeout + :default :timeout)) + (error "Hang in (join-thread ~A) ?" thread)))) + (safe-join-thread t1 :timeout 10) + (safe-join-thread t3 :timeout 10))))) + (when (zerop (mod run 60)) + (fresh-line) + (write-string "; ")) + (write-char #\.) + (force-output))) + (with-test (:name (:semaphore-notification :wait-on-semaphore) :skipped-on '(not :sb-thread)) (let ((sem (make-semaphore)) @@ -524,7 +575,7 @@ #+sb-thread (sb-thread::block-deferrable-signals)))))) (let* ((threads (loop for i from 1 upto 100 - collect (make-thread #'critical :name (format nil "T~A" i)))) + collect (make-join-thread #'critical :name (format nil "T~A" i)))) (safe nil) (unsafe nil) (interruptor (make-thread (lambda () @@ -559,7 +610,8 @@ (try-semaphore sem 1 note) (assert (semaphore-notification-status note)))) -(with-test (:name (:return-from-thread :normal-thread)) +(with-test (:name (:return-from-thread :normal-thread) + :skipped-on '(not :sb-thread)) (let* ((thread (make-thread (lambda () (return-from-thread (values 1 2 3)) :foo))) @@ -575,7 +627,8 @@ (thread-error () :oops))))) -(with-test (:name (:abort-thread :normal-thread)) +(with-test (:name (:abort-thread :normal-thread) + :skipped-on '(not :sb-thread)) (let ((thread (make-thread (lambda () (abort-thread) :foo)))) @@ -589,3 +642,26 @@ (thread-error () :oops))))) +;; SB-THREAD:MAKE-THREAD used to lock SB-THREAD:*MAKE-THREAD-LOCK* +;; before entering WITHOUT-INTERRUPTS. When a thread which was +;; executing SB-THREAD:MAKE-THREAD was interrupted with code which +;; also called SB-THREAD:MAKE-THREAD, it could happen that the first +;; thread already owned SB-THREAD:*MAKE-THREAD-LOCK* and the +;; interrupting code thus made a recursive lock attempt. +;; +;; See (:TIMER :DISPATCH-THREAD :MAKE-THREAD :BUG-1180102) in +;; timer.impure.lisp. +(with-test (:name (make-thread :interrupt-with make-thread :bug-1180102) + :skipped-on '(not :sb-thread)) + (dotimes (i 100) + (let ((threads '()) + (parent *current-thread*)) + (dotimes (i 100) + (push (make-thread + (lambda () + (interrupt-thread + parent + (lambda () (push (make-thread (lambda ())) threads))))) + threads) + (push (make-thread (lambda ())) threads)) + (mapc #'join-thread threads))))