spark 的RDD依赖系

RDD和它依赖的parent RDD(s)的关系有两种不同的类型，即窄依赖（narrow dependency）和宽依赖（wide dependency）。

     1）窄依赖指的是每一个parent RDD的Partition最多被子RDD的一个Partition使用，如图1所示。

     2）宽依赖指的是多个子RDD的Partition会依赖同一个parent RDD的Partition，如图2所示。

 

　　RDD作为数据结构，本质上是一个只读的分区记录集合。一个RDD可以包含多个分区，每个分区就是一个dataset片段。RDD可以相互依赖。

　　1）如果RDD的每个分区最多只能被一个Child RDD的一个分区使用，则称之为narrow dependency。

　　2）如果多个Child RDD分区都可以依赖，则称之为wide / shuffle dependency 。

 

 

Spark之所以将依赖分为narrow 和 shuffle / wide 。基于两点原因

　　1、首先，narrow dependencies可以支持在同一个cluster node上，以pipeline形式执行多条命令，例如在执行了map后，紧接着执行filter。

　　　　相反，shuffle / wide dependencies 需要所有的父分区都是可用的，可能还需要调用类似MapReduce之类的操作进行跨节点传递。

     2、其次，则是从失败恢复的角度考虑。 narrow dependencies的失败恢复更有效，因为它只需要重新计算丢失的parent partition即可，而且可以并行地在不同节点进行重计算。

　　     相反，shuffle / wide dependencies 牵涉RDD各级的多个parent partition。

 

 

 

                          

　　　　　　　　图 1  RDD的窄依赖  　　　　　　　　　　　   　 图 2 RDD的宽依赖

 

     接下来可以从不同类型的转换来进一步理解RDD的窄依赖和宽依赖的区别，如图3所示。

     对于map和filter形式的转换来说，它们只是将Partition的数据根据转换的规则进行转化，并不涉及其他的处理，可以简单地认为只是将数据从一个形式转换到另一个形式。对于union，只是将多个RDD合并成一个，parent RDD的Partition(s)不会有任何的变化，可以认为只是把parent RDD的Partition(s)简单进行复制与合并。对于join，如果每个Partition仅仅和已知的、特定的Partition进行join，那么这个依赖关系也是窄依赖。对于这种有规则的数据的join，并不会引入昂贵的Shuffle。对于窄依赖，由于RDD每个Partition依赖固定数量的parent RDD(s)的Partition(s)，因此可以通过一个计算任务来处理这些Partition，并且这些Partition相互独立，这些计算任务也就可以并行执行了。

　　 对于groupByKey，子RDD的所有Partition(s)会依赖于parent RDD的所有Partition(s)，子RDD的Partition是parent RDD的所有Partition Shuffle的结果，因此这两个RDD是不能通过一个计算任务来完成的。同样，对于需要parent RDD的所有Partition进行join的转换，也是需要Shuffle，这类join的依赖就是宽依赖而不是前面提到的窄依赖了。

 

 

　　不同的操作依据其特性，可能会产生不同的依赖。例如map、filter操作会产生 narrow dependency 。reduceBykey操作会产生 wide / shuffle dependency。

 

 

 

 

    

所有的依赖都要实现trait Dependency[T]：

abstract class Dependency[T] extends Serializable {

    def rdd: RDD[T]

}

 

其中rdd就是依赖的parent RDD。

 

 

对于窄依赖的实现是：

 

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

    //返回子RDD的partitionId依赖的所有的parent RDD的Partition(s)

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

    override def rdd: RDD[T] = _rdd

}

 

现在有两种窄依赖的具体实现，一种是一对一的依赖，即OneToOneDependency：

 

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

    override def getParents(partitionId: Int) = List(partitionId)

 

 

 

 

 

    通过getParents的实现不难看出，RDD仅仅依赖于parent RDD相同ID的Partition。
还有一个是范围的依赖，即RangeDependency，它仅仅被org.apache.spark.rdd.UnionRDD使用。UnionRDD是把多个RDD合成一个RDD，这些RDD是被拼接而成，即每个parent RDD的Partition的相对顺序不会变，只不过每个parent RDD在UnionRDD中的Partition的起始位置不同。因此它的getPartents如下：

override def getParents(partitionId: Int) = {

    if(partitionId >= outStart && partitionId < outStart + length) {

       List(partitionId - outStart + inStart)

    } else {

       Nil

    }

}

其中，inStart是parent RDD中Partition的起始位置，outStart是在UnionRDD中的起始位置，length就是parent RDD中Partition的数量。

 

 

对于宽依赖的实现是：

　　宽依赖的实现只有一种：ShuffleDependency。子RDD依赖于parent RDD的所有Partition，因此需要Shuffle过程：

class ShuffleDependency[K, V, C](

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

    val partitioner: Partitioner,

    val serializer: Option[Serializer] = None,

    val keyOrdering: Option[Ordering[K]] = None,

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

    val mapSideCombine: Boolean = false)

extends Dependency[Product2[K, V]] {

 

override def rdd = _rdd.asInstanceOf[RDD[Product2[K, V]]]

//获取新的shuffleId

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

//向ShuffleManager注册Shuffle的信息

val shuffleHandle: ShuffleHandle =

_rdd.context.env.shuffleManager.registerShuffle(

    shuffleId, _rdd.partitions.size, this)

 

    _rdd.sparkContext.cleaner.foreach(_.registerShuffleForCleanup(this))

}

　　宽依赖支持两种Shuffle Manager，即org.apache.spark.shuffle.hash.HashShuffleManager（基于Hash的Shuffle机制）和org.apache.spark.shuffle.sort.SortShuffleManager（基于排序的Shuffle机制）。