anchor.diff:  ;;;   data flow graph are critical nodes. However such a critical node is
   ;;;   cheap, because it has already been allocated.
   ;;;
  -;;; - Each graph root is a critical node. Since the whole purpose of
  -;;;   Petalisp is to compute the values of the graph roots, allocating them
  -;;;   is absolutely mandatory.
  +;;; - Each graph root is a critical node -- the whole purpose of Petalisp
  +;;;   is to compute the values of these graph roots.
   ;;;
   ;;; - A node that appears as an input of multiple other nodes of the same
   ;;;   graph, is a critical node. As a result, all non-critical nodes have
  
positive.code: ;;;
  ;;; 2. By construction, the nodes starting from one critical node, up to
  ;;;    and including the next critical nodes, form a tree of application,
  ;;;    reduction, reference and fusion nodes. To eliminate fusion nodes in
  ;;;    the later stages, determine a set of index spaces such that their
  ;;;    union is the index space of the current critical node, but such that
  ;;;    each index space lies uniquely within a particular input of each
  ;;;    fusion node.
  ;;;
  ;;; 3. Each particular index space from 2. denotes a fusion-free
  ;;;    sub-problem on the way to computing the current critical
  ;;;    node. Determine the iteration space of this sub-problem and the set
  ;;;    of referenced immediates.
  ;;;
  ;;; 4. Given the iteration space and the set of referenced immediates,
  ;;;    translate the tree into an explicit blueprint. The blueprint
  ;;;    describes how the given inputs are used to compute the target. It is
  ;;;    important that this blueprint is normalized, such that as many
  ;;;    computationally similar operations as possible have the same
  ;;;    blueprint. To achieve this, blueprints do not use index space
  ;;;    coordinates, but the storage coordinates of the source and target
  ;;;    immediates.
  ;;;
  ;;; 5. Use each blueprint, together with the set of sources, the target and
  ;;;    the iteration space, to create one kernel and associates its target
  ;;;    node. Once every critical node and index space thereof has been
  ;;;    processed, the algorithm terminates.
  
  (defun kernelize (graph-roots)
    (kernelize-subtrees
  
negative.code: ;;;
  ;;; The goal is to translate a data flow graph into a graph of executable
  ;;; parts, called kernels. The data flow nodes form a DAG (directed acyclic
  ;;; graph). The data flow graph is fully determined by a set of graph
  ;;; roots, typically the nodes passed to SCHEDULE.
  ;;;
  ;;; The resulting graph consists only of immediate values. Each immediate
  ;;; hash a possibly empty set of kernels. Each kernel describes how values
  ;;; of a subspace of the index space of its target immediate can be
  ;;; computed. Furthermore each kernel tracks the set of its sources,
  ;;; i.e. those immediates that are referenced during their
  ;;; evaluation. Since the resulting immediate graph is used to decide a
  ;;; scheduling and allocation strategy, it is important that its kernels
  ;;; are easy to analyze, yet expressive enough to denote fast programs.
  