hadoop之CombineFileInputFormat篇

 简介

本文主要介绍下面4个方面

1．为什么要使用CombineFileInputFormat

2．CombineFileInputFormat实现原理

3．怎样使用CombineFileInputFormat

4．现存的问题

 

使用CombineFileInputFormat的目的

在开发MR的程序时，mapper的主要作用是对数据的收集。一般情况下，为了能让mapper更快的运行，我们会对文件进行split，以便多个mapper同时运行。在这种情况下，为了让程序更好更快的运行，我们需要控制mapper的个数。Mapper的个数主要由文件的大小及我们所设置的mapred.min.split.size以及blockSize所决定（详细参考：http://ai-longyu.iteye.com/blog/1566633）

上面所说的在我们使用TextInputFormat和分析单个文件时是没有问题的，基本上mapper的个数能够控制在我们所预期的范围内。但是当我们使用多个文件作为input的时候，mapper的个数就不再是我们所期望的那样了，因为TextInputFormat继承的是FileInputFormat，而FileInputFormat的split操作是只针对单个文件，对于多个文件，是将每个文件进行split，而不能做一些合并的操作（尤其是大量的小文件）。

 

你会想为什么不能进行合并呢，有没有实现合并的split呢？在这个时候，CombineFileInputFormat就闪亮登场了。这里所说的CombineFileInputFormat是由官方提供的，只要我们搞清楚了官方是怎么实现的，就能够自己也实现一个了。接下来将逐步分析CombineFileInputFormat的实现了。

 

 

CombineFileInputFormat实现步骤

这里插一句，官方的CombineFileInputFormat并不是线程安全的。

先申明一下，这里分析所采用的源码是apache的1.0.3，分析的在org.apache.hadoop.mapred.lib.CombineFileInputFormat而不是org.apache.hadoop.mapreduce.lib.input.CombineFileInputFormat,这里分析的旧API，而没有分析新的API

 

生成split的信息是由

1. public InputSplit[] getSplits(JobConf job, int numSplits)  

 

Job参数：job的配置信息

numSplits参数：期望的mapper数目，在这里根本就没有使用

1. //每个DN的最小split大小 
2. long minSizeNode = 0; 
3. //同机架的最小split大小 
4. long minSizeRack = 0; 
5. //最大的split大小 
6. long maxSize = 0; 

 

 

这几个变量都可以从job的配置信息中获取

接下来就是获取input的路径列表，判断每个路径时候被Filter所允许，然后对允许的路径列表生成split信息列表，进入该类的核心方法

1. /** 
2.   * Return all the splits in the specified set of paths 
3.   *  
4. * @param job Job的配置信息 
5. * @param paths 输入源的路径列表 
6. * @param maxSize 最大的split大小 
7. * @param minSizeNode 每个DN最小的split大小 
8. * @param minSizeRack 每个rack最小的split大小 
9. * @param splits split信息列表 
10. * @throws IOException 
11. */ 
12. private void getMoreSplits(JobConf job, Path[] paths,  
13.                             long maxSize, long minSizeNode, long minSizeRack, 
14.                             List<CombineFileSplit> splits) 

 

生成每个文件的OneFileInfo对象

1. // populate all the blocks for all files 
2.     long totLength = 0; 
3.     for (int i = 0; i < paths.length; i++) { 
4.         //构建每个input文件的信息，并将文件中的每个 
5.         //block信息收集到rackToBlocks、blockToNodes、nodeToBlocks中 
6.       files[i] = new OneFileInfo(paths[i], job,  
7.                                  rackToBlocks, blockToNodes, nodeToBlocks); 
8.       //增加所有文件的大小 
9.       totLength += files[i].getLength(); 
10.     } 

 

 

在下面就开始真正的生成Split信息了

 

 

第一次：将同DN上的所有block生成Split，生成方式：

 

 

1．循环nodeToBlocks，获得每个DN上有哪些block

2．循环这些block列表

3．将block从blockToNodes中移除，避免同一个block被包含在多个split中

