Java TaskAttemptState.KILLED属性代码示例

public static TaskAttemptState toYarn(
    org.apache.hadoop.mapred.TaskStatus.State state) {
  switch (state) {
  case COMMIT_PENDING:
    return TaskAttemptState.COMMIT_PENDING;
  case FAILED:
  case FAILED_UNCLEAN:
    return TaskAttemptState.FAILED;
  case KILLED:
  case KILLED_UNCLEAN:
    return TaskAttemptState.KILLED;
  case RUNNING:
    return TaskAttemptState.RUNNING;
  case SUCCEEDED:
    return TaskAttemptState.SUCCEEDED;
  case UNASSIGNED:
    return TaskAttemptState.STARTING;
  default:
    throw new YarnRuntimeException("Unrecognized State: " + state);
  }
}
 

private static TaskAttemptState getExternalState(
    TaskAttemptStateInternal smState) {
  switch (smState) {
  case ASSIGNED:
  case UNASSIGNED:
    return TaskAttemptState.STARTING;
  case COMMIT_PENDING:
    return TaskAttemptState.COMMIT_PENDING;
  case FAILED:
    return TaskAttemptState.FAILED;
  case KILLED:
    return TaskAttemptState.KILLED;
    // All CLEANUP states considered as RUNNING since events have not gone out
    // to the Task yet. May be possible to consider them as a Finished state.
  case FAIL_CONTAINER_CLEANUP:
  case FAIL_TASK_CLEANUP:
  case KILL_CONTAINER_CLEANUP:
  case KILL_TASK_CLEANUP:
  case SUCCESS_CONTAINER_CLEANUP:
  case RUNNING:
    return TaskAttemptState.RUNNING;
  case NEW:
    return TaskAttemptState.NEW;
  case SUCCEEDED:
    return TaskAttemptState.SUCCEEDED;
  default:
    throw new YarnRuntimeException("Attempt to convert invalid "
        + "stateMachineTaskAttemptState to externalTaskAttemptState: "
        + smState);
  }
}
 

CompletedTaskAttempt(TaskId taskId, TaskAttemptInfo attemptInfo) {
  this.attemptInfo = attemptInfo;
  this.attemptId = TypeConverter.toYarn(attemptInfo.getAttemptId());
  if (attemptInfo.getTaskStatus() != null) {
    this.state = TaskAttemptState.valueOf(attemptInfo.getTaskStatus());
  } else {
    this.state = TaskAttemptState.KILLED;
    localDiagMessage = "Attmpt state missing from History : marked as KILLED";
    diagnostics.add(localDiagMessage);
  }
  if (attemptInfo.getError() != null) {
    diagnostics.add(attemptInfo.getError());
  }
}
 

protected static TaskAttemptState getExternalState(
    TaskAttemptStateInternal smState) {
  switch (smState) {
  case ASSIGNED:
  case UNASSIGNED:
    return TaskAttemptState.STARTING;
  case COMMIT_PENDING:
    return TaskAttemptState.COMMIT_PENDING;
  case FAIL_CONTAINER_CLEANUP:
  case FAIL_TASK_CLEANUP:
  case FAIL_FINISHING_CONTAINER:
  case FAILED:
    return TaskAttemptState.FAILED;
  case KILL_CONTAINER_CLEANUP:
  case KILL_TASK_CLEANUP:
  case KILLED:
    return TaskAttemptState.KILLED;
  case RUNNING:
    return TaskAttemptState.RUNNING;
  case NEW:
    return TaskAttemptState.NEW;
  case SUCCESS_CONTAINER_CLEANUP:
  case SUCCESS_FINISHING_CONTAINER:
  case SUCCEEDED:
    return TaskAttemptState.SUCCEEDED;
  default:
    throw new YarnRuntimeException("Attempt to convert invalid "
        + "stateMachineTaskAttemptState to externalTaskAttemptState: "
        + smState);
  }
}
 

@Override
public TaskAttemptState getState() {
  if (overridingState != null) {
    return overridingState;
  }
  TaskAttemptState result
      = getProgress() < 1.0F ? TaskAttemptState.RUNNING : TaskAttemptState.SUCCEEDED;

  if (result == TaskAttemptState.SUCCEEDED) {
    overridingState = TaskAttemptState.SUCCEEDED;

    System.out.println("MyTaskAttemptImpl.getState() -- attempt " + myAttemptID + " finished.");

    slotsInUse.addAndGet(- taskTypeSlots(myAttemptID.getTaskId().getTaskType()));

    (myAttemptID.getTaskId().getTaskType() == TaskType.MAP
        ? completedMaps : completedReduces).getAndIncrement();

    // check for a spectacularly successful speculation
    TaskId taskID = myAttemptID.getTaskId();

    Task task = myJob.getTask(taskID);

    for (TaskAttempt otherAttempt : task.getAttempts().values()) {
      if (otherAttempt != this
          && otherAttempt.getState() == TaskAttemptState.RUNNING) {
        // we had two instances running.  Try to determine how much
        //  we might have saved by speculation
        if (getID().getId() > otherAttempt.getID().getId()) {
          // the speculation won
          successfulSpeculations.getAndIncrement();
          float hisProgress = otherAttempt.getProgress();
          long hisStartTime = ((MyTaskAttemptImpl)otherAttempt).startMockTime;
          System.out.println("TLTRE:A speculation finished at time "
              + clock.getTime()
              + ".  The stalled attempt is at " + (hisProgress * 100.0)
              + "% progress, and it started at "
              + hisStartTime + ", which is "
              + (clock.getTime() - hisStartTime) + " ago.");
          long originalTaskEndEstimate
              = (hisStartTime
                  + estimator.estimatedRuntime(otherAttempt.getID()));
          System.out.println(
              "TLTRE: We would have expected the original attempt to take "
              + estimator.estimatedRuntime(otherAttempt.getID())
              + ", finishing at " + originalTaskEndEstimate);
          long estimatedSavings = originalTaskEndEstimate - clock.getTime();
          taskTimeSavedBySpeculation.addAndGet(estimatedSavings);
          System.out.println("TLTRE: The task is " + task.getID());
          slotsInUse.addAndGet(- taskTypeSlots(myAttemptID.getTaskId().getTaskType()));
          ((MyTaskAttemptImpl)otherAttempt).overridingState
              = TaskAttemptState.KILLED;
        } else {
          System.out.println(
              "TLTRE: The normal attempt beat the speculation in "
              + task.getID());
        }
      }
    }
  }

  return result;
}