【Spark二七】Spark Shuffle写过程源代码代码剖析

以WordCount为例，最简单情况的Shuffle过程为例，展示Spark Shuffle的读写过程，

WordCount代码：

 

package spark.examples

import org.apache.spark.SparkConf
import org.apache.spark.SparkContext

import org.apache.spark.SparkContext._

object SparkWordCount {
  def main(args: Array[String]) {
    System.setProperty("hadoop.home.dir", "E:\\devsoftware\\hadoop-2.5.2\\hadoop-2.5.2");
    val conf = new SparkConf()
    conf.setAppName("SparkWordCount")
    conf.setMaster("local")
    val sc = new SparkContext(conf)
    val rdd = sc.textFile("file:///D:/word.in")
    println(rdd.toDebugString)
    val rdd1 = rdd.flatMap(_.split(" "))
    println("rdd1:" + rdd1.toDebugString)
    val rdd2 = rdd1.map((_, 1))
    println("rdd2:" + rdd2.toDebugString)
    val rdd3 = rdd2.reduceByKey(_ + _);
    println("rdd3:" + rdd3.toDebugString)
    rdd3.saveAsTextFile("file:///D:/wordout" + System.currentTimeMillis());
    sc.stop
  }
}

 

 上面的代码，在Spark内部会创建六个RDD，两个Stage，两个Task， 一个Job。

前面四个RDD形成一个Stage，后面两个RDD形成第二个Stage。第一个Stage对应的是ShuffleMapTask，类似于Hadoop的Map阶段，类似将数据进行单词分解，计数(为1)。第二个Stage对应的是ResultTask，类似于Hadoop的Reduce阶段，用于将Map阶段的结果Shuffle到Reduce节点，然后经过统计计算，写入本地磁盘(本例所示)。

 

为什么Stage0的最后一个RDD(MappedRDD)和ShuffleRDD之间没有依赖关系？答：对于有依赖关系的RDD，假如RDD B依赖于RDD A，那么RDD B的compute方法，必然要从A中获取输入，而对于ShuffleRDD，它是从上一个Stage的输出中获取输入(可能是内存也可能是HDFS)，(不同的Stage位于不同的Task，并且不同阶段的Task是串行执行的，因此，在上一个Stage结束时，它的Task已经结束了，因此RDD的生命周期也结束了)，所以ShuffledRDD只能从RDD之外获取数据，因为ShuffleRDD不是从它的父RDD获取，所以ShuffleRDD没有依赖。

这就是说，每个Stage的第一个RDD不依赖于其它RDD。

 

 

 

 

 

ShuffledRDD是个经过shuffle后开始的RDD，那么它依赖的数据分散在多个Mapper节点上，那么ShuffledRDD就需要将它们拉取回来，所以，真正产生从mapper拉取Shuffle数据的RDD是ShuffledRDD。也就是说，ShuffledRDD，是个依赖于多个节点的数据的RDD(也就是ShuffleRDD是个宽依赖)

 

那么问题来了，第一个Stage的计算结果存放在哪，第二个Stage的Reduce从何处取数据？ 第一个Stage和第二个Stage是否有重叠，即Stage0产出一部分数据，Stage1立马可取？

 

 

DAGScheduler将RDD图进行Stage，划分为两个Stage，Stage0对应的ShuffleMapTask（负责Map的Shuffle写），Stage1对应的是ResultTask(首先读数据，然后shuffle的统计整理，进行写操作)

 

ShuffleMapTask的runTask的主流程

1.通过调用如下语句反序列化得到Stage0的最后一个RDD，这里是MappedRDD，以及ShuffleDependency实例。序列化的数据时task的二进制表示taskBinary.value，即从SparkContext提交过来的任务？

注意的是taskBinary是个Broadcast变量，它的定义在ShuffleMapTask是，taskBinary: Broadcast[Array[Byte]]。

a. rdd中有个成员变量f，它是这个RDD携带的操作，在WordCount的，他表示val rdd3 = rdd2.reduceByKey(_ + _)语句中的_ + _,

 

 

    val (rdd, dep) = ser.deserialize[(RDD[_], ShuffleDependency[_, _, _])](
      ByteBuffer.wrap(taskBinary.value), Thread.currentThread.getContextClassLoader)

b.rdd中的dependencies_ 成员变量包含了这个RDD依赖关系图，也完成了序列化

c. dep是ShuffleDependency实例，它的类声明为

/**
 * :: DeveloperApi ::
 * Represents a dependency on the output of a shuffle stage. Note that in the case of shuffle,
 * the RDD is transient since we don't need it on the executor side.
 *
 * @param _rdd the parent RDD
 * @param partitioner partitioner used to partition the shuffle output
 * @param serializer [[org.apache.spark.serializer.Serializer Serializer]] to use. If set to None,
 *                   the default serializer, as specified by `spark.serializer` config option, will
 *                   be used.
 */

 因为它的rdd属性是transisent，因此，在我们看到的反序列化得到seq，rdd为空。

问题：在ShuffleMapTask中就有了ShuffleDependency,那么在ResultTask中是否也有此ShuffleDependency，言外之意是，到底哪个Stage是shuffle Stage？

2.通过SparkEnv.get.shuffleManager获取SortSuffleManager实例，SortShuffleManager包含有一个IndexShuffleBlockManager实例，而IndexShuffleBlockManager实例包含org.apache.spark.storage.BlockManager实例。

IndexShuffleBlockManager实例和org.apache.spark.storage.BlockManager实例都是从SparkEnv中获取的，因此可以认为IndexShuffleBlockManager实例和org.apache.spark.storage.BlockManager是全局唯一的。

 

3.通过SortShuffleManager获取SortShuffleWriter实例，SortShuffleWriter实例中包含

• IndexShuffleBlockManager实例（与SortSuffleManager实例中的IndexShuffleBlockManager实例同一个），
• org.apache.spark.storage.BlockManager实例
• MapStatus实例，这个实例用于最后返回？

writer的实例是通过如下语句获得的，因此在获取是需要传入shuffleHandle对象。dep.shuffleHandle是个方法调用，它要为shuffleManager注册shuffle后得到的句柄，

 

获取writer实例

  writer = manager.getWriter[Any, Any](dep.shuffleHandle, partitionId, context) //启动的partitionId表示的是当前RDD的某个partition,也就是说write操作作用于partition之上

 

 dep.shuffleHandle方法调用：

  val shuffleHandle: ShuffleHandle = _rdd.context.env.shuffleManager.registerShuffle(shuffleId, _rdd.partitions.size, this)

  shuffleManager.registerShuffle方法调用

  /**
   * Register a shuffle with the manager and obtain a handle for it to pass to tasks.
   */
  override def registerShuffle[K, V, C](
      shuffleId: Int,
      numMaps: Int,
      dependency: ShuffleDependency[K, V, C]): ShuffleHandle = {
    new BaseShuffleHandle(shuffleId, numMaps, dependency)
  }

 

 

 

4. 调用SortShuffleWriter的write方法，将结果输出到Shuffle的Output，那么write方法的输入是什么呢？它是调用Stage0的最后一个RDD的iterator方法，将RDD中的数据转换为一个数组返回，那么，执行逻辑将专项调用

RDD(Stage0的最后一个RDD是MappedRDD)的iterator方法获取RDD中的数据。这个iterator方法，会将Stage中所有的RDD的iterator方法调用一遍，具体的算法是：

假如A<-B<-C<-D

D，C，B分别调用它的parent的iterator方法获得数