anchor.diff:  
   (defun unmake-watcher (watcher)
     (assert (null (watcher-watched-objects watcher)))
  -  (with-snapshot-inhibited ()
  -    (with-mutex (*watcher-pool-lock*)
  -      (when (< *watcher-watcher-pool-size* *watcher-watcher-pool-limit*)
  -        (incf *watcher-watcher-pool-size*)
  -        (setf (watcher-name watcher) 'pooled-watcher) ; don't leak the old name
  -        (shiftf (watcher-watched-objects watcher)
  -                *watcher-watcher-pool*
  -                watcher)))))
  +  (setf (watcher-name watcher) 'pooled-watcher) ; don't leak the old name
  +  (object-pool-push *watcher-watcher-pool* watcher))
   
   (defun make-watcher-event-monitor (watcher object event)
     "Create a new event watcher monitor."
     ;; Structured so that CONS-IN-AREA isn't called inside the pool lock.
     (flet ((pop-pool ()
  -           (with-snapshot-inhibited ()
  -             (with-mutex (*watcher-pool-lock*)
  -               (let ((monitor *watcher-monitor-pool*))
  -                 (cond (monitor
  -                        (setf *watcher-monitor-pool* (watcher-event-monitor-watcher monitor))
  -                        (decf *watcher-monitor-pool-size*)
  -                        (setf (watcher-event-monitor-watcher monitor) watcher
  -                              (watcher-event-monitor-event monitor) event
  -                              (watcher-event-monitor-object monitor) object)
  -                        (incf *watcher-pool-hit-count*)
  -                        monitor)
  -                       (t
  -                        (incf *watcher-pool-miss-count*)
  -                        nil)))))))
  +           (let ((monitor (object-pool-pop *watcher-monitor-pool*)))
  +             (when monitor
  +               (setf (watcher-event-monitor-watcher monitor) watcher
  +                     (watcher-event-monitor-event monitor) event
  +                     (watcher-event-monitor-object monitor) object)
  +               monitor))))
       (declare (dynamic-extent #'pop-pool))
       (or (pop-pool)
           (%make-watcher-event-monitor watcher object event))))
   
   (defun unmake-watcher-event-monitor (monitor)
  -  (with-snapshot-inhibited ()
  -    (with-mutex (*watcher-pool-lock*)
  -      (when (< *watcher-monitor-pool-size* *watcher-monitor-pool-limit*)
  -        (incf *watcher-monitor-pool-size*)
  -        ;; Don't leak objects.
  -        (setf (car (watcher-event-monitor-result-cons monitor)) nil
  -              (cdr (watcher-event-monitor-result-cons monitor)) nil
  -              (watcher-event-monitor-object monitor) nil
  -              (watcher-event-monitor-event monitor) nil
  -              (watcher-event-monitor-watcher monitor) nil
  -              (watcher-event-monitor-event-next monitor) nil
  -              (watcher-event-monitor-watcher-next monitor) nil)
  -        (shiftf (watcher-event-monitor-watcher monitor)
  -                *watcher-monitor-pool*
  -                monitor)))))
  +  ;; Don't leak objects.
  +  (setf (car (watcher-event-monitor-result-cons monitor)) nil
  +        (cdr (watcher-event-monitor-result-cons monitor)) nil
  +        (watcher-event-monitor-object monitor) nil
  +        (watcher-event-monitor-event monitor) nil
  +        (watcher-event-monitor-watcher monitor) nil
  +        (watcher-event-monitor-event-next monitor) nil
  +        (watcher-event-monitor-watcher-next monitor) nil)
  +  (object-pool-push *watcher-monitor-pool* monitor))
   
   (defun watcher-add-object (object watcher)
     "Begin watching a new object.
  
positive.code:              (release-place-spinlock *big-wait-for-objects-lock*)
               (%reschedule-via-wired-stack sp fp))))))
  
  ;;; Event/object watcher.
  ;;;
  ;;; This is a generalization of WAIT-FOR-OBJECTS that allows users
  
negative.code: (defun make-watcher (&key name)
    "Create a new event watcher."
    ;; Structured so that CONS-IN-AREA isn't called inside the pool lock.
    (flet ((pop-pool ()
             (let ((watcher (object-pool-pop *watcher-watcher-pool*)))
               (when watcher
                 (setf (watcher-name watcher) name
                       (watcher-watched-objects watcher) nil)
                 watcher))))
      (declare (dynamic-extent #'pop-pool))
      (or (pop-pool)
          (%make-watcher name))))
  