private static void GenerateProgramFile(string projectDir, Benchmark benchmark)
        {
            var isVoid = benchmark.Target.Method.ReturnType == typeof(void);

            var operationsPerInvoke = benchmark.Target.OperationsPerInvoke;

            var targetTypeNamespace = benchmark.Target.Type.Namespace;
            var targetMethodReturnTypeNamespace = benchmark.Target.Method.ReturnType == typeof(void)
                ? "System"
                : benchmark.Target.Method.ReturnType.Namespace;

            var targetTypeName = benchmark.Target.Type.FullName.Replace('+', '.');
            var targetMethodName = benchmark.Target.Method.Name;

            var targetMethodReturnType = isVoid
                ? "void"
                : benchmark.Target.Method.ReturnType.GetCorrectTypeName();
            var targetMethodResultHolder = isVoid
                ? "" :
                $"private {targetMethodReturnType} value;";
            var targetMethodHoldValue = isVoid
                ? ""
                : "value = ";
            var targetMethodDelegateType = isVoid
                ? "Action "
                : $"Func<{targetMethodReturnType}> ";
            var idleImplementation = isVoid
                ? ""
                : $"return default({targetMethodReturnType});";

            string runBenchmarkTemplate = "";
            switch (benchmark.Task.Configuration.Mode)
            {
                case BenchmarkMode.SingleRun:
                    runBenchmarkTemplate = GetTemplate("BenchmarkSingleRun.txt");
                    break;
                case BenchmarkMode.Throughput:
                    runBenchmarkTemplate = GetTemplate("BenchmarkThroughput.txt");
                    break;
            }

            var contentTemplate = GetTemplate("BenchmarkProgram.txt");
            var content = contentTemplate.
                Replace("$RunBenchmarkContent$", runBenchmarkTemplate).
                Replace("$OperationsPerInvoke$", operationsPerInvoke.ToInvariantString()).
                Replace("$TargetTypeNamespace$", targetTypeNamespace).
                Replace("$TargetMethodReturnTypeNamespace$", targetMethodReturnTypeNamespace).
                Replace("$TargetTypeName$", targetTypeName).
                Replace("$TargetMethodName$", targetMethodName).
                Replace("$TargetMethodResultHolder$", targetMethodResultHolder).
                Replace("$TargetMethodDelegateType$", targetMethodDelegateType).
                Replace("$TargetMethodHoldValue$", targetMethodHoldValue).
                Replace("$TargetMethodReturnType$", targetMethodReturnType).
                Replace("$IdleImplementation$", idleImplementation).
                Replace("$AdditionalLogic$", benchmark.Target.AdditionalLogic);

            string fileName = Path.Combine(projectDir, MainClassName + ".cs");
            File.WriteAllText(fileName, content);
        }
 public string GenerateProject(Benchmark benchmark)
 {
     var projectDir = CreateProjectDirectory(benchmark);
     GenerateProgramFile(projectDir, benchmark);
     GenerateProjectFile(projectDir, benchmark);
     GenerateAppConfigFile(projectDir, benchmark.Task.Configuration);
     return projectDir;
 }
        public BenchmarkCodeExtractor(Benchmark benchmark, Process process, string codeExeName, IBenchmarkLogger logger)
        {
            this.process = process;
            this.codeExeName = codeExeName;
            this.logger = logger;

            //Method name format: "BenchmarkDotNet.Samples.Infra.RunFast()" (NOTE: WITHOUT the return type)
            var methodInfo = benchmark.Target.Method;
            fullTypeName = methodInfo.DeclaringType.FullName;

            var methodParams = string.Join(", ", methodInfo.GetParameters().Select(p => p.ParameterType.FullName));
            fullMethodName = $"{fullTypeName}.{methodInfo.Name}({methodParams})";
        }
 private static string CreateProjectDirectory(Benchmark benchmark)
 {
     var directoryPath = Path.Combine(Directory.GetCurrentDirectory(), benchmark.Caption);
     try
     {
         if (Directory.Exists(directoryPath))
             Directory.Delete(directoryPath, true);
     }
     catch (Exception)
     {
         // Nevermind
     }
     if (!Directory.Exists(directoryPath))
         Directory.CreateDirectory(directoryPath);
     return directoryPath;
 }
