diff --git a/src/benchmarks/gc/GC.Infrastructure/Configurations/GCPerfSim/GCPerfSimFunctionalRun.yaml b/src/benchmarks/gc/GC.Infrastructure/Configurations/GCPerfSim/GCPerfSimFunctionalRun.yaml new file mode 100644 index 00000000000..5ef21cdd2a4 --- /dev/null +++ b/src/benchmarks/gc/GC.Infrastructure/Configurations/GCPerfSim/GCPerfSimFunctionalRun.yaml @@ -0,0 +1,18 @@ +output_path: C:\Outputs\GCPerfsimFunctionalTest +gcperfsim_path: C:\performance\artifacts\bin\GCPerfSim\release\net7.0\GCPerfSim.dll + +coreruns: + segments: + path: C:\runtime_rc2\artifacts\tests\coreclr\windows.x64.Release\Tests\Core_Root\corerun.exe + environment_variables: + COMPlus_GCName: clrgc.dll + regions: + path: C:\runtime_ga\artifacts\tests\coreclr\windows.x64.Release\Tests\Core_Root\corerun.exe + environment_variables: + COMPlus_GCName: clrgc.dll + +environment: + environment_variables: + COMPlus_GCName: clrgc.dll + +trace_configuration_type: gc # Choose between: none, gc, verbose, cpu, cpu_managed, threadtime, join. \ No newline at end of file diff --git a/src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure.Core/Configurations/GCPerfSimFunctional.Configuration.cs b/src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure.Core/Configurations/GCPerfSimFunctional.Configuration.cs new file mode 100644 index 00000000000..477770dfbfb --- /dev/null +++ b/src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure.Core/Configurations/GCPerfSimFunctional.Configuration.cs @@ -0,0 +1,64 @@ +using GC.Infrastructure.Core.Configurations.GCPerfSim; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace GC.Infrastructure.Core.Configurations +{ + public sealed class GCPerfSimFunctionalConfiguration + { + public string output_path { get; set; } + public string gcperfsim_path { get; set; } + public Dictionary coreruns { get; set; } + public Environment Environment { get; set; } = new(); + public string trace_configuration_type { get; set; } = "gc"; + } + public class Environment + { + public Dictionary environment_variables { get; set; } = new(); + } + + public static class GCPerfSimFunctionalConfigurationParser + { + public static GCPerfSimFunctionalConfiguration Parse(string path) + { + string serializedConfiguration = File.ReadAllText(path); + + GCPerfSimFunctionalConfiguration? configuration = null; + + try + { + configuration = Common.Deserializer.Deserialize(serializedConfiguration); + } + catch (Exception ex) + { + throw new ArgumentException($"{nameof(GCPerfSimFunctionalConfigurationParser)}: Unable to parse the yaml file because of an error in the syntax. Please use the configurations under: Configuration/GCPerfSim/*.yaml in as example to ensure the file is formatted correctly. Exception: {ex.Message} \n Call Stack: {ex.StackTrace}"); + } + + // Preconditions. + if (configuration.coreruns == null) + { + throw new ArgumentException($"{nameof(GCPerfSimFunctionalConfigurationParser)}: Provide a set of coreruns use for the analysis."); + } + + if (string.IsNullOrEmpty(configuration.output_path)) + { + throw new ArgumentException($"{nameof(GCPerfSimFunctionalConfigurationParser)}: Provide an output path."); + } + + if (string.IsNullOrEmpty(configuration.gcperfsim_path) || !File.Exists(configuration.gcperfsim_path)) + { + throw new ArgumentException($"{nameof(GCPerfSimFunctionalConfigurationParser)}: A path to the gcperfsim dll must be provided or exist."); + } + + if (configuration.trace_configuration_type == null || string.IsNullOrEmpty(configuration?.trace_configuration_type)) + { + throw new ArgumentException($"{nameof(GCPerfSimFunctionalConfigurationParser)}: Please provide the trace_configuration type"); + } + + return configuration; + } + } +} diff --git a/src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure.Core/Presentation/MarkdownReportBuilder.cs b/src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure.Core/Presentation/MarkdownReportBuilder.cs index 23de5e0187a..188e8dba8ce 100644 --- a/src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure.Core/Presentation/MarkdownReportBuilder.cs +++ b/src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure.Core/Presentation/MarkdownReportBuilder.cs @@ -81,6 +81,24 @@ public static void AddIncompleteTestsSection(this StreamWriter sw, Dictionary executionDetails) + { + sw.WriteLine($"# Incomplete Tests: {yamlFileName}.yaml"); + + foreach (var p in executionDetails) + { + if (p.Value.HasFailed) + { + sw.WriteLine($"### {p.Key}"); + sw.WriteLine($"Standard Error: {p.Value.StandardError}\n"); + sw.WriteLine(); + sw.WriteLine($"Standard Out: {p.Value.StandardOut}\n"); + sw.WriteLine(); + sw.WriteLine($"Repro: \n ```{p.Value.CommandlineArgs}```\n"); + } + } + } + public static void AddReproSection(this StreamWriter sw, Dictionary executionDetails) { sw.WriteLine("## Repro Steps"); diff --git a/src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure/Commands/GCPerfSim/GCPerfSimFunctionalCommand.cs b/src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure/Commands/GCPerfSim/GCPerfSimFunctionalCommand.cs new file mode 100644 index 00000000000..53367b91438 --- /dev/null +++ b/src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure/Commands/GCPerfSim/GCPerfSimFunctionalCommand.cs @@ -0,0 +1,394 @@ +using GC.Analysis.API; +using GC.Infrastructure.Commands.RunCommand; +using GC.Infrastructure.Core.Configurations; +using GC.Infrastructure.Core.Configurations.GCPerfSim; +using GC.Infrastructure.Core.Presentation; +using Spectre.Console; +using Spectre.Console.Cli; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Configuration; +using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using YamlDotNet.Serialization; + +namespace GC.Infrastructure.Commands.GCPerfSim +{ + public sealed class GCPerfSimFunctionalCommand : Command + { + private static readonly string _baseSuitePath = Path.Combine("Commands", "RunCommand", "BaseSuite"); + private static readonly string _gcPerfSimBase = Path.Combine(_baseSuitePath, "GCPerfSim_Normal_Workstation.yaml"); + private static readonly ISerializer _serializer = Common.Serializer; + private static readonly int _logicalProcessors = CreateSuitesCommand.GetAppropriateLogicalProcessors(); + + public sealed class GCPerfSimFunctionalSettings : CommandSettings + { + [Description("Path to Configuration.")] + [CommandOption("-c|--configuration")] + public string? ConfigurationPath { get; init; } + + [Description("Crank Server to target.")] + [CommandOption("-s|--server")] + public string? Server { get; init; } + } + + internal static void SaveConfiguration(ConfigurationBase configuration, string outputPath, string fileName) + { + var serializedResult = _serializer.Serialize(configuration); + File.WriteAllText(Path.Combine(outputPath, fileName), serializedResult); + } + + public override int Execute([NotNull] CommandContext context, [NotNull] GCPerfSimFunctionalSettings settings) + { + // I. Extract the configuration path. + string configurationPath = settings.ConfigurationPath; + + // Parse out the yaml file -> Memory as a C# object make use of that. + // Precondition checks. + ConfigurationChecker.VerifyFile(configurationPath, $"{nameof(GCPerfSimFunctionalCommand)}"); + GCPerfSimFunctionalConfiguration configuration = GCPerfSimFunctionalConfigurationParser.Parse(configurationPath); + + // II. Create the test suite for gcperfsim functional tests. + string gcPerfSimOutputPath = Path.Combine(configuration.output_path, "GCPerfSim"); + Core.Utilities.TryCreateDirectory(gcPerfSimOutputPath); + + string suitePath = Path.Combine(configuration.output_path, "Suites"); + string gcPerfSimSuitePath = Path.Combine(suitePath, "GCPerfSim_Functional"); + + Core.Utilities.TryCreateDirectory(gcPerfSimSuitePath); + + // For each of the scenarios below: + // a. Add the coreruns. + // b. Add the gcperfsim parameters that are pertinent to that run. + // c. Add any environment variables that will be related to that run. + + // 1. Normal Server + CreateNormalServerSuite(gcPerfSimSuitePath, configuration); + + // 2. Normal Workstation. + CreateNormalWorkstationSuite(gcPerfSimSuitePath, configuration); + + // 3. LowMemoryContainer. + CreateLowMemoryContainerSuite(gcPerfSimSuitePath, configuration); + + // 4. HighMemoryLoad. + CreateHighMemoryLoadSuite(gcPerfSimSuitePath, configuration); + + // 5. LargePage_Server + CreateLargePages_ServerSuite(gcPerfSimSuitePath, configuration); + + // 6. LargePage_Workstation + CreateLargePages_WorkstationSuite(gcPerfSimSuitePath, configuration); + + // III. Execute all the functional tests. + string[] gcperfsimConfigurationFileNames = Directory.GetFiles(gcPerfSimSuitePath, "*.yaml"); + + Dictionary yamlFileResultMap = new Dictionary(); + + foreach (string gcperfsimConfigurationFileName in gcperfsimConfigurationFileNames) + { + try + { + GCPerfSimConfiguration gcperfsimConfiguration = + GCPerfSimConfigurationParser.Parse(gcperfsimConfigurationFileName); + + Stopwatch sw = new(); + sw.Start(); + + AnsiConsole.Write(new Rule(gcperfsimConfiguration.Name)); + AnsiConsole.WriteLine(); + + // run the test + GCPerfSimResults gcperfsimResult = GCPerfSimCommand.RunGCPerfSim(gcperfsimConfiguration, settings.Server); + string yamlFileName = Path.GetFileNameWithoutExtension(gcperfsimConfigurationFileName); + yamlFileResultMap[yamlFileName] = gcperfsimResult; + + sw.Stop(); + AnsiConsole.WriteLine($"Time to execute Msec: {sw.ElapsedMilliseconds}"); + } + catch (Exception e) + { + Console.WriteLine(e.ToString()); + continue; + } + } + + // IV. Based on the results of the functional tests, we'd want to generate a report. + // Looking at all the runs data, we'd want to aggregate and create a markdown table of the following type: + // Output should live in Results.md in the output folder. + // TODO: If the run fails, what are the commands, failures and any debugging information that'll be helpful. + // | Yaml | Scenario | ✅ / ❌ | + // | ---- | -------- | ------------ | + // | Normal_Server.yaml | 0gb | Pass | + // | Normal_Workstation.yaml | 2gb_pinning | Fail | + string markdownPath = Path.Combine(configuration.output_path, "Results.md"); + using (StreamWriter resultWriter = new StreamWriter(markdownPath)) + { + resultWriter.WriteLine("| Yaml | Scenario | ✅ / ❌ |"); + resultWriter.WriteLine("| ---- | -------- | ------------ |"); + + StringBuilder resultContent = new StringBuilder(); + + foreach (var yamlFileNameResultPair in yamlFileResultMap) + { + string yamlFileName = yamlFileNameResultPair.Key; + GCPerfSimResults gcperfsimResult = yamlFileNameResultPair.Value; + foreach (var executionDetail in gcperfsimResult.ExecutionDetails) + { + string scenario = executionDetail.Key; + string testResult = executionDetail.Value.HasFailed == false ? "✅" : "❌"; + resultContent.AppendLine($"| {yamlFileName} | {scenario} | {testResult} |"); + } + } + + resultWriter.Write(resultContent.ToString()); + + foreach (var yamlFileNameResultPair in yamlFileResultMap) + { + string yamlFileName = yamlFileNameResultPair.Key; + GCPerfSimResults gcperfsimResult = yamlFileNameResultPair.Value; + + bool hasFailedTests = gcperfsimResult.ExecutionDetails.Any( + executionDetail => executionDetail.Value.HasFailed == true); + + if (hasFailedTests == true) + { + resultWriter.AddIncompleteTestsSectionWithYamlFileName( + yamlFileName, new(gcperfsimResult.ExecutionDetails)); + } + } + } + return 0; + } + + private void CreateNormalServerSuite(string gcPerfSimSuitePath, GCPerfSimFunctionalConfiguration configuration) + { + GCPerfSimConfiguration gcPerfSimNormalServerConfiguration = CreateBasicGCPerfSimConfiguration(configuration); + + // Set tc = 2 * logicalProcessors + gcPerfSimNormalServerConfiguration.gcperfsim_configurations.Parameters["tc"] = (_logicalProcessors * 2).ToString(); + gcPerfSimNormalServerConfiguration.gcperfsim_configurations.Parameters["tagb"] = "100"; + + // modify environment + gcPerfSimNormalServerConfiguration.Environment.environment_variables["COMPlus_GCServer"] = "1"; + gcPerfSimNormalServerConfiguration.Environment.environment_variables["COMPlus_GCHeapCount"] = _logicalProcessors.ToString("X"); + + // modify output + gcPerfSimNormalServerConfiguration.Output.Path = + Path.Combine(configuration.output_path, "Normal_Server"); + + // modify name + gcPerfSimNormalServerConfiguration.Name = "Normal_Server"; + + SaveConfiguration(gcPerfSimNormalServerConfiguration, gcPerfSimSuitePath, "Normal_Server.yaml"); + } + + private void CreateNormalWorkstationSuite(string gcPerfSimSuitePath, GCPerfSimFunctionalConfiguration configuration) + { + GCPerfSimConfiguration gcPerfSimNormalWorkstationConfiguration = CreateBasicGCPerfSimConfiguration(configuration); + + // modify gcperfsim_configurations + gcPerfSimNormalWorkstationConfiguration.gcperfsim_configurations.Parameters["tc"] = "2"; + gcPerfSimNormalWorkstationConfiguration.gcperfsim_configurations.Parameters["tagb"] = "100"; + + // modify output + gcPerfSimNormalWorkstationConfiguration.Output.Path = + Path.Combine(configuration.output_path, "Normal_Workstation"); + + // modify name + gcPerfSimNormalWorkstationConfiguration.Name = "Normal_Workstation"; + + SaveConfiguration(gcPerfSimNormalWorkstationConfiguration, gcPerfSimSuitePath, "Normal_Workstation.yaml"); + } + + private void CreateLowMemoryContainerSuite(string gcPerfSimSuitePath, GCPerfSimFunctionalConfiguration configuration) + { + GCPerfSimConfiguration gcPerfSimLowMemoryContainerConfiguration = CreateBasicGCPerfSimConfiguration(configuration); + + // modify runs + + gcPerfSimLowMemoryContainerConfiguration.Runs.Clear(); + + gcPerfSimLowMemoryContainerConfiguration.Runs["server"] = new Run + { + override_parameters = new Dictionary() + { + { "tc", (2 * _logicalProcessors).ToString() }, + { "tagb", "100" }, + { "tlgb", "0.45"} + } + }; + + gcPerfSimLowMemoryContainerConfiguration.Runs["workstation"] = new Run + { + override_parameters = new Dictionary() + { + { "tc", "2" }, + { "tlgb", "0.45" } // oom if set tlgb to 0.5 in workstation scenario + }, + environment_variables = new Dictionary() + { + {"COMPlus_GCServer", "0" }, + {"COMPlus_GCHeapCount", "1" }, + } + }; + + // modify gcperfsim_configurations + gcPerfSimLowMemoryContainerConfiguration.gcperfsim_configurations.Parameters["tc"] = (_logicalProcessors * 2).ToString(); + gcPerfSimLowMemoryContainerConfiguration.gcperfsim_configurations.Parameters["tagb"] = "100"; + gcPerfSimLowMemoryContainerConfiguration.gcperfsim_configurations.Parameters["tlgb"] = "0.1"; + gcPerfSimLowMemoryContainerConfiguration.gcperfsim_configurations.Parameters["sohsi"] = "50"; + gcPerfSimLowMemoryContainerConfiguration.gcperfsim_configurations.gcperfsim_path = + configuration.gcperfsim_path; + + // modify environment + gcPerfSimLowMemoryContainerConfiguration.Environment.environment_variables["COMPlus_GCServer"] = "1"; + gcPerfSimLowMemoryContainerConfiguration.Environment.environment_variables["COMPlus_GCHeapCount"] = "4"; + gcPerfSimLowMemoryContainerConfiguration.Environment.environment_variables["COMPlus_GCHeapHardLimit"] = "0x23C34600"; + gcPerfSimLowMemoryContainerConfiguration.Environment.environment_variables["COMPlus_GCTotalPhysicalMemory"] = "0x23C34600"; + + // modify output + gcPerfSimLowMemoryContainerConfiguration.Output.Path = + Path.Combine(configuration.output_path, "LowMemoryContainer"); + + // modify name + gcPerfSimLowMemoryContainerConfiguration.Name = "LowMemoryContainer"; + + SaveConfiguration(gcPerfSimLowMemoryContainerConfiguration, gcPerfSimSuitePath, "LowMemoryContainer.yaml"); + } + + private void CreateHighMemoryLoadSuite(string gcPerfSimSuitePath, GCPerfSimFunctionalConfiguration configuration) + { + GCPerfSimConfiguration gcPerfSimHighMemoryLoadConfiguration = CreateBasicGCPerfSimConfiguration(configuration); + + // modify runs + gcPerfSimHighMemoryLoadConfiguration.Runs.Clear(); + + gcPerfSimHighMemoryLoadConfiguration.Runs["server"] = new Run + { + override_parameters = new Dictionary() + { + { "tlgb", "3"}, + { "sohsi", "50"} + } + }; + + gcPerfSimHighMemoryLoadConfiguration.Runs["workstation"] = new Run + { + override_parameters = new Dictionary() + { + { "tlgb", "3" }, + { "sohsi", "50" } + }, + environment_variables = new Dictionary() + { + {"COMPlus_GCServer", "0" }, + } + }; + + // modify gcperfsim_configurations + gcPerfSimHighMemoryLoadConfiguration.gcperfsim_configurations.Parameters["tc"] = (_logicalProcessors * 2).ToString(); + gcPerfSimHighMemoryLoadConfiguration.gcperfsim_configurations.Parameters["tagb"] = "100"; + gcPerfSimHighMemoryLoadConfiguration.gcperfsim_configurations.Parameters["tlgb"] = "3"; + gcPerfSimHighMemoryLoadConfiguration.gcperfsim_configurations.gcperfsim_path = + configuration.gcperfsim_path; + + // modify environment + gcPerfSimHighMemoryLoadConfiguration.Environment.environment_variables["COMPlus_GCServer"] = "1"; + gcPerfSimHighMemoryLoadConfiguration.Environment.environment_variables["COMPlus_GCHeapCount"] = _logicalProcessors.ToString("X"); + + // add environment variables in GCPerfSimFunctionalRun.yaml + gcPerfSimHighMemoryLoadConfiguration.Environment.environment_variables["COMPlus_GCHeapHardLimit"] = "0x100000000"; + gcPerfSimHighMemoryLoadConfiguration.Environment.environment_variables["COMPlus_GCTotalPhysicalMemory"] = "0x100000000"; + + // modify output + gcPerfSimHighMemoryLoadConfiguration.Output.Path = + Path.Combine(configuration.output_path, "HighMemoryLoad"); + + // modify name + gcPerfSimHighMemoryLoadConfiguration.Name = "HighMemory_NormalServer"; + + SaveConfiguration(gcPerfSimHighMemoryLoadConfiguration, gcPerfSimSuitePath, "HighMemoryLoad.yaml"); + } + + private void CreateLargePages_ServerSuite(string gcPerfSimSuitePath, GCPerfSimFunctionalConfiguration configuration) + { + GCPerfSimConfiguration gcPerfSimLargePages_ServerConfiguration = CreateBasicGCPerfSimConfiguration(configuration); + + // Set tc = 2 * logicalProcessors + gcPerfSimLargePages_ServerConfiguration.gcperfsim_configurations.Parameters["tc"] = (_logicalProcessors * 2).ToString(); + gcPerfSimLargePages_ServerConfiguration.gcperfsim_configurations.Parameters["tagb"] = "100"; + + // modify environment + gcPerfSimLargePages_ServerConfiguration.Environment.environment_variables["COMPlus_GCServer"] = "1"; + gcPerfSimLargePages_ServerConfiguration.Environment.environment_variables["COMPlus_GCHeapCount"] = _logicalProcessors.ToString("X"); + gcPerfSimLargePages_ServerConfiguration.Environment.environment_variables["COMPlus_GCLargePages"] = "1"; + gcPerfSimLargePages_ServerConfiguration.Environment.environment_variables["COMPlus_GCHeapHardLimitSOH"] = "0x800000000"; + gcPerfSimLargePages_ServerConfiguration.Environment.environment_variables["COMPlus_GCHeapHardLimitLOH"] = "0x400000000"; + gcPerfSimLargePages_ServerConfiguration.Environment.environment_variables["COMPlus_GCHeapHardLimitPOH"] = "0x100000000"; + + // modify output + gcPerfSimLargePages_ServerConfiguration.Output.Path = + Path.Combine(configuration.output_path, "LargePages_Server"); + + // modify name + gcPerfSimLargePages_ServerConfiguration.Name = "LargePages_Server"; + + SaveConfiguration(gcPerfSimLargePages_ServerConfiguration, gcPerfSimSuitePath, "LargePages_Server.yaml"); + } + + private void CreateLargePages_WorkstationSuite(string gcPerfSimSuitePath, GCPerfSimFunctionalConfiguration configuration) + { + GCPerfSimConfiguration gcPerfSimLargePages_WorkstationConfiguration = CreateBasicGCPerfSimConfiguration(configuration); + + // Set tc = 2 * logicalProcessors + gcPerfSimLargePages_WorkstationConfiguration.gcperfsim_configurations.Parameters["tc"] = (_logicalProcessors * 2).ToString(); + gcPerfSimLargePages_WorkstationConfiguration.gcperfsim_configurations.Parameters["tagb"] = "100"; + + // modify environment + gcPerfSimLargePages_WorkstationConfiguration.Environment.environment_variables["COMPlus_GCServer"] = "1"; + gcPerfSimLargePages_WorkstationConfiguration.Environment.environment_variables["COMPlus_GCHeapCount"] = _logicalProcessors.ToString("X"); + gcPerfSimLargePages_WorkstationConfiguration.Environment.environment_variables["COMPlus_GCLargePages"] = "1"; + gcPerfSimLargePages_WorkstationConfiguration.Environment.environment_variables["COMPlus_GCHeapHardLimitSOH"] = "0x800000000"; + gcPerfSimLargePages_WorkstationConfiguration.Environment.environment_variables["COMPlus_GCHeapHardLimitLOH"] = "0x400000000"; + gcPerfSimLargePages_WorkstationConfiguration.Environment.environment_variables["COMPlus_GCHeapHardLimitPOH"] = "0x100000000"; + + // modify output + gcPerfSimLargePages_WorkstationConfiguration.Output.Path = + Path.Combine(configuration.output_path, "LargePages_Workstation"); + + // modify name + gcPerfSimLargePages_WorkstationConfiguration.Name = "LargePages_Workstation"; + + SaveConfiguration(gcPerfSimLargePages_WorkstationConfiguration, gcPerfSimSuitePath, "LargePages_Workstation.yaml"); + } + + private GCPerfSimConfiguration CreateBasicGCPerfSimConfiguration(GCPerfSimFunctionalConfiguration configuration) + { + GCPerfSimConfiguration gcPerfSimNormalWorkstationConfiguration = GCPerfSimConfigurationParser.Parse(_gcPerfSimBase, true); + + // modify gcperfsim_configurations + gcPerfSimNormalWorkstationConfiguration.gcperfsim_configurations.gcperfsim_path = + configuration.gcperfsim_path; + + // modify coreruns + gcPerfSimNormalWorkstationConfiguration.coreruns = new Dictionary(); + foreach (var keyValuePair in configuration.coreruns) + { + gcPerfSimNormalWorkstationConfiguration.coreruns[keyValuePair.Key] = keyValuePair.Value; + } + + // modify trace_configurations + gcPerfSimNormalWorkstationConfiguration.TraceConfigurations.Type = configuration.trace_configuration_type; + + // load environment variables + gcPerfSimNormalWorkstationConfiguration.Environment.environment_variables = configuration.Environment.environment_variables; + + return gcPerfSimNormalWorkstationConfiguration; + } + } +} diff --git a/src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure/Program.cs b/src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure/Program.cs index 3d24cd5abf2..a1d9d7a8e0b 100644 --- a/src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure/Program.cs +++ b/src/benchmarks/gc/GC.Infrastructure/GC.Infrastructure/Program.cs @@ -42,6 +42,7 @@ internal static void Main(string[] args) configuration.AddCommand("gcperfsim"); configuration.AddCommand("gcperfsim-analyze"); configuration.AddCommand("gcperfsim-compare"); + configuration.AddCommand("gcperfsim-functional"); // Microbenchmarks configuration.AddCommand("microbenchmarks"); diff --git a/src/benchmarks/gc/GC.Infrastructure/README.md b/src/benchmarks/gc/GC.Infrastructure/README.md index a766f684ffb..1b44bb7acb7 100644 --- a/src/benchmarks/gc/GC.Infrastructure/README.md +++ b/src/benchmarks/gc/GC.Infrastructure/README.md @@ -234,6 +234,7 @@ The infrastructure can be run in modular manner. What this means is that you can | gcperfsim | Runs a GCPerfSim Configuration - both orchestration and analysis. | ``gcperfsim --configuration Configuration.yaml [--server nameOfMachine]`` | | gcperfsim-analyze | Runs just the analysis portion of the GCPerfSim run assuming the traces are available. | ``gcperfsim-analyze --configuration Configuration.yaml`` | | gcperfsim-compare | Runs the comparison between two traces and generates a report for GCPerfSim runs. The acceptable file types are: ``.etl, .nettrace, .etl.zip`` | ``gcperfsim-compare --baseline Trace1Path --comparand Trace2Path --output PathToOutput.md`` | +| gcperfsim-functional | Runs the functional portion of the GCPerfSim Tests. | ``gcperfsim-functional --configuration Configuration.yaml`` | | microbenchmarks | Runs a Microbenchmark Configuration - both orchestration and analysis. | ``microbenchmarks --configuration Configuration.yaml`` | | microbenchmarks-analyze | Runs just the analysis portion of the Microbenchmark run assuming the traces are available. | ``microbenchmarks-analyze --configuration Configuration.yaml`` | | aspnetbenchmarks | Runs the ASPNet Benchmarks - both orchestration and analysis. | ``aspnetbenchmarks --configuration Configuration.yaml`` |