This document discusses MapReduce and its ability to process large datasets in a distributed manner. MapReduce addresses challenges of distributed computation by allowing programmers to specify map and reduce functions. It then parallelizes the execution of these functions across large clusters and handles failures transparently. The map function processes input key-value pairs to generate intermediate pairs, which are then grouped by key and passed to reduce functions to generate the final output.
1 of 42
More Related Content
ch02-mapreduce.pptx
2. Challenges:
How to distribute computation?
Distributed/parallel programming is hard
Map-reduce addresses all of the above
Google’s computational/data manipulation model
Elegant way to work with big data
2
4. 20+ billion web pages x 20KB = 400+ TB
1 computer reads 30-35 MB/sec from disk
~4 months to read the web
~1,000 hard drives to store the web
Takes even more to do something useful
with the data!
Today, a standard architecture for such
problems is emerging:
Cluster of commodity Linux nodes
Commodity network (ethernet) to connect them
4
5. Mem
Disk
CPU
Mem
Disk
CPU
…
Switch
Each rack contains 16-64 nodes
Mem
Disk
CPU
Mem
Disk
CPU
…
Switch
Switch
1 Gbps between
any pair of nodes
in a rack
2-10 Gbps backbone between racks
In 2011 it was guestimated that Google had 1M machines, http://bit.ly/Shh0RO
5
6. J. Leskovec, A. Rajaraman, J. Ullman: Mining of Massive Datasets, http://www.mmds.org 6
7. Large-scale computing for data mining
problems on commodity hardware
Challenges:
How do you distribute computation?
How can we make it easy to write distributed
programs?
Machines fail:
One server may stay up 3 years (1,000 days)
If you have 1,000 servers, expect to loose 1/day
People estimated Google had ~1M machines in 2011
1,000 machines fail every day!
7
8. Large-scale computing for data mining
problems on commodity hardware
Challenges:
How do you distribute computation?
How can we make it easy to write distributed
programs?
Machines fail:
One server may stay up 3 years (1,000 days)
If you have 1,000 servers, expect to loose 1/day
People estimated Google had ~1M machines in 2011
1,000 machines fail every day!
8
9. Problem:
If nodes fail, how to store data persistently?
Answer:
Distributed File System:
Provides global file namespace
Google GFS; Hadoop HDFS;
Typical usage pattern
Huge files (100s of GB to TB)
Data is rarely updated in place
Reads and appends are common
9
10. Reliable distributed file system
Data kept in “chunks” spread across machines
Each chunk replicated on different machines
Seamless recovery from disk or machine failure
C0 C1
C2
C5
Chunk server 1
D1
C5
Chunk server 3
C1
C3
C5
Chunk server 2
…
C2
D0
D0
Bring computation directly to the data!
C0 C5
Chunk server N
C2
D0
10
Chunk servers also serve as compute servers
11. Chunk servers
File is split into contiguous chunks
Typically each chunk is 16-64MB
Each chunk replicated (usually 2x or 3x)
Try to keep replicas in different racks (why do that?)
Master node
a.k.a. Name Node in Hadoop’s HDFS
Stores metadata about where files are stored
Might be replicated
Client library for file access
Talks to master to find chunk servers
Connects directly to chunk servers to access data
11
12. Warm-up task:
We have a huge text document
Count the number of times each
distinct word appears in the file
Sample application:
Analyze web server logs to find popular URLs
Term statistics for search
12
13. Case 1:
File too large for memory, but all <word, count> pairs
fit in memory (solution HashTable)
Case 2:
File too large for memory and all <word, count> pairs
do not fit in memory (need Big Data Soution)
Count occurrences of words:
words(doc.txt) | sort | uniq -c
where words takes a file and outputs the words in it, one per
a line
Case 2 captures the essence of MapReduce
Great thing is that it is naturally parallelizable
13
14. Sequentially read a lot of data
Map: (words(doc.txt))
Extract something you care about e.g. word=key
Group by key: (sort)
Sort and Shuffle
Reduce: (uniq –c)
Aggregate, summarize, filter or transform
Write the result
Outline stays the same, Map and Reduce
change to fit the problem
14
16. k v
…
k v
k v
k v
Intermediate
key-value pairs
Group
by key
reduce
reduce
k v
k v
k v
…
k v
…
k v
k v v
v v
Key-value groups
Output
key-value pairs
16
17. Input: a set of key-value pairs
Programmer specifies two methods:
Map(k, v) <k’, v’>*
Takes a key-value pair and outputs a set of key-value pairs
E.g., key is the filename, value is a single line in the file
There is one Map call for every (k,v) pair
Reduce(k’, <v’>*) <k’, v’’>*
All values v’ with same key k’ are reduced together
and processed in v’ order
There is one Reduce function call per unique key k’
17
18. The crew of the space
shuttle Endeavor recently
returned to Earth as
ambassadors, harbingers of
a new era of space
exploration. Scientists at
NASA are saying that the
recent assembly of the
Dextre bot is the first step in
a long-term space-based
man/mache partnership.
'"The work we're doing now
-- the robotics we're doing -
- is what we're going to
need ……………………..
Big document
(The, 1)
(crew, 1)
(of, 1)
(the, 1)
(space, 1)
(shuttle, 1)
(Endeavor, 1)
(recently, 1)
….
(crew, 1)
(crew, 1)
(space, 1)
(the, 1)
(the, 1)
(the, 1)
(shuttle, 1)
(recently, 1)
…
(crew, 2)
(space, 1)
(the, 3)
(shuttle, 1)
(recently, 1)
…
MAP:
Read input and
produces a set of
key-value pairs
Group by key:
Collect all pairs
with same key
Reduce:
Collect all values
belonging to the
key and output
(key, value)
Provided by the
programmer
Provided by the
programmer
(key, value)
(key, value)
Sequentially
read
the
data
Only
sequential
reads
18
19. map(key, value):
// key: document name; value: text of the document
for each word w in value:
emit(w, 1)
reduce(key, values):
// key: a word; value: an iterator over counts
result = 0
for each count v in values:
result += v
emit(key, result)
19
21. 21
Big document
MAP:
Read input and
produces a set of
key-value pairs
Group by key:
Collect all pairs with
same key
(Hash merge, Shuffle,
Sort, Partition)
Reduce:
Collect all values
belonging to the
key and output
22. 22
Use a Partitioning (HASH) function in order to find which
reducer e.g. key k4 is send to Reducer1
The programmer supplies the function R to do something
with the values.
All phases are distributed with many tasks doing the work
23. Map-Reduce environment takes care of:
Partitioning the input data
Scheduling the program’s execution across a
set of machines
Performing the group by key step
Handling machine failures
Managing required inter-machine
communication
23
24. Programmer specifies:
Map and Reduce and input files
Workflow:
Read inputs as a set of key-value-
pairs
Map transforms input kv-pairs into a
new set of k'v'-pairs
Sorts & Shuffles the k'v'-pairs to
output nodes
All k’v’-pairs with a given k’ are sent
to the same reduce
Reduce processes all k'v'-pairs
grouped by key into new k''v''-pairs
Write the resulting pairs to files
All phases are distributed with
many tasks doing the work
Input 0
Map 0
Input 1
Map 1
Input 2
Map 2
Reduce 0 Reduce 1
Out 0 Out 1
Shuffle
24
25. Input and final output are stored on a
distributed file system (FS):
Scheduler tries to schedule map tasks “close” to
physical storage location of input data
Intermediate results are stored on local FS
of Map and Reduce workers e.g. output of a
map step
Output of a MapReduce Task is often input
to another MapReduce task
25
26. Master node takes care of coordination:
Task status: (idle, in-progress, completed)
Idle tasks get scheduled as workers become
available
When a map task completes, it sends the master
the location and sizes of its R intermediate files,
one for each reducer
Master pushes this info to reducers
Master pings workers periodically to detect
failures
26
27. Map worker failure
Map tasks completed or in-progress at
worker are reset to idle
Reduce workers are notified when task is
rescheduled on another worker
Reduce worker failure
Reduce task is restarted
Master failure
MapReduce task is aborted and client is notified
27
28. M map tasks, R reduce tasks
Rule of a thumb:
Make M much larger than the number of nodes
in the cluster
One DFS chunk per map is common
Improves dynamic load balancing and speeds up
recovery from worker failures
Usually R is smaller than M
Because output is spread across R files (more
convenient to store a file/output in a small
number of files/reducers)
28
30. Often a Map task will produce many pairs of
the form (k,v1), (k,v2), … for the same key k
E.g., popular words (e.g. the) in the word count
example
Can save network time by
pre-aggregating values in
the mapper:
E.g. Send (‘the’,1013)
INPUT:combine(k, list(v1))
OUTPUT k,v2
Combiner is usually same
as the reduce function
30
31. Back to our word counting example:
Combiner combines the values of all keys of a
single mapper (single machine):
Much less data needs to be copied and shuffled!
31
32. Want to control how keys get partitioned
Inputs to map tasks are created by contiguous
splits of input file
Reduce needs to ensure that records with the
same intermediate key end up at the same worker
System uses a default partition function:
hash(key) mod R
Sometimes useful to override the hash
function:
E.g., hash(hostname(URL)) mod R ensures URLs
from a host end up in the same output file
32
33. Google
Uses Google File System (GFS)
Not available outside Google
Hadoop
An open-source implementation in Java
Uses HDFS for stable storage
Download: http://lucene.apache.org/hadoop/
Aster Data
Cluster-optimized SQL Database that also
implements MapReduce
33
34. Ability to rent computing by the hour
Additional services e.g., persistent storage
Amazon’s “Elastic Compute Cloud” (EC2)
Aster Data and Hadoop can both be run on
EC2
For CS341 (offered next quarter) Amazon will
provide free access for the class
34
36. Statistical machine translation:
Need to count number of times every 5-word
sequence occurs in a large corpus of documents
Very easy with MapReduce:
Map:
Extract (5-word sequence, count) from document
Reduce:
Combine the counts
36
37. Suppose we have a large web corpus
Look at the metadata file
Lines of the form: (URL, size, date, …)
For each host, find the total number of bytes
That is, the sum of the page sizes for all URLs from
that particular host
Other examples:
Link analysis and graph processing
Machine Learning algorithms
37
39. Jeffrey Dean and Sanjay Ghemawat:
MapReduce: Simplified Data Processing on
Large Clusters
http://labs.google.com/papers/mapreduce.html
Sanjay Ghemawat, Howard Gobioff, and Shun-
Tak Leung: The Google File System
http://labs.google.com/papers/gfs.html
39
41. Releases from Apache download mirrors
http://www.apache.org/dyn/closer.cgi/lucene/had
oop/
Nightly builds of source
http://people.apache.org/dist/lucene/hadoop/nig
htly/
Source code from subversion
http://lucene.apache.org/hadoop/version_control
.html
41
42. Programming model inspired by functional language
primitives
Partitioning/shuffling similar to many large-scale sorting
systems
NOW-Sort ['97]
Re-execution for fault tolerance
BAD-FS ['04] and TACC ['97]
Locality optimization has parallels with Active
Disks/Diamond work
Active Disks ['01], Diamond ['04]
Backup tasks similar to Eager Scheduling in Charlotte
system
Charlotte ['96]
Dynamic load balancing solves similar problem as River's
distributed queues
River ['99]
42