sb-concurrency self test failing sometimes: FLOATING-POINT-INVALID-OPERATION

[Lutz Euler]

I build SBCL x86 under x86-64.
Sometimes (one out of ten builds maybe?) the
sb-concurrency self test fails.
The error is:

arithmetic error FLOATING-POINT-INVALID-OPERATION signalled

See below for the backtrace.
Seen with version 1.0.50.54 and 1.0.51.28.

This is Linux, kernel 3.0.3 with preemption
and Kolivas' BFS Scheduler version 406,
on a triple-core machine.

; compiling file "/home/sbcl/contrib/sb-concurrency/tests/test-mailbox.lisp" (written 22 JUL 2011 09:34:04 PM):
; compiling (IN-PACKAGE :SB-CONCURRENCY-TEST)
; compiling (DEFTEST MAILBOX-TRIVIA.1 ...)
; compiling (DEFTEST MAILBOX-TRIVIA.2 ...)
; compiling (DEFTEST MAILBOX-TRIVIA.3 ...)
; compiling (DEFSTRUCT COUNTER ...)
; compiling (DEFUN RECEIVER-DISTRIBUTION ...)
; compiling (DEFUN TEST-MAILBOX-PRODUCERS-CONSUMERS ...)
; compiling (DEFTEST MAILBOX.SINGLE-PRODUCER-SINGLE-CONSUMER ...)
; compiling (DEFTEST MAILBOX.SINGLE-PRODUCER-MULTIPLE-CONSUMERS ...)
; compiling (DEFTEST MAILBOX.MULTIPLE-PRODUCERS-SINGLE-CONSUMER ...)
; compiling (DEFTEST MAILBOX.MULTIPLE-PRODUCERS-MULTIPLE-CONSUMERS ...)
; compiling (DEFTEST MAILBOX.INTERRUPTS-SAFETY.1 ...)

; /home/sbcl/contrib/sb-concurrency/tests/ASDF-TMP-test-mailbox.fasl written
; compilation finished in 0:00:00.065
Doing 16 pending tests of 16 tests total.
 SB-CONCURRENCY-TEST::QUEUE.1 SB-CONCURRENCY-TEST::QUEUE.2
 SB-CONCURRENCY-TEST::QUEUE.3 SB-CONCURRENCY-TEST::QUEUE.4
 SB-CONCURRENCY-TEST::QUEUE.5 SB-CONCURRENCY-TEST::QUEUE.T.1
 SB-CONCURRENCY-TEST::QUEUE.T.2 SB-CONCURRENCY-TEST::QUEUE.T.3
 SB-CONCURRENCY-TEST::MAILBOX-TRIVIA.1 SB-CONCURRENCY-TEST::MAILBOX-TRIVIA.2
 SB-CONCURRENCY-TEST::MAILBOX-TRIVIA.3
 SB-CONCURRENCY-TEST::MAILBOX.SINGLE-PRODUCER-SINGLE-CONSUMER
 SB-CONCURRENCY-TEST::MAILBOX.SINGLE-PRODUCER-MULTIPLE-CONSUMERS
unhandled FLOATING-POINT-INVALID-OPERATION in thread #<SB-THREAD:THREAD
                                                       "RECV-MSG-16" RUNNING
                                                        {B99C7E1}>:
  arithmetic error FLOATING-POINT-INVALID-OPERATION signalled

