Hadoop SparkContext.textFile在封面下是如何工作的？

我试图深入理解

textFile

方法，但我认为 缺乏Hadoop的知识让我不得不回到这里。让我把我的手摊开 理解，也许你可以纠正任何不正确的事情

调用

sc.textFile（path）

时，使用

defaultMinPartitions

， 这实际上只是

math.min（taskScheduler.defaultParallelism，2）

。让我们 假设我们使用的是

SparkDeploySchedulerBackend

，这是

conf.getInt("spark.default.parallelism", math.max(totalCoreCount.get(),
2))

那么，现在让我们假设默认值为2，返回到

textFile

，这是 传递到HadoopRDD。在

getPartitions（）

中使用

inputFormat.getSplits（jobConf，minPartitions）

。但是，根据我所能找到的， 分区只是一个提示，实际上大部分被忽略，因此您将 可能会得到块的总数

好的，这符合预期，但是如果不使用默认值，并且 您提供的分区大小大于块大小。如果我的 研究是正确的，getSplits调用只是忽略了这个参数，然后 提供的最小值不会被忽略，而您仍然会 区块大小

---

短版：

拆分大小由

mapred.min.Split.size

或

mapreduce.input.fileinputformat.Split.minsize

确定，如果它大于HDFS的块大小，则同一文件中的多个块将合并为一个拆分

详细版本：

我认为您在

inputFormat.getSplits

之前理解的过程是正确的

在

inputFormat.getSplits

内部，更具体地说，在

FileInputFormat的getSplits

内部，是

mapred.min.split.size

或

mapreduce.input.FileInputFormat.split.minsize

最终决定拆分大小。（我不确定哪种方法对Spark有效，我更愿意相信前一种方法）

让我们看看代码：

long goalSize=totalSize/（numSplits==0？1:numSplits）；
long minSize=Math.max（job.getLong（org.apache.hadoop.mapreduce.lib.input）。
FileInputFormat.SPLIT_MINSIZE，1），minSplitSize）；
//生成拆分
ArrayList拆分=新的ArrayList（numSplits）；
NetworkTopology clusterMap=新的NetworkTopology（）；
for（FileStatus文件：files）{
路径路径=file.getPath（）；
long length=file.getLen（）；
如果（长度！=0）{
FileSystem fs=path.getFileSystem（作业）；
区块位置[]BLKLLOCATIONS；
if（LocatedFileStatus的文件实例）{
blkLocations=（（LocatedFileStatus）文件）.getBlockLocations（）；
}否则{
blkLocations=fs.getFileBlockLocations（文件，0，长度）；
}
if（isSplitable（fs，路径））{
long blockSize=file.getBlockSize（）；
长拆分大小=计算拆分大小（goalSize、minSize、blockSize）；
长字节剩余=长度；
而（（（双）字节剩余）/splitSize>SPLIT_SLOP）{
String[]splitHosts=getSplitHosts（blkLocations，
剩余长度字节、拆分大小、群集映射）；
添加（makeSplit（路径、剩余长度字节、splitSize、，
拆分主机）；
字节剩余-=拆分大小；
}
if（剩余字节数！=0）{
String[]splitHosts=getSplitHosts（blkLocations，length
-字节剩余，字节剩余，聚类图）；
添加（makeSplit（路径，长度-字节剩余，字节剩余，
拆分主机）；
}
}否则{
String[]splitHosts=getSplitHosts（blkLocations，0，length，clusterMap）；
添加（makeSplit（路径，0，长度，splitHosts））；
}
}否则{
//为零长度文件创建空主机阵列
添加（makeSplit（路径，0，长度，新字符串[0]）；
}
}

在for循环中，

makeSplit（）

用于生成每个拆分，而

splitSize

是有效的拆分大小。computeSplitSize函数用于生成

splitSize

：

protected long computeSplitSize（long goalSize，long minSize，
长块大小）{
返回Math.max（minSize，Math.min（goalSize，blockSize））；
}

