private OutputRequest FulfilRequest(Simulation simulation, SimInput serieInput)
{
Log.Debug($"{nameof(SimData)} retrieving output");
var serie = simulation.LoadData(serieInput);
_outputs.TryAdd(
(serieInput.Hash, simulation),
SimDataOutput.Create(simulation, serieInput, serie, OutputOrigin.Storage, DateTime.UtcNow, false)
);
return(OutputRequest.Create(serieInput, Array(serieInput)));
}
private async Task <OutputRequest> FulfilRequestAsync(
Simulation simulation,
SimInput seriesInput,
ServerLicense serverLicense,
bool persist,
CancellationToken cancellationToken)
{
var serieInputs = await EvaluateNonScalarsAsync(
seriesInput,
simulation.SimConfig.SimInput,
serverLicense,
cancellationToken
);
Log.Debug($"Evaluating non-scalar parameter values produced n={serieInputs.Count} series");
var useExec = simulation.SimConfig.SimCode.Exec.IsAString();
async Task <(SimInput SerieInput, NumDataTable Serie, bool Persist, OutputOrigin OutputOrigin)> AcquireSerieDataAsync(SimInput serieInput)
{
if (simulation.HasData(serieInput))
{
Log.Debug($"{nameof(SimData)} retrieving data");
var retrieved = simulation.LoadData(serieInput);
return(serieInput, retrieved, false, OutputOrigin.Storage);
}
Log.Debug($"{nameof(SimData)} generating data");
var serieConfig = simulation.SimConfig.With(serieInput);
NumDataTable serie;
var stopWatch = Stopwatch.StartNew();
if (simulation.IsRSimulation())
{
var client = await serverLicense.GetRClientAsync(cancellationToken);
if (useExec)
{
var pathToCodeFile = simulation.PathToCodeFile;
RequireFile(pathToCodeFile);
await client.RunExecAsync(pathToCodeFile, serieConfig, cancellationToken);
serie = await client.TabulateExecOutputAsync(serieConfig, cancellationToken);
}
else
{
var pathToCodeFile = simulation.PopulateTemplate(serieConfig.SimInput.SimParameters);
await client.SourceFileAsync(pathToCodeFile, cancellationToken);
serie = await client.TabulateTmplOutputAsync(serieConfig, cancellationToken);
}
}
else
{
var mcsimExecutor = serverLicense.GetMCSimExecutor(simulation);
var numDataTable = mcsimExecutor.Execute(serieConfig.SimInput.SimParameters);
RequireNotNull(numDataTable, "MCSim execution failed");
serie = numDataTable;
}
stopWatch.Stop();
var msElapsed = 1000L * stopWatch.ElapsedTicks / Stopwatch.Frequency;
lock (_syncLock)
{
if (!_executionIntervals.TryGetValue(simulation, out SimExecutionInterval? executionInterval))
{
executionInterval = new SimExecutionInterval(simulation);
executionInterval.Load();
_executionIntervals.Add(simulation, executionInterval);
}
executionInterval.AddInterval(msElapsed);
}
return(serieInput, serie, persist, OutputOrigin.Generation);
}
var outputs = (await Task.WhenAll(serieInputs.Map(AcquireSerieDataAsync))).ToArr();
var outputsRequiringPersistence = outputs
.Filter(t =>
{
var didAdd = _outputs.TryAdd(
(t.SerieInput.Hash, simulation),
SimDataOutput.Create(simulation, t.SerieInput, t.Serie, t.OutputOrigin, DateTime.UtcNow, t.Persist)
);
return(didAdd && t.Persist);
});
if (!outputsRequiringPersistence.IsEmpty)
{
_mreDataService.Set();
}
return(OutputRequest.Create(
seriesInput,
outputs.Map(t => t.SerieInput)
));
}
