Spark RDD深度解析-RDD计算流程
摘要 RDD(Resilient Distributed Datasets)是Spark的核心数据结构,所有数据计算操作均基于该结构进行,包括Spark sql、Spark Streaming。理解RDD有助于了解分布式计算引擎的基本架构,更好地使用Spark进行批处理与流计算。本文以Spark2.0源代码为主,对RDD的生成、计算流程、加载顺序等作深入的解析。
RDD印象
直观上,RDD可理解为下图所示结构,即RDD包含多个Partition(分区),每个Partition代表一部分数据并位于一个计算节点。
RDD本质上是Spark中的一个抽象类,所有子RDD(HadoopRDD、MapPartitionRDD、JdbcRDD等)都要继承并实现其中的方法。
abstract classRDD[T: ClassTag](
@transient private var_sc: SparkContext,
@transient private vardeps: Seq[Dependency[_]]
) extendsSerializable withLogging {
RDD包含以下成员方法或属性:
1、compute方法
提供在计算过程中Partition元素的获取与计算方式
2、partition的列表
每一个partition代表一个并行的最小划分单元;
3、dependencies列表
描述RDD依赖哪些父RDD生成,即RDD的血缘关系;
4、partition的位置列表
定义如何最快速的获取partition的数据,加快计算,这个是可选的,可作为本地化计算的优化选项;
5、partitioner方法
定义如何对数据进行分区。
RDD生成方式
1、scala集合
Partition的默认值:defaultParallelism
defaultParallelism与spark的部署模式相关:
Local 模式:本机cpu cores的数量
Mesos 模式:8
Yarn:max(2,所有executors的cpu cores个数总和)
2、物理数据载入
默认为min(defaultParallelism, 2)
3、其他RDD转换
根据具体的转换算子而定
Partition
Partiton不直接持有数据,仅仅代表了分区的位置(index的值)。
traitPartition extendsSerializable {
/*** Get the partition's index within its parent RDD*/defindex: Int
// A better default implementation of HashCode
override defhashCode(): Int = index
override defequals(other: Any): Boolean = super.equals(other)
}
Dependency
从名字可以猜想,他描述了RDD之间的依赖关系。成员rdd就是父RDD,会在构造RDD时被赋值。
abstract classDependency[T] extendsSerializable {
defrdd: RDD[T]
}
由上述RDD、Dependcy关系可画出下图,通过这种方式,子RDD能轻易找到父RDD的位置等信息,从而构建出RDD的转换路径,为DAGScheduler的任务划分及任务执行时寻找依赖的数据提供依据。
到此应该能大致明白RDD中涉及的各个概念的含义及其之间的联系。但是仔细思考,会发现存在很多问题,比如:
既然RDD不携带数据,那么数据是何时加载的?怎么加载的?怎么分布到不同计算节点的?
不同类型的RDD是怎么完成转换的?
RDD计算流程
以下面几行代码为例,解答上述问题。
var sc = new SparkContext();
var hdfs_rdd = sc.textFile(hdfs://master:9000/examples/people.txt); // 加载数据
var rdd = hdfs_rdd.map(_.split(“,”)); // 对每行数据按逗号分隔
print(rdd.count());//打印数据的条数
RDD的转换
首先从直观上了解上述代码执行过程中RDD的转换,如下图,Spark按照HDFS中文件的block将数据加载到内存,成为初始RDD1,经过每一步操作后转换为相应RDD。
首先分析textFile方法的作用,源码如下:
def textFile(
path: String,
minPartitions: Int = defaultMinPartitions): RDD[String] = withScope {
assertNotStopped()
hadoopFile(path, classOf[TextInputFormat], classOf[LongWritable], classOf[Text],
minPartitions).map(pair => pair._2.toString).setName(path)
}
着重看红色语句,textFile方法实际上是先调用了hadoopFile方法,再利用其返回值调用map方法,HadoopFile执行了什么,返回了什么呢?
def hadoopFile[K, V](
path: String,
inputFormatClass: Class[_ <: inputformat v>
keyClass: Class[K],
valueClass: Class[V],
minPartitions: Int = defaultMinPartitions): RDD[(K, V)] = withScope {
assertNotStopped()
// This is a hack to enforce loading hdfs-site.xml.
// See SPARK-11227 for details.
FileSystem.getLocal(hadoopConfiguration)
// A Hadoop configuration can be about 10 KB, which is pretty big, so broadcast it.
val confBroadcast = broadcast(new SerializableConfiguration(hadoopConfiguration))
val setInputPathsFunc = (jobConf: JobConf) => FileInputFormat.setInputPaths(jobConf, path)
new HadoopRDD(
this,
confBroadcast,
Some(setInputPathsFunc),
inputFormatClass,
keyClass,
valueClass,
minPartitions).setName(path)
}
很明显,hadoopFile实际上是获取了HADOOP的配置,然后构造并返回了HadoopRDD对象,HadoopRDD是RDD的子类。因此textFile最后调用的是HadoopRDD对象的map方法,其实RDD接口中定义并实现了map方法,所有继承了RDD的类调用的map方法都来自于此。
观察RDD的map方法:
def map[U: ClassTag](f: T => U): RDD[U] = withScope {
val cleanF = sc.clean(f)
new MapPartitionsRDD[U, T](this, (context, pid, iter) => iter.map(cleanF))
}
map方法很简单,首先包装一下传进来的函数,然后返回MapPartitionsRDD对象。至此,textFile结束,他最终只是返回了MapPartitionsRDD,并没有执行数据读取、计算操作。
接着看下一语句:var rdd = hdfs_rdd.map(_.split(“,”));
由上面的分析可知hdfs_rdd是一个MapPartitionsRDD对象,于是其map方法内容与上文的一模一样,也只是返回一个包含用户函数的MapPartitionsRDD对象。
目前为止每个方法的调用只是返回不同类型的RDD对象,还未真正执行计算。
接着看var cnt = rdd.count();
count是一种action类型的操作,会触发RDD的计算,为什么说count会触发RDD的计算呢?需要看看count的实现:
def count(): Long = sc.runJob(this, Utils.getIteratorSize _).sum
可以看到,count方法中调用了sc(sparkContext)的runJob方法,该操作将触发DagScheduler去分解任务并提交到集群执行。count方法会返回Array[U]类型的结果,数组中每个值代表了当前RDD每个分区中包含的元素个数,因此sum的结果就是RDD中所有元素的个数,本例的结果就是HDFS文件中存在几行数据。
RDD的计算
下面介绍任务提交后RDD是怎么计算出来的。
任务分解并提交后开始执行,task会在最后一个RDD上执行compute方法。
以上述代码为例,最后一个RDD的类型是MapPartitionsRDD,看其compute方法:
override defcompute(split: Partition, context: TaskContext): Iterator[U] =
f(context, split.index, firstParent[T].iterator(split, context))
其中split是RDD的分区,firstParent是父RDD;最外层的f其实是构造MapPartitionsRDD时传入的一个参数,改参数是一个函数对象,接收三个参数并返回Iterator
private[spark] classMapPartitionsRDD[U: ClassTag, T: ClassTag](
varprev: RDD[T],
f: (TaskContext, Int, Iterator[T]) => Iterator[U], // (TaskContext, partition index, iterator)
preservesPartitioning: Boolean = false)
f是何时生成的呢?就看何时生成的MapPartitionsRDD,参考上文可知MapPartitionsRDD是在map方法里构造的,其第二个构造参数就是f的具体实现。
new MapPartitionsRDD[U, T](this, (context, pid, iter) =>iter.map(cleanF))
综上可知,MapPartitionsRDD的compute中f的作用就是就是对f的第三个参数iter执行iter.map(cleanF),其中cleanF就是用户调用map时传入的函数,而iter又是firstParent[T].iterator(split, context)的返回值。
firstParent[T].iterator(split, context)又是什么呢?他是对父RDD执行iterator方法,该方法是RDD接口的final方法,因此所有子RDD调用的都是该方法。
final defiterator(split: Partition, context: TaskContext): Iterator[T] = {
if(storageLevel!= StorageLevel.NONE) {
getOrCompute(split, context)
} else{
computeOrReadCheckpoint(split, context)
}
}
通过进一步查看可知,iterator先判断RDD的storageLevel是否为NONE,若不是,则尝试从缓存中读取,读取不到则通过计算来获取该Partition对应的数据的迭代器;若是,尝试从checkpoint中获取Partition对应数据的迭代器,若checkpoint不存在则通过计算来获取。
Iterator方法将返回一个迭代器,通过迭代器可以访问父RDD的某个分区的每个元素,如果内存中不存在父RDD的数据,则调用父RDD的compute方法进行计算。
RDD真正的计算由RDD的action 操作触发,对于action 操作之前的所有Transformation操作,Spark只记录Transformation的RDD生成轨迹,即各个RDD之间的相互依赖关系。
总结
Spark RDD的计算方式为:spark是从最后一个RDD开始计算(调用compute),计算时寻找父RDD,若父RDD在内存就直接使用,否则调用父RDD的compute计算得出,以此递归,过程可抽象为下图:
从对象产生的顺序看,先生成了HadoopRDD,调用两次map方法后依次产生两个MapPartitionsRDD;从执行的角度看,先执行最后一个RDD的compute方法,在计算过程中递归执行父RDD的compute,以生成对应RDD的数据;从数据加载角度看,第一个构造出来的RDD在执行compute时才会将数据载入内存(本例中为HDFS读入内存),然后在这些数据上执行用户传入的方法,依次生成子RDD的内存数据。