
    {\em SemiNaive Evaluation} is the method used to evaluate an
    individual SCC.  Because of the ordering of the evaluation of
    SCC's, when this SCC is being evaluated, all relations
    outside this SCC that this SCC depends on have already been computed. 
    SemiNaive evaluation is a type of fixpoint evaluation that can solve
    a set of rules that may contain inter-dependancies, or recursion.
    Coral has marked each rule that is involved in recursion in the
    SCC-analysis phase.

    The evaluation starts by firing each rule in the SCC that is not
    marked as recursive.  These rules will already have their 
    dependancies satisfied due to the ordering of SCC evaluation,
    so there is no benefit to evaluating these rules more than once.

    Now the recursive rules are evaluted, we iterate through the
    recursive rules, with each one firing as many times as it can
    with the current information available.  We continue to iterate
    over these rules as long as new facts are being created.

    Each recursive relation being evaluated is conceptually split
    into two parts (via an {\em RMark}), there is the {\em old}
    part, which are the tuples computed in previous iterations,
    and the {\em delta}, which are the tuples that we have computed
    in this iteration.  At the end of each pass, the tuples in the
    delta are added to the old part of the relation, and the deltas
    are emptied.  If the deltas for all relations within this SCC
    are empty at the end of an iteration, we have reached a {\em fixpoint},
    and evaluation can stop, as further evaluation will not discover
    any new facts.

    The deltas are implemented through two {\em RMarks}, (Relation Marks),
    for each relation.  An RMark can be considered to be a conceptual
    mark seperating the two portions of the relation (when visualized
    as a table of facts).  One RMark seperates the old part from the
    delta, with the other marking the end of the delta.   If the user
    has specified (via an annotation in this module) that deltas
    should be indexed, the delta is actually implemented as a seperate
    relation which is then indexed.  Otherwise, the delta is implemented
    as a simple list of tuples that are not yet added to the main relation,
    though all the low-level primitives (such as a scan over the relation)
    consider them to be part of it.  At the end of each iteration, the
    {\em move\_all\_entries()} function is called, and these tuples are
    moved from the delta into the main relation.


\noindent
Files to look at:
{\em
\begin{itemize}
\item SemiNaive.h 
\item SemiNaiveEval.C  
\item SccInfo.C  
\end{itemize}
}