4．将该block添加到一个有效block的列表中，这个列表主要是保留哪些block已经从blockToNodes中被移除了，方便后面恢复到blockToNodes中

5．向临时变量curSplitSize增加block的大小

6．判断curSplitSize是否已经超过了设置的maxSize

a) 如果超过，执行并添加split信息，并重置curSplitSize和validBlocks

b) 没有超过，继续循环block列表，跳到第2步

7．当前DN上的block列表循环完成，判断剩余的block是否允许被split（剩下的block大小之和是否大于每个DN的最小split大小）

a) 如果允许，执行并添加split信息

b) 如果不被允许，将这些剩余的block归还blockToNodes

8．重置

9．跳到步骤1

 

 

1. // process all nodes and create splits that are local 
2.     // to a node.  
3.     //创建同一个DN上的split 
4.     for (Iterator<Map.Entry<String,  
5.          List<OneBlockInfo>>> iter = nodeToBlocks.entrySet().iterator();  
6.          iter.hasNext();) { 
7.  
8.       Map.Entry<String, List<OneBlockInfo>> one = iter.next(); 
9.       nodes.add(one.getKey()); 
10.       List<OneBlockInfo> blocksInNode = one.getValue(); 
11.  
12.       // for each block, copy it into validBlocks. Delete it from  
13.       // blockToNodes so that the same block does not appear in  
14.       // two different splits. 
15.       for (OneBlockInfo oneblock : blocksInNode) { 
16.         if (blockToNodes.containsKey(oneblock)) { 
17.           validBlocks.add(oneblock); 
18.           blockToNodes.remove(oneblock); 
19.           curSplitSize += oneblock.length; 
20.  
21.           // if the accumulated split size exceeds the maximum, then  
22.           // create this split. 
23.           if (maxSize != 0 && curSplitSize >= maxSize) { 
24.             // create an input split and add it to the splits array 
25.             //创建这些block合并后的split，并将其split添加到split列表中 
26.             addCreatedSplit(job, splits, nodes, validBlocks); 
27.             //重置 
28.             curSplitSize = 0; 
29.             validBlocks.clear(); 
30.           } 
31.         } 
32.       } 
33.       // if there were any blocks left over and their combined size is 
34.       // larger than minSplitNode, then combine them into one split. 
35.       // Otherwise add them back to the unprocessed pool. It is likely  
36.       // that they will be combined with other blocks from the same rack later on. 
37.       //其实这里的注释已经说的很清楚，我再按照我的理解说一下 
38.       /** 
39.        * 这里有几种情况： 
40.        * 1、在这个DN上还有没有被split的block， 
41.        * 而且这些block的大小大于了在一个DN上的split最小值（没有达到最大值）， 
42.        * 将把这些block合并成一个split 
43.        * 2、剩余的block的大小还是没有达到，将剩余的这些block 
44.        * 归还给blockToNodes，等以后统一处理 
45.        */ 
46.       if (minSizeNode != 0 && curSplitSize >= minSizeNode) { 
47.         // create an input split and add it to the splits array 
48.         addCreatedSplit(job, splits, nodes, validBlocks); 
49.       } else { 
50.         for (OneBlockInfo oneblock : validBlocks) { 
51.           blockToNodes.put(oneblock, oneblock.hosts); 
52.         } 
53.       } 
54.       validBlocks.clear(); 
55.       nodes.clear(); 
56.       curSplitSize = 0; 
57.     } 

 

第二次：对不再同一个DN上但是在同一个Rack上的block进行合并（只是之前还剩下的block）

 

 

