diff options
| -rw-r--r-- | impl/MaxStrategy.hpp | 18 | ||||
| -rw-r--r-- | impl/VariableAssignment.hpp | 31 | ||||
| -rw-r--r-- | tex/thesis/contribution/contribution.tex | 405 |
3 files changed, 324 insertions, 130 deletions
diff --git a/impl/MaxStrategy.hpp b/impl/MaxStrategy.hpp index 6fee921..1b471e0 100644 --- a/impl/MaxStrategy.hpp +++ b/impl/MaxStrategy.hpp @@ -132,7 +132,7 @@ private: struct DependencyAssignment : public VariableAssignment<Domain>{ DependencyAssignment(DynamicMaxStrategy& strat, - VariableAssignment<Domain>& rho, + DynamicVariableAssignment<Domain>& rho, const MaxExpression<Domain>& expr) : _strat(strat), _rho(rho), @@ -144,11 +144,23 @@ private: // recursive magic! _strat.solve(*_strat._system[var]); _strat._influence[*_strat._system[var]].insert(_expr); - return _rho[var]; + + // force evaluation to get touched variables + Domain value = _rho[var]; + // invalidate touched variables + IdSet<Variable<Domain> > changed = _rho.get_changed(); + for (typename IdSet<Variable<Domain> >::iterator + it = changed.begin(), + ei = changed.end(); + it != ei; + ++it) { + _strat.invalidate(_strat._system.variable(*it)); + } + return value; } private: DynamicMaxStrategy& _strat; - VariableAssignment<Domain>& _rho; + DynamicVariableAssignment<Domain>& _rho; const MaxExpression<Domain>& _expr; IdSet<Variable<Domain> > _current; }; diff --git a/impl/VariableAssignment.hpp b/impl/VariableAssignment.hpp index e575d60..fff00b5 100644 --- a/impl/VariableAssignment.hpp +++ b/impl/VariableAssignment.hpp @@ -24,9 +24,11 @@ struct DynamicVariableAssignment : public VariableAssignment<Domain> { ) : _system(system), _strategy(strat), _values(system.variableCount(), value), + _old_values(system.variableCount(), value), _unstable(system.variableCount()), _influence(system.variableCount(), - IdSet<Variable<Domain> >(system.variableCount())) + IdSet<Variable<Domain> >(system.variableCount())), + _touched(system.variableCount()) { } const Domain operator[](const Variable<Domain>& var) { @@ -39,6 +41,8 @@ struct DynamicVariableAssignment : public VariableAssignment<Domain> { log::fixpoint << indent() << "Invalidating " << x << std::endl; _unstable.insert(x); + _old_values[x] = _values[x]; + _touched.insert(x); _values[x] = infinity<Domain>(); IdSet<Variable<Domain> > infl = _influence[x]; @@ -54,6 +58,27 @@ struct DynamicVariableAssignment : public VariableAssignment<Domain> { } } + IdSet<Variable<Domain> > get_changed() { + IdSet<Variable<Domain> > changed; + for (typename IdSet<Variable<Domain> >::iterator + it = _touched.begin(), + ei = _touched.end(); + it != ei; + ++it) { + Variable<Domain>& var = _system.variable(*it); + //if (_old_values[var] != _values[var]) { + changed.insert(var); + _touched.remove(var); + //} + } + //_touched.clear(); + return changed; + } + + const IdMap<Variable<Domain>, Domain> get_old_values() const { + return _old_values; + } + private: void solve(const Variable<Domain>& x) { @@ -72,8 +97,6 @@ private: if (val != _values[x]) { log::fixpoint << x << " = " << val << std::endl; - _strategy.invalidate(x); - IdSet<Variable<Domain> > oldInfluence = _influence[x]; _influence[x].clear(); _values[x] = val; @@ -111,8 +134,10 @@ private: const EquationSystem<Domain>& _system; DynamicMaxStrategy<Domain>& _strategy; IdMap<Variable<Domain>, Domain> _values; + IdMap<Variable<Domain>, Domain> _old_values; IdSet<Variable<Domain> > _unstable; IdMap<Variable<Domain>,IdSet<Variable<Domain> > > _influence; + IdSet<Variable<Domain> > _touched; }; #endif diff --git a/tex/thesis/contribution/contribution.tex b/tex/thesis/contribution/contribution.tex index cc8d3ba..4a3c7b7 100644 --- a/tex/thesis/contribution/contribution.tex +++ b/tex/thesis/contribution/contribution.tex @@ -1,13 +1,26 @@ \floatname{algorithm}{Listing} +\newcommand\inflFP{\mathsf{infl^{FP}}} +\newcommand\stableFP{\mathsf{stable^{FP}}} +\newcommand\touchedFP{\mathsf{touched^{FP}}} +\newcommand\inflSI{\mathsf{infl^{SI}}} +\newcommand\stableSI{\mathsf{stable^{SI}}} + \newcommand\stable{\mathsf{stable}} +\newcommand\system{\mathsf{system}} + + +\newcommand\Systems{\mathcal{E}} + + +\newcommand\init{\mathsf{\textsc{init}}} \newcommand\eval{\mathsf{\textsc{eval}}} \newcommand\stabilise{\mathsf{\textsc{stabilise}}} \newcommand\solve{\mathsf{\textsc{solve}}} -\newcommand\system{\mathsf{system}} \newcommand\invalidate{\mathsf{\textsc{invalidate}}} \newcommand\fixpoint{\mathsf{\textsc{fixpoint}}} \newcommand\strategy{\mathsf{\textsc{strategy}}} + \algblockx[Globals]{Globals}{EndGlobals}{\textbf{Globals:\\}}{} \algblockx[Assume]{Assumptions}{EndAssumptions}{\textbf{Assume:\\}}{} @@ -70,16 +83,28 @@ and all values from the set $\D$. The subset of expressions of the form $\max(e_1, e_2, ... e_n)$, with $e_1, e_2, ..., e_n \in E$ are referred to as - \emph{$\max$-expressions}, denoted by $E_{\max} \subset E$. + \emph{$\max$-expressions}, denoted by $E_{\max} \subset E$. \end{definition} \begin{definition} \textbf{Equation System:} $\{ x = e_x \mid x \in X, e_x \in E \}$. The values $x \in X$ are called ``variables'' while the values - $e_x \in E$ are called ``right-hand-sides''. - - An equation system can also be considered as a function $\varepsilon - : (X \to D) \to (X \to D)$; $\varepsilon[\rho](x) = e_x(\rho)$. + $e_x \in E$ are called ``right-hand-sides''. The set of all equation + systems is denoted by $\Systems$; + + An equation system can be considered as a function $\system : X + \to ((X \to \D) \to \D)$; $\system[x] = e_x$, mapping from each + variable to its right-hand-side. + + An equation system can also be considered as a function $\system + : (X \to \D) \to (X \to \D)$, $\system(\rho)[x] = e_x(\rho)$, + taking a variable assignment $\rho$ and returning the result of each + $e_x$'s evaluation in $\rho$. + + These two functional forms are equivalent and correspond to changing + the argument order in the following way: $\system(\rho)[x] = + \system[x](\rho)$. It is only for convenience that we use both + forms. \end{definition} \begin{definition} @@ -107,20 +132,15 @@ algorithm is presented in Listing \ref{algo:kleene}. \begin{algorithm}[H] \begin{algorithmic} - \Assumptions - \begin{tabularx}{0.9\textwidth}{rX} - $\rho $:&$ X \to \D$, a variable assignment \\ - $\varepsilon $:&$ (X \to \D) \to (X \to \D)$, an equation system - \end{tabularx} - \EndAssumptions - - \State $n = 0$ - \State $\rho_0 = \underline{\infty}$ - \Repeat - \State $\rho_{n+1} = \varepsilon[ \rho_{n} ]$ - \State $n = n + 1$ - \Until {$\rho_{n-1} = \rho_n$} - \State \Return $\rho_n$ + \Function {solvefixpoint} {$\system \in \Systems$} + \State $k = 0$ + \State $\rho_0 = \underline{\infty}$ + \Repeat + \State $\rho_{k+1} = \system( \rho_{k} )$ + \State $k = k + 1$ + \Until {$\rho_{k-1} = \rho_k$} + \State \Return $\rho_k$ + \EndFunction \end{algorithmic} \caption{The Kleene iteration algorithm for solving fixpoint equations for their greatest solutions.} @@ -146,7 +166,7 @@ greatest fixpoint of $\{ x \mapsto -\infty, y \mapsto -\infty \}$. \begin{figure}[H] \begin{align*} - x &= \min(0, x) \\ + x &= \min(0, y) \\ y &= x - 1 \end{align*} \caption{An example equation system for which Kleene iteration will @@ -154,76 +174,113 @@ greatest fixpoint of $\{ x \mapsto -\infty, y \mapsto -\infty \}$. \label{fig:kleene-infinite} \end{figure} +This particular non-termination of Kleene iteration is not a +significant problem in our application, however, as it has been shown +in the work of Gawlitza +et. al. \cite{Gawlitza:2007:PFC:1762174.1762203}, that Kleene +iteration in this specific case is restricted to at most $|X|$ +iterations. + \subsection{W-DFS algorithm} \label{sec:wdfs} The W-DFS algorithm presented by Seidl, et al. takes into account some form of data-dependencies as it solves the system. This gives it the ability to leave portions of the system unevaluated when it is certain -that those values have not changed. +that those values have not changed. The algorithm is presented in +Listing \ref{algo:w-dfs}. -\begin{algorithm}[H] +\begin{algorithm} \begin{algorithmic} \Globals \begin{tabularx}{0.9\textwidth}{rX} - $D : X \to \D$ & a mapping from variables to their current - values, starting at $\{ x \mapsto \infty | \forall x \in X \}$ - \\ + $D$ & $\in (X \to \D)$, a mapping from variables to their current + values \\ + + $\inflFP$ & $\in (X \to 2^X)$, a mapping from a variable to the + variables it \emph{may} influence \\ - I & A mapping from a variable to the variables which \emph{may} - depend on it in their evaluation \\ + $\stableFP$ & $\subseteq X$, a set of ``stable'' variables \\ - stable & The set of all variables whose values have stabilised - \\ - - system & The equation system, a mapping from a variable to its - associated function \\ + $\system$ & $\in \Systems$, an equation system \\ \end{tabularx} \EndGlobals \end{algorithmic} \begin{algorithmic} - \Function {eval} {$x$, $y$} - \Comment{Evaluate $y$ for its value and note that when $y$ - changes, $x$ must be re-evaluated} + \Function {solvefixpoint} {$s \in \Systems$} + \State $D = \underline{\infty}$ + \State $\inflFP = \{x \mapsto \emptyset \mid \forall x \in X\}$ + \State $\stableFP = \emptyset$ + \State $\system = s$ + \State \Return $\lambda x . (\solve(x); D[x])$ + \EndFunction + \label{algo:w-dfs:init} + \end{algorithmic} + + \begin{algorithmic} + \Function {eval} {$x \in X$, $y \in X$} + \Comment{Evaluate $y$, track $x$ depends on $y$} \State $\solve(y)$ - \State $I[y] = I[y] \cup \{x\}$ + \State $\inflFP[y] = \inflFP[y] \cup \{x\}$ \State \Return $D[y]$ \EndFunction \end{algorithmic} \begin{algorithmic} - \Function {solve} {$x$} - \Comment{Solve a specific variable and place its value in $D$} - \If {$x \not \in \stable$} - \State $f = \system[x]$ - \State $\stable = \stable \cup \{x\}$ - \State $v = f( \lambda y . \eval(x, y) )$ + \Procedure {solve} {$x \in X$} + \Comment{Solve a $x$ and place its value in $D$} + \If {$x \not \in \stableFP$} + \State $e_x = \system[x]$ + \State $\stableFP = \stableFP \cup \{x\}$ + \State $v = e_x( \lambda y . \eval(x, y) )$ \If {$v \ne D[x]$} \State $D = \{ x \mapsto v \} \oplus D$ - \State $W = I[x]$ - \State $I(x) = \emptyset$ - \State $\stable = \stable \backslash W$ + \State $W = \inflFP[x]$ + \State $\inflFP(x) = \emptyset$ + \State $\stableFP = \stableFP \backslash W$ \For {$v \in W$} \State $\solve(v)$ \EndFor \EndIf \EndIf - \EndFunction + \EndProcedure \end{algorithmic} - \caption{The W-DFS alluded to in \cite{DBLP:tr/trier/MI96-11} and + \caption{The W-DFS mentioned in \cite{DBLP:tr/trier/MI96-11} and presented in \cite{fixpoint-slides}, modified to find greatest-fixpoints of monotonic fixpoint equations} \label{algo:w-dfs} \end{algorithm} -The W-DFS algorithm over-approximates the dependencies for each -variable, keeping a map of which variables \emph{may} depend on other -variables. +The function $\init$ in Listing \ref{algo:w-dfs:init} is of the type +$\Systems \to (X \to D)$. It takes an equation system and returns a +function to query the greatest fixpoint. Each fixpoint value is solved +on demand and will only evaluate the subset of the equation system +which is required to ensure the correct solution is found. + +The algorithm performs no evaluation of any variables unless their +value is requested (whether externally or internally). Once a value is +requested the right-hand-side is evaluated, which may in turn request +the values of other variables (through the $\eval$ function). + +In the case of mutually-recursive variables this would result in +infinite recursion, as each time the variable's value must be +calculated it must first calculate its own value. In order to prevent +this a $\stable$ set is maintained of variables whose values are +either currently being computed or whose values have already been +computed. This set provides a ``base'' for the recursion to terminate, +at which point the value is simply looked up in $D$. + +Whenever a variable's value changes it will ``destabilise'' and +re-evaluate any variables which \emph{may} depend on it for their +values, as they may change their value if re-evaluated (and hence are +not stable). If these values change then they, too, will destabilise +their dependent variables, and so on. + +The W-DFS algorithm provides us with a \emph{local}, +\emph{demand-driven} solver for greatest fixpoints of monotonic +fixpoint problems. -The particular variation of W-DFS presented here is designed to return -the \emph{greatest} fixpoint of an equation system consisting of only -\emph{monotonic} expressions. @@ -233,10 +290,9 @@ The $\max$-strategy iteration can be viewed as an accelerated fixpoint problem. We are attempting to find a strategy, $\sigma: E_{\max} \to E$ that will result in the greatest value for each $e \in E_{\max}$. Therefore if we consider our ``variables'' to be -$\max$-expressions and our ``values'' to be their subexpressions then we -can solve for the best $\max$-strategy using a similar approach - and our -``comparison'' +$\max$-expressions and our ``values'' to be their subexpressions then +we can solve for the best $\max$-strategy using a similar approach to +the W-DFS algorithm presented above. Because $\max$-strategy iteration is so similar to a standard fixpoint problem it is possible @@ -247,28 +303,29 @@ problem it is possible \begin{algorithmic} \Assumptions \begin{tabularx}{0.9\textwidth}{rX} - $\sigma $:&$ E_{\max} \to E$, a $\max$ strategy \\ + $\sigma$ & $\in E_{\max} \to E$, a $\max$ strategy \\ - $\varepsilon $:&$ (X \to \D) \to (X \to \D)$, an equation + $\system$ & $\in \Systems$, an equation system \\ - $\rho $:&$ (X \to D)$, a variable assignment \\ + $\rho$ & $\in (X \to D)$, a variable assignment \\ - $P_{\max} $:&$ ((E_{\max} \to E_{\max}), (X \to \D)) \to - (E_{\max} \to E_{\max})$, a $\max$-strategy improvement - operator + $P_{\max}$ & $ \in ((E_{\max} \to E), (X \to \D)) \to (E_{\max} + \to E)$, a $\max$-strategy improvement operator \\ \end{tabularx} \EndAssumptions - \State $n = 0$ - \State $\sigma_0 = \lambda x . -\infty$ - \State $\rho_0 = \underline{-\infty}$ - \Repeat - \State $\sigma_{n+1} = P_{\max}(\sigma, \rho)$ - \State $\rho_{n+1} = \sigma(\varepsilon)[ \rho_{n} ]$ - \State $n = n + 1$ - \Until {$\sigma_{n-1} = \sigma_n$} - \State \Return $\sigma_n$ + \Function {solvestrategy} {$\system \in \Systems$} + \State $k = 0$ + \State $\sigma_0 = \lambda x . -\infty$ + \State $\rho_0 = \underline{-\infty}$ + \Repeat + \State $\sigma_{k+1} = P_{\max}(\sigma_k, \rho_k)$ + \State $\rho_{k+1} = \solve \fixpoint(\sigma_{k+1}(\system))$ + \State $k = k + 1$ + \Until {$\sigma_{k-1} = \sigma_k$} + \State \Return $\sigma_k$ + \EndFunction \end{algorithmic} \caption{The naive approach to strategy iteration} \label{algo:naive-strategy} @@ -285,46 +342,61 @@ those parts of the strategy which have changed. Listing \begin{algorithmic} \Globals \begin{tabularx}{0.9\textwidth}{rX} - $\sigma$ & A mapping from $\max$-expressions to their current - sub-expressions, starting by mapping to the first - sub-expression \\ - I & A mapping from a $\max$-expression to the sub-expressions - which depend on it in their evaluation \\ - stable & The set of all $\max$-expressions whose strategies have - stabilised \\ - system & The equation system, a mapping from a variable to its - associated function \\ - bestStrategy & A function $(E_{\max}, (X \to D)) \to E$ mapping - from an expression and a variable \\& assignment to the greatest - subexpression in that context + $\sigma$ & $\in (E_{\max} \to E)$, a mapping from + $\max$-expressions to a subexpression \\ + + $\inflSI$ & $\in (E_{\max} \to 2^{E_{\max}}$, a mapping from a + $\max$-expression to the sub-expressions it influences \\ + + $\stableSI$ & $\subseteq E_{\max}$, the set of all + $\max$-expressions whose strategies are stable \\ + + $\system$ & $\in \Systems$, an equation system \\ + + $P_{\max}$ & $\in (E_{\max}, E, (X \to \D)) \to E$, a function + mapping from a $\max$-expression, the current strategy and a + variable assignment to a better subexpression than the current + strategy in that variable assignment \\ \end{tabularx} \EndGlobals + \end{algorithmic} - \Function {eval} {$x$, $y$} - \Comment{Evaluate $y$ for its value and note that when $y$ - changes, $x$ must be re-evaluated} + \begin{algorithmic} + \Function {solvestrategy} {$s \in \Systems$} + \State $\sigma = \underline{-\infty}$ + \State $\inflSI = \{x \mapsto \emptyset \mid \forall x \in E_{\max}\}$ + \State $\stableSI = \emptyset$ + \State $\system = s$ + \State \Return $\lambda x . (\solve(x); \sigma[x])$ + \EndFunction + \label{algo:w-dfs:init} + \end{algorithmic} + + \begin{algorithmic} + \Function {eval} {$x \in E_{\max}$, $y \in E_{\max}$} \State $\solve(y)$ - \State $I[y] = I[y] \cup \{x\}$ + \State $\inflSI[y] = \inflSI[y] \cup \{x\}$ \State \Return $\sigma[y]$ \EndFunction + \end{algorithmic} - \Function {solve} {$x$} - \Comment{Solve a specific expression and place its value in $\sigma$} - \If {$x \not \in \stable$} - \State $f = \system[x]$ - \State $\stable = \stable \cup \{x\}$ - \State $v = bestStrategy(f, \lambda y . \eval(x, y))$ + \begin{algorithmic} + \Procedure {solve} {$x \in E_{\max}$} + \If {$x \not \in \stableSI$} + \State $\stableSI = \stableSI \cup \{x\}$ + \State $\rho = \solve \fixpoint(\sigma(\system))$ + \State $v = P_{\max}(x, \sigma[x], \lambda y . \eval(x, y))$ \If {$v \ne \sigma[x]$} \State $\sigma = \{ x \mapsto v\} \oplus \sigma$ - \State $W = I[x]$ - \State $I(x) = \emptyset$ - \State $\stable = \stable \backslash W$ + \State $W = \inflSI[x]$ + \State $\inflSI(x) = \emptyset$ + \State $\stableSI = \stableSI \backslash W$ \For {$v \in W$} \State $\solve(v)$ \EndFor \EndIf \EndIf - \EndFunction + \EndProcedure \end{algorithmic} \caption{W-DFS, this time modified to find the best $\max$-strategy.} @@ -335,42 +407,127 @@ those parts of the strategy which have changed. Listing \section{Local Demand-driven Strategy Improvement (LDSI)} W-DFS can be used to speed up both the $\max$-strategy iteration and -the fixpoint iteration as two independent processes, but each -fixpoint-iteration step still requires at least one complete -evaluation of the equation system per $\max$-strategy improvement -step. Ideally we would be able to adapt the W-DFS algorithm so that -the fixpoint-iteration and $\max$-strategy iteration steps could -provide some information to each other about what values have changed -so that at each step only a subset of the entire system would have to -be evaluated. +the fixpoint iteration as two independent processes, but each time we +seek to improve our strategy we must compute at least a subset of the +fixpoint from a base of no information. Ideally we would be able to +provide some channel for communication between the two W-DFS instances +to reduce the amount of work that must be done at each stage. By +supplying each other with information about which parts of the system +have changed we can jump in partway through the process of finding a +solution, thereby avoiding repeating work that we have already done. The new \emph{Local Demand-driven Strategy Improvement} algorithm, -\emph{LDSI}, seeks to do this. By adding an ``invalidate'' -function to both W-DFS instances we provide an interface for the two -sides of the algorithm to indicate which values have changed and -``destabilise'' that portion of the system. +\emph{LDSI}, seeks to do this. By adding an ``invalidate'' procedure +to the fixpoint iteration we provide a method for the $\max$-strategy +to invalidate fixpoint variables, and we can modify the fixpoint +iteration algorithm to report which variables it has modified with +each fixpoint iteration step. This essentially results in a $\max$-strategy iteration which, at each strategy-improvement step, invalidates a portion of the current fixpoint iteration which may depend on the changed strategy. The -fixpoint iteration then re-stabilises itself by evaluating what values -have been changed, but only when such values are requested by the -$\max$-strategy iteration. The $\max$-strategy can continue as normal, -invalidating the fixpoint-iteration as required, and simply assume -that the fixpoint-iteration will provide it with the correct values -from the greatest fixpoint. +fixpoint iteration then re-stabilises each variable as it is +requested, tracking which values have changed since the last time they +iterated. The $\max$-strategy iteration then uses this list of changed +variables to determine which portions of the current strategy must be +re-stabilised once more. This process continues until the +$\max$-strategy stabilises (at which point the fixpoint will also +stabilise). + +This entire approach is \emph{demand driven}, and so any necessary +evaluation of strategies or fixpoint values is delayed until the point +when it is actually required. This means that the solver will be +\emph{local}. + + + + + + +This algorithm is presented in three parts. + +Section \ref{sec:ldsi:top-level} presents the global state and entry +point to the algorithm. + +Section \ref{sec:ldsi:max-strategy} presents the fixpoint portion of +the algorithm. This portion bears many similarities to the W-DFS +algorithm presented in Section \ref{sec:wdfs}, with a few +modifications to track changes and allow external invalidations of +parts of the solution. + +Section \ref{sec:ldsi:fixpoint} presents the $\max$-strategy portion +of the algorithm. This portion is quite similar to the Adapted W-DFS +algorithm presented in Section \ref{sec:adapted-wdfs}, with some +modifications to allow for communication with the fixpoint portion of +the algorithm. + +Section \ref{sec:ldsi:correctness} argues the correctness of this +approach for finding the least fixpoints of monotonic, expansive +equation systems involving $\max$-expressions. + +\subsection{Top level} \label{sec:ldsi:top-level} + +\begin{algorithm}[H] + \begin{algorithmic} + \Globals + \begin{tabularx}{0.9\textwidth}{rX} + $D$ & $\in (X \to \D)$, a mapping from variables to their current + values \\ + + $\inflFP$ & $\in (X \to 2^X)$, a mapping from a variable to the + variables it \emph{may} influence \\ + + $\stableFP$ & $\subseteq X$, a set of ``stable'' variables \\ + + $\touchedFP$ & $\subseteq X$, a set of variables which have been + ``touched'' by the fixpoint iteration, but not yet acknowledged + by the $\max$-strategy iteration \\ + + \\ + + $\sigma$ & $\in (E_{\max} \to E)$, a mapping from + $\max$-expressions to a subexpression \\ + + $\inflSI$ & $\in (E_{\max} \to 2^{E_{\max}}$, a mapping from a + $\max$-expression to the sub-expressions it influences \\ + + $\stableSI$ & $\subseteq E_{\max}$, the set of all + $\max$-expressions whose strategies are stable \\ + + $P_{\max}$ & $\in (E_{\max}, E, (X \to \D)) \to E$, a function + mapping from a $\max$-expression, the current strategy and a + variable assignment to a better subexpression than the current + strategy in that variable assignment \\ + + \\ + + $\system$ & $\in \Systems$, an equation system \\ + \end{tabularx} + \EndGlobals + \end{algorithmic} + \caption{Global variables used by the LDSI algorithm} + \label{algo:ldsi:fixpoint:globals} +\end{algorithm} + +These variables are mostly just a combination of the variables found +in Sections \ref{sec:wdfs} and \ref{sec:adapted-wdfs}. The only +exception is $\touchedFP$, which is a newly introduced variable to +track variables which are touched by the fixpoint iteration steps. + -This entire approach is demand driven, and so any necessary evaluation -is delayed until the point when it is actually required. Additionally, -if it is not necessary to evaluate a particular right hand side in -order to make a decision then the algorithm will attempt to avoid -evaluating it. +\subsection{$\max$-strategy iteration} \label{sec:ldsi:max-strategy} +\subsection{Fixpoint iteration} \label{sec:ldsi:fixpoint} +\subsection{Correctness} \label{sec:ldsi:correctness} +THIS IS THE END OF WHERE I'M UP TO! The stuff after this still needs +to be fixed up to use the new variables and have the ``touched'' thing +properly put in. +\endinput -This algorithm is presented in two parts. Listings +Listings \ref{algo:ldsi:fixpoint:globals}, \ref{algo:ldsi:fixpoint:eval}, \ref{algo:ldsi:fixpoint:invalidate}, @@ -404,7 +561,7 @@ correctness of this new algorithm is argued in have stabilised to their final strategy (stable $\max$-expressions) \\ - $\varepsilon$ & The equation system, a mapping from a variable + $\system$ & The equation system, a mapping from a variable to its associated function \\ \end{tabularx} \EndGlobals |