public void Run()
{
cancel = false;
tasksCompleted = 0;
// Время необходимо указывать во всех именах файлов, тк эксель не может открыть 2 файла с одинаковым названием.
string curTime = $"{DateTime.Now:yyyy'-'MM'-'dd'-T'HH'-'mm'-'ss}";
if (!Directory.Exists(resultsFolderPath))
{
Directory.CreateDirectory(resultsFolderPath);
}
curPath = resultsFolderPath + @"\" + curTime + @"\";
if (!Directory.Exists(curPath))
{
Directory.CreateDirectory(curPath);
}
string sysInfoPath = curPath + @"\System-Info_" + curTime + ".csv";
if (!File.Exists(sysInfoPath))
{
progressStatus = "Сбор информации о системе.";
FullSystemInfo.WriteFullSystemInfo(sysInfoPath);
}
string profilerFolderPath = curPath + @"\Profiler\";
if (!Directory.Exists(profilerFolderPath))
{
Directory.CreateDirectory(profilerFolderPath);
}
string logsFolderPath = curPath + @"\Logs\";
if (!Directory.Exists(logsFolderPath))
{
Directory.CreateDirectory(logsFolderPath);
}
string resultsPath = curPath + @"\Results_" + curTime + ".csv";
if (File.Exists(resultsPath))
{
File.SetAttributes(resultsPath, FileAttributes.Normal);
}
using (StreamWriter resFS = new StreamWriter(File.Create(resultsPath), Encoding.GetEncoding(1251)))
{
resFS.WriteLine(ExecutionResult.CsvNames());
foreach (string executable in executionParameters.executionFilesPaths)
{
foreach (string programTextFile in executionParameters.textProgramFilesPaths)
{
resFS.WriteLine(ExecutionResult.CsvEmpty());
string executableName = SaveName(string.IsNullOrEmpty(programTextFile)
? Path.GetFileNameWithoutExtension(executable)
: $"{Path.GetFileNameWithoutExtension(executable)}_{Path.GetFileNameWithoutExtension(programTextFile)}");
string logPath = $@"{logsFolderPath}\Log_{executableName}_{curTime}.txt";
if (File.Exists(logPath))
{
File.SetAttributes(logPath, FileAttributes.Normal);
}
using (StreamWriter outLogFS =
new StreamWriter(File.Create(logPath), Encoding.GetEncoding(1251)))
for (int par = 0; par < executionParameters.startParams.Count; ++par)
{
ExecutionResult executionResult = new ExecutionResult
{
programName = executableName,
interpArgs = executionParameters.interprParams[par],
arguments = executionParameters.startParams[par],
avgExecTime = 0,
variance = double.NaN,
maxCpuUsage = 0,
maxMemUsage = 0,
avgCpuUsage = 0,
execStatus = ExecutionStatus.Untested
};
outLogFS.WriteLine("\n------------------------------------------------------------");
outLogFS.WriteLine(executionResult.interpArgs + " " + executionResult.arguments);
outLogFS.WriteLine("------------------------------------------------------------");
int n = 0;
bool success = false;
for (var iteration = 1; iteration <= executionParameters.launchNum; ++iteration)
{
if (cancel)
{
return;
}
progressStatus =
$"Набор №{par + 1}. Проход №{iteration}. {executionResult.programName}";
if (executionResult.execStatus != ExecutionStatus.Success &&
executionResult.execStatus != ExecutionStatus.Untested ||
executionResult.variance < executionParameters.variance)
{
tasksCompleted++;
continue;
}
outLogFS.WriteLine(
"\n____________________________________________________________\n");
outLogFS.WriteLine($"Iteration: {iteration}\n");
StringBuilder profilerPathBuilder = new StringBuilder();
profilerPathBuilder.Append($@"{profilerFolderPath}\{executionResult.programName}_");
profilerPathBuilder.Append(SaveName(executionResult.interpArgs + " " + executionResult.arguments));
profilerPathBuilder.Append($"_{iteration}_{curTime}.csv");
string profilerPath = profilerPathBuilder.ToString();
if (File.Exists(profilerPath))
{
File.SetAttributes(profilerPath, FileAttributes.Normal);
}
if (string.IsNullOrEmpty(programTextFile))
{
profiler = new Profiler(executable,
executionResult.arguments,
profilerPath,
executionParameters.prohibitUsePageFile,
executionParameters.timeLimit);
}
else
{
profiler = new Profiler(executable,
$"{executionResult.interpArgs} \"{programTextFile}\" {executionResult.arguments}",
profilerPath,
executionParameters.prohibitUsePageFile,
executionParameters.timeLimit);
}
Profiler.ProfilerResultStatistic stats = profiler.StartProcess();
if (profiler.IsExceededMemory())
{
executionResult.execStatus = ExecutionStatus.ExceededMemory;
outLogFS.WriteLine("Exceeded memory!\n");
break;
}
else if (profiler.IsProcessCanceled())
{
executionResult.execStatus = ExecutionStatus.Cancel;
outLogFS.WriteLine("Canceled!\n");
}
else if (executionResult.execStatus == ExecutionStatus.Untested)
{
string refRes = "";
if (!String.IsNullOrEmpty(executionParameters.referenceResults[par]))
{
refRes = executionParameters.referenceResults[par];
}
try
{
success = checkAlgorithm.Check(refRes, stats.programResult.ToString(),
storage);
}
catch (Exception exc)
{
outLogFS.WriteLine($"Errored!\n{exc.InnerException ?? exc}\n");
//Main.ShowError("Check error.\n\n", exc.InnerException ?? exc);
success = false;
}
if (success)
{
executionResult.execStatus = ExecutionStatus.Success;
}
else
{
executionResult.execStatus = ExecutionStatus.Error;
}
}
++n;
if (n == 2)
{
executionResult.variance =
Math.Pow(stats.execTime - executionResult.avgExecTime, 2) / 2;
}
else if (n > 2)
{
executionResult.variance =
(executionResult.variance +
Math.Pow(stats.execTime - executionResult.avgExecTime, 2) / n -
executionResult.variance / (n - 1));
}
executionResult.avgExecTime =
executionResult.avgExecTime +
(stats.execTime - executionResult.avgExecTime) / n;
executionResult.avgCpuUsage =
executionResult.avgCpuUsage +
(stats.avgCpuUsage - executionResult.avgCpuUsage) / n;
if (executionResult.maxMemUsage < stats.maxMemUsage)
{
executionResult.maxMemUsage = stats.maxMemUsage;
}
if (executionResult.maxCpuUsage < stats.maxCpuUsage)
{
executionResult.maxCpuUsage = stats.maxCpuUsage;
}
profiler = null;
stats.LogToFile(outLogFS);
tasksCompleted++;
}
executionResult.threadsCount = CoreNumParser.parseCoreNum(executionResult.interpArgs);
resFS.WriteLine(executionResult.CsvResults());
}
}
}
}
}
