Communication Cost in Big Data Processing

Communication Cost in Big

Data Processing

Dan Suciu

University of Washington

Joint work with Paul Beame and Paris Koutris

and the Database Group at the UW

Queries on Big Data

Big Data processing on distributed clusters

•

 

General programs: MapReduce, Spark

•

 

SQL: PigLatin,, BigQuery, Shark, Myria…

Traditional Data Processing

•

 

Main cost = disk I/O

Big Data Processing

•

 

Main cost = communication

This Talk

•

 

How much communication is needed to solve

a “problem” on

p

servers?

•

 

“Problem”:

–

 

In this talk = Full Conjunctive Query CQ (

≈

SQL)

–

 

Future work = extend to linear algebra, ML, etc.

•

 

Some techniques discussed in this talk are

implemented in Myria (Bill Howe’s talk)

Models of Communication

•

 

Combined communication/computation cost:

–

 

PRAM

à

MRC [Karloff’2010]

–

 

BSP [Valiant]

à

LogP Model [Culler]

•

 

Explicit communication cost

–

 

[Hong&Kung’81] red/blue pebble games, for I/O

communication complexity

à

[Ballard’2012] extension to parallel algorithms

–

 

MapReduce model [DasSarma’2013]

MPC [Beame’2013,Beame’2014]

– this talk

Outline

•

 

The MPC Model

•

 

Communication Cost for Triangles

•

 

Communication Cost for CQ’s

•

 

Discussion

Massively Parallel Communication

Model (MPC)

Extends BSP [Valiant]

Server 1 . . . . Server p

Input (size=M)

Input data

= size

M

bits

Number of servers

=

p

O(M/p) _O(M/p)

Massively Parallel Communication

Model (MPC)

Extends BSP [Valiant] Server 1 . . . . Server p Server 1 . . . . Server p Input (size=M) Round 1

Input data

= size

M

bits

One round

=

Compute & communicate

Number of servers

=

p

O(M/p) _O(M/p)

Massively Parallel Communication

Model (MPC)

Extends BSP [Valiant] Server 1 . . . . Server p Server 1 . . . . Server p Server 1 . . . . Server p Input (size=M) . . . . Round 1 Round 2 Round 3 . . . .

Input data

= size

M

bits

Algorithm

= Several rounds

One round

=

Compute & communicate

Number of servers

=

p

O(M/p) _O(M/p)

Massively Parallel Communication

Model (MPC)

Extends BSP [Valiant] Server 1 . . . . Server p Server 1 . . . . Server p Server 1 . . . . Server p Input (size=M) . . . . Round 1 Round 2 Round 3 . . . .

Input data

= size

M

bits

Max communication load per server

=

L

Algorithm

= Several rounds

One round

=

Compute & communicate

Number of servers

=

p

L L L L L L O(M/p) _O(M/p) 9

Massively Parallel Communication

Model (MPC)

Extends BSP [Valiant] Server 1 . . . . Server p Server 1 . . . . Server p Server 1 . . . . Server p Input (size=M) . . . . Round 1 Round 2 Round 3 . . . .

Input data

= size

M

bits

Max communication load per server

=

L

Ideal:

L

=

M

/

p

This talk:

L

=

M

/

p * p

ε

_{, where}

_ε

_{in [0,1] is called}

_{space exponent}

Degenerate:

L

=

M

(send everything to one server)

Algorithm

= Several rounds

One round

=

Compute & communicate

Number of servers

=

p

L L L L L L O(M/p) _O(M/p) 10

Example:

Q(x,y,z) = R(x,y)

⋈

_S(y,z)

Server 1 . . . . Server p M/p _M/p

Input:

• 

R

,

S

uniformly

partitioned on

p

servers

size(R)+size(S)=M 11

Example:

Q(x,y,z) = R(x,y)

⋈

_S(y,z)

Server 1 . . . . Server p Server 1 . . . . Server p Round 1 O(M/p) O(M/p) M/p _M/p

Round 1: each server

•

 

Sends record

R(x,y)

to server

h(y) mod p

•

 

Sends record

S(y,z)

to server

h(y) mod p

Input:

• 

R

,

S

uniformly

partitioned on

p

servers

size(R)+size(S)=M

Example:

Q(x,y,z) = R(x,y)

⋈

_S(y,z)

Server 1 . . . . Server p Server 1 . . . . Server p Round 1 O(M/p) O(M/p) M/p _M/p

