热门搜索:
您现在的位置是：首页 > 文章详情

Hadoop2.6.0的FileInputFormat的任务切分原理分析（即如何控制FileInputFormat的map任务数量）

日期：2016-04-11点击：577
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/beliefer/article/details/51122009

前言

首先确保已经搭建好Hadoop集群环境，可以参考《Linux下Hadoop集群环境的搭建》一文的内容。我在测试mapreduce任务时，发现相比于使用Job.setNumReduceTasks(int)控制reduce任务数量而言，控制map任务数量一直是一个困扰我的问题。好在经过很多摸索与实验，终于梳理出来，希望对在工作中进行Hadoop进行性能调优的新人们有个借鉴。本文只针对FileInputFormat的任务划分进行分析，其它类型的InputFormat的划分方式又各有不同。虽然如此，都可以按照本文类似的方法进行分析和总结。

为了简便起见，本文以Hadoop2.6.0自带的word count例子为例，进行展开。

wordcount

我们首先准备好wordcount所需的数据，一共有两份文件，都位于hdfs的/wordcount/input目录下：


这两个文件的内容分别为：

On the top of the Crumpretty Tree
The Quangle Wangle sat,
But his face you could not see,
On account of his Beaver Hat.
和 
But his face you could not see,
On account of his Beaver Hat.
有关如何操作hdfs并准备好数据的细节，本文不作赘述。

现在我们不作任何性能优化（不增加任何配置参数），然后执行hadoop-mapreduce-examples子项目（有关此项目介绍，可以阅读《Hadoop2.6.0子项目hadoop-mapreduce-examples的简单介绍》一文）中自带的wordcount例子：

hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-2.6.0.jar wordcount /wordcount/input /wordcount/output/result1

当然也可以使用朴素的方式运行wordcount例子：

hadoop org.apache.hadoop.examples.WordCount -D mapreduce.input.fileinputformat.split.maxsize=1 /wordcount/input /wordcount/output/result1

最后执行的结果在hdfs的/wordcount/output/result1目录下：


执行结果可以查看/wordcount/output/result1/part-r-00000的内容：


第一次优化

wordcount例子，查看运行结果不是本文的目的。在执行wordcount例子时，在任务运行信息中可以看到创建的map及reduce任务的数量：


可以看到FileInputFormat的输入文件有2个，JobSubmitter任务划分的数量是2，最后产生的map任务数量也是2，看到这我们可以猜想由于我们提供了两个输入文件，所以会有2个map任务。我们此处姑且不论这种猜测正确与否，现在我们打算改变map任务的数量。通过查看文档，很多人知道使用mapreduce.job.maps参数可以快速修改map任务的数量，事实果真如此？让我们先来实验一番，输入以下命令：

hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-2.6.0.jar wordcount -D mapreduce.job.maps=1 /wordcount/input /wordcount/output/result2
执行以上命令后，观察输出的信息，与之前未添加mapreduce.job.maps参数的输出信息几乎没有变化。难道Hadoop的实现人员开了一个玩笑，亦或者这是一个bug？我们先给这个问题在我们的大脑中设置一个检查点，最后再来看看究竟是怎么回事。

第二次优化

用mapreduce.job.maps调整map任务数量没有见效，我们翻翻文档，发现还有mapreduce.input.fileinputformat.split.minsize参数，它可以控制map任务输入划分的最小字节数。这个参数和mapreduce.input.fileinputformat.split.maxsize通常配合使用，后者控制map任务输入划分的最大字节数。我们目前只调整mapreduce.input.fileinputformat.split.minsize的大小，划分最小的尺寸变小是否预示着任务划分数量变多？来看看会发生什么？输入以下命令： 

hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-2.6.0.jar wordcount -D mapreduce.input.fileinputformat.split.minsize=1 /wordcount/input /wordcount/output/result3
执行以上命令后，观察输出信息，依然未发生改变。好吧，弟弟不给力，我们用它的兄弟参数mapreduce.input.fileinputformat.split.maxsize来控制。如果我们将mapreduce.input.fileinputformat.split.maxsize改得很小，会怎么样？输入以下命令： 

hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-2.6.0.jar wordcount -D mapreduce.input.fileinputformat.split.maxsize=1 /wordcount/input /wordcount/output/result4
这是的信息有了改变，我们似乎取得了想要的结果：



呵呵，任务划分成了177个，想想也是，我们把最大的划分字节数仅仅设置为1字节。接着往下看确实执行了177个map任务：

我们还可以通过Web UI观察map任务所分配的Container。首先查看Slave1节点上分配的Container情况：

再来看看Slave2节点上分配的Container情况：

确实说明最多有15个Container分配给当前作业执行map任务。由于在YARN中yarn.nodemanager.resource.cpu-vcores参数的默认值是8，所以Slave1和Slave2两台机器上的虚拟cpu总数是16，由于ResourceManager会为mapreduce任务分配一个Container给ApplicationMaster（即MrAppMaster），所以整个集群只剩余了15个Container用于ApplicationMaster向NodeManager申请和运行map任务。

第三次优化

阅读文档我们知道dfs.blocksize可以控制块的大小，看看这个参数能否发挥作用。为便于测试，我们首先需要修改hdfs-site.xml中dfs.blocksize的大小为10m（最小就只能这么小，Hadoop限制了参数单位至少是10m）。

<property>
  <name>dfs.blocksize</name>
  <value>10m</value>
</property>
然后，将此配置复制到集群的所有NameNode和DataNode上。为了使此配置在不重启的情况下生效，在NameNode节点上执行以下命令： 

hadoop dfsadmin -refreshNodes
yarn rmadmin -refreshNodes

我们使用以下命令查看下系统内的文件所占用的blocksize大小：

hadoop dfs -stat "%b %n %o %r %y" /wordcount/input/quangle*
输出结果如下：


可以看到虽然quangle.txt和quangle2.txt的字节数分别是121字节和56字节，但是在hdfs中这两个文件的blockSize已经是10m了。现在我们试试以下命令：

hadoop jar share/hadoop/mapreduce/hadoop-mapreduce-examples-2.6.0.jar wordcount /wordcount/input /wordcount/output/result5
观察输出信息，发现没有任何效果。

源码分析

经过以上3次不同实验，发现只有mapreduce.input.fileinputformat.split.maxsize参数确实影响了map任务的数量。现在我们通过源码分析，来一探究竟吧。

首先我们看看WordCount例子的源码，其中和任务划分有关的代码如下：

    for (int i = 0; i < otherArgs.length - 1; ++i) {
      FileInputFormat.addInputPath(job, new Path(otherArgs[i]));
    }
    FileOutputFormat.setOutputPath(job,
      new Path(otherArgs[otherArgs.length - 1]));
    System.exit(job.waitForCompletion(true) ? 0 : 1);

我们看到使用的InputFormat是FileOutputFormat，任务执行调用了Job的waitForCompletion方法。waitForCompletion方法中真正提交job的代码如下： 

  public boolean waitForCompletion(boolean verbose
                                   ) throws IOException, InterruptedException,
                                            ClassNotFoundException {
    if (state == JobState.DEFINE) {
      submit();
    }
    // 省略本文不关心的代码
    return isSuccessful();
  }

这里的submit方法的实现如下： 

  public void submit() 
         throws IOException, InterruptedException, ClassNotFoundException {
    // 省略本文不关心的代码</span>
    final JobSubmitter submitter = 
        getJobSubmitter(cluster.getFileSystem(), cluster.getClient());
    status = ugi.doAs(new PrivilegedExceptionAction<JobStatus>() {
      public JobStatus run() throws IOException, InterruptedException, 
      ClassNotFoundException {
        return submitter.submitJobInternal(Job.this, cluster);
      }
    });
    state = JobState.RUNNING;
    LOG.info("The url to track the job: " + getTrackingURL());
   }

submit方法首先创建了JobSubmitter实例，然后异步调用了JobSubmitter的submitJobInternal方法。JobSubmitter的submitJobInternal方法有关划分任务的代码如下：

      // Create the splits for the job
      LOG.debug("Creating splits at " + jtFs.makeQualified(submitJobDir));
      int maps = writeSplits(job, submitJobDir);
      conf.setInt(MRJobConfig.NUM_MAPS, maps);
      LOG.info("number of splits:" + maps);

