# MapReduce

> Mediated Wiki article. Canonical URL: https://mediated.wiki/source/MapReduce
> Markdown URL: https://mediated.wiki/source/MapReduce.md
> Source: https://en.wikipedia.org/wiki/MapReduce
> Source revision: 1356371653
> License: Creative Commons Attribution-ShareAlike 4.0 International (https://creativecommons.org/licenses/by-sa/4.0/)

Parallel programming model

**MapReduce** is a [programming model](/source/Programming_model) and an associated implementation for processing and generating [big data](/source/Big_data) sets with a [parallel](/source/Parallel_computing) and [distributed](/source/Distributed_computing) algorithm on a [cluster](/source/Cluster_(computing)).[1][2][3]

A MapReduce program is composed of a [*map*](/source/Map_(parallel_pattern)) [procedure](/source/Procedure_(computing)), which performs filtering and sorting (such as sorting students by first name into queues, one queue for each name), and a *[reduce](/source/Reduce_(parallel_pattern))* method, which performs a summary operation (such as counting the number of students in each queue, yielding name frequencies). The "MapReduce System" (also called "infrastructure" or "framework") orchestrates the processing by marshalling the distributed servers, running the various tasks in parallel, managing all communications and data transfers between the various parts of the system, and providing for [redundancy](/source/Redundancy_(engineering)) and [fault tolerance](/source/Fault-tolerant_computer_system).

The model is a specialization of the *split-apply-combine* strategy for data analysis.[4] It is inspired by the [map](/source/Map_(higher-order_function)) and [reduce](/source/Reduce_(higher-order_function)) functions commonly used in [functional programming](/source/Functional_programming),[5] although their purpose in the MapReduce framework is not the same as in their original forms.[6] The key contributions of the MapReduce framework are not the actual map and reduce functions (which, for example, resemble the 1995 [Message Passing Interface](/source/Message_Passing_Interface) standard's[7] *reduce*[8] and *scatter*[9] operations), but the scalability and fault-tolerance achieved for a variety of applications due to parallelization. As such, a [single-threaded](/source/Single-threaded) implementation of MapReduce is usually not faster than a traditional (non-MapReduce) implementation; any gains are usually only seen with [multi-threaded](/source/Multi-threaded) implementations on multi-processor hardware.[10] The use of this model is beneficial only when the optimized distributed shuffle operation (which reduces network communication cost) and fault tolerance features of the MapReduce framework come into play. Optimizing the communication cost is essential to a good MapReduce algorithm.[11]

MapReduce [libraries](/source/Library_(software)) have been written in many programming languages, with different levels of optimization. A popular [open-source](/source/Open-source_software) implementation that has support for distributed shuffles is part of [Apache Hadoop](/source/Apache_Hadoop). The name MapReduce originally referred to the proprietary [Google](/source/Google) technology, but has since become a [generic trademark](/source/Generic_trademark). By 2014, Google was no longer using MapReduce as its primary *[big data](/source/Big_data)* processing model,[12] and development on [Apache Mahout](/source/Apache_Mahout) had moved on to more capable and less disk-oriented mechanisms that incorporated full map and reduce capabilities.[13]

## Overview

MapReduce is a framework for processing [parallelizable](/source/Parallel_computing) problems across large datasets using a large number of computers (nodes), collectively referred to as a [cluster](/source/Computer_cluster) (if all nodes are on the same local network and use similar hardware) or a [grid](/source/Grid_Computing) (if the nodes are shared across geographically and administratively distributed systems, and use more heterogeneous hardware). Processing can occur on data stored either in a [filesystem](/source/Filesystem) (unstructured) or in a [database](/source/Database) (structured). MapReduce can take advantage of the locality of data, processing it near the place it is stored in order to minimize communication overhead.

A MapReduce framework (or system) is usually composed of three operations (or steps):

1. **Map:** each worker node applies the map function to the local data, and writes the output to a temporary storage. A master node ensures that only one copy of the redundant input data is processed.

1. **Shuffle:** worker nodes redistribute data based on the output keys (produced by the map function), such that all data belonging to one key is located on the same worker node.

1. **Reduce:** worker nodes now process each group of output data, per key, in parallel.

MapReduce allows for the distributed processing of the map and reduction operations. Maps can be performed in parallel, provided that each mapping operation is independent of the others; in practice, this is limited by the number of independent data sources and/or the number of CPUs near each source. Similarly, a set of 'reducers' can perform the reduction phase, provided that all outputs of the map operation that share the same key are presented to the same reducer at the same time, or that the reduction function is [associative](/source/Associative_property). While this process often appears inefficient compared to algorithms that are more sequential (because multiple instances of the reduction process must be run), MapReduce can be applied to significantly larger datasets than a single ["commodity" server](/source/Commodity_computing) can handle – a large [server farm](/source/Server_farm) can use MapReduce to sort a [petabyte](/source/Petabyte) of data in only a few hours.[14] The parallelism also offers some possibility of recovering from partial failure of servers or storage during the operation: if one mapper or reducer fails, the work can be rescheduled – assuming the input data are still available.

Another way to look at MapReduce is as a 5-step parallel and distributed computation:

1. **Prepare the Map() input** – the "MapReduce system" designates Map processors, assigns the input key *K1* that each processor would work on, and provides that processor with all the input data associated with that key.

1. **Run the user-provided Map() code** – Map() is run exactly once for each *K1* key, generating output organized by key *K2*.

1. **"Shuffle" the Map output to the Reduce processors** – the MapReduce system designates Reduce processors, assigns the *K2* key each processor should work on, and provides that processor with all the Map-generated data associated with that key.

1. **Run the user-provided Reduce() code** – Reduce() is run exactly once for each *K2* key produced by the Map step.

1. **Produce the final output** – the MapReduce system collects all the Reduce output, and sorts it by *K2* to produce the final outcome.

These five steps can be logically thought of as running in sequence – each step starts only after the previous step is completed – although in practice they can be interleaved as long as the final result is not affected.

In many situations, the input data might have already been distributed (["sharded"](/source/Shard_(database_architecture))) among many different servers, in which case step 1 could sometimes be greatly simplified by assigning Map servers that would process the locally present input data. Similarly, step 3 could sometimes be sped up by assigning Reduce processors that are as close as possible to the Map-generated data they need to process.

## Logical view

The *Map* and *Reduce* functions of *MapReduce* are both defined with respect to data structured in (key, value) pairs. *Map* takes one pair of data with a type in one [data domain](/source/Data_domain), and returns a list of pairs in a different domain:

Map(k1,v1) → list(k2,v2)

The *Map* function is applied in parallel to every pair (keyed by k1) in the input dataset. This produces a list of pairs (keyed by k2) for each call. After that, the MapReduce framework collects all pairs with the same key (k2) from all lists and groups them together, creating one group for each key.

The *Reduce* function is then applied in parallel to each group, which in turn produces a collection of values in the same domain:

Reduce(k2, list (v2)) → list((k3, v3))[15]

Each *Reduce* call typically produces either one key value pair or an empty return, though one call is allowed to return more than one key value pair. The returns of all calls are collected as the desired result list.

Thus the MapReduce framework transforms a list of (key, value) pairs into another list of (key, value) pairs.[16] This behavior is different from the typical functional programming map and reduce combination, which accepts a list of arbitrary values and returns one single value that combines *all* the values returned by map.

It is [necessary but not sufficient](/source/Necessity_and_sufficiency) to have implementations of the map and reduce abstractions in order to implement MapReduce. Distributed implementations of MapReduce require a means of connecting the processes performing the Map and Reduce phases. This may be a [distributed file system](/source/Distributed_file_system). Other options are possible, such as direct streaming from mappers to reducers, or for the mapping processors to serve up their results to reducers that query them.

### Examples

The canonical MapReduce example counts the appearance of each word in a set of documents:[17]

**function** map(String name, String document):
    *// name: document name*
    *// document: document contents*
    **for each** word w **in** document:
        emit (w, 1)

**function** reduce(String word, Iterator partialCounts):
    *// word: a word*
    *// partialCounts: a list of aggregated partial counts*
    sum = 0
    **for each** pc **in** partialCounts:
        sum += pc
    emit (word, sum)

Here, each document is split into words, and each word is counted by the *map* function, using the word as the result key. The framework puts together all the pairs with the same key and feeds them to the same call to *reduce*. Thus, this function just needs to sum all of its input values to find the total appearances of that word.

As another example, imagine that for a database of 1.1 billion people, one would like to compute the average number of social contacts a person has according to age. In [SQL](/source/SQL), such a query could be expressed as:

  SELECT age, AVG(contacts)
    FROM social.person
GROUP BY age
ORDER BY age

Using MapReduce, the K1 key values could be the integers 1 through 1100, each representing a batch of 1 million records, the K2 key value could be a person's age in years, and this computation could be achieved using the following functions:

**function** Map **is**
    **input:** **integer** K1 between 1 and 1100, representing a batch of 1 million social.person records
    **for each** social.person record in the K1 batch **do**
        **let** Y be the person's age
        **let** N be the number of contacts the person has
        **produce one output record** (Y,(N,1))
    **repeat**
**end function**

**function** Reduce **is**
    **input:** age (in years) Y
    **for each** input record (Y,(N,C)) **do**
        Accumulate in S the sum of N*C
        Accumulate in Cnew the sum of C
    **repeat**
    **let** A be S/Cnew
    **produce one output record** (Y,(A,Cnew))
**end function**

Note that in the Reduce function, C is the count of people having in total N contacts, so in the Map function it is natural to write C=1, since every output pair is referring to the contacts of one single person.

The MapReduce system would line up the 1100 Map processors, and would provide each with its corresponding 1 million input records. The Map step would produce 1.1 billion (Y,(N,1)) records, with Y values ranging between, say, 8 and 103. The MapReduce System would then line up the 96 Reduce processors by performing shuffling operation of the key/value pairs due to the fact that we need average per age, and provide each with its millions of corresponding input records. The Reduce step would result in the much reduced set of only 96 output records (Y,A), which would be put in the final result file, sorted by Y.

The count info in the record is important if the processing is reduced more than one time. If we did not add the count of the records, the computed average would be wrong, for example:

*-- map output #1: age, quantity of contacts*
10, 9
10, 9
10, 9

*-- map output #2: age, quantity of contacts*
10, 9
10, 9

*-- map output #3: age, quantity of contacts*
10, 10

If we reduce files #1 and #2, we will have a new file with an average of 9 contacts for a 10-year-old person ((9+9+9+9+9)/5):

*-- reduce step #1: age, average of contacts*
10, 9

If we reduce it with file #3, we lose the count of how many records we've already seen, so we end up with an average of 9.5 contacts for a 10-year-old person ((9+10)/2), which is wrong. The correct answer is 9.166 = 55 / 6 = (9×3+9×2+10×1)/(3+2+1).

## Dataflow

[Software framework architecture](/source/Software_framework#Architecture) adheres to [open-closed principle](/source/Open-closed_principle) where code is effectively divided into unmodifiable *frozen spots* and [extensible](/source/Extensibility) *hot spots*. The frozen spot of the MapReduce framework is a large distributed sort. The hot spots, which the application defines, are:

- an *input reader*

- a *Map* function

- a *partition* function

- a *compare* function

- a *Reduce* function

- an *output writer*

### Input reader

The *input reader* divides the input into appropriate size 'splits' (in practice, typically, 64 MB to 128 MB) and the framework assigns one split to each *Map* function. The *input reader* reads data from stable storage (typically, a [distributed file system](/source/Distributed_file_system)) and generates key/value pairs.

A common example will read a directory full of text files and return each line as a record.

### Map function

The *Map* function takes a series of key/value pairs, processes each, and generates zero or more output key/value pairs. The input and output types of the map can be (and often are) different from each other.

If the application is doing a word count, the map function would break the line into words and output a key/value pair for each word. Each output pair would contain the word as the key and the number of instances of that word in the line as the value.

### Partition function

Each *Map* function output is allocated to a particular *reducer* by the application's *partition* function for [sharding](/source/Sharding) purposes. The *partition* function is given the key and the number of reducers and returns the index of the desired *reducer*.

A typical default is to [hash](/source/Hash_function) the key and use the hash value [modulo](/source/Modulo_operation) the number of *reducers*. It is important to pick a partition function that gives an approximately uniform distribution of data per shard for [load-balancing](/source/Load_balancing_(computing)) purposes, otherwise the MapReduce operation can be held up waiting for slow reducers to finish (i.e. the reducers assigned the larger shares of the non-uniformly partitioned data).

Between the map and reduce stages, the data are *shuffled* (parallel-sorted / exchanged between nodes) in order to move the data from the map node that produced them to the shard in which they will be reduced. The shuffle can sometimes take longer than the computation time depending on network bandwidth, CPU speeds, data produced and time taken by map and reduce computations.

### Comparison function

The input for each *Reduce* is pulled from the machine where the *Map* ran and sorted using the application's *comparison* function.

### Reduce function

The framework calls the application's *Reduce* function once for each unique key in the sorted order. The *Reduce* can iterate through the values that are associated with that key and produce zero or more outputs.

In the word count example, the *Reduce* function takes the input values, sums them and generates a single output of the word and the final sum.

### Output writer

The *Output Writer* writes the output of the *Reduce* to the stable storage.

## Theoretical background

Properties of [monoids](/source/Monoid) are the basis for ensuring the validity of MapReduce operations.[18][19]

In the Algebird package[20] a Scala implementation of Map/Reduce explicitly requires a monoid class type .[21]

The operations of MapReduce deal with two types: the type *A* of input data being mapped, and the type *B* of output data being reduced.

The *Map* operation takes individual values of type *A* and produces, for each *a:A* a value *b:B*; The *Reduce* operation requires a binary operation • defined on values of type *B*; it consists of folding all available *b:B* to a single value.

From a basic requirements point of view, any MapReduce operation must involve the ability to arbitrarily regroup data being reduced. Such a requirement amounts to two properties of the operation •:

- associativity: (*x* • *y*) • *z* = *x* • (*y* • *z*)

- existence of neutral element *e* such that *e* • *x* = *x* • *e* = *x* for every *x:B*.

The second property guarantees that, when parallelized over multiple nodes, the nodes that don't have any data to process would have no impact on the result.

These two properties amount to having a [monoid](/source/Monoid) (*B*, •, *e*) on values of type *B* with operation • and with neutral element *e*.

There's no requirements on the values of type *A*; an arbitrary function *A* → *B* can be used for the *Map* operation. This means that we have a [catamorphism](/source/Catamorphism) *A** → (*B*, •, *e*). Here *A** denotes a [Kleene star](/source/Kleene_star), also known as the type of lists over *A*.

The *Shuffle* operation per se is not related to the essence of MapReduce; it's needed to distribute calculations over the cloud.

It follows from the above that not every binary *Reduce* operation will work in MapReduce. Here are the counter-examples:

- building a tree from subtrees: this operation is not associative, and the result will depend on grouping;

- direct calculation of averages: *avg* is also not associative (and it has no neutral element); to calculate an average, one needs to calculate [moments](/source/Moment_(mathematics)).

## Performance considerations

MapReduce programs are not guaranteed to be fast. The main benefit of this programming model is to exploit the optimized shuffle operation of the platform, and only having to write the *Map* and *Reduce* parts of the program. In practice, the author of a MapReduce program however has to take the shuffle step into consideration; in particular the partition function and the amount of data written by the *Map* function can have a large impact on the performance and scalability. Additional modules such as the *Combiner* function can help to reduce the amount of data written to disk, and transmitted over the network. MapReduce applications can achieve sub-linear speedups under specific circumstances.[22]

When designing a MapReduce algorithm, the author needs to choose a good tradeoff[11] between the computation and the communication costs. Communication cost often dominates the computation cost,[11][22] and many MapReduce implementations are designed to write all communication to distributed storage for crash recovery.

In tuning performance of MapReduce, the complexity of mapping, shuffle, sorting (grouping by the key), and reducing has to be taken into account. The amount of data produced by the mappers is a key parameter that shifts the bulk of the computation cost between mapping and reducing. Reducing includes sorting (grouping of the keys) which has nonlinear complexity. Hence, small partition sizes reduce sorting time, but there is a trade-off because having a large number of reducers may be impractical. The influence of split unit size is marginal (unless chosen particularly badly, say <1MB). The gains from some mappers reading load from local disks, on average, is minor.[23]

For processes that complete quickly, and where the data fits into main memory of a single machine or a small cluster, using a MapReduce framework usually is not effective. Since these frameworks are designed to recover from the loss of whole nodes during the computation, they write interim results to distributed storage. This crash recovery is expensive, and only pays off when the computation involves many computers and a long runtime of the computation. A task that completes in seconds can just be restarted in the case of an error, and the likelihood of at least one machine failing grows quickly with the cluster size. On such problems, implementations keeping all data in memory and simply restarting a computation on node failures or —when the data is small enough— non-distributed solutions will often be faster than a MapReduce system.

## Distribution and reliability

MapReduce achieves reliability by parceling out a number of operations on the set of data to each node in the network. Each node is expected to report back periodically with completed work and status updates. If a node falls silent for longer than that interval, the master node (similar to the master server in the [Google File System](/source/Google_File_System)) records the node as dead and sends out the node's assigned work to other nodes. Individual operations use [atomic](/source/Atomicity_(programming)) operations for naming file outputs as a check to ensure that there are not parallel conflicting threads running. When files are renamed, it is possible to also copy them to another name in addition to the name of the task (allowing for [side-effects](/source/Side-effect_(computer_science))).

The reduce operations operate much the same way. Because of their inferior properties with regard to parallel operations, the master node attempts to schedule reduce operations on the same node, or in the same rack as the node holding the data being operated on. This property is desirable as it conserves bandwidth across the backbone network of the datacenter.

Implementations are not necessarily highly reliable. For example, in older versions of [Hadoop](/source/Hadoop) the *NameNode* was a [single point of failure](/source/Single_point_of_failure) for the distributed filesystem. Later versions of Hadoop have high availability with an active/passive failover for the "NameNode."

## Uses

MapReduce is useful in a wide range of applications, including distributed pattern-based searching, distributed sorting, web link-graph reversal, Singular Value Decomposition,[24] web access log stats, [inverted index](/source/Inverted_index) construction, [document clustering](/source/Document_clustering), [machine learning](/source/Machine_learning),[25] and [statistical machine translation](/source/Statistical_machine_translation). Moreover, the MapReduce model has been adapted to several computing environments like multi-core and many-core systems,[26][27][28] desktop grids,[29] multi-cluster,[30] volunteer computing environments,[31] dynamic cloud environments,[32] mobile environments,[33] and high-performance computing environments.[34]

At Google, MapReduce was used to completely regenerate Google's index of the [World Wide Web](/source/World_Wide_Web). It replaced the old *ad hoc* programs that updated the index and ran the various analyses.[35] Development at Google has since moved on to technologies such as Percolator, FlumeJava[36] and [MillWheel](/source/Google_MillWheel) that offer streaming operation and updates instead of batch processing, to allow integrating "live" search results without rebuilding the complete index.[37]

MapReduce's stable inputs and outputs are usually stored in a [distributed file system](/source/Distributed_file_system). The transient data are usually stored on local disk and fetched remotely by the reducers.

## Criticism

### Lack of novelty

[David DeWitt](/source/David_DeWitt) and [Michael Stonebraker](/source/Michael_Stonebraker), computer scientists specializing in [parallel databases](/source/Parallel_database) and [shared-nothing architectures](/source/Shared-nothing_architecture), have been critical of the breadth of problems that MapReduce can be used for.[38] They called its interface too low-level and questioned whether it really represents the [paradigm shift](/source/Paradigm_shift) its proponents have claimed it is.[39] They challenged the MapReduce proponents' claims of novelty, citing [Teradata](/source/Teradata) as an example of [prior art](/source/Prior_art) that has existed for over two decades. They also compared MapReduce programmers to [CODASYL](/source/CODASYL) programmers, noting both are "writing in a [low-level language](/source/Low-level_programming_language) performing low-level record manipulation."[39] MapReduce's use of input files and lack of [schema](/source/Logical_schema) support prevents the performance improvements enabled by common database system features such as [B-trees](/source/B-tree) and [hash partitioning](/source/Partition_(database)), though projects such as [Pig (or PigLatin)](/source/Pig_(programming_language)), [Sawzall](/source/Sawzall_(programming_language)), [Apache Hive](/source/Apache_Hive),[40] [HBase](/source/HBase)[41] and [Bigtable](/source/Bigtable)[41][42] are addressing some of these problems.

Greg Jorgensen wrote an article rejecting these views.[43] Jorgensen asserts that DeWitt and Stonebraker's entire analysis is groundless as MapReduce was never designed nor intended to be used as a database.

DeWitt and Stonebraker have subsequently published a detailed benchmark study in 2009 comparing performance of [Hadoop's](/source/Hadoop) MapReduce and [RDBMS](/source/RDBMS) approaches on several specific problems.[44] They concluded that relational databases offer real advantages for many kinds of data use, especially on complex processing or where the data is used across an enterprise, but that MapReduce may be easier for users to adopt for simple or one-time processing tasks.

The MapReduce programming paradigm was also described in [Danny Hillis](/source/Danny_Hillis)'s 1985 thesis [45] intended for use on the [Connection Machine](/source/Connection_Machine), where it was called "xapping/reduction"[46] and relied upon that machine's special hardware to accelerate both map and reduce. The dialect ultimately used for the Connection Machine, the 1986 [StarLisp](/source/StarLisp), had parallel *map and reduce!!,[47] which in turn was based on the 1984 [Common Lisp](/source/Common_Lisp), which had non-parallel map and reduce built in.[48] The [tree-like](/source/Fold_(higher-order_function)#Linear_vs._tree-like_folds) approach that the Connection Machine's [hypercube architecture](/source/Hypercube_internetwork_topology) uses to execute reduce in O ( log ⁡ n ) {\displaystyle O(\log n)} time[49] is effectively the same as the approach referred to within the Google paper as prior work.[3]: 11

In 2010 Google was granted what is described as a patent on MapReduce. The patent, filed in 2004, may cover use of MapReduce by open source software such as [Hadoop](/source/Hadoop), [CouchDB](/source/CouchDB), and others. In *[Ars Technica](/source/Ars_Technica)*, an editor acknowledged Google's role in popularizing the MapReduce concept, but questioned whether the patent was valid or novel.[50][51] In 2013, as part of its "Open Patent Non-Assertion (OPN) Pledge", Google pledged to only use the patent defensively.[52][53] The patent is expected to expire on 23 December 2026.[54]

### Restricted programming framework

MapReduce tasks must be written as acyclic dataflow programs, i.e. a stateless mapper followed by a stateless reducer, that are executed by a batch job scheduler. This paradigm makes repeated querying of datasets difficult and imposes limitations that are felt in fields such as [graph](/source/Graph_(abstract_data_type)) processing[55] where iterative algorithms that revisit a single [working set](/source/Working_set) multiple times are the norm, as well as, in the presence of [disk](/source/Hard_disk_drive)-based data with high [latency](/source/Latency_(engineering)#Mechanics), even the field of [machine learning](/source/Machine_learning) where multiple passes through the data are required even though algorithms can tolerate serial access to the data each pass.[56]

## See also

- [Bird–Meertens formalism](/source/Bird%E2%80%93Meertens_formalism)

- [Parallelization contract](/source/Parallelization_contract)

### Implementations of MapReduce

- [Apache CouchDB](/source/Apache_CouchDB)

- [Apache Hadoop](/source/Apache_Hadoop)

- [Infinispan](/source/Infinispan)

- [Riak](/source/Riak)

## References

1. **[^](#cite_ref-1)** ["MapReduce Tutorial"](https://hadoop.apache.org/docs/r1.2.1/mapred_tutorial.html). *Apache Hadoop*. Retrieved 3 July 2019.

1. **[^](#cite_ref-2)** ["Google spotlights data center inner workings"](https://web.archive.org/web/20131019063218/http://news.cnet.com/8301-10784_3-9955184-7.html). *cnet.com*. 30 May 2008. Archived from [the original](https://news.cnet.com/8301-10784_3-9955184-7.html) on 19 October 2013. Retrieved 31 May 2008.

1. ^ [***a***](#cite_ref-GoogleMapReduce_3-0) [***b***](#cite_ref-GoogleMapReduce_3-1) ["MapReduce: Simplified Data Processing on Large Clusters"](http://static.googleusercontent.com/media/research.google.com/es/us/archive/mapreduce-osdi04.pdf) (PDF). *googleusercontent.com*.

1. **[^](#cite_ref-4)** Wickham, Hadley (2011). ["The split-apply-combine strategy for data analysis"](https://doi.org/10.18637%2Fjss.v040.i01). *Journal of Statistical Software*. **40**: 1–29. [doi](/source/Doi_(identifier)):[10.18637/jss.v040.i01](https://doi.org/10.18637%2Fjss.v040.i01).

1. **[^](#cite_ref-map_5-0)** "Our abstraction is inspired by the map and reduce primitives present in Lisp and many other functional languages." -["MapReduce: Simplified Data Processing on Large Clusters"](http://research.google.com/archive/mapreduce.html), by Jeffrey Dean and Sanjay Ghemawat; from Google Research

1. **[^](#cite_ref-6)** Lämmel, R. (2008). "Google's Map *Reduce* programming model — Revisited". *Science of Computer Programming*. **70**: 1–30. [doi](/source/Doi_(identifier)):[10.1016/j.scico.2007.07.001](https://doi.org/10.1016%2Fj.scico.2007.07.001).

1. **[^](#cite_ref-7)** [http://www.mcs.anl.gov/research/projects/mpi/mpi-standard/mpi-report-2.0/mpi2-report.htm](http://www.mcs.anl.gov/research/projects/mpi/mpi-standard/mpi-report-2.0/mpi2-report.htm) MPI 2 standard

1. **[^](#cite_ref-8)** ["MPI Reduce and Allreduce · MPI Tutorial"](http://mpitutorial.com/tutorials/mpi-reduce-and-allreduce/). *mpitutorial.com*.

1. **[^](#cite_ref-9)** ["Performing Parallel Rank with MPI · MPI Tutorial"](http://mpitutorial.com/tutorials/performing-parallel-rank-with-mpi/). *mpitutorial.com*.

1. **[^](#cite_ref-stackoverflow_10-0)** ["MongoDB: Terrible MapReduce Performance"](https://stackoverflow.com/questions/3947889/mongodb-terrible-mapreduce-performance). Stack Overflow. October 16, 2010. The MapReduce implementation in MongoDB has little to do with map reduce apparently. Because for all I read, it is single-threaded, while map-reduce is meant to be used highly parallel on a cluster. ... MongoDB MapReduce is single threaded on a single server...

1. ^ [***a***](#cite_ref-ullman_11-0) [***b***](#cite_ref-ullman_11-1) [***c***](#cite_ref-ullman_11-2) [Ullman, J. D.](/source/Jeffrey_Ullman) (2012). ["Designing good MapReduce algorithms"](http://xrds.acm.org/article.cfm?aid=2331053). *XRDS: Crossroads, the ACM Magazine for Students*. **19**: 30–34. [doi](/source/Doi_(identifier)):[10.1145/2331042.2331053](https://doi.org/10.1145%2F2331042.2331053). [S2CID](/source/S2CID_(identifier)) [26498063](https://api.semanticscholar.org/CorpusID:26498063).

1. **[^](#cite_ref-12)** Sverdlik, Yevgeniy (2014-06-25). ["Google Dumps MapReduce in Favor of New Hyper-Scale Analytics System"](http://www.datacenterknowledge.com/archives/2014/06/25/google-dumps-mapreduce-favor-new-hyper-scale-analytics-system/). *Data Center Knowledge*. Retrieved 2015-10-25. "We don't really use MapReduce anymore" [Urs Hölzle, senior vice president of technical infrastructure at Google]

1. **[^](#cite_ref-13)** ["Why MapReduce Is Still A Dominant Approach For Large-Scale Machine Learning"](https://analyticsindiamag.com/ai-origins-evolution/why-mapreduce-is-still-a-dominant-approach-for-large-scale-machine-learning/). *Analytics India*. April 5, 2019.

1. **[^](#cite_ref-14)** Czajkowski, Grzegorz; Marián Dvorský; Jerry Zhao; Michael Conley (7 September 2011). ["Sorting Petabytes with MapReduce – The Next Episode"](https://googleresearch.blogspot.com/2011/09/sorting-petabytes-with-mapreduce-next.html). Retrieved 7 April 2014.

1. **[^](#cite_ref-15)** ["MapReduce Tutorial"](https://hadoop.apache.org/docs/r1.2.1/mapred_tutorial.html#Inputs+and+Outputs).

1. **[^](#cite_ref-16)** ["Apache/Hadoop-mapreduce"](https://github.com/apache/hadoop-mapreduce/blob/307cb5b316e10defdbbc228d8cdcdb627191ea15/src/java/org/apache/hadoop/mapreduce/Reducer.java#L148). *[GitHub](/source/GitHub)*. 31 August 2021.

1. **[^](#cite_ref-17)** ["Example: Count word occurrences"](http://research.google.com/archive/mapreduce-osdi04-slides/index-auto-0004.html). Google Research. Retrieved September 18, 2013.

1. **[^](#cite_ref-18)** Fegaras, Leonidas (2017). "An algebra for distributed Big Data analytics". *Journal of Functional Programming*. **28** e27. [doi](/source/Doi_(identifier)):[10.1017/S0956796817000193](https://doi.org/10.1017%2FS0956796817000193). [S2CID](/source/S2CID_(identifier)) [44629767](https://api.semanticscholar.org/CorpusID:44629767).

1. **[^](#cite_ref-19)** Lin, Jimmy (29 Apr 2013). "Monoidify! Monoids as a Design Principle for Efficient MapReduce Algorithms". [arXiv](/source/ArXiv_(identifier)):[1304.7544](https://arxiv.org/abs/1304.7544) [[cs.DC](https://arxiv.org/archive/cs.DC)].

1. **[^](#cite_ref-20)** ["Abstract Algebra for Scala"](https://twitter.github.io/algebird/).

1. **[^](#cite_ref-21)** ["Encoding Map-Reduce As A Monoid With Left Folding"](http://erikerlandson.github.io/blog/2016/09/05/expressing-map-reduce-as-a-left-folding-monoid/). 5 September 2016.

1. ^ [***a***](#cite_ref-:0_22-0) [***b***](#cite_ref-:0_22-1) Senger, Hermes; Gil-Costa, Veronica; Arantes, Luciana; Marcondes, Cesar A. C.; Marín, Mauricio; Sato, Liria M.; da Silva, Fabrício A.B. (2015-01-01). "BSP cost and scalability analysis for MapReduce operations". *Concurrency and Computation: Practice and Experience*. **28** (8): 2503–2527. [doi](/source/Doi_(identifier)):[10.1002/cpe.3628](https://doi.org/10.1002%2Fcpe.3628). [hdl](/source/Hdl_(identifier)):[10533/147670](https://hdl.handle.net/10533%2F147670). [ISSN](/source/ISSN_(identifier)) [1532-0634](https://search.worldcat.org/issn/1532-0634). [S2CID](/source/S2CID_(identifier)) [33645927](https://api.semanticscholar.org/CorpusID:33645927).

1. **[^](#cite_ref-23)** Berlińska, Joanna; Drozdowski, Maciej (2010-12-01). "Scheduling divisible MapReduce computations". *Journal of Parallel and Distributed Computing*. **71** (3): 450–459. [doi](/source/Doi_(identifier)):[10.1016/j.jpdc.2010.12.004](https://doi.org/10.1016%2Fj.jpdc.2010.12.004).

1. **[^](#cite_ref-24)** Bosagh Zadeh, Reza; Carlsson, Gunnar (2013). ["Dimension Independent Matrix Square Using MapReduce"](https://stanford.edu/~rezab/papers/dimsum.pdf) (PDF). *Stanford University*. [arXiv](/source/ArXiv_(identifier)):[1304.1467](https://arxiv.org/abs/1304.1467). [Bibcode](/source/Bibcode_(identifier)):[2013arXiv1304.1467B](https://ui.adsabs.harvard.edu/abs/2013arXiv1304.1467B). Retrieved 12 July 2014.

1. **[^](#cite_ref-mrml_25-0)** Ng, Andrew Y.; Bradski, Gary; Chu, Cheng-Tao; Olukotun, Kunle; Kim, Sang Kyun; Lin, Yi-An; Yu, YuanYuan (2006). ["Map-Reduce for Machine Learning on Multicore"](https://web.archive.org/web/20100620092743/http://www.willowgarage.com/map-reduce-machine-learning-multicore). NIPS 2006. Archived from [the original](http://www.willowgarage.com/map-reduce-machine-learning-multicore) on 2010-06-20. Retrieved 2009-11-24.

1. **[^](#cite_ref-evalMR_26-0)** Ranger, C.; Raghuraman, R.; Penmetsa, A.; Bradski, G.; Kozyrakis, C. (2007). "Evaluating MapReduce for Multi-core and Multiprocessor Systems". *2007 IEEE 13th International Symposium on High Performance Computer Architecture*. p. 13. [CiteSeerX](/source/CiteSeerX_(identifier)) [10.1.1.220.8210](https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.220.8210). [doi](/source/Doi_(identifier)):[10.1109/HPCA.2007.346181](https://doi.org/10.1109%2FHPCA.2007.346181). [ISBN](/source/ISBN_(identifier)) [978-1-4244-0804-7](https://en.wikipedia.org/wiki/Special:BookSources/978-1-4244-0804-7). [S2CID](/source/S2CID_(identifier)) [12563671](https://api.semanticscholar.org/CorpusID:12563671).

1. **[^](#cite_ref-graphicsMR_27-0)** He, B.; Fang, W.; Luo, Q.; Govindaraju, N. K.; Wang, T. (2008). ["Mars: a MapReduce framework on graphics processors"](http://wenbin.org/doc/papers/Wenbin08PACT.pdf) (PDF). *Proceedings of the 17th international conference on Parallel architectures and compilation techniques – PACT '08*. p. 260. [doi](/source/Doi_(identifier)):[10.1145/1454115.1454152](https://doi.org/10.1145%2F1454115.1454152). [ISBN](/source/ISBN_(identifier)) [9781605582825](https://en.wikipedia.org/wiki/Special:BookSources/9781605582825). [S2CID](/source/S2CID_(identifier)) [207169888](https://api.semanticscholar.org/CorpusID:207169888).

1. **[^](#cite_ref-tiledMR_28-0)** Chen, R.; Chen, H.; Zang, B. (2010). "Tiled-MapReduce: optimizing resource usages of data-parallel applications on multicore with tiling". *Proceedings of the 19th international conference on Parallel architectures and compilation techniques – PACT '10*. p. 523. [doi](/source/Doi_(identifier)):[10.1145/1854273.1854337](https://doi.org/10.1145%2F1854273.1854337). [ISBN](/source/ISBN_(identifier)) [9781450301787](https://en.wikipedia.org/wiki/Special:BookSources/9781450301787). [S2CID](/source/S2CID_(identifier)) [2082196](https://api.semanticscholar.org/CorpusID:2082196).

1. **[^](#cite_ref-gridMR_29-0)** Tang, B.; Moca, M.; Chevalier, S.; He, H.; Fedak, G. (2010). ["Towards MapReduce for Desktop Grid Computing"](http://graal.ens-lyon.fr/~gfedak/papers/xtremmapreduce.3pgcic10.pdf) (PDF). *2010 International Conference on P2P, Parallel, Grid, Cloud and Internet Computing*. p. 193. [CiteSeerX](/source/CiteSeerX_(identifier)) [10.1.1.671.2763](https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.671.2763). [doi](/source/Doi_(identifier)):[10.1109/3PGCIC.2010.33](https://doi.org/10.1109%2F3PGCIC.2010.33). [ISBN](/source/ISBN_(identifier)) [978-1-4244-8538-3](https://en.wikipedia.org/wiki/Special:BookSources/978-1-4244-8538-3). [S2CID](/source/S2CID_(identifier)) [15044391](https://api.semanticscholar.org/CorpusID:15044391).

1. **[^](#cite_ref-HMR_30-0)** Luo, Y.; Guo, Z.; Sun, Y.; [Plale, B.](/source/Beth_Plale); Qiu, J.; Li, W. (2011). ["A Hierarchical Framework for Cross-Domain MapReduce Execution"](http://yuanluo.net/publications/LUO_ECMLS2011.pdf) (PDF). *Proceedings of the second international workshop on Emerging computational methods for the life sciences (ECMLS '11)*. [CiteSeerX](/source/CiteSeerX_(identifier)) [10.1.1.364.9898](https://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.364.9898). [doi](/source/Doi_(identifier)):[10.1145/1996023.1996026](https://doi.org/10.1145%2F1996023.1996026). [ISBN](/source/ISBN_(identifier)) [978-1-4503-0702-4](https://en.wikipedia.org/wiki/Special:BookSources/978-1-4503-0702-4). [S2CID](/source/S2CID_(identifier)) [15179363](https://api.semanticscholar.org/CorpusID:15179363).

1. **[^](#cite_ref-volunteerMR_31-0)** Lin, H.; Ma, X.; Archuleta, J.; Feng, W. C.; Gardner, M.; Zhang, Z. (2010). ["MOON: MapReduce On Opportunistic eNvironments"](http://eprints.cs.vt.edu/archive/00001089/01/moon.pdf) (PDF). *Proceedings of the 19th ACM International Symposium on High Performance Distributed Computing – HPDC '10*. p. 95. [doi](/source/Doi_(identifier)):[10.1145/1851476.1851489](https://doi.org/10.1145%2F1851476.1851489). [ISBN](/source/ISBN_(identifier)) [9781605589428](https://en.wikipedia.org/wiki/Special:BookSources/9781605589428). [S2CID](/source/S2CID_(identifier)) [2351790](https://api.semanticscholar.org/CorpusID:2351790).

1. **[^](#cite_ref-dynCloudMR_32-0)** Marozzo, F.; Talia, D.; Trunfio, P. (2012). ["P2P-MapReduce: Parallel data processing in dynamic Cloud environments"](https://doi.org/10.1016%2Fj.jcss.2011.12.021). *[Journal of Computer and System Sciences](/source/Journal_of_Computer_and_System_Sciences)*. **78** (5): 1382–1402. [doi](/source/Doi_(identifier)):[10.1016/j.jcss.2011.12.021](https://doi.org/10.1016%2Fj.jcss.2011.12.021).

1. **[^](#cite_ref-mobileMR_33-0)** Dou, A.; Kalogeraki, V.; Gunopulos, D.; Mielikainen, T.; Tuulos, V. H. (2010). "Misco: a MapReduce framework for mobile systems". *Proceedings of the 3rd International Conference on PErvasive Technologies Related to Assistive Environments – PETRA '10*. p. 1. [doi](/source/Doi_(identifier)):[10.1145/1839294.1839332](https://doi.org/10.1145%2F1839294.1839332). [ISBN](/source/ISBN_(identifier)) [9781450300711](https://en.wikipedia.org/wiki/Special:BookSources/9781450300711). [S2CID](/source/S2CID_(identifier)) [14517696](https://api.semanticscholar.org/CorpusID:14517696).

1. **[^](#cite_ref-34)** Wang, Yandong; Goldstone, Robin; Yu, Weikuan; Wang, Teng (May 2014). "Characterization and Optimization of Memory-Resident MapReduce on HPC Systems". *2014 IEEE 28th International Parallel and Distributed Processing Symposium*. IEEE. pp. 799–808. [doi](/source/Doi_(identifier)):[10.1109/IPDPS.2014.87](https://doi.org/10.1109%2FIPDPS.2014.87). [ISBN](/source/ISBN_(identifier)) [978-1-4799-3800-1](https://en.wikipedia.org/wiki/Special:BookSources/978-1-4799-3800-1). [S2CID](/source/S2CID_(identifier)) [11157612](https://api.semanticscholar.org/CorpusID:11157612).

1. **[^](#cite_ref-usage_35-0)** ["How Google Works"](http://www.baselinemag.com/c/a/Infrastructure/How-Google-Works-1/5). baselinemag.com. 7 July 2006. As of October, Google was running about 3,000 computing jobs per day through MapReduce, representing thousands of machine-days, according to a presentation by Dean. Among other things, these batch routines analyze the latest Web pages and update Google's indexes.

1. **[^](#cite_ref-Chambers2010_36-0)** Chambers, Craig; Raniwala, Ashish; Perry, Frances; Adams, Stephen; Henry, Robert R.; Bradshaw, Robert; Weizenbaum, Nathan (1 January 2010). "FlumeJava". [*Proceedings of the 31st ACM SIGPLAN Conference on Programming Language Design and Implementation*](https://web.archive.org/web/20160923141630/https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/35650.pdf) (PDF). pp. 363–375. [doi](/source/Doi_(identifier)):[10.1145/1806596.1806638](https://doi.org/10.1145%2F1806596.1806638). [ISBN](/source/ISBN_(identifier)) [9781450300193](https://en.wikipedia.org/wiki/Special:BookSources/9781450300193). [S2CID](/source/S2CID_(identifier)) [14888571](https://api.semanticscholar.org/CorpusID:14888571). Archived from [the original](https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/35650.pdf) (PDF) on 23 September 2016. Retrieved 4 August 2016.

1. **[^](#cite_ref-37)** Peng, D., & Dabek, F. (2010, October). Large-scale Incremental Processing Using Distributed Transactions and Notifications. In OSDI (Vol. 10, pp. 1-15).

1. **[^](#cite_ref-shark_38-0)** ["Database Experts Jump the MapReduce Shark"](http://typicalprogrammer.com/relational-database-experts-jump-the-mapreduce-shark).

1. ^ [***a***](#cite_ref-ddandms1_39-0) [***b***](#cite_ref-ddandms1_39-1) [David DeWitt](/source/David_DeWitt); [Michael Stonebraker](/source/Michael_Stonebraker). ["MapReduce: A major step backwards"](https://craig-henderson.blogspot.com/2009/11/dewitt-and-stonebrakers-mapreduce-major.html). craig-henderson.blogspot.com. Retrieved 2008-08-27.

1. **[^](#cite_ref-ApacheHiveWiki_40-0)** ["Apache Hive – Index of – Apache Software Foundation"](https://cwiki.apache.org/confluence/display/Hive/Home).

1. ^ [***a***](#cite_ref-HBase_41-0) [***b***](#cite_ref-HBase_41-1) ["HBase – HBase Home – Apache Software Foundation"](https://hbase.apache.org/).

1. **[^](#cite_ref-BigtablePaper_42-0)** ["Bigtable: A Distributed Storage System for Structured Data"](http://research.google.com/archive/bigtable-osdi06.pdf) (PDF).

1. **[^](#cite_ref-gj1_43-0)** [Greg Jorgensen](https://en.wikipedia.org/w/index.php?title=Greg_Jorgensen&action=edit&redlink=1). ["Relational Database Experts Jump The MapReduce Shark"](http://typicalprogrammer.com/relational-database-experts-jump-the-mapreduce-shark). typicalprogrammer.com. Retrieved 2009-11-11.

1. **[^](#cite_ref-sigmod_44-0)** Pavlo, Andrew; Paulson, Erik; Rasin, Alexander; Abadi, Daniel J.; DeWitt, Deavid J.; Madden, Samuel; Stonebraker, Michael. ["A Comparison of Approaches to Large-Scale Data Analysis"](https://database.cs.brown.edu/projects/mapreduce-vs-dbms). Brown University. Retrieved 2010-01-11.

1. **[^](#cite_ref-WDHmit86_45-0)** Hillis, W. Danny (1986). [*The Connection Machine*](https://archive.org/details/connectionmachin00hill). [MIT Press](/source/MIT_Press). [ISBN](/source/ISBN_(identifier)) [0262081571](https://en.wikipedia.org/wiki/Special:BookSources/0262081571).

1. **[^](#cite_ref-46)** ["Connection Machine Model CM-2 Technical Summary"](http://bitsavers.trailing-edge.com/pdf/thinkingMachines/CM2/HA87-4_Connection_Machine_Model_CM-2_Technical_Summary_Apr1987.pdf) (PDF). [Thinking Machines Corporation](/source/Thinking_Machines_Corporation). 1987-04-01. Retrieved 2022-11-21.

1. **[^](#cite_ref-47)** ["Supplement to the *Lisp Reference Manual"](https://www.softwarepreservation.org/projects/LISP/starlisp/supplement-to-the-starlisp-reference-manual-version-5-0.pdf) (PDF). [Thinking Machines Corporation](/source/Thinking_Machines_Corporation). 1988-09-01. Retrieved 2022-11-21.

1. **[^](#cite_ref-48)** ["Rediflow Architecture Prospectus"](https://collections.lib.utah.edu/dl_files/20/2e/202ebf04b52d043c78297444bc9bc4fbc17b6b5e.pdf) (PDF). [University of Utah Department of Computer Science](/source/University_of_Utah_School_of_Computing). 1986-04-05. Retrieved 2022-11-21.

1. **[^](#cite_ref-49)** Ranka, Sanjay (1989). "2.6 Data Sum". [*Hypercube Algorithms for Image Processing and Pattern Recognition*](https://www.cise.ufl.edu/~sahni/papers/imagemono.pdf#page=20) (PDF). University of Florida. Retrieved 2022-12-08.

1. **[^](#cite_ref-50)** Paul, Ryan (20 January 2010). ["Google's MapReduce patent: what does it mean for Hadoop?"](https://arstechnica.com/information-technology/2010/01/googles-mapreduce-patent-what-does-it-mean-for-hadoop/). *Ars Technica*. Retrieved 21 March 2021.

1. **[^](#cite_ref-patent_51-0)** ["United States Patent: 7650331 - System and method for efficient large-scale data processing"](https://web.archive.org/web/20130921164908/http://patft.uspto.gov/netacgi/nph-Parser?Sect1=PTO1&Sect2=HITOFF&d=PALL&p=1&u=/netahtml/PTO/srchnum.htm&r=1&f=G&l=50&s1=7,650,331.PN.&OS=PN/7,650,331&RS=PN/7,650,331). *uspto.gov*. Archived from [the original](http://patft.uspto.gov/netacgi/nph-Parser?Sect1=PTO1&Sect2=HITOFF&d=PALL&p=1&u=/netahtml/PTO/srchnum.htm&r=1&f=G&l=50&s1=7,650,331.PN.&OS=PN/7,650,331&RS=PN/7,650,331) on 2013-09-21. Retrieved 2010-01-19.

1. **[^](#cite_ref-52)** Nazer, Daniel (28 March 2013). ["Google Makes Open Patent Non-assertion Pledge and Proposes New Licensing Models"](https://www.eff.org/deeplinks/2013/03/google-makes-open-patent-non-assertion-pledge). *Electronic Frontier Foundation*. Retrieved 21 March 2021.

1. **[^](#cite_ref-53)** King, Rachel (2013). ["Google expands open patent pledge to 79 more about data center management"](https://www.zdnet.com/article/google-expands-open-patent-pledge-to-79-more-about-data-center-management/). *ZDNet*. Retrieved 21 March 2021.

1. **[^](#cite_ref-54)** ["System and method for efficient large-scale data processing"](https://patents.google.com/patent/US7650331B1/en). Google Patents Search. 18 June 2004. Retrieved 21 March 2021.

1. **[^](#cite_ref-55)** Gupta, Upa; Fegaras, Leonidas (2013-10-06). ["Map-Based Graph Analysis on MapReduce"](https://csc.csudh.edu/btang/seminar/papers/BigD399.pdf) (PDF). *Proceedings: 2013 IEEE International Conference on Big Data*. 2013 IEEE International Conference on Big Data. [Santa Clara, California](/source/Santa_Clara%2C_California): [IEEE](/source/IEEE). pp. 24–30.

1. **[^](#cite_ref-56)** Zaharia, Matei; Chowdhury, Mosharaf; Franklin, Michael; Shenker, Scott; Stoica, Ion (June 2010). [*Spark: Cluster Computing with Working Sets*](https://amplab.cs.berkeley.edu/wp-content/uploads/2011/06/Spark-Cluster-Computing-with-Working-Sets.pdf) (PDF). HotCloud 2010.

Wikimedia Commons has media related to [MapReduce](https://commons.wikimedia.org/wiki/Category:MapReduce).

v t e Google a subsidiary of Alphabet Company Divisions AI Area 120 ATAP Brain China Cloud Platform Energy Google.org Crisis Response Registry Subsidiaries Active DeepMind Fitbit ITA Software Jigsaw Looker Mandiant Security Operations Owlchemy Labs Defunct Actifio Adscape Akwan Information Technologies Anvato Apigee BandPage Bitium BufferBox Crashlytics Dodgeball DoubleClick Dropcam Endoxon Flutter Global IP Solutions Green Throttle Games GreenBorder Gridcentric ImageAmerica Impermium Invite Media Kaltix Marratech Meebo Metaweb Neotonic Software Neverware Nik Software Orbitera Pyra Labs Quest Visual Reqwireless RightsFlow Sidewalk Labs SlickLogin Titan Aerospace Typhoon Studios Urban Engines Vicarious Viewdle Wavii Wildfire Interactive YouTube Next Lab and Audience Development Group Programs Business Groups Computing University Initiative Contact Lens Content ID CrossCheck Data Liberation Front Data Transfer Project Developer Expert DigiKavach DigiPivot Digital Garage Digital News Initiative Digital Unlocked Dragonfly Founders' Award Free Zone Get Your Business Online Google for Education Google for Health Google for Startups Living Stories Made with Code News Lab PowerMeter Privacy Sandbox Project Nightingale Project Nimbus Project Sunroof Project Zero Quantum Artificial Intelligence Lab RechargeIT Sensorvault Silicon Initiative Solve for X Street View Trusted Student Ambassador Program Vevo YouTube BrandConnect YouTube Creator Awards YouTube Select YouTube Original Channel Initiative Year in Search YouTube Rewind 2018 2019 Events AlphaGo versus Fan Hui AlphaGo versus Lee Sedol AlphaGo versus Ke Jie Android Developer Challenge Android Developer Day Android Developer Lab CNN/YouTube presidential debates Code-in Code Jam Developer Day Developers Live Doodle4Google Future of Go Summit G-Day Hash Code I/O Lunar X Prize Mapathon Science Fair Summer of Code World Chess Championship 2024 YouTube Awards YouTube Comedy Week YouTube Live YouTube Music Awards 2013 2015 YouTube Space Lab YouTube Symphony Orchestra Infrastructure 111 Eighth Avenue Android lawn statues Androidland Barges Binoculars Building Central Saint Giles Chelsea Market Chrome Zone Data centers GeoEye-1 Googleplex Ivanpah Solar Power Facility James R. Thompson Center King's Cross Mayfield Mall Pier 57 Sidewalk Toronto St. John's Terminal Submarine cables Dunant Grace Hopper Unity WiFi YouTube Space YouTube Theater People Current Krishna Bharat Vint Cerf Jeff Dean John Doerr Sanjay Ghemawat Al Gore John L. Hennessy Urs Hölzle Salar Kamangar Ray Kurzweil Ann Mather Alan Mulally Rick Osterloh Sundar Pichai (CEO) Ruth Porat (CFO) Rajen Sheth Hal Varian Neal Mohan Former Andy Bechtolsheim Sergey Brin (co-founder) David Cheriton Matt Cutts David Drummond Alan Eustace Timnit Gebru Omid Kordestani Paul Otellini Larry Page (co-founder) Patrick Pichette Eric Schmidt Ram Shriram Amit Singhal Shirley M. Tilghman Rachel Whetstone Susan Wojcicki Criticism General Censorship DeGoogle FairSearch "Google's Ideological Echo Chamber" No Tech for Apartheid Privacy concerns Street View YouTube Trade unions Alphabet Workers Union YouTube copyright issues Incidents Backdoor advertisement controversy Blocking of YouTube videos in Germany Data breach Elsagate Fantastic Adventures scandal Kohistan video case Reactions to Innocence of Muslims San Francisco tech bus protests Services outages Slovenian government incident Walkouts YouTube headquarters shooting Other Android apps April Fools' Day jokes Doodles Doodle Champion Island Games Magic Cat Academy Pac-Man Easter eggs History Gmail Search YouTube Logo Material Design Mergers and acquisitions Development Software A–C Accelerated Linear Algebra AMP Actions on Google ALTS American Fuzzy Lop Android Cloud to Device Messaging Android Debug Bridge Android NDK Android Runtime Android SDK Android Studio Angular AngularJS Antigravity Apache Beam APIs App Engine App Inventor App Maker App Runtime for Chrome AppJet Apps Script AppSheet ARCore Base Bazel BeyondCorp Bigtable BigQuery Bionic Blockly Borg Caja Cameyo Chart API Charts Chrome Frame Chromium Blink Closure Tools Cloud Connect Cloud Dataflow Cloud Datastore Cloud Messaging Cloud Shell Cloud Storage Code Search Compute Engine Cpplint D–N Dalvik Data Protocol Data Studio Dialogflow Exposure Notification Fast Pair Fastboot Federated Learning of Cohorts File System Firebase Firebase Studio Firebase Cloud Messaging FlatBuffers Flutter Freebase Gadgets Ganeti Gears Gerrit Global Cache GLOP gRPC Gson Guava Guetzli Guice gVisor GYP JAX Jetpack Compose Keyhole Markup Language Kubernetes Kythe LevelDB Lighthouse lmctfy MapReduce Mashup Editor Matter Mobile Services Namebench Native Client Neatx Neural Machine Translation Nomulus O–Z Open Location Code OpenRefine OpenSocial Optimize OR-Tools Pack PageSpeed Piper Plugin for Eclipse Polymer Programmable Search Engine Project Shield Public DNS reCAPTCHA RenderScript SafetyNet SageTV Schema.org Search Console Shell Sitemaps Skia Graphics Engine Spanner Sputnik Stackdriver Swiffy Tango TensorFlow Tesseract Test Translator Toolkit Urchin UTM parameters V8 VirusTotal VisBug Wave Federation Protocol Weave Web Accelerator Web Designer Web Server Web Toolkit Webdriver Torso WebRTC Operating systems Android Cupcake Donut Eclair Froyo Gingerbread Honeycomb Ice Cream Sandwich Jelly Bean KitKat Lollipop Marshmallow Nougat Oreo Pie 10 11 12 13 14 15 16 version history smartphones Android Automotive Android Go devices Android Things Android TV Google TV interface devices Android XR ChromeOS ChromeOS Flex ChromiumOS Fuchsia Glass OS Google TV gLinux Goobuntu Wear OS Machine learning models BERT Chinchilla DreamBooth Gemini Gemini Robotics Gemma Imagen (2023) LaMDA PaLM T5 Veo (text-to-video model) VideoPoet XLNet Neural networks EfficientNet Gato Inception MobileNet Transformer WaveNet Computer programs AlphaDev AlphaFold AlphaGeometry AlphaGo AlphaGo Zero AlphaStar AlphaZero Master MuZero Formats and codecs AAB APK AV1 iLBC iSAC libvpx Lyra Protocol Buffers Ultra HDR VP3 VP6 VP8 VP9 WebM WebP WOFF2 Programming languages Carbon Dart Go Sawzall Search algorithms Googlebot Hummingbird Mobilegeddon PageRank matrix Panda Penguin Pigeon RankBrain Domain names .app .dev .google .zip g.co google.by Typefaces Croscore Noto Product Sans Roboto Software A Aardvark Account Dashboard Takeout Ad Manager AdMob Ads AdSense Affiliate Network Alerts Allo Analytics Android Auto Android Beam Answers Apture Arts & Culture Assistant Attribution Authenticator B BebaPay BeatThatQuote.com Beam Blog Search Blogger Body Bookmarks Books Ngram Viewer Browser Sync Building Maker Bump BumpTop Buzz C Calendar Cast Catalogs Chat Checkout Chrome Chrome Apps Chrome Experiments Chrome Remote Desktop Chrome Web Store Classroom Cloud Print Cloud Search Contacts Contributor Crowdsource Currents (social app) Currents (news app) D Data Commons Dataset Search Desktop Dictionary Dinosaur Game Directory Docs Docs Editors Domains Drawings Drive Duo E Earth Etherpad Expeditions Express F Family Link Fast Flip FeedBurner fflick Fi Wireless Finance Files Find Hub Fit Flights Flu Trends Fonts Forms Friend Connect Fusion Tables G Gboard Gemini Nano Banana Gesture Search Gizmo5 Google+ Gmail Goggles GOOG-411 Grasshopper Groups H Hangouts Helpouts Home I iGoogle Images Image Labeler Image Swirl Inbox by Gmail Input Tools Japanese Input Pinyin Insights for Search J Jaiku Jamboard K Kaggle Keep Knol L Labs Latitude Lens Like.com Live Transcribe Lively M Map Maker Maps Maps Navigation Marketing Platform Meet Messages Moderator My Tracks N Nearby Share News News & Weather News Archive Notebook NotebookLM Now O Offers One One Pass Opinion Rewards Orkut Oyster P Panoramio PaperofRecord.com Patents Page Creator Pay (mobile app) Pay (payment method) Pay Send People Cards Person Finder Personalized Search Photomath Photos Picasa Picasa Web Albums Picnik Pixel Camera Play Play Books Play Games Play Music Play Newsstand Play Pass Play Services Podcasts Poly Postini PostRank Primer Public Alerts Public Data Explorer Q Question Hub Quick, Draw! Quick Search Box Quick Share Quickoffice R Read Along Reader Reply S Safe Browsing SageTV Santa Tracker Schemer Scholar Search AI Overviews Knowledge Graph SafeSearch Searchwiki Sheets Shoploop Shopping Sidewiki Sites Slides Snapseed Socratic Softcard Songza Sound Amplifier Spaces Sparrow (chatbot) Sparrow (email client) Speech Recognition & Synthesis Squared Stadia Station Store Street View Surveys Sync T Tables Talk TalkBack Tasks Tenor Tez Tilt Brush Toolbar Toontastic 3D Translate Travel Trendalyzer Trends TV U URL Shortener V Video Vids Voice Voice Access Voice Search W Wallet Wave Waze WDYL Web Light Where Is My Train Widevine Wiz Word Lens Workspace Workspace Marketplace Y YouTube YouTube Kids YouTube Music YouTube Premium YouTube Shorts YouTube Studio YouTube TV YouTube VR Hardware Pixel Smartphones Pixel (2016) Pixel 2 (2017) Pixel 3 (2018) Pixel 3a (2019) Pixel 4 (2019) Pixel 4a (2020) Pixel 5 (2020) Pixel 5a (2021) Pixel 6 (2021) Pixel 6a (2022) Pixel 7 (2022) Pixel 7a (2023) Pixel Fold (2023) Pixel 8 (2023) Pixel 8a (2024) Pixel 9 (2024) Pixel 9 Pro Fold (2024) Pixel 9a (2025) Pixel 10 (2025) Pixel 10 Pro Fold (2025) Smartwatches Pixel Watch (2022) Pixel Watch 2 (2023) Pixel Watch 3 (2024) Pixel Watch 4 (2025) Tablets Pixel C (2015) Pixel Slate (2018) Pixel Tablet (2023) Laptops Chromebook Pixel (2013–2015) Pixelbook (2017) Pixelbook Go (2019) Other Pixel Buds (2017–present) Nexus Smartphones Nexus One (2010) Nexus S (2010) Galaxy Nexus (2011) Nexus 4 (2012) Nexus 5 (2013) Nexus 6 (2014) Nexus 5X (2015) Nexus 6P (2015) Tablets Nexus 7 (2012) Nexus 10 (2012) Nexus 7 (2013) Nexus 9 (2014) Other Nexus Q (2012) Nexus Player (2014) Other Android Dev Phone Android One Cardboard Chromebit Chromebook Chromebox Chromecast Clips Daydream Fitbit Glass Liftware Liquid Galaxy Nest smart speakers Thermostat Wifi Play Edition Project Ara OnHub Pixel Visual Core Project Iris Search Appliance Sycamore processor Tensor Tensor Processing Unit Titan Security Key v t e Litigation Advertising Feldman v. Google, Inc. (2007) Rescuecom Corp. v. Google Inc. (2009) Goddard v. Google, Inc. (2009) Rosetta Stone Ltd. v. Google, Inc. (2012) Google, Inc. v. American Blind & Wallpaper Factory, Inc. (2017) Jedi Blue Antitrust European Union (2010–present) United States v. Adobe Systems, Inc., Apple Inc., Google Inc., Intel Corporation, Intuit, Inc., and Pixar (2011) Umar Javeed, Sukarma Thapar, Aaqib Javeed vs. Google LLC and Ors. (2019) United States v. Google LLC (2020) Epic Games v. Google (2021) United States v. Google LLC (2023) Intellectual property Perfect 10, Inc. v. Amazon.com, Inc. (2007) Viacom International, Inc. v. YouTube, Inc. (2010) Lenz v. Universal Music Corp.(2015) Authors Guild, Inc. v. Google, Inc. (2015) Field v. Google, Inc. (2016) Google LLC v. Oracle America, Inc. (2021) Smartphone patent wars Privacy Rocky Mountain Bank v. Google, Inc. (2009) Hibnick v. Google, Inc. (2010) United States v. Google Inc. (2012) Judgement of the German Federal Court of Justice on Google's autocomplete function (2013) Joffe v. Google, Inc. (2013) Mosley v SARL Google (2013) Google Spain v AEPD and Mario Costeja González (2014) Frank v. Gaos (2019) Other Garcia v. Google, Inc. (2015) Google LLC v Defteros (2020) Gonzalez v. Google LLC (2022) Related Concepts Beauty YouTuber BookTube BreadTube "Don't be evil" Gayglers Google as a verb Google bombing 2004 U.S. presidential election Google effect Googlefight Google hacking Googleshare Google tax Googlewhack Googlization Illegal flower tribute Objectives and key results Rooting Search engine manipulation effect Side project time Sitelink Site reliability engineering StudyTube VTuber YouTube Poop YouTuber list Products Android Booting process Custom distributions Features Recovery mode Software development Street View coverage Africa Antarctica Asia Israel Europe North America Canada United States Oceania South America Argentina Chile Colombia YouTube Copyright strike Education Features Moderation Most-disliked videos Most-liked videos Most-subscribed channels Most-viewed channels Most-viewed videos Official channel Social impact YouTube Premium original programming Other Gmail interface Maps pin Most downloaded Google Play applications Stadia games Documentaries AlphaGo Google: Behind the Screen Google Maps Road Trip Google and the World Brain The Creepy Line Books Google Hacks The Google Story Googled: The End of the World as We Know It How Google Works I'm Feeling Lucky In the Plex The MANIAC Popular culture Google Feud Google Me (film) "Google Me" (Kim Zolciak song) "Google Me" (Teyana Taylor song) Is Google Making Us Stupid? Proceratium google Matt Nathanson: Live at Google The Billion Dollar Code The Internship Where on Google Earth is Carmen Sandiego? Other "Attention Is All You Need" elgooG Generative pre-trained transformer "Me at the zoo" Predictions of the end Relationship with Wikipedia "Reunion" Robot Constitution Italics denote discontinued products. Category Outline

Authority control databases International VIAF National United States Israel

---
Adapted from the Wikipedia article [MapReduce](https://en.wikipedia.org/wiki/MapReduce) by Wikipedia contributors ([contributor history](https://en.wikipedia.org/wiki/MapReduce?action=history)). Available under [Creative Commons Attribution-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-sa/4.0/). Changes may have been made.