public BuildResult Build(GenerateResult generateResult, BuildPartition buildPartition, ILogger logger)
{
var result = Roslyn.Builder.Instance.Build(generateResult, buildPartition, logger);
if (!result.IsBuildSuccess)
{
return(result);
}
var exePath = generateResult.ArtifactsPaths.ExecutablePath;
var monoRuntime = (MonoRuntime)buildPartition.Runtime;
var environmentVariables = string.IsNullOrEmpty(monoRuntime.MonoBclPath)
? null
: new Dictionary <string, string> {
{ "MONO_PATH", monoRuntime.MonoBclPath }
};
var(exitCode, output) = ProcessHelper.RunAndReadOutputLineByLine(
fileName: monoRuntime.CustomPath ?? "mono",
arguments: $"{monoRuntime.AotArgs} \"{Path.GetFullPath(exePath)}\"",
workingDirectory: Path.GetDirectoryName(exePath),
environmentVariables: environmentVariables,
includeErrors: true,
logger: logger);
return(exitCode != 0
? BuildResult.Failure(generateResult, $"Attempt to AOT failed: with exit code: {exitCode}, output: {string.Join(Environment.NewLine, output)}")
: result);
}
/// <summary>
/// generates project.lock.json that tells compiler where to take dlls and source from
/// and builds executable and copies all required dll's
/// </summary>
public BuildResult Build(GenerateResult generateResult, ILogger logger, Benchmark benchmark, IResolver resolver)
{
var restoreResult = DotNetCliCommandExecutor.ExecuteCommand(
RestoreCommand,
generateResult.ArtifactsPaths.BuildArtifactsDirectoryPath);
logger.WriteLineInfo($"// dotnet restore took {restoreResult.ExecutionTime.TotalSeconds:0.##}s");
if (!restoreResult.IsSuccess)
{
return(BuildResult.Failure(generateResult, new Exception(restoreResult.ProblemDescription)));
}
var buildResult = Build(generateResult);
logger.WriteLineInfo($"// dotnet build took {buildResult.ExecutionTime.TotalSeconds:0.##}s");
if (!buildResult.IsSuccess)
{
// dotnet cli could have succesfully builded the program, but returned 1 as exit code because it had some warnings
// so we need to check whether the exe exists or not, if it does then it is OK
if (File.Exists(generateResult.ArtifactsPaths.ExecutablePath))
{
return(BuildResult.Success(generateResult));
}
return(BuildResult.Failure(generateResult, new Exception(buildResult.ProblemDescription)));
}
return(BuildResult.Success(generateResult));
}
public BuildResult Build(GenerateResult generateResult, BuildPartition buildPartition, ILogger logger)
{
Assembly assembly = null;
Exception buildError = null;
try
{
assembly = RunnableEmitter.EmitPartitionAssembly(generateResult, buildPartition, logger);
}
catch (Exception ex)
{
buildError = ex;
}
if (buildError != null)
{
return(BuildResult.Failure(generateResult, buildError));
}
// HACK: use custom artifacts path class to pass the generated assembly.
return(BuildResult.Success(
GenerateResult.Success(
new InProcessEmitArtifactsPath(assembly, generateResult.ArtifactsPaths),
generateResult.ArtifactsToCleanup)));
}
public BuildResult RestoreThenBuildThenPublish()
{
var packagesResult = AddPackages();
if (!packagesResult.IsSuccess)
{
return(BuildResult.Failure(GenerateResult, new Exception(packagesResult.AllInformation)));
}
var restoreResult = Restore();
if (!restoreResult.IsSuccess)
{
return(BuildResult.Failure(GenerateResult, new Exception(restoreResult.AllInformation)));
}
var buildResult = Build();
if (!buildResult.IsSuccess) // if we failed to do the full build, let's try with --no-dependencies
{
buildResult = BuildNoDependencies();
}
if (!buildResult.IsSuccess)
{
return(BuildResult.Failure(GenerateResult, new Exception(buildResult.AllInformation)));
}
return(Publish().ToBuildResult(GenerateResult));
}
public BuildResult Build(GenerateResult generateResult, ILogger logger, Benchmark benchmark, IResolver resolver)
{
var extraArguments = DotNetCliGenerator.GetCustomArguments(benchmark, resolver);
var configurationName = benchmark.Job.ResolveValue(InfrastructureMode.BuildConfigurationCharacteristic, resolver);
var publishResult = DotNetCliCommandExecutor.ExecuteCommand(
CustomDotNetCliPath,
$"publish -c {configurationName} {extraArguments}",
generateResult.ArtifactsPaths.BuildArtifactsDirectoryPath);
if (!publishResult.IsSuccess &&
!File.Exists(generateResult.ArtifactsPaths.ExecutablePath)) // dotnet cli could have succesfully builded the program, but returned 1 as exit code because it had some warnings
{
return(BuildResult.Failure(generateResult, new Exception(publishResult.ProblemDescription)));
}
if (FilesToCopy != null)
{
var destinationFolder = Path.GetDirectoryName(generateResult.ArtifactsPaths.ExecutablePath);
foreach (var fileToCopy in FilesToCopy)
{
File.Copy(fileToCopy, Path.Combine(destinationFolder, Path.GetFileName(fileToCopy)), overwrite: true);
}
}
return(BuildResult.Success(generateResult));
}
public BuildResult Build(GenerateResult generateResult, BuildPartition buildPartition, ILogger logger)
{
string extraArguments = DotNetCliGenerator.GetCustomArguments(buildPartition.RepresentativeBenchmarkCase, buildPartition.Resolver);
var restoreResult = DotNetCliCommandExecutor.ExecuteCommand(
CustomDotNetCliPath,
$"{RestoreCommand} {extraArguments}",
generateResult.ArtifactsPaths.BuildArtifactsDirectoryPath,
logger);
if (!restoreResult.IsSuccess)
{
return(BuildResult.Failure(generateResult, new Exception(restoreResult.ProblemDescription)));
}
var buildResult = Build(generateResult, buildPartition.BuildConfiguration, extraArguments, logger);
if (!buildResult.IsSuccess)
{
// dotnet cli could have successfully built the program, but returned 1 as exit code because it had some warnings
// so we need to check whether the exe exists or not, if it does then it is OK
if (File.Exists(generateResult.ArtifactsPaths.ExecutablePath))
{
return(BuildResult.Success(generateResult));
}
return(BuildResult.Failure(generateResult, new Exception(buildResult.ProblemDescription)));
}
return(BuildResult.Success(generateResult));
}
private void Verify(string msbuildError, bool expectedResult, string expectedReason)
{
var sut = BuildResult.Failure(GenerateResult.Success(ArtifactsPaths.Empty, Array.Empty <string>()), msbuildError);
Assert.Equal(expectedResult, sut.TryToExplainFailureReason(out string reason));
Assert.Equal(expectedReason, reason);
}
/// <summary>
/// generates project.lock.json that tells compiler where to take dlls and source from
/// and builds executable and copies all required dll's
/// </summary>
public BuildResult Build(GenerateResult generateResult, ILogger logger, Benchmark benchmark, IResolver resolver)
{
if (!DotNetCliCommandExecutor.ExecuteCommand(
RestoreCommand,
generateResult.ArtifactsPaths.BuildArtifactsDirectoryPath,
logger,
DefaultTimeout))
{
return(BuildResult.Failure(generateResult, new Exception("dotnet restore has failed")));
}
if (!DotNetCliCommandExecutor.ExecuteCommand(
GetBuildCommand(TargetFrameworkMoniker),
generateResult.ArtifactsPaths.BuildArtifactsDirectoryPath,
logger,
DefaultTimeout))
{
// dotnet cli could have succesfully builded the program, but returned 1 as exit code because it had some warnings
// so we need to check whether the exe exists or not, if it does then it is OK
if (File.Exists(generateResult.ArtifactsPaths.ExecutablePath))
{
return(BuildResult.Success(generateResult));
}
return(BuildResult.Failure(generateResult));
}
return(BuildResult.Success(generateResult));
}
public BuildResult RestoreThenBuild()
{
var packagesResult = AddPackages();
if (!packagesResult.IsSuccess)
{
return(BuildResult.Failure(GenerateResult, packagesResult.AllInformation));
}
// there is no way to do tell dotnet restore which configuration to use (https://github.com/NuGet/Home/issues/5119)
// so when users go with custom build configuration, we must perform full build
// which will internally restore for the right configuration
if (BuildPartition.IsCustomBuildConfiguration)
{
return(Build().ToBuildResult(GenerateResult));
}
var restoreResult = Restore();
if (!restoreResult.IsSuccess)
{
return(BuildResult.Failure(GenerateResult, restoreResult.AllInformation));
}
var buildResult = BuildNoRestore();
if (!buildResult.IsSuccess) // if we fail to do the full build, we try with --no-dependencies
{
buildResult = BuildNoRestoreNoDependencies();
}
return(buildResult.ToBuildResult(GenerateResult));
}
public BuildResult RestoreThenBuildThenPublish()
{
var packagesResult = AddPackages();
if (!packagesResult.IsSuccess)
{
return(BuildResult.Failure(GenerateResult, packagesResult.AllInformation));
}
var restoreResult = Restore();
if (!restoreResult.IsSuccess)
{
return(BuildResult.Failure(GenerateResult, restoreResult.AllInformation));
}
var buildResult = BuildNoRestore();
if (!buildResult.IsSuccess)
{
return(BuildResult.Failure(GenerateResult, buildResult.AllInformation));
}
var publishResult = PublishNoBuildAndNoRestore();
return(publishResult.ToBuildResult(GenerateResult));
}
public BuildResult RestoreThenBuildThenPublish()
{
var packagesResult = AddPackages();
if (!packagesResult.IsSuccess)
{
return(BuildResult.Failure(GenerateResult, packagesResult.AllInformation));
}
var restoreResult = Restore();
if (!restoreResult.IsSuccess)
{
return(BuildResult.Failure(GenerateResult, restoreResult.AllInformation));
}
var buildResult = BuildNoRestore();
if (!buildResult.IsSuccess) // if we fail to do the full build, we try with --no-dependencies
{
buildResult = BuildNoRestoreNoDependencies();
}
if (!buildResult.IsSuccess)
{
return(BuildResult.Failure(GenerateResult, buildResult.AllInformation));
}
var publishResult = PublishNoBuildAndNoRestore();
return(publishResult.ToBuildResult(GenerateResult));
}
private static BenchmarkReport CreateFailureReport(BenchmarkCase benchmark)
{
GenerateResult generateResult = GenerateResult.Failure(ArtifactsPaths.Empty, Array.Empty <string>());
BuildResult buildResult = BuildResult.Failure(generateResult, string.Empty);
// Null may be legitimately passed as metrics to BenchmarkReport ctor here:
// https://github.com/dotnet/BenchmarkDotNet/blob/89255c9fceb1b27c475a93d08c152349be4199e9/src/BenchmarkDotNet/Running/BenchmarkRunner.cs#L197
return(new BenchmarkReport(false, benchmark, generateResult, buildResult, default, default, default, default));
private static BenchmarkReport RunCore(Benchmark benchmark, ILogger logger, ReadOnlyConfig config, string rootArtifactsFolderPath, Func <Job, IToolchain> toolchainProvider, IResolver resolver, List <string> artifactsToCleanup)
{
var toolchain = toolchainProvider(benchmark.Job);
logger.WriteLineHeader("// **************************");
logger.WriteLineHeader("// Benchmark: " + benchmark.DisplayInfo);
var assemblyResolveHelper = GetAssemblyResolveHelper(toolchain, logger);
var generateResult = Generate(logger, toolchain, benchmark, rootArtifactsFolderPath, config, resolver);
try
{
if (!generateResult.IsGenerateSuccess)
{
return(new BenchmarkReport(benchmark, generateResult, null, null, null, default(GcStats)));
}
var buildResult = Build(logger, toolchain, generateResult, benchmark, resolver);
if (!buildResult.IsBuildSuccess)
{
return(new BenchmarkReport(benchmark, generateResult, buildResult, null, null, default(GcStats)));
}
var(executeResults, gcStats) = Execute(logger, benchmark, toolchain, buildResult, config, resolver);
var runs = new List <Measurement>();
for (int index = 0; index < executeResults.Count; index++)
{
var executeResult = executeResults[index];
runs.AddRange(executeResult.Data.Select(line => Measurement.Parse(logger, line, index + 1)).Where(r => r.IterationMode != IterationMode.Unknown));
}
return(new BenchmarkReport(benchmark, generateResult, buildResult, executeResults, runs, gcStats));
}
catch (Exception e)
{
logger.WriteLineError("// Exception: " + e);
return(new BenchmarkReport(benchmark, generateResult, BuildResult.Failure(generateResult, e), Array.Empty <ExecuteResult>(), Array.Empty <Measurement>(), GcStats.Empty));
}
finally
{
if (!config.KeepBenchmarkFiles)
{
artifactsToCleanup.AddRange(generateResult.ArtifactsToCleanup);
}
assemblyResolveHelper?.Dispose();
}
}
public BuildResult RestoreThenBuild()
{
var restoreResult = Restore();
if (!restoreResult.IsSuccess)
{
return(BuildResult.Failure(GenerateResult, new Exception(restoreResult.ProblemDescription)));
}
var buildResult = Build().ToBuildResult(GenerateResult);
if (!buildResult.IsBuildSuccess) // if we failed to do the full build, let's try with --no-dependencies
{
buildResult = BuildNoDependencies().ToBuildResult(GenerateResult);
}
return(buildResult);
}
public BuildResult Build(GenerateResult generateResult, ILogger logger, Benchmark benchmark, IResolver resolver)
{
logger.WriteLineInfo($"BuildScript: {generateResult.ArtifactsPaths.BuildScriptFilePath}");
var syntaxTree = CSharpSyntaxTree.ParseText(File.ReadAllText(generateResult.ArtifactsPaths.ProgramCodePath));
var compilationOptions = new CSharpCompilationOptions(
outputKind: OutputKind.ConsoleApplication,
optimizationLevel: OptimizationLevel.Release,
allowUnsafe: true,
platform: GetPlatform(benchmark.Job.ResolveValue(EnvMode.PlatformCharacteristic, resolver)),
deterministic: true);
var references = Generator
.GetAllReferences(benchmark)
.Select(assembly => AssemblyMetadata.CreateFromFile(assembly.Location))
.Concat(FrameworkAssembliesMetadata.Value)
.Distinct()
.Select(uniqueMetadata => uniqueMetadata.GetReference());
var compilation = CSharpCompilation
.Create(assemblyName: Path.GetFileName(generateResult.ArtifactsPaths.ExecutablePath))
.AddSyntaxTrees(syntaxTree)
.WithOptions(compilationOptions)
.AddReferences(references);
using (var executable = File.Create(generateResult.ArtifactsPaths.ExecutablePath))
{
var emitResult = compilation.Emit(executable);
if (emitResult.Success)
{
return(BuildResult.Success(generateResult));
}
foreach (var diagnostic in emitResult.Diagnostics
.Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error))
{
logger.WriteError($"{diagnostic.Id}: {diagnostic.GetMessage()}");
}
return(BuildResult.Failure(generateResult));
}
}
public BuildResult Build(GenerateResult generateResult, BuildPartition buildPartition, ILogger logger)
{
logger.WriteLineInfo($"BuildScript: {generateResult.ArtifactsPaths.BuildScriptFilePath}");
CancellationTokenSource cts = new CancellationTokenSource(buildPartition.Timeout);
try
{
return(Build(generateResult, buildPartition, logger, cts.Token));
}
catch (OperationCanceledException)
{
return(BuildResult.Failure(generateResult, $"The configured timeout {buildPartition.Timeout} was reached!"));
}
finally
{
cts.Dispose();
}
}
private static BuildResult Build(Benchmark benchmark, ReadOnlyConfig config, string rootArtifactsFolderPath, Func <Job, IToolchain> toolchainProvider, IResolver resolver)
{
var toolchain = toolchainProvider(benchmark.Job);
var generateResult = toolchain.Generator.GenerateProject(benchmark, NullLogger.Instance, rootArtifactsFolderPath, config, resolver);
try
{
if (!generateResult.IsGenerateSuccess)
{
return(BuildResult.Failure(generateResult));
}
return(toolchain.Builder.Build(generateResult, NullLogger.Instance, benchmark, resolver));
}
catch (Exception e)
{
return(BuildResult.Failure(generateResult, e));
}
}
public BuildResult Build(
GenerateResult generateResult,
ILogger logger,
Benchmark benchmark,
IResolver resolver)
{
if (!(benchmark is ExternalProcessBenchmark externalProcessBenchmark))
{
return(BuildResult.Failure(generateResult));
}
var exitCode = externalProcessBenchmark.BuildFunc((string)benchmark.Parameters["Commit"]);
if (exitCode != 0)
{
return(BuildResult.Failure(generateResult));
}
return(BuildResult.Success(generateResult));
}
public BuildResult Build(GenerateResult generateResult, ILogger logger, Benchmark benchmark, IResolver resolver)
{
var extraArguments = DotNetCliGenerator.GetCustomArguments(benchmark, resolver);
if (!string.IsNullOrEmpty(RestoreCommand))
{
var restoreResult = DotNetCliCommandExecutor.ExecuteCommand(
CustomDotNetCliPath,
$"{RestoreCommand} {extraArguments}",
generateResult.ArtifactsPaths.BuildArtifactsDirectoryPath);
logger.WriteLineInfo($"// dotnet restore took {restoreResult.ExecutionTime.TotalSeconds:0.##}s");
if (!restoreResult.IsSuccess)
{
return(BuildResult.Failure(generateResult, new Exception(restoreResult.ProblemDescription)));
}
}
var buildResult = Build(
generateResult,
benchmark.Job.ResolveValue(InfrastructureMode.BuildConfigurationCharacteristic, resolver),
extraArguments);
logger.WriteLineInfo($"// dotnet build/publish took {buildResult.ExecutionTime.TotalSeconds:0.##}s");
if (!buildResult.IsSuccess)
{
// dotnet cli could have succesfully builded the program, but returned 1 as exit code because it had some warnings
// so we need to check whether the exe exists or not, if it does then it is OK
if (File.Exists(generateResult.ArtifactsPaths.ExecutablePath))
{
return(BuildResult.Success(generateResult));
}
return(BuildResult.Failure(generateResult, new Exception(buildResult.ProblemDescription)));
}
return(BuildResult.Success(generateResult));
}
public BuildResult ToBuildResult(GenerateResult generateResult)
=> IsSuccess || File.Exists(generateResult.ArtifactsPaths.ExecutablePath) // dotnet cli could have successfully built the program, but returned 1 as exit code because it had some warnings
? BuildResult.Success(generateResult)
: BuildResult.Failure(generateResult, AllInformation);