A linear programming approach to general dataflow process network verification and dimensioning

In this paper, we present linear programming-based sufficient conditions, some of them polynomial-time, to establish the liveness and memory boundedness of general dataflow process networks. Furthermore, this approach can be used to obtain safe upper bounds on the size of the channel buffers of such a network.

💡 Research Summary

The paper introduces a linear‑programming (LP) framework for verifying two fundamental properties of Dataflow Process Networks (DPNs): liveness (the guarantee that the network can continue to make progress) and memory boundedness (the existence of finite channel buffers that prevent unbounded growth). The authors model a DPN as a set of tasks (nodes) communicating through unidirectional FIFO channels (edges). Each task is described by a state‑transition graph Gₜ = (Vₜ ∪ {v₀ₜ}, Aₜ ∪ {τ₀ₜ}) where τ₀ₜ is the unique unconditional initial transition. For every transition τ and every channel f that a task either produces to (Pₜ) or consumes from (Cₜ), the amounts of data produced (qpᵗ_f) and consumed (qcᵗ_f) are known constants.

The core of the method is the introduction of integer variables n_τ ≥ 0 that count how many times each transition τ has been executed. From these variables the authors derive a collection of linear constraints that capture the admissibility of a global system state:

• Initialization – the initial transition of each task must be executed exactly once (n_{τ₀ₜ}=1).
• Conservation – for every state v of a task, the number of times the state is entered and left must differ by at most one, which yields inequalities of the form Σ_in(v) n_τ – 1 ≤ Σ_out(v) n_τ ≤ Σ_in(v) n_τ.
• Uniqueness – each task must be in exactly one current state; this is expressed by defining γ_v = Σ_in(v) n_τ – Σ_out(v) n_τ and enforcing Σ_{v∈Vₜ} γ_v = 1.
• Consistency – for each channel f the total produced data qp_f = Σ_{τ∈A_{p_f}} n_τ·qpᵗ_f must be at least the total consumed data qc_f.
• Capacity – the current occupancy qp_f – qc_f must never exceed the buffer capacity d_f.

To reason about deadlock, the authors define two notions of blockedness. A task is strongly blocked if, in its current state, no outgoing transition can fire; a task is weakly blocked if at least one outgoing transition is unavailable. Both notions are expressed by linear inequalities (γ_v ≤ 0 together with channel‑occupancy constraints) and a logical OR over the outgoing transitions. Standard LP modeling tricks (big‑M, binary variables) linearize these disjunctions, yielding a pure integer linear system

 Ax ≤ b(d) , x ∈ ℤⁿ.

The key observation is that if this system is inconsistent (has no integer solution), then the DPN is live for the given buffer dimensions d. Moreover, the continuous relaxation (allowing real variables) provides a weaker but polynomial‑time sufficient condition: if the relaxed system is infeasible, the network is certainly live.

The paper then tackles memory boundedness. By exploiting the equivalence between DPNs and Kahn Process Networks (KPNs), the authors prove a monotonicity property: if a DPN is live with a certain buffer vector d, it remains live for any larger vector d′ ≥ d (component‑wise). Consequently, they formulate an integer linear program that seeks the largest uniform buffer size z such that the network fails to be live:

 maximize z
 subject to Ax ≤ b(z), y = (x, z) ∈ ℤ^{n+1}_+.

If the optimal value z_IP is finite, then any buffer size d_f ≥ z_IP + 1 guarantees both liveness and boundedness. If z_IP = ∞, no conclusion can be drawn. The continuous relaxation of this program, yielding z_LP, can be solved in polynomial time; finiteness of z_LP is equivalent to finiteness of z_IP, providing a tractable sufficient condition for both properties.

Algorithmically, the authors note that while z_LP is easy to compute, the integrality gap (z_LP – z_IP) may be large, so tight buffer dimensioning often requires solving the integer program. Because the feasible region is unbounded (the n_τ variables are not a priori bounded), generic branch‑and‑bound ILP solvers may not terminate. The paper suggests using cutting‑plane methods—Gomory cuts or, preferably, problem‑specific inequalities derived from a polyhedral study of the integer hull—to guarantee termination.

In summary, the contribution is a comprehensive LP‑based methodology that (1) models DPN execution states with linear constraints, (2) provides polynomial‑time sufficient tests for liveness via continuous relaxation, (3) translates memory boundedness into a maximization problem over a uniform buffer size, and (4) discusses practical solution strategies for the resulting integer programs. This framework enables designers to automatically verify deadlock‑freedom and to compute safe upper bounds on channel buffer capacities early in the design flow of highly concurrent, data‑driven applications.