FairScheduler(公平调度器)的源码阅读

FairScheduler 是 hadoop 中的作业公平调度器，主要是解决当 TT 发送心跳告诉 JT 当前的空闲 slots 时，希望 JT 分配给 TT 相应多个 task ，让 TT 去执行这些 task 。所以 JT 就需要一个调度器来对作业进行调度，选择出作业，然后将作业的 task 分配 TT 去执行。

而 hadoop 中的 task 可以分为 map,reduce,jobsetup,jobcleanup,taskcleanup 这五种 task 。

关于 setup,cleanup task 的信息在

https://issues.apache.org/jira/browse/MAPREDUCE-463 ， hadoop-5785

分别是为 job 做准备工作，为 job 做清理工作，清理 task 工作。

一个 job 初始化时，依次产生 map task,reduce task,steup and cleanup task 。

Setup,cleanup 分别有二个，对应于 map 和 reduce 的。

比如 jobcleanup 工作主要是删除输出的临时文件夹，因为 mapreduce 为了保证正确性，数据会先写到输出文件夹下面的 _temporary 文件下 , 如果正确执行的话，最终会将临时文件夹下的数据重命名为真正的输出文件夹下，而这个重命名在 hadoop 中的代价比较小。

Jobstepup 的原理也是一样，即先创建起相应的输出的临时文件夹，用于数据存储。

那么到底分配哪个 job 中的 map,reduce task 给 TT 去执行呢？这就是调度器要做的事情。

首先将用户分成多个组，每个组中的用户是相互独立的，每个组都有一定的容量大小，并且有实际的 slots 数目，根据这些来决定当前哪个组可以分配 task ，然后再到该组中的选择一个用户的 job 来分配。

FairScheduler

继承了 TaskScheduler 类。主有要变量 Configuration, TaskTrackerManager 二个变量，另外有方法：start(),terminate(),assignTasks(TaskTracker) 。

Start : 是由Jobtracker 启动的调用它，用来初始化调度器。

terminate() ：停止工作。

assignTasks(TaskTracker) ：为某个TT 分配task 队列。

Start

首先，创建日志监听器 eventLog = new FairSchedulerEventLog(); 将调度器的动作写到日志中，用于为后面决策作分析。

添加二个job 监听对象。

  taskTrackerManager .addJobInProgressListener( jobListener );

      if (! mockMode ) {

        eagerInitListener = new EagerTaskInitializationListener(conf);

        eagerInitListener .setTaskTrackerManager( taskTrackerManager );

        eagerInitListener .start();

        taskTrackerManager .addJobInProgressListener( eagerInitListener );

      }

JobListener 对象是从调度器中添加或删除job ，继续JobInProgressListener 接口的方法。

