anchor.diff:                  ,@body))
               (defun/wrapper ,name ,(unchecked-name name) ,params
                 ,@(unsplice docstring)
  -              (let ((kernel (check-kernel)))
  -                (,',call-impl kernel)))
  +              (,',call-impl (check-kernel)))
               (eval-when (:load-toplevel :execute)
                 (register-fn ',name))
               ',name)))))
   
  -(defmacro call-impl-in-worker (kernel)
  +(defmacro/once call-impl-in-worker (&once kernel)
     (with-gensyms (worker channel)
       `(let ((,worker *worker*))
          (if ,worker
  
positive.code: 
  (locally (declare #.*full-optimize*)
    (defslots task-counter ()
      ((count              :initform 0 :type fixnum)
       (lock  :reader lock :initform (make-lock)))))
  
  (setf *make-optimizer-data* 'make-task-counter-instance)
  
  (defmacro accept-task-p (kernel)
    (check-type kernel symbol)
  
negative.code: (defmacro define-update-task-count/no-lock (name op)
    `(defun/type ,name (kernel delta) (kernel fixnum) t
       (declare #.*full-optimize*)
       (with-optimizer-slots ((accept-task-p optimizer-flag)
                              (task-counter optimizer-data)) kernel
         (with-task-counter-slots (count) task-counter
           (incf count delta)
           ;; `<=' returns generalized boolean
           (setf accept-task-p
                 (to-boolean (<= count (the fixnum (,op kernel)))))))))
  
  (macrolet ((n-workers   (k) `(%kernel-worker-count ,k))
  