MAPREDUCE PRESENTED BY: KATIE WOODS & JORDAN HOWELL

TEAM MEMBERS: Katie Woods: Covered Sections 1. Introduction 3.Implementation 6.Experience 7.Related Work Jordan Howell: Covered Sections 2.Programming Model 4.Refinements 5.Performance Conclusion

OVERVIEW What is MapReduce Programming model Section Related Work Conclusion How to run MapReduce on OpenStack Reference What we went over Questions/Comments

WHAT IS MAPREDUCE? Originally created by Google Used to query large data-sets Extracts relations from unstructured data Can draw from many disparate data sources

2. PROGRAMMING MODEL Two parts: Map() and Reduce() MapReduce library groups together intermediate values associated with same intermediate key I Passes values to Reduce() via an iterator Reduce() merges values to form possibly smaller set of values Zero or one output value is produced per Reduce request

3. IMPLEMENTATION Many different implementations The right choice depends on the environment For example: Google’s setup typically dual x86 processors 2-4GB memory 100Mb/s or 1Gb/s networking hardware Hundreds or thousands of machines per cluster Inexpensive IDE disks directly on machines

3.1 EXECUTION Input data partitioned into M splits Intermediate key space partitioned into R pieces. 1. Splits input files into 16 to 64 MB per piece. Then starts up many copies of the program on a cluster of machines. 2. Master assigns each one map task or a reduce task. 3. Worker reads the input split. 4. Periodically, buffered pairs get written to local disk. 5. Reduce worker makes procedure call to retrieve data from map worker’s local disk. 6. Results are written to final output file for the reduce partition 7. Master wakes user program and returns all output files.

3.2 MASTER DATA STRUCTURES Master keeps several data structures Each Map task and reduce task it stores the state (idle, in-process, and completed) The master is the conduit through which the location of intermediate file regions is propagated from map tasks to reduce tasks

3.3 FAULT TOLERANCE Since MapReduce library is designed to process large amounts the library must tolerate machine failures gracefully Worker Failure: Master Failure: Semantics in the Presence of Failures:

3.4 LOCALITY Due to relatively scarce network bandwidth data is stored on the local disk of each machine The files are split into 64MB blocks. Each block is copied typically three times to other machines The master machine tries to schedule jobs on the machine that contains a replica of the corresponding input data. Otherwise, it schedules a job close to a machine containing the job data When running large operations most input data is read locally and consumes no network bandwidth.

3.5 TASK GRANULARITY The map and reduce phases are split into different size pieces M pieces for Map Phase & R pieces for Reduce Phase Total phase pieces should be much larger than the number of worker machines This helps with dynamic load balancing and recovery speed when a worker fails Reduce phase pieces are usually constrained by users since each task is in a separate output file The number of map phase pieces are chosen so that the input data size is between 16MB and 64MB Google usually uses 200,000 map pieces, 5,000 reduce pieces, and 2,000 worker machines

3.6 BACKUP TASKS “Straggler” machines can cause large total computation time Stragglers can arise by many different reasons Straggler alleviation is possible The master backs up in-progress tasks when the operation is close to finishing Task is marked as complete when the primary task or backup completes Backup task overhead has been tuned to no more than a few percent An example task takes 44% longer when the backup is disabled

4. REFINEMENTS General algorithms fit most needs User defined extensions have been found useful

4.1 PARTITIONING FUNCTION Users can define the number of reduce tasks to run (R) We can redefine the intermediate keys A default function is hash(key) mod R which results in fairly well balanced partitions Sometimes we may want to group output together, such as grouping web data by domain We can redefine partition to use hash(Hostname(urlkey)) mod R

4.2 ORDERING GUARANTEES Within each partition, intermediate key/value pairs are always processed in increasing order Makes it easy to generate a sorted output file per partition This supports efficient lookup of random keys

4.3 COMBINER FUNCTION There is sometimes significant repetition in the intermediate keys This is usually handled in the Reduce function, but sometimes we want to partially combine it in the Map function The combiner function sometimes grants significant performance gains

4.4 INPUT AND OUTPUT TYPES MapReduce can take data from several different formats The way the data is organized for input greatly effects the output Adding support for a new data type only requires users to change the reader interface

4.5 SIDE EFFECTS Sometimes we want to produce auxiliary files as additional outputs from the Map or Reduce operators Users are responsible for these files, as long as these outputs are deterministic This restriction has never been an issue in practice

4.6 SKIPPING BAD RECORDS Sometimes there are bugs in user code Course of action is to fix the bug but sometimes not feasible It is acceptable to ignore a few records Optional mode of execution Detects which records cause deterministic crashes and skips them

