anchor.diff:    (when (or force (not *timer*))
       (setf *timer*
   	  (make-timer 
  -	   :cv-lock (make-lock)
  -	   :cv (make-condition-variable)
  -	   :cv-wait 0
  +	   :empty-cv (make-cv)
  +	   :fair-cv (make-cv 
  +		     :accum t
  +		     :accum-max 1
  +		     :notified 1)
  +	   :last-time 0
   	   :queue (make-queue :type 'priority-cqueue
   			      :compare (lambda (x y)
   					 (< (timer-event-time x)
   					    (timer-event-time y)))))
   	  (timer-thread *timer*) (make-thread #'timer-handling))
  -    ;; Wait for the new thread to initiate
  -    (timer-wait)
       t))
   
   ;;; ----------------------------------------------------------------------------
  
positive.code: 		  (timer-event-fn event))
  		 (make-thread (timer-event-fn event)))
  	     t)))
      (let ((*in-scope?* nil)
  	  (first t))
        (loop
  	 (catch 'interrupt
  	   ;; When constructing a timer thread, the constructor waits on the cv
  	   ;; one time, to give this function time to set up
  	   (when first (timer-notify) (setf first nil))
  	   (cond ((plusp (qsize (timer-queue *timer*)))
  		  (let (event)
  		    (unwind-protect
  
negative.code: 
  (defun set-timer (fn time &optional new-thread)
    (ensure-timer-thread)
    (cv-wait (timer-fair-cv *timer*)
  	   (lambda ()
  	     (and (> (get-internal-real-time)
  		     (+ (timer-last-time *timer*)
  			(secs2i .0001)))
  		  (zerop (cv-count *current-cv*)))))
    (let ((event (make-timer-event
  		:fn fn
  		:thread (unless new-thread (current-thread))
  		:time (+ (secs2i time)
  			 (get-internal-real-time)))))
      (multiple-value-bind (ign node)
  	(qpush (timer-queue *timer*) event)
        (declare (ignore ign))
        (cv-notify (timer-empty-cv *timer*))
        (interrupt-thread (timer-thread *timer*) #'%int-thrower)
        (values event node))))
  
  ;;; ----------------------------------------------------------------------------
  
  (defun remove-timer (timer)
    (ensure-timer-thread)
    (let ((node
  	 (if (queue-node-p timer)
  	     timer
  	     (block search
  	       (queue-find (timer-queue *timer*)
  			   (lambda (x)
  			     (when (eq x timer)
  			       (return-from search
  				 *current-queue-node*))))))))
        (when node
  	(queue-delete (timer-queue *timer*) node)
  	timer)))
  