开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 网格计算 > 查看源码
HistoryViewer.java
资源名称：hadoop-0.20.0.tar.gz　[点击查看]
上传用户：quxuerui
上传日期：2018-01-08
资源大小：41811k
文件大小：24k
源码类别：

网格计算

开发平台：

Java

HistoryViewer.java：源码内容
  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  19. package org.apache.hadoop.mapred;
  21. import java.io.IOException;
  22. import java.text.SimpleDateFormat;
  23. import java.util.Arrays;
  24. import java.util.Comparator;
  25. import java.util.Date;
  26. import java.util.Map;
  27. import java.util.Set;
  28. import java.util.TreeMap;
  30. import org.apache.hadoop.conf.Configuration;
  31. import org.apache.hadoop.fs.FileSystem;
  32. import org.apache.hadoop.fs.FileUtil;
  33. import org.apache.hadoop.fs.Path;
  34. import org.apache.hadoop.fs.PathFilter;
  35. import org.apache.hadoop.mapred.DefaultJobHistoryParser.*;
  36. import org.apache.hadoop.mapred.JobHistory.*;
  37. import org.apache.hadoop.util.StringUtils;
  39. /**
  40.  * This class is to view job history files.
  41.  */
  42. class HistoryViewer {
  43.   private static SimpleDateFormat dateFormat = new SimpleDateFormat(
  44.                                              "d-MMM-yyyy HH:mm:ss");
  45.   private FileSystem fs;
  46.   private Configuration conf;
  47.   private Path historyLogDir;
  48.   private String jobLogFile;
  49.   private JobHistory.JobInfo job;
  50.   private String trackerHostName;
  51.   private String trackerStartTime;
  52.   private String jobId;
  53.   private boolean printAll;
  54.   
  55.   private PathFilter jobLogFileFilter = new PathFilter() {
  56.     public boolean accept(Path path) {
  57.       return !(path.getName().endsWith(".xml"));
  58.     }
  59.   };
  61.   public HistoryViewer(String outputDir, Configuration conf, boolean printAll)
  62.   throws IOException {
  63.     this.conf = conf;
  64.     this.printAll = printAll;
  65.     Path output = new Path(outputDir);
  66.     historyLogDir = new Path(output, "_logs/history");
  67.     try {
  68.       fs = output.getFileSystem(this.conf);
  69.       if (!fs.exists(output)) {
  70.         throw new IOException("History directory " + historyLogDir.toString()
  71.                               + "does not exist");
  72.       }
  73.       Path[] jobFiles = FileUtil.stat2Paths(fs.listStatus(historyLogDir,
  74.                                                           jobLogFileFilter));
  75.       if (jobFiles.length == 0) {
  76.         throw new IOException("Not a valid history directory " 
  77.                               + historyLogDir.toString());
  78.       }
  79.       jobLogFile = jobFiles[0].toString();
  80.       String[] jobDetails = 
  81.           JobInfo.decodeJobHistoryFileName(jobFiles[0].getName()).split("_");
  82.       trackerHostName = jobDetails[0];
  83.       trackerStartTime = jobDetails[1];
  84.       jobId = jobDetails[2] + "_" + jobDetails[3] + "_" + jobDetails[4];
  85.       job = new JobHistory.JobInfo(jobId); 
  86.       DefaultJobHistoryParser.parseJobTasks(jobFiles[0].toString(), job, fs);
  87.     } catch(Exception e) {
  88.       throw new IOException("Not able to initialize History viewer", e);
  89.     }
  90.   }
  91.   
  92.   public void print() throws IOException{
  93.     printJobDetails();
  94.     printTaskSummary();
  95.     printJobAnalysis();
  96.     printTasks("SETUP", "FAILED");
  97.     printTasks("SETUP", "KILLED");
  98.     printTasks("MAP", "FAILED");
  99.     printTasks("MAP", "KILLED");
  100.     printTasks("REDUCE", "FAILED");
  101.     printTasks("REDUCE", "KILLED");
  102.     printTasks("CLEANUP", "FAILED");
  103.     printTasks("CLEANUP", "KILLED");
  104.     if (printAll) {
  105.       printTasks("SETUP", "SUCCESS");
  106.       printTasks("MAP", "SUCCESS");
  107.       printTasks("REDUCE", "SUCCESS");
  108.       printTasks("CLEANUP", "SUCCESS");
  109.       printAllTaskAttempts("SETUP");
  110.       printAllTaskAttempts("MAP");
  111.       printAllTaskAttempts("REDUCE");
  112.       printAllTaskAttempts("CLEANUP");
  113.     }
  114.     NodesFilter filter = new FailedOnNodesFilter();
  115.     printFailedAttempts(filter);
  116.     filter = new KilledOnNodesFilter();
  117.     printFailedAttempts(filter);
  118.   }
  120.   private void printJobDetails() {
  121.     StringBuffer jobDetails = new StringBuffer();
  122.     jobDetails.append("nHadoop job: " ).append(jobId);
  123.     jobDetails.append("n=====================================");
  124.     jobDetails.append("nJob tracker host name: ").append(trackerHostName);
  125.     jobDetails.append("njob tracker start time: ").append( 
  126.                       new Date(Long.parseLong(trackerStartTime))); 
  127.     jobDetails.append("nUser: ").append(job.get(Keys.USER)); 
  128.     jobDetails.append("nJobName: ").append(job.get(Keys.JOBNAME)); 
  129.     jobDetails.append("nJobConf: ").append(job.get(Keys.JOBCONF)); 
  130.     jobDetails.append("nSubmitted At: ").append(StringUtils.
  131.                         getFormattedTimeWithDiff(dateFormat,
  132.                         job.getLong(Keys.SUBMIT_TIME), 0)); 
  133.     jobDetails.append("nLaunched At: ").append(StringUtils.
  134.                         getFormattedTimeWithDiff(dateFormat,
  135.                         job.getLong(Keys.LAUNCH_TIME),
  136.                         job.getLong(Keys.SUBMIT_TIME)));
  137.     jobDetails.append("nFinished At: ").append(StringUtils.
  138.                         getFormattedTimeWithDiff(dateFormat,
  139.                         job.getLong(Keys.FINISH_TIME),
  140.                         job.getLong(Keys.LAUNCH_TIME)));
  141.     jobDetails.append("nStatus: ").append(((job.get(Keys.JOB_STATUS) == "") ? 
  142.                       "Incomplete" :job.get(Keys.JOB_STATUS)));
  143.     jobDetails.append("n=====================================");
  144.     System.out.println(jobDetails.toString());
  145.   }
  146.   
  147.   private void printTasks(String taskType, String taskStatus) {
  148.     Map<String, JobHistory.Task> tasks = job.getAllTasks();
  149.     StringBuffer taskList = new StringBuffer();
  150.     taskList.append("n").append(taskStatus).append(" ");
  151.     taskList.append(taskType).append(" task list for ").append(jobId);
  152.     taskList.append("nTaskIdttStartTimetFinishTimetError");
  153.     if (Values.MAP.name().equals(taskType)) {
  154.       taskList.append("tInputSplits");
  155.     }
  156.     taskList.append("n====================================================");
  157.     System.out.println(taskList.toString());
  158.     for (JobHistory.Task task : tasks.values()) {
  159.       if (taskType.equals(task.get(Keys.TASK_TYPE)) &&
  160.          (taskStatus.equals(task.get(Keys.TASK_STATUS))
  161.           || taskStatus.equals("all"))) {
  162.         taskList.setLength(0);
  163.         taskList.append(task.get(Keys.TASKID));
  164.         taskList.append("t").append(StringUtils.getFormattedTimeWithDiff(
  165.                    dateFormat, task.getLong(Keys.START_TIME), 0));
  166.         taskList.append("t").append(StringUtils.getFormattedTimeWithDiff(
  167.                    dateFormat, task.getLong(Keys.FINISH_TIME),
  168.                    task.getLong(Keys.START_TIME))); 
  169.         taskList.append("t").append(task.get(Keys.ERROR));
  170.         if (Values.MAP.name().equals(taskType)) {
  171.           taskList.append("t").append(task.get(Keys.SPLITS));
  172.         }
  173.         System.out.println(taskList.toString());
  174.       }
  175.     }
  176.   }
  177.   
  178.   private void printAllTaskAttempts(String taskType) {
  179.     Map<String, JobHistory.Task> tasks = job.getAllTasks();
  180.     StringBuffer taskList = new StringBuffer();
  181.     taskList.append("n").append(taskType);
  182.     taskList.append(" task list for ").append(jobId);
  183.     taskList.append("nTaskIdttStartTime");
  184.     if (Values.REDUCE.name().equals(taskType)) {
  185.       taskList.append("tShuffleFinishedtSortFinished");
  186.     }
  187.     taskList.append("tFinishTimetHostNametErrortTaskLogs");
  188.     taskList.append("n====================================================");
  189.     System.out.println(taskList.toString());
  190.     for (JobHistory.Task task : tasks.values()) {
  191.       for (JobHistory.TaskAttempt attempt : task.getTaskAttempts().values()) {
  192.         if (taskType.equals(task.get(Keys.TASK_TYPE))){
  193.           taskList.setLength(0); 
  194.           taskList.append(attempt.get(Keys.TASK_ATTEMPT_ID)).append("t");
  195.           taskList.append(StringUtils.getFormattedTimeWithDiff(dateFormat,
  196.                           attempt.getLong(Keys.START_TIME), 0)).append("t");
  197.           if (Values.REDUCE.name().equals(taskType)) {
  198.             ReduceAttempt reduceAttempt = (ReduceAttempt)attempt; 
  199.             taskList.append(StringUtils.getFormattedTimeWithDiff(dateFormat,
  200.                             reduceAttempt.getLong(Keys.SHUFFLE_FINISHED),
  201.                             reduceAttempt.getLong(Keys.START_TIME)));
  202.             taskList.append("t"); 
  203.             taskList.append(StringUtils.getFormattedTimeWithDiff(dateFormat, 
  204.                             reduceAttempt.getLong(Keys.SORT_FINISHED),
  205.                             reduceAttempt.getLong(Keys.SHUFFLE_FINISHED))); 
  206.           } 
  207.           taskList.append(StringUtils.getFormattedTimeWithDiff(dateFormat,
  208.                           attempt.getLong(Keys.FINISH_TIME),
  209.                           attempt.getLong(Keys.START_TIME))); 
  210.           taskList.append("t"); 
  211.           taskList.append(attempt.get(Keys.HOSTNAME)).append("t");
  212.           taskList.append(attempt.get(Keys.ERROR));
  213.           String taskLogsUrl = JobHistory.getTaskLogsUrl(attempt);
  214.           taskList.append(taskLogsUrl != null ? taskLogsUrl : "n/a");
  215.           System.out.println(taskList.toString());
  216.         }
  217.       }
  218.     }
  219.   }
  220.   
  221.   private void printTaskSummary() {
  222.     Map<String, JobHistory.Task> tasks = job.getAllTasks();
  223.     int totalMaps = 0; 
  224.     int totalReduces = 0; 
  225.     int totalCleanups = 0;
  226.     int totalSetups = 0;
  227.     int numFailedMaps = 0; 
  228.     int numKilledMaps = 0;
  229.     int numFailedReduces = 0; 
  230.     int numKilledReduces = 0;
  231.     int numFinishedCleanups = 0;
  232.     int numFailedCleanups = 0;
  233.     int numKilledCleanups = 0;
  234.     int numFinishedSetups = 0;
  235.     int numFailedSetups = 0;
  236.     int numKilledSetups = 0;
  237.     long mapStarted = 0; 
  238.     long mapFinished = 0; 
  239.     long reduceStarted = 0; 
  240.     long reduceFinished = 0; 
  241.     long cleanupStarted = 0;
  242.     long cleanupFinished = 0;
  243.     long setupStarted = 0;
  244.     long setupFinished = 0;
  246.     Map <String, String> allHosts = new TreeMap<String, String>();
  248.     for (JobHistory.Task task : tasks.values()) {
  249.       Map<String, TaskAttempt> attempts = task.getTaskAttempts();
  250.       allHosts.put(task.get(Keys.HOSTNAME), "");
  251.       for (TaskAttempt attempt : attempts.values()) {
  252.         long startTime = attempt.getLong(Keys.START_TIME); 
  253.         long finishTime = attempt.getLong(Keys.FINISH_TIME); 
  254.         if (Values.MAP.name().equals(task.get(Keys.TASK_TYPE))) {
  255.           if (mapStarted==0 || mapStarted > startTime) {
  256.             mapStarted = startTime; 
  257.           }
  258.           if (mapFinished < finishTime) {
  259.             mapFinished = finishTime; 
  260.           }
  261.           totalMaps++; 
  262.           if (Values.FAILED.name().equals(attempt.get(Keys.TASK_STATUS))) {
  263.             numFailedMaps++; 
  264.           } else if (Values.KILLED.name().equals(
  265.                                             attempt.get(Keys.TASK_STATUS))) {
  266.             numKilledMaps++;
  267.           }
  268.         } else if (Values.REDUCE.name().equals(task.get(Keys.TASK_TYPE))) {
  269.           if (reduceStarted==0||reduceStarted > startTime) {
  270.             reduceStarted = startTime; 
  271.           }
  272.           if (reduceFinished < finishTime) {
  273.             reduceFinished = finishTime; 
  274.           }
  275.           totalReduces++; 
  276.           if (Values.FAILED.name().equals(attempt.get(Keys.TASK_STATUS))) {
  277.             numFailedReduces++;
  278.           } else if (Values.KILLED.name().equals(
  279.                                             attempt.get(Keys.TASK_STATUS))) {
  280.             numKilledReduces++;
  281.           }
  282.         } else if (Values.CLEANUP.name().equals(task.get(Keys.TASK_TYPE))){
  283.           if (cleanupStarted==0||cleanupStarted > startTime) {
  284.             cleanupStarted = startTime; 
  285.           }
  286.           if (cleanupFinished < finishTime) {
  287.             cleanupFinished = finishTime; 
  288.           }
  289.           totalCleanups++; 
  290.           if (Values.SUCCESS.name().equals(attempt.get(Keys.TASK_STATUS))) {
  291.             numFinishedCleanups++;
  292.           } else if (Values.FAILED.name().equals(
  293.                                             attempt.get(Keys.TASK_STATUS))) {
  294.             numFailedCleanups++;
  295.           } else if (Values.KILLED.name().equals(
  296.                                             attempt.get(Keys.TASK_STATUS))) {
  297.             numKilledCleanups++;
  298.           }
  299.         } else if (Values.SETUP.name().equals(task.get(Keys.TASK_TYPE))){
  300.           if (setupStarted==0||setupStarted > startTime) {
  301.             setupStarted = startTime; 
  302.           }
  303.           if (setupFinished < finishTime) {
  304.             setupFinished = finishTime; 
  305.           }
  306.           totalSetups++; 
  307.           if (Values.SUCCESS.name().equals(attempt.get(Keys.TASK_STATUS))) {
  308.             numFinishedSetups++;
  309.           } else if (Values.FAILED.name().equals(
  310.                                             attempt.get(Keys.TASK_STATUS))) {
  311.             numFailedSetups++;
  312.           } else if (Values.KILLED.name().equals(
  313.                                             attempt.get(Keys.TASK_STATUS))) {
  314.             numKilledSetups++;
  315.           }
  316.         }
  317.       }
  318.     }
  319.     
  320.     StringBuffer taskSummary = new StringBuffer();
  321.     taskSummary.append("nTask Summary");
  322.     taskSummary.append("n============================");
  323.     taskSummary.append("nKindtTotalt");
  324.     taskSummary.append("SuccessfultFailedtKilledtStartTimetFinishTime");
  325.     taskSummary.append("n");
  326.     taskSummary.append("nSetupt").append(totalSetups);
  327.     taskSummary.append("t").append(numFinishedSetups);
  328.     taskSummary.append("tt").append(numFailedSetups);
  329.     taskSummary.append("t").append(numKilledSetups);
  330.     taskSummary.append("t").append(StringUtils.getFormattedTimeWithDiff(
  331.                                dateFormat, setupStarted, 0));
  332.     taskSummary.append("t").append(StringUtils.getFormattedTimeWithDiff(
  333.                                dateFormat, setupFinished, setupStarted)); 
  334.     taskSummary.append("nMapt").append(totalMaps);
  335.     taskSummary.append("t").append(job.getInt(Keys.FINISHED_MAPS));
  336.     taskSummary.append("tt").append(numFailedMaps);
  337.     taskSummary.append("t").append(numKilledMaps);
  338.     taskSummary.append("t").append(StringUtils.getFormattedTimeWithDiff(
  339.                                dateFormat, mapStarted, 0));
  340.     taskSummary.append("t").append(StringUtils.getFormattedTimeWithDiff(
  341.                                dateFormat, mapFinished, mapStarted));
  342.     taskSummary.append("nReducet").append(totalReduces);
  343.     taskSummary.append("t").append(job.getInt(Keys.FINISHED_REDUCES));
  344.     taskSummary.append("tt").append(numFailedReduces);
  345.     taskSummary.append("t").append(numKilledReduces);
  346.     taskSummary.append("t").append(StringUtils.getFormattedTimeWithDiff(
  347.                                dateFormat, reduceStarted, 0));
  348.     taskSummary.append("t").append(StringUtils.getFormattedTimeWithDiff(
  349.                                dateFormat, reduceFinished, reduceStarted)); 
  350.     taskSummary.append("nCleanupt").append(totalCleanups);
  351.     taskSummary.append("t").append(numFinishedCleanups);
  352.     taskSummary.append("tt").append(numFailedCleanups);
  353.     taskSummary.append("t").append(numKilledCleanups);
  354.     taskSummary.append("t").append(StringUtils.getFormattedTimeWithDiff(
  355.                                dateFormat, cleanupStarted, 0));
  356.     taskSummary.append("t").append(StringUtils.getFormattedTimeWithDiff(
  357.                                dateFormat, cleanupFinished, cleanupStarted)); 
  358.     taskSummary.append("n============================n");
  359.     System.out.println(taskSummary.toString());
  360.   }
  361.   
  362.   private void printFailedAttempts(NodesFilter filter) throws IOException {
  363.     JobHistory.parseHistoryFromFS(jobLogFile, filter, fs); 
  364.     Map<String, Set<String>> badNodes = filter.getValues();
  365.     StringBuffer attempts = new StringBuffer(); 
  366.     if (badNodes.size() > 0) {
  367.       attempts.append("n").append(filter.getFailureType());
  368.       attempts.append(" task attempts by nodes");
  369.       attempts.append("nHostnametFailedTasks");
  370.       attempts.append("n===============================");
  371.       System.out.println(attempts.toString());
  372.       for (Map.Entry<String, Set<String>> entry : badNodes.entrySet()) {
  373.         String node = entry.getKey();
  374.         Set<String> failedTasks = entry.getValue();
  375.         attempts.setLength(0);
  376.         attempts.append(node).append("t");
  377.         for (String t : failedTasks) {
  378.           attempts.append(t).append(", ");
  379.         }
  380.         System.out.println(attempts.toString());
  381.       }
  382.     }
  383.   }
  384.   
  385.   private void printJobAnalysis() {
  386.     if (!Values.SUCCESS.name().equals(job.get(Keys.JOB_STATUS))) {
  387.       System.out.println("No Analysis available as job did not finish");
  388.       return;
  389.     }
  390.     
  391.     Map<String, JobHistory.Task> tasks = job.getAllTasks();
  392.     int finishedMaps = job.getInt(Keys.FINISHED_MAPS);
  393.     int finishedReduces = job.getInt(Keys.FINISHED_REDUCES);
  394.     JobHistory.Task [] mapTasks = new JobHistory.Task[finishedMaps]; 
  395.     JobHistory.Task [] reduceTasks = new JobHistory.Task[finishedReduces]; 
  396.     int mapIndex = 0 , reduceIndex=0; 
  397.     long avgMapTime = 0;
  398.     long avgReduceTime = 0;
  399.     long avgShuffleTime = 0;
  401.     for (JobHistory.Task task : tasks.values()) {
  402.       Map<String, TaskAttempt> attempts = task.getTaskAttempts();
  403.       for (JobHistory.TaskAttempt attempt : attempts.values()) {
  404.         if (attempt.get(Keys.TASK_STATUS).equals(Values.SUCCESS.name())) {
  405.           long avgFinishTime = (attempt.getLong(Keys.FINISH_TIME) -
  406.                                 attempt.getLong(Keys.START_TIME));
  407.           if (Values.MAP.name().equals(task.get(Keys.TASK_TYPE))) {
  408.             mapTasks[mapIndex++] = attempt; 
  409.             avgMapTime += avgFinishTime;
  410.           } else if (Values.REDUCE.name().equals(task.get(Keys.TASK_TYPE))) { 
  411.             reduceTasks[reduceIndex++] = attempt;
  412.             avgShuffleTime += (attempt.getLong(Keys.SHUFFLE_FINISHED) - 
  413.                                attempt.getLong(Keys.START_TIME));
  414.             avgReduceTime += (attempt.getLong(Keys.FINISH_TIME) -
  415.                               attempt.getLong(Keys.SHUFFLE_FINISHED));
  416.           }
  417.           break;
  418.         }
  419.       }
  420.     }
  421.     if (finishedMaps > 0) {
  422.       avgMapTime /= finishedMaps;
  423.     }
  424.     if (finishedReduces > 0) {
  425.       avgReduceTime /= finishedReduces;
  426.       avgShuffleTime /= finishedReduces;
  427.     }
  428.     System.out.println("nAnalysis");
  429.     System.out.println("=========");
  430.     printAnalysis(mapTasks, cMap, "map", avgMapTime, 10);
  431.     printLast(mapTasks, "map", cFinishMapRed);
  433.     if (reduceTasks.length > 0) {
  434.       printAnalysis(reduceTasks, cShuffle, "shuffle", avgShuffleTime, 10);
  435.       printLast(reduceTasks, "shuffle", cFinishShuffle);
  437.       printAnalysis(reduceTasks, cReduce, "reduce", avgReduceTime, 10);
  438.       printLast(reduceTasks, "reduce", cFinishMapRed);
  439.     }
  440.     System.out.println("=========");
  441.   }
  442.   
  443.   private void printLast(JobHistory.Task [] tasks,
  444.                          String taskType,
  445.                          Comparator<JobHistory.Task> cmp
  446.                          ) {
  447.     Arrays.sort(tasks, cFinishMapRed);
  448.     JobHistory.Task last = tasks[0];
  449.     StringBuffer lastBuf = new StringBuffer();
  450.     lastBuf.append("The last ").append(taskType);
  451.     lastBuf.append(" task ").append(last.get(Keys.TASKID));
  452.     Long finishTime;
  453.     if ("shuffle".equals(taskType)) {
  454.       finishTime = last.getLong(Keys.SHUFFLE_FINISHED);
  455.     } else {
  456.       finishTime = last.getLong(Keys.FINISH_TIME);
  457.     }
  458.     lastBuf.append(" finished at (relative to the Job launch time): ");
  459.     lastBuf.append(StringUtils.getFormattedTimeWithDiff(dateFormat,
  460.                                  finishTime, job.getLong(Keys.LAUNCH_TIME)));
  461.     System.out.println(lastBuf.toString());
  462.   }
  464.   private void printAnalysis(JobHistory.Task [] tasks,
  465.                              Comparator<JobHistory.Task> cmp,
  466.                              String taskType,
  467.                              long avg,
  468.                              int showTasks) {
  469.     Arrays.sort(tasks, cmp);
  470.     JobHistory.Task min = tasks[tasks.length-1];
  471.     StringBuffer details = new StringBuffer();
  472.     details.append("nTime taken by best performing ");
  473.     details.append(taskType).append(" task ");
  474.     details.append(min.get(Keys.TASKID)).append(": ");
  475.     if ("map".equals(taskType)) {
  476.       details.append(StringUtils.formatTimeDiff(
  477.                      min.getLong(Keys.FINISH_TIME),
  478.                      min.getLong(Keys.START_TIME)));
  479.     } else if ("shuffle".equals(taskType)) {
  480.       details.append(StringUtils.formatTimeDiff(
  481.                      min.getLong(Keys.SHUFFLE_FINISHED),
  482.                      min.getLong(Keys.START_TIME)));
  483.     } else {
  484.       details.append(StringUtils.formatTimeDiff(
  485.                 min.getLong(Keys.FINISH_TIME),
  486.                 min.getLong(Keys.SHUFFLE_FINISHED)));
  487.     }
  488.     details.append("nAverage time taken by ");
  489.     details.append(taskType).append(" tasks: "); 
  490.     details.append(StringUtils.formatTimeDiff(avg, 0));
  491.     details.append("nWorse performing ");
  492.     details.append(taskType).append(" tasks: ");
  493.     details.append("nTaskIdttTimetaken");
  494.     System.out.println(details.toString());
  495.     for (int i = 0; i < showTasks && i < tasks.length; i++) {
  496.       details.setLength(0);
  497.       details.append(tasks[i].get(Keys.TASKID)).append(" ");
  498.       if ("map".equals(taskType)) {
  499.         details.append(StringUtils.formatTimeDiff(
  500.                        tasks[i].getLong(Keys.FINISH_TIME),
  501.                        tasks[i].getLong(Keys.START_TIME)));
  502.       } else if ("shuffle".equals(taskType)) {
  503.         details.append(StringUtils.formatTimeDiff(
  504.                        tasks[i].getLong(Keys.SHUFFLE_FINISHED),
  505.                        tasks[i].getLong(Keys.START_TIME)));
  506.       } else {
  507.         details.append(StringUtils.formatTimeDiff(
  508.                        tasks[i].getLong(Keys.FINISH_TIME),
  509.                        tasks[i].getLong(Keys.SHUFFLE_FINISHED)));
  510.       }
  511.       System.out.println(details.toString());
  512.     }
  513.   }
  514.   
  515.   private Comparator<JobHistory.Task> cMap = 
  516.                                         new Comparator<JobHistory.Task>() {
  517.     public int compare(JobHistory.Task t1, JobHistory.Task t2) {
  518.       long l1 = t1.getLong(Keys.FINISH_TIME) - t1.getLong(Keys.START_TIME);
  519.       long l2 = t2.getLong(Keys.FINISH_TIME) - t2.getLong(Keys.START_TIME);
  520.       return (l2 < l1 ? -1 : (l2 == l1 ? 0 : 1));
  521.     }
  522.   };
  523.   
  524.   private Comparator<JobHistory.Task> cShuffle = 
  525.     new Comparator<JobHistory.Task>() {
  526.     public int compare(JobHistory.Task t1, JobHistory.Task t2) {
  527.       long l1 = t1.getLong(Keys.SHUFFLE_FINISHED) - 
  528.                 t1.getLong(Keys.START_TIME);
  529.       long l2 = t2.getLong(Keys.SHUFFLE_FINISHED) -
  530.                 t2.getLong(Keys.START_TIME);
  531.       return (l2 < l1 ? -1 : (l2 == l1 ? 0 : 1));
  532.     }
  533.   };
  535.   private Comparator<JobHistory.Task> cFinishShuffle = 
  536.     new Comparator<JobHistory.Task>() {
  537.     public int compare(JobHistory.Task t1, JobHistory.Task t2) {
  538.       long l1 = t1.getLong(Keys.SHUFFLE_FINISHED); 
  539.       long l2 = t2.getLong(Keys.SHUFFLE_FINISHED);
  540.       return (l2 < l1 ? -1 : (l2 == l1 ? 0 : 1));
  541.     }
  542.   };
  544.   private Comparator<JobHistory.Task> cFinishMapRed = 
  545.     new Comparator<JobHistory.Task>() {
  546.     public int compare(JobHistory.Task t1, JobHistory.Task t2) {
  547.       long l1 = t1.getLong(Keys.FINISH_TIME); 
  548.       long l2 = t2.getLong(Keys.FINISH_TIME);
  549.       return (l2 < l1 ? -1 : (l2 == l1 ? 0 : 1));
  550.     }
  551.   };
  552.   
  553.   private Comparator<JobHistory.Task> cReduce = 
  554.     new Comparator<JobHistory.Task>() {
  555.     public int compare(JobHistory.Task t1, JobHistory.Task t2) {
  556.       long l1 = t1.getLong(Keys.FINISH_TIME) -
  557.                 t1.getLong(Keys.SHUFFLE_FINISHED);
  558.       long l2 = t2.getLong(Keys.FINISH_TIME) -
  559.                 t2.getLong(Keys.SHUFFLE_FINISHED);
  560.       return (l2 < l1 ? -1 : (l2 == l1 ? 0 : 1));
  561.     }
  562.   }; 
  563. }