anchor.diff:            (return-from grab-task task))))))
   
   (defvar *worker-id* nil)
  +(defvar *current-queue* nil)
   
   (defun %make-worker (wqueue i)
     (let* ((lock   (queue-lock   wqueue))
  
positive.code:           (t
             (enqueue queue task)))))
  
  (defun push-self-all (queue tasks)
    (declare (type queue queue))
    (assert (alive-p queue))
    (let ((id *worker-id*))
  
negative.code:          (stack  (aref stacks i))
           (hint   (float (/ i (queue-nthread wqueue)) 1d0)))
      (make-thread
       (lambda (&aux (*worker-id* i) (*current-queue* wqueue))
         (loop named outer do
           (let* ((timeout 1e-4)
                  (task
                    (with-mutex (lock)
                      (loop
                        (when (eql (car state) :done)
                          (return-from outer))
                        (let ((task (grab-task queue stacks i)))
                          (when task
                            (return task)))
                        (condition-wait cvar lock :timeout timeout)
                        (when (< timeout 1e0)
                          (setf timeout (* timeout 2)))))))
             (declare (type single-float timeout))
             (if (bulk-task-p task)
                 (work-stack:push stack task hint)
                 (work-stack:execute-task task))
  