gmane.lisp.steel-bank.devel

Automating widetag dispatch

James M. Lawrence — 2012-05-24T09:10:19

I would like to optimize some (apply #'map-into ..) calls where the
sequence(s) passed are not created by me. That is, optimize the
non-open-coded MAP-INTO.

I gathered the pieces of the widetag dispatching code for
VECTOR-SUBSEQ* and wrote a general macro for creating dispatch tables.
Using the first parameter as the specialized array,
DEFINE-ARRAY-DISPATCH defines each specializing function with a
corresponding type declaration inside. VECTOR-SUBSEQ* may now be
written as:

(define-array-dispatch vector-subseq-dispatch (array start end)
  (declare (optimize speed (safety 0)))
  (declare (type index start end))
  (subseq array start end))

(defun vector-subseq* (sequence start end)
  (declare (type vector sequence))
  (declare (type index start)
           (type (or null index) end)
           (optimize speed))
  (with-array-data ((data sequence)
                    (start start)
                    (end end)
                    :check-fill-pointer t
                    :force-inline t)
    (vector-subseq-dispatch data start end)))

To slightly complicate matters, the current MAP-INTO is kludgy. With
that kludginess fixed[1], a basic MAP-INTO benchmark drops from 385ms
to 227ms. When we add widetag dispatching[2][3] on top of that fix, it
goes from 227ms to 110ms.

However it's not clear whether it is appropriate to do this
optimization inside SBCL since a time/space trade-off is involved. Is
an 86K core size increase (uncompressed) worth it? This is only for
MAP-INTO.

Of course, if a user wants performance then he should be using
declarations with the open-coded MAP-INTO. But there are still cases
where declarations can't easily be made, my own situation being one of
them.

It would be nice to have something like

(defmacro with-declared-array-type (array &body body)
  (check-type array symbol)
  `(typecase ,array
     ,< at >(loop
          :for saetp
  :across sb-vm:*specialized-array-element-type-properties*
          :collect `((simple-array ,(sb-vm:saetp-specifier saetp))
                     ,< at >body))
     (otherwise
      ,< at >body)))

available in userland. This would make it easier to do such
optimizations without depending upon internals. Ideally it would have
constant lookup, although the linear search with TYPEP is quick enough
for most purposes.

(Out of curiosity I implemented WITH-DECLARED-ARRAY-TYPE using a
stack-allocated vector of FLET functions, but this was slower than
TYPECASE even for the worst-case TYPEP search. A fast
WITH-DECLARED-ARRAY-TYPE seems possible in principle, though it would
presumably require new special operator(s) and/or magic.)

Getting back to SBCL innards, considering that SUBSEQ and FILL already
use widetag dispatch there may be another place which would benefit
from it. If so then [2] will help. If not then it may be needless
abstraction.

[1] 0001-fix-MAP-INTO-performance.patch -- same as bug #1001043

[2] 0002-automate-widetag-dispatching.patch

[3] 0003-widetag-dispatch-for-MAP-INTO.patch -- needs [1]
------------------------------------------------------------------------------
Live Security Virtual Conference
Exclusive live event will cover all the ways today's security and 
threat landscape has changed and how IT managers can respond. Discussions 
will include endpoint security, mobile security and the latest in malware 
threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/_______________________________________________
Sbcl-devel mailing list
Sbcl-devel< at >lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/sbcl-devel

BUG: incorrect results from LOGAND (AMD64)

Eric Marsden — 2012-05-23T12:01:08

Hi,


* (lisp-implementation-version)
"1.0.57.15-35f68f4"
* (defun foo (x)
    (declare (optimize (space 2))
             (type (integer 12417236377505266230 12417274239874990070) x))
    (logand 8459622733968096971 x))
FOO
* (foo 12417237222845306758)
11836165733894624898  ;; <-- incorrect
* (logand 8459622733968096971 12417237222845306758)
2612793697039849090
* (defun bar (x) 
    (declare (type (integer 22965360520649903105 22965361070405717069) x))
    (lognand 6936474818856893141 x))
BAR
* (bar 22965361070405716988)
#<unknown immediate object, lowtag=#b1, widetag=#x41 {FFFFFFEFFD4D3D41}>


(More random-integer testing.)

rudimentary escape analysis for NLXs [Was: master:lazy STACK-TOP-HINTs]

Nikodemus Siivola — 2012-05-22T19:43:14

...stuff...


Amusingly, it turned out that the TYPEP consing came from NLX value
cells as well. Rudimentary escape analysis is enough to sort this out.

I already committed the SIGNAL improvements, but would much appreciate
it if someone could find the time to review this one before I commit
it. I keep having the feeling I'm missing something obvious.

Non-loadable patch attached, apply on top of
9bc5da72887b15eb83500e16f05c3e42835476a3 or later.

With that setup, the example above should run without consing.

Cheers,

 -- Nikodemus
------------------------------------------------------------------------------
Live Security Virtual Conference
Exclusive live event will cover all the ways today's security and 
threat landscape has changed and how IT managers can respond. Discussions 
will include endpoint security, mobile security and the latest in malware 
threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/_______________________________________________
Sbcl-devel mailing list
Sbcl-devel< at >lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/sbcl-devel

package name for implicit generic function symbols

Cyrus Harmon — 2012-05-17T04:34:10

I'm always annoyed by messages like:

   Implicitly creating new generic function FOO.

scrolling by in my slime window. WTF is FOO? Well, the problem is that FOO is usually in the then-current package and so the package identifier isn't printed out. The following patch causes the package name to be printed in the STYLE-WARNING. Any objections to seeing this in the tree post-freeze?

thanks,

Cyrus


diff --git a/src/code/condition.lisp b/src/code/condition.lisp
index 3e7e84e..d0b7013 100644
--- a/src/code/condition.lisp
+++ b/src/code/condition.lisp
< at >< at > -1004,8 +1004,9 < at >< at > (define-condition implicit-generic-function-warning (style-warning)
   ((name :initarg :name :reader implicit-generic-function-name))
   (:report
    (lambda (condition stream)
-     (format stream "~< at ><Implicitly creating new generic function ~S.~:< at >>"
-             (implicit-generic-function-name condition)))))
+     (let ((*package* (find-package :keyword)))
+       (format stream "~< at ><Implicitly creating new generic function ~S.~:< at >>"
+               (implicit-generic-function-name condition))))))
 
 (define-condition extension-failure (reference-condition simple-error)
   ())


------------------------------------------------------------------------------
Live Security Virtual Conference
Exclusive live event will cover all the ways today's security and 
threat landscape has changed and how IT managers can respond. Discussions 
will include endpoint security, mobile security and the latest in malware 
threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/

SBCL compiler bug? Overzealous optimization?

Patrick Stein — 2012-05-16T00:59:42

In looking over the errors generated by a cl-test-grid run, I looked
into the trivial-backtrace test that was failing. [1] I think that
I've uncovered a subtle bug in the SBCL compiler.

    [1] http://cl-test-grid.appspot.com/blob?key=100025

I'm using almost-the-latest SBCL (1.0.55.0-abb03f9-dirty) compiled for
64-bit with threading on MacOSX Lion (10.7.3).

