Spark中shuffle的触发和调度

Spark中的shuffle是在干嘛？

Shuffle在Spark中即是把父RDD中的KV对按照Key重新分区，从而得到一个新的RDD。也就是说原本同属于父RDD同一个分区的数据需要进入到子RDD的不同的分区。

但这只是shuffle的过程，却不是shuffle的原因。为何需要shuffle呢？

Shuffle和Stage

在分布式计算框架中，比如map-reduce，数据本地化是一个很重要的考虑，即计算需要被分发到数据所在的位置，从而减少数据的移动，提高运行效率。

Map-Reduce的输入数据通常是HDFS中的文件，所以数据本地化要求map任务尽量被调度到保存了输入文件的节点执行。但是，有一些计算逻辑是无法简单地获取本地数据的，reduce的逻辑都是如此。对于reduce来说，处理函数的输入是key相同的所有value，但是这些value所在的数据集(即map的输出)位于不同的节点上，因此需要对map的输出进行重新组织，使得同样的key进入相同的reducer。 shuffle移动了大量的数据，对计算、内存、网络和磁盘都有巨大的消耗，因此，只有确实需要shuffle的地方才应该进行shuffle。

Stage的划分

对于Spark来说，计算的逻辑存在于RDD的转换逻辑中。Spark的调度器也是在依据数据本地化在调度任务，只不过此处的“本地”不仅包括磁盘文件，也包括RDD的分区， Spark会使得数据尽量少地被移动，据此，DAGScheduler把一个job划分为多个Stage，在一个Stage内部，数据是不需要移动地，数据会在本地经过一系列函数的处理，直至确实需要shuffle的地方。

例如，在DAGScheduler的getParentStages方法中，寻找父stage时，使用了如下的代码段

        for (dep <- r.dependencies) {
          dep match {
            case shufDep: ShuffleDependency[_, _, _] =>
              parents += getShuffleMapStage(shufDep, jobId)
            case _ =>
              waitingForVisit.push(dep.rdd)
          }

即找到了ShuffleDependency才会划分出一个最的Stage(除了没有父RDD的RDD，比如HadoopRDD，它的dependencies为Nil)。

在上边的代码中，提到了ShuffleMapStage，其实Spark的Stage只有两个子类:ShuffleStage和 ResultStage。相应的，Task也只有两个子类，ResultTask和ShuffleMapTask。这些类之间的联系，可以从DAGScheduler的submitMissingTasks方法中表现中来。下面是这个方法中的一段代码：

  val tasks: Seq[Task[_]] = try {
      stage match {
        case stage: ShuffleMapStage =>
          partitionsToCompute.map { id =>
            val locs = getPreferredLocs(stage.rdd, id)
            val part = stage.rdd.partitions(id)
            new ShuffleMapTask(stage.id, taskBinary, part, locs)
          }

        case stage: ResultStage =>
          val job = stage.resultOfJob.get
          partitionsToCompute.map { id =>
            val p: Int = job.partitions(id)
            val part = stage.rdd.partitions(p)
            val locs = getPreferredLocs(stage.rdd, p)
            new ResultTask(stage.id, taskBinary, part, locs, id)
          }
      }
    } catch {
      case NonFatal(e) =>
        abortStage(stage, s"Task creation failed: $e\n${e.getStackTraceString}")
        runningStages -= stage
        return
    }

这段代码用来生成task, 确切地说是为某个Stage生成task。从以上代码可以看出，为ResultStage生成的就是ResultTask， 为ShuffleMapStage生成的就是ShuffleMapTask。

ShuffleMapTask有何特殊之处呢？

对于多于一个Stage的job，肯定会存在shuffle，这也意味会有Stage的父Stage是ShuffleMapStage。ShuffleMapStage中的ShuffleMapTask的最后一个RDD的数据会被进行shuffle，这也是它与ResultTask的区别。下边是ShuffleMapTask的runTask方法中的一段代码，executor会间接调用runTask方法

      val manager = SparkEnv.get.shuffleManager//莸取ShuffleManager
      //获取writer，注意会把ShuffleDependency.shuffleHander传过去
      writer = manager.getWriter[Any, Any](dep.shuffleHandle, partitionId, context)
      writer.write(rdd.iterator(partition, context).asInstanceOf[Iterator[_ <: Product2[Any, Any]]])
      return writer.stop(success = true).get

writer.write(rdd.iterator(partition, context).asInstanceOf[Iterator[_ <: Product2[Any, Any]]])这一句会计算最后一个rdd的某个分区，然后用writer写入这个分区的数据，这可以认为是shuffle中的map阶段。

那么reduce阶段是如何触发的呢？

这实际上是很自然地由Spark对RDD的计算逻辑触发的。

Spark的运算逻辑是由对RDD的partition的计算驱动的(上一篇提到过), 即对子RDD的partition的计算会触发对父RDD的对应partition的计算，由此触发到第一个可以计算的RDD的分区。所以shuffle关系子Stage中最初始的那个RDD一定包含有和shuffle过程相关的逻辑，这种特殊的RDD有两类，ShuffledRDD和CoGroupedRDD,（后者不一定是shuffle的结果), 也就是说reduce是由对特殊RDD的计算触发的。下面以ShuffledRDD为例进行说明，单个RDD进行shuffle会生成这种RDD。

