Identifying the connected components of a graph, apart from being a fundamental problem with countless applications, is a key primitive for many other algorithms. In this paper, we consider this problem in parallel settings. Particularly, we focus on the Massively Parallel Computations (MPC) model, which is the standard theoretical model for modern parallel frameworks such as MapReduce, Hadoop, or Spark. We consider the truly sublinear regime of MPC for graph problems where the space per machine is n δ for some desirably small constant δ ∈ (0, 1).We present an algorithm that for graphs with diameter D in the wide range [log n, n], takes O(log D) rounds to identify the connected components and takes O(log log n) rounds for all other graphs. The algorithm is randomized, succeeds with high probability 1 , does not require prior knowledge of D, and uses an optimal total space of O(m). We complement this by showing a conditional lower-bound based on the widely believed 2-Cycle conjecture that Ω(log D) rounds are indeed necessary in this setting.Studying parallel connectivity algorithms received a resurgence of interest after the pioneering work of Andoni et al. [FOCS 2018] who presented an algorithm with O(log D · log log n) round-complexity. Our algorithm improves this result for the whole range of values of D and almost settles the problem due to the conditional lower-bound.Additionally, we show that with minimal adjustments, our algorithm can also be implemented in a variant of the (CRCW) PRAM in asymptotically the same number of rounds. * A preliminary version of this paper is O(1) round algorithm if e.g. D = O( √ n). We refute this possibility and show that indeed for any choice of D ∈ [log 1+Ω(1) , n], there are family of graphs with diameter D on which Ω(log D) rounds are necessary in this regime of MPC, if the 2-Cycle conjecture holds.Theorem 2. Fix some D ≥ log 1+ρ n for a desirably small constant ρ ∈ (0, 1). Any MPC algorithm with n 1−Ω(1) space per machine that w.h.p. identifies each connected component of any given n-vertex graph with diameter D requires Ω(log D ) rounds, unless the 2-Cycle conjecture is wrong.We note that proving any unconditional super constant lower bound for any problem in P, in this regime of MPC, would imply NC 1 P which seems out of the reach of current techniques [59].Extention to PRAM. As a side result, we provide an implementation of our connectivity algorithm in O(log D + log log m/n n) depth in the multiprefix CRCW PRAM model, a parallel computation model that permits concurrent reads and concurrent writes. This implementation of our algorithm performs O((m+n)(log D +log log m/n n)) work and is therefore nearly work-efficient. The following theorem states our result. We defer further elaborations on this result to Appendix B.3.

We introduce the Adaptive Massively Parallel Computation (AMPC) model, which is an extension of the Massively Parallel Computation (MPC) model. At a high level, the AMPC model strengthens the MPC model by storing all messages sent within a round in a distributed data store. In the following round, all machines are provided with random read access to the data store, subject to the same constraints on the total amount of communication as in the MPC model. Our model is inspired by the previous empirical studies of distributed graph algorithms [28,9] using MapReduce and a distributed hash table service [17].This extension allows us to give new graph algorithms with much lower round complexities compared to the best known solutions in the MPC model. In particular, in the AMPC model we show how to solve maximal independent set in O(1) rounds and connectivity/minimum spanning tree in O(log log m/n n) rounds both using O(n δ ) space per machine for constant δ < 1. In the same memory regime for MPC, the best known algorithms for these problems require poly log n rounds. Our results imply that the 2-Cycle conjecture, which is widely believed to hold in the MPC model, does not hold in the AMPC model.

For over a decade now we have been witnessing the success of massive parallel computation (MPC) frameworks, such as MapReduce, Hadoop, Dryad, or Spark. One of the reasons for their success is the fact that these frameworks are able to accurately capture the nature of large-scale computation. In particular, compared to the classic distributed algorithms or PRAM models, these frameworks allow for much more local computation. The fundamental question that arises in this context is though: can we leverage this additional power to obtain even faster parallel algorithms?A prominent example here is the maximum matching problem-one of the most classic graph problems. It is well known that in the PRAM model one can compute a 2-approximate maximum matching in O(log n) rounds. However, the exact complexity of this problem in the MPC framework is still far from understood. Lattanzi et al. (SPAA 2011) showed that if each machine has n 1+Ω(1) memory, this problem can also be solved 2-approximately in a constant number of rounds. These techniques, as well as the approaches developed in the follow up work, seem though to get stuck in a fundamental way at roughly O(log n) rounds once we enter the (at most) near-linear memory regime. It is thus entirely possible that in this regime, which captures in particular the case of sparse graph computations, the best MPC round complexity matches what one can already get in the PRAM model, without the need to take advantage of the extra local computation power.In this paper, we finally refute that perplexing possibility. That is, we break the above O(log n) round complexity bound even in the case of slightly sublinear memory per machine. In fact, our improvement here is almost exponential: we are able to deliver a (2 + ǫ)-approximation to maximum matching, for any fixed constant ǫ > 0, in O (log log n) 2 rounds.To establish our result we need to deviate from the previous work in two important ways that are crucial for exploiting the power of the MPC model, as compared to the PRAM model. Firstly, we use vertexbased graph partitioning, instead of the edge-based approaches that were utilized so far. Secondly, we develop a technique of round compression. This technique enables one to take a (distributed) algorithm that computes an O(1)-approximation of maximum matching in O(log n) independent PRAM phases and implement a super-constant number of these phases in only a constant number of MPC rounds.

No abstract

The version presented here may differ from the published version or, version of record, if you wish to cite this item you are advised to consult the publisher's version. Please see the 'permanent WRAP url' above for details on accessing the published version and note that access may require a subscription.