-\section{Ranking phase}
-
-{\bf Ranking} is:
-\begin{enumerate}
-\item Set $\allpatches = \{ \}$.
-\item Repeatedly:
-\begin{enumerate}
-\item Clear out the graph $\hasdirdep$ so it has neither nodes nor edges.
-\item Execute {\bf Rank-Recurse}($\pc_0$) .
-\item Until $\allpatches$ remains unchanged.
-\end{enumerate}
-\end{enumerate}
-
-{\bf Rank-Recurse}($\pc$) is:
-\begin{enumerate}
-\item Add $\pc$ to $\allpatches$ if it is not there already.
-\item Let $\set S_{\pcn} = h(\pcn)
- \cup
- \bigcup_{\p \in \allpatches}
- \bigcup_{H \in h(\pn) \lor H \in h(\py)}
- \{ \baseof{E} \; | \; E \in \pendsof{H}{\pcy} \} $.
-
-(We write $\set S = \set S_{\pcn}$ when it's not ambiguous.)
-\end{enumerate}
-
-\section{Planning phase}
-
-The results of the planning phase consist of:
-\begin{itemize*}
-\item{ The relation $\hasdirdep$ and hence the partial order $\hasdep$. }
-\item{ For each commit set $\pc$, a confirmed set of sources $\set S_{\pc}$. }
-\item{ For each commit set $\pc$, the order in which to merge the sources
- $E_{\pc,j} \in \set E_{\pc}$. }
-\item{ For each $E_{\pc,j}$ an intended merge base $M_{\pc,j}$. }
-\end{itemize*}
-
-We use a recursive planning algorith, recursing over Topbloke commit
-sets (ie, sets $\py$ or $\pn$). We'll call the commit set we're
-processing at each step $\pc$.
-At each recursive step
-we make a plan to merge all $\set E_{\pc} = \{ E_{\pc,j \ldots} \}$
-and all the direct contributors of $\pc$ (as determined below)
-into $\tipzc$, to make $\tipfc$.
-
-We start with $\pc = \pl$ where $\pl = \patchof{L}$.
-
-
-\subsection{Direct contributors for $\pc = \pcn$}
-
-The direct contributors of $\pcn$ are the commit sets corresponding to
-the tip branches for the direct dependencies of the patch $\pc$. We
-need to calculate what the direct dependencies are going to be.
-
-Choose an (arbitrary, but ideally somehow optimal in
-a way not discussed here) ordering of $\set E_{\pc}$, $E_{\pc,j}$
-($j = 1 \ldots m$).
-For brevity we will write $E_j$ for $E_{\pc,j}$.
-Remove from that set (and ordering) any $E_j$ which
-are $\le$ and $\neq$ some other $E_k$.
-
-Initially let $\set D_0 = \depsreqof{\tipzc}$.
-For each $E_j$ starting with $j=1$ choose a corresponding intended
-merge base $M_j$ such that $M_j \le E_j \land M_j \le T_{\pc,j-1}$.
-Calculate $\set D_j$ as the 3-way merge of the sets $\set D_{j-1}$ and
-$\depsreqof{E_j}$ using as a base $\depsreqof{M_j}$. This will
-generate $D_m$ as the putative direct contributors of $\pcn$.
-
-However, the invocation may give instructions that certain direct
-dependencies are definitely to be included, or excluded. As a result
-the set of actual direct contributors is some arbitrary set of patches
-(strictly, some arbitrary set of Topbloke tip commit sets).
-
-\subsection{Direct contributors for $\pc = \pcy$}
-
-The sole direct contributor of $\pcy$ is $\pcn$.
-
-\subsection{Recursive step}
-
-For each direct contributor $\p$, we add the edge $\pc \hasdirdep \p$
-and augment the ordering $\hasdep$ accordingly.
-
-If this would make a cycle in $\hasdep$, we abort . The operation must
-then be retried by the user, if desired, but with different or
-additional instructions for modifying the direct contributors of some
-$\pqn$ involved in the cycle.
-
-For each such $\p$, after updating $\hasdep$, we recursively make a plan
-for $\pc' = \p$.
-
-
-
-\section{Execution phase}
-
-We process commit sets from the bottom up according to the relation
-$\hasdep$. For each commit set $\pc$ we construct $\tipfc$ from
-$\tipzc$, as planned. By construction, $\hasdep$ has $\patchof{L}$
-as its maximum, so this operation will finish by updating
-$\tipca{\patchof{L}}$ with $\tipfa{\patchof{L}}$.
-
-After we are done with each commit set $\pc$, the
-new tip $\tipfc$ has the following properties:
-\[ \eqn{Tip Sources}{
- \bigforall_{E_i \in \set E_{\pc}} \tipfc \ge E_i
-}\]
-\[ \eqn{Tip Dependencies}{
- \bigforall_{\pc \hasdep \p} \tipfc \ge \tipfa \p
-}\]
-\[ \eqn{Perfect Contents}{
- \tipfc \haspatch \p \equiv \pc \hasdep \py
-}\]
~ian / topbloke-formulae.git / blobdiff