anchor.diff:  (defun make-watcher (&key name)
     "Create a new event watcher."
     ;; Structured so that CONS-IN-AREA isn't called inside the pool lock.
  -  ;; Snapshot should be inhibited so that the lock is never held at the
  -  ;; start of boot.
     (flet ((pop-pool ()
  -           (with-snapshot-inhibited ()
  -             (with-mutex (*watcher-pool-lock*)
  -               (let ((watcher *watcher-watcher-pool*))
  -                 (cond (watcher
  -                        (setf *watcher-watcher-pool* (watcher-watched-objects watcher))
  -                        (decf *watcher-watcher-pool-size*)
  -                        (setf (watcher-name watcher) name
  -                              (watcher-watched-objects watcher) nil)
  -                        (incf *watcher-pool-hit-count*)
  -                        watcher)
  -                       (t
  -                        (incf *watcher-pool-miss-count*)
  -                        nil)))))))
  +           (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))))
  
positive.code: 
  (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)))))
  
  (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)))))))
      (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)))))
  
  (defun watcher-add-object (object watcher)
    "Begin watching a new object.
  
negative.code: ;; Object pools are used for watcher & associated structures.
  ;; This is to reduce allocation in the wired area which is
  ;; very slow, and GCing the wired area requires a full GC cycle.
  (sys.int::defglobal *watcher-watcher-pool*
      (make-object-pool '*watcher-watcher-pool* 1000
                        #'watcher-watched-objects #'(setf watcher-watched-objects)))
  (sys.int::defglobal *watcher-monitor-pool*
      (make-object-pool '*watcher-monitor-pool* 1000
                        #'watcher-event-monitor-watcher #'(setf watcher-event-monitor-watcher)))
  
  (defstruct (watcher
               (:constructor %make-watcher (name))
  