This is the simplest I can seem to get the same problem to arise is
this:

    (defun absorbs ()
      (let ((ret 'no-error))
        (handler-case
            (let ((y 0))
              (/ y))
          (division-by-zero (c) (setf ret c)))
        ret))

When that compiles, it gives no warnings.  When invoked, it returns
NO-ERROR.

This, on the other hand, gives me a warning at compile time and
returns an instance of the division-by-zero error when invoked.

    (defun throws ()
      (let ((ret 'no-error))
        (handler-case
            (let* ((y 0)
                   (z (/ y)))
              z)
          (division-by-zero (c) (setf ret c)))
        ret))

Here is the compile time "style" warning.

    ;  Lisp error during constant folding:
    ;  arithmetic error DIVISION-BY-ZERO signalled
    ;  Operation was SB-KERNEL::DIVISION, operands (1 0).

I spent some time trying to track it down.  I started with the
:TRACE-FILE option to COMPILE-FILE.  The first place that they differ
materially is here:

    absorbs.trace:165-169
      IR1 block 11 start c104
      start stack: dv94 dv86 dv82 dv68 dv60
      104>     entry NIL
      end stack: dv94 dv86 dv82 dv68 dv60
      successors c105

    throws.trace:165-173
      IR1 block 11 start c104
      start stack: dv94 dv86 dv82 dv68 dv60
      104>     entry NIL
      105>106: / {GLOBAL-FUNCTION}
      107>108: '1
      109>110: '0
      111>     full combination v106 v108 v110
      end stack: dv94 dv86 dv82 dv68 dv60
      successors c112

This makes me think that the ABSORBS function is optimizing away the
divide entirely.  I haven't been able to track down exactly why that
would be.  I suppose that I spent some time looking at how the #'/
clause was getting optimized in IR1-OPTIMIZE, but I didn't spend any
real time looking at how the HANDLER-CASE was getting optimized.

What I saw with the #'/ clause was that the (NODE-LVAR NODE) check in
this block was NIL for the ABSORBS case and an LVAR instance for the
THROWS case:

    (let ((attr (fun-info-attributes info)))
      (when (and (ir1-attributep attr foldable)
                 ;; KLUDGE: The next test could be made more sensitive,
                 ;; only suppressing constant-folding of functions with
                 ;; CALL attributes when they're actually passed
                 ;; function arguments. -- WHN 19990918
                 (not (ir1-attributep attr call))
                 (every #'constant-lvar-p args)
                 (node-lvar node))
        (constant-fold-call node)
        (return-from ir1-optimize-combination)))

I'm guessing that's just because the HANDLER-CASE's return value is
not the return value of the enclosing LET block.  Regardless, so it
isn't constant-folded.  Somehow or other, it eventually ends up
getting excised.  I'm assuming that also because it isn't the return
value of the enclosing LET block that something decides it can be
pruned.  But, I'm not seeing where that would be.

So... I present this here both to report the bug and for any tidbits
any of y'all would like to share about where the optimizer might be
mussing this one up.

Thanks,
Patrick


------------------------------------------------------------------------------
Live Security Virtual Conference
Exclusive live event will cover all the ways today's security and 
threat landscape has changed and how IT managers can respond. Discussions 
will include endpoint security, mobile security and the latest in malware 
threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/

freeze for 1.0.57

Juho Snellman — 2012-05-14T02:02:44

I'll try to release 1.0.57 sometime next weekend.

BUG: SB-VM::FAST-ASH-LEFT-MOD32/UNSIGNED=>UNSIGNED onPowerPC

Eric Marsden — 2012-05-13T11:01:11

Hi,

On PowerPC:


* (lisp-implementation-version)
"1.0.56.68-e0aff99"
*  (lambda (x)
     (declare (type (rational * 4) x))
     (logbitp x 122741952))
debugger invoked on a SIMPLE-ERROR:
  #<SB-C:TN t1> is not valid as the first argument to VOP:
  SB-VM::FAST-ASH-LEFT-MOD32/UNSIGNED=>UNSIGNED
Primitive type: T
SC restrictions:
  (SB-VM::UNSIGNED-REG)
The primitive type disallows these loadable SCs:
  (SB-VM::UNSIGNED-REG)


[From pfdietz's random-integer testing]

BUG: incorrect type checks on AMD64

Eric Marsden — 2012-05-10T07:22:16

Hi,

* (lisp-implementation-version)
"1.0.56.66-2892e35"
* (defun foo (x)
    (declare (optimize (speed 0) (space 0))
             (type (integer -228645653448155482 -228645653447928749) x))
    (floor 1.0 (the (integer -228645653448151677 -228645653448150900) x)))
FOO
* (foo -228645653448151381)
debugger invoked on a TYPE-ERROR in thread
#<THREAD "main thread" RUNNING {1002979243}>:
  The value -228645653448151381
  is not of type
    (INTEGER -228645653448151677 -228645653448150900).



[From pfdietz's random-integer testing]

Interface changes

Martin Cracauer — 2012-05-08T17:35:05

I would like to have a dialogue about how we want to deal with
interface changes, namely what we do when we remove or rename exported
symbols that are used in libraries and systems outside SBCL.

I started pushing *features* symbols to guide this in my personal
builds, I don't think this can be answer.  There'll be too many and
when I use an official build I crash and burn.

My toy has auto-recovery for this kind of change.  Code that
determines whether certain symbols are present, with the required
sugar to deal with names of possibly not yet existing packages.  It is
the ugliest code in my toy which probably takes it right to being
among the ugliest pieces of code this side of Saturn.

One straightforward solution is that we introduce *feature* symbols
but batch up interface changes so that we don't flood ourselves with
symbols.  :sbcl-api-1, :sbcl-api-2 ...

Pure interface changes without functionality changes could also have
third-party modules that translate.

Martin

wanted: sb-sequence docs

Nikodemus Siivola — 2012-05-04T11:30:23

https://bugs.launchpad.net/sbcl/+bug/994528

Just saying,

 -- Nikodemus

------------------------------------------------------------------------------
Live Security Virtual Conference
Exclusive live event will cover all the ways today's security and 
threat landscape has changed and how IT managers can respond. Discussions 
will include endpoint security, mobile security and the latest in malware 
threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
_______________________________________________
Sbcl-devel mailing list
Sbcl-devel< at >lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/sbcl-devel

Test for LP #936304 fails on x86.

Lutz Euler — 2012-04-30T21:01:38

Hi,

I see the test for bug #936304 in "gc.impure.lisp" fail on x86.
Did I miss a discussion about this or am I the first one to notice?

Tested on 64-bit Linux with the following x86 SBCLs:
  sbcl-1.0.56-7-g6b1b11a
  sbcl-1.0.56-55-gf0da2f6
I have not tested earlier versions.

sbcl-1.0.56-7-g6b1b11a is the commit "gencgc: reclaim space more
aggressively", which claims that it fixed this bug and introduced
the test for it.

Greetings,

Lutz

------------------------------------------------------------------------------
Live Security Virtual Conference
Exclusive live event will cover all the ways today's security and 
threat landscape has changed and how IT managers can respond. Discussions 
will include endpoint security, mobile security and the latest in malware 
threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/

SBCL build times with modified optimization qualities

Lutz Euler — 2012-04-29T18:05:44

Hi,

following up the discussion in #sbcl, I measured the times on
my system. Here are the results:

All tests were done with version 1.0.56.52, x86-64, Linux.

The fast version differs as follows:

diff --git a/make-host-2.lisp b/make-host-2.lisp
index 72ce598..c57381d 100644
< at >< at > -15,7 +15,7 < at >< at >
   (let ((debug (if (position :sb-show *shebang-features*) 2 1)))
     (sb-xc:proclaim
      `(optimize
-       (compilation-speed 1) (debug ,debug)
+       (compilation-speed 0) (debug ,debug)
        ;; CLISP's pretty-printer is fragile and tends to cause stack
        ;; corruption or fail internal assertions, as of 2003-04-20; we
        ;; therefore turn off as many notes as possible.
< at >< at > -23,7 +23,7 < at >< at >
        ;; SAFETY = SPEED (and < 3) should provide reasonable safety,
        ;; but might skip some unreasonably expensive stuff
        ;; (e.g. %DETECT-STACK-EXHAUSTION in sbcl-0.7.2).
-       (safety 2) (space 1) (speed 2)
+       (safety 0) (space 0) (speed 3)
        ;; sbcl-internal optimization declarations:
        ;;
        ;; never insert stepper conditions

All times are "elapsed" wall clock time, rounded to full seconds,
from the "time" calls in make.sh. The "total" row is according to
the "//build started/finished" output at the end of make.sh.

1: current building current
2: current building fast
3: fast building fast

                             1       2       3
-----------------------------------------------
make-host-1.sh            1:06    1:06    0:53
make-target-1.sh          0:07    0:07    0:07
make-host-2.sh            2:28    2:04    1:52
make-target-2.sh          0:14    0:11    0:11
make-target-contrib.sh    0:36    0:30    0:31

total                     4:29    3:58    3:34

Greetings,

Lutz

------------------------------------------------------------------------------
Live Security Virtual Conference
Exclusive live event will cover all the ways today's security and 
threat landscape has changed and how IT managers can respond. Discussions 
will include endpoint security, mobile security and the latest in malware 
threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/

RES size growing when consing garbage

Nikodemus Siivola — 2012-04-28T15:31:16

Below a small test-case. Run it with --dynamic-space-size 8Gb, and
observe how the resident memory size keeps growing. The issue is that
we don't release memory back to the OS after nursery collections --
and indeed doing that would be pretty expensive.

Though this, as far as I can tell, is actually not a regression, Stas
(and someone else too, IIRC), however, has reported similar behaviour
as a regression since

commit 6b1b11a6c51e1c29aee947f1fde7f91651ca3763
Author: Nikodemus Siivola <nikodemus< at >random-state.net>
Date:   Sat Mar 31 00:56:44 2012 +0300

    gencgc: reclaim space more aggressively

...but I so far lack a test-case that demonstrates this.

So, if you have a test-case that demonstrates a regression in SBCL's
RES growing for no apparent good cause, please let me know!

The test-case below behaves apparently identically with current HEAD
and ones prior to the commit above. SBCL's *between* the commit above
and

commit 31103f174118c5e30087b26447cf33515627f9c4
Author: Nikodemus Siivola <nikodemus< at >random-state.net>
Date:   Sat Apr 14 11:08:45 2012 +0300

    gencgc: tune the recent "more aggressive GC" changes

misbehave terribly this test, though -- but ones after the latter one
behave effectively identically to say 1.0.55.

Re. the misbehaviour with the test-case below. I have a couple of
tentative fixes for it. One is to remap after every N nursery
collections if there have been no intervening larger collections.
Another is to trigger a remap depending on the number of bytes
released by GCs. Both seem reasonable heuristics, but I'm looking into
actually keeping track of the exact number of pages eligible for
release to the OS, which is a bit hairier, but a much better basis for
the decision than heuristics.

Cheers,

 -- nikodemus

(require :sb-posix)

(defun xterm-status-hook (proc)
  (when (member (process-status proc) '(:exited :signaled))
    (quit :unix-status 0 :recklessly-p t)))

(run-program "xterm" (list "-e" (format nil "top -b -p~S | tee
top.log" (sb-posix:getpid)))
             :search t :wait nil :status-hook 'xterm-status-hook)

(setf (bytes-consed-between-gcs) (* 400 1024 1024))

(defun test (n)
  (loop repeat n count (evenp (length (make-list 100000)))))

(loop
  (write-char #\.)
  (finish-output)
  (test 10000))

Cheers,

 -- Nikodemus

------------------------------------------------------------------------------
Live Security Virtual Conference
Exclusive live event will cover all the ways today's security and 
threat landscape has changed and how IT managers can respond. Discussions 
will include endpoint security, mobile security and the latest in malware 
threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/
_______________________________________________
Sbcl-devel mailing list
Sbcl-devel< at >lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/sbcl-devel

Reading a slot after condition-wait

James M. Lawrence — 2012-04-25T17:30:57

Defined below is the promise-bug:run function which

* fails on SBCL 1.0.55.0.debian obtained by `apt-get install sbcl';

* succeeds on SBCL 1.0.55.0.debian when `force' is a defun instead of
  a defmethod;

* succeeds on SBCL 1.0.55.0 and 1.0.56.0 when manually compiled from
  source, regardless of the `force' definition.

In my case it either runs forever (not failing) or it fails
immediately. If the former happens, re-launch SBCL and recompile
promise-bug.lisp.

In addition to my own reproduction of the problem, I have two other
bug reports which are likely to be the issue distilled in
promise-bug.lisp.

* 4-core Linux machine, specs unknown.
* 4-core Gentoo, https://gist.github.com/2490445
* 4-core Ubuntu 12.04 (my box), https://gist.github.com/2490520

I was not able to reproduce on a 2-core Mac running Linux in
VirtualBox, or with native Darwin SBCL on the same machine.

I experimented with adding various barriers to `force', though the
assertion failure persisted.

Noticing the zlib reference in Ubuntu's SBCL, I compiled SBCL with
core compression but wasn't able to reproduce the problem.

Of course there's always the possibility that I misunderstand
something about condition variables.

==== promise-bug.lisp

(defpackage :promise-bug (:use :cl :sb-thread) (:export :run))
(in-package :promise-bug)

(defparameter *thread-count* 10)

(defstruct promise
  (result 'no-result)
  (mutex (make-mutex))
  (cvar (make-waitqueue)))

(defgeneric force (object))

(defmethod force ((promise promise))
  (with-mutex ((promise-mutex promise))
    (assert (eq 'no-result (promise-result promise)))
    (condition-wait (promise-cvar promise) (promise-mutex promise))
    (assert (eq 'foo (promise-result promise)))
    (condition-notify (promise-cvar promise))
    (promise-result promise)))

(defun test ()
  (let ((promise (make-promise)))
    ;; create threads which wait for the promise
    (loop
       :repeat *thread-count*
       :do (make-thread (lambda () (force promise))))

    ;; wait for threads to block (sloppy)
    (sleep 0.5)

    ;; set result and begin the notify cascade
    (with-mutex ((promise-mutex promise))
      (setf (promise-result promise) 'foo)
      (condition-notify (promise-cvar promise))))
  :ok)

(defun run ()
  (loop
     (test)
     (format t ".")))

==== outcome

The assertion (EQ 'PROMISE-BUG::FOO
                  (PROMISE-BUG::PROMISE-RESULT
                   PROMISE-BUG::PROMISE)) failed.
   [Condition of type SIMPLE-ERROR]

Restarts:
 0: [CONTINUE] Retry assertion.
 1: [TERMINATE-THREAD] Terminate this thread (#<THREAD RUNNING {C1A7A11}>)

Backtrace:
  0: (SB-KERNEL:ASSERT-ERROR (EQ 'PROMISE-BUG::FOO
(PROMISE-BUG::PROMISE-RESULT PROMISE-BUG::PROMISE)) NIL NIL)
  1: ((FLET SB-THREAD::WITH-MUTEX-THUNK :IN PROMISE-BUG::FORCE))
  2: ((FLET #:WITHOUT-INTERRUPTS-BODY-88894 :IN SB-THREAD::CALL-WITH-MUTEX))
  3: (SB-THREAD::CALL-WITH-MUTEX ..)
  4: ((SB-PCL::FAST-METHOD PROMISE-BUG::FORCE (PROMISE-BUG::PROMISE)) ..)
  5: ((FLET #:WITHOUT-INTERRUPTS-BODY-223578 :IN SB-THREAD:MAKE-THREAD))
  6: ((FLET SB-THREAD::WITH-MUTEX-THUNK :IN SB-THREAD:MAKE-THREAD))
  7: ((FLET #:WITHOUT-INTERRUPTS-BODY-88894 :IN SB-THREAD::CALL-WITH-MUTEX))
  8: (SB-THREAD::CALL-WITH-MUTEX ..)
  9: (SB-THREAD::INITIAL-THREAD-FUNCTION)
 10: ("foreign function: call_into_lisp")
 11: ("foreign function: funcall0")
 12: ("foreign function: new_thread_trampoline")
 13: ("foreign function: #xB7FB1D4C")

------------------------------------------------------------------------------
Live Security Virtual Conference
Exclusive live event will cover all the ways today's security and 
threat landscape has changed and how IT managers can respond. Discussions 
will include endpoint security, mobile security and the latest in malware 
threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/

thread deadlock (still)

Cyrus Harmon — 2012-04-25T14:17:49

Nikodemus,

I was all ready to declare your changes victorious and move on this morning, but I got the hang again. The test case that seems to trigger it is:

(asdf:test-system 'flexi-streams)

(after having deleted any previous fasls, of course).

But, I got another hang here:

...
; compiling (DEFCLASS FLEXI-OUTPUT-STREAM ...)
; compiling (DEFCLASS FLEXI-INPUT-STREAM ...)
; compiling (DEFCLASS FLEXI-IO-STREAM ...)
; compiling (DEFUN MAKE-FLEXI-STREAM ...)

which is the usual spot. listing the threads gives us:

(sb-thread:list-all-threads)

(#<SB-THREAD:THREAD "repl-thread" waiting on:
      #<WAITQUEUE  {1004AE0CC3}>
    {1004AD8043}>
 #<SB-THREAD:THREAD "auto-flush-thread" waiting on:
      #<MUTEX "World Lock"
          owner: #<SB-THREAD:THREAD "repl-thread" waiting on: # {1004AD8043}>>
    {1004AD7DA3}>
 #<SB-THREAD:THREAD "swank-indentation-cache-thread" waiting on:
      #<WAITQUEUE  {1004080193}>
    {1004078313}>
 #<SB-THREAD:THREAD "reader-thread" RUNNING {1004078153}>
 #<SB-THREAD:THREAD "control-thread" waiting on:
      #<MUTEX "World Lock"
          owner: #<SB-THREAD:THREAD "repl-thread" waiting on: # {1004AD8043}>>
    {1004073453}>
 #<SB-THREAD:THREAD "Swank Sentinel" waiting on:
      #<WAITQUEUE  {1003D38103}>
    {1003D31C93}>
 #<SB-THREAD:THREAD "initial thread" RUNNING {1002978D93}>)

any further suggestions?

thanks,

Cyrus


------------------------------------------------------------------------------
Live Security Virtual Conference
Exclusive live event will cover all the ways today's security and 
threat landscape has changed and how IT managers can respond. Discussions 
will include endpoint security, mobile security and the latest in malware 
threats. http://www.accelacomm.com/jaw/sfrnl04242012/114/50122263/

Random floats

Mario S. Mommer — 2012-04-21T17:44:27

Hello,

I attach a patch that improves the quality of random floating point
number generation by ensuring that all the bits of the mantissa are
random. Currently, the lower bits of small numbers are biased.  A
description of the issue can be found on page 4 in this article:
<www.mathworks.com/moler/random.pdf>. My solution is similar to that of
[1], except that I do almost everything with bitwise operators.

One way to see the issue with the bias in the lower bits is to run the
mintest-d function included in the attached file testfrng.lisp. It
displays the bit pattern (sign, exponent, mantissa) of successively
smaller random numbers. The smaller the numbers, the more zeros you
will observe in the lower bits. If you run again the test with the
patch applied, you will see that all bits become random. If you run
(random 1.0d0) often enough with the patch applied, all possible
double-floats in [0,1) will eventually be generated, including the
subnormal ones.

I've tried to make sure that the speed of random number generation does
not degrade too much. On my computer, the FP RNGs become slower by
slightly less than 10%.

The testfrng.lisp file contains additional routines for playing with
this and testing that everything is ok by using the program ent [2].

Please let me know if you have any comments or questions.

Regards,
       Mario

[1] <http://www.home.hs-karlsruhe.de/~moth0001/forschung/Uniform%20and%20
Exponential%20Random%20Floating%20OR2007.pdf>

[2] <http://www.fourmilab.ch/random/>


(in-package :cl-user)

(defun disect-single-float (sfloat)
  (let* ((bb (sb-kernel:single-float-bits sfloat))
         (bb (if (>= bb 0) bb (+ (sb-kernel:single-float-bits (- sfloat))
                                 (expt 2 31))))
         (ss (format nil "~32,'0B" bb)))
    (values
     (format nil "|~A|~A|~A|"
             (subseq ss 0 1) (subseq ss 1 9) (subseq ss 9))
     sfloat)))


(defun disect-double-float (dfloat)
  (let* ((hb (sb-kernel::double-float-high-bits (* (signum dfloat) dfloat)))
         (lb (sb-kernel::double-float-low-bits dfloat))
         (num (+ (* (/ (+ (- (floor (signum dfloat))) 1) 2) (expt 2 63))
                 (* (expt 2 32) hb)
                 lb))
         (ss (format nil "~64,'0B" num)))
    (values
     (format nil "|~A|~A|~A|"
             (subseq ss 0 1) (subseq ss 1 12) (subseq ss 12))
     dfloat)))

(defun mintest-s ()
  (let ((min 1.0))
    (loop do
         (let ((n (sb-kernel::%random-single-float 1.0 *random-state*)))
           (when (< n min)
             (setf min n)
             (format t "~32,16,3E ~A~%" n (disect-single-float n)))))))

(defun mintest-d ()
  (let ((min 1.0d0))
    (loop do
         (let ((n (sb-kernel::%random-double-float 1.0d0 *random-state*)))
           (when (< n min)
             (setf min n)
             (format t "~32,16,3E ~A~%" n (disect-double-float n)))))))

;; The lowbits functions can be used to test the randomness of the low
;; bits by writing them to a file that can be passed to ent
(defun lowbits-s ()
  (with-open-file (ss "/tmp/randfile-please-delete-me"
                      :direction :output
                      :if-exists :supersede
                      :element-type '(unsigned-byte 8)
                      :if-does-not-exist :create)
    (loop for i from 0 below 50000000 do
         (write-byte
          (logand (sb-kernel::single-float-bits (random 1.0s0))
                  #.(- (expt 2 8) 1))
          ss))))

(defun lowbits-d ()
  (with-open-file (ss "/tmp/randfile-please-delete-me"
                      :direction :output
                      :if-exists :supersede
                      :element-type '(unsigned-byte 8)
                      :if-does-not-exist :create)
    (loop for i from 0 below 50000000 do
         (write-byte
          (logand (sb-kernel::double-float-low-bits (random 1.0d0))
                  #.(- (expt 2 8) 1))
          ss))))

(defun maxtest-d ()
  (let ((max 0.0d0))
    (loop do
         (let ((n (sb-kernel::%random-double-float pi *random-state*)))
           (when (> n max)
             (setf max n)
             (format t "~32,16,3E ~A~%" n (disect-double-float n)))))))

;; The fftest funcs test the uniformity of the random floats
(defun fftest-for-enc-single ()
  (with-open-file (ss "/tmp/randfile-please-delete-me"
                      :direction :output
                      :if-exists :supersede
                      :element-type '(unsigned-byte 8)
                      :if-does-not-exist :create)
    (loop for i from 0 below 50000000 do
         (write-byte
          (floor (sb-kernel:%random-single-float 256.0e0 *random-state*))
          ss))))

(defun fftest-for-enc-double ()
  (with-open-file (ss "/tmp/randfile-please-delete-me"
                      :direction :output
                      :if-exists :supersede
                      :element-type '(unsigned-byte 8)
                      :if-does-not-exist :create)
    (loop for i from 0 below 50000000 do
         (write-byte
          (floor (sb-kernel:%random-double-float 256.0d0 *random-state*))
          ss))))
------------------------------------------------------------------------------
For Developers, A Lot Can Happen In A Second.
Boundary is the first to Know...and Tell You.
Monitor Your Applications in Ultra-Fine Resolution. Try it FREE!
http://p.sf.net/sfu/Boundary-d2dvs2_______________________________________________
Sbcl-devel mailing list
Sbcl-devel< at >lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/sbcl-devel

my incomplete re-implementation of external-formatsfor sbcl

Nikodemus Siivola — 2012-04-20T22:27:11

I've been muttering about this on IRC for far too long now. Since it
seems I'm not going to have a chance to spend proper time on it for a
fair while yet, I'm putting it up in github so that others can take a
poke at it.

  https://github.com/nikodemus/sb-external-formats

It's nowhere near complete or ready. It's been almost a year since I
last touched it -- unless you count the cleanup pass to make it build
I just gave it -- so I'm probably not going to be able answer very
many questions about it off the top of my hat.

I'm not saying it's The Right Thing. That would presuppose that I
remember what it actually is. :) But I do remember that when I was
working on it I was definitely trying for the right thing, and keeping
it fast while at it. It's obviously not hooked into SBCL at all,
either.

Have fun. :)

Cheers,

 -- Nikodemus

------------------------------------------------------------------------------
For Developers, A Lot Can Happen In A Second.
Boundary is the first to Know...and Tell You.
Monitor Your Applications in Ultra-Fine Resolution. Try it FREE!
http://p.sf.net/sfu/Boundary-d2dvs2
_______________________________________________
Sbcl-devel mailing list
Sbcl-devel< at >lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/sbcl-devel

Debugging contrib modules

Robert Swindells — 2012-04-20T18:17:16

Is there any easy way to interactively load contrib modules in order to
debug them ?

I'm trying to find out why sb-bsd-sockets is failing on my system.

Robert Swindells

------------------------------------------------------------------------------
For Developers, A Lot Can Happen In A Second.
Boundary is the first to Know...and Tell You.
Monitor Your Applications in Ultra-Fine Resolution. Try it FREE!
http://p.sf.net/sfu/Boundary-d2dvs2

slime deadlock problems?

Cyrus Harmon — 2012-04-19T23:47:35

I'm seeing some deadlock problems trying to asdf:load-system flexi-streams from the SLIME REPL. I seem to recall noticing this a few weeks ago and I just ignored it. It only happens the first time this stuff gets compiled, I think, and it wasn't annoying enough to track down at the time. However, recent SBCLs seem to do something different, as now it hangs entirely. So, in an effort to track down the problem, I figured I'd start with this and see if it's at the root of the problem. A stack trace is shown below.

thanks,

Cyrus

When attempting 
* STYLE-WARNING: redefining SWANK::SYMBOL-INDENTATION in DEFUN
STYLE-WARNING: redefining SWANK::MACRO-INDENTATION in DEFUN
Help! 11 nested errors. SB-KERNEL:*MAXIMUM-ERROR-DEPTH* exceeded.
0: (SB-DEBUG::MAP-BACKTRACE #<CLOSURE (LAMBDA (SB-DEBUG::FRAME) :IN BACKTRACE) {100A91F35B}> :START 0 :COUNT 4611686018427387903)
1: (BACKTRACE 4611686018427387903 #<SYNONYM-STREAM :SYMBOL SB-SYS:*TTY* {100A91F013}>)
2: ((LAMBDA NIL :IN SB-IMPL::ERROR-ERROR))
3: (SB-IMPL::%WITH-STANDARD-IO-SYNTAX #<CLOSURE (LAMBDA NIL :IN SB-IMPL::ERROR-ERROR) {100A91F24B}>)
4: (SB-IMPL::ERROR-ERROR "Help! " 11 " nested errors. " "SB-KERNEL:*MAXIMUM-ERROR-DEPTH* exceeded.")
5: (SB-IMPL::INFINITE-ERROR-PROTECTOR)
6: (ERROR SB-THREAD:THREAD-DEADLOCK :THREAD #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> :CYCLE ((#1=#<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> . #<SB-THREAD:MUTEX "buffer write lock" owner: #2=#<SB-THREAD:THREAD "auto-flush-thread" waiting on: #3=#<MUTEX "World Lock" owner: #1#> {1010417DA3}>>) (#2# #3#)))
7: (SB-THREAD::CHECK-DEADLOCK)
8: (SB-THREAD::%WAIT-FOR-MUTEX #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> NIL NIL NIL NIL NIL NIL)
9: ((FLET #:WITHOUT-INTERRUPTS-BODY-89183 :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
10: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SWANK-BACKEND:CALL-WITH-LOCK-HELD) {725B3EB}> #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>>)
11: ((FLET SWANK-BACKEND:CALL-WITH-LOCK-HELD :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<CLOSURE (LAMBDA NIL :IN STREAM-WRITE-STRING) {100A91D02B}>)
12: ((SB-PCL::FAST-METHOD STREAM-WRITE-STRING (SWANK-BACKEND::SLIME-OUTPUT-STREAM T)) #<unused argument> #<unused argument> #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}> "Help! " 0 6)
13: (SB-IMPL::%WRITE-STRING "Help! " #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}> 0 6)
14: (SB-IMPL::%WRITE-STRING "Help! " #<TWO-WAY-STREAM :INPUT-STREAM #<SWANK-BACKEND::SLIME-INPUT-STREAM {1020D28203}> :OUTPUT-STREAM #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>> 0 NIL)
15: ((LABELS SB-IMPL::HANDLE-IT :IN SB-KERNEL:OUTPUT-OBJECT) #<TWO-WAY-STREAM :INPUT-STREAM #<SWANK-BACKEND::SLIME-INPUT-STREAM {1020D28203}> :OUTPUT-STREAM #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>>)
16: (PRINC "Help! " #<TWO-WAY-STREAM :INPUT-STREAM #<SWANK-BACKEND::SLIME-INPUT-STREAM {1020D28203}> :OUTPUT-STREAM #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>>)
17: ((LAMBDA NIL :IN SB-IMPL::ERROR-ERROR))
18: (SB-IMPL::%WITH-STANDARD-IO-SYNTAX #<CLOSURE (LAMBDA NIL :IN SB-IMPL::ERROR-ERROR) {100A91CFEB}>)
19: (SB-IMPL::ERROR-ERROR "Help! " 11 " nested errors. " "SB-KERNEL:*MAXIMUM-ERROR-DEPTH* exceeded.")
20: (SB-IMPL::INFINITE-ERROR-PROTECTOR)
21: (ERROR SB-THREAD:THREAD-DEADLOCK :THREAD #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> :CYCLE ((#1=#<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> . #<SB-THREAD:MUTEX "buffer write lock" owner: #2=#<SB-THREAD:THREAD "auto-flush-thread" waiting on: #3=#<MUTEX "World Lock" owner: #1#> {1010417DA3}>>) (#2# #3#)))
22: (SB-THREAD::CHECK-DEADLOCK)
23: (SB-THREAD::%WAIT-FOR-MUTEX #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> NIL NIL NIL NIL NIL NIL)
24: ((FLET #:WITHOUT-INTERRUPTS-BODY-89183 :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
25: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SWANK-BACKEND:CALL-WITH-LOCK-HELD) {725BB8B}> #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>>)
26: ((FLET SWANK-BACKEND:CALL-WITH-LOCK-HELD :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<CLOSURE (LAMBDA NIL :IN STREAM-FINISH-OUTPUT) {100A91CEEB}>)
27: ((SB-PCL::FAST-METHOD STREAM-FINISH-OUTPUT (SWANK-BACKEND::SLIME-OUTPUT-STREAM)) #<unavailable argument> #<unavailable argument> #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
28: (FORCE-OUTPUT #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
29: (FORCE-OUTPUT #<TWO-WAY-STREAM :INPUT-STREAM #<SWANK-BACKEND::SLIME-INPUT-STREAM {1020D28203}> :OUTPUT-STREAM #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>>)
30: (SWANK::DEBUG-IN-EMACS #<SB-THREAD:THREAD-DEADLOCK {100A91CAE3}>)
31: (SWANK:INVOKE-SLIME-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A91CAE3}>)
32: (SWANK-BACKEND::CALL-WITH-BREAK-HOOK #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91CE2B}>)
33: ((FLET SWANK-BACKEND:CALL-WITH-DEBUGGER-HOOK :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91CE2B}>)
34: (SWANK:SWANK-DEBUGGER-HOOK #<SB-THREAD:THREAD-DEADLOCK {100A91CAE3}> #<unavailable argument>)
35: (SB-DEBUG::RUN-HOOK *DEBUGGER-HOOK* #<SB-THREAD:THREAD-DEADLOCK {100A91CAE3}>)
36: (INVOKE-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A91CAE3}>)
37: (ERROR SB-THREAD:THREAD-DEADLOCK :THREAD #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> :CYCLE ((#1=#<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> . #<SB-THREAD:MUTEX "buffer write lock" owner: #2=#<SB-THREAD:THREAD "auto-flush-thread" waiting on: #3=#<MUTEX "World Lock" owner: #1#> {1010417DA3}>>) (#2# #3#)))
38: (SB-THREAD::CHECK-DEADLOCK)
39: (SB-THREAD::%WAIT-FOR-MUTEX #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> NIL NIL NIL NIL NIL NIL)
40: ((FLET #:WITHOUT-INTERRUPTS-BODY-89183 :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
41: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SWANK-BACKEND:CALL-WITH-LOCK-HELD) {725C44B}> #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>>)
42: ((FLET SWANK-BACKEND:CALL-WITH-LOCK-HELD :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<CLOSURE (LAMBDA NIL :IN STREAM-FINISH-OUTPUT) {100A91C9EB}>)
43: ((SB-PCL::FAST-METHOD STREAM-FINISH-OUTPUT (SWANK-BACKEND::SLIME-OUTPUT-STREAM)) #<unavailable argument> #<unavailable argument> #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
44: (FORCE-OUTPUT #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
45: (FORCE-OUTPUT #<TWO-WAY-STREAM :INPUT-STREAM #<SWANK-BACKEND::SLIME-INPUT-STREAM {1020D28203}> :OUTPUT-STREAM #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>>)
46: (SWANK::DEBUG-IN-EMACS #<SB-THREAD:THREAD-DEADLOCK {100A91C603}>)
47: (SWANK:INVOKE-SLIME-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A91C603}>)
48: (SWANK-BACKEND::CALL-WITH-BREAK-HOOK #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91C92B}>)
49: ((FLET SWANK-BACKEND:CALL-WITH-DEBUGGER-HOOK :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91C92B}>)
50: (SWANK:SWANK-DEBUGGER-HOOK #<SB-THREAD:THREAD-DEADLOCK {100A91C603}> #<unavailable argument>)
51: (SB-DEBUG::RUN-HOOK *DEBUGGER-HOOK* #<SB-THREAD:THREAD-DEADLOCK {100A91C603}>)
52: (INVOKE-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A91C603}>)
53: (ERROR SB-THREAD:THREAD-DEADLOCK :THREAD #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> :CYCLE ((#1=#<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> . #<SB-THREAD:MUTEX "buffer write lock" owner: #2=#<SB-THREAD:THREAD "auto-flush-thread" waiting on: #3=#<MUTEX "World Lock" owner: #1#> {1010417DA3}>>) (#2# #3#)))
54: (SB-THREAD::CHECK-DEADLOCK)
55: (SB-THREAD::%WAIT-FOR-MUTEX #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> NIL NIL NIL NIL NIL NIL)
56: ((FLET #:WITHOUT-INTERRUPTS-BODY-89183 :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
57: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SWANK-BACKEND:CALL-WITH-LOCK-HELD) {725CD0B}> #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>>)
58: ((FLET SWANK-BACKEND:CALL-WITH-LOCK-HELD :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<CLOSURE (LAMBDA NIL :IN STREAM-FINISH-OUTPUT) {100A91C50B}>)
59: ((SB-PCL::FAST-METHOD STREAM-FINISH-OUTPUT (SWANK-BACKEND::SLIME-OUTPUT-STREAM)) #<unavailable argument> #<unavailable argument> #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
60: (FORCE-OUTPUT #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
61: (FORCE-OUTPUT #<TWO-WAY-STREAM :INPUT-STREAM #<SWANK-BACKEND::SLIME-INPUT-STREAM {1020D28203}> :OUTPUT-STREAM #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>>)
62: (SWANK::DEBUG-IN-EMACS #<SB-THREAD:THREAD-DEADLOCK {100A91C143}>)
63: (SWANK:INVOKE-SLIME-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A91C143}>)
64: (SWANK-BACKEND::CALL-WITH-BREAK-HOOK #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91C44B}>)
65: ((FLET SWANK-BACKEND:CALL-WITH-DEBUGGER-HOOK :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91C44B}>)
66: (SWANK:SWANK-DEBUGGER-HOOK #<SB-THREAD:THREAD-DEADLOCK {100A91C143}> #<unavailable argument>)
67: (SB-DEBUG::RUN-HOOK *DEBUGGER-HOOK* #<SB-THREAD:THREAD-DEADLOCK {100A91C143}>)
68: (INVOKE-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A91C143}>)
69: (ERROR SB-THREAD:THREAD-DEADLOCK :THREAD #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> :CYCLE ((#1=#<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> . #<SB-THREAD:MUTEX "buffer write lock" owner: #2=#<SB-THREAD:THREAD "auto-flush-thread" waiting on: #3=#<MUTEX "World Lock" owner: #1#> {1010417DA3}>>) (#2# #3#)))
70: (SB-THREAD::CHECK-DEADLOCK)
71: (SB-THREAD::%WAIT-FOR-MUTEX #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> NIL NIL NIL NIL NIL NIL)
72: ((FLET #:WITHOUT-INTERRUPTS-BODY-89183 :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
73: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SWANK-BACKEND:CALL-WITH-LOCK-HELD) {725D5CB}> #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>>)
74: ((FLET SWANK-BACKEND:CALL-WITH-LOCK-HELD :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<CLOSURE (LAMBDA NIL :IN STREAM-FINISH-OUTPUT) {100A91C04B}>)
75: ((SB-PCL::FAST-METHOD STREAM-FINISH-OUTPUT (SWANK-BACKEND::SLIME-OUTPUT-STREAM)) #<unavailable argument> #<unavailable argument> #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
76: (FORCE-OUTPUT #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
77: (FORCE-OUTPUT #<TWO-WAY-STREAM :INPUT-STREAM #<SWANK-BACKEND::SLIME-INPUT-STREAM {1020D28203}> :OUTPUT-STREAM #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>>)
78: (SWANK::DEBUG-IN-EMACS #<SB-THREAD:THREAD-DEADLOCK {100A91BCA3}>)
79: (SWANK:INVOKE-SLIME-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A91BCA3}>)
80: (SWANK-BACKEND::CALL-WITH-BREAK-HOOK #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91BF8B}>)
81: ((FLET SWANK-BACKEND:CALL-WITH-DEBUGGER-HOOK :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91BF8B}>)
82: (SWANK:SWANK-DEBUGGER-HOOK #<SB-THREAD:THREAD-DEADLOCK {100A91BCA3}> #<unavailable argument>)
83: (SB-DEBUG::RUN-HOOK *DEBUGGER-HOOK* #<SB-THREAD:THREAD-DEADLOCK {100A91BCA3}>)
84: (INVOKE-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A91BCA3}>)
85: (ERROR SB-THREAD:THREAD-DEADLOCK :THREAD #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> :CYCLE ((#1=#<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> . #<SB-THREAD:MUTEX "buffer write lock" owner: #2=#<SB-THREAD:THREAD "auto-flush-thread" waiting on: #3=#<MUTEX "World Lock" owner: #1#> {1010417DA3}>>) (#2# #3#)))
86: (SB-THREAD::CHECK-DEADLOCK)
87: (SB-THREAD::%WAIT-FOR-MUTEX #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> NIL NIL NIL NIL NIL NIL)
88: ((FLET #:WITHOUT-INTERRUPTS-BODY-89183 :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
89: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SWANK-BACKEND:CALL-WITH-LOCK-HELD) {725DE8B}> #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>>)
90: ((FLET SWANK-BACKEND:CALL-WITH-LOCK-HELD :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<CLOSURE (LAMBDA NIL :IN STREAM-FINISH-OUTPUT) {100A91BBAB}>)
91: ((SB-PCL::FAST-METHOD STREAM-FINISH-OUTPUT (SWANK-BACKEND::SLIME-OUTPUT-STREAM)) #<unavailable argument> #<unavailable argument> #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
92: (FORCE-OUTPUT #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
93: (FORCE-OUTPUT #<TWO-WAY-STREAM :INPUT-STREAM #<SWANK-BACKEND::SLIME-INPUT-STREAM {1020D28203}> :OUTPUT-STREAM #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>>)
94: (SWANK::DEBUG-IN-EMACS #<SB-THREAD:THREAD-DEADLOCK {100A91B823}>)
95: (SWANK:INVOKE-SLIME-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A91B823}>)
96: (SWANK-BACKEND::CALL-WITH-BREAK-HOOK #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91BAEB}>)
97: ((FLET SWANK-BACKEND:CALL-WITH-DEBUGGER-HOOK :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91BAEB}>)
98: (SWANK:SWANK-DEBUGGER-HOOK #<SB-THREAD:THREAD-DEADLOCK {100A91B823}> #<unavailable argument>)
99: (SB-DEBUG::RUN-HOOK *DEBUGGER-HOOK* #<SB-THREAD:THREAD-DEADLOCK {100A91B823}>)
100: (INVOKE-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A91B823}>)
101: (ERROR SB-THREAD:THREAD-DEADLOCK :THREAD #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> :CYCLE ((#1=#<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> . #<SB-THREAD:MUTEX "buffer write lock" owner: #2=#<SB-THREAD:THREAD "auto-flush-thread" waiting on: #3=#<MUTEX "World Lock" owner: #1#> {1010417DA3}>>) (#2# #3#)))
102: (SB-THREAD::CHECK-DEADLOCK)
103: (SB-THREAD::%WAIT-FOR-MUTEX #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> NIL NIL NIL NIL NIL NIL)
104: ((FLET #:WITHOUT-INTERRUPTS-BODY-89183 :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
105: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SWANK-BACKEND:CALL-WITH-LOCK-HELD) {725E74B}> #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>>)
106: ((FLET SWANK-BACKEND:CALL-WITH-LOCK-HELD :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<CLOSURE (LAMBDA NIL :IN STREAM-FINISH-OUTPUT) {100A91B72B}>)
107: ((SB-PCL::FAST-METHOD STREAM-FINISH-OUTPUT (SWANK-BACKEND::SLIME-OUTPUT-STREAM)) #<unavailable argument> #<unavailable argument> #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
108: (FORCE-OUTPUT #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
109: (FORCE-OUTPUT #<TWO-WAY-STREAM :INPUT-STREAM #<SWANK-BACKEND::SLIME-INPUT-STREAM {1020D28203}> :OUTPUT-STREAM #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>>)
110: (SWANK::DEBUG-IN-EMACS #<SB-THREAD:THREAD-DEADLOCK {100A91B3C3}>)
111: (SWANK:INVOKE-SLIME-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A91B3C3}>)
112: (SWANK-BACKEND::CALL-WITH-BREAK-HOOK #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91B66B}>)
113: ((FLET SWANK-BACKEND:CALL-WITH-DEBUGGER-HOOK :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91B66B}>)
114: (SWANK:SWANK-DEBUGGER-HOOK #<SB-THREAD:THREAD-DEADLOCK {100A91B3C3}> #<unavailable argument>)
115: (SB-DEBUG::RUN-HOOK *DEBUGGER-HOOK* #<SB-THREAD:THREAD-DEADLOCK {100A91B3C3}>)
116: (INVOKE-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A91B3C3}>)
117: (ERROR SB-THREAD:THREAD-DEADLOCK :THREAD #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> :CYCLE ((#1=#<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> . #<SB-THREAD:MUTEX "buffer write lock" owner: #2=#<SB-THREAD:THREAD "auto-flush-thread" waiting on: #3=#<MUTEX "World Lock" owner: #1#> {1010417DA3}>>) (#2# #3#)))
118: (SB-THREAD::CHECK-DEADLOCK)
119: (SB-THREAD::%WAIT-FOR-MUTEX #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> NIL NIL NIL NIL NIL NIL)
120: ((FLET #:WITHOUT-INTERRUPTS-BODY-89183 :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
121: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SWANK-BACKEND:CALL-WITH-LOCK-HELD) {725F00B}> #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>>)
122: ((FLET SWANK-BACKEND:CALL-WITH-LOCK-HELD :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<CLOSURE (LAMBDA NIL :IN STREAM-FINISH-OUTPUT) {100A91B2CB}>)
123: ((SB-PCL::FAST-METHOD STREAM-FINISH-OUTPUT (SWANK-BACKEND::SLIME-OUTPUT-STREAM)) #<unavailable argument> #<unavailable argument> #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
124: (FORCE-OUTPUT #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
125: (FORCE-OUTPUT #<TWO-WAY-STREAM :INPUT-STREAM #<SWANK-BACKEND::SLIME-INPUT-STREAM {1020D28203}> :OUTPUT-STREAM #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>>)
126: (SWANK::DEBUG-IN-EMACS #<SB-THREAD:THREAD-DEADLOCK {100A91AF83}>)
127: (SWANK:INVOKE-SLIME-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A91AF83}>)
128: (SWANK-BACKEND::CALL-WITH-BREAK-HOOK #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91B20B}>)
129: ((FLET SWANK-BACKEND:CALL-WITH-DEBUGGER-HOOK :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91B20B}>)
130: (SWANK:SWANK-DEBUGGER-HOOK #<SB-THREAD:THREAD-DEADLOCK {100A91AF83}> #<unavailable argument>)
131: (SB-DEBUG::RUN-HOOK *DEBUGGER-HOOK* #<SB-THREAD:THREAD-DEADLOCK {100A91AF83}>)
132: (INVOKE-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A91AF83}>)
133: (ERROR SB-THREAD:THREAD-DEADLOCK :THREAD #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> :CYCLE ((#1=#<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> . #<SB-THREAD:MUTEX "buffer write lock" owner: #2=#<SB-THREAD:THREAD "auto-flush-thread" waiting on: #3=#<MUTEX "World Lock" owner: #1#> {1010417DA3}>>) (#2# #3#)))
134: (SB-THREAD::CHECK-DEADLOCK)
135: (SB-THREAD::%WAIT-FOR-MUTEX #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> NIL NIL NIL NIL NIL NIL)
136: ((FLET #:WITHOUT-INTERRUPTS-BODY-89183 :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
137: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SWANK-BACKEND:CALL-WITH-LOCK-HELD) {725F8CB}> #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>>)
138: ((FLET SWANK-BACKEND:CALL-WITH-LOCK-HELD :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<CLOSURE (LAMBDA NIL :IN STREAM-FINISH-OUTPUT) {100A91AE8B}>)
139: ((SB-PCL::FAST-METHOD STREAM-FINISH-OUTPUT (SWANK-BACKEND::SLIME-OUTPUT-STREAM)) #<unavailable argument> #<unavailable argument> #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
140: (FORCE-OUTPUT #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
141: (FORCE-OUTPUT #<TWO-WAY-STREAM :INPUT-STREAM #<SWANK-BACKEND::SLIME-INPUT-STREAM {1020D28203}> :OUTPUT-STREAM #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>>)
142: (SWANK::DEBUG-IN-EMACS #<SB-THREAD:THREAD-DEADLOCK {100A91AB63}>)
143: (SWANK:INVOKE-SLIME-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A91AB63}>)
144: (SWANK-BACKEND::CALL-WITH-BREAK-HOOK #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91ADCB}>)
145: ((FLET SWANK-BACKEND:CALL-WITH-DEBUGGER-HOOK :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91ADCB}>)
146: (SWANK:SWANK-DEBUGGER-HOOK #<SB-THREAD:THREAD-DEADLOCK {100A91AB63}> #<unavailable argument>)
147: (SB-DEBUG::RUN-HOOK *DEBUGGER-HOOK* #<SB-THREAD:THREAD-DEADLOCK {100A91AB63}>)
148: (INVOKE-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A91AB63}>)
149: (ERROR SB-THREAD:THREAD-DEADLOCK :THREAD #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> :CYCLE ((#1=#<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> . #<SB-THREAD:MUTEX "buffer write lock" owner: #2=#<SB-THREAD:THREAD "auto-flush-thread" waiting on: #3=#<MUTEX "World Lock" owner: #1#> {1010417DA3}>>) (#2# #3#)))
150: (SB-THREAD::CHECK-DEADLOCK)
151: (SB-THREAD::%WAIT-FOR-MUTEX #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> NIL NIL NIL NIL NIL NIL)
152: ((FLET #:WITHOUT-INTERRUPTS-BODY-89183 :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
153: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SWANK-BACKEND:CALL-WITH-LOCK-HELD) {726018B}> #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>>)
154: ((FLET SWANK-BACKEND:CALL-WITH-LOCK-HELD :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<CLOSURE (LAMBDA NIL :IN STREAM-FINISH-OUTPUT) {100A91AA6B}>)
155: ((SB-PCL::FAST-METHOD STREAM-FINISH-OUTPUT (SWANK-BACKEND::SLIME-OUTPUT-STREAM)) #<unavailable argument> #<unavailable argument> #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
156: (FORCE-OUTPUT #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
157: (FORCE-OUTPUT #<TWO-WAY-STREAM :INPUT-STREAM #<SWANK-BACKEND::SLIME-INPUT-STREAM {1020D28203}> :OUTPUT-STREAM #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>>)
158: (SWANK::DEBUG-IN-EMACS #<SB-THREAD:THREAD-DEADLOCK {100A91A763}>)
159: (SWANK:INVOKE-SLIME-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A91A763}>)
160: (SWANK-BACKEND::CALL-WITH-BREAK-HOOK #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91A9AB}>)
161: ((FLET SWANK-BACKEND:CALL-WITH-DEBUGGER-HOOK :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91A9AB}>)
162: (SWANK:SWANK-DEBUGGER-HOOK #<SB-THREAD:THREAD-DEADLOCK {100A91A763}> #<unavailable argument>)
163: (SB-DEBUG::RUN-HOOK *DEBUGGER-HOOK* #<SB-THREAD:THREAD-DEADLOCK {100A91A763}>)
164: (INVOKE-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A91A763}>)
165: (ERROR SB-THREAD:THREAD-DEADLOCK :THREAD #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> :CYCLE ((#1=#<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> . #<SB-THREAD:MUTEX "buffer write lock" owner: #2=#<SB-THREAD:THREAD "auto-flush-thread" waiting on: #3=#<MUTEX "World Lock" owner: #1#> {1010417DA3}>>) (#2# #3#)))
166: (SB-THREAD::CHECK-DEADLOCK)
167: (SB-THREAD::%WAIT-FOR-MUTEX #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> NIL NIL NIL NIL NIL NIL)
168: ((FLET #:WITHOUT-INTERRUPTS-BODY-89183 :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
169: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SWANK-BACKEND:CALL-WITH-LOCK-HELD) {7260A4B}> #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>>)
170: ((FLET SWANK-BACKEND:CALL-WITH-LOCK-HELD :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<CLOSURE (LAMBDA NIL :IN STREAM-FINISH-OUTPUT) {100A91A66B}>)
171: ((SB-PCL::FAST-METHOD STREAM-FINISH-OUTPUT (SWANK-BACKEND::SLIME-OUTPUT-STREAM)) #<unavailable argument> #<unavailable argument> #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
172: (FORCE-OUTPUT #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
173: (FORCE-OUTPUT #<TWO-WAY-STREAM :INPUT-STREAM #<SWANK-BACKEND::SLIME-INPUT-STREAM {1020D28203}> :OUTPUT-STREAM #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>>)
174: (SWANK::DEBUG-IN-EMACS #<SB-THREAD:THREAD-DEADLOCK {100A91A353}>)
175: (SWANK:INVOKE-SLIME-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A91A353}>)
176: (SWANK-BACKEND::CALL-WITH-BREAK-HOOK #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91A5AB}>)
177: ((FLET SWANK-BACKEND:CALL-WITH-DEBUGGER-HOOK :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91A5AB}>)
178: (SWANK:SWANK-DEBUGGER-HOOK #<SB-THREAD:THREAD-DEADLOCK {100A91A353}> #<unavailable argument>)
179: (SB-DEBUG::RUN-HOOK *DEBUGGER-HOOK* #<SB-THREAD:THREAD-DEADLOCK {100A91A353}>)
180: (INVOKE-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A91A353}>)
181: (ERROR SB-THREAD:THREAD-DEADLOCK :THREAD #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> :CYCLE ((#1=#<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> . #<SB-THREAD:MUTEX "buffer write lock" owner: #2=#<SB-THREAD:THREAD "auto-flush-thread" waiting on: #3=#<MUTEX "World Lock" owner: #1#> {1010417DA3}>>) (#2# #3#)))
182: (SB-THREAD::CHECK-DEADLOCK)
183: (SB-THREAD::%WAIT-FOR-MUTEX #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> NIL NIL NIL NIL NIL NIL)
184: ((FLET #:WITHOUT-INTERRUPTS-BODY-89183 :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
185: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SWANK-BACKEND:CALL-WITH-LOCK-HELD) {726130B}> #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>>)
186: ((FLET SWANK-BACKEND:CALL-WITH-LOCK-HELD :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<CLOSURE (LAMBDA NIL :IN STREAM-FINISH-OUTPUT) {100A91A25B}>)
187: ((SB-PCL::FAST-METHOD STREAM-FINISH-OUTPUT (SWANK-BACKEND::SLIME-OUTPUT-STREAM)) #<unavailable argument> #<unavailable argument> #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
188: (FORCE-OUTPUT #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>)
189: (FORCE-OUTPUT #<TWO-WAY-STREAM :INPUT-STREAM #<SWANK-BACKEND::SLIME-INPUT-STREAM {1020D28203}> :OUTPUT-STREAM #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>>)
190: (SWANK::DEBUG-IN-EMACS #<SB-THREAD:THREAD-DEADLOCK {100A919A33}>)
191: (SWANK:INVOKE-SLIME-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A919A33}>)
192: (SWANK-BACKEND::CALL-WITH-BREAK-HOOK #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91A16B}>)
193: ((FLET SWANK-BACKEND:CALL-WITH-DEBUGGER-HOOK :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK:SWANK-DEBUGGER-HOOK) {100A91A16B}>)
194: (SWANK:SWANK-DEBUGGER-HOOK #<SB-THREAD:THREAD-DEADLOCK {100A919A33}> #<unavailable argument>)
195: (SB-DEBUG::RUN-HOOK *DEBUGGER-HOOK* #<SB-THREAD:THREAD-DEADLOCK {100A919A33}>)
196: (INVOKE-DEBUGGER #<SB-THREAD:THREAD-DEADLOCK {100A919A33}>)
197: (ERROR SB-THREAD:THREAD-DEADLOCK :THREAD #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> :CYCLE ((#1=#<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> . #<SB-THREAD:MUTEX "buffer write lock" owner: #2=#<SB-THREAD:THREAD "auto-flush-thread" waiting on: #3=#<MUTEX "World Lock" owner: #1#> {1010417DA3}>>) (#2# #3#)))
198: (SB-THREAD::CHECK-DEADLOCK)
199: (SB-THREAD::%WAIT-FOR-MUTEX #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> NIL NIL NIL NIL NIL NIL)
200: ((FLET #:WITHOUT-INTERRUPTS-BODY-89183 :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
201: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SWANK-BACKEND:CALL-WITH-LOCK-HELD) {7261BCB}> #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>>)
202: ((FLET SWANK-BACKEND:CALL-WITH-LOCK-HELD :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<SB-THREAD:MUTEX "buffer write lock" owner: #<SB-THREAD:THREAD "auto-flush-thread" waiting on: #<MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> {1010417DA3}>> #<CLOSURE (LAMBDA NIL :IN STREAM-FRESH-LINE) {100A91993B}>)
203: (SB-FORMAT::&-FORMAT-DIRECTIVE-INTERPRETER #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}> #<~&> ("Test " #<~S> " failed signalling error of type " #<~A> ": " #<~A> "." #<~%>) #<unavailable argument> #<unavailable argument>)
204: (SB-FORMAT::INTERPRET-DIRECTIVE-LIST #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}> (#<~&> "Test " #<~S> " failed signalling error of type " #<~A> ": " #<~A> "." #<~%>) ((STRING= (FLEXI-STREAMS-TEST::OLD-OCTETS-TO-STRING FLEXI-STREAMS-TEST::OCTETS-VECTOR :EXTERNAL-FORMAT FLEXI-STREAMS-TEST::EXTERNAL-FORMAT) STRING) TYPE-ERROR #<TYPE-ERROR expected-type: (MEMBER NIL T) datum: 0>) ((STRING= (FLEXI-STREAMS-TEST::OLD-OCTETS-TO-STRING FLEXI-STREAMS-TEST::OCTETS-VECTOR :EXTERNAL-FORMAT FLEXI-STREAMS-TEST::EXTERNAL-FORMAT) STRING) TYPE-ERROR #<TYPE-ERROR expected-type: (MEMBER NIL T) datum: 0>))
205: (SB-FORMAT::%FORMAT #<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}> "~&Test ~S failed signalling error of type ~A: ~A.~%" ((STRING= (FLEXI-STREAMS-TEST::OLD-OCTETS-TO-STRING FLEXI-STREAMS-TEST::OCTETS-VECTOR :EXTERNAL-FORMAT FLEXI-STREAMS-TEST::EXTERNAL-FORMAT) STRING) TYPE-ERROR #<TYPE-ERROR expected-type: (MEMBER NIL T) datum: 0>) ((STRING= (FLEXI-STREAMS-TEST::OLD-OCTETS-TO-STRING FLEXI-STREAMS-TEST::OCTETS-VECTOR :EXTERNAL-FORMAT FLEXI-STREAMS-TEST::EXTERNAL-FORMAT) STRING) TYPE-ERROR #<TYPE-ERROR expected-type: (MEMBER NIL T) datum: 0>))
206: (FORMAT T "~&Test ~S failed signalling error of type ~A: ~A.~%" (STRING= (FLEXI-STREAMS-TEST::OLD-OCTETS-TO-STRING FLEXI-STREAMS-TEST::OCTETS-VECTOR :EXTERNAL-FORMAT FLEXI-STREAMS-TEST::EXTERNAL-FORMAT) STRING) TYPE-ERROR #<TYPE-ERROR expected-type: (MEMBER NIL T) datum: 0>)
207: ((FLET FLEXI-STREAMS-TEST::FAIL :IN FLEXI-STREAMS-TEST::STRING-TESTS) "~&Test ~S failed signalling error of type ~A: ~A.~%" (STRING= (FLEXI-STREAMS-TEST::OLD-OCTETS-TO-STRING FLEXI-STREAMS-TEST::OCTETS-VECTOR :EXTERNAL-FORMAT FLEXI-STREAMS-TEST::EXTERNAL-FORMAT) STRING) TYPE-ERROR #<TYPE-ERROR expected-type: (MEMBER NIL T) datum: 0>)
208: (FLEXI-STREAMS-TEST::STRING-TESTS :VERBOSE NIL)
209: (FLEXI-STREAMS-TEST:RUN-ALL-TESTS :VERBOSE NIL)
210: ((SB-PCL::EMF ASDF:PERFORM) #<unavailable argument> #<unavailable argument> #<ASDF:TEST-OP NIL {101045F273}> #<ASDF:SYSTEM "flexi-streams">)
211: ((SB-PCL::FAST-METHOD ASDF::PERFORM-WITH-RESTARTS :AROUND (T T)) #<unavailable argument> #S(SB-PCL::FAST-METHOD-CALL :FUNCTION #<FUNCTION (SB-PCL::FAST-METHOD ASDF::PERFORM-WITH-RESTARTS #)> :PV NIL :NEXT-METHOD-CALL NIL :ARG-INFO (2)) #<ASDF:TEST-OP NIL {101045F273}> #<ASDF:SYSTEM "flexi-streams">)
212: ((LAMBDA NIL :IN ASDF::PERFORM-PLAN))
213: ((FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SB-C::%WITH-COMPILATION-UNIT))
214: ((FLET #:WITHOUT-INTERRUPTS-BODY-89183 :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
215: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SB-C::%WITH-COMPILATION-UNIT) {726291B}> #<SB-THREAD:MUTEX "World Lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>>)
216: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
217: ((SB-PCL::FAST-METHOD ASDF::PERFORM-PLAN (LIST)) #<unused argument> #<unused argument> ((#1=#<ASDF:COMPILE-OP NIL {1020D71B33}> . #2=#<ASDF:CL-SOURCE-FILE #3="trivial-gray-streams" "package">) (#<ASDF:LOAD-OP NIL {1020D71DA3}> . #2#) (#1# . #4=#<ASDF:CL-SOURCE-FILE #3# "mixin">) (#1# . #5=#<ASDF:SYSTEM #3#>) (#6=#<ASDF:LOAD-OP NIL {1020E149C3}> . #4#) (#6# . #5#) (#7=#<ASDF:COMPILE-OP NIL {1010966B83}> . #8=#<ASDF:CL-SOURCE-FILE #9="flexi-streams" "packages">) (#<ASDF:LOAD-OP NIL {1020E14A63}> . #8#) (#7# . #10=#<ASDF:CL-SOURCE-FILE #9# "mapping">) (#<ASDF:LOAD-OP NIL {1020E14A83}> . #10#) (#7# . #11=#<ASDF:CL-SOURCE-FILE #9# "ascii">) (#<ASDF:LOAD-OP NIL {1020E14AA3}> . #11#) (#7# . #12=#<ASDF:CL-SOURCE-FILE #9# "koi8-r">) (#<ASDF:LOAD-OP NIL {1020E14AC3}> . #12#) (#7# . #13=#<ASDF:C
 L-SOURCE-FILE #9# "iso-8859">) (#<ASDF:LOAD-OP NIL {1020E14AE3}> . #13#) (#7# . #14=#<ASDF:CL-SOURCE-FILE #9# "code-pages">) (#<ASDF:LOAD-OP NIL {1020E14B03}> . #14#) (#7# . #15=#<ASDF:CL-SOURCE-FILE #9# "specials">) (#<ASDF:LOAD-OP NIL {1020E14B23}> . #15#) (#7# . #16=#<ASDF:CL-SOURCE-FILE #9# "util">) (#<ASDF:LOAD-OP NIL {1020E14B43}> . #16#) (#7# . #17=#<ASDF:CL-SOURCE-FILE #9# "conditions">) (#<ASDF:LOAD-OP NIL {1020E14B63}> . #17#) (#7# . #18=#<ASDF:CL-SOURCE-FILE #9# "external-format">) (#<ASDF:LOAD-OP NIL {1020E14B83}> . #18#) (#7# . #19=#<ASDF:CL-SOURCE-FILE #9# "length">) (#<ASDF:LOAD-OP NIL {1020E14BA3}> . #19#) (#7# . #20=#<ASDF:CL-SOURCE-FILE #9# "encode">) (#<ASDF:LOAD-OP NIL {1020E14BC3}> . #20#) (#7# . #21=#<ASDF:CL-SOURCE-FILE #9# "decode">) (#<ASDF:LOAD-OP NIL {1020E14BE
 3}> . #21#) (#7# . #22=#<ASDF:CL-SOURCE-FILE #9# "in-memory">) (#<ASDF:LOAD-OP NIL {1020E14C03}> . #22#) (#7# . #23=#<ASDF:CL-SOURCE-FILE #9# "stream">) (#<ASDF:LOAD-OP NIL {1020E14C23}> . #23#) (#7# . #24=#<ASDF:CL-SOURCE-FILE #9# "output">) (#<ASDF:LOAD-OP NIL {1020E14C43}> . #24#) (#7# . #25=#<ASDF:CL-SOURCE-FILE #9# "input">) (#<ASDF:LOAD-OP NIL {1020E14C63}> . #25#) (#7# . #26=#<ASDF:CL-SOURCE-FILE #9# "io">) (#<ASDF:LOAD-OP NIL {1020E14C83}> . #26#) (#7# . #27=#<ASDF:CL-SOURCE-FILE #9# "strings">) (#7# . #28=#<ASDF:SYSTEM #9#>) (#29=#<ASDF:LOAD-OP NIL {1010960AD3}> . #27#) (#29# . #28#) (#30=#<ASDF:TEST-OP NIL {101045F273}> . #8#) (#30# . #10#) (#30# . #11#) (#30# . #12#) (#30# . #13#) (#30# . #14#) (#30# . #15#) (#30# . #16#) (#30# . #17#) (#30# . #18#) (#30# . #19#) (#30# . #20#)
  (#30# . #21#) (#30# . #22#) (#30# . #23#) (#30# . #24#) (#30# . #25#) (#30# . #26#) (#30# . #27#) (#30# . #28#)))
218: ((LAMBDA NIL :IN ASDF:OPERATE))
219: (ASDF::CALL-WITH-SYSTEM-DEFINITIONS #<CLOSURE (LAMBDA NIL :IN ASDF:OPERATE) {101045E8FB}>)
220: ((SB-PCL::FAST-METHOD ASDF:OPERATE (T T)) #<unused argument> #<unused argument> ASDF:TEST-OP FLEXI-STREAMS)
221: ((SB-PCL::EMF ASDF:OPERATE) #<unused argument> #<unused argument> ASDF:TEST-OP FLEXI-STREAMS)
222: (ASDF:TEST-SYSTEM FLEXI-STREAMS)
223: (SB-INT:SIMPLE-EVAL-IN-LEXENV (ASDF:TEST-SYSTEM (QUOTE FLEXI-STREAMS)) #<NULL-LEXENV>)
224: (EVAL (ASDF:TEST-SYSTEM (QUOTE FLEXI-STREAMS)))
225: (SWANK::EVAL-REGION "(asdf:test-system 'flexi-streams)
")
226: ((LAMBDA NIL :IN SWANK::REPL-EVAL))
227: (SWANK::TRACK-PACKAGE #<CLOSURE (LAMBDA NIL :IN SWANK::REPL-EVAL) {101045E3FB}>)
228: (SWANK::CALL-WITH-RETRY-RESTART "Retry SLIME REPL evaluation request." #<CLOSURE (LAMBDA NIL :IN SWANK::REPL-EVAL) {101045E31B}>)
229: (SWANK::CALL-WITH-BUFFER-SYNTAX NIL #<CLOSURE (LAMBDA NIL :IN SWANK::REPL-EVAL) {101045E2EB}>)
230: (SWANK::REPL-EVAL "(asdf:test-system 'flexi-streams)
")
231: (SB-INT:SIMPLE-EVAL-IN-LEXENV (SWANK:LISTENER-EVAL "(asdf:test-system 'flexi-streams)
") #<NULL-LEXENV>)
232: (EVAL (SWANK:LISTENER-EVAL "(asdf:test-system 'flexi-streams)
"))
233: (SWANK:EVAL-FOR-EMACS (SWANK:LISTENER-EVAL "(asdf:test-system 'flexi-streams)
") "COMMON-LISP-USER" 4)
234: (SWANK::PROCESS-REQUESTS NIL)
235: ((LAMBDA NIL :IN SWANK::HANDLE-REQUESTS))
236: ((LAMBDA NIL :IN SWANK::HANDLE-REQUESTS))
237: (SWANK-BACKEND::CALL-WITH-BREAK-HOOK #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK::HANDLE-REQUESTS) {101042011B}>)
238: ((FLET SWANK-BACKEND:CALL-WITH-DEBUGGER-HOOK :IN "/Users/sly/.emacs.d/site-lisp/slime/swank-sbcl.lisp") #<FUNCTION SWANK:SWANK-DEBUGGER-HOOK> #<CLOSURE (LAMBDA NIL :IN SWANK::HANDLE-REQUESTS) {101042011B}>)
239: (SWANK::CALL-WITH-BINDINGS ((*STANDARD-OUTPUT* . #1=#<SWANK-BACKEND::SLIME-OUTPUT-STREAM {1010400243}>) (*STANDARD-INPUT* . #2=#<SWANK-BACKEND::SLIME-INPUT-STREAM {1020D28203}>) (*TRACE-OUTPUT* . #1#) (*ERROR-OUTPUT* . #1#) (*DEBUG-IO* . #3=#<TWO-WAY-STREAM :INPUT-STREAM #2# :OUTPUT-STREAM #1#>) (*QUERY-IO* . #3#) (*TERMINAL-IO* . #3#)) #<CLOSURE (LAMBDA NIL :IN SWANK::HANDLE-REQUESTS) {101042013B}>)
240: (SWANK::HANDLE-REQUESTS #<SWANK::MULTITHREADED-CONNECTION {100FB39C83}> NIL)
241: ((FLET #:WITHOUT-INTERRUPTS-BODY-237707 :IN SB-THREAD:MAKE-THREAD))
242: ((FLET SB-THREAD::WITH-MUTEX-THUNK :IN SB-THREAD:MAKE-THREAD))
243: ((FLET #:WITHOUT-INTERRUPTS-BODY-89154 :IN SB-THREAD::CALL-WITH-MUTEX))
244: (SB-THREAD::CALL-WITH-MUTEX #<CLOSURE (FLET SB-THREAD::WITH-MUTEX-THUNK :IN SB-THREAD:MAKE-THREAD) {7263D0B}> #<SB-THREAD:MUTEX "thread result lock" owner: #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}>> #<SB-THREAD:THREAD "repl-thread" RUNNING {1010418023}> T)
245: (SB-THREAD::INITIAL-THREAD-FUNCTION)
246: ("foreign function: call_into_lisp")
247: ("foreign function: new_thread_trampoline")
248: ("foreign function: _pthread_start")
249: ("foreign function: thread_start")
; 
; compilation unit aborted
;   caught 1 fatal ERROR condition
;   printed 1262 notes


------------------------------------------------------------------------------
For Developers, A Lot Can Happen In A Second.
Boundary is the first to Know...and Tell You.
Monitor Your Applications in Ultra-Fine Resolution. Try it FREE!
http://p.sf.net/sfu/Boundary-d2dvs2

sbcl-1.0.56-x86-binary-solaris-tar.bz2 corrupted

Mark Evenson — 2012-04-19T11:35:00

The binary distribution of sbcl-1.0.56 for solaris-x86 seems to be corrupted.

bunzip2 gives up with a "Compressed file ends unexpectedly" message.

evenson< at >saturn:~/Downloads$  ls -l sbcl-1.0.56-x86-solaris-binary.tar.bz2
-rw-r--r-- 1 evenson evenson 2457600 2012-04-19 13:15 
sbcl-1.0.56-x86-solaris-binary.tar.bz2
evenson< at >saturn:~/Downloads$ sha256sum sbcl-1.0.56-x86-solaris-binary.tar.bz2
6b235c8b3b75c0a370948eb519699f8978770492078d784c61876f9290d51c9f  
sbcl-1.0.56-x86-solaris-binary.tar.bz2

Recent breakage in OpenBSD/PPC

Bruce O'Neel — 2012-04-16T17:55:55

Hi,

The change below breaks OpenBSD/PPC.  It does not break Darwin/PPC, nor OpenBSD/x86 or OpenBSD/AMD64.

I've attached a log from a broken build, and, a log from a patched build.  I've also attached the
world's silliest patch since all it does is remove part of the commit below.

If someone has an idea I'm happy to debug and explore more.  I don't understand the bit of code
that is broken and haven't gotten very far to understand why it is broken.

Thanks.

bruce


commit 52b1041d3a14eaa4e45f6d8edfbdc0dec4292239
Author: Christophe Rhodes <csr21< at >cantab.net>
Date:   Thu Apr 5 19:55:05 2012 +0100

    Fix bug in unsigned modular arithmetic using a signed implementation
    
    If we aim to be clever by implementing an unsigned modular arithmetic
    computation using signed arithmetic, we need to make sure that we
    don't accidentally contaminate the computation with any extraneous
    high bits.  This means that we must be sure to cut constants to the
    appropriate width, as well as computations, so do so; this fixes
    bug #974406 from Paul Dietz.  (In addition the change from cutting
    to the requested width to the implementation width fixes #903821,
    so Go Team!)
    
    Test cases.  Minimally horrible test case for #903821; far worse
    suggestions were made on #sbcl IRC...


diff --git a/src/compiler/srctran.lisp b/src/compiler/srctran.lisp
index 09842e9..670fe84 100644
--- a/src/compiler/srctran.lisp
+++ b/src/compiler/srctran.lisp
< at >< at > -3042,6 +3042,7 < at >< at >
                (setf (block-reoptimize (node-block node)) t)
                (reoptimize-component (node-component node) :maybe))
              (cut-node (node &aux did-something)
+#!-(and openbsd ppc)
                (when (and (not (block-delete-p (node-block node)))
                           (ref-p node)
                           (constant-p (ref-leaf node)))
------------------------------------------------------------------------------
Better than sec? Nothing is better than sec when it comes to
monitoring Big Data applications. Try Boundary one-second 
resolution app monitoring today. Free.
http://p.sf.net/sfu/Boundary-dev2dev_______________________________________________
Sbcl-devel mailing list
Sbcl-devel< at >lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/sbcl-devel