DAG-Inducing Problems and Algorithms

TL;DR

This work addresses the challenge of ensuring convergence to optimal states in parallel, asynchronous computation without synchronization. It introduces the framework of DAG-inducing problems (DIP) and DAG-inducing algorithms (DIA), showing that a $\prec$-DAG on the global state space is a necessary and sufficient condition for correct asynchronous execution. The paper demonstrates concrete instances, proving DC and SP are DIP (with DC enabling self-stabilization) while MM requires an imposed DAG induction to become DIA; it also provides explicit convergence-time bounds for these algorithms. The results yield a general, verifiable criterion for designing asynchrony-tolerant algorithms, with practical implications for reducing synchronization overhead in multiprocessor systems and for simplifying correctness proofs. Overall, the authors unify asynchronous convergence under the lens of partial-order structures on local states, extending lattice-linear ideas to a broader class of problems and algorithms.

Abstract

Consider the execution of a sequential algorithm that requires the program to converge to an optimal state, and then terminate/stutter. To design such an algorithm, we need to ensure that the state space that it traverses forms a directed acyclic graph (DAG) and its sink nodes are optimal states. However, if we run the same algorithm on multiple computing nodes running in parallel, and without synchronization, it may not reach an optimal state. In most parallel processing algorithms designed in the literature, a synchronization primitive is assumed. Synchronization ensures that the nodes read fresh value, and the execution proceeds systematically, such that the subject algorithm traverses a DAG induced among the global states. With this observation, we investigate the conditions that guarantee that the execution of an algorithm is correct even if it is executed in parallel and without synchronization. To this end, we introduce DAG-inducing problems and DAG-inducing algorithms. We show that induction of a $\prec$-DAG (induced among the global states -- that forms as a result of a partial order induced among the local states visited by individual nodes) is a necessary and sufficient condition to allow an algorithm to run in asynchrony. In the paper, we first give a comprehensive description of DAG-inducing problems and DAG-inducing algorithms, along with some simple examples. Then we show some properties of an algorithm that is tolerant to asynchrony, which include the above-mentioned condition.

Figures (4)

• Figure 1: (a) Input graph. (b) Partial order induced among the local states of node 1 (all edges are directed upwards).
• Figure 2: DAG, assuming that initial state is $\langle\{1\},\{2\},\{3\}\rangle$; we replaced writing $v_i$ by $i$ for brevity. In all these states, the second guard of \ref{['algorithm:dc-dip']} is false. Observe that any other state will converge to one of these states and then converge to one of the optimal states in this DAG. Transitive edges are not shown in this DAG. All edges are directed upwards.
• Figure 3: (a) Input graph. (b) DAG induced among the global states in evaluating for the shortest path parblem in the graph shown in (a); a global state is represented as $\langle\langle p.v_1,d.v_1\rangle,...,\langle p.v_4,d.v_4\rangle\rangle$. Transitive edges are not shown.
• Figure 4: (a) Input graph. (b) The state transition diagram, a DAG, assuming that the initial global state is $\langle \top,\top,\top,\top\rangle$. In every state, the first row shows the global state, the second row shows the respective local state values of nodes and the rank of the global state. Observe that any other state will converge to one of these states and then converge to one of the optimal states in this DAG. Transitive edges are not shown for brevity.

Theorems & Definitions (38)

• Definition 1
• Definition 2
• Definition 3
• Definition 4
• Definition 5
• Definition 6
• Definition 7
• Definition 8
• Definition 9
• Definition 10