writeSplits方法的实现如下： 

  private int writeSplits(org.apache.hadoop.mapreduce.JobContext job,
      Path jobSubmitDir) throws IOException,
      InterruptedException, ClassNotFoundException {
    JobConf jConf = (JobConf)job.getConfiguration();
    int maps;
    if (jConf.getUseNewMapper()) {
      maps = writeNewSplits(job, jobSubmitDir);
    } else {
      maps = writeOldSplits(jConf, jobSubmitDir);
    }
    return maps;
  }

由于WordCount使用的是新的mapreduce API，所以最终会调用writeNewSplits方法。writeNewSplits的实现如下：

  private <T extends InputSplit>
  int writeNewSplits(JobContext job, Path jobSubmitDir) throws IOException,
      InterruptedException, ClassNotFoundException {
    Configuration conf = job.getConfiguration();
    InputFormat<?, ?> input =
      ReflectionUtils.newInstance(job.getInputFormatClass(), conf);

    List<InputSplit> splits = input.getSplits(job);
    T[] array = (T[]) splits.toArray(new InputSplit[splits.size()]);

    // sort the splits into order based on size, so that the biggest
    // go first
    Arrays.sort(array, new SplitComparator());
    JobSplitWriter.createSplitFiles(jobSubmitDir, conf, 
        jobSubmitDir.getFileSystem(conf), array);
    return array.length;
  }

writeNewSplits方法中，划分任务数量最关键的代码即为InputFormat的getSplits方法（提示：大家可以直接通过此处的调用，查看不同InputFormat的划分任务实现）。根据前面的分析我们知道此时的InputFormat即为FileOutputFormat，其getSplits方法的实现如下：

  public List<InputSplit> getSplits(JobContext job) throws IOException {
    Stopwatch sw = new Stopwatch().start();
    long minSize = Math.max(getFormatMinSplitSize(), getMinSplitSize(job));
    long maxSize = getMaxSplitSize(job);

    // generate splits
    List<InputSplit> splits = new ArrayList<InputSplit>();
    List<FileStatus> files = listStatus(job);
    for (FileStatus file: files) {
      Path path = file.getPath();
      long length = file.getLen();
      if (length != 0) {
        BlockLocation[] blkLocations;
        if (file instanceof LocatedFileStatus) {
          blkLocations = ((LocatedFileStatus) file).getBlockLocations();
        } else {
          FileSystem fs = path.getFileSystem(job.getConfiguration());
          blkLocations = fs.getFileBlockLocations(file, 0, length);
        }
        if (isSplitable(job, path)) {
          long blockSize = file.getBlockSize();
          long splitSize = computeSplitSize(blockSize, minSize, maxSize);

          long bytesRemaining = length;
          while (((double) bytesRemaining)/splitSize > SPLIT_SLOP) {
            int blkIndex = getBlockIndex(blkLocations, length-bytesRemaining);
            splits.add(makeSplit(path, length-bytesRemaining, splitSize,
                        blkLocations[blkIndex].getHosts(),
                        blkLocations[blkIndex].getCachedHosts()));
            bytesRemaining -= splitSize;
          }

          if (bytesRemaining != 0) {
            int blkIndex = getBlockIndex(blkLocations, length-bytesRemaining);
            splits.add(makeSplit(path, length-bytesRemaining, bytesRemaining,
                       blkLocations[blkIndex].getHosts(),
                       blkLocations[blkIndex].getCachedHosts()));
          }
        } else { // not splitable
          splits.add(makeSplit(path, 0, length, blkLocations[0].getHosts(),
                      blkLocations[0].getCachedHosts()));
        }
      } else { 
        //Create empty hosts array for zero length files
        splits.add(makeSplit(path, 0, length, new String[0]));
      }
    }
    // Save the number of input files for metrics/loadgen
    job.getConfiguration().setLong(NUM_INPUT_FILES, files.size());
    sw.stop();
    if (LOG.isDebugEnabled()) {
      LOG.debug("Total # of splits generated by getSplits: " + splits.size()
          + ", TimeTaken: " + sw.elapsedMillis());
    }
    return splits;
  }

