Spark源码分析 – Dependency

Dependency

依赖, 用于表示RDD之间的因果关系, 一个dependency表示一个parent rdd, 所以在RDD中使用Seq[Dependency[_]]来表示所有的依赖关系

Dependency的base class
可见Dependency唯一的成员就是rdd, 即所依赖的rdd, 或parent rdd

/**

 * Base class for dependencies.

 */

abstract class Dependency[T](val rdd: RDD[T]) extends Serializable

Dependency分为两种, narrow和shuffle

NarrowDependency

先看看比较简单的narrow
定义, parent RDD中的每个partition最多被child RDD中的一个partition使用, 即不需要shuffle
更直白点, 就是Narrow只有map, partition本身范围不会改变, 一个parititon经过transform还是一个partition, 虽然内容发生了变化, 所以可以在local完成
而wide就是, partition需要打乱从新划分, 存在shuffle的过程, partition的数目和范围都发生了变化

唯一的接口getParents, 即给定任一个partition-id, 得到所有依赖的parent partitions的id的seq

/**

 * Base class for dependencies where each partition of the parent RDD is used by at most one

 * partition of the child RDD.  Narrow dependencies allow for pipelined execution.

 */

abstract class NarrowDependency[T](rdd: RDD[T]) extends Dependency(rdd) {

  /**

   * Get the parent partitions for a child partition.

   * @param partitionId a partition of the child RDD

   * @return the partitions of the parent RDD that the child partition depends upon

   */

  def getParents(partitionId: Int): Seq[Int]

}

NarrowDependency又分为两种,

OneToOneDependency
最简单的依赖关系, 即parent和child里面的partitions是一一对应的, 典型的操作就是map, filter…

其实partitionId就是partition在RDD中的序号, 所以如果是一一对应, 那么parent和child中的partition的序号应该是一样的

/**

 * Represents a one-to-one dependency between partitions of the parent and child RDDs.

 */

class OneToOneDependency[T](rdd: RDD[T]) extends NarrowDependency[T](rdd) {

  override def getParents(partitionId: Int) = List(partitionId) //序号一致

}

 

RangeDependency

虽然仍然是一一对应, 但是是parent RDD中的某个区间的partitions对应到child RDD中的某个区间的partitions
典型的操作是union, 多个parent RDD合并到一个child RDD, 故每个parent RDD都对应到child RDD中的一个区间
需要注意的是, 这里的union不会把多个partition合并成一个partition, 而是的简单的把多个RDD中的partitions放到一个RDD里面, partition不会发生变化, 可以参考Spark 源码分析 – RDD 中UnionRDD的实现

由于是range, 所以直接记录起点和length就可以了, 没有必要加入每个中间rdd, 所以RangeDependency优化了空间效率

/**

 * Represents a one-to-one dependency between ranges of partitions in the parent and child RDDs.

 * @param rdd the parent RDD

 * @param inStart the start of the range in the parent RDD, parent RDD中区间的起始点

 * @param outStart the start of the range in the child RDD, child RDD中区间的起始点 

 * @param length the length of the range

 */

class RangeDependency[T](rdd: RDD[T], inStart: Int, outStart: Int, length: Int)

  extends NarrowDependency[T](rdd) {



  override def getParents(partitionId: Int) = {

    if (partitionId >= outStart && partitionId < outStart + length) { //判断partitionId的合理性,必须在child RDD的合理partition范围内

      List(partitionId - outStart + inStart) //算出parent RDD中对应的partition id

    } else {

      Nil

    }

  }

}

 

WideDependency

WideDependency, 也称为ShuffleDependency
首先需要基于PairRDD, 因为一般需要依据key进行shuffle, 所以数据结构往往是kv
即RDD中的数据是kv pair, [_ <: Product2[K, V]],

trait Product2[+T1, +T2] extends Product  // Product2 is a cartesian product of 2 components

Product2是trait, 这里实现了Product2可以用于表示kv pair? 不是很理解

其次, 由于需要shuffle, 所以当然需要给出partitioner, 如何完成shuffle

然后, shuffle不象map可以在local进行, 往往需要网络传输或存储, 所以需要serializerClass

最后, 每个shuffle需要分配一个全局的id, context.newShuffleId()的实现就是把全局id累加

 

/**

 * Represents a dependency on the output of a shuffle stage.

 * @param rdd the parent RDD

 * @param partitioner partitioner used to partition the shuffle output

 * @param serializerClass class name of the serializer to use

 */

class ShuffleDependency[K, V](

    @transient rdd: RDD[_ <: Product2[K, V]],

    val partitioner: Partitioner,

    val serializerClass: String = null)

  extends Dependency(rdd.asInstanceOf[RDD[Product2[K, V]]]) {



  val shuffleId: Int = rdd.context.newShuffleId()

}