RDD Dependency详解---Spark学习笔记9

RDD的最重要的特性之一就是血缘关系，血缘关系描述了一个RDD是如何从父RDD计算得来的。

这个性质可以理解为人类的进化，人是怎么从猿人一步步进化到现代的人类的，每个进化阶段可以理解为一个RDD。

如果某个RDD丢失了，则可以根据血缘关系，从父RDD计算得来。

总结：

RDD可以描述为一组partition的向量表示，且具有依赖关系。

Dependency（依赖）：

图中蓝色实心矩形就是一个个的partition，而大的空心矩形就是一个RDD

RDD与RDD直接的连线代表了RDD之间的依赖关系。

RDD的Dependency就是描述了这样的关系，分为2类，Narrow Dependency， Shuffle Dependency。

/**
 * Base class for dependencies.
 */
abstract class Dependency[T](val rdd: RDD[T]) extends Serializable

1. Narrow Dependency

窄依赖，描述了一种很窄的依赖范围，通常是1对1的依赖关系，1父1子。

Stage2中的C到D，就是一种narrow dependency。

/**
 * 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]
}

源代码也解释了什么是窄依赖：

窄依赖是一种RDD的基类，这种RDD的父RDD的每个分区都被用作它的子RDD，翻译起来很拗口，其实就是子RDD的每个分区都是由父RDD的每个分区变形而来。

窄依赖允许管道式的执行，很容易理解像map, filter 这些都是窄依赖。

1.1 OneToOneDependency

一对一的依赖，一父一子。最典型的是map，filter。如上图C->D。

/**
 * 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)

1.2 RangeDependency

范围依赖，一定范围的RDD直接的对应。最典型的是Union，如上图D->F。

参数：

inStart  在父RDD中range的开始位置

outStart  在子RDD中range中的开始位置

length   这个范围的长度

/**
 * 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
 * @param outStart the start of the range in the 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) {
      List(partitionId - outStart + inStart)
    } else {
      Nil
    }
  }
}

2. Shuffle Dependency

洗牌依赖？可以这样翻译么？我们还是叫它Wide Dependency吧。

这种叫做宽泛依赖，代表了在shuffle stage的时候的依赖关系。

这种依赖首先要求是PariRdd即k,v的形式，这样才能做shuffle，和hadoop一样。

最典型的是join了，如图B,F->G。

参数：

partitioner，要进行shuffle就需要一个partitioner,是hash partitioner还是自定义的都可以。

serializerClass，因为需要网络传输进行shuffle。

/**
 * 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()
}

原创文章，转载请注明出处http://blog.csdn.net/oopsoom/article/details/23865255