ShuffledRDD

ShuffledRDD的特点由三部分可以体现。首先，它包括了一些跟shuffle有关的field：

  private var serializer: Option[Serializer] = None

  private var keyOrdering: Option[Ordering[K]] = None

  private var aggregator: Option[Aggregator[K, V, C]] = None

  private var mapSideCombine: Boolean = false

其中Aggregator主要用来指明对于同一个key对应的value，如何进行aggregate，但不仅于此。这是个挺有意思的类，它的域是一系列函数。

其次，它的dependency是ShuffleDependency，因此DAGScheduler会把它当作新Stage的起点，它的父RDD被当作前一个Stage的终点。

  override def getDependencies: Seq[Dependency[_]] = {
    List(new ShuffleDependency(prev, part, serializer, keyOrdering, aggregator, mapSideCombine))
  }

最后，当ShuffledRDD的某个partition被compute时，会触发对map输出的fetch，以及对value的aggregate等操作，也就是reduce阶段。

  override def compute(split: Partition, context: TaskContext): Iterator[(K, C)] = {
    val dep = dependencies.head.asInstanceOf[ShuffleDependency[K, V, C]]
    SparkEnv.get.shuffleManager.getReader(dep.shuffleHandle, split.index, split.index + 1, context)
      .read()
      .asInstanceOf[Iterator[(K, C)]]
  }

那么ShuffledRDD是如何生成的呢？

当然，会引起shuffle的transformation就会生成ShuffledRDD，以reduceByKey为例。

reduceByKey实际上有很多个重载的同名方法，以最简单的为例

  def reduceByKey(func: (V, V) => V): RDD[(K, V)] = self.withScope {
    reduceByKey(defaultPartitioner(self), func)
  }

  def reduceByKey(partitioner: Partitioner, func: (V, V) => V): RDD[(K, V)] = self.withScope {
    combineByKey[V]((v: V) => v, func, func, partitioner)
  }

reduceByKey是在某个RDD上被调用的，设此RDD为A，调用reduceByKey生成的RDD为B。那么，以上代码中的partitioner是指用于生成B的Partitioner, 它指出了A中的每个kv对应该进行B的哪个分区。之所以需要注意这点，是因为在combineByKey中会根据这个Partitioner决定需要生成的RDD，在特定情况下reduceByKey不会导致shuffle.

