Towards a decentralized algorithm for mapping network and computational resources for distributed data-flow computations

Several high-throughput distributed data-processing applications require multi-hop processing of streams of data. These applications include continual processing on data streams originating from a network of sensors, composing a multimedia stream through embedding several component streams originating from different locations, etc. These data-flow computing applications require multiple processing nodes interconnected according to the data-flow topology of the application, for on-stream processing of the data. Since the applications usually sustain for a long period, it is important to optimally map the component computations and communications on the nodes and links in the network, fulfilling the capacity constraints and optimizing some quality metric such as end-to-end latency. The mapping problem is unfortunately NP-complete and heuristics have been previously proposed to compute the approximate solution in a centralized way. However, because of the dynamicity of the network, it is practically impossible to aggregate the correct state of the whole network in a single node. In this paper, we present a distributed algorithm for optimal mapping of the components of the data flow applications. We propose several heuristics to minimize the message complexity of the algorithm while maintaining the quality of the solution.

💡 Research Summary

The paper addresses the problem of mapping the components of high‑throughput, multi‑hop data‑flow applications onto a distributed set of computing and network resources. Such applications—e.g., continuous sensor‑stream processing, multimedia stream composition, scientific workflows—require a series of processing nodes arranged according to the data‑flow topology, and they typically run for long periods, making an initial optimal resource allocation crucial.

The authors formalize the problem by defining a data‑flow directed acyclic graph (DAG) G_J = (V_J, E_J) and a resource graph G_R = (V_R, E_R). Each resource node v_R has a processing capacity C_av(v_R) and each resource link e_R has a bandwidth B_av(e_R) together with additive metrics such as latency. Every data‑flow node v_J has a processing requirement C_req(v_J) and each data‑flow edge e_J a bandwidth requirement B_req(e_J). A mapping consists of a vertex mapping M: V_J → V_R (multiple data‑flow vertices may share a resource node) and an edge mapping M_e: E_J → P_R where P_R denotes all possible paths in the resource graph (including zero‑length paths). The mapping must satisfy (1) per‑node capacity constraints, (2) per‑edge bandwidth constraints (the minimum bandwidth along the chosen path must meet the requirement), and (3) an objective such as minimizing total end‑to‑end latency.

Because the general DAG‑to‑graph mapping is computationally hard, the authors focus first on the special case where the data‑flow topology is a simple directed path (single source, single sink). They call this the Bandwidth‑Constrained Path Mapping (BCPM) problem. By a polynomial reduction from the classic Longest Path problem (even when all edge lengths are 1), they prove that BCPM is NP‑complete, which in turn implies that the more general Bandwidth‑Constrained DAG Mapping (BCDM) is NP‑hard.

To solve BCPM, the paper proposes an algorithm based on the Bellman‑Ford relaxation scheme. In the centralized version, a single node that knows the entire resource graph iteratively relaxes every edge N‑1 times (N = |V_R|). For each resource node u, a set S(u) of feasible partial mappings of prefixes of the data‑flow path is maintained. During a relaxation of edge (u, v), each partial mapping in S(u) is extended along (u, v) in all admissible ways, and the resulting new partial mappings are inserted into S(v). After N‑1 iterations, S(t) (where t is the sink) contains every feasible full mapping of the data‑flow path onto any source‑to‑sink resource path.

The distributed algorithm adapts this scheme to a setting where each node only knows the state of its immediate neighbors. Nodes exchange their current partial‑mapping sets with neighbors in synchronous rounds; each node locally performs the same relaxation as in the centralized case. To keep communication overhead low, the authors introduce two practical refinements: (a) early termination as soon as any feasible source‑to‑sink mapping is discovered, and (b) discarding partial mappings after a single relaxation step, which bounds the memory usage at each node to O(d·p) (d = average degree of the resource graph, p = length of the data‑flow path).

The paper analyses computational complexity, noting that while the worst‑case size of the partial‑mapping sets can be exponential (as expected for an NP‑hard problem), realistic networks with limited capacities naturally prune the search space. Consequently, the authors suggest several heuristics to keep the algorithm tractable: limiting each node’s stored mappings to the K lowest‑cost candidates, preferring links with abundant bandwidth, and imposing a maximum path‑length bound during exploration. These heuristics preserve solution quality (total latency) while dramatically reducing message count and processing time.

A formal correctness proof shows that the distributed relaxation preserves the Bellman‑Ford invariant, guaranteeing that any feasible mapping will eventually be discovered (or the optimal one if early termination is disabled). The authors also discuss memory and message complexity, emphasizing that the approach scales to large, dynamic networks where a single controller cannot maintain a global view.

In conclusion, the paper makes three key contributions: (1) a rigorous proof of NP‑completeness for bandwidth‑constrained path mapping, (2) a novel distributed Bellman‑Ford‑based algorithm that computes feasible (or optimal) mappings without requiring a global state, and (3) a set of practical heuristics that reduce communication and storage overhead while maintaining high solution quality. The work opens avenues for future research on multi‑constraint QoS (e.g., jitter, reliability), support for more complex DAG topologies, and experimental validation on real network testbeds.