1. // if blocks in a rack are below the specified minimum size, then keep them 
2.     // in 'overflow'. After the processing of all racks is complete, these overflow 
3.     // blocks will be combined into splits. 
4.     ArrayList<OneBlockInfo> overflowBlocks = new ArrayList<OneBlockInfo>(); 
5.     ArrayList<String> racks = new ArrayList<String>(); 
6.  
7.     // Process all racks over and over again until there is no more work to do. 
8.     //这里处理的就不再是同一个DN上的block 
9.     //同一个DN上的已经被处理过了（上面的代码），这里是一些 
10.     //还没有被处理的block 
11.     while (blockToNodes.size() > 0) { 
12.  
13.       // Create one split for this rack before moving over to the next rack.  
14.       // Come back to this rack after creating a single split for each of the  
15.       // remaining racks. 
16.       // Process one rack location at a time, Combine all possible blocks that 
17.       // reside on this rack as one split. (constrained by minimum and maximum 
18.       // split size). 
19.  
20.       // iterate over all racks  
21.     //创建同机架的split 
22.       for (Iterator<Map.Entry<String, List<OneBlockInfo>>> iter =  
23.            rackToBlocks.entrySet().iterator(); iter.hasNext();) { 
24.  
25.         Map.Entry<String, List<OneBlockInfo>> one = iter.next(); 
26.         racks.add(one.getKey()); 
27.         List<OneBlockInfo> blocks = one.getValue(); 
28.  
29.         // for each block, copy it into validBlocks. Delete it from  
30.         // blockToNodes so that the same block does not appear in  
31.         // two different splits. 
32.         boolean createdSplit = false; 
33.         for (OneBlockInfo oneblock : blocks) { 
34.             //这里很重要，现在的blockToNodes说明的是还有哪些block没有被split 
35.           if (blockToNodes.containsKey(oneblock)) { 
36.             validBlocks.add(oneblock); 
37.             blockToNodes.remove(oneblock); 
38.             curSplitSize += oneblock.length; 
39.        
40.             // if the accumulated split size exceeds the maximum, then  
41.             // create this split. 
42.             if (maxSize != 0 && curSplitSize >= maxSize) { 
43.               // create an input split and add it to the splits array 
44.               addCreatedSplit(job, splits, getHosts(racks), validBlocks); 
45.               createdSplit = true; 
46.               break; 
47.             } 
48.           } 
49.         } 
50.  
51.         // if we created a split, then just go to the next rack 
52.         if (createdSplit) { 
53.           curSplitSize = 0; 
54.           validBlocks.clear(); 
55.           racks.clear(); 
56.           continue; 
57.         } 
58.  
59.         //还有没有被split的block 
60.         //如果这些block的大小大于了同机架的最小split， 
61.         //则创建split 
62.         //否则，将这些block留到后面处理 
63.         if (!validBlocks.isEmpty()) { 
64.           if (minSizeRack != 0 && curSplitSize >= minSizeRack) { 
65.             // if there is a mimimum size specified, then create a single split 
66.             // otherwise, store these blocks into overflow data structure 
67.             addCreatedSplit(job, splits, getHosts(racks), validBlocks); 
68.           } else { 
69.             // There were a few blocks in this rack that remained to be processed. 
70.             // Keep them in 'overflow' block list. These will be combined later. 
71.             overflowBlocks.addAll(validBlocks); 
72.           } 
73.         } 
74.         curSplitSize = 0; 
75.         validBlocks.clear(); 
76.         racks.clear(); 
77.       } 
78.     } 

 

最后，对于既不在同DN也不在同rack的block进行合并（经过前两步还剩下的block），这里源码就没有什么了，就不再贴了

 

源码总结：

合并，经过了3个步骤。同DN----》同rack不同DN-----》不同rack

将可以合并的block写到同一个split中

 

 

使用自定义的CombineFileInputFormat

MultiFileCombineInputFormat

 

