JobTracker任务调度器之JobQueueTaskScheduler
在客户端把作业提交给JobTracker节点之后，JobTracker节点就可以使用任务调度器TaskScheduler将这个Job的任务分配给那些合适的TaskTracker节点来执行。当然在JobTracker调度该Job之前，必须要确保该Job的JobInProgress被初始化了，即将Job划分为若干个map任务和reduce任务。在JobTracker中有一个基于优先级的FIFO任务调度器JobQueueTaskScheduler。对于目前的Hadoop任务调度设计来看，它是一个“拉”的过程，即每一个TaskTracker节点主动向JobTracker节点请求作业的任务，而不是当有新作业的时候，JobTracker节点主动给TaskTracker节点分配任务。先来看看它的类图：
在上面的类图中，我们可以看出JobQueueTaskScheduler类依赖于两个JobInProgressListener的实现类，其中JobQueueJobInProgressListener类被用来按照优先级队列的方式来管理Job，EagerTaskInitializationListener类被用来初始化Job，即对Job进行map任务和reduce任务的切分。关于这两个JobInProgressListener类的具体实现，我在这里不再作详细的阐述，因为我将会在以后专门进行详细地讨论，有兴趣的童鞋可以自己查先研究它的源代码。所以，当JobTracker给某个TaskTracker分配任务时，它就会调用TaskScheduler的assignTasks(TaskTrackerStatus)方法，让TaskScheduler给该TaskTracker分配任务。那么，究竟TaskScheduler是如何给TaskTracker任务分配任务的，这就得看TaskScheduler的具体实现了，Hadoop允许用户自定义TaskScheduler来根据自己的实际情况来调度Job任务，这个具体实现可以通过配置文件中的mapred.jobtracker.taskScheduler项来设置。TaskScheduler开放给了用户四个可用的方法：
/*开始任务调度器*/
public void start() throws IOException {
// do nothing
}
/*关闭任务调度器*/
public void terminate() throws IOException {
// do nothing
}
/*给一个TaskTracker节点分配若干个任务*/
public abstract List<Task> assignTasks(TaskTrackerStatus taskTracker) throws IOException;
/*获取属于某一个队列的所有JobInProgress*/
public abstract Collection<JobInProgress> getJobs(String queueName);
下面以JobQueueTaskScheduler为例，来详细的讨论如何给一个TaskTracker分配任务。
1.分配map任务
无论怎样，任务调度器JobQueueTaskScheduler总是按照优先级的FIFO来调度每一个Job的Map任务，但对于每一个Job，它只给一次机会，也就是说它顶多只调度该Job的一个Map任务，然后就再调度其它Job的一个Map任务给当前的TaskTracker节点，同时优先分配一个Job的本地任务，当给当前的TaskTracker节点分配了一个非本地任务时，任务调度器JobQueueTaskScheduler就不会再给该TaskTracker节点分配Map任务了，尽管该TaskTracker节点还有空闲的Map Slot。这主要考虑到TaskTracker节点执行非本地任务的代价(CPU不是主要的，关键是网络带宽)。
2.分配reduce任务
给一个计算节点分配map/reduce任务的源代码如下：
/**
* 给一个计算节点分配若干个任务
*/
public synchronized List<Task> assignTasks(TaskTrackerStatus taskTracker)throws IOException {
ClusterStatus clusterStatus = taskTrackerManager.getClusterStatus();
final int numTaskTrackers = clusterStatus.getTaskTrackers(); //当前集群可用的计算节点数量
final int clusterMapCapacity = clusterStatus.getMaxMapTasks(); //当前集群执行map任务的总计算能力(Map Slot的总数量)
final int clusterReduceCapacity = clusterStatus.getMaxReduceTasks(); //当前集群执行reduce任务的总计算能力(Reduce Slot的总数量)
//当前集群待调度的作业队列
Collection<JobInProgress> jobQueue = jobQueueJobInProgressListener.getJobQueue();
// Get map + reduce counts for the current tracker.
final int trackerMapCapacity = taskTracker.getMaxMapTasks(); //当前计算节点执行map任务的总计算能力(Map Slot的最大数量)
final int trackerReduceCapacity = taskTracker.getMaxReduceTasks(); //当前计算节点执行reduce任务的总计算能力(Reduce Slot的最大数量)
final int trackerRunningMaps = taskTracker.countMapTasks(); //当前计算节点正在使用的map计算能力(正在使用Map Slot执行map任务的数量)
final int trackerRunningReduces = taskTracker.countReduceTasks(); //当前计算节点正在使用的reduce计算能力(正在使用Reduce Slot执行reduce任务的数量)
//用来存储给该计算节点分配的任务
List<Task> assignedTasks = new ArrayList<Task>();
int remainingReduceLoad = 0; //当前集群执行map尚需的计算能力
int remainingMapLoad = 0; //当前集群执行reduce尚需的计算能力
//通过所有正在执行的作业情况，统计当前尚需的计算能力
synchronized (jobQueue) {
for (JobInProgress job : jobQueue) {
if (job.getStatus().getRunState() == JobStatus.RUNNING) {
remainingMapLoad += (job.desiredMaps() - job.finishedMaps());
//当前作业是否可以开始调度reduce任务
if (job.scheduleReduces()) {
remainingReduceLoad += (job.desiredReduces() - job.finishedReduces());
}
}
}
}
LOG.debug("There are "+remainingMapLoad+" running/pending map tasks and "+remainingReduceLoad+" running/pending reduce tasks in the cluster now!");
//计算当前map任务的负载
double mapLoadFactor = 0.0;
if(clusterMapCapacity > 0) {
mapLoadFactor = (double)remainingMapLoad / clusterMapCapacity;
}
//计算当前reduce任务的负载
double reduceLoadFactor = 0.0;
if (clusterReduceCapacity > 0) {
reduceLoadFactor = (double)remainingReduceLoad / clusterReduceCapacity;
}
//基于当前集群map任务的负载及当前节点节点的总计算能力，估算此时其应该使用的计算能力
final int trackerCurrentMapCapacity = Math.min((int)Math.ceil(mapLoadFactor * trackerMapCapacity), trackerMapCapacity);
//计算当前计算节点剩余的计算能力
int availableMapSlots = trackerCurrentMapCapacity - trackerRunningMaps;
boolean exceededMapPadding = false;
if(availableMapSlots > 0) {
exceededMapPadding = exceededPadding(true, clusterStatus, trackerMapCapacity);
}
int numLocalMaps = 0;
int numNonLocalMaps = 0;
if(availableMapSlots > 0) LOG.debug("Try to assign "+availableMapSlots+" map tasks to TaskTracker["+taskTracker.trackerName+"]..");
else LOG.debug("Can not assign map tasks to TaskTracker["+taskTracker.trackerName+"], because it doesn't have any free map slot or it is overloaded.");
scheduleMaps:
for (int i=0; i < availableMapSlots; ++i) {
synchronized (jobQueue) {
for (JobInProgress job : jobQueue) {
if (job.getStatus().getRunState() != JobStatus.RUNNING) {
continue;
}
Task t = null;
//尝试给当前计算节点分配一个本地map任务
t = job.obtainNewLocalMapTask(taskTracker, numTaskTrackers,taskTrackerManager.getNumberOfUniqueHosts());
if(t != null) {
LOG.debug("assign a local map Task["+t.getTaskID()+"] to TaskTracker["+taskTracker.trackerName+"]");
assignedTasks.add(t);
++numLocalMaps;
//需要当前计算节点保留部分map计算能力，所以结束对当前计算节点的map任务分配
if(exceededMapPadding) {
break scheduleMaps;
}
break;
}
//尝试给当前计算节点分配一个非本地map任务，如果分配成功则结束对该节点的map任务分配，
//以避免它抢走了其它计算节点的本地map任务
t = job.obtainNewNonLocalMapTask(taskTracker, numTaskTrackers,taskTrackerManager.getNumberOfUniqueHosts());
if(t != null) {
assignedTasks.add(t);
++numNonLocalMaps;
break scheduleMaps;
}
}//for
}
}//for
int assignedMaps = assignedTasks.size();
//基于当前集群reduce任务的负载及当前节点节点的总计算能力，估算此时其应该使用的reduce计算能力
final int trackerCurrentReduceCapacity = Math.min((int)Math.ceil(reduceLoadFactor * trackerReduceCapacity), trackerReduceCapacity);
//计算当前节点剩余的reduce计算能力
final int availableReduceSlots = Math.min((trackerCurrentReduceCapacity - trackerRunningReduces), 1);
boolean exceededReducePadding = false;
if(availableReduceSlots > 0) {
exceededReducePadding = exceededPadding(false, clusterStatus, trackerReduceCapacity);
//给当前计算节点至多分配一个reduce任务
synchronized (jobQueue) {
LOG.debug("try to assign 1 reduce task to TaskTracker["+taskTracker.trackerName+"]..");
for (JobInProgress job : jobQueue) {
if (job.getStatus().getRunState() != JobStatus.RUNNING || job.numReduceTasks == 0) {
continue;
}
//尝试给当前计算节点分配一个reduce任务
Task t = job.obtainNewReduceTask(taskTracker, numTaskTrackers, taskTrackerManager.getNumberOfUniqueHosts());
//reduce任务分配成功，所以结束对当前计算节点的reduce任务分配
if(t != null) {
assignedTasks.add(t);
break;
}
//reduce任务分配失败，但需要当前计算节点保留部分reduce计算能力，所以结束对当前计算节点的reduce任务分配
if(exceededReducePadding) {
break;
}
}//for
}
}
if (LOG.isDebugEnabled()) {
LOG.debug("Task assignments for " + taskTracker.getTrackerName() + " --> " +
"[" + mapLoadFactor + ", " + trackerMapCapacity + ", " +
trackerCurrentMapCapacity + ", " + trackerRunningMaps + "] -> [" +
(trackerCurrentMapCapacity - trackerRunningMaps) + ", " +
assignedMaps + " (" + numLocalMaps + ", " + numNonLocalMaps +
")] [" + reduceLoadFactor + ", " + trackerReduceCapacity + ", " +
trackerCurrentReduceCapacity + "," + trackerRunningReduces +
"] -> [" + (trackerCurrentReduceCapacity - trackerRunningReduces) +
", " + (assignedTasks.size()-assignedMaps) + "]");
}
return assignedTasks;
}
3.计算一个TaskTracker节点是否需要保留部分计算能力(Map/Reduce Slots)
在任务调度器JobQueueTaskScheduler的实现中，如果在集群中的TaskTracker节点比较多的情况下，它总是会想办法让若干个TaskTracker节点预留一些空闲的slots(计算能力)，以便能够快速的处理优先级比较高的Job的Task或者发生错误的Task，以保证已经被调度的作业的完成。它的具体实现如下：
/**
* 预留计算能力的集群最小规模
*/
private static final int MIN_CLUSTER_SIZE_FOR_PADDING = 3;
/**
* 判断当前集群是否需要预留一部分map/reduce计算能力来执行那些失败的、紧急的或特殊的任务
*/
private boolean exceededPadding(boolean isMapTask, ClusterStatus clusterStatus, int maxTaskTrackerSlots) {
//当前集群可用的计算节点数量
int numTaskTrackers = clusterStatus.getTaskTrackers();
//当前集群正在执行的map/reduce任务总数量
int totalTasks = (isMapTask) ? clusterStatus.getMapTasks() : clusterStatus.getReduceTasks();
//当前集群执行的map/reduce任务的总计算能力
int totalTaskCapacity = isMapTask ? clusterStatus.getMaxMapTasks() : clusterStatus.getMaxReduceTasks();
//当前集群待调度的作业队列
Collection<JobInProgress> jobQueue = jobQueueJobInProgressListener.getJobQueue();
boolean exceededPadding = false; //当前集群应该预留的计算能力
synchronized (jobQueue) {
int totalNeededTasks = 0;
for(JobInProgress job : jobQueue) {
if(job.getStatus().getRunState() != JobStatus.RUNNING || job.numReduceTasks == 0) {
continue;
}
//统计当前集群的map/reduce计算需求，计算应该预留多少map/reduce计算力
totalNeededTasks += isMapTask ? job.desiredMaps() : job.desiredReduces();
int padding = 0;
if(numTaskTrackers > MIN_CLUSTER_SIZE_FOR_PADDING) {
padding = Math.min(maxTaskTrackerSlots, (int) (totalNeededTasks * padFraction));
}
//当前集群剩余的map/reduce计算能力不足预留的，则让当前计算节点预留一部分map/reduce计算能力
if(totalTasks + padding >= totalTaskCapacity) {
exceededPadding = true;
break;
}
}//for
}
return exceededPadding;
}
其中，全局变量padFraction的默认值为0.01，也可通过配置文件中的mapred.jobtracker.taskalloc.capacitypad项来设置。还要值得说明的是，任务调度器TaskScheduler只负责调度作业的正式Map/Reduce任务，而作业的其它辅助任务都是交由JobTracker来调度的，如JobSetup、JobCleanup、TaskCleanup任务等。这一点是非常值得用户在自定义任务调度器的时候注意的。对于JobQueueTaskScheduler的任务调度实现原则可总结如下：
1.先调度优先级高的作业，统一优先级的作业则先进先出；
2.尽量使集群每一个TaskTracker达到负载均衡(这个均衡是task数量上的而不是实际的工作强度)；
3.尽量分配作业的本地任务给TaskTracker，但不是尽快分配作业的本地任务给TaskTracker，最多分配一个非本地任务给TaskTracker(一是保证任务的并发性，二是避免有些TaskTracker的本地任务被偷走)，最多分配一个reduce任务；
4.为优先级或者紧急的Task预留一定的slot；