Distributed Computation in Node-Capacitated Networks

In this paper, we study distributed graph algorithms in networks in which the nodes have a limited communication capacity. Many distributed systems are built on top of an underlying networking infrastructure, for example by using a virtual communication topology known as an overlay network. Although this underlying network might allow each node to directly communicate with a large number of other nodes, the amount of communication that a node can perform in a fixed amount of time is typically much more limited. We introduce the Node-Capacitated Clique model as an abstract communication model, which allows us to study the effect of nodes having limited communication capacity on the complexity of distributed graph computations. In this model, the $n$ nodes of a network are connected as a clique and communicate in synchronous rounds. In each round, every node can exchange messages of $O(\log n)$ bits with at most $O(\log n)$ other nodes. When solving a graph problem, the input graph $G$ is defined on the same set of $n$ nodes, where each node knows which other nodes are its neighbors in $G$. To initiate research on the Node-Capacitated Clique model, we present distributed algorithms for the Minimum Spanning Tree (MST), BFS Tree, Maximal Independent Set, Maximal Matching, and Vertex Coloring problems. We show that even with only $O(\log n)$ concurrent interactions per node, the MST problem can still be solved in polylogarithmic time. In all other cases, the runtime of our algorithms depends linearly on the arboricity of $G$, which is a constant for many important graph families such as planar graphs.

💡 Research Summary

The paper introduces the Node‑Capacitated Clique (NCC) model, a variant of the Congested Clique that reflects realistic bandwidth constraints in large‑scale distributed systems. In NCC, n nodes form a logical complete graph but each node may send and receive messages of O(log n) bits to at most O(log n) distinct neighbors per synchronous round. Excess messages are dropped, limiting the total network traffic to Θ(n log n) bits per round.

The authors first develop a suite of communication primitives tailored to this restrictive setting: (1) aggregation, where many nodes combine values at a single destination; (2) multicast tree construction, enabling a node to broadcast to many recipients while respecting per‑node limits; and (3) random‑hash based collision avoidance to keep inbound traffic within the O(log n) bound. A central technical contribution is an O(a)‑orientation algorithm for the input graph G, where a is the arboricity. By orienting edges so that each node’s out‑degree is O(a), the authors can build low‑degree multicast trees that efficiently route information even for high‑degree vertices.

Using these building blocks, the paper presents distributed algorithms for five classic graph problems, with running times expressed in terms of arboricity a, graph diameter D, and n:

• Minimum Spanning Tree (MST) – solved in O(log⁴ n) rounds, matching the polylogarithmic performance of Congested Clique despite the stricter bandwidth cap.
• Breadth‑First Search (BFS) Tree – constructed in O((a + D + log n)·log n) rounds. The algorithm propagates frontier information via aggregation and then expands each level using the multicast trees.
• Maximal Independent Set (MIS) – achieved in O((a + log n)·log n) rounds by combining a Luby‑style random selection with the a‑orientation to limit the number of messages a high‑degree node must handle.
• Maximal Matching – also completed in O((a + log n)·log n) rounds, reusing the MIS framework and adding a conflict‑resolution phase based on aggregation.
• Vertex Coloring – an O((a + log n)·log^{3/2} n)‑round algorithm that produces an O(a)‑coloring. The method partitions the graph using the orientation, colors each part independently, and resolves color collisions with random hashing.

For graph families with constant arboricity (planar graphs, bounded‑genus graphs, bounded‑treewidth graphs, etc.) all these algorithms run in polylogarithmic time, often independent of the maximum degree Δ. This contrasts with classic CONGEST algorithms whose complexities typically depend on Δ or the diameter D.

The paper further discusses how NCC naturally maps to hybrid network models, where nodes have cheap local links and expensive global links, and to the k‑machine model used for massive graph processing in data centers. In the k‑machine setting, an NCC algorithm that takes T rounds can be simulated in O(nT/k²) rounds, providing a straightforward translation of the results.

A notable challenge addressed by the authors is the inability of high‑degree nodes to communicate directly with all neighbors under the O(log n) per‑round limit. Their solution—orienting the graph to bound out‑degree, then constructing multicast trees that route through low‑degree intermediate nodes—effectively sidesteps this bottleneck while preserving the overall round complexity.

While the paper does not provide formal lower bounds for NCC, it argues that many problems likely require Ω(a) rounds because each edge must convey at least one bit of information (e.g., to inform a neighbor that an incident edge has been removed in MIS). Proving such bounds formally remains an open direction.

In summary, this work establishes a realistic communication model for distributed graph computation, supplies a toolbox of primitives for overcoming per‑node bandwidth limits, and demonstrates that a wide range of fundamental graph problems can be solved efficiently—often in polylogarithmic time—when the underlying graph has low arboricity. The results bridge the gap between theoretical models that assume unlimited node capacity and practical systems where bandwidth per node is a scarce resource.