MapReduce
See http://en.wikipedia.org/wiki/Mapreduce
The MapReduce pattern aims to handle large-scale computations across a cluster
of servers, often involving massive amounts
of data.
"The computation takes a set
of input key/value pairs, and produces a set
of output key/value pairs. The developer expresses the computation as two Func delegates: Map and Reduce.
Map - takes a single input pair and produces a set
of intermediate key/value pairs. The MapReduce function groups results by key and passes them to the Reduce function.
Reduce - accepts an intermediate key I and a set
of values for that key. It merges together these values to form a possibly smaller set
of values. Typically just zero or one output value is produced per Reduce invocation. The intermediate values are supplied to the user's Reduce function via an iterator."
the canonical MapReduce example: counting word frequency in a text file.
MapReduce using DryadLINQ
see http://research.microsoft.com/en-us/projects/dryadlinq/ and http://connect.microsoft.com/Dryad
DryadLINQ provides a simple and straightforward way to implement MapReduce operations. This The implementation has two primary components: A Pair structure, which serves as a data container. A MapReduce method, which counts word frequency and returns the top five words.
The Pair Structure - Pair has two properties: Word is a string that holds a word or key. Count is an int that holds the word count. The structure also overrides ToString to simplify printing the results. The following example shows the Pair implementation.
public struct Pair
{
private string word;
private int count;
public Pair(string w, int c)
{
word = w;
count = c;
}
public int Count { get { return count; } }
public string Word { get { return word; } }
public override string ToString()
{
return word + ":" + count.ToString();
}
}
The MapReduce function that gets the results. the input data could be partitioned and distributed across the cluster.
1. Creates a DryadTable<LineRecord> object, inputTable, to represent the lines
of input text. For partitioned data, use GetPartitionedTable<T> instead
of GetTable<T> and pass the method a metadata file.
2. Applies the SelectMany operator to inputTable to transform the collection
of lines into collection
of words. The String.Split method converts the line into a collection
of words. SelectMany concatenates the collections created by Split into a single IQueryable<string> collection named words, which represents all the words in the file.
3. Performs the Map part
of the operation by applying GroupBy to the words object. The GroupBy operation groups elements with the same key, which is defined by the selector delegate. This creates a higher order collection, whose elements are groups. In this case, the delegate is an identity function, so the key is the word itself and the operation creates a groups collection that consists
of groups
of identical words.
4. Performs the Reduce part
of the operation by applying Select to groups. This operation reduces the groups
of words from Step 3 to an IQueryable<Pair> collection named counts that represents the unique words in the file and how many instances there are
of each word. Each key value in groups represents a unique word, so Select creates one Pair object for each unique word. IGrouping.Count returns the number
of items in the group, so each Pair object's Count member is set to the number
of instances
of the word.
5. Applies OrderByDescending to counts. This operation sorts the input collection in descending order
of frequency and creates an ordered collection named ordered.
6. Applies Take to ordered to create an IQueryable<Pair> collection named top, which contains the 100 most common words in the input file, and their frequency.
Test then uses the Pair object's ToString implementation to print the top one hundred words, and their frequency.
public static IQueryable<Pair> MapReduce(
string directory,
string fileName,
int k)
{
DryadDataContext ddc = new DryadDataContext("file://" + directory);
DryadTable<LineRecord> inputTable = ddc.GetTable<LineRecord>(fileName);
IQueryable<string> words = inputTable.SelectMany(x => x.line.Split(' '));
IQueryable<IGrouping<string, string>> groups = words.GroupBy(x => x);
IQueryable<Pair> counts = groups.Select(x => new Pair(x.Key, x.Count()));
IQueryable<Pair> ordered = counts.OrderByDescending(x => x.Count);
IQueryable<Pair> top = ordered.Take(k);
return top;
}
To Test:
IQueryable<Pair> results = MapReduce(@"c:\DryadData\input",
"TestFile.txt",
100);
foreach (Pair words in results)
Debug.Print(words.ToString());
Note: DryadLINQ applications can use a more compact way to represent the query:
return inputTable
.SelectMany(x => x.line.Split(' '))
.GroupBy(x => x)
.Select(x => new Pair(x.Key, x.Count()))
.OrderByDescending(x => x.Count)
.Take(k);
MapReduce using PLINQ
The pattern is relevant even for a single multi-core machine, however. We can write our own PLINQ MapReduce in a few lines.
the Map function takes a single input value and returns a set
of mapped values àLINQ's SelectMany operator.
These are then grouped according to an intermediate key à LINQ GroupBy operator.
The Reduce function takes each intermediate key and a set
of values for that key, and produces any number
of outputs per key à LINQ SelectMany again.
We can put all
of this together to implement MapReduce in PLINQ that returns a ParallelQuery<T>
public static ParallelQuery<TResult> MapReduce<TSource, TMapped, TKey, TResult>(
this ParallelQuery<TSource> source,
Func<TSource, IEnumerable<TMapped>> map,
Func<TMapped, TKey> keySelector,
Func<IGrouping<TKey, TMapped>, IEnumerable<TResult>> reduce)
{
return source
.SelectMany(map)
.GroupBy(keySelector)
.SelectMany(reduce);
}
the map function takes in an input document and outputs all
of the words in that document. The grouping phase groups all
of the identical words together, such that the reduce phase can then count the words in each group and output a word/count pair for each grouping:
var files = Directory.EnumerateFiles(dirPath, "*.txt").AsParallel();
var counts = files.MapReduce(
path => File.ReadLines(path).SelectMany(line => line.Split(delimiters)),
word => word,
group => new[] { new KeyValuePair<string, int>(group.Key, group.Count()) });