因此，如果minSplitSize>blockSize，则输出分割实际上是同一HDFS文件中多个块的组合，另一方面，如果minSplitSize

I will add more points with examples to Yijie Shen answer

Before we go into details,lets understand the following

Assume that we are working on Spark Standalone local system with 4 cores

In the application if master is configured as like below
new SparkConf().setMaster("**local[*]**") then 

defaultParallelism : 4 (taskScheduler.defaultParallelism ie no.of cores)

/* Default level of parallelism to use when not given by user (e.g. parallelize and makeRDD). */ 

defaultMinPartitions : 2 //Default min number of partitions for Hadoop RDDs when not given by user

* Notice that we use math.min so the "defaultMinPartitions" cannot be higher than 2. 

查找defaultMinPartitions的逻辑如下

DefDefaultMinPartitions:Int=math.min（defaultParallelism，2）

实际分区大小由FileInputFormat.computeSplitSize方法中的以下公式定义
包org.apache.hadoop.mapred；
公共抽象类FileInputFormat实现InputFormat{
受保护的长计算规模（长目标规模、长最小规模、长块规模）{
返回Math.max（minSize，Math.min（goalSize，blockSize））；
}
}
哪里
minSize是hadoop参数mapreduce.input.fileinputformat.split.minSize（默认mapreduce.input.fileinputformat.split.minSize=1字节）
blockSize是群集模式下dfs.block.size的值（**dfs.block.size-Hadoop 2.0中的默认值为128 MB**）和本地模式下fs.local.block.size的值（**默认fs.local.block.size=32 MB ie blockSize=33554432字节**）
goalSize=总输入大小/numPartitions
哪里
totalInputSize是输入路径中所有文件的总大小（以字节为单位）
numPartitions是提供给方法sc.textFile（inputPath，numPartitions）的自定义参数-如果未提供，则将是defaultMinPartitions，如果master设置为local（*），则为defaultMinPartitions 2
blocksize=文件大小（以字节为单位）=33554432
33554432/1024=32768 KB
32768/1024=32 MB
Ex1:-如果我们的文件大小是91字节
minSize=1（mapreduce.input.fileinputformat.split.minSize=1字节）
goalSize=总输入大小/numPartitions
goalSize=91（文件大小）/12（分区在sc.textFil中作为第二个参数提供
The actual partition size is defined by the following formula in the method FileInputFormat.computeSplitSize

package org.apache.hadoop.mapred;
public abstract class FileInputFormat<K, V> implements InputFormat<K, V> {
    protected long computeSplitSize(long goalSize, long minSize, long blockSize) {
        return Math.max(minSize, Math.min(goalSize, blockSize));
    }
}

where,
    minSize is the hadoop parameter mapreduce.input.fileinputformat.split.minsize (default mapreduce.input.fileinputformat.split.minsize = 1 byte)
    blockSize is the value of the dfs.block.size in cluster mode(**dfs.block.size - The default value in Hadoop 2.0 is 128 MB**) and fs.local.block.size in the local mode (**default fs.local.block.size = 32 MB ie blocksize = 33554432 bytes**)
    goalSize = totalInputSize/numPartitions
        where,
            totalInputSize is the total size in bytes of all the files in the input path
            numPartitions is the custom parameter provided to the method sc.textFile(inputPath, numPartitions) - if not provided it will be defaultMinPartitions ie 2 if master is set as local(*)

blocksize = file size in bytes = 33554432
33554432/1024 = 32768 KB
32768/1024 = 32 MB


Ex1:- If our file size is 91 bytes
minSize=1 (mapreduce.input.fileinputformat.split.minsize = 1 byte)
goalSize = totalInputSize/numPartitions
goalSize = 91(file size)/12(partitions provided as 2nd paramater in sc.textFile) = 7 

splitSize = Math.max(minSize, Math.min(goalSize, blockSize)); => Math.max(1,Math.min(7,33554432)) = 7 // 33554432 is block size in local mode

Splits = 91(file size 91 bytes) / 7 (splitSize) => 13

FileInputFormat: Total # of splits generated by getSplits: 13