예제 #5
0
        public BenchmarkReport Run(Benchmark benchmark, IList<string> importantPropertyNames)
        {
            Logger.WriteLineHeader("// **************************");
            Logger.WriteLineHeader("// Benchmark: " + benchmark.Description);
            var directoryPath = benchmarkProjectGenerator.GenerateProject(benchmark);
            Logger.WriteLineInfo("// Generated project: " + directoryPath);
            Logger.NewLine();
            Logger.WriteLineInfo("// Build:");
            var buildResult = benchmarkProjectGenerator.BuildProject(directoryPath, Logger);
            if (buildResult.OverallResult == BuildResultCode.Success)
            {
                Logger.WriteLineInfo("// OverallResult = Success");
            }
            else
            {
                Logger.WriteLineError("// OverallResult = Failure");
                if (buildResult.Exception != null)
                    Logger.WriteLineError(buildResult.Exception.Message);
                return new BenchmarkReport(benchmark, new BenchmarkRunReport[0]);
            }
            Logger.NewLine();
            var processCount = Math.Max(1, benchmark.Task.ProcessCount);
            var runReports = new List<BenchmarkRunReport>();
            var exeFileName = Path.Combine(directoryPath, "Program.exe");
            for (int processNumber = 0; processNumber < processCount; processNumber++)
            {
                Logger.WriteLineInfo($"// Run, Process: {processNumber + 1} / {processCount}");
                if (importantPropertyNames.Any())
                {
                    Logger.WriteInfo("// ");
                    foreach (var name in importantPropertyNames)
                        Logger.WriteInfo($"{name}={benchmark.Properties.GetValue(name)} ");
                    Logger.NewLine();
                }

                var executor = new BenchmarkExecutor(Logger);
                if (File.Exists(exeFileName))
                {
                    var lines = executor.Exec(exeFileName, benchmark.Task.Settings.ToArgs());
                    var iterRunReports = lines.Select(line => BenchmarkRunReport.Parse(Logger, line)).Where(r => r != null).ToList();
                    runReports.AddRange(iterRunReports);
                }
            }
            Logger.NewLine();
            return new BenchmarkReport(benchmark, runReports);
        }
예제 #6
0
        private BenchmarkReport Run(Benchmark benchmark, IList<string> importantPropertyNames, BenchmarkParameters parameters = null)
        {
            var flow = BenchmarkFlowFactory.CreateFlow(benchmark, Logger);

            Logger.WriteLineHeader("// **************************");
            Logger.WriteLineHeader("// Benchmark: " + benchmark.Description);

            var generateResult = Generate(flow);
            if (!generateResult.IsGenerateSuccess)
                return BenchmarkReport.CreateEmpty(benchmark, parameters);

            var buildResult = Build(flow, generateResult);
            if (!buildResult.IsBuildSuccess)
                return BenchmarkReport.CreateEmpty(benchmark, parameters);

            var runReports = Exec(benchmark, importantPropertyNames, parameters, flow, buildResult);
            return new BenchmarkReport(benchmark, runReports, parameters);
        }
예제 #7
0
        private List<BenchmarkRunReport> Exec(Benchmark benchmark, IList<string> importantPropertyNames, BenchmarkParameters parameters, IBenchmarkFlow flow, BenchmarkBuildResult buildResult)
        {
            Logger.WriteLineInfo("// *** Exec ***");
            var processCount = Math.Max(1, benchmark.Task.ProcessCount);
            var runReports = new List<BenchmarkRunReport>();

            for (int processNumber = 0; processNumber < processCount; processNumber++)
            {
                Logger.WriteLineInfo($"// Run, Process: {processNumber + 1} / {processCount}");
                if (parameters != null)
                    Logger.WriteLineInfo($"// {parameters.ToInfo()}");
                if (importantPropertyNames.Any())
                {
                    Logger.WriteInfo("// ");
                    foreach (var name in importantPropertyNames)
                        Logger.WriteInfo($"{name}={benchmark.Properties.GetValue(name)} ");
                    Logger.NewLine();
                }

                var execResult = flow.Exec(buildResult, parameters);

                if (execResult.FoundExecutable)
                {
                    var iterRunReports = execResult.Data.Select(line => BenchmarkRunReport.Parse(Logger, line)).Where(r => r != null).ToList();
                    runReports.AddRange(iterRunReports);
                }
                else
                {
                    Logger.WriteLineError("Executable not found");
                }
            }
            Logger.NewLine();
            return runReports;
        }
        private static void GenerateProjectFile(string projectDir, Benchmark benchmark)
        {
            var configuration = benchmark.Task.Configuration;
            var platform = configuration.Platform.ToConfig();
            var framework = configuration.Framework.ToConfig();

            var template = GetTemplate("BenchmarkCsproj.txt");
            var content = template.
                Replace("$Platform$", platform).
                Replace("$Framework$", framework).
                Replace("$TargetAssemblyReference$", GetReferenceToAssembly(benchmark.Target.Type)).
                Replace("$TargetMethodReturnTypeAssemblyReference$", GetReferenceToAssembly(benchmark.Target.Method.ReturnType));

            string fileName = Path.Combine(projectDir, MainClassName + ".csproj");
            File.WriteAllText(fileName, content);
        }
