public override void StartStep(RunnablePip runnablePip, PipExecutionStep step)
{
if (step == PipExecutionStep.PostProcess)
{
ExecutionResult executionResult;
var removed = m_processExecutionResult.TryRemove(runnablePip.PipId, out executionResult);
Contract.Assert(removed, "Execution result must be stored from ExecuteProcess step for PostProcess");
runnablePip.SetExecutionResult(executionResult);
}
m_workerService.StartStep(runnablePip, step);
}
/// <inheritdoc />
public override async Task <PipResult> ExecuteIpcAsync(RunnablePip runnablePip)
{
using (OnPipExecutionStarted(runnablePip))
{
var environment = runnablePip.Environment;
var ipcPip = (IpcPip)runnablePip.Pip;
var operationContext = runnablePip.OperationContext;
Transition(runnablePip.PipId, WorkerPipState.Executing);
var executionResult = await PipExecutor.ExecuteIpcAsync(operationContext, environment, ipcPip);
runnablePip.SetExecutionResult(executionResult);
return(RunnablePip.CreatePipResultFromExecutionResult(runnablePip.StartTime, executionResult));
}
}
public void HandleRemoteResult(RunnablePip runnable, ExecutionResult executionResult)
{
var environment = runnable.Environment;
var operationContext = runnable.OperationContext;
var description = runnable.Description;
var pip = runnable.Pip;
var pipType = runnable.PipType;
bool isExecuteStep = runnable.Step == PipExecutionStep.ExecuteProcess || runnable.Step == PipExecutionStep.ExecuteNonProcessPip;
if (runnable.Step == PipExecutionStep.CacheLookup && executionResult.CacheLookupPerfInfo != null)
{
var perfInfo = executionResult.CacheLookupPerfInfo;
runnable.Performance.SetCacheLookupPerfInfo(perfInfo);
if (perfInfo.CacheMissType != PipCacheMissType.Invalid)
{
environment.Counters.IncrementCounter((PipExecutorCounter)perfInfo.CacheMissType);
}
}
if (isExecuteStep)
{
runnable.SetExecutionResult(executionResult);
}
if (executionResult.Result == PipResultStatus.Failed)
{
// Failure
m_masterService.Environment.Counters.IncrementCounter(pip.PipType == PipType.Process ? PipExecutorCounter.ProcessPipsFailedRemotely : PipExecutorCounter.IpcPipsFailedRemotely);
return;
}
if (!isExecuteStep)
{
return;
}
// Success
if (pipType == PipType.Process)
{
m_masterService.Environment.Counters.IncrementCounter(PipExecutorCounter.ProcessPipsSucceededRemotely);
// NOTE: Process outputs will be reported later during the PostProcess step.
}
else
{
Contract.Assert(pipType == PipType.Ipc);
m_masterService.Environment.Counters.IncrementCounter(PipExecutorCounter.IpcPipsSucceededRemotely);
// NOTE: Output content is reported for IPC but not Process because Process outputs will be reported
// later during PostProcess because cache convergence can change which outputs for a process are used
// Report the payload file of the IPC pip
foreach (var(fileArtifact, fileInfo, pipOutputOrigin) in executionResult.OutputContent)
{
environment.State.FileContentManager.ReportOutputContent(
operationContext,
description,
artifact: fileArtifact,
info: fileInfo,
origin: pipOutputOrigin);
}
}
}