{"id":1750,"date":"2012-09-28T16:00:00","date_gmt":"2012-09-28T16:00:00","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/2012\/10\/mapreduce-working-through-data-intensive-text-processing.html"},"modified":"2012-10-22T06:40:46","modified_gmt":"2012-10-22T06:40:46","slug":"mapreduce-working-through-data","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2012\/09\/mapreduce-working-through-data.html","title":{"rendered":"MapReduce: Working Through Data-Intensive Text Processing"},"content":{"rendered":"
It has been a while since I last posted, as I\u2019ve been busy with some of the classes offered by Coursera<\/a>. There are some very interesting offerings and is worth a look. Some time ago, I purchased Data-Intensive Processing with MapReduce<\/a> by Jimmy Lin and Chris Dyer. The book presents several key MapReduce algorithms, but in pseudo code format. My goal is to take the algorithms presented in chapters 3-6 and implement them in Hadoop, using Hadoop: The Definitive Guide<\/a> by Tom White as a reference. I\u2019m going to assume familiarity with Hadoop and MapReduce and not cover any introductory material. So let\u2019s jump into chapter 3 \u2013 MapReduce Algorithm Design, starting with local aggregation. <\/p>\n

Local Aggregation<\/strong><\/p>\n

At a very high level, when Mappers emit data, the intermediate results are written to disk then sent across the network to Reducers for final processing. The latency of writing to disk then transferring data across the network is an expensive operation in the processing of a MapReduce job. So it stands to reason that whenever possible, reducing the amount of data sent from mappers would increase the speed of the MapReduce job. Local aggregation is a technique used to reduce the amount of data and improve the efficiency of our MapReduce job. Local aggregation can not take the place of reducers, as we need a way to gather results with the same key from different mappers. We are going to consider 3 ways of achieving local aggregation: <\/p>\n

    \n
  1. Using Hadoop Combiner functions.<\/li>\n
  2. Two approaches of \u201cin-mapper\u201d combining presented in the Text Processing with MapReduce book.<\/li>\n<\/ol>\n

    Of course any optimization is going to have tradeoffs and we\u2019ll discuss those as well.
    \nTo demonstrate local aggregation, we will run the ubiquitous word count job on a plain text version of     A Christmas Carol<\/a> by Charles Dickens (downloaded from Project Gutenberg<\/a>) on a pseudo distributed cluster installed on my MacBookPro, using the hadoop-0.20.2-cdh3u3 distribution from Cloudera<\/a>. I plan in a future post to run the same experiment on an EC2 cluster with more realistic sized data.
    \n
    \n<\/strong>Combiners<\/strong> <\/p>\n

    A combiner function is an object that extends the Reducer class. In fact, for our examples here, we are going to re-use the same reducer used in the word count job. A combiner function is specified when setting up the MapReduce job like so: <\/p>\n

     job.setReducerClass(TokenCountReducer.class);<\/pre>\n
    Here is the reducer code:         <\/p>\n
    public class TokenCountReducer extends Reducer<Text,IntWritable,Text,IntWritable>{\r\n    @Override\r\n    protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {\r\n        int count = 0;\r\n        for (IntWritable value : values) {\r\n              count+= value.get();\r\n        }\r\n        context.write(key,new IntWritable(count));\r\n    }\r\n}<\/pre>\n
    The job of a combiner is to do just what the name implies, aggregate data with the net result of less data begin shuffled across the network, which gives us gains in efficiency. As stated before, keep in mind that reducers are still required to put together results with the same keys coming from different mappers. Since combiner functions are an optimization, the Hadoop framework offers no guarantees on how many times a combiner will be called, if at all.
    \n
    \n<\/strong>In Mapper Combining Option 1<\/strong>        
     
    <\/div> <\/div><\/p>\n
    The first alternative to using Combiners (figure 3.2 page 41) is very straight forward and makes a slight modification to our original word count mapper:         <\/p>\n
    public class PerDocumentMapper extends Mapper<LongWritable, Text, Text, IntWritable> {\r\n    @Override\r\n    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {\r\n        IntWritable writableCount = new IntWritable();\r\n        Text text = new Text();\r\n        Map<String,Integer> tokenMap = new HashMap<String, Integer>();\r\n        StringTokenizer tokenizer = new StringTokenizer(value.toString());\r\n\r\n        while(tokenizer.hasMoreElements()){\r\n            String token = tokenizer.nextToken();\r\n            Integer count = tokenMap.get(token);\r\n            if(count == null) count = new Integer(0);\r\n            count+=1;\r\n            tokenMap.put(token,count);\r\n        }\r\n\r\n        Set<String> keys = tokenMap.keySet();\r\n        for (String s : keys) {\r\n             text.set(s);\r\n             writableCount.set(tokenMap.get(s));\r\n             context.write(text,writableCount);\r\n        }\r\n    }\r\n}<\/pre>\n
    As we can see here, instead of emitting a word with the count of 1, for each word encountered, we use a map to keep track of each word already processed. Then when all of the tokens are processed we loop through the map and emit the total count for each word encountered in that line.
    \n
    \n<\/strong>In Mapper Combining Option 2<\/strong>        <\/p>\n
    The second option of in mapper combining (figure 3.3 page 41) is very similar to the above example with two distinctions \u2013 when the hash map is created and when we emit the results contained in the map. In the above example, a map is created and has its contents dumped over the wire for each<\/i> invocation of the map method. In this example we are going make the map an instance variable and shift the instantiation of the map to the setUp method in our mapper. Likewise the contents of the map will not be sent out to the reducers until all of the calls to mapper have completed and the cleanUp method is called.         <\/p>\n
    public class AllDocumentMapper extends Mapper<LongWritable,Text,Text,IntWritable> {\r\n\r\n    private  Map<String,Integer> tokenMap;\r\n\r\n    @Override\r\n    protected void setup(Context context) throws IOException, InterruptedException {\r\n           tokenMap = new HashMap<String, Integer>();\r\n    }\r\n\r\n    @Override\r\n    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {\r\n        StringTokenizer tokenizer = new StringTokenizer(value.toString());\r\n        while(tokenizer.hasMoreElements()){\r\n            String token = tokenizer.nextToken();\r\n            Integer count = tokenMap.get(token);\r\n            if(count == null) count = new Integer(0);\r\n            count+=1;\r\n            tokenMap.put(token,count);\r\n        }\r\n    }\r\n\r\n\r\n    @Override\r\n    protected void cleanup(Context context) throws IOException, InterruptedException {\r\n        IntWritable writableCount = new IntWritable();\r\n        Text text = new Text();\r\n        Set<String> keys = tokenMap.keySet();\r\n        for (String s : keys) {\r\n            text.set(s);\r\n            writableCount.set(tokenMap.get(s));\r\n            context.write(text,writableCount);\r\n        }\r\n    }\r\n}<\/pre>\n
    As we can see from the above code example, the mapper is keeping track of unique word counts, across all calls to the map method. By keeping track of unique tokens and their counts, there should be a substantial reduction in the number of records sent to the reducers, which in turn should improve the running time of the MapReduce job. This accomplishes the same effect as using the combiner function option provided by the MapReduce framework, but in this case you are guaranteed that the combining code will be called. But there are some caveats with this approach also. Keeping state across map calls could prove problematic and definitely is a violation of the functional spirit of a \u201cmap\u201d function. Also, by keeping state across all mappers, depending on the data used in the job, memory could be another issue to contend with. Ultimately, one would have to weigh all of the trade offs to determine the best approach.
    \n
    \n<\/strong>Results<\/strong>        <\/p>\n
    Now lets take a look at the some results of the different mappers. Since the job was run in pseudo-distributed mode, actual running times are irrelevant, but we can still infer how using local aggregation could impact the efficiency of MapReduce job running on a real cluster.          <\/p>\n
    Per Token Mapper:         <\/p>\n
    12\/09\/13 21:25:32 INFO mapred.JobClient:     Reduce shuffle bytes=366010\r\n12\/09\/13 21:25:32 INFO mapred.JobClient:     Reduce output records=7657\r\n12\/09\/13 21:25:32 INFO mapred.JobClient:     Spilled Records=63118\r\n12\/09\/13 21:25:32 INFO mapred.JobClient:     Map output bytes=302886<\/pre>\n
    In Mapper Reducing Option 1:         <\/p>\n
    12\/09\/13 21:28:15 INFO mapred.JobClient:     Reduce shuffle bytes=354112\r\n12\/09\/13 21:28:15 INFO mapred.JobClient:     Reduce output records=7657\r\n12\/09\/13 21:28:15 INFO mapred.JobClient:     Spilled Records=60704\r\n12\/09\/13 21:28:15 INFO mapred.JobClient:     Map output bytes=293402<\/pre>\n
    In Mapper Reducing Option 2:         <\/p>\n
    12\/09\/13 21:30:49 INFO mapred.JobClient:     Reduce shuffle bytes=105885\r\n12\/09\/13 21:30:49 INFO mapred.JobClient:     Reduce output records=7657\r\n12\/09\/13 21:30:49 INFO mapred.JobClient:     Spilled Records=15314\r\n12\/09\/13 21:30:49 INFO mapred.JobClient:     Map output bytes=90565<\/pre>\n
    Combiner Option:         <\/p>\n
    12\/09\/13 21:22:18 INFO mapred.JobClient:     Reduce shuffle bytes=105885\r\n12\/09\/13 21:22:18 INFO mapred.JobClient:     Reduce output records=7657\r\n12\/09\/13 21:22:18 INFO mapred.JobClient:     Spilled Records=15314\r\n12\/09\/13 21:22:18 INFO mapred.JobClient:     Map output bytes=302886\r\n12\/09\/13 21:22:18 INFO mapred.JobClient:     Combine input records=31559\r\n12\/09\/13 21:22:18 INFO mapred.JobClient:     Combine output records=7657<\/pre>\n
    As expected the Mapper that did no combining had the worst results, followed closely by the first in-mapper combining option (although these results could have been made better had the data been cleaned up before running the word count). The second in-mapper combining option and the combiner function had virtually identical results. The significant fact is that both produced 2\/3 less<\/i><\/strong> reduce shuffle bytes as the first two options. Reducing the amount of bytes sent over the network to the reducers by that amount would surely would have a positive impact on the efficiency of a MapReduce job. There is one point to keep in mind here and that is Combiners\/In-Mapper combining can not just be used in all MapReduce jobs, in this case the word count lends itself very nicely to such an enhancement, but that might not always be true.
    \n
    \n<\/strong>Conclusion<\/strong>        <\/p>\n
    As you can see the benefits of using either in-mapper combining or the Hadoop combiner function require serious consideration when looking to improve the performance of your MapReduce jobs. As for which approach, it is up to you the weigh the trade offs for each approach.
    \n
    \n<\/strong>Related links<\/strong>
    \n
    \n<\/strong><\/p>\n