public void jobAdded(JobInProgress job) {       synchronized (FairScheduler. this ) {         eventLog .log( "JOB_ADDED" , job.getJobID());         JobInfo info = new JobInfo( new JobSchedulable(FairScheduler. this , job, TaskType. MAP ),             new JobSchedulable(FairScheduler. this , job, TaskType. REDUCE ));         infos .put(job, info);         poolMgr .addJob(job); // Also adds job into the right PoolScheduable         update();       }     }

EagerTaskInitializationListener 对象启动了一个线程池来对job 队列进行实始化工作。

接下来创建组管理和对TT 的负载管理，最后初始化一些环境参数。

poolMgr = new PoolManager( this );       poolMgr .initialize();       loadMgr = (LoadManager) ReflectionUtils.newInstance (           conf.getClass( "mapred.fairscheduler.loadmanager" ,               CapBasedLoadManager. class , LoadManager. class ), conf);       loadMgr .setTaskTrackerManager( taskTrackerManager );       loadMgr .setEventLog( eventLog );       loadMgr .start();

最后是启动一个 UpdateThread 的守护线程，另外创建好 servlet ，提供给给用户实时查看相关的调度信息。

if (! mockMode ) {         new UpdateThread ().start();       }     // Register servlet with JobTracker's Jetty server       if ( taskTrackerManager instanceof JobTracker) {         JobTracker jobTracker = (JobTracker) taskTrackerManager ;         HttpServer infoServer = jobTracker. infoServer ;         infoServer.setAttribute( "scheduler" , this );         infoServer.addServlet( "scheduler" , "/scheduler" ,             FairSchedulerServlet. class );       }

UpdateThread 线程每隔 mapred.fairscheduler.update.interval 时间去计算调度的相关参数，如每个job 权重，公平性，当前运行的数目等。

然后就是将当前的job 运行参数dump 到log 中，用于分析和决策。

计算需要被抢占的task 数目。

public void run() {       while ( running ) {         try {           Thread.sleep ( updateInterval );           update();            dumpIfNecessary();           preemptTasksIfNecessary();         } catch (Exception e) {           LOG .error( "Exception in fair scheduler UpdateThread" , e);         }       }     }   }

 

JobListener jobAdded()

当jobtracker 有job 提交后，该方法会被调用。

将job 信息存到map 中，同时调用组管理器将job 加入到组中，

最后调用update() 方法更新调度器中的相关参数。

public void jobAdded(JobInProgress job) {       synchronized (FairScheduler. this ) {         eventLog .log( "JOB_ADDED" , job.getJobID());         JobInfo info = new JobInfo( new JobSchedulable(FairScheduler. this , job, TaskType. MAP ),             new JobSchedulable(FairScheduler. this , job, TaskType. REDUCE ));         infos .put(job, info);         poolMgr .addJob(job); // Also adds job into the right PoolScheduable         update() ;       }     }

 

assignTasks()

根据每个组的情况，计算出当前集群的map,reduce 运行数目。

for (Pool pool: poolMgr .getPools()) {       runnableMaps += pool.getMapSchedulable().getDemand();       runningMaps += pool.getMapSchedulable().getRunningTasks();       runnableReduces += pool.getReduceSchedulable().getDemand();        runningReduces += pool.getReduceSchedulable().getRunningTasks();     }

得到集群中所有 TT 加起来总的 map,reduce 的 slots 数目。

int totalMapSlots = getTotalSlots(TaskType. MAP , clusterStatus);     int totalReduceSlots = getTotalSlots(TaskType. REDUCE , clusterStatus);

利用排序算法对各个组进行排序。

// Get the map or reduce schedulables and sort them by fair sharing       List<PoolSchedulable> scheds = getPoolSchedulables(taskType);       Collections.sort (scheds, new SchedulingAlgorithms.FairShareComparator());

对于排好序的组遍历，获得相应的 map,reduce 的 task 。而在调用组的 assignTask() 方法时，会先对组内的 job 队列应用调度算法进行排序，然后再选择一个 job ，调用该 job 的 assignTask() 方法，这样就可以得到某个 job 的 task 任务了。

for (Schedulable sched: scheds) { // This loop will assign only one task         eventLog .log( "INFO" , "Checking for " + taskType +             " task in " + sched.getName());         Task task = taskType == TaskType. MAP ?                     sched.assignTask(tts, currentTime, visitedForMap) :                     sched.assignTask(tts, currentTime, visitedForReduce);         if (task != null ) {            foundTask = true ;           JobInProgress job = taskTrackerManager .getJob(task.getJobID());           eventLog .log( "ASSIGN" , trackerName, taskType,               job.getJobID(), task.getTaskID());           // Update running task counts, and the job's locality level           if (taskType == TaskType. MAP ) {             launchedMap.add(job);             mapsAssigned++;             runningMaps++;             updateLastMapLocalityLevel(job, task, tts);           } else {             reducesAssigned++;              runningReduces++;           }           // Add task to the list of assignments           tasks.add(task);           break ; // This break makes this loop assign only one task         } // end if(task != null)       } // end for(Schedulable sched: scheds)

 

update()

这个方法是一个很重要的方法，就是用来 更新公平调度器的相关参数。

如：读取最新的配置参数，删除已经完成或者被kill 掉的job 。

更新job,pool 的最新需求。

计算每个组的map,reduce 的公平性。

更新每个组的时间优先级顺序。

当要将 job 加入到调度器时，以及调度器每隔一段时间会调用这个方法，去更新公平调度器的相关信息。分别在 JobListener 类中的jobAdded() 方法和UpdateThread 守护线程中调用。

 

PoolManager

管理调度中的所有组，即 Pool 。

记录调度中的每个组，一种映射关系，即组名与组对象。

private Map<String, Pool> pools = new HashMap<String, Pool>();

 

addJob(JobInProgress job)

当有job 来了，就将其加入到相应的组中。

public synchronized void addJob(JobInProgress job) {     getPool(getPoolName(job)).addJob(job);   }

如果该组存在，则直接得到 Pool 对象，然后将 job 加入到组中。

如果组不存在，则创建一个 Pool 对象，将 job 加入到组后，再将组加入到组管理对象的队列中。

public synchronized Pool getPool(String name) {     Pool pool = pools .get(name);     if (pool == null ) {       pool = new Pool( scheduler , name);       pool.setSchedulingMode( defaultSchedulingMode );       pools .put(name, pool);     }     return pool;   }

reloadAllocs()

 

reloadAllocsIfNecessary()

 

Pool

组名，该组中的job, 以及组内的map,reduce task 的调度算法。

保存该组的job 队列。

private Collection<JobInProgress> jobs = new ArrayList<JobInProgress>();

该组的调度算法。

  /** Scheduling mode for jobs inside the pool (fair or FIFO) */

  private SchedulingMode schedulingMode ;

组的map,reduce 调度。

  private PoolSchedulable mapSchedulable ;

  private PoolSchedulable reduceSchedulable ;

 

addJob()

就是将job 加入到组队列，以及组的调度中。

public void addJob(JobInProgress job) {     jobs .add(job);     mapSchedulable .addJob(job);     reduceSchedulable .addJob(job);   }

 

PoolSchedulable

负责管理组内 job 的 map,reduce 调度问题。

实现了Schedulable 接口。

主要负责三件事情：

实现了assignTask() 接口，从多个组中分配task 给TT 。

提供了job/pool 信息给调度器，包括当前需求数，当前运行数，每个组的最小共享数，job/pool 的权重以及起始时间，优先级等。

同时对于每个用户来适用于公平调度算法。

addJob(JobInProgress)

PoolSchedulable 分为map 和reduce 二种，在Pool 构造时建立起来。

public Pool(FairScheduler scheduler, String name) {     this . name = name;     mapSchedulable = new PoolSchedulable(scheduler, this , TaskType. MAP );     reduceSchedulable = new PoolSchedulable(scheduler, this , TaskType. REDUCE );   }

 

assignTask()

当公平调度选择了该组后，具体选择组内的哪个 job ，就由 PoolSchedulable 的该方法来完成。

仔细研读一下，步骤如下：

首先得到该组当前运行的 task 数目，如果当前运行数目大于公平调度给的最大 slots 数，那么返回 null 。

否则可以从该组中分配任务，得到该组的调度方式，有二种： FIFO,FAIR 。这个方式是针对 job 来说的。

然后将调度方式应用于当前的组内的所有 JobSchedulable 队列中的job 。

最后遍历所有 JobSchedulable 队列，调用job 的JobSchedulable 对象中的assignTask 方法，从job 中获得task 。

public Task assignTask(TaskTrackerStatus tts, long currentTime,       Collection<JobInProgress> visited) throws IOException {      int runningTasks = getRunningTasks();     if (runningTasks >= poolMgr .getMaxSlots( pool .getName(), taskType )) {       return null ;     }     SchedulingMode mode = pool .getSchedulingMode();     Comparator<Schedulable> comparator;     if (mode == SchedulingMode. FIFO ) {       comparator = new SchedulingAlgorithms .FifoComparator();     } else if (mode == SchedulingMode. FAIR ) {       comparator = new SchedulingAlgorithms.FairShareComparator();     } else {       throw new RuntimeException( "Unsupported pool scheduling mode " + mode);     }     Collections.sort ( jobScheds , comparator);     for (JobSchedulable sched: jobScheds ) {       Task task = sched.assignTask (tts, currentTime, visited);       if (task != null )         return task;     }     return null ;   }

 

 

JobSchedulable

Job 的调度管理。

主要变量有：

  公平调度对象，job 对象，task 类型，有map,reduce 二种。

private FairScheduler scheduler ;   private JobInProgress job ;   private TaskType taskType ;   private int demand = 0;

assignTask （）

就是从该job 中，获得相应的map,reduce task 。

public Task assignTask(TaskTrackerStatus tts, long currentTime,       Collection<JobInProgress> visited) throws IOException {     if (isRunnable()) {       visited.add( job );       TaskTrackerManager ttm = scheduler . taskTrackerManager ;       ClusterStatus clusterStatus = ttm.getClusterStatus();       int numTaskTrackers = clusterStatus.getTaskTrackers();         // check with the load manager whether it is safe to       // launch this task on this taskTracker.       LoadManager loadMgr = scheduler .getLoadManager();       if (!loadMgr.canLaunchTask(tts, job , taskType )) {         return null ;       }       if ( taskType == TaskType. MAP ) {         LocalityLevel localityLevel = scheduler .getAllowedLocalityLevel(             job , currentTime);         scheduler .getEventLog().log(              "ALLOWED_LOC_LEVEL" , job .getJobID(), localityLevel);         // obtainNewMapTask needs to be passed 1 + the desired locality level         return job .obtainNewMapTask(tts, numTaskTrackers,             ttm.getNumberOfUniqueHosts(), localityLevel.toCacheLevelCap());       } else {         return job .obtainNewReduceTask(tts, numTaskTrackers,             ttm.getNumberOfUniqueHosts());       }     } else {       return null ;     }   }

 

SchedulingAlgorithms

该类中有二个类：FairShareComparor ，FifoComparator 。分别实现了公平调度和先来服务算法。

二个类主要实现了一个接口。

public int compare(Schedulable s1, Schedulable s2) {}

这样可以对一个组内的job 进行排序，或者对各个组进行排序。

下面看一下公平调度的比较类 FairShareComparator ，即公平调度器是如何去选择哪个组来分配 task 任务。

判断当前运行的任务数目小于最小共享数目。

如果二个组都小于，则比较最小共享占比。即当前运行的数 / 该组的最小共享数。

如果二个组都大于，则比较权重比。即运行任务数 / 权重系数。

如果二者还是相等，则根据起始时间来比较。

 

public int compare(Schedulable s1, Schedulable s2) {       double minShareRatio1, minShareRatio2;       double tasksToWeightRatio1, tasksToWeightRatio2;       int minShare1 = Math.min (s1.getMinShare(), s1.getDemand());       int minShare2 = Math.min (s2.getMinShare(), s2.getDemand());       boolean s1Needy = s1.getRunningTasks() < minShare1;       boolean s2Needy = s2.getRunningTasks() < minShare2;       minShareRatio1 = s1.getRunningTasks() / Math.max (minShare1, 1.0);       minShareRatio2 = s2.getRunningTasks() / Math.max (minShare2, 1.0);       tasksToWeightRatio1 = s1.getRunningTasks() / s1.getWeight();       tasksToWeightRatio2 = s2.getRunningTasks() / s2.getWeight();       int res = 0;       if (s1Needy && !s2Needy)         res = -1;       else if (s2Needy && !s1Needy)         res = 1;       else if (s1Needy && s2Needy)         res = ( int ) Math.signum (minShareRatio1 - minShareRatio2);       else // Neither schedulable is needy         res = ( int ) Math.signum (tasksToWeightRatio1 - tasksToWeightRatio2);       if (res == 0) {         // Jobs are tied in fairness ratio. Break the tie by submit time and job         // name to get a deterministic ordering, which is useful for unit tests.         res = ( int ) Math.signum (s1.getStartTime() - s2.getStartTime());         if (res == 0)           res = s1.getName().compareTo(s2.getName());       }       return res;     }

 

 

到此，把公平调度的基本框架了解了一下，具体的实现还是要看里面的具体源代码，才能真正掌握具体。另外就是官方的文档， http://hadoop.apache.org/common/docs/r0.20.2/fair_scheduler.html,

以及 Hadoop Fair Scheduler Design Document 。