spark源码学习（五）:stage的划分和task的创建
spark源码学习（五）:stage的划分和task的创建
上一篇blog简单的阐述了和Resultstage和ActiveJob创建相关的源码，在这里我们接着上次没说完的submitStage，getMissingParentStages,submitMissingTasks两个函数开始.后面的这两个函数是在第一个函数里面调用的。
submitStage的代码在上一篇已经贴出来啦，首先来看看那个getMissingParentStages是什么:
private def getMissingParentStages(stage: Stage): List[Stage] = {
val missing = new HashSet[Stage]//保存没有被访问过的Stage
val visited = new HashSet[RDD[_]]//保存已经访问过的RDD
//手动的维护栈就是为了防止内存泄漏
val waitingForVisit = new Stack[RDD[_]]
def visit(rdd: RDD[_]) {
if (!visited(rdd)) {
visited += rdd
if (getCacheLocs(rdd).contains(Nil)) {//会缓存RDD到内存去，会加快访问速度
for (dep <- rdd.dependencies) {
dep match {
case shufDep: ShuffleDependency[_, _, _] =>
val mapStage = getShuffleMapStage(shufDep, stage.jobId)
if (!mapStage.isAvailable) {
missing += mapStage
}
case narrowDep: NarrowDependency[_] =>
waitingForVisit.push(narrowDep.rdd)
}
}
}
}
}
waitingForVisit.push(stage.rdd)
while (waitingForVisit.nonEmpty) {
visit(waitingForVisit.pop())//递归的调用visit函数
}
missing.toList
}
上面的函数中有一个getCacheLocs函数的使用，主要作用就是把当前的RDD进行cache放到内存来加快访问的速度。具体操作就是如果rdd已经cache就返回cache的位置，否则就执行cache操作：
为了更加明白上面的那个函数，我们来看看这个变量cacheLocs吧，源码中的注释还挺详细的：
说的很明白，id就是所对应RDD的id，而values对应的是已经缓存之后每个rdd的partitions分别存放的位置。
(1)函数后面的contains(Nil)也就是为了容错处理吧，因为完整的队列后面都是以Nil结尾的嘛。在得到RDD的父依赖之后，依据依赖类型的不同对应不同的操作。如果是shuffle依赖就会得到一个新的stage叫做shuffleMapStage,如下：
最核心的 newOrUsedShuffleStage就是用来创建一个新的shuffleMapStage的，具体的就不去深究啦。
(2)如果是窄依赖的话，就把当前的RDD放到waitingForVist的栈中，之后每次都会pop得到栈顶的RDD在进行同样的模式匹配工作，知道访问到最前面的那个RDD为止(当前stage的最前面的那个RDD)。我们会发现和stage相关的代码都是相同的code架构，对吧
说到这里，上面的getMissingParentStages就介绍完毕，下面继续来看看submitMissingTasks:这是重头戏
/** Called when stage's parents are available and we can now do its task. */
private def submitMissingTasks(stage: Stage, jobId: Int) {
logDebug("submitMissingTasks(" + stage + ")")
// Get our pending tasks and remember them in our pendingTasks entry
stage.pendingTasks.clear()
// First figure out the indexes of partition ids to compute.
val partitionsToCompute: Seq[Int] = {
stage match {
case stage: ShuffleMapStage =>
(0 until stage.numPartitions).filter(id => stage.outputLocs(id).isEmpty)
case stage: ResultStage =>
val job = stage.resultOfJob.get
(0 until job.numPartitions).filter(id => !job.finished(id))
}
}
....省略
val properties = jobIdToActiveJob.get(stage.jobId).map(_.properties).orNull
runningStages += stage
var taskBinary: Broadcast[Array[Byte]] = null
try {//不同的依赖不同的序列化机制
// For ShuffleMapTask, serialize and broadcast (rdd, shuffleDep).
// For ResultTask, serialize and broadcast (rdd, func).
val taskBinaryBytes: Array[Byte] = stage match {
case stage: ShuffleMapStage =>
closureSerializer.serialize((stage.rdd, stage.shuffleDep): AnyRef).array()
case stage: ResultStage =>
closureSerializer.serialize((stage.rdd, stage.resultOfJob.get.func): AnyRef).array()
}
taskBinary = sc.broadcast(taskBinaryBytes)
} catch {.....}
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 {...}
这个时候才会发现任务才是任务的创建，也就是说只有在全部的stage提交之后，才会去提交task的时候创建与之相对应的task，我们可以看到，task是在每个RDD所对应的partition上面去创建的是吧。(●'◡'●)至于shuffleMapTask和resultTask的创建，在这里就不说啦，以后有空再看看。到这里仅仅是涉及task相关的创建，关键是task如何提交和运行的呢？哈哈代码还没完。
这里就是就可以看到，就是taskScheduler把我们上面创建的tasks封装到一个taskSet中，然后再经过submitTask把任务提交给集群就可啦。具体的我们下次再看啦。