Broadly speaking the update proceeds as follows: during the Ranking
phase we construct the intended graph of dependencies between patches
-(which involves select a merge order for the base branch of each
+(and incidentally select a merge order for the base branch of each
patch). Then during the Traversal phase we walk that graph from the
bottom up, constructing for each patch by a series of merges and other
operations first a new base branch head commit and then a new tip
Convenience notation for
$\bigforall_{E \in \pendsof{\set X}{\p}} E \le T$
-\item[ $\Gamma_{\pc}$ ]
-The desired direct dependencies of $\pc$, a set of patches.
-
-\item[ $\allpatches$ ]
-The set of all the patches we are dealing with (constructed
-during the update algorithm).
-
%\item[ $\set E_{\pc}$ ]
%$ \bigcup_i \pendsof{S_{\pc,i}}{\pc} $.
%All the ends of $\pc$ in the sources.
\end{basedescript}
+\stdsection{Important variables and values in the update algorithm}
+
+\begin{basedescript}{
+\desclabelwidth{5em}
+\desclabelstyle{\nextlinelabel}
+}
+\item[ $\Gamma_{\pc}$ ]
+The desired direct dependencies of $\pc$, a set of patches.
+
+\item[ $\allpatches$ ]
+The set of all the patches we are dealing with (constructed
+during the update algorithm).
+
+\end{basedescript}
+
\section{Ranking phase}
We run the following algorithm:
\item Repeatedly:
\begin{enumerate}
\item Clear out the graph $\hasdirdep$ so it has no edges.
-\item Execute {\bf Rank-Recurse}($\pc_0$)
+\item Execute $\alg{Rank-Recurse}(\pc_0)$
\item Until $\allpatches$ remains unchanged.
\end{enumerate}
\end{enumerate}
-{\bf Rank-Recurse}($\pc$) is:
+$\alg{Rank-Recurse}(\pc)$ is:
\begin{enumerate}
-\item If we have already done {\bf Rank-Recurse}($\pc$) in this
+\item If we have already done $\alg{Rank-Recurse}(\pc)$ in this
ranking iteration, do nothing. Otherwise:
\item Add $\pc$ to $\allpatches$ if it is not there already.
-\item Let
+\item Set
$$
- \set S = h(\pcn)
+ \set S \iassign h(\pcn)
\cup
\bigcup_{\p \in \allpatches}
\bigcup_{H \in h(\pn) \lor H \in h(\py)}
\{ \baseof{E} \; | \; E \in \pendsof{H}{\pcy} \}
$$
-and $W = w(h(\pcn))$
+and $W \iassign w(h(\pcn))$
\item While $\exists_{S \in \set S} S \ge W$,
update $W \assign S$ and $\set S \assign \set S \, \backslash \{ S \}$
(This will often remove $W$ from $\set S$. Afterwards, $\set S$
is a collection of heads to be merged into $W$.)
-\item Choose an order of $\set S$, $S_i$ for $i=1 \ldots n$.
+\item Choose an ordering of $\set S$, $S_i$ for $i=1 \ldots n$.
\item For each $S_i$ in turn, choose a corresponding $M_i$
such that $$
M_i \le S_i \land \left[
- M_i \le W \lor \bigexists_{S_i, j<i} M_i \le S_i
+ M_i \le W \lor \bigexists_{j<i} M_i \le S_j
\right]
$$
-\item Set $\Gamma = \depsreqof{W}$.
+\item Set $\Gamma \iassign \depsreqof{W}$.
If there are multiple candidates we prefer $M_i \in \pcn$
if available.
\item For each $i \ldots 1..n$, update our putative direct
dependencies:
$$
-\Gamma \assign \text{\bf set-merge}\left[\Gamma,
- \left( \begin{cases}
- M_i \in \pcn : & \depsreqof{M_i} \\
- M_i \not\in \pcn : & \{ \}
- \end{cases} \right),
- \depsreqof{S_i}
- \right]
+\Gamma \assign \setmergeof{
+ \Gamma
+ }{
+ \begin{cases}
+ M_i \in \pcn : & \depsreqof{M_i} \\
+ M_i \not\in \pcn : & \{ \}
+ \end{cases}
+ }{
+ \depsreqof{S_i}
+ }
$$
-TODO define {\bf set-merge}
+TODO define $\setmerge$
\item Finalise our putative direct dependencies
$
\item Add an edge $\pc \hasdirdep \pd$ to the digraph (adding nodes
as necessary).
If this results in a cycle, abort entirely (as the function $g$ is
-inappropriate; a different $g$ could work.)
+inappropriate; a different $g$ could work).
+\item Run $\alg{Rank-Recurse}(\pd)$.
\end{enumerate}
-\item Run ${\text{\bf Rank-Recurse}}(\pd)$.
\end{enumerate}
into the partial order $\hasdep$.
\item
-For each $\pc \in \allpatches$, the base branch starting point commit $W_{\pcn} = W$.
+For each $\pc \in \allpatches$,
+the base branch starting point commit $W^{\pcn} = W$.
\item
For each $\pc$,
-the direct dependencies $\Gamma_{\pc}$.
+the direct dependencies $\Gamma^{\pc} = \Gamma$.
\item
For each $\pc$,
-the ordered set of base branch sources $\set S_{\pcn} = \set S,
-S_{\pcn,i} = S_i$
-and corresponding merge bases $M_{\pcn,i} = M_i$.
+the ordered set of base branch sources $\set S^{\pcn} = \set S,
+S^{\pcn}_i = S_i$
+and corresponding merge bases $M^{\pcn}_i = M_i$.
\end{itemize}
+\subsection{Proof of termination}
+
+$\alg{Rank-Recurse}(\pc)$ recurses but only downwards through the
+finite graph $\hasdirdep$, so it must terminate.
+
+The whole ranking algorithm iterates but each iteration involves
+adding one or more patches to $\allpatches$. Since there are
+finitely many patches and we never remove anything from $\allpatches$
+this must complete eventually.
+
+$\qed$
+
\section{Traversal phase}
+For each patch $C \in \allpatches$ in topological order by $\hasdep$,
+lowest first:
+\begin{enumerate}
+
+\item Optionally, attempt $\alg{Merge-Base}(\pc)$.
+\end{enumerate}
\section{Planning phase}
~ian / topbloke-formulae.git / blobdiff