* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements.  See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership.  The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License.  You may obtain a copy of the License at

*

*     http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

* JobInProgress maintains all the info for keeping a Job on the straight and

* narrow. It keeps its JobProfile and its latest JobStatus, plus a set of

* tables for doing bookkeeping of its Tasks.

*/

  /**

   * Used when the a kill is issued to a job which is initializing.

   */

  static class KillInterruptedException extends InterruptedException {

   private static final long serialVersionUID = 1L;

    public KillInterruptedException(String msg) {

      super(msg);

    }

  }

 

  static final Log LOG = LogFactory.getLog(JobInProgress.class);

   

  JobProfile profile;

  JobStatus status;

  Path jobFile = null;

  Path localJobFile = null;

  TaskInProgress maps[] = new TaskInProgress[0];

  TaskInProgress reduces[] = new TaskInProgress[0];

  TaskInProgress cleanup[] = new TaskInProgress[0];

  TaskInProgress setup[] = new TaskInProgress[0];

  int numMapTasks = 0;

  int numReduceTasks = 0;

  int numSlotsPerMap = 1;

  int numSlotsPerReduce = 1;

 

  // Counters to track currently running/finished/failed Map/Reduce task-attempts

  int runningMapTasks = 0;

  int runningReduceTasks = 0;

  int finishedMapTasks = 0;

  int finishedReduceTasks = 0;

  int failedMapTasks = 0;

  int failedReduceTasks = 0;

 

  static final float DEFAULT_COMPLETED_MAPS_PERCENT_FOR_REDUCE_SLOWSTART = 0.05f;

  int completedMapsForReduceSlowstart = 0;

 

  // runningMapTasks include speculative tasks, so we need to capture

  // speculative tasks separately

  int speculativeMapTasks = 0;

  int speculativeReduceTasks = 0;

 

  int mapFailuresPercent = 0;

  int reduceFailuresPercent = 0;

  int failedMapTIPs = 0;

  int failedReduceTIPs = 0;

  private volatile boolean launchedCleanup = false;

  private volatile boolean launchedSetup = false;

  private volatile boolean jobKilled = false;

  private volatile boolean jobFailed = false;

  private final boolean jobSetupCleanupNeeded;

  JobPriority priority = JobPriority.NORMAL;

  protected JobTracker jobtracker;

 

  protected TokenStorage tokenStorage;

 

  JobHistory jobHistory;

  // NetworkTopology Node to the set of TIPs

  Map<Node, List<TaskInProgress>> nonRunningMapCache;

 

  // Map of NetworkTopology Node to set of running TIPs

  Map<Node, Set<TaskInProgress>> runningMapCache;

  // A list of non-local non-running maps

  List<TaskInProgress> nonLocalMaps;

  // A set of non-local running maps

  Set<TaskInProgress> nonLocalRunningMaps;

  // A list of non-running reduce TIPs

  List<TaskInProgress> nonRunningReduces;

  // A set of running reduce TIPs

  Set<TaskInProgress> runningReduces;

 

  // A list of cleanup tasks for the map task attempts, to be launched

  List<TaskAttemptID> mapCleanupTasks = new LinkedList<TaskAttemptID>();

 

  // A list of cleanup tasks for the reduce task attempts, to be launched

  List<TaskAttemptID> reduceCleanupTasks = new LinkedList<TaskAttemptID>();

  int maxLevel;

  /**

   * A special value indicating that

   * {@link #findNewMapTask(TaskTrackerStatus, int, int, int, double)} should

   * schedule any available map tasks for this job, including speculative tasks.

   */

  int anyCacheLevel;

 

  /**

   * A special value indicating that

   * {@link #findNewMapTask(TaskTrackerStatus, int, int, int, double)} should

   * schedule any only off-switch and speculative map tasks for this job.

   */

  private static final int NON_LOCAL_CACHE_LEVEL = -1;

  private int taskCompletionEventTracker = 0;

  List<TaskCompletionEvent> taskCompletionEvents;

   

  // The maximum percentage of trackers in cluster added to the 'blacklist'.

  private static final double CLUSTER_BLACKLIST_PERCENT = 0.25;

 

  // The maximum percentage of fetch failures allowed for a map

  private static final double MAX_ALLOWED_FETCH_FAILURES_PERCENT = 0.5;

 

  // No. of tasktrackers in the cluster

  private volatile int clusterSize = 0;

 

  // The no. of tasktrackers where >= conf.getMaxTaskFailuresPerTracker()

  // tasks have failed

  private volatile int flakyTaskTrackers = 0;

  // Map of trackerHostName -> no. of task failures

  private Map<String, Integer> trackerToFailuresMap =

    new TreeMap<String, Integer>();

   

  //Confine estimation algorithms to an "oracle" class that JIP queries.

  ResourceEstimator resourceEstimator;

 

  long startTime;

  long launchTime;

  long finishTime;

 

  // Indicates how many times the job got restarted

  private final int restartCount;

  JobConf conf;

  protected AtomicBoolean tasksInited = new AtomicBoolean(false);

  private JobInitKillStatus jobInitKillStatus = new JobInitKillStatus();

  LocalFileSystem localFs;

  FileSystem fs;

  String user;

  JobID jobId;

  private boolean hasSpeculativeMaps;

  private boolean hasSpeculativeReduces;

  long inputLength = 0;

 

  Counters jobCounters = new Counters();

 

  // Maximum no. of fetch-failure notifications after which map task is killed

  private static final int MAX_FETCH_FAILURES_NOTIFICATIONS = 3;

  // Don't lower speculativeCap below one TT's worth (for small clusters)

  private static final int MIN_SPEC_CAP = 10;

 

  private static final float MIN_SLOTS_CAP = 0.01f;

 

  // Map of mapTaskId -> no. of fetch failures

  private Map<TaskAttemptID, Integer> mapTaskIdToFetchFailuresMap =

    new TreeMap<TaskAttemptID, Integer>();

  private Object schedulingInfo;

  //thresholds for speculative execution

  float slowTaskThreshold;

  float speculativeCap;

  float slowNodeThreshold; //standard deviations

  //Statistics are maintained for a couple of things

  //mapTaskStats is used for maintaining statistics about

  //the completion time of map tasks on the trackers. On a per

  //tracker basis, the mean time for task completion is maintained

  private DataStatistics mapTaskStats = new DataStatistics();

  //reduceTaskStats is used for maintaining statistics about

  //the completion time of reduce tasks on the trackers. On a per

  //tracker basis, the mean time for task completion is maintained

  private DataStatistics reduceTaskStats = new DataStatistics();

  //trackerMapStats used to maintain a mapping from the tracker to the

  //the statistics about completion time of map tasks

  private Map<String,DataStatistics> trackerMapStats =

    new HashMap<String,DataStatistics>();

  //trackerReduceStats used to maintain a mapping from the tracker to the

  //the statistics about completion time of reduce tasks

  private Map<String,DataStatistics> trackerReduceStats =

    new HashMap<String,DataStatistics>();