0: (SB-DEBUG::MAP-BACKTRACE #<CLOSURE (LAMBDA #) {AB81805}> :START 0 :COUNT 128)
1: (BACKTRACE 128 #<SYNONYM-STREAM :SYMBOL SB-SYS:*STDERR* {90D6DE9}>)
2: (SB-DEBUG::DEBUGGER-DISABLED-HOOK
    #<FLOATING-POINT-INVALID-OPERATION {ACE74F9}>
    #<unavailable argument>)
3: (SB-DEBUG::RUN-HOOK
    *INVOKE-DEBUGGER-HOOK*
    #<FLOATING-POINT-INVALID-OPERATION {ACE74F9}>)
4: (INVOKE-DEBUGGER #<FLOATING-POINT-INVALID-OPERATION {ACE74F9}>)
5: (ERROR FLOATING-POINT-INVALID-OPERATION)
6: (SB-VM:SIGFPE-HANDLER
    #<unavailable argument>
    #.(SB-SYS:INT-SAP #X741BC88C)
    #<unavailable argument>)
7: ((FLET #:WITHOUT-INTERRUPTS-BODY-[EXEC]20))
8: ((FLET SB-THREAD::EXEC))
9: ((FLET #:WITHOUT-INTERRUPTS-BODY-[INVOKE-INTERRUPTION]11))
10: (SB-SYS:INVOKE-INTERRUPTION
     #<CLOSURE (FLET SB-UNIX::INTERRUPTION) {741BC5ED}>)
11: (SB-SYS:INVOKE-INTERRUPTION
     #<CLOSURE (FLET SB-UNIX::INTERRUPTION) {741BC5ED}>)[:EXTERNAL]
12: ((FLET SB-UNIX::RUN-HANDLER)
     8
     #.(SB-SYS:INT-SAP #X741BC88C)
     #.(SB-SYS:INT-SAP #X741BC90C))
13: ("foreign function: call_into_lisp")
14: ("foreign function: funcall3")
15: ("foreign function: interrupt_handle_now")
16: ("foreign function: interrupt_handle_now_handler")
17: ((LAMBDA ()))
18: (SB-C::INVOKE-WITH-SAVED-FP-AND-PC #<unavailable argument>)
19: (GET-INTERNAL-REAL-TIME)
20: (SB-SYS:DECODE-TIMEOUT NIL)
21: (SB-THREAD:GET-MUTEX
     #<unavailable argument>
     #<unavailable argument>
     #<unavailable argument>
     #<unavailable argument>)
22: ((FLET #:WITHOUT-INTERRUPTS-BODY-[CALL-WITH-SYSTEM-MUTEX/ALLOW-WITH-INTERRUPTS]206))
23: (SB-THREAD:WAIT-ON-SEMAPHORE
     #S(SB-THREAD:SEMAPHORE
        :NAME "Mailbox Semaphore"
        :%COUNT 1
        :WAITCOUNT 4
        :MUTEX #<SB-THREAD:MUTEX
                   owner: #1=#<SB-THREAD:THREAD "RECV-MSG-1" waiting for:
                                  #
                                {AEE3809}>
                   {BAB4DD1}>
        :QUEUE #<SB-THREAD:WAITQUEUE {BAB4DE9}>))
24: ((FLET #:WITHOUT-INTERRUPTS-BODY-[RECEIVE-MESSAGE]139))
25: (SB-CONCURRENCY:RECEIVE-MESSAGE
     #<SB-CONCURRENCY:MAILBOX (1 msgs pending) {BAB4E19}>)
26: ((LAMBDA ()))
27: ((FLET #:WITHOUT-INTERRUPTS-BODY-[BLOCK405]410))
28: ((FLET SB-THREAD::WITH-MUTEX-THUNK))
29: ((FLET #:WITHOUT-INTERRUPTS-BODY-[CALL-WITH-MUTEX]309))
30: (SB-THREAD::CALL-WITH-MUTEX
     #<CLOSURE (FLET SB-THREAD::WITH-MUTEX-THUNK) {741BD205}>
     #<SB-THREAD:MUTEX "thread result lock"
         owner: #<SB-THREAD:THREAD "RECV-MSG-16" RUNNING {B99C7E1}>>
     #<SB-THREAD:THREAD "RECV-MSG-16" RUNNING {B99C7E1}>
     T)
31: (SB-THREAD::INITIAL-THREAD-FUNCTION)
32: ("foreign function: call_into_lisp")
33: ("foreign function: funcall0")
34: ("foreign function: new_thread_trampoline")
35: ("foreign function: #x555A7E72")

unhandled condition in --disable-debugger mode, quitting
unhandled FLOATING-POINT-INVALID-OPERATION in thread #<SB-THREAD:THREAD
                                                       "RECV-MSG-NO-HANG-34" RUNNING
                                                        {BCA1521}>:
  arithmetic error FLOATING-POINT-INVALID-OPERATION signalled

unhandled FLOATING-POINT-INVALID-OPERATION in thread #<SB-THREAD:THREAD
                                                       "RECV-PEND-MSGS-2" RUNNING
                                                        {AE50B31}>:
  arithmetic error FLOATING-POINT-INVALID-OPERATION signalled

0:
0: (SB-DEBUG::MAP-BACKTRACE #<CLOSURE (LAMBDA #) {AB2FF5D}> :START 0 :COUNT 128)(SB-DEBUG::MAP-BACKTRACE #<CLOSURE (LAMBDA #) {AAACF65}> :START 0 :COUNT 128)
1:
1: (BACKTRACE 128 #<SYNONYM-STREAM :SYMBOL SB-SYS:*STDERR* {90D6DE9}>)
2: (BACKTRACE 128 #<SYNONYM-STREAM :SYMBOL SB-SYS:*STDERR* {90D6DE9}>)(SB-DEBUG::DEBUGGER-DISABLED-HOOK
2: (BACKTRACE 128 #<SYNONYM-STREAM :SYMBOL SB-SYS:*STDERR* {90D6DE9}>)(SB-DEBUG::DEBUGGER-DISABLED-HOOK
 : #<FLOATING-POINT-INVALID-OPERATION {AB2F001}>
    #<unavailable argument>)
3: (SB-DEBUG::RUN-HOOK
    *INVOKE-DEBUGGER-HOOK*
    #<FLOATING-POINT-INVALID-OPERATION {AB2F001}>)(SB-DEBUG::DEBUGGER-DISABLED-HOOK
                             #<FLOATING-POINT-INVALID-OPERATION {AAAC009}>
                             #<unavailable argument>)(INVOKE-DEBUGGER #<FLOATING-POINT-INVALID-OPERATION {AB2F001}>)
5: (ERROR FLOATING-POINT-INVALID-OPERATION)
6:
3: (SB-VM:SIGFPE-HANDLER
    #<unavailable argument>
    #.(SB-SYS:INT-SAP #X7862CBAC)
    #<unavailable argument>)
7: ((FLET #:WITHOUT-INTERRUPTS-BODY-[EXEC]20))
8: ((FLET SB-THREAD::EXEC))
9: ((FLET #:WITHOUT-INTERRUPTS-BODY-[INVOKE-INTERRUPTION]11))
10: (SB-SYS:INVOKE-INTERRUPTION
     #<CLOSURE (FLET SB-UNIX::INTERRUPTION) {7862C90D}>)
11: (SB-SYS:INVOKE-INTERRUPTION
     #<CLOSURE (FLET SB-UNIX::INTERRUPTION) {7862C90D}>)[:EXTERNAL]
12: ((FLET SB-UNIX::RUN-HANDLER)
     8
     #.(SB-SYS:INT-SAP #X7862CBAC)
     #.(SB-SYS:INT-SAP #X7862CC2C))
13: ("foreign function: call_into_lisp")
14: ("foreign function: funcall3")
15: ("foreign function: interrupt_handle_now")
16: ("foreign function: interrupt_handle_now_handler")
17: ((LAMBDA ()))
18: ((FLET #:WITHOUT-INTERRUPTS-BODY-[BLOCK405]410))
19: ((FLET SB-THREAD::WITH-MUTEX-THUNK))
20: ((FLET #:WITHOUT-INTERRUPTS-BODY-[CALL-WITH-MUTEX]309))
21: (SB-THREAD::CALL-WITH-MUTEX
     #<CLOSURE (FLET SB-THREAD::WITH-MUTEX-THUNK) {7862D205}>
     #<SB-THREAD:MUTEX "thread result lock"
         owner: #<SB-THREAD:THREAD "RECV-PEND-MSGS-2" RUNNING {AE50B31}>>
     #<SB-THREAD:THREAD "RECV-PEND-MSGS-2" RUNNING {AE50B31}>
     T)
22: (SB-THREAD::INITIAL-THREAD-FUNCTION)
23: ("foreign function: call_into_lisp")
24: ("foreign function: funcall0")
25: ("foreign function: new_thread_trampoline")
26: ("foreign function: #x555A7E72")

unhandled condition in --disable-debugger mode, quitting
(SB-DEBUG::RUN-HOOK
    *INVOKE-DEBUGGER-HOOK*
    #<FLOATING-POINT-INVALID-OPERATION {AAAC009}>)
4: (INVOKE-DEBUGGER #<FLOATING-POINT-INVALID-OPERATION {AAAC009}>)
5: (ERROR FLOATING-POINT-INVALID-OPERATION)
6: (SB-VM:SIGFPE-HANDLER
    #<unavailable argument>
    #.(SB-SYS:INT-SAP #X6097D93C)
    #<unavailable argument>)
7: ((FLET #:WITHOUT-INTERRUPTS-BODY-[EXEC]20))
8: ((FLET SB-THREAD::EXEC))
9: ((FLET #:WITHOUT-INTERRUPTS-BODY-[INVOKE-INTERRUPTION]11))
10: (SB-SYS:INVOKE-INTERRUPTION
     #<CLOSURE (FLET SB-UNIX::INTERRUPTION) {6097D69D}>)
11: (SB-SYS:INVOKE-INTERRUPTION
     #<CLOSURE (FLET SB-UNIX::INTERRUPTION) {6097D69D}>)[:EXTERNAL]
12: ((FLET SB-UNIX::RUN-HANDLER)
     8
     #.(SB-SYS:INT-SAP #X6097D93C)
     #.(SB-SYS:INT-SAP #X6097D9BC))
13: ("foreign function: call_into_lisp")
14: ("foreign function: funcall3")
15: ("foreign function: interrupt_handle_now")
16: ("foreign function: interrupt_handle_now_handler")
17: (SB-THREAD:GET-MUTEX
     #<unavailable argument>
     #<unavailable argument>
     #<unavailable argument>
     #<unavailable argument>)
18: ((FLET #:WITHOUT-INTERRUPTS-BODY-[CALL-WITH-MUTEX]309))
19: (SB-THREAD:TRY-SEMAPHORE
     #S(SB-THREAD:SEMAPHORE
        :NAME "Mailbox Semaphore"
        :%COUNT 0
        :WAITCOUNT 49
        :MUTEX #<SB-THREAD:MUTEX
                   owner: #1=#<SB-THREAD:THREAD
                               "RECV-MSG-NO-HANG-28" waiting for:
                                  #
                                {BC9A219}>
                   {BAB4DD1}>
        :QUEUE #<SB-THREAD:WAITQUEUE {BAB4DE9}>)
     1)
20: ((FLET #:WITHOUT-INTERRUPTS-BODY-[RECEIVE-MESSAGE-NO-HANG]183))
21: (SB-CONCURRENCY:RECEIVE-MESSAGE-NO-HANG
     #<SB-CONCURRENCY:MAILBOX (0 msgs pending) {BAB4E19}>)
22: ((LAMBDA ()))
23: ((FLET #:WITHOUT-INTERRUPTS-BODY-[BLOCK405]410))
24: ((FLET SB-THREAD::WITH-MUTEX-THUNK))
25: ((FLET #:WITHOUT-INTERRUPTS-BODY-[CALL-WITH-MUTEX]309))
26: (SB-THREAD::CALL-WITH-MUTEX
     #<CLOSURE (FLET SB-THREAD::WITH-MUTEX-THUNK) {6097E205}>
     #<SB-THREAD:MUTEX "thread result lock"
         owner: #<SB-THREAD:THREAD "RECV-MSG-NO-HANG-34" RUNNING {BCA1521}>>
     #<SB-THREAD:THREAD "RECV-MSG-NO-HANG-34" RUNNING {BCA1521}>
     T)
27: (SB-THREAD::INITIAL-THREAD-FUNCTION)
28: ("foreign function: call_into_lisp")
29: ("foreign function: funcall0")
30: ("foreign function: new_thread_trampoline")
31: ("foreign function: #x555A7E72")

unhandled condition in --disable-debugger mode, quitting
 SB-CONCURRENCY-TEST::MAILBOX.MULTIPLE-PRODUCERS-SINGLE-CONSUMER
Test SB-CONCURRENCY-TEST::MAILBOX.MULTIPLE-PRODUCERS-MULTIPLE-CONSUMERS failed
Form: (SB-CONCURRENCY-TEST::TEST-MAILBOX-PRODUCERS-CONSUMERS :N-SENDERS 100
                                                             :N-RECEIVERS 100
                                                             :N-MESSAGES 1000)
Expected values: (:RECEIVED . 100000)
                 (:GARBAGE . 0)
                 (:ERRORS . 0)
                 (:TIMEOUTS . 0)
Actual values: (:RECEIVED . 100000)
               (:GARBAGE . 0)
               (:ERRORS . 3)
               (:TIMEOUTS . 0).
 SB-CONCURRENCY-TEST::MAILBOX.INTERRUPTS-SAFETY.1
1 out of 16 total tests failed:
   SB-CONCURRENCY-TEST::MAILBOX.MULTIPLE-PRODUCERS-MULTIPLE-CONSUMERS.unhandled SIMPLE-ERROR in thread #<SB-THREAD:THREAD "initial thread" RUNNING
                                    {AAA5129}>:
  ASDF:TEST-OP failed

0: (SB-DEBUG::MAP-BACKTRACE #<CLOSURE (LAMBDA #) {B229865}> :START 0 :COUNT 128)
1: (BACKTRACE 128 #<SYNONYM-STREAM :SYMBOL SB-SYS:*STDERR* {90D6DE9}>)
2: (SB-DEBUG::DEBUGGER-DISABLED-HOOK
    #<SIMPLE-ERROR "~S failed" {B2283A9}>
    #<unavailable argument>)
3: (SB-DEBUG::RUN-HOOK
    *INVOKE-DEBUGGER-HOOK*
    #<SIMPLE-ERROR "~S failed" {B2283A9}>)
4: (INVOKE-DEBUGGER #<SIMPLE-ERROR "~S failed" {B2283A9}>)
5: (ERROR "~S failed" ASDF:TEST-OP)
6: ((SB-PCL::FAST-METHOD ASDF:PERFORM
     (ASDF:TEST-OP (EQL (ASDF:FIND-SYSTEM :SB-CONCURRENCY-TESTS))))
    #<unavailable argument>
    #<unavailable argument>
    #<unavailable argument>
    #<unavailable argument>)
7: ((SB-PCL::EMF ASDF:PERFORM)
    #<unavailable argument>
    #<unavailable argument>
    #<ASDF:TEST-OP NIL {B3973D1}>
    #<ASDF:SYSTEM "sb-concurrency-tests">)
8: ((LAMBDA ()))
9: ((FLET SB-C::WITH-IT))
10: ((SB-PCL::FAST-METHOD ASDF::PERFORM-PLAN (LIST))
     #<unused argument>
     #<unused argument>
     ((#<ASDF:TEST-OP NIL {B3973D1}>
       . #<ASDF:CL-SOURCE-FILE "sb-concurrency-tests" "tests" "package">)
      (#<ASDF:TEST-OP NIL {B3973D1}>
       . #<ASDF:CL-SOURCE-FILE "sb-concurrency-tests" "tests" "test-utils">)
      (#<ASDF:TEST-OP NIL {B3973D1}>
       . #<ASDF:CL-SOURCE-FILE "sb-concurrency-tests" "tests" "test-queue">)
      (#<ASDF:TEST-OP NIL {B3973D1}>
       . #<ASDF:CL-SOURCE-FILE "sb-concurrency-tests" "tests" "test-mailbox">)
      (#<ASDF:TEST-OP NIL {B3973D1}>
       . #<ASDF:MODULE "sb-concurrency-tests" "tests">)
      (#<ASDF:TEST-OP NIL {B3973D1}> . #<ASDF:SYSTEM "sb-concurrency-tests">)))
11: ((LAMBDA ()))
12: ((SB-PCL::FAST-METHOD ASDF:OPERATE (T T))
     #<unused argument>
     #<unused argument>
     ASDF:TEST-OP
     :SB-CONCURRENCY-TESTS)
13: ((SB-PCL::EMF ASDF:OPERATE)
     #<unused argument>
     #<unused argument>
     ASDF:TEST-OP
     :SB-CONCURRENCY-TESTS)
14: ((SB-PCL::EMF ASDF:PERFORM)
     #<unavailable argument>
     #<unavailable argument>
     #<ASDF:TEST-OP NIL {B401C49}>
     #<ASDF:SYSTEM "sb-concurrency">)
15: ((LAMBDA ()))
16: ((FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK))
17: ((FLET #:WITHOUT-INTERRUPTS-BODY-[CALL-WITH-RECURSIVE-LOCK]333))
18: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK
     #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK) {55A407FD}>
     #<SB-THREAD:MUTEX "World Lock"
         owner: #<SB-THREAD:THREAD "initial thread" RUNNING {AAA5129}>>)
19: ((FLET SB-C::WITH-IT))
20: ((SB-PCL::FAST-METHOD ASDF::PERFORM-PLAN (LIST))
     #<unused argument>
     #<unused argument>
     ((#<ASDF:TEST-OP NIL {B401C49}>
       . #<ASDF:CL-SOURCE-FILE "sb-concurrency" "package">)
      (#<ASDF:TEST-OP NIL {B401C49}>
       . #<ASDF:CL-SOURCE-FILE "sb-concurrency" "queue">)
      (#<ASDF:TEST-OP NIL {B401C49}>
       . #<ASDF:CL-SOURCE-FILE "sb-concurrency" "mailbox">)
      (#<ASDF:TEST-OP NIL {B401C49}> . #<ASDF:SYSTEM "sb-concurrency">)))
21: ((LAMBDA ()))
22: (ASDF::CALL-WITH-SYSTEM-DEFINITIONS #<CLOSURE (LAMBDA #) {B401765}>)
23: ((SB-PCL::FAST-METHOD ASDF:OPERATE (T T))
     #<unused argument>
     #<unused argument>
     ASDF:TEST-OP
     :SB-CONCURRENCY)
24: ((SB-PCL::EMF ASDF:OPERATE)
     #<unused argument>
     #<unused argument>
     ASDF:TEST-OP
     :SB-CONCURRENCY)
25: (SB-INT:SIMPLE-EVAL-IN-LEXENV
     (ASDF:OPERATE 'ASDF:TEST-OP :SB-CONCURRENCY)
     #<NULL-LEXENV>)
26: (EVAL (ASDF:OPERATE 'ASDF:TEST-OP :SB-CONCURRENCY))
27: (INTERACTIVE-EVAL (ASDF:OPERATE 'ASDF:TEST-OP :SB-CONCURRENCY) :EVAL NIL)
28: (SB-IMPL::REPL-FUN NIL)
29: ((LAMBDA ()))
30: (SB-IMPL::%WITH-REBOUND-IO-SYNTAX #<CLOSURE (LAMBDA #) {AFB1ECD}>)
31: (SB-IMPL::TOPLEVEL-REPL NIL)
32: (SB-IMPL::TOPLEVEL-INIT)
33: ((FLET #:WITHOUT-INTERRUPTS-BODY-[RESTART-LISP]38))
34: ((LABELS SB-IMPL::RESTART-LISP))

unhandled condition in --disable-debugger mode, quitting
;
; compilation unit aborted
; caught 2 fatal ERROR conditions
make: *** [test] Error 1
make: Leaving directory `/home/sbcl/contrib/sb-concurrency'

[Nikodemus Siivola (nikodemus)]

I'm virtually certain this is a kernel issue.

[Douglas Katzman (dougk)]

unable to reproduce