  We study the problem of computing conjunctive queries over large databases on
parallel architectures without 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$.
  When the data is 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 heavy-hitter elements are available,
obtaining essentially optimal algorithms for queries such as simple joins and
triangle join queries.
  For queries that we identify as tree-like, we also prove nearly matching
upper and lower bounds for multi-round algorithms for a natural class of
skew-free databases. One consequence of these latter lower bounds is that for
any $\varepsilon>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/p^{1-\varepsilon})$ requires $\Omega(\log p)$ 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.