4.7 LOCAL EXECUTION Debugging problems in functions can be tricky Decisions can be made dynamically by the master To help facilitate debugging, profiling, and small-scale testing Controls are provided to limit particular map tasks

4.8 STATUS INFORMATION The master runs an internal HTTP server and exports a set of status pages Shows progress of the computation Contains links to the standard error and standard output files User uses data to predict how long the computation will take Top-level status page shows which works have failed & which Map and Reduce tasks were processing when they failed

4.9 COUNTERS MapReduce provides a counter facility to count occurrences of various events Some counter values are automatically maintained by the MapReduce library Users have found the counter facility useful for sanity checking the behavior of operations

5 PERFORMANCE This section measures the performance of MapReduce on two computations, Grep and Sort. These programs represent a large subset of real programs that MapReduce users have created

5.1 CLUSTER CONFIGURATION Cluster of ≈ 1800 machines. Two 2GHz Intel Xeon processors with Hyper-Threading. 4 GB of memory. Two 160GB IDE(Integrated Drive Electronics) Disks. Gigabit Ethernet link. Arranged in a two-level tree-shaped switched network. ≈ Gbps aggregate bandwidth available at root. Every machine is located in the same hosting facility. Round trip between pairs is less than a millisecond. Out of the 4GB of memory available, approximately 1-1.5GB was reserved by other tasks. Programs were run on a weekend afternoon, when the CPUs, disks, and network were mostly idle.

5.2 GREP Grep scans through 10^ byte records. The program looks for a match to a rare 3-character pattern. This pattern occurs in 92,337 records. The input gets slip up into ≈ 64 MB pieces. Output gets stored into one file

5.3 SORT The sort program sorts through 10^ byte records. This is modeled after the TeraSort benchmark. Whole program is less than 50 lines. Like Grep the input for the sort program is split up into 64MB pieces. The sorted output is partitioned into 4000 files. The partitioning function uses the initial bytes of the key to segregate the output into one of the 4000 pieces.

SORT CONTINUED

5.4 EFFECT OF BACKUP TASK Backup Tasks Disabled After 960 still 5 reduce tasks not completed Takes 1283 Seconds to completely finish Increase of 44% time

5.5 MACHINE FAILURES Intentional kill 200 process Finishes in 933 seconds 5% increase over normal time

6 EXPERIENCE Extraction of data for popular queries Google Zeitgeist Extracting properties of web pages Geographical locations of web pages for localized search Clustering problems for Google News and Froogle products Large-scale machine learning problems and graph computations

6.1 LARGE SCALE INDEXING Production Indexing System Produces data structures for searches Completely rewritten with MapReduce What it does: Crawler gathers approx. 20 terabytes of data Indexing Process: 5-10 MapReduce operations

6.1 CONTINUED Indexing code is Simpler 3800 lines of C++ to 700 w/ MapReduce Improved Performance Separates unrelated computations Avoids extra passes over data Easier to Operate MapReduce handles issues without operator intervention Machine failures, slow machines, networking hiccups

7 RELATED WORK MapReduce can be viewed as a simplification of many system’s programming models to be adaptable and scalable Works off the restricted model of pushing data to be stored locally on the worker’s system Backup system similar to Charlotte System with the fix of the ability to skip bad records caused by failures

CONCLUSION Been successfully used at Google for different purposes Easy for programmers to use, even without the background of distributed and parallel systems Used well to sorting, data mining, machine learning and many more

LESSONS LEARNED Restricting the programming model makes it easy to parallelize and distribute computations fault-tolerant. Bandwidth is precious. Optimizations save it. Redundant execution can be used reduce the impact of slow machines, and to handle machine failures and data loss

MAP REDUCE WITH OPENSTACK Cloud Computing with Data Analytics

COMMON DEPLOYMENT Swift Storage joined to MapReduce cluster. Scalable storage mode to handle large amounts of data. Reason why is because annual data growth is 60%

BEGINNER DEPLOYMENT Cloudera has a mapreduce distribution Lets companies slowly implement big data

ADVANCED DEPLOYMENT Best Flexibility, Scalability, and Autonomy Build Cloud and then add Swift and Nova Quantum should be added for segmentation

GOOGLE FILE SYSTEM Letting a third party handle storage while company focuses on Computational processing.

NEED TO KNOW Let employees grow with technology If you do not plan you will most likely fail

WHAT WE WENT OVER What MapReduce is Programming Model: types Implantation: execution, master data structures, fault tolerance, locality, task granularity, and backup tasks Refinements: partitioning function, ordering guarantees, combiner functions, input & output types, side-effects, skipping bad records, local execution, status information, and counters Performance: cluster configuration, GREP, SORT, effect & backup tasks, and machine failures Experiences Related Work Conclusion How MapReduce is run with OpenStack

QUESTIONS/COMMENTS

REFERENCES