1. package org.rollinkin.hadoop; 
2.  
3. import java.io.IOException; 
4.  
5. import org.apache.hadoop.io.LongWritable; 
6. import org.apache.hadoop.io.Text; 
7. import org.apache.hadoop.mapred.InputSplit; 
8. import org.apache.hadoop.mapred.JobConf; 
9. import org.apache.hadoop.mapred.RecordReader; 
10. import org.apache.hadoop.mapred.Reporter; 
11. import org.apache.hadoop.mapred.lib.CombineFileInputFormat; 
12. import org.apache.hadoop.mapred.lib.CombineFileRecordReader; 
13. import org.apache.hadoop.mapred.lib.CombineFileSplit; 
14.  
15. /** 
16.  * 多文件合并split的输入format 
17.  *  
18.  * @author rollinkin 
19.  * @date 2012-10-29 
20.  * @version 1.0 
21.  * @since 1.0 
22.  */ 
23. public class MultiFileCombineInputFormat extends 
24.         CombineFileInputFormat<LongWritable, Text> { 
25.     @Override   
26.     public RecordReader<LongWritable, Text> getRecordReader(   
27.             InputSplit split, JobConf job, Reporter reporter)   
28.             throws IOException {   
29.          @SuppressWarnings({ "rawtypes", "unchecked" }) 
30.         Class<RecordReader<LongWritable, Text>> rrClass = (Class)CombineLineRecordReader.class; 
31.         return new CombineFileRecordReader<LongWritable, Text>(job,(CombineFileSplit) split, reporter,rrClass);   
32.            
33.     }  
34.  
35. } 

CombineLineRecordReader，这个其实没有什么内容，就是包装了一个Reader

 

1. package org.rollinkin.hadoop; 
2.  
3. import java.io.IOException; 
4.  
5. import org.apache.hadoop.conf.Configuration; 
6. import org.apache.hadoop.io.LongWritable; 
7. import org.apache.hadoop.io.Text; 
8. import org.apache.hadoop.mapred.FileSplit; 
9. import org.apache.hadoop.mapred.LineRecordReader; 
10. import org.apache.hadoop.mapred.RecordReader; 
11. import org.apache.hadoop.mapred.Reporter; 
12. import org.apache.hadoop.mapred.lib.CombineFileSplit; 
13.  
14. public class CombineLineRecordReader implements 
15.         RecordReader<LongWritable, Text> { 
16.  
17.     private LineRecordReader delegate; 
18.  
19.     public CombineLineRecordReader(CombineFileSplit split, Configuration conf, 
20.             Reporter reporter, Integer idx) throws IOException { 
21.         FileSplit fileSplit = new FileSplit(split.getPath(idx), 
22.                 split.getOffset(idx), split.getLength(idx), 
23.                 split.getLocations()); 
24.         delegate = new LineRecordReader(conf, fileSplit); 
25.     } 
26.  
27.     @Override 
28.     public boolean next(LongWritable key, Text value) throws IOException { 
29.         return delegate.next(key, value); 
30.     } 
31.  
32.     @Override 
33.     public LongWritable createKey() { 
34.         return delegate.createKey(); 
35.     } 
36.  
37.     @Override 
38.     public Text createValue() { 
39.         return delegate.createValue(); 
40.     } 
41.  
42.     @Override 
43.     public long getPos() throws IOException { 
44.         return delegate.getPos(); 
45.     } 
46.  
47.     @Override 
48.     public void close() throws IOException { 
49.         delegate.close(); 
50.     } 
51.  
52.     @Override 
53.     public float getProgress() throws IOException { 
54.         return delegate.getProgress(); 
55.     } 
56.  
57. } 

 

具体的使用我就不再留了，其实很简单，就是把你的InputFormat设置成MultiFileCombineInputFormat 就可以了（在2012-11-09之前提供了一个reader实际上是不可用，他存在跨块读取的问题，

这里就不在提供了。如果使用了，请更新一下。哎，又传播错误的消息了）

 

 

现存问题

1. 合并后会造成mapper不能本地化，带来mapper的额外开销，需要权衡
2. 这里只实现了简单的Text的方式的合并，对于可压缩的、二进制等文件没有提供
3. 这里提供的自定义的实现，只是简单的按行读取
   
   
   ps。这是我第一次些blog，写的不好的地方，欢迎大家指正，我其实也借用了很多他人的成果，但是好多我都已经搞忘了，实在不好意思。好了，先写这些了，欢迎大家多多交流关于hadoop方面的经验
    

 

 

 

转载于:https://blog.51cto.com/rollinkin/1041071