Resource Allocation for Multiple Concurrent In-Network Stream-Processing Applications

This paper investigates the operator mapping problem for in-network stream-processing applications. In-network stream-processing amounts to applying one or more trees of operators in steady-state, to multiple data objects that are continuously updated at different locations in the network. The goal is to compute some final data at some desired rate. Different operator trees may share common subtrees. Therefore, it may be possible to reuse some intermediate results in different application trees. The first contribution of this work is to provide complexity results for different instances of the basic problem, as well as integer linear program formulations of various problem instances. The second second contribution is the design of several polynomial-time heuristics. One of the primary objectives of these heuristics is to reuse intermediate results shared by multiple applications. Our quantitative comparisons of these heuristics in simulation demonstrates the importance of choosing appropriate processors for operator mapping. It also allow us to identify a heuristic that achieves good results in practice.

💡 Research Summary

This paper addresses the operator‑mapping problem that arises when several stream‑processing applications run concurrently inside a network. In‑network stream processing consists of continuously applying one or more trees of operators to data objects that are constantly updated at distributed locations (e.g., sensor readings, video frames). Each application is modeled as a binary operator tree whose leaves are basic objects and whose internal nodes perform aggregation or transformation operations. The goal is to produce final results at a prescribed throughput (QoS) for each application while using as few computational and communication resources as possible.

The authors first formalize the problem. They consider a set of K applications, each with its own throughput requirement ρ(k). The underlying platform is a fully connected network of processors P. Each processor u has a compute speed s_u and a network‑card bandwidth B_u; each link (u,v) has a bandwidth b_{u,v}. Operators may need to download basic objects (incurring bandwidth proportional to object size and update frequency) and to receive intermediate results from child operators. An allocation function a(k,i)=u maps node i of application k to processor u. The model captures three kinds of traffic: (i) downloads of basic objects, (ii) transmissions of intermediate results from children to parents, and (iii) transmissions of intermediate results from a processor to its parent’s processor. The mapping must respect (a) the per‑processor compute capacity, (b) the per‑processor and per‑link bandwidth caps, and (c) the throughput constraints of all applications.

Two scenarios are distinguished. In earlier work the authors studied a “constructive” setting where resources could be bought; here they focus on a “non‑constructive” setting where a fixed set of processors and links is given and the objective is to minimize the number of used processors (or equivalently the total resource consumption) while meeting all QoS constraints.

Complexity analysis shows that the general mapping problem is NP‑hard, essentially because it combines a multidimensional knapsack (assigning operators to processors under compute and bandwidth limits) with a network‑flow feasibility component. Certain restricted cases become polynomial: (i) homogeneous platforms (identical processors and links) admit polynomial‑time algorithms, and (ii) left‑deep trees allow dynamic‑programming solutions.

To obtain exact solutions the authors formulate integer linear programs (ILPs) that encode the allocation variables, the bandwidth consumption on each link, and the compute load on each processor. The objective can be either the number of active processors or a weighted sum of compute and communication costs. While ILP solves small instances optimally, its size grows quickly (variables proportional to K·|tree|·|P|), making it impractical for realistic scales.

Consequently, the paper proposes several polynomial‑time heuristics designed to exploit the most important practical feature: reuse of common sub‑expressions across different applications. The heuristics are:

1. Greedy‑Reuse (GR) – Scans all operators, and whenever an operator already placed on some processor can serve another application’s identical operator, it is assigned to the same processor. This maximizes sharing of intermediate results and reduces duplicate computation.

2. Load‑Balanced (LB) – Maintains a view of each processor’s current compute and bandwidth load; each new operator is placed on the processor with the most remaining capacity, aiming to keep the system balanced and avoid hotspots.

3. Bandwidth‑Aware (BA) – Estimates the total download and inter‑processor traffic generated by each operator. Operators are placed so that the most bandwidth‑intensive data transfers are minimized, e.g., by co‑locating operators that exchange large intermediate results.

4. Hybrid (HY) – Combines GR and BA: first attempts maximal reuse, then re‑assigns operators that would cause severe bandwidth overload to alternative processors identified by the BA step.

All heuristics run in O(K·|tree|·|P|) time and are straightforward to implement in a real system.

The authors evaluate the heuristics through extensive simulations. Testbeds include 20–50 processors, link bandwidths ranging from 100 Mbps to 1 Gbps, and 10–30 concurrent applications with tree depths of 4–8 and 5–10 distinct operator types. QoS requirements vary from 1 to 10 operations per second per application. Metrics measured are (i) number of processors actually used, (ii) total compute load, (iii) total network bandwidth consumption, and (iv) whether all throughput constraints are satisfied.

Results show that Greedy‑Reuse achieves the largest reduction in processor count (30 %–45 % fewer processors than a naïve allocation) because it exploits common sub‑trees aggressively; it also yields a high reuse ratio (over 60 % of operators are shared). Load‑Balanced guarantees that all applications meet their throughput targets most reliably, especially when the system is heavily loaded. Bandwidth‑Aware excels in scenarios where link capacities are tight, cutting overall bandwidth usage by 20 %–35 % compared with naïve placement. The Hybrid heuristic consistently delivers a balanced performance, often matching the best of the other three in each metric.

A key experimental observation is that duplicating basic objects across processors is costly unless it eliminates redundant downloads; therefore, the heuristics that co‑locate operators needing the same objects tend to perform better. Moreover, the benefit of sharing intermediate results grows with the number of concurrent applications, confirming the intuition that multi‑application environments can achieve substantial savings through sub‑expression reuse.

In conclusion, the paper establishes that optimal operator mapping for multiple concurrent in‑network stream‑processing applications is computationally intractable in the general case, but practical polynomial‑time heuristics can achieve near‑optimal resource utilization. The main insights are: (1) identify and reuse common sub‑trees across applications, (2) balance compute load while respecting per‑processor bandwidth caps, and (3) consider both download traffic of basic objects and inter‑operator traffic when placing operators. Future work suggested includes dynamic re‑mapping for time‑varying workloads, incorporating energy consumption into the objective, and integrating the proposed heuristics into real stream‑processing frameworks such as Apache Flink or Spark Streaming for empirical validation on production clusters.