getFormatMinSplitSize方法固定返回1，getMinSplitSize方法实际就是mapreduce.input.fileinputformat.split.minsize参数的值（默认为1），那么变量minSize的大小为mapreduce.input.fileinputformat.split.minsize与1之间的最大值。

getMaxSplitSize方法实际是mapreduce.input.fileinputformat.split.maxsize参数的值，那么maxSize即为mapreduce.input.fileinputformat.split.maxsize参数的值。

由于我的试验中有两个输入源文件，所以List<FileStatus> files = listStatus(job);方法返回的files列表的大小为2。

在遍历files列表的过程中，会获取每个文件的blockSize，最终调用computeSplitSize方法计算每个输入文件应当划分的任务数。computeSplitSize方法的实现如下：

  protected long computeSplitSize(long blockSize, long minSize,
                                  long maxSize) {
    return Math.max(minSize, Math.min(maxSize, blockSize));
  }

因此我们知道每个输入文件被划分的公式如下：

map任务要划分的大小（splitSize ）=（maxSize与blockSize之间的最小值）与minSize之间的最大值

bytesRemaining 是单个输入源文件未划分的字节数

根据getSplits方法，我们知道map任务划分的数量=输入源文件数目 * (bytesRemaining / splitSize个划分任务+bytesRemaining不能被splitSize 整除的剩余大小单独划分一个任务 )

总结

根据源码分析得到的计算方法和之前的优化结果，我们最后总结一下：

对于第一次优化，由于FileOutputFormat压根没有采用mapreduce.job.maps参数指定的值，所以它当然不会有任何作用。

对于第二次优化，minSize几乎由mapreduce.input.fileinputformat.split.minsize控制；mapreduce.input.fileinputformat.split.maxsize默认的大小是Long.MAX_VALUE，所以blockSize即为maxSize与blockSize之间的最小值；blockSize的默认大小是128m，所以blockSize与值为1的mapreduce.input.fileinputformat.split.minsize之间的最大值为blockSize，即map任务要划分的大小的大小与blockSize相同。

对于第三次优化，虽然我们将blockSize设置为10m（最小也只能这么小了，hdfs对于block大小的最低限制），根据以上公式maxSize与blockSize之间的最小值必然是blockSize，而blockSize与minSize之间的最大值也必然是blockSize。说明blockSize实际上已经发挥了作用，它决定了splitSize的大小就是blockSize。由于blockSize大于bytesRemaining，所以并没有对map任务数量产生影响。

针对以上分析，我们用更加容易理解的方式列出这些配置参数的关系：

  1. 当mapreduce.input.fileinputformat.split.maxsize > mapreduce.input.fileinputformat.split.minsize > dfs.blockSize的情况下，此时的splitSize 将由mapreduce.input.fileinputformat.split.minsize参数决定。
  2. 当mapreduce.input.fileinputformat.split.maxsize > dfs.blockSize > mapreduce.input.fileinputformat.split.minsize的情况下，此时的splitSize 将由dfs.blockSize配置决定。（第二次优化符合此种情况）
  3. 当dfs.blockSize > mapreduce.input.fileinputformat.split.maxsize > mapreduce.input.fileinputformat.split.minsize的情况下，此时的splitSize 将由mapreduce.input.fileinputformat.split.maxsize参数决定。

鸣谢

我在试验的过程中，遇到很多问题。但是很多问题在网络上都能找到，特此感谢在互联网上分享经验的同仁们。


后记：个人总结整理的《深入理解Spark：核心思想与源码分析》一书现在已经正式出版上市，目前京东、当当、天猫等网站均有销售，欢迎感兴趣的同学购买。


京东(现有满150减50活动）)：http://item.jd.com/11846120.html 

当当：http://product.dangdang.com/23838168.html 

原文链接：https://yq.aliyun.com/articles/632474
关注公众号

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。

持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

转载内容版权归作者及来源网站所有，本站原创内容转载请注明来源。

相关文章

    文章评论

    共有0条评论来说两句吧...

    文章二维码

    扫描即可查看该文章

    点击排行

    推荐阅读

    最新文章