anchor.diff:  ;;; generation, we move A and its transitive closure to an older
   ;;; generation.
   
  -;;; We trace the live objects and we obtain a bitvector (or
  -;;; equivalent) of information about what words in the nursery are
  -;;; live and what words are dead.  We want to compact the nursery by
  -;;; "sliding" the live objects towards lower indexes of the nursery.
  -;;; Since we are moving objects, any address that points to an object
  -;;; in the nursery that is going to be moved needs to be modified to
  -;;; reflect the motion.  The amount that an object is moved is
  -;;; determined by the total free space before it in the nursery. 
  +;;; We trace the live objects and we obtain a bitvector (though not
  +;;; represented as a Common Lisp bitvector) of information about what
  +;;; words in the nursery are live and what words are dead.  We want to
  +;;; compact the nursery by "sliding" the live objects towards lower
  +;;; indexes of the nursery.  Since we are moving objects, any address
  +;;; that points to an object in the nursery that is going to be moved
  +;;; needs to be modified to reflect the motion.  The amount that an
  +;;; object is moved is determined by the total free space before it in
  +;;; the nursery.
   
   (defconstant +word-size+ 64)
   
  
positive.code: (defconstant +nursery-size+ (* +word-size+ (expt 2 12)))
  
  ;;; In each thread, this variable gets bound to a vector that contains
  ;;; the youngest generation objects.  An object takes up at least two
  ;;; words in the nursery, and objects are aligned on a double-word
  ;;; boundary.
  (defvar *nursery*)
  
  ;;; In each thread, this variable gets bound to a vector of words.
  ;;; The length of the vector is (/ +nursery-size+ +word-size 2).  Each
  ;;; word is an unsigned integer, but it represents a bitvector, that
  ;;; contains liveness information of the objects in the nursery.  The
  ;;; word at index i of the vector represents the objects at indexes
  ;;; between (* 2 +word-size+ i)) and (1- (* 2 +word-size+ (1+ i))).
  ;;; When the bit (ash 1 k) is set in word i, then the two consecutive
  ;;; words at indexes m and m+1 in the nursery are free, where m can be
  ;;; expressed as (* 2 (+ (* +word-size+ i) k)).  By doing it this way,
  ;;; we can use integer-length to find the most significant bit that is
  ;;; set in a word, and thus the corresponding free word with the
  ;;; highest index.
  (defvar *nursery-live*)
  
  
negative.code: 			      (1+ i)
  			      i))))
      (aref nursery (- i size))))
  
  ;;; In each thread, this variable gets bound to the address of element
  ;;; zero of the nursery. 
  