Spark1.3从创建到提交：4)资源分配源码分析

接着上一节Master里case RegisterApplication最后的一个资源调度方法schedule() ，假如我提交的任务需要6G,10Cores，而集群的部署如下所示：

Spark提供了2种资源分配的策略，一种是尽量分散(spreadOut，默认)，一种是尽量集中，具体看下这个Master.schedule方法(源码位置555行)

分散策略

  //在当前等待队列waitingApps中还存在未执行的app并且它要求的cores数还未被满足 
  for (app <- waitingApps if app.coresLeft > 0) {
	//在集群的Worker节点中过滤出可用的(当前worker的内存大于App请求的内存，且之前没有执行过该任务)Worker节点
	val usableWorkers = workers.toArray.filter(_.state == WorkerState.ALIVE)
	  .filter(canUse(app, _)).sortBy(_.coresFree).reverse
	//可用Worker节点的长度 
	val numUsable = usableWorkers.length 
	//记录usableWorkers节点已经为该App分配的核心数
	val assigned = new Array[Int](numUsable) 
	//在App剩下核心数需求和所有可用的Worker核心总中，取较小的值
	var toAssign = math.min(app.coresLeft, usableWorkers.map(_.coresFree).sum)
	var pos = 0
	while (toAssign > 0) {
	  if (usableWorkers(pos).coresFree - assigned(pos) > 0) { //当前usableWorker可用核心数还能继续分配
		toAssign -= 1
		assigned(pos) += 1 //当前worker节点分配数+1
	  }
	  pos = (pos + 1) % numUsable //循环列表
	}
	//每个可用的Worked节点都应该分配多少核给该App已经计算出来保存在assigned中，下面进行启动Executor
	for (pos <- 0 until numUsable) {
	  if (assigned(pos) > 0) {
		val exec = app.addExecutor(usableWorkers(pos), assigned(pos))
		launchExecutor(usableWorkers(pos), exec)
		app.state = ApplicationState.RUNNING
	  }
	}
  }

集中策略

  //当前Worker节点可用并且可用核心数大于0
  for (worker <- workers if worker.coresFree > 0 && worker.state == WorkerState.ALIVE) {
	//在当前等待队列waitingApps中还存在未执行的app并且它要求的cores数还未被满足 
	for (app <- waitingApps if app.coresLeft > 0) {
	  //当前worker的内存大于App请求的内存，且之前没有执行过该任务
	  if (canUse(app, worker)) {
		//在Worker节点可用核心数和App请求核心数中，取较小的值
		val coresToUse = math.min(worker.coresFree, app.coresLeft)
		if (coresToUse > 0) {
		  //在该worker节点上启动Executor进行
		  val exec = app.addExecutor(worker, coresToUse)
		  launchExecutor(worker, exec)
		  app.state = ApplicationState.RUNNING
		}
	  }
	}
  }

下面比较这2种策略

分散策略：不断地轮询可用的worker节点，每次分别请求分别1个核心数，直至满足其需求。

集中策略：轮询可用的worker节点，若当前worker节点可满足App核心请求，则一次分配完所需核心数；若不满足，也把该worker节点剩下的核心榨干，接下来榨取剩下的worker直到满足她的需求为止