Communication steps for parallelquery processing

Abstract

We study the problem of computing conjunctive queries over large databases on parallel architectureswithout shared storage. Using the structure of such a query q and the skew in the data, we study tradeoffs between the number of processors, the number of rounds of communication, and the per-processor load-the number of bits each processor can send or can receive in a single round-that are required to compute q. Since each processor must store its received bits, the load is at most the number of bits of storage per processor. When the data are free of skew, we obtain essentially tight upper and lower bounds for one round algorithms, and we show how the bounds degrade when there is skew in the data. In the case of skewed data, we show how to improve the algorithms when approximate degrees of the (necessarily small number of) heavyhitter elements are available, obtaining essentially optimal algorithms for queries such as skewed simple joins and skewed triangle join queries. For queries that we identify as treelike, we also prove nearly matching upper and lower bounds for multiround algorithms for a natural class of skew-free databases. One consequence of these latter lower bounds is that for any ϵ > 0, using p processors to compute the connected components of a graph, or to output the path, if any, between a specified pair of vertices of a graph with m edges and per-processor load that is O(m/p1-ϵ ) requires Ω(logp) rounds of communication. Our upper bounds are given by simple structured algorithms using MapReduce. Our one-round lower bounds are proved in a very general model, which we call the Massively Parallel Communication (MPC) model, that allows processors to communicate arbitrary bits. Our multi-round lower bounds apply in a restricted version of the MPC model in which processors in subsequent rounds after the first communication round are only allowed to send tuples.