RDD进阶（章节三）

最新推荐文章于 2024-07-25 23:49:05 发布

策马出凉州

最新推荐文章于 2024-07-25 23:49:05 发布

阅读量143

点赞数

分类专栏： spark计算框架文章标签： spark

本文链接：https://blog.csdn.net/origin_cx/article/details/104434056

版权

spark计算框架专栏收录该内容

5 篇文章 0 订阅

订阅专栏

RDD进阶（章节三）

分析WordCount

sc.textFile("hdfs:///demo/words/t_word") //RDD0
    .flatMap(_.split(" ")) //RDD1
    .map((_,1)) //RDD2
    .reduceByKey(_+_) //RDD3 finalRDD
    .collect //Array 任务提交

RDD都有哪些特性？

RDD具有分区-分区数等于该RDD并⾏度
每个分区独⽴运算，尽可能实现分区本地性计算
RDD是一个只读的数据集，且RDD与RDD之间存在着相互依赖关系
针对于 key-value RDD，可以指定分区策略【可选】
基于数据所属的位置，选择最优位置实现本地性计算【可选】

RDD容错

在理解DAGSchedule如何做状态划分的前提是需要⼤家了解⼀个专业术语 lineage 通常被⼈们称为RDD的⾎统。

Spark的计算本质就是对RDD做各种转换，因为RDD是⼀个不可变只读的集合，因此每次的转换都需要上⼀次的RDD作为本次转换的输⼊，因此RDD的lineage描述的是RDD间的相互依赖关系。

Spark将RDD之间的关系归类为宽依赖和窄依赖。

Spark会根据Lineage存储的RDD的依赖关系对RDD计算做故障容错。⽬前Saprk的容错策略 根据RDD依赖关系重新计算-⽆需⼲预 、RDD做Cache-临时缓存 、 RDD做Checkpoint-持久化⼿段完成RDD计算的故障容错。

RDD缓存

缓存是⼀种RDD计算容错的⼀种⼿段，程序在RDD数据丢失的时候，可以通过缓存快速计算当前RDD的值，⽽不需要反推出所有的RDD重新计算，因此Spark在需要对某个RDD多次使⽤的时候，为了提⾼程序的执⾏效率⽤户可以考虑使⽤RDD的cache。

scala> var finalRDD=sc.textFile("hdfs:///demo/words/t_word").flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_)
finalRDD: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[25] at reduceByKey at<console>:24
scala> finalRDD.cache              //finalRDD.persist(StorageLevel.MEMORY_ONLY)
res7: org.apache.spark.rdd.RDD[(String, Int)] = ShuffledRDD[25] at reduceByKey at<console>:24
scala> finalRDD.collect
res8: Array[(String, Int)] = Array((this,1), (is,1), (day,2), (come,1), (hello,1),(baby,1), (up,1), (spark,1), (a,1), (on,1), (demo,1), (good,2), (study,1))
scala> finalRDD.collect
res9: Array[(String, Int)] = Array((this,1), (is,1), (day,2), (come,1), (hello,1),
(baby,1), (up,1), (spark,1), (a,1), (on,1), (demo,1), (good,2), (study,1))

⽤户可以调⽤upersist⽅法清空缓存

scala> finalRDD.unpersist()          //清空缓存中的finalRDD
res11: org.apache.spark.rdd.RDD[(String, Int)]
@scala.reflect.internal.annotations.uncheckedBounds = ShuffledRDD[25] at reduceByKey at<console>:24

⽬前Spark⽀持的缓存⽅案如下：