下面是combineByKey中用于决定生成何种RDD的代码：

  if (self.partitioner == Some(partitioner)) {
      self.mapPartitions(iter => {
        val context = TaskContext.get()
        new InterruptibleIterator(context, aggregator.combineValuesByKey(iter, context))
      }, preservesPartitioning = true)
    } else {
      new ShuffledRDD[K, V, C](self, partitioner)
        .setSerializer(serializer)
        .setAggregator(aggregator)
        .setMapSideCombine(mapSideCombine)
    }

它会根据

if (self.partitioner == Some(partitioner)) 

来决定是否生成ShuffledRDD。其中self.partitioner是指A这个RDD的partitioner，它指明了A这个RDD中的每个key在哪个partition中。而等号右边的partitioner，指明了B这个RDD的每个key在哪个partition中。当二者==时，就会用self.mapPartitions生成MapPartitionsRDD， 这和map这种transformation生成的RDD是一样的，此时reduceByKey不会引发shuffle。

Partitioner有几个子类，它们中的某些会override默认的equals方法(注意，Scala中的==会调用equals方法，这点和Java不同)。典型的，如HashPartitioner中的equals方法

  override def equals(other: Any): Boolean = other match {
    case h: HashPartitioner =>
      h.numPartitions == numPartitions
    case _ =>
      false
  }

当两个HashPartitioner的分区数目一致时，就认为他们相等。但是，即是A和B有相同的Partitioner，也只决定了这两个RDD中相同的key在同一个partition中，并不意味着A中相同的key对应的value已经被aggregate了，因此在combineByKey操作中调用mapPartitions方法时，指定了特殊的Iterator到Iterator的转换方法。

 new InterruptibleIterator(context, aggregator.combineValuesByKey(iter, context))

也就是说A中partition的Iterator会被执行combineValuesByKey操作，来对value进行aggregate。对于reduceByKey，不管需不需要进行shuffle，对value进行aggregate都是要执行的。比如，在ShuffledRDD的compute方法中，会调用ShuffleReader的read方法。ShuffleReader当前只有一种，叫HashShuffleReader， 不管是用sort还是hash进行shuffle，reduce端都是使用的这个Reader，它会对从map端抓取数据后生成的iterator进行aggregate

    val aggregatedIter: Iterator[Product2[K, C]] = if (dep.aggregator.isDefined) {
      if (dep.mapSideCombine) {
        new InterruptibleIterator(context, dep.aggregator.get.combineCombinersByKey(iter, context))
      } else {
        new InterruptibleIterator(context, dep.aggregator.get.combineValuesByKey(iter, context))
      }
    } else {
      require(!dep.mapSideCombine, "Map-side combine without Aggregator specified!")

      // Convert the Product2s to pairs since this is what downstream RDDs currently expect
      iter.asInstanceOf[Iterator[Product2[K, C]]].map(pair => (pair._1, pair._2))
    }

在上边combineByKey的代码中，可以看到它生成ShuffledRDD时，设置了aggreator，而mapSideCombine使用了默认参数，为true，所以combineCombinerByKey会被调用，来对已经combine好的value进行combine。

总结

通过上边的内容，基本可以了解到DAGScheduler是如何处理根据shuffle划分Stage，生成特殊的task；以及Spark执行过程中，map和reduce两个阶段是如何被触发的。

总的是来说， RDD的转换操作会尽量避免shuffle的出现，如果不得不shuffle，会生成特殊的RDD，它的dependencies会是ShuffleDependency。DAGScheduler在划分Stage时，会用ShuffleDependency确定Stage的边界，也会由此生成ShuffleMapTask来完成map端的工作。引发shuffle的transformation会生成特殊的RDD，此RDD会是shuffle中子Stage的起点，当这些RDD的compute方法被调用时，就会触发reduce端操作的执行。这种特殊的RDD有两类：

ShuffledRDD, 它只有一个父RDD，是对一个RDD进行shuffle的结果。

CoGroupedRDD, 它有多个RDD，是对多个RDD进行shuffle的结果。