[Paper Review] Finding Connected Components on Map-reduce in Logarithmic Rounds

Vibhor Rastogi, Ashwin Machanavajjhala+2 more|arXiv (Cornell University)|Mar 24, 2012

Graph Theory and Algorithms14 references4 citations

TL;DR

This paper presents two novel map-reduce algorithms—Hash-Greater-to-Min and Hash-to-Min—for computing connected components in large graphs with logarithmic rounds. By leveraging randomized hashing and secondary sorting to manage cluster merging efficiently, both algorithms achieve $O(\log n)$ rounds and linear communication per round, significantly outperforming prior methods in practice, especially under high data skew and memory constraints.

ABSTRACT

Given a large graph G = (V,E) with millions of nodes and edges, how do we compute its connected components efficiently? Recent work addresses this problem in map-reduce, where a fundamental trade-off exists between the number of map-reduce rounds and the communication of each round. Denoting d the diameter of the graph, and n the number of nodes in the largest component, all prior map-reduce techniques either require d rounds, or require about n|V| + |E| communication per round. We propose two randomized map-reduce algorithms -- (i) Hash-Greater-To-Min, which provably requires at most 3log(n) rounds with high probability, and at most 2(|V| + |E|) communication per round, and (ii) Hash-to-Min, which has a worse theoretical complexity, but in practice completes in at most 2log(d) rounds and 3(|V| + |E|) communication per rounds. Our techniques for connected components can be applied to clustering as well. We propose a novel algorithm for agglomerative single linkage clustering in map-reduce. This is the first algorithm that can provably compute a clustering in at most O(log(n)) rounds, where n is the size of the largest cluster. We show the effectiveness of all our algorithms through detailed experiments on large synthetic as well as real-world datasets.

Motivation & Objective

• To address the fundamental trade-off in map-reduce between round count and communication cost for connected components computation.
• To design efficient, scalable map-reduce algorithms that complete in $O(\log n)$ rounds with low per-round communication, even for graphs with very large connected components.
• To overcome memory and data skew issues in large-scale graph processing by avoiding materialization of entire clusters during merging.
• To extend the proposed techniques to single-linkage agglomerative clustering, enabling $O(\log n)$ round clustering in map-reduce for the first time.
• To demonstrate through experiments that the proposed algorithms outperform existing map-reduce and BSP-based approaches under shared, congested cluster environments.

Proposed method

• Uses a randomized hashing strategy in Hash-Greater-to-Min to simulate PRAM algorithms, ensuring each cluster is replicated exactly once to minimize communication.
• Employs secondary sorting in map-reduce to maintain sorted node lists per cluster key, enabling in-memory duplicate removal during cluster merging without full cluster materialization.
• Applies pointer-doubling techniques from PRAM literature to efficiently propagate cluster IDs across graph distances in logarithmic rounds.
• Introduces Hash-to-Min, a novel algorithm that provably terminates in $O(\log n)$ rounds for path graphs, with a novel but non-tight proof technique.
• Extends the framework to clustering by designing Hash-to-All and Hash-to-Min variants for single-linkage agglomerative clustering, using similar merging and sorting strategies.
• Employs a hybrid approach where mappers emit nodes with cluster IDs, reducers merge sorted node lists to remove duplicates, and cluster IDs are propagated iteratively.

Experimental results

Research questions

• RQ1 Can connected components be computed in map-reduce using only $O(\log n)$ rounds while maintaining linear communication per round?
• RQ2 How can large connected components be processed efficiently in map-reduce without materializing entire clusters in memory?
• RQ3 Can the performance of map-reduce algorithms for connected components be improved over existing $\Theta(d)$-round or $\Theta(n|V|+|E|)$-communication methods?
• RQ4 Is it possible to design a map-reduce clustering algorithm that completes in $O(\log n)$ rounds for single-linkage clustering?
• RQ5 How does map-reduce compare to bulk-synchronous parallel (BSP) models in terms of scalability under shared, congested cluster workloads?

Key findings

• Hash-to-Min completes in at most $2\log d$ rounds and $3(|V|+|E|)$ communication per round in practice, outperforming Hash-Greater-to-Min despite a less tight theoretical bound.
• The algorithm achieves $O(\log n)$ rounds for path graphs, with a novel proof technique that is not tight but captures practical behavior.
• Experiments show that Hash-to-Min is faster than Hash-Greater-to-Min on both synthetic and real-world datasets like MovieW and BizW.
• In shared, congested clusters, map-reduce with Hash-to-Min scales better than BSP (e.g., Giraph), with mr-15 completing in ~20 minutes while bsp-15 took over an hour due to lack of job-level parallelism in BSP.
• The use of secondary sorting enables efficient duplicate removal during cluster merging without materializing full clusters, solving memory and skew issues.
• The paper presents the first map-reduce algorithms for single-linkage clustering that complete in $O(\log n)$ rounds, with Hash-to-Min conjectured to require $O(\log d)$ rounds and $O(|V|+|E|)$ communication per round.