[Hadoop]

  TaskTracker节点向JobTracker汇报当前节点的运行时信息时候，是将运行状态信息同心跳报告一起发送给JobTracker的，主要包括TaskTracker的基本信息、节点资源使用信息、各任务状态等。所以信息被序列化为TaskTrackerStatus实例对象。每次发送心跳报告的时候，会重新构造一个Status对象，并重置这些信息，而且需要主要的是每次发送的status对象的大小是不一定的，因为很多信息的发送是有时间间隔的。这些操作主要位于方法transmitHeartBeat的上半部分代码：

HeartbeatResponse transmitHeartBeat(long now) throws IOException {   
 // 计算是否发送任务计数器信息，间隔时间为${COUNTER_UPDATE_INTERVAL}对应的值为60s，不支持配置
    boolean sendCounters;
    if (now > (previousUpdate + COUNTER_UPDATE_INTERVAL)) {
      sendCounters = true;
      previousUpdate = now;
    }
    else {
      sendCounters = false;
    }

    // 
    // Check if the last heartbeat got through... 
    // if so then build the heartbeat information for the JobTracker;
    // else resend the previous status information.
    //
    if (status == null) {
      synchronized (this) {
        status = new TaskTrackerStatus(taskTrackerName, localHostname, 
                                       httpPort, 
                                       cloneAndResetRunningTaskStatuses(
                                         sendCounters), 
                                       failures, 
                                       maxMapSlots,
                                       maxReduceSlots); 
      }
    } else {
      LOG.info("Resending 'status' to '" + jobTrackAddr.getHostName() +
               "' with reponseId '" + heartbeatResponseId);
    }
      
    //
    // Check if we should ask for a new Task
    // 计算节点资源使用信息
    boolean askForNewTask;
    long localMinSpaceStart;
    synchronized (this) {
      askForNewTask = 
        ((status.countOccupiedMapSlots() < maxMapSlots || 
          status.countOccupiedReduceSlots() < maxReduceSlots) && 
         acceptNewTasks); 
      localMinSpaceStart = minSpaceStart;
    }
    if (askForNewTask) {
      askForNewTask = enoughFreeSpace(localMinSpaceStart);
      long freeDiskSpace = getFreeSpace();
      long totVmem = getTotalVirtualMemoryOnTT();
      long totPmem = getTotalPhysicalMemoryOnTT();
      long availableVmem = getAvailableVirtualMemoryOnTT();
      long availablePmem = getAvailablePhysicalMemoryOnTT();
      long cumuCpuTime = getCumulativeCpuTimeOnTT();
      long cpuFreq = getCpuFrequencyOnTT();
      int numCpu = getNumProcessorsOnTT();
      float cpuUsage = getCpuUsageOnTT();

      status.getResourceStatus().setAvailableSpace(freeDiskSpace);
      status.getResourceStatus().setTotalVirtualMemory(totVmem);
      status.getResourceStatus().setTotalPhysicalMemory(totPmem);
      status.getResourceStatus().setMapSlotMemorySizeOnTT(
          mapSlotMemorySizeOnTT);
      status.getResourceStatus().setReduceSlotMemorySizeOnTT(
          reduceSlotSizeMemoryOnTT);
      status.getResourceStatus().setAvailableVirtualMemory(availableVmem); 
      status.getResourceStatus().setAvailablePhysicalMemory(availablePmem);
      status.getResourceStatus().setCumulativeCpuTime(cumuCpuTime);
      status.getResourceStatus().setCpuFrequency(cpuFreq);
      status.getResourceStatus().setNumProcessors(numCpu);
      status.getResourceStatus().setCpuUsage(cpuUsage);
    }
    //add node health information 添加节点健康状态    
    TaskTrackerHealthStatus healthStatus = status.getHealthStatus();
    synchronized (this) {
      if (healthChecker != null) {
        healthChecker.setHealthStatus(healthStatus);
      } else {
        healthStatus.setNodeHealthy(true);
        healthStatus.setLastReported(0L);
        healthStatus.setHealthReport("");
      }
    }

......
...//发送心跳报告
.....
    synchronized (this) {
      for (TaskStatus taskStatus : status.getTaskReports()) {
        if (taskStatus.getRunState() != TaskStatus.State.RUNNING &&
            taskStatus.getRunState() != TaskStatus.State.UNASSIGNED &&
            taskStatus.getRunState() != TaskStatus.State.COMMIT_PENDING &&
            !taskStatus.inTaskCleanupPhase()) {
          if (taskStatus.getIsMap()) {
            mapTotal--;
          } else {
            reduceTotal--;
          }
          myInstrumentation.completeTask(taskStatus.getTaskID());
          runningTasks.remove(taskStatus.getTaskID());
        }
      }

.....
// 其他代码
}

　　1、创建TaskTrackerStatus实例对象status，创建代码如下：

status = new TaskTrackerStatus(taskTrackerName, localHostname, httpPort, cloneAndResetRunningTaskStatuses(sendCounters), failures, maxMapSlots,maxReduceSlots); 

　　创建status对象的时候参数分别是: taskTrackerName-->当前节点名称，value为{"tracker_" + localHostname + ":" + taskReportAddress}，其中taskReportAddress是为task服务的监听地址。

　　　　　　　　localHostname-->当前节点的指定的host名称，配置参数变量为slave.host.name，如果不指定该参数，那么从mapred.tasktracker.dns.interface和mapred.tasktracker.dns.nameserver指定的dns中获取，默认为本地hostname。

　　　　　　　　httpPort-->Http监听的端口号

　　　　　　　　cloneAndResetRunningTaskStatuses(sendCounters)-->根据是否进行任务计数器信息发送标志，clone真正运行的task状态信息

　　　　　　　　failures-->当前节点上失败的任务次数，用于判断当前节点的完整性，当该值达到最大标准的时候，JobTracker不会再给该节点分配任务信息。

　　　　　　　　maxMapSlots, maxReduceSlots-->该节点运行的最大slot个数。

　　2、判断是否允许分配任务给该节点，这个是先通过判断当前节点的空闲slot个数，然后通过判断当前节点的磁盘剩余量来达到的。代码如下：

askForNewTask = ((status.countOccupiedMapSlots() < maxMapSlots || status.countOccupiedReduceSlots() < maxReduceSlots) && acceptNewTasks);
askForNewTask = enoughFreeSpace(localMinSpaceStart); // 其中localMinSpaceStart为配置中给定的${mapred.local.dir.minspacestart}，默认为0

　　当满足第一个条件：使用的slot个数小于总slot个数的时候，那么给JobTracker发送节点资源使用情况。当满足第二个条件的时候，允许JobTracker给当前节点分配任务。

　　3、初始化资源使用情况，主要是设置一系列的磁盘、内存等资源信息等，代码如下：

      long freeDiskSpace = getFreeSpace(); // 获取剩余的磁盘大小
      long totVmem = getTotalVirtualMemoryOnTT(); // 获取总的虚拟内存
      long totPmem = getTotalPhysicalMemoryOnTT(); // 获取总的物理内存
      long availableVmem = getAvailableVirtualMemoryOnTT(); // 获取可用的虚拟内存
      long availablePmem = getAvailablePhysicalMemoryOnTT(); // 获取可用的物理内存
      long cumuCpuTime = getCumulativeCpuTimeOnTT(); // 获取累积cpu时间
      long cpuFreq = getCpuFrequencyOnTT(); // 获取cpu频率
      int numCpu = getNumProcessorsOnTT(); // 获取总的进程数
      float cpuUsage = getCpuUsageOnTT(); // 获取cpu可用比例

      status.getResourceStatus().setAvailableSpace(freeDiskSpace);
      status.getResourceStatus().setTotalVirtualMemory(totVmem);
      status.getResourceStatus().setTotalPhysicalMemory(totPmem);
      status.getResourceStatus().setMapSlotMemorySizeOnTT(mapSlotMemorySizeOnTT); // 设置map阶段slot允许的内存大小， ${mapred.cluster.map.memory.mb}
      status.getResourceStatus().setReduceSlotMemorySizeOnTT(reduceSlotSizeMemoryOnTT); // 设置reduce阶段slot允许的内存大小, ${mapred.cluster.reduce.memory.mb}
      status.getResourceStatus().setAvailableVirtualMemory(availableVmem); 
      status.getResourceStatus().setAvailablePhysicalMemory(availablePmem);
      status.getResourceStatus().setCumulativeCpuTime(cumuCpuTime);
      status.getResourceStatus().setCpuFrequency(cpuFreq);
      status.getResourceStatus().setNumProcessors(numCpu);
      status.getResourceStatus().setCpuUsage(cpuUsage);

　　4、获取当前节点的监控状态，获取当前节点的监控状态是有线程NodeHealthCheckerService来周期性的检查的，可以通过配置一个监控脚本来实现，默认为不实现。详细分析见TaskTracker源码分析(TaskTracker节点健康状况监控)

　　5、发送心跳报告

　　6、处理当前真正运行的Task，处理规则是：只要task不是出于运行、就绪、提交挂起或者cleanup阶段，那么就将该task设置为完成状态，从真正运行的task列表中移除，并针对该task是map阶段或者reduce阶段，分别对map/reduce solt进行操作。

　　7、完成发送。

　　发送的状态对象是org.apache.hadoop.mapred.TaskTrackerStatus，主要属性有：

  String trackerName; // task tracker 节点名称
  String host; // 主机名
  int httpPort; // http web监听端口
  int failures; // 在该节点上失败的task次数
  List<TaskStatus> taskReports; // 当前节点上真正运行的各个人物的状态
    
  volatile long lastSeen; // 上次汇报时间
  private int maxMapTasks; // 当前节点上允许的最大map slot个数
  private int maxReduceTasks; // 当前节点上允许的最大reduce slot个数
  private TaskTrackerHealthStatus healthStatus; // 当前节点的健康状态对象
   
  public static final int UNAVAILABLE = -1; // 是否不可用
  private ResourceStatus resStatus; // 当前节点的资源对象

　　其中ResourceStatus和TaskTrackerHealthStatus分别表示当前节点的资源信息和状态信息，是一个简单的model类。在这里不做分析。

　　TaskStatus类全称为org.apache.hadoop.mapred.TaskStatus。主要保存当前TaskTracker上运行的所有任务的运行状态，基本属性如下：

  private final TaskAttemptID taskid; // task任务id
  private float progress; // 任务执行进度，0-1.0
  private volatile State runState; // 任务运行所处状态，详见TaskStatus.State枚举类
  private String diagnosticInfo; // 诊断信息，一般为异常信息或者错误信息
  private String stateString; // 字符串信息的运行状态
  private String taskTracker; // 所属task tracker名称
  private int numSlots; // 运行该task所需的slot个数，默认为1
    
  private long startTime; // 任务启动时间
  private long finishTime;  // 任务完成时间
  private long outputSize = -1L; // 输出数据量
    
  private volatile Phase phase = Phase.STARTING; // 任务运行阶段，详见TaskStatus.Phase枚举类 
  private Counters counters; // 该任务中定义的计数器(包括系统自带计数器和用户自定义计数器)
  private boolean includeCounters; // 是否包含计数器，计数器没个60s发送一次，也就是说每隔60s，发送的数据中包含一次计数器
  private SortedRanges.Range nextRecordRange = new SortedRanges.Range(); // 下一个要处理的数据区间，用于定位坏记录所在的空间

　　===================================

　　ResourceStatus实例对象resStatus的属性是由抽象类ResourceCalculatorPlugin来获取的，如果不指定该抽象类的具体实现类，那么获取的value值全部都是-1。在linux平台上，默认实现为LinuxResourceCalculatorPlugin类。

    // 创建获取资源的对象
    Class<? extends ResourceCalculatorPlugin> clazz = fConf.getClass(TT_RESOURCE_CALCULATOR_PLUGIN,
            null, ResourceCalculatorPlugin.class);
    resourceCalculatorPlugin = ResourceCalculatorPlugin.getResourceCalculatorPlugin(clazz, fConf);

　　另外，用户可以自定义该实现类，配置参数为${mapreduce.tasktracker.resourcecalculatorplugin}，默认为空。获取代码如下：

public static ResourceCalculatorPlugin getResourceCalculatorPlugin(
      Class<? extends ResourceCalculatorPlugin> clazz, Configuration conf) {

    if (clazz != null) {
      return ReflectionUtils.newInstance(clazz, conf); // 如果已经配置了class，那么直接使用配置的class
    }

    // No class given, try a os specific class
    try {
      String osName = System.getProperty("os.name"); // 获取操作系统
      if (osName.startsWith("Linux")) { // 如果是linux
        return new LinuxResourceCalculatorPlugin(); // 使用已经实现的一种
      }
    } catch (SecurityException se) {
      // Failed to get Operating System name.
      return null;
    }

    // Not supported on this system.
    return null;
  }

　　在LinuxResourceCalculatorPlugin中，其实获取系统的资源信息都是通过读取proc虚拟文件系统中的一些信息来达成的，比如从/proc/meminfo中读取内存，从/proc/cpuinfo中读取cpu信息等。