object StorageLevel {
 val NONE = new StorageLevel(false, false, false, false)
 val DISK_ONLY = new StorageLevel(true, false, false, false) // 仅仅存储磁盘
 val DISK_ONLY_2 = new StorageLevel(true, false, false, false, 2) // 仅仅存储磁盘 存储两份
 val MEMORY_ONLY = new StorageLevel(false, true, false, true)       //缓存在内存中
 val MEMORY_ONLY_2 = new StorageLevel(false, true, false, true, 2)
 val MEMORY_ONLY_SER = new StorageLevel(false, true, false, false) //先序列化再存储内存，费CPU节省内存
 val MEMORY_ONLY_SER_2 = new StorageLevel(false, true, false, false, 2)
 val MEMORY_AND_DISK = new StorageLevel(true, true, false, true)       //推荐使用
 val MEMORY_AND_DISK_2 = new StorageLevel(true, true, false, true, 2)
 val MEMORY_AND_DISK_SER = new StorageLevel(true, true, false, false)
 val MEMORY_AND_DISK_SER_2 = new StorageLevel(true, true, false, false, 2)
 val OFF_HEAP = new StorageLevel(true, true, true, false, 1)
...

那如何选择呢？

默认情况下，性能最⾼的当然是MEMORY_ONLY，但前提是你的内存必须⾜够⾜够⼤，可以绰绰有余地存放下整个RDD的所有数据。因为不进⾏序列化与反序列化操作，就避免了这部分的性能开销；对这个RDD的后续算⼦操作，都是基于纯内存中的数据的操作，不需要从磁盘⽂件中读取数据，性能也很⾼；⽽且不需要复制⼀份数据副本，并远程传送到其他节点上。但是这⾥必须要注意的是，在实际的⽣产环境中，恐怕能够直接⽤这种策略的场景还是有限的，如果RDD中数据⽐较多时（⽐如⼏⼗亿），直接⽤这种持久化级别，会导致JVM的OOM内存溢出异常。

如果使⽤MEMORY_ONLY级别时发⽣了内存溢出，那么建议尝试使⽤MEMORY_ONLY_SER级别。该级别会将RDD数据序列化后再保存在内存中，此时每个partition仅仅是⼀个字节数组⽽已，⼤⼤减少了对象数量，并降低了内存占⽤。这种级别⽐MEMORY_ONLY多出来的性能开销，主要就是序列化与反序列化的开销。但是后续算⼦可以基于纯内存进⾏操作，因此性能总体还是⽐较⾼的。此外，可能发⽣的问题同上，如果RDD中的数据量过多的话，还是可能会导致OOM内存溢出的异常。

不要泄漏到磁盘，除⾮你在内存中计算需要很⼤的花费，或者可以过滤⼤量数据，保存部分相对重要的在内存中。否则存储在磁盘中计算速度会很慢，性能急剧降低。

后缀为_2的级别，必须将所有数据都复制⼀份副本，并发送到其他节点上，数据复制以及⽹络传输会导致较⼤的性能开销，除⾮是要求作业的⾼可⽤性，否则不建议使⽤。

Check Point 机制

除了使⽤缓存机制可以有效的保证RDD的故障恢复，但是如果缓存失效还是会在导致系统重新计算RDD的结果，所以对于⼀些RDD的lineage较⻓的场景，计算⽐较耗时，⽤户可以尝试使⽤checkpoint机制存储RDD的计算结果。

该种机制和缓存最⼤的不同在于，使⽤checkpoint之后被checkpoint的RDD数据直接持久化在⽂件系统中，⼀般推荐将结果写在hdfs中，这种checpoint并不会⾃动清空。

注意checkpoint在计算的过程中先是对RDD做mark，在任务执⾏结束后，再对mark的RDD实⾏checkpoint，也就是要重新计算被Mark之后的rdd的依赖和结果。

sc.setCheckpointDir("hdfs://CentOS:9000/checkpoints")
val rdd1 = sc.textFile("hdfs://CentOS:9000/demo/words/")
.map(line => {
 println(line)
})
//对当前RDD做标记
rdd1.checkpoint()
rdd1.collect()

因此在checkpoint⼀般需要和cache连⽤，这样就可以保证计算⼀次

sc.setCheckpointDir("hdfs://CentOS:9000/checkpoints")
val rdd1 = sc.textFile("hdfs://CentOS:9000/demo/words/")
.map(line => {
 println(line)
})
rdd1.persist(StorageLevel.MEMORY_AND_DISK) //先cache,保证后面在checkpoint时不必重新进行RDD转换
//对当前RDD做标记
rdd1.checkpoint()
rdd1.collect()
rdd1.unpersist()//删除缓存

spark的RDD计算详解

http://people.csail.mit.edu/matei/papers/2012/nsdi_spark.pdf

Spark 任务计算源码剖析

理论指导

sc.textFile("hdfs:///demo/words/t_word") //RDD0
 .flatMap(_.split(" ")) //RDD1
 .map((_,1)) //RDD2
 .reduceByKey(_+_) //RDD3 finalRDD
 .collect //Array 任务提交

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bGxiUp7v-1582287314652)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1582271261086.png)]$

通过分析以上的代码，我们不难发现Spark在执⾏任务前期，会根据RDD的转换关系形成⼀个任务执⾏DAG。将任务划分成若⼲个stage。Spark底层在划分stage的依据是根据RDD间的依赖关系划分。Spark将RDD与RDD间的转换分类： ShuffleDependency-宽依赖 | NarrowDependency-窄依赖，Spark如果发现RDD与RDD之间存在窄依赖关系，系统会⾃动将存在窄依赖关系的RDD的计算算⼦归纳为⼀个stage，如果遇到宽依赖系统开启⼀个新的stage.

Spark 宽窄依赖判断

宽依赖：⽗RDD的⼀个分区对应了⼦RDD的多个分区，出现分叉就认定为宽依赖。 ShuffleDependency

窄依赖：⽗RDD的1个分区（多个⽗RDD）仅仅只对应⼦RDD的⼀个分区认定为窄依赖。 OneToOneDependency | RangeDependency | PruneDependency

Spark在任务提交前期，⾸先根据finalRDD逆推出所有依赖RDD，以及RDD间依赖关系，如果遇到窄依赖合并在当前的stage中，如果是宽依赖开启新的stage。

源码追踪

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KpFdjVS6-1582287314654)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1582287145373.png)]$

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iNUeWhqC-1582287314655)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1582287178213.png)]$

getMissingParentStages