예제 #9
0
        private BenchmarkReport Run(IBenchmarkLogger logger, Benchmark benchmark, IList<string> importantPropertyNames, BenchmarkParameters parameters = null)
        {
            var toolchain = Plugins.CreateToolchain(benchmark, logger);

            logger.WriteLineHeader("// **************************");
            logger.WriteLineHeader("// Benchmark: " + benchmark.Description);

            var generateResult = Generate(logger, toolchain);
            if (!generateResult.IsGenerateSuccess)
                return BenchmarkReport.CreateEmpty(benchmark, parameters);

            var buildResult = Build(logger, toolchain, generateResult);
            if (!buildResult.IsBuildSuccess)
                return BenchmarkReport.CreateEmpty(benchmark, parameters);

            var runReports = Execute(logger, benchmark, importantPropertyNames, parameters, toolchain, buildResult);
            return new BenchmarkReport(benchmark, runReports, EnvironmentInfo.GetCurrentInfo(), parameters);
        }
        private static void GenerateProgramFile(string projectDir, Benchmark benchmark)
        {
            var isVoid = benchmark.Target.Method.ReturnType == typeof(void);

            var operationsPerInvoke = benchmark.Target.OperationsPerInvoke;

            var targetTypeNamespace = benchmark.Target.Type.Namespace;
            var targetMethodReturnTypeNamespace = benchmark.Target.Method.ReturnType == typeof(void)
                ? "System"
                : benchmark.Target.Method.ReturnType.Namespace;

            var targetTypeName = benchmark.Target.Type.FullName.Replace('+', '.');
            var targetMethodName = benchmark.Target.Method.Name;

            var targetMethodReturnType = isVoid
                ? "void"
                : benchmark.Target.Method.ReturnType.GetCorrectTypeName();
            var targetMethodResultHolder = isVoid
                ? "" :
                $"private {targetMethodReturnType} value;";
            var targetMethodHoldValue = isVoid
                ? ""
                : "value = ";
            var targetMethodDelegateType = isVoid
                ? "Action "
                : $"Func<{targetMethodReturnType}> ";

            // setupMethod is optional, so default to an empty delegate, so there is always something that can be invoked
            var setupMethodName = benchmark.Target.SetupMethod != null
                ? benchmark.Target.SetupMethod.Name
                : "() => { }";

            var idleImplementation = isVoid
                ? ""
                : $"return default({targetMethodReturnType});";

            var paramsContent = "";
            if (benchmark.Task.Params != null)
            {
                var typeQualifier = benchmark.Task.Params.IsStatic
                    ? $"{benchmark.Target.Type.Name}"
                    : "instance";
                paramsContent = $"{typeQualifier}.{benchmark.Task.Params.ParamFieldOrProperty} = BenchmarkParams.Parse(args);";
            }

            string runBenchmarkTemplate = "";
            switch (benchmark.Task.Configuration.Mode)
            {
                case BenchmarkMode.SingleRun:
                    runBenchmarkTemplate = GetTemplate("BenchmarkSingleRun.txt");
                    break;
                case BenchmarkMode.Throughput:
                    runBenchmarkTemplate = GetTemplate("BenchmarkThroughput.txt");
                    break;
            }

            var contentTemplate = GetTemplate("BenchmarkProgram.txt");
            var content = contentTemplate.
                Replace("$RunBenchmarkContent$", runBenchmarkTemplate).
                Replace("$OperationsPerInvoke$", operationsPerInvoke.ToInvariantString()).
                Replace("$TargetTypeNamespace$", targetTypeNamespace).
                Replace("$TargetMethodReturnTypeNamespace$", targetMethodReturnTypeNamespace).
                Replace("$TargetTypeName$", targetTypeName).
                Replace("$TargetMethodName$", targetMethodName).
                Replace("$TargetMethodResultHolder$", targetMethodResultHolder).
                Replace("$TargetMethodDelegateType$", targetMethodDelegateType).
                Replace("$TargetMethodHoldValue$", targetMethodHoldValue).
                Replace("$TargetMethodReturnType$", targetMethodReturnType).
                Replace("$SetupMethodName$", setupMethodName).
                Replace("$IdleImplementation$", idleImplementation).
                Replace("$AdditionalLogic$", benchmark.Target.AdditionalLogic)
               .Replace("$ParamsContent$", paramsContent);

            string fileName = Path.Combine(projectDir, MainClassName + ".cs");
            File.WriteAllText(fileName, content);
        }