`
jiwenke
  • 浏览: 401820 次
  • 性别: Icon_minigender_1
  • 来自: 南京
博客专栏
4ee69929-b8e1-3eb5-bbca-157d075d6192
Spring技术内幕——深...
浏览量:183068
D1c226f7-74e9-3ec4-a15b-18a45ccd88c5
随笔:Spring与云计算...
浏览量:26582
社区版块
存档分类
最新评论

Hadoop的mapred JobTracker端源码概览

阅读更多
上一节看到TaskTracker启动新任务的过程,这里接着看看在JobTracker中是怎样响应和调度的,在hadoop中,我们看到采用的是pull的方式拿到任务。
    
HeartbeatResponse heartbeatResponse = jobClient.heartbeat(status, 
                                                            justStarted, askForNewTask, 
                                                              heartbeatResponseId);

这里是TaskTracker想JobTracker发送heartbeat的地方 - 使用的是RPC,这样我们你就来到JobTracker了:
  
public synchronized HeartbeatResponse heartbeat(TaskTrackerStatus status, 
                                                  boolean initialContact, boolean acceptNewTasks, short responseId) 
    throws IOException {
.............
    //如果是接受新任务的话,让JotTracker去进行调度,这里会调用taskScheduler的assignTasks
    if (acceptNewTasks) {
      TaskTrackerStatus taskTrackerStatus = getTaskTracker(trackerName);
      if (taskTrackerStatus == null) {
        LOG.warn("Unknown task tracker polling; ignoring: " + trackerName);
      } else {
        List<Task> tasks = getSetupAndCleanupTasks(taskTrackerStatus);
    //这里是准备assignTask的地方,由配置的调度器来决定怎样调度
        if (tasks == null ) {
         tasks = taskScheduler.assignTasks(taskTrackerStatus);
        }
        if (tasks != null) {
          for (Task task : tasks) {
            expireLaunchingTasks.addNewTask(task.getTaskID());
            LOG.debug(trackerName + " -> LaunchTask: " + task.getTaskID());
            actions.add(new LaunchTaskAction(task));
          }
        }
      }
    }

这个taskScheduler采用的是默认的   
taskScheduler = (TaskScheduler) ReflectionUtils.newInstance(schedulerClass,conf);

这是在配置文件中指定的,"mapred.jobtracker.taskScheduler",常常是JobQueueTaskScheduler是hadoop的实现,FIFO类型的调度器,让我们看看这个调度器是怎样assignTasks的:
  
public synchronized List<Task> assignTasks(TaskTrackerStatus taskTracker)
      throws IOException {

    ClusterStatus clusterStatus = taskTrackerManager.getClusterStatus();
    int numTaskTrackers = clusterStatus.getTaskTrackers();

    Collection<JobInProgress> jobQueue =
      jobQueueJobInProgressListener.getJobQueue();

    //
    // Get map + reduce counts for the current tracker.
    //
    int maxCurrentMapTasks = taskTracker.getMaxMapTasks();
    int maxCurrentReduceTasks = taskTracker.getMaxReduceTasks();
    int numMaps = taskTracker.countMapTasks();
    int numReduces = taskTracker.countReduceTasks();

    //
    // Compute average map and reduce task numbers across pool
    //
    int remainingReduceLoad = 0;
    int remainingMapLoad = 0;
    synchronized (jobQueue) {
      for (JobInProgress job : jobQueue) {
        if (job.getStatus().getRunState() == JobStatus.RUNNING) {
          int totalMapTasks = job.desiredMaps();
          int totalReduceTasks = job.desiredReduces();
          remainingMapLoad += (totalMapTasks - job.finishedMaps());
          remainingReduceLoad += (totalReduceTasks - job.finishedReduces());
        }
      }
    }

    // find out the maximum number of maps or reduces that we are willing
    // to run on any node.
    int maxMapLoad = 0;
    int maxReduceLoad = 0;
    if (numTaskTrackers > 0) {
      maxMapLoad = Math.min(maxCurrentMapTasks,
                            (int) Math.ceil((double) remainingMapLoad / 
                                            numTaskTrackers));
      maxReduceLoad = Math.min(maxCurrentReduceTasks,
                               (int) Math.ceil((double) remainingReduceLoad
                                               / numTaskTrackers));
    }
        
    int totalMaps = clusterStatus.getMapTasks();
    int totalMapTaskCapacity = clusterStatus.getMaxMapTasks();
    int totalReduces = clusterStatus.getReduceTasks();
    int totalReduceTaskCapacity = clusterStatus.getMaxReduceTasks();

    //
    // In the below steps, we allocate first a map task (if appropriate),
    // and then a reduce task if appropriate.  We go through all jobs
    // in order of job arrival; jobs only get serviced if their 
    // predecessors are serviced, too.
    //

    //
    // We hand a task to the current taskTracker if the given machine 
    // has a workload that's less than the maximum load of that kind of
    // task.
    //
       
    if (numMaps < maxMapLoad) {

      int totalNeededMaps = 0;
      synchronized (jobQueue) {
        for (JobInProgress job : jobQueue) {
          if (job.getStatus().getRunState() != JobStatus.RUNNING) {
            continue;
          }
      //这里是取得Task的地方,需要到job中去取
          Task t = job.obtainNewMapTask(taskTracker, numTaskTrackers,
              taskTrackerManager.getNumberOfUniqueHosts());
          if (t != null) {
            return Collections.singletonList(t);
          }

          //
          // Beyond the highest-priority task, reserve a little 
          // room for failures and speculative executions; don't 
          // schedule tasks to the hilt.
          //
          totalNeededMaps += job.desiredMaps();
          int padding = 0;
          if (numTaskTrackers > MIN_CLUSTER_SIZE_FOR_PADDING) {
            padding = Math.min(maxCurrentMapTasks,
                               (int)(totalNeededMaps * padFraction));
          }
          if (totalMaps + padding >= totalMapTaskCapacity) {
            break;
          }
        }
      }
    }

    //
    // Same thing, but for reduce tasks
    //
    if (numReduces < maxReduceLoad) {

      int totalNeededReduces = 0;
      synchronized (jobQueue) {
        for (JobInProgress job : jobQueue) {
          if (job.getStatus().getRunState() != JobStatus.RUNNING ||
              job.numReduceTasks == 0) {
            continue;
          }

          Task t = job.obtainNewReduceTask(taskTracker, numTaskTrackers, 
              taskTrackerManager.getNumberOfUniqueHosts());
          if (t != null) {
            return Collections.singletonList(t);
          }

          //
          // Beyond the highest-priority task, reserve a little 
          // room for failures and speculative executions; don't 
          // schedule tasks to the hilt.
          //
          totalNeededReduces += job.desiredReduces();
          int padding = 0;
          if (numTaskTrackers > MIN_CLUSTER_SIZE_FOR_PADDING) {
            padding = 
              Math.min(maxCurrentReduceTasks,
                       (int) (totalNeededReduces * padFraction));
          }
          if (totalReduces + padding >= totalReduceTaskCapacity) {
            break;
          }
        }
      }
    }
    return null;
  }

task的取得就要到JobInProgress中去obtainNewReduceTask了,需要对集群的状态进行查询处理了。
4
0
分享到:
评论
1 楼 luweimstr 2011-09-01  
good job.学习了

相关推荐

    Hadoop源码 包含mapred及mapreduce

    Hadoop源码 包含mapred

    基于Hadoop图书推荐系统源码+数据库.zip

    基于Hadoop图书推荐系统源码+数据库.zip基于Hadoop图书推荐系统源码+数据库.zip基于Hadoop图书推荐系统源码+数据库.zip基于Hadoop图书推荐系统源码+数据库.zip基于Hadoop图书推荐系统源码+数据库.zip基于Hadoop图书...

    hadoop mapred_tutorial官方文档

    hadoop mapred_tutorial官方文档

    hadoop-2.8.1源码

    《深入剖析Hadoop 2.8.1源码:分布式系统的智慧结晶》 Hadoop,作为开源的大数据处理框架,自2006年诞生以来,一直是大数据领域的重要支柱。其2.8.1版本是Hadoop发展的一个关键节点,为用户提供了更稳定、高效的...

    hadoop权威指南4和源码

    这本书是许多开发者和数据工程师学习Hadoop的首选资料,而附带的源码则为读者提供了更直观的理解途径。在深入探讨Hadoop的知识点时,我们可以从以下几个方面进行: 1. **Hadoop概述**:Hadoop是一个开源的分布式...

    Hadoop商品推荐系统-源码.zip

    使用Eclipse的export功能把所有源码打包,然后把打包后的jar文件拷贝到hadoop集群的$HADOOP_HOME/share/hadoop/mapreduce/lib目录下面。这一步相当重要,否则项目将无法找到相关类。注意,如果搭建的是全分布集群,...

    实战hadoop中的源码

    【标题】"实战hadoop中的源码"涵盖了在大数据处理领域深入理解并应用Apache Hadoop的核心技术。Hadoop是开源的分布式计算框架,它允许在大规模集群上存储和处理海量数据。通过研究Hadoop的源码,开发者可以深入了解...

    Hadoop源码分析(完整版)

    Hadoop源码分析是深入理解Hadoop分布式计算平台原理的起点,通过源码分析,可以更好地掌握Hadoop的工作机制、关键组件的实现方式和内部通信流程。Hadoop项目包括了多个子项目,其中最核心的是HDFS和MapReduce,这两...

    Hadoop学习总结和源码分析

    本文将基于“Hadoop学习总结和源码分析”这一主题,结合提供的文档资源,深入探讨Hadoop的核心组件HDFS(Hadoop Distributed File System)和MapReduce。 首先,我们从“Hadoop学习总结之一:HDFS简介.doc”开始,...

    hadoop 2.2.2 已编译源码

    当你拥有已编译的Hadoop 2.2.2源码时,你可以深入理解其内部工作原理,这对于Java开发者尤其是那些专注于大数据处理的工程师来说,具有极大的学习价值。 首先,让我们关注Hadoop的核心组件:HDFS(Hadoop ...

    hadoop 2.9.0 mapred-default.xml 属性集

    Hadoop 2.9.0版本中的mapred-default.xml文件包含了MapReduce作业的配置属性,这些属性定义了MapReduce作业执行过程中的各种行为和参数。下面我们来详细介绍mapred-site.xml文件中的一些关键属性。 1. mapreduce....

    hadoop-3.1.3.tar.gz编译后的源码包

    这个hadoop-3.1.3.tar.gz文件是一个包含了Hadoop 3.1.3版本的源码压缩包,对于理解Hadoop的工作原理、进行二次开发或者定制化配置来说,研究源码是非常重要的。 首先,Hadoop的核心组件包括HDFS(Hadoop ...

    hadoop2.7.3源码包,hadoop2.7.3zip源码包

    - `hadoop/mapreduce`: MapReduce的实现,包括JobTracker、TaskTracker、作业提交和执行机制。 3. `hadoop/yarn`: YARN(Yet Another Resource Negotiator)是Hadoop的资源管理系统,负责任务调度和集群资源管理。 ...

    Hadoop 源码编译所需软件

    本文将深入探讨在编译Hadoop CDH源码时所需的软件及其重要性。 首先,我们来看“google-snappy-ea660b5”。Snappy是由Google开发的一个高效的数据压缩库,它主要关注的是高速度而非最高压缩率。在Hadoop中,Snappy...

    基于Python和大数据hadoop电影分析系统源码+文档说明.zip

    基于Python和大数据hadoop电影分析系统源码+文档说明.zip,本项目是一套98分毕业设计系统,主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者,也可作为课程设计、期末大作业,包含:项目源码、...

    hadoop-2.8.4源码

    在Hadoop 2.8.4源码中,我们可以看到HDFS的设计理念,包括数据块的复制策略、心跳机制、数据节点和名称节点的交互过程,以及故障检测和恢复机制。通过分析源码,我们可以了解到如何实现数据的高可用性和容错性。 ...

    hadoop2.6.0源码和eclipse插件

    源码包含了JobTracker、TaskTracker、Task等核心组件,以及作业提交、任务调度和容错机制的实现。 3. **YARN(Yet Another Resource Negotiator)**:从Hadoop 2.x开始,资源管理从MapReduce中剥离出来,形成了独立...

    hadoop 2.5.2 源码

    Hadoop 2.5.2源码分析 Hadoop是一个开源框架,主要用于处理和存储大量数据,它由Apache软件基金会开发并维护。Hadoop 2.5.2是Hadoop发展过程中的一个重要版本,它引入了许多改进和优化,旨在提高系统的稳定性和性能...

    hadoop2.7.2源码包

    源码在`hadoop-mapreduce-project`目录下,包括Map任务、Reduce任务、JobTracker(在Hadoop 2.x中被YARN取代)和TaskTracker等组件的实现。 3. **YARN(Yet Another Resource Negotiator)**:从Hadoop 2.x开始,...

Global site tag (gtag.js) - Google Analytics