Computational Frameworks

MapReduce

1

OUTLINE

1 MapReduce

2 Basic Techniques and Primitives

2

MapReduce

3

Motivating scenario

At the dawn of the big-data era (early 2000’s), the following scenario wasrapidly emerging

• In a wide spectrum of domains there was an increasing need toanalyze large amounts of data.

• Available tools and commonly used platforms could not practicallyhandle very large datasets.

• Algorithms with high polynomial complexities were unfeasible,and platforms had limited main memory.

• In extreme cases, even touching all data items would provequite time consuming. (E.g., ' 50 · 109 web pages of about20KB each → 1000TB of data.)

• The use of powerful computing systems, which has been confineduntil then to a limited number of applications –typically fromcomputational sciences (physics, biology, weather forecast,simulations)– was becoming necessary for a much wider array ofapplications.

4

Motivating scenario

The use of powerful computing systems based on eithertightly-coupled parallel architectures or more loosely-coupleddistributed platforms poses several problems

• These systems are costly to buy and to maintain, and theybecome rapidly obsolete.

• Fault-tolerance becomes serious issue: a large number ofcomponents implies a low Mean-Time Between Failures(MTBF).

• Developing software that effectively benefits from parallelismrequires sophisticated programming skills.

5

MapReduce

• Introduced by Google in 2004 as a programming framework for bigdata processing on distributed platforms.

• Its original formulation (see [DG08]) contained

• A programming model• An implementation tailored towards a cluster-based computing

environment.

• Since then, MapReduce implementations have been employed onclusters of commodity processors and cloud infrastructures for awide array of big-data applications

• Main features:

• Data centric view

• Inspired by functional programming (map, reduce functions)

• Ease of algorithm/program development. Messy details (e.g.,task allocation; data distribution; fault-tolerance;load-balancing) are hidden to the programmer

6

Platforms

Typically, MapReduce applications run on

• Clusters of commodity processors (On-premises)

• Platforms from cloud providers (Amazon AWS, Microsoft Azure)

• IaaS (Infrastructure as a Service): provides the userscomputing infrastructure and physical (or virtual) machines.This is the case of CloudVeneto which provides us a cluster ofvirtual machines.

• PaaS (Platform as a Service): provides the users computingplatforms with OS; execution environments, etc.

7

Platforms

8

Typical cluster architecture

• Racks of 16-64 compute nodes (commodity hardware), connected(within each rack and among racks) by fast switches (e.g., 10 GbpsEthernet)

• Distributed File System

• Files divided into chunks (e.g., 64MB per chunk)• Each chunk replicated (e.g., 2x o 3x) with replicas in different

nodes and, possibly, in different racks• The distribution of the chunks of a file is represented into a

master node file which is also replicated. A directory (alsoreplicated) records where all master nodes are.

• Examples: Google File System (GFS); Hadoop Distributed FileSystem (HDFS)

9

MapReduce-Hadoop-Spark

Several software frameworks have been proposed to support MapReduceprogramming. For example:

• Apache Hadoop: most popular MapReduceimplementation (often used as synonymous of MapReduce) fromwhich an entire ecosystem of alternatives has stemmed, aimed atimproving its (initially) very poor performance. The HadoopDistributed File System is still widely used.

• Apache Spark (learned in this course): one of the most popular andwidely used frameworks for big-data applications. It supports theimplementation of MapReduce computations, but provides a muchricher programming environment. It uses the HDFS.

Important: in this course we use the MapReduce programmimg modelfor the design and analysis of high-level algorithmic strategies, and Sparkfor their efficient implementation.

10

MapReduce computation

• Computation viewed as a sequence of rounds.(The original formulation considered only one round.)

• Each round transforms a set of key-value pairs into another set ofkey-value pairs (data centric view!), through the following twophases

• Map phase: a user-specified map function is applied separatelyto each input key-value pair and produces ≥ 0 other key-valuepairs, referred to as intermediate key-value pairs.

• Reduce phase: the intermediate key-value pairs are grouped bykey and a user-specified reduce function is applied separatelyto each group of key-value pairs with the same key, producing≥ 0 other key-value pairs, which is the output of the round.

• The output of a round is the input of the next round.

11

MapReduce computation

12

Why key-value pairs?

The use of key-value pairs in MapReduce seems an unnecessarycomplication, and one might be tempted to regard individual data itemssimply as objects belonging to some domain, without imposing adistinction between keys and values.

Justification. MapReduce is data-centric and focuses on datatrasformations which are independent of where data actually reside. Thekeys are needed as addresses to reach the objects, and as labels to definethe groups in the reduce phases.

Practical considerations.

• One should choose the key-value representations in the mostconvenient way. The domains for key and values may change fromone round to another.

• Programming frameworks such as Spark, as we will see, whilecontaining explicit provisions for handling key-value pairs, allow alsoto manage data without the use of keys. In this case, internaladdresses/labels, not explicitly visible to the programmer, are used.

13

Implementation of a round

• Input file is split into X chunks and each chunk forms the input of amap task.

• Each map task is assigned to a worker (a compute node) whichapplies the map function to each key-value pair of the correspondingchunk, buffering the intermediate key-value pairs it produces in itslocal disk

• The intermediate key-values pairs, while residing in the local disks,are partitioned into Y buckets through a hash function h:

(k , v) → Bucket i = h(k) mod Y .

• Each bucket forms the input of a different reduce task which isassigned to a worker (a compute node).

Obs.: hashing helps balancing the load of the workers

The worker applies the reduce function to each group of key-valuepairs with the same key, writing the output on the DFS. Theapplication of the reduce function to a group is called reducer

14

Implementation of a round

• The user program is forked into a master process and several workerprocesses. The master is in charge of assigning map and reducetasks to the various workers, and to monitor their status (idle,in-progress, completed).

• Input and output files reside on a Distributed File System, whileintermediate data are stored on the workers’ local disks.

• The round involves a data shuffle for moving the intermediatekey-value pairs from the compute nodes where they were produced(by map tasks) to the compute nodes where they must be processed(by reduce tasks).

Obs.: shuffle is often the most expensive operation of the round

• The values X and Y are design parameters.

15

Implementation of a round

From the original paper (split i ≡ chunk i):

16

Dealing with faults

• The Distributed File System is fault-tolerant

• Master pings workers periodically to detect failures• Worker failure:

• Map tasks completed or in-progress at failed worker are resetto idle and will be rescheduled. Note that even if a map task iscompleted, the failure of the worker makes its outputunavailable to reduce tasks, hence it must be rescheduled.

• Reduce tasks in-progress at failed worker are reset to idle andwill be rescheduled.

• Master failure: the whole MapReduce task is aborted

17

Specification of a MapReduce algorithm

A MapReduce (MR) algorithm should be specified so that

• The input and output of the algorithm is clearly defined

• The sequence of rounds executed for any given input instanceis unambiguously implied by the specification

• For each round the following aspects are clear

• input, intermediate and output sets of key-value pairs

• functions applied in the map and reduce phases.

• Meaningful values (or asymptotic) bounds for the keyperformance indicators (defined later) can be derived.

18

Specification of a MapReduce algorithm

For example, an MR algorithm with a fixed number of rounds R, we canuse the following style:

Input: description of the input as set of key-value pairsOutput: description of the output as set of key-value pairs

Round 1:

• Map phase: description of the function applied to each key-value pair

• Reduce phase: description of the function applied to each group ofkey-value pairs with the same key

Round 2: as before ..

· · ·Round R: as before ...

Observation: for simplicity, we sometime provide a high-level description of around, which, however, must enable a straightforward yet tedious derivation ofthe Map and Reduce phases.

19

Analysis of a MapReduce algorithm

The analysis of an MR algorithm aims at estimating the following keyperformance indicators:

• Number of rounds R.

• Local space ML: maximum amount of main memory required, inany round, by a single invocation of the map or reduce functionused in that round, for storing the input and any data structureneeded by the invocation.

• Aggregate space MA: maximum amount of (disk) space which isoccupied by the stored data at the beginning/end of the map orreduce phase of any round.

Observations:

• The indicators are usually estimated through asymptotic analysis (eitherworst-case or probabilistic) as functions of the instance size.

• ML bounds the amount of main memory required at each worker, whileMA bounds the overall amount of (disk) space that the executingplatform must provide.

20

Example: Word count

Input: collection of text documents D1,D2, . . . ,Dk containing N wordsoccurrences (counting repetitions). Each document is a key-value pair,whose key is the document’s name and the value is its content.

Output: The set of pairs (w , c(w)) where w is a word occurring in thedocuments, and c(w) is the number of occurrences of w in thedocuments.

Round 1:

• Map phase: for each document Di , produce the set of intermediatepairs (w , ci (w)), one for each word w ∈ Di , where ci (w) is thenumber of occurrences of w in Di .

• Reduce phase: For each word w , gather all intermediate pairs(w , ci (w)) and return the output pair (w , c(w)) where c(w) isthe sum of the ci (w)’s.

Observation: the output, in this case, is the set of pairs (w , c(w))produced by the various reducers, hence one pair for each word.

21

Analysis of Word count

Let Ni be the number of words in Di counting repetitions (hence,

N =∑k

i=1 Ni ), and assume that each word takes constant space. Letalso Nmax = maxi=1,k Ni . We have:

• R = 1 (trivial)

• ML = O (max{Nmax, k}) = O (Nmax + k). The bound is justified asfollows. In the map phase, the worker processing Di needs O (Ni )space. In the reduce phase, the worker in charge of word w adds upthe contribution of at most k pairs (w , ci (w)).

• MA = O (N), since the input size is O (N) and O (N) additionalpairs are produced by the algorithm, overall.

Observation: in principle, we may have Nmax + k = Θ (N), which implieslinear local space. When this happens, most of the advantages of MapReducevanish (see more in the next two slides). In practice, however it is likely thatk,Nmax = o(N), so the above algorithm is efficient. We’ll see later how toimprove the algorithm ensuring sublinear ML even for large k.

22

Design goals for MapReduce algorithms

Here is a simple yet important observation.

Theorem

For every computational problem solvable by a sequentialalgorithm in space S(|input|) there exists a 1-round MapReducealgorithm with ML = MA = Θ (S(|input|))

Proof.

Run sequential algorithm on whole input with one reducer.

Remark: the trivial solution implied by the above theorem isimpractical for very large inputs for the following reasons:

• A platform with very large main memory is needed.

• No parallelism is exploited.

23

Design goals for MapReduce algorithms

In general, to process efficiently very large input instances, an algorithmshould aim at: breaking the computation into a (hopefully small) numberof rounds that execute several tasks in parallel, each task workingefficiently on a (hopefully small) subset of the data.

In MapReduce terms, the design goals are the following:

Design Goals

• Few rounds (e.g., R = O (1))

• Sublinear local space (e.g., ML = O (|input|ε), for some constantε ∈ (0, 1))

• Linear aggregate space (i.e., MA = O (|input|)), or only slightlysuperlinear

• Polynomial complexity of each map or reduce function .

Observation: algorithms usually exhibit tradeoffs between performanceindicators. Often, small ML enables high parallelism but may incur large R.

24

Pros and cons of MapReduce

Why is MapReduce suitable for big data processing?

• Data-centric view. Algorithm design can focus on datatransformations, targeting the aforementioned design goals.Moreover, programming frameworks supporting MapReduce (e.g.,Spark) usually make allocation of tasks to workers, datamanagement, handling of failures, totally transparent to theprogrammer.

• Portability/Adaptability. Applications can run on different platformsand the underlying implementation of the framework will do besteffort to exploit parallelism and minimize data movement costs.

• Cost. MapReduce applications can be run on moderately expensiveplatforms, and many popular cloud providers support theirexecution.

25

Pros and cons of MapReduce

What are the main drawbacks of MapReduce?

• Weakness of the number of rounds as performance measure. Itignores the runtimes of map and reduce functions and the actualvolume of data shuffled. More sophisticated (yet, less usable)performance measures exist.

• Curse of the last reducer. In some cases, one or a few reducers maybe much slower than the other ones, thus delaying the end of theround. When designing MapReduce algorithms one should try toensure load balancing (if at all possible) among reducers.

26

Basic Techniques and Primitives

27

Partitioning technique

When some aggregation functions (e.g., sum of the ci (w)’s forevery word i) may potentially receive large inputs (e.g., large k) orskewed ones, it is advisable to partition the input, eitherdeterministically or randomly, and perform the aggregation instages.

We will see two examples:

• An improved version of Word count

• A Class count primitive

28

Improved Word count

Consider the word count problem, k documents and N word occurrencesoverall, in a realistic scenario where k = Θ (N) and N is huge (e.g., hugenumber of small documents). The following algorithm reduces localspace requirements at the expense of an extra round.

Idea: partition intermediate pairs randomly in o(N) groups and computecounts in two stages

Round 1:

• Map phase: for each document Di , produce the intermediate pairs(x , (w , ci (w))), one for every word w ∈ Di , where x (the key of thepair) is a random integer in [0,

√N) and ci (w) is the number of

occurrences of w in Di .

• Reduce phase: For each key x gather all pairs (x , (w , ci (w))), andfor each word w occurring in these pairs produce the pair(w , c(x ,w)) where c(x ,w) =

∑(x,(w ,ci (w))) ci (w). Now, w is the

key for (w , c(x ,w)).

29

Improved Word count

Round 2:

• Map phase: empty.

• Reduce phase: for each word w , gather the at most√N pairs

(w , c(x ,w)) resulting at the end of the previous round, and returnthe output pair (w ,

∑x c(x ,w)).

Analysis. Let mx be the number of intermediate pairs with key xproduced by the Map phase of Round 1, and let m = maxx mx . Asbefore, let Ni be the number of words in Di . We have

• R = 2

• ML = O(

maxi=1,k Ni + m +√N)

.

• MA = O (N)

How large can m be? We need a very useful technical tool.

30

Technical tool: Chernoff bound

Chernoff bound

Let X1,X2, . . . ,Xn be n i.i.d. Bernoulli random variables, withPr(Xi = 1) = p, for each 1 ≤ i ≤ n. Thus, X =

∑ni=1 Xi is a

Binomial(n, p) random variable. Let µ = E [X ] = n · p. For everyδ1 ≥ 5 and δ2 ∈ (0, 1) we have that

Pr(X ≥ (1 + δ1)µ) ≤ 2−(1+δ1)µ

Pr(X ≤ (1− δ2)µ) ≤ 2−µδ22/2

The proof can be found in [MU05].

31

Bound on m for Improved Word count

Theorem

Suppose that the keys assigned to the intermediate pairs in Round1 are i.i.d. random variables with uniform distribution in [0,

√N).

Then, with probability at least 1− 1/N5

m = O(√

N).

Therefore, from the theorem and the preceding analysis we get

ML = O

(maxi=1,k

Ni +√N

),

with probability at least 1− 1/N5. In fact, for large N theprobability becomes very close to 1.

N.B.: This is an example of probabilistic analysis, as opposed tomore traditional worst-case analysis.

32

Bound on m for Improved Word count

Proof of theorem.

Let N ′ ≤ N be the number of intermediate pairs produced by the Map phase ofRound 1, and consider an arbitrary key x ∈ [0,

√N).

Crucial observation: mx is a Binomial(N ′, 1/√N) random variable with

expecation µ = N ′/√N ≤

√N. Since 6

√N ≥ 6µ, by the Chernoff bound

Pr(mx ≥ 6√N) ≤ 1

26√N≤ 1

26 log2 N=

1

N6.

Now, the event ”m ≥ 6√N” is the union of the events ”mx ≥ 6

√N”, over all

x . By union bound (the probabiity of a union of events is upper bunded by thesum of the probabilities of the individual events) we have that

Pr(m ≥ 6√N) ≤

∑x∈[0,

√N)

Pr(mx ≥ 6√N)

≤√N Pr(mx ≥ 6

√N) ≤ 1

N5

Therefore, with probability at least 1− 1/N5 we have m ≤ 6√N, i.e.,

m = O(√

N)

.

33

Observations

The choice of partitioning the intermediate pairs into groups of

size O(√

N)

, in the first round of Improved Word count, is

somewhat arbitrary, but it provides an example of a simple tradeoffbetween local space and number of rounds.

In the rest of the course we will often make a similar choice.However, it is important to understand that the approach can begeneralized to attain a given target bound on ML (e.g.,ML = O (Nε) for some ε ∈ (0, 1)) exercising a finer tradeoffbetween ML and number of rounds. One of the exercises willexplore this issue.

34

Class count

Suppose that we are given a set S of N objects, each labeled witha class from a given domain, and we want to count how manyobjects belong to each class.

More precisely:

Input: Set S of N objects represented by pairs (i , (oi , γi )), for0 ≤ i < N, where oi is the i-th object, and γi its class.Output: The set of pairs (γ, c(γ)) where γ is a class labeling someobject of S and c(γ) is the number of objects of S labeled with γ.

Observation: the straightforward 1-round algorithm may requireO (N) local space, in case a large fraction of objects belong to thesame class. In the next slide we will see a more efficient algorithm.

35

Class count

Round 1:

• Map phase: map each pair (i , (oi , γi )) into the intermediate pair(i mod

√N, (oi , γi )) (mod = reminder of integer division)

• Reduce phase: For each key j ∈ [0,√N) gather the set (say S (j)) of

all intermediate pairs with key j and, for each class γ labeling someobject in S (j), produce the pair (γ, cj(γ)), where cj(γ) is thenumber of objects of S (j) labeled with γ.

Round 2:

• Map phase: empty

• Reduce phase: for each class γ, gather the at most√N pairs

(γ, cj(γ)) resulting at the end of the previous round, and return theoutput pair (γ,

∑j cj(γ)).

Exercise

Derive bounds on ML and MA for the above algorithm.

36

Trading accuracy for efficiency

There are problems for which exact MR algorithms may be toocostly, namely they may require a large number of rounds, or large(i.e., close to linear) local space, or large (i.e., superlinear)aggregate space. These algorithms become impractical for verylarge inputs.

In these scenarios, giving up exact solutions (if acceptable for theapplication) may greatly improve efficiency.

We’ll now see an example through an important primitive for theprocessing of pointsets from metric spaces (e.g., spatial datasets).

37

Maximum pairwise distance

Suppose that we are given a set S of N points from some metricspace (e.g., <3) and we want to determine the maximum distancebetween two points, for a given distance function d(·, ·).

More precisely:

Input: Set S of N points represented by pairs (i , xi ), for0 ≤ i < N, where xi is the i-th point.Output: (0,max0≤i ,j<N d(xi , xj)).

Exercise

Design an MR algorithm for the problem which requires

R = O (1), ML = O(√

N)

and MA = O(N2).

38

Maximum pairwise distance

39

Maximum pairwise distance

We can substantially reduce the aggregate space requirements ifwe tolerate a factor 2 error in the estimate of dmax. For anarbitrary point xi define

dmax(i) = max0≤j<Nd(xi , xj).

Lemma

For any 0 ≤ i < N we have dmax ∈ [dmax(i), 2dmax(i)].

Proof.

It is immediate to see that dmax ≥ dmax(i). Suppose thatdmax = d(xr , xt) for some r , t. By the triangle inequality we have

d(xr , xt) ≤ d(xr , xi ) + d(xi , xt) ≤ 2dmax(i).

40

Maximum pairwise distance

Round 1:

• Map phase: map each pair (i , xi ) into the intermediate pair(i mod

√N, (i , xi )). Also, create the

√N − 1 pairs (j , (0, x0)), for

1 ≤ j <√N.

• Reduce phase: For each key j ∈ [0,√N) gather the set S (j) of all

intermediate pairs with key j (which include (j , (0, x0))) andproduce the pair (0, dmax(0, j)) where dmax(0, j) is the maximumdistance between x0 and the points associated with pairs in S (j)

Round 2:

• Map phase: empty.

• Reduce phase: gather all pairs (0, dmax(0, j)) with j ∈ [0,√N) and

return the output pair (0,max0≤j<√N dmax(0, j)).

Analysis: R = 2, ML = O(√

N)

, MA = O (N).

41

Exploiting samples

When facing a big-data processing task, we should ask ourselvesthe following question:

Can we profitably process a small sample of the data?

In many cases, the answer is YES! Specifically, a small sample,suitably extracted, could be exploited for the following purposes.

• To subdivide the dataset in smaller subsets to be analyzedseparately.

• To provide a succint yet accurate representation of the wholedataset, which contains a good solution to the problem andfilters out noise and outliers, thus allowing the execution ofthe task on the sample.

In what follows, we will see an example of the first type throughthe sorting primitive, while an example of the second type will begiven later.

42

Sorting

Input: Set S = {si : 1 ≤ i ≤ N} of N distinct sortable objects(each si represented as a pair (i , si ))

Output: Sorted set {(i , sπ(i)) : 1 ≤ i ≤ N}, where π is apermutation such that sπ(1) ≤ sπ(2) ≤ · · · ≤ sπ(N).

The MR SampleSort algorithm is based on the following idea:

• Fix a suitable integral design parameter K .

• Randomly select some input objects (K on average) assplitters.

• Partition the objects into subsets based on the orderedsequence of splitters.

• Sort each subset separately and compute the final ranks.

Obs.: SampleSort is at the base of TeraSort, a popular benchmark formeasuring the performance of computing platforms, as well as mostwinners of the big-data Sort Benchmark competition.

43

MR SampleSort

Round 1:

• Map phase: for each pair (i , si ) do the following:

• transform the pair into (i mod K , (0, si )) (call it regular pair);• with probability p = K/N, independently of other objects,

select si as a splitter and, if selected, create K splitter pairs(j , (1, si )), with 0 ≤ j < K . (Note that a binary flag is used todistinguish between splitter from regular pairs).

Obs. Let t be the number of splitters selected in the Map phase.At the end of the phase, the splitter pairs represent K copies of thesplitters, one for each key j .

• Reduce phase: for 0 ≤ j < K do the following: gather all regularand splitter pairs with key j ; sort the t splitters and letx1 ≤ x2 ≤ · · · xt be the splitters in sorted order. Transform eachregular pair (j , (0, s)) into the pair (`, s), where ` ∈ [0, t] is suchthat x` < s ≤ x`+1 (assume x0 = −∞ and xt+1 = +∞).

44

MR SampleSort

• Round 2:• Map phase: empty• Reduce phase: for every 0 ≤ ` ≤ t gather, from the output of

the previous round, the set of pairs S (`) = {(`, s)}, computeN` = |S (`)|, and create t + 1 replicas of N` (use suitable pairsfor these replicas).

• Round 3:• Map phase: empty• Reduce phase: for every 0 ≤ ` ≤ t do the following: gather

S (`) and the values N0,N1, . . . ,Nt ; sort S (`); and compute thefinal output pairs for the objects in S (`) whose ranks start from1 +

∑`−1h=0 Nh.

45

Example

N = 32, K = 4

S = 16, 12, 25, 31, 32, 3, 21, 22, 1, 29, 13, 9, 15, 17, 5, 6,

14, 11, 19, 27, 7, 10, 23, 24, 28, 8, 30, 4, 20, 2, 26, 18

Round 1. Call Sj the set of intermediate pairs (j , (0, s)) after the Mapphase. We have (objects only):

S0 = 16, 32, 1, 15, 14, 7, 28, 20

S1 = 12, 3, 29, 17, 11, 10, 8, 2

S2 = 25, 21, 13, 5, 19, 23, 30, 26

S3 = 31, 22, 9, 6, 27, 24, 4, 18

The t = 5 splitters are highlighted in blue. In sorted order:

x1 = 4, x2 = 9, x3 = 16, x4 = 21, x5 = 29.

46

Example

Round 1 (cont’d). Call S(`)j the set of intermediate pairs (j , (0, s)) with

x` < s ≤ x`+1. We have (objects only):

j S(0)j S

(1)j S

(2)j S

(3)j S

(4)j S

(5)j

0 1 7 16,15,14 20 28 321 3,2 8 12,11,10 17 292 5 13 21,19 25,23,26 303 4 9,6 18 22,27,24 31

Round 2 The S (`)’s (objects only) and the N`’s values are

S (0) = 1, 3, 2, 4 N0 = 4S (1) = 7, 8, 5, 9, 6 N1 = 5S (2) = 16, 15, 14, 12, 11, 10, 13 N2 = 7S (3) = 20, 17, 21, 19, 18 N3 = 5S (4) = 28, 29, 25, 23, 26, 22, 27, 24 N4 = 8S (5) = 32, 30, 31 N5 = 3

47

Example

Round 3. Final output

(1, 1), · · · , (4, 4) from rank 1(5, 5), · · · , (9, 9) from rank N0 + 1 = 5(10, 10), · · · , (16, 16) from rank N0 + N1 + 1 = 10(17, 17), · · · , (21, 21) from rank N0 + N1 + N2 + 1 = 17(22, 22), · · · , (29, 29) from rank N0 + N1 + N2 + N3 + 1 = 22(30, 30), · · · , (32, 32) from rank N0 + · · ·+ N4 + 1 = 30

48

Analysis of MR SampleSort

• Number of rounds: R = 3• Local Space ML:

• Round 1: O (K + t + N/K ), since K copies of each splitterare created, and each reducer must store all splitter pairs and asubset of N/K intermediate pairs.

• Round 2: O (t + 1 + max{N` ; 0 ≤ ` ≤ t}) since each reducermust gather one S (`) and make t + 1 replicas of its size.

• Round 3: O (t + max{N` ; 0 ≤ ` ≤ t}), since each reducermust store all N`’s and one S (`).

⇒ overall ML = O (K + t + N/K + max{N` ; 0 ≤ ` ≤ t})• Aggregate Space MA: O

(N + t · K + t2)

), since in Round 1

each splitter is replicated K times, and in Round 3 each N` isreplicated t + 1 times. The objects are never replicated.

49

Analysis of MR SampleSort

Lemma

With reference to the MR SampleSort algorithm, for any K ∈ (2 lnN,N)the following two inequalities hold with high probability (i.e., probabilityat least 1− 1/N):

1 t ≤ 6K , and

2 max{N` ; 0 ≤ ` ≤ t} ≤ 4(N/K ) lnN.

Proof.

Deferred.

Theorem

By setting K =√N, MR SampleSort runs in 3 rounds, and, with high

probability, it requires local space ML = O(√

N lnN)

and aggregate

space MA = O (N).

Proof.

Immediate from the lemma and the previous analysis.50

Analysis of MR SampleSort

Proof of Lemma

We show that each inequality holds with probability at least 1− 1/(2N).

1 t is a Binomial(N,K/N) random variable with E [t] = K > 2 lnN.By the Chernoff bound (first inequality with δ1 = 5) we have thatt > 6K with probability at most 1/(2N).

2 View the sorted sequence of objects as divided into K/(2 lnN)contiguous segments of length N ′ = 2(N/K ) lnN each, andconsider one arbitrary such segment. The probability that no splitteris chosen among the objects of the segment is(

1− K

N

)N′

=

(1− 1

(N/K )

)(N/K)2 lnN

≤(

1

e lnN

)2

=1

N2.

(We used the well-known inequality (1− 1/x)x ≤ 1/e, ∀ x ≥ 0.)

51

Analysis of MR SampleSort

52

Analysis of MR SampleSort

Proof of Lemma.

2 (cont’d) So, there are K/(2 lnN) segments and we know that, foreach segment, the event “no splitter falls in the segment” occurswith probability ≤ 1/N2. Hence, the probability that any of theseK/(2 lnN) events occurs is ≤ K/(N22 lnN) ≤ 1/(2N) (unionbound!). Therefore, with probability at least (1− 1/(2N)), at least 1splitter falls in each segment, which implies that each N` cannot belarger than 4(N/K ) lnN. Hence, we have that the second inequalitystated in the lemma holds with probability at least (1− 1/(2N)).

In conclusion, we have that the probability that at least one of the twoinequalities does not hold, is at most 2 · 1/(2N) = 1/N, and the lemmafollows.

53

Exercises

Exercise 1

For each of the 4 problems listed in Exercise 2.3.1 of [LRU14],

design an O (1)-round MR algorithm which uses O(√

N)

local

space and linear aggregate space, where N is the input size.

Exercise 2

Suppose that an instance of the Class count problem is givenconsisting only of object-class pairs (o, γ) (i.e., without the initialinteger keys in [0,N)). Consider a modification of the algorithmdescribed in the slides, where in the Map phase of Round 1 eachpair (o, γ) is mapped into a pair (j , (o, γ)), where j is a randominteger in [0,

√N). The rest of the algorithm is unchanged.

Analyze probabilistically the local space requirements of themodified algorithm.

54

Exercises

Exercise 3

Design and analyze an efficient MR algorithm for approximatingthe maximum pairwise distance, which uses local spaceML = O

(N1/4

). Can you generalize the algorithm to attain

ML = O (Nε), for any ε ∈ (0, 1/2)?

Exercise 4

Design an O (1)-round MR algorithm for computing amatrix-vector product W = A · V , where A is an m× n matrix andV is an n-vector. Your algorithm must use o(n) local space andlinear (i.e., O (mn)) aggregate space. For simplicity you mayassume m ≤

√n, but think about how your solution changes if m

is larger.

55

Summary

• MapReduce.

• Motivating scenario.• Main Features, platforms and software frameworks.• MapReduce computation: high-level structure,

implementation, algorithm specification, analysis, keypeformance indicators.

• Algorithm design goals

• Basic Techniques and Primitives.

• Chernoff bound• Partitioning: Word count and Class count.• Efficiency-accuracy tradeoffs: Maximum pariwise distance• Sampling: Sorting

56

References

LRU14 J. Leskovec, A. Rajaraman and J. Ullman. Mining Massive Datasets.Cambridge University Press, 2014. Chapter 2 and Section 6.4

DG08 J. Dean and A. Ghemawat. MapReduce: simplified data processingon large clusters. OSDI’04 and CACM 51,1:107113, 2008

MU05 M. Mitzenmacher and E. Upfal. Proability and Computing:Randomized Algorithms and Probabilistic Analysis. CambridgeUniversity Press, 2005. (Chernoff bounds: Theorems 4.4 and 4.5)

P+12 A. Pietracaprina, G. Pucci, M. Riondato, F. Silvestri, E. Upfal:Space-round tradeoffs for MapReduce computations. ACM ICS’112.

57

Errata

Changes w.r.t. first draft:

• Slide 33: added some passages and clarifications.

• Slide 43: indices of the input/output objects start now from 1;also clarified that splitters are selected from the input objects.

• Slide 46: changed the order of the input points to make itconsistent with the groups after map phase

• Slide 49: added a term t + 1 to the contribution of R2 to ML,and K to the final ML bound.

• Slide 55: added a simplifying assumption to Ex.4.

58