anchor.diff:           (return :timeout))
          (setf timeout (min 1.0 (* timeout 1.1)))))))
   
  +(declaim (inline %worker-loop))
  +(defun %worker-loop (weak-queue index hint &optional poll-function wait-time)
  +  (flet ((poll ()
  +           (let ((x (funcall poll-function)))
  +             (when x (return-from %worker-loop x)))))
  +    (declare (inline poll))
  +    (let* ((wait-time (and poll-function (or wait-time 1)))
  +           (wqueue    (or (weak-pointer-value weak-queue)
  +                          (return-from %worker-loop)))
  +           (i         index)
  +           (state     (queue-state  wqueue))
  +           (cvar      (queue-cvar   wqueue))
  +           (locks     (queue-locks  wqueue))
  +           (queue     (queue-queue  wqueue))
  +           (stacks    (queue-stacks wqueue))
  +           (stack     (aref stacks i))
  +           (task      (loop-get-task state (aref locks i) cvar
  +                                     queue stacks i
  +                                     wait-time)))
  +      (unless (and task queue)
  +        (return-from %worker-loop))
  +      (if poll-function
  +          (poll)
  +          (assert (not (eq task :timeout))))
  +      (if (bulk-task-p task)
  +          (work-stack:push stack task hint)
  +          (work-stack:execute-task task))
  +      (loop while (progn
  +                    (when poll-function
  +                      (poll))
  +                    (work-stack:run-one stack))
  +            do (when (eq (car state) :done)
  +                 (return-from %worker-loop)))
  +      (setf queue nil))))
  +
   (defun %make-worker (wqueue i &optional binding-names binding-compute)
  -  (let* ((locks  (queue-locks  wqueue))
  -         (cvar   (queue-cvar   wqueue))
  -         (state  (queue-state  wqueue))
  -         (queue  (queue-queue  wqueue))
  -         (stacks (queue-stacks wqueue))
  +  (declare (type queue wqueue))
  +  (let* ((state  (queue-state  wqueue))
            (nthread (queue-nthread wqueue))
  -         (stack  (aref stacks i))
            (hint   (float (/ i nthread) 1d0))
            (weak-queue (make-weak-pointer wqueue)))
       (make-thread
  
positive.code:                   (let ((value (funcall condition)))
                      (when value (return-from progress-until value))))
                  (inner ()
                    (let ((task  (loop-get-task state (aref locks i) cvar
                                                queue stacks i
                                                wait-time))
                          (queue (weak-pointer-value weak-queue)))
                      (unless (and task (not (eql task :timeout))
                                   queue)
                        (go retry))
                      (if (bulk-task-p task)
                          (work-stack:push stack task hint)
                          (work-stack:execute-task task))
                      (loop while (progn
                                    (check)
                                    (work-stack:run-one stack))
                            do
                               (when (eq (car state) :done)
                                 (return-from progress-until)))
                      (setf queue nil))))
           (declare (notinline inner)
                    (inline check))
           (check)
           (inner)
           (sb-sys:scrub-control-stack)
           (go retry)))))
  
  (defun make (nthread &optional constructor &rest arguments)
    (declare (type (and unsigned-byte fixnum) nthread)
  
negative.code:        (progv binding-names (mapcar (lambda (x)
                                        (if (functionp x) (funcall x) x))
                                      binding-compute)
           (loop
             (flet ((inner ()
                      (%worker-loop weak-queue i hint)))
               (declare (notinline inner))
               (inner)
               (sb-sys:scrub-control-stack)
               (when (eq (car state) :done)
                 (return))))))
       :name (format nil "Work queue worker ~A/~A" i nthread))))
  
  (defun progress-until (condition)
    (let* ((condition (if (functionp condition)
                          condition (fdefinition condition)))
           (i         (worker-id))
           (weak-queue *current-queue*)
           (state     (queue-state
                       (or (current-queue)
                           (error "Not in recursive wait?!"))))
           (wait-time 1d-3))
      (tagbody
         retry
         (if (< wait-time 1)
  