R(x,y) ⋈ S(y,z) R(x,y) ⋈ S(y,z)

Output:

•

 

Each server computes and outputs

the local join

R(x,y)

⋈

_S(y,z)

Round 1: each server

•

 

Sends record

R(x,y)

to server

h(y) mod p

•

 

Sends record

S(y,z)

to server

h(y) mod p

Input:

• 

R

,

S

uniformly

partitioned on

p

servers

size(R)+size(S)=M

Example:

Q(x,y,z) = R(x,y)

⋈

_S(y,z)

Server 1 . . . . Server p Server 1 . . . . Server p Round 1 O(M/p) O(M/p) M/p _M/p

R(x,y) ⋈ S(y,z) R(x,y) ⋈ S(y,z)

Output:

•

 

Each server computes and outputs

the local join

R(x,y)

⋈

_S(y,z)

Round 1: each server

•

 

Sends record

R(x,y)

to server

h(y) mod p

•

 

Sends record

S(y,z)

to server

h(y) mod p

Input:

• 

R

,

S

uniformly

partitioned on

p

servers

Assuming no Skew:

∀

y,

degree

_R

(y), degree

_S

(y)

≤

M

/

p

Rounds

=

1

Load

L

= O(

M

/

p

) =

O(

M

/

p * p

0

₎

size(R)+size(S)=M

Space exponent = 0

Example:

Q(x,y,z) = R(x,y)

⋈

_S(y,z)

Server 1 . . . . Server p Server 1 . . . . Server p Round 1 O(M/p) O(M/p) M/p _M/p

R(x,y) ⋈ S(y,z) R(x,y) ⋈ S(y,z)

Output:

•

 

Each server computes and outputs

the local join

R(x,y)

⋈

_S(y,z)

Round 1: each server

•

 

Sends record

R(x,y)

to server

h(y) mod p

•

 

Sends record

S(y,z)

to server

h(y) mod p

Input:

• 

R

,

S

uniformly

partitioned on

p

servers

Assuming no Skew:

∀

y,

degree

_R

(y), degree

_S

(y)

≤

M

/

p

Rounds

=

1

Load

L

= O(

M

/

p

) =

O(

M

/

p * p

0

₎

size(R)+size(S)=M Space exponent = 0

SQL is

embarrassingly

parallel!

Questions

Fix a query

Q

and a number of servers

p

•

 

What is the communication load

L

needed

to compute

Q

in

one round

? This talk

based on [Beame’2013, Beame’2014]

•

 

Fix a maximum load

L

(space exponent

ε

)

How

many rounds

are needed for

Q

?

Preliminary results in [Beame’2013]

Outline

•

 

The MPC Model

•

 

Communication Cost for Triangles

•

 

Communication Cost for CQ’s

•

 

Discussion

The Triangle Query

•

 

Input

: three tables

R(X, Y), S(Y, Z), T(Z, X)

size(

R

)+size(

S

)+size(

T

)=

M

•

 

Output

: compute

Q(x,y,z) = R(x,y)

⋈

S(y,z)

⋈

T(z,x)

Z X Fred Alice Jack Jim Fred Jim Carol Alice … Y Z Fred Alice Jack Jim Fred Jim Carol Alice … X Y Fred Alice Jack Jim Fred Jim Carol Alice … R S T 18

Triangles in Two Rounds

•

 

Round 1: compute

temp(X,Y,Z) = R(X,Y)

⋈

S(Y,Z)

•

 

Round 2: compute

Q(X,Y,Z) = temp(X,Y,Z)

⋈

T(Z,X)

Load

L

depends on the size of

temp

. Can

be much larger than

M

/

p

Triangles in One Round

•

 

Factorize

p

=

p

⅓

×

p

⅓

×

p

⅓

•

 

Each server identified by (

i

,

j

,

k

)

i j

k

(i,j,k)

P⅓

Place the servers in a cube: _{Server (i,j,k)}

[Ganguli’92, Afrati&Ullman’10, Suri’11, Beame’13]

20

Triangles in One Round

k (i,j,k) P⅓ Z X Fred Alice Jack Jim Fred Jim Carol Alice … Jack Jim Y Z Fred Alice Jack Jim Fred Jim Carol Alice Jim Jack Jim Jack X Y Fred Alice Jack Jim Fred Jim Carol Alice … R S T i = h(Fred) j = h(Jim) Fred Jim Fred Jim Fred Jim Fred Jim Jim Jack Jim Jack Fred Jim Jim Jack Jim Jack Fred Jim Fred Jim

Jack _Jack Jim _Jim

Round 1:

Send R(x,y) to all servers (h(x),h(y),*) Send S(y,z) to all servers (*, h(y), h(z)) Send T(z,x) to all servers (h(x), *, h(z))

Output:

compute locally R(x,y) ⋈ S(y,z) ⋈ T(z,x)

21

Upper Bound is

L

_algo

= O(

M

/

p

⅔

₎

22

Theorem

Assume data has no skew: all degree

≤

O(

M

/

p

⅓

_).

Then the algorithm computes

Q

in one round,

with communication load

L

_algo

= O(

M

/

p

⅔

₎

Compare to two rounds:

•

 

No more large intermediate result

•

 

Skew-free up to degrees = O(

M

/

p

⅓

) (from O(

M

/

p

))

•

 

BUT: space exponent increased to

ε

=

⅓

(from

ε

= 1

)

Q(X,Y,Z) = R(X,Y)

⋈

S(Y,Z)

⋈

T(Z,X)

M

= size(

R

)+size(

S

)+size(

T

) (in bits)

Lower Bound is

L

_lower

=

M

/

p

⅔

# without this assumption need to add a multiplicative factor 3

* Beame, Koutris, Suciu, Communication Steps for Parallel Query Processing, PODS 2013

M

= size(

R

)+size(

S

)+size(

T

) (in bits)

23

Lower Bound is

L

_lower

=

M

/

p

⅔

# without this assumption need to add a multiplicative factor 3

* Beame, Koutris, Suciu, Communication Steps for Parallel Query Processing, PODS 2013

M

= size(

R

)+size(

S

)+size(

T

) (in bits)

24

Theorem

* Any one-round deterministic algorithm

A

for

Q

requires

L

_lower

bits of communication per server

Q(X,Y,Z) = R(X,Y)

⋈

S(Y,Z)

⋈

T(Z,X)

Assume that the three input relations R, S, T are stored on disjoint servers#

Lower Bound is

L

_lower

=

M

/

p

⅔

M

= size(

R

)+size(

S

)+size(

T

) (in bits)

25

Theorem

* Any one-round deterministic algorithm

A

for

Q

requires

L

_lower

bits of communication per server

We prove a stronger claim, about any algorithm communicating <

L

_lower

bits

Let

L

be the algorithm’s max communication load per server

We prove:

if

L

<

L

_lower

then, over random permutations

R, S, T,

the algorithm returns at most a fraction (

L

/

L

_lower

)

3/2

_{of the answers to}

_Q

Q(X,Y,Z) = R(X,Y)

⋈

S(Y,Z)

⋈

T(Z,X)

# without this assumption need to add a multiplicative factor 3

* Beame, Koutris, Suciu, Communication Steps for Parallel Query Processing, PODS 2013

Assume that the three input relations R, S, T are stored on disjoint servers#

Lower Bound is

L

_lower

=

M

/

p

⅔

Discussion:

•

 

An algorithm with space exponent

ε

<

⅓

, has load

L = M/p

1-ε

_{and reports only (}

_L

_/

_L

lower

)

3/2

=

1/p

(1-3ε)/2

fraction of all answers. Fewer, as

p

increases!

•

 

Lower bound holds only for random inputs: cannot

hold for fixed input

R, S, T

since the algorithm may

use a short bit encoding to signal this input to all

servers

•

 

By Yao’s lemma, the result also holds for

randomized algorithms, some fixed input

26

[Balard’2012] consider Strassen’s matrix multiplication

algorithm

and prove

the following theorem for the

CDAG

model. If each server has

M

_

c

_·

_p2n/2lg7

memory, then the communication load per server:

IO

(n, p, M

) =

⌦

✓

n

p

M

◆

lg7

M

p

!

Thus, if

M

=

_p2n_/2_lg7

then

IO

(

n, p

) =

⌦

⇣

_p2/n2_lg7

⌘

Lower Bound is

L

_lower

=

M

/

p

⅔

•

 

Stronger than MPC: no restriction on rounds

•

 

Weaker than MPC

–

 

Applies only to an algorithm, not to a problem

–

 

CDAG model of computation v.s. bit-model

27

Q(X,Y,Z) = R(X,Y)

⋈

S(Y,Z)

⋈

T(Z,X)

M here same as n2 _here

Lower Bound is

L

_lower

=

M

/

p

⅔

Q(X,Y,Z) = R(X,Y)

⋈

S(Y,Z)

⋈

T(Z,X)

Proof

28

Lower Bound is

L

_lower

=

M

/

p

⅔

Q(X,Y,Z) = R(X,Y)

⋈

S(Y,Z)

⋈

T(Z,X)

Proof

E [#answers to Q] = Σ_i,j,k Pr [(i,j,k) ∈ R⋈S⋈T] = n3 _{* (1/n)}3 _{= 1}

29

Input: size = M = 3 log n!

•  R, S, T random permutations on [n]: Pr [(i,j) ∈R] = 1/n, same for S, T

Lower Bound is

L

_lower

=

M

/

p

⅔

Q(X,Y,Z) = R(X,Y)

⋈

S(Y,Z)

⋈

T(Z,X)

Proof

E [#answers to Q] = Σ_i,j,k Pr [(i,j,k) ∈ R⋈S⋈T] = n3 _{* (1/n)}3 _{= 1}

30

One server v ∈[p]: receives L(v) = L_R(v) + L_S(v) + L_T(v) bits •  Denote a_ij = Pr [(i,j)∈R and v knows it]

Then (1) a_ij ≤ 1/n (obvious) (2) Σ_i,j a_ij ≤ L_R(v) / log n (formal proof: entropy) •  Denote similarly b_jk,c_ki for S and T

Input: size = M = 3 log n!

•  R, S, T random permutations on [n]: Pr [(i,j) ∈R] = 1/n, same for S, T

Lower Bound is

L

_lower

=

M

/

p

⅔

Q(X,Y,Z) = R(X,Y)

⋈

S(Y,Z)

⋈

T(Z,X)

Proof

E [#answers to Q] = Σ_i,j,k Pr [(i,j,k) ∈ R⋈S⋈T] = n3 _{* (1/n)}3 _{= 1}

31

One server v ∈[p]: receives L(v) = L_R(v) + L_S(v) + L_T(v) bits •  Denote a_ij = Pr [(i,j)∈R and v knows it]

Then (1) a_ij ≤ 1/n (obvious) (2) Σ_i,j a_ij ≤ L_R(v) / log n (formal proof: entropy) •  Denote similarly b_jk,c_ki for S and T

•  E [#answers to Q reported by server v] = Σ_i,j,k a_ij b_jk c_ki ≤ [(Σ_i,j a_ij2_{) * (Σ}

j,k bjk2) * (Σk,i cki2)]½ [Friedgut]

≤ (1/n) 3/2 _{* [ L}

R(v) * LS(v) * LT(v) / log3 n ]½ by (1), (2)

≤ (1/n) 3/2 _{* [ L(v) / 3* log n ]}3/2 _{geometric/arithmetic}

= [ L(v) / M ]3/2 _{expression for M above}

Input: size = M = 3 log n!

•  R, S, T random permutations on [n]: Pr [(i,j) ∈R] = 1/n, same for S, T

Lower Bound is

L

_lower

=

M

/

p

⅔

Q(X,Y,Z) = R(X,Y)

⋈

S(Y,Z)

⋈

T(Z,X)

Proof

E [#answers to Q] = Σ_i,j,k Pr [(i,j,k) ∈ R⋈S⋈T] = n3 _{* (1/n)}3 _{= 1}

E [#answers to Q reported by all servers]

≤ Σ_v [ L(v) / M ]3/2 _{= p * [ L / M ]} 3/2 _{= [ L / L}

lower ]3/2

32

Input: size = M = 3 log n!

•  R, S, T random permutations on [n]: Pr [(i,j) ∈R] = 1/n, same for S, T

One server v ∈[p]: receives L(v) = L_R(v) + L_S(v) + L_T(v) bits •  Denote a_ij = Pr [(i,j)∈R and v knows it]

Then (1) a_ij ≤ 1/n (obvious) (2) Σ_i,j a_ij ≤ L_R(v) / log n (formal proof: entropy) •  Denote similarly b_jk,c_ki for S and T

•  E [#answers to Q reported by server v] = Σ_i,j,k a_ij b_jk c_ki ≤ [(Σ_i,j a_ij2_{) * (Σ}

j,k bjk2) * (Σk,i cki2)]½ [Friedgut]

≤ (1/n) 3/2 _{* [ L}

R(v) * LS(v) * LT(v) / log3 n ]½ by (1), (2)

≤ (1/n) 3/2 _{* [ L(v) / 3* log n ]}3/2 _{geometric/arithmetic}

= [ L(v) / M ]3/2 _{expression for M above}

Outline

•

 

The MPC Model

•

 

Communication Cost for Triangles

•

 

Communication Cost for CQ’s

•

 

Discussion

General Formula

Consider an arbitrary conjunctive query (CQ):

We will:

•

 

Give a lower bound

L

_lower

formula

•

 

Give an algorithm with load

L

_algo

•

 

Prove that

L

_lower

=

L

_algo

34

Q

(

x

₁

, . . . , x

_k

) =

S

₁

(

x

₁

)

o

n

. . .

o

n

S

_`

(

x

_`

)

Cartesian Product

Cartesian Product

S₁(x) à

S

2_(y)

à

Q(x,y) = S₁(x) × S₂(y) _{size(S1)=M1, size(S2) = M2}

L

_algo

= 2

✓

M

₁

_·

M

₂

p

◆

1 2

Algorithm

: factorize

p

=

p

₁

×

p

₂

•

 

Send

S

₁

(x)

to all servers (

h(x)

,*)

Send

S

₂

(y)

to all servers (*,

h(y)

)

•

 

Load =

M

₁

/

p

₁

+

M

₂

/

p

₂

;

Cartesian Product

37 S₁(x) à S 2_(y) à

Q(x,y) = S₁(x) × S₂(y) _{size(S1)=M1, size(S2) = M2}

L

_algo

= 2

✓

M

₁

_·

M

₂

p

◆

1 2

L

_lower

= 2

✓

M

₁

_·

M

₂

p

◆

1 2

Lower bound:

•

 

Let

L(v) = L

₁

(

v

) +

L

₂

(

v

) = load at server

v

•

 

The

p

servers must report all answers to

Q

:

M

₁

M

₂

≤

Σ

_v

L

₁

(

v

) *

L

₂

(

v

)

≤

½

Σ

_v

(

L

(

v

))

2

≤

½

p

max

_v

(

L

(

v

))

2

Algorithm

: factorize

p

=

p

₁

×

p

₂

•

 

Send

S

₁

(x)

to all servers (

h(x)

,*)

Send

S

₂

(y)

to all servers (*,

h(y)

)

•

 

Load =

M

₁

/

p

₁

+

M

₂

/

p

₂

;

A Simple Observation

Q(x1, . . . , xk) = S1(x1) on . . . on S`(x`) size(S1) = M1,size(S2) = M2, . . . ,size(S`) = M`

Proof similar to cartesian product on previous slide

Definition

An

edge packing

for

Q

is a set of atoms with no common variables:

U

=

_{

S

_j1

(x

_j1

)

,

S

_j2

(x

_j2

)

, . . . ,

S

_j|U|

(x

_j|U|

)

_}

₈

i, k

:

x

_ji

_\

x

_jk

=

_;

Claim

Any one-round algorithm for

Q

must also compute the cartesian product:

Q

0

(

x

_j1

, . . . ,

x

_j|U|

) =

S

_j1

(

x

_j1

)

o

n

S

_j2

(

x

_j2

)

o

n

. . .

o

n

S

_j|U|

(

x

_j|U|

)

Proof

Because the algorithm doesn’t know the other

S

_j

’s.

L

_lower

=

_|

U

_|

_·

✓

_M

j₁

·

M

j₂

· · ·

M

j_|U|

p

◆

1 |U|

Assume that the three input relations

S

₁

, S

₂

, …

are stored on disjoint servers

#

The Lower Bound for CQ

39

Q(x1, . . . , xk) = S1(x1) on . . . on S`(x`) size(S1) = M1,size(S2) = M2, . . . ,size(S`) = M`

Theorem

* Any one-round deterministic algorithm

A

for

Q

requires O(

L

_lower

) bits of communication per server:

L

_lower

=

✓

M

₁

u

1

·

M

2

u

2

· · ·

M

`

u

`

p

◆

1 u₁+u₂+_···+u_`

*Beame, Koutris, Suciu, Skew in Parallel Data Processing, PODS 2014

Note that we ignore constant factors (like |U| on the previous slide)

Definition

A

fractional edge packing

are real numbers

u

1

, u

2

, . . . , u

`

s.t.:

8

j

₂

[

`

] :

u

_j

0

8

i

₂

[

k

] :

X

j₂[`]:xi2vars(Sj(xj))

Triangle Query Revisited

40

Q(X,Y,Z) = R(X,Y)

⋈

S(Y,Z)

⋈

T(Z,X) size(R) = M1, size(S) = M2, size(T) = M3

Packing

u

₁

,

u

₂

,

u

₃

L

= (

M

₁u1

_*

_M

2u2

*

M

3u3

/

p

)

1/(u1+u2+u3)

½

,

½

,

½

(

M

₁

M

₂

M

₃

)

⅓

_/

_p

⅔

1

,

0

,

0

M

₁

/

p

0

,

1

,

0

M

₂

/

p

0

,

0

,

1

M

₃

/

p

L

_lower

= the largest of these four values

When

M

₁

=

M

₂

=

M

₃

=

M

, then the largest value is the first:

M

/

p

⅔

x y

z

½

½ ½

An Algorithm for CQ

[Afrati&Ullman’2010]

Factorize

p

=

p

₁

×

p

₂

×

…

×

p

_k

;

a server is (

v

₁

, …,

v

_k

)

∈

[

p

₁

]

×

…

×

[

p

_k

]

•

 

Send

S

₁

(x

₁₁

, x

₁₂

, …)

to servers with coordinates

h(x

₁₁

)

,

h(x

₁₂

)

, …

•

 

Send

S

₂

(x

₂₁

, x

₂₂

, …)

to servers with coordinates

h(x

₂₁

)

,

h(x

₂₂

)

, …

•

 

…

•

 

Compute the query locally at each server

•

 

Load is O(

L

_algo

), where:

Q(x1, . . . , xk) = S1(x1) on . . . on S`(x`) size(S1) = M1,size(S2) = M2, . . . ,size(S`) = M`

[A&U] use sum instead of max. With max we can compute the optimal p₁, p₂, …, p_k

L

_algo

= max

j

₂

[

`

]

M

_j

Q

L

_lower

=

L

_algo

Q(x1, . . . , xk) = S1(x1) on . . . on S`(x`) size(S1) = M1,size(S2) = M2, . . . ,size(S`) = M`

L

_lower

=

✓ Q

j

M

juj

p

◆

_P 1 j uj

Apply log in base p. Denote µ_j = log_p M_j, e_i = log_p p_i

L

_algo

=

max

_j

Q

M

j

L

_lower

=

L

_algo

Q(x1, . . . , xk) = S1(x1) on . . . on S`(x`) size(S1) = M1,size(S2) = M2, . . . ,size(S`) = M`

L

_lower

=

✓ Q

j

M

juj

p

◆

_P 1 j uj

Apply log in base p. Denote µ_j = log_p M_j, e_i = log_p p_i

minimize

X

i

e

i



1

8

j

:

+

X

j:xi2vars(Sj)

e

i

µ

j

L

_algo

=

max

_j

Q

M

j

i

:

x

i

2

vars

(

S

j

)

p

i

L

_lower

=

L

_algo

Q(x1, . . . , xk) = S1(x1) on . . . on S`(x`) size(S1) = M1,size(S2) = M2, . . . ,size(S`) = M`

L

_lower

=

✓ Q

j

M

juj

p

◆

_P 1 j uj

Apply log in base p. Denote µ_j = log_p M_j, e_i = log_p p_i

minimize

X

i

e

i



1

8

j

:

+

X

j:xi2vars(Sj)

e

i

µ

j

maximize

₍

X

j

f

j

µ

j

f

0

)

X

j

f

j



1

8

i

:

X

j:xi2vars(Sj)

f

j



f

0 Primal/Dual u_j = f_j / f₀ u₀ = 1 / f₀ at optimality: u₀ = Σ_j u_j

L

_algo

=

max

_j

Q

M

j

i

:

x

i

2

vars

(

S

j

)

p

i

Outline

•

 

The MPC Model

•

 

Communication Cost for Triangles

•

 

Communication Cost for CQ’s

•

 

Discussion

Discussion

Communication costs for multiple rounds

•

 

Lower/upper bounds in [Beame’13] connect the

number of rounds to log of the query diameter

•

 

Weaker communication model: algorithm sends

only tuples, not arbitrary bits

Communication cost for skewed data

•

 

Lower/upper bounds in [Beame’14] have a gap of

poly log p

Communication costs beyond full CQ’s

•

 

Open!