private def getMissingParentStages(stage: Stage): List[Stage] = {
    val missing = new HashSet[Stage]
    val visited = new HashSet[RDD[_]]
    // We are manually maintaining a stack here to prevent StackOverflowError
    // caused by recursively visiting
    val waitingForVisit = new ArrayStack[RDD[_]]
    def visit(rdd: RDD[_]) {
        if (!visited(rdd)) {
            visited += rdd
            val rddHasUncachedPartitions = getCacheLocs(rdd).contains(Nil)
            if (rddHasUncachedPartitions) {
                for (dep <- rdd.dependencies) {
                    dep match {
                        case shufDep: ShuffleDependency[_, _, _] =>
                        val mapStage = getOrCreateShuffleMapStage(shufDep, stage.firstJobId)
                        if (!mapStage.isAvailable) {
                            missing += mapStage
                        }
                        case narrowDep: NarrowDependency[_] =>
                        waitingForVisit.push(narrowDep.rdd)
                    }
                }
            }
        }
    }
    waitingForVisit.push(stage.rdd)
    while (waitingForVisit.nonEmpty) {
        visit(waitingForVisit.pop())
    }
    missing.toList
}

遇到宽依赖，系统会⾃动的创建⼀个 ShuffleMapStage

submitMissingTasks

private def submitMissingTasks(stage: Stage, jobId: Int) {

    //计算分区
    val partitionsToCompute: Seq[Int] = stage.findMissingPartitions()
    ...
    //计算最佳位置
    val taskIdToLocations: Map[Int, Seq[TaskLocation]] = try {
        stage match {
            case s: ShuffleMapStage =>
            partitionsToCompute.map { id => (id, getPreferredLocs(stage.rdd,
                                                                  id))}.toMap
            case s: ResultStage =>
            partitionsToCompute.map { id =>
                val p = s.partitions(id)
                (id, getPreferredLocs(stage.rdd, p))
            }.toMap
        }
    } catch {
        case NonFatal(e) =>
        stage.makeNewStageAttempt(partitionsToCompute.size)
        listenerBus.post(SparkListenerStageSubmitted(stage.latestInfo, properties))
        abortStage(stage, s"Task creation failed: $e\n${Utils.exceptionString(e)}",
                   Some(e))
        runningStages -= stage
        return
    }
    //将分区映射TaskSet
    val tasks: Seq[Task[_]] = try {
        val serializedTaskMetrics =
        closureSerializer.serialize(stage.latestInfo.taskMetrics).array()
        stage match {
            case stage: ShuffleMapStage =>
            stage.pendingPartitions.clear()
            partitionsToCompute.map { id =>
                val locs = taskIdToLocations(id)
                val part = partitions(id)
                stage.pendingPartitions += id
                new ShuffleMapTask(stage.id, stage.latestInfo.attemptNumber,
                                   taskBinary, part, locs, properties, serializedTaskMetrics,
                                   Option(jobId),
                                   Option(sc.applicationId), sc.applicationAttemptId,
                                   stage.rdd.isBarrier())
            }
            case stage: ResultStage =>
            partitionsToCompute.map { id =>
                val p: Int = stage.partitions(id)
                val part = partitions(p)
                val locs = taskIdToLocations(id)
                new ResultTask(stage.id, stage.latestInfo.attemptNumber,
                               taskBinary, part, locs, id, properties, serializedTaskMetrics,
                               Option(jobId), Option(sc.applicationId), sc.applicationAttemptId,
                               stage.rdd.isBarrier())
            }
        }
    } catch {
        case NonFatal(e) =>
        abortStage(stage, s"Task creation failed: $e\n${Utils.exceptionString(e)}",
                   Some(e))
        runningStages -= stage
        return
    }
    //调⽤taskScheduler#submitTasks TaskSet
    if (tasks.size > 0) {
        logInfo(s"Submitting ${tasks.size} missing tasks from $stage (${stage.rdd})
(first 15 " +
                s"tasks are for partitions ${tasks.take(15).map(_.partitionId)})")
        taskScheduler.submitTasks(new TaskSet(
            tasks.toArray, stage.id, stage.latestInfo.attemptNumber, jobId, properties))
    }
    ...
}

总结关键字：逆推、finalRDD、ResultStage 、Shu!leMapStage、Shu!leMapTask、ResultTask、Shu!leDependency、NarrowDependency、DAGScheduler、TaskScheduler、SchedulerBackend、
t(
tasks.toArray, stage.id, stage.latestInfo.attemptNumber, jobId, properties))
}
…
}


总结关键字：逆推、finalRDD、ResultStage 、Shu!leMapStage、Shu!leMapTask、ResultTask、Shu!leDependency、NarrowDependency、DAGScheduler、TaskScheduler、SchedulerBackend、
DAGSchedulerEventProcessLoop

策马出凉州

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RDD进阶（章节三）

RDD进阶（章节三）分析WordCountsc.textFile("hdfs:///demo/words/t_word") //RDD0 .flatMap(_.split(" ")) //RDD1 .map((_,1)) //RDD2 .reduceByKey(_+_) //RDD3 finalRDD .collect //Array 任务提交RDD都有哪...
复制链接

扫一扫

专栏目录