anchor.diff:  (defvar *all-threads*)
   
   (defvar *world-stop-lock*)
  -(defvar *world-stop-resume-cvar*)
  -(defvar *world-stop-pa-exit-cvar*)
  +(defvar *world-stop-cvar*)
   (defvar *world-stop-pending*)
   (defvar *world-stopper*)
   (defvar *pseudo-atomic-thread-count*)
  
positive.code:            (setf *world-stop-pending* self)
             (return))
           ;; Wait for the world to unstop.
           (condition-wait *world-stop-resume-cvar* *world-stop-lock*))
        ;; Now wait for any PA threads to finish.
        (loop
           (when (zerop *pseudo-atomic-thread-count*)
             (setf *world-stopper* self
                   *world-stop-pending* nil)
             (return))
           (condition-wait *world-stop-pa-exit-cvar* *world-stop-lock*)))
      ;; Don't hold the mutex over the thunk, it's a spinlock and disables interrupts.
      (multiple-value-prog1
          (funcall thunk)
        (with-mutex (*world-stop-lock*)
          ;; Release the dogs!
          (setf *world-stopper* nil)
          (condition-notify *world-stop-resume-cvar*)))))
  
  (defmacro with-world-stopped (&body body)
    `(call-with-world-stopped (dx-lambda () ,@body)))
  
negative.code:   (reset-ephemeral-thread sys.int::*snapshot-thread* #'snapshot-thread :sleeping)
    (reset-ephemeral-thread sys.int::*pager-thread* #'pager-thread :runnable)
    (reset-ephemeral-thread sys.int::*disk-io-thread* #'disk-thread :runnable)
    (condition-notify *world-stop-cvar*))
  
  (defun wake-thread (thread)
    "Wake a sleeping thread."
  