Add AOT options to wasm runtime (#1722)

Author: Nathan Ricci

samples/BenchmarkDotNet.Samples/.BenchmarkDotNet.Samples.csproj.swp

@@ -190,6 +190,9 @@ public class CommandLineOptions
         [Option("AOTCompilerMode", Required = false, Default = MonoAotCompilerMode.mini, HelpText = "Mono AOT compiler mode, either 'mini' or 'llvm'")]
         public MonoAotCompilerMode AOTCompilerMode { get; set; }
 
+        [Option("runtimeSrcDir", Required = false, HelpText = "Path to a local copy of dotnet/runtime. . Used by the WASM toolchain when AOTCompilerMode is 'wasm'.")]
+        public DirectoryInfo RuntimeSrcDir { get; set; }
+
         internal bool UserProvidedFilters => Filters.Any() || AttributeNames.Any() || AllCategories.Any() || AnyCategories.Any();
 
         [Usage(ApplicationAlias = "")]
@@ -225,4 +228,4 @@ public static IEnumerable<Example> Examples
 
         private static string Escape(string input) => UserInteractionHelper.EscapeCommandExample(input);
     }
-}
+}

src/BenchmarkDotNet/ConsoleArguments/CommandLineOptions.cs

@@ -112,7 +112,7 @@ private static bool Validate(CommandLineOptions options, ILogger logger)
                     logger.WriteLineError($"The provided runtime \"{runtime}\" is invalid. Available options are: {string.Join(", ", Enum.GetNames(typeof(RuntimeMoniker)).Select(name => name.ToLower()))}.");
                     return false;
                 }
-                else if (runtimeMoniker == RuntimeMoniker.Wasm && (options.WasmMainJs == null || options.WasmMainJs.IsNotNullButDoesNotExist()))
+                else if (runtimeMoniker == RuntimeMoniker.Wasm && !(options.AOTCompilerMode == MonoAotCompilerMode.wasm) && (options.WasmMainJs == null || options.WasmMainJs.IsNotNullButDoesNotExist()))
                 {
                     logger.WriteLineError($"The provided {nameof(options.WasmMainJs)} \"{options.WasmMainJs}\" does NOT exist. It MUST be provided.");
                     return false;
@@ -121,6 +121,11 @@ private static bool Validate(CommandLineOptions options, ILogger logger)
                 {
                      logger.WriteLineError($"The provided {nameof(options.AOTCompilerPath)} \"{ options.AOTCompilerPath }\" does NOT exist. It MUST be provided.");
                 }
+                else if (runtimeMoniker == RuntimeMoniker.Wasm && options.AOTCompilerMode == MonoAotCompilerMode.wasm && (options.RuntimeSrcDir == null || options.RuntimeSrcDir.IsNotNullButDoesNotExist()))
+                {
+                    logger.WriteLineError($"The provided {nameof(options.RuntimeSrcDir)} \"{options.RuntimeSrcDir}\" does NOT exist. It MUST be provided.");
+                    return false;
+                }
             }
 
             foreach (string exporter in options.Exporters)
@@ -414,11 +419,15 @@ private static Job CreateJobForGivenRuntime(Job baseJob, string runtimeId, Comma
 
         private static Job MakeWasmJob(Job baseJob, CommandLineOptions options, TimeSpan? timeOut, string msBuildMoniker)
         {
+            bool wasmAot = options.AOTCompilerMode == MonoAotCompilerMode.wasm;
+
             var wasmRuntime = new WasmRuntime(
                 mainJs: options.WasmMainJs,
                 msBuildMoniker: msBuildMoniker,
                 javaScriptEngine: options.WasmJavascriptEngine?.FullName ?? "v8",
-                javaScriptEngineArguments: options.WasmJavaScriptEngineArguments);
+                javaScriptEngineArguments: options.WasmJavaScriptEngineArguments,
+                aot: wasmAot,
+                runtimeSrcDir: options.RuntimeSrcDir);
 
             var toolChain = WasmToolChain.From(new NetCoreAppSettings(
                 targetFrameworkMoniker: wasmRuntime.MsBuildMoniker,
@@ -427,7 +436,8 @@ private static Job MakeWasmJob(Job baseJob, CommandLineOptions options, TimeSpan
                 customDotNetCliPath: options.CliPath?.FullName,
                 packagesPath: options.RestorePath?.FullName,
                 timeout: timeOut ?? NetCoreAppSettings.DefaultBuildTimeout,
-                customRuntimePack: options.CustomRuntimePack));
+                customRuntimePack: options.CustomRuntimePack,
+                aotCompilerMode: options.AOTCompilerMode));
 
             return baseJob.WithRuntime(wasmRuntime).WithToolchain(toolChain);
         }

src/BenchmarkDotNet/ConsoleArguments/ConfigParser.cs

@@ -3,6 +3,7 @@
 using System.IO;
 using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.Jobs;
+using BenchmarkDotNet.Toolchains.MonoWasm;
 
 namespace BenchmarkDotNet.Environments
 {
@@ -17,6 +18,10 @@ public class WasmRuntime : Runtime, IEquatable<WasmRuntime>
 
         public string JavaScriptEngineArguments { get;  }
 
+        public bool Aot { get;  }
+
+        public DirectoryInfo RuntimeSrcDir { get;  }
+
         /// <summary>
         /// creates new instance of WasmRuntime
         /// </summary>
@@ -26,18 +31,20 @@ public class WasmRuntime : Runtime, IEquatable<WasmRuntime>
         /// <param name="msBuildMoniker">moniker, default: "net5.0"</param>
         /// <param name="displayName">default: "Wasm"</param>
         /// <remarks>path to mainJs MUST be provided</remarks>
-        public WasmRuntime(FileInfo mainJs, string msBuildMoniker = "net5.0", string displayName = "Wasm", string javaScriptEngine = "v8", string javaScriptEngineArguments = "--expose_wasm") : base(RuntimeMoniker.Wasm, msBuildMoniker, displayName)
+        public WasmRuntime(FileInfo mainJs, string msBuildMoniker = "net5.0", string displayName = "Wasm", string javaScriptEngine = "v8", string javaScriptEngineArguments = "--expose_wasm", bool aot = false, DirectoryInfo runtimeSrcDir = null) : base(RuntimeMoniker.Wasm, msBuildMoniker, displayName)
         {
-            if (mainJs == null)
+            if (!aot && mainJs == null)
                 throw new ArgumentNullException(paramName: nameof(mainJs));
-            if (mainJs.IsNotNullButDoesNotExist())
+            if (!aot && mainJs.IsNotNullButDoesNotExist())
                 throw new FileNotFoundException($"Provided {nameof(mainJs)} file: \"{mainJs.FullName}\" doest NOT exist");
             if (!string.IsNullOrEmpty(javaScriptEngine) && javaScriptEngine != "v8" && !File.Exists(javaScriptEngine))
                 throw new FileNotFoundException($"Provided {nameof(javaScriptEngine)} file: \"{javaScriptEngine}\" doest NOT exist");
 
             MainJs = mainJs;
             JavaScriptEngine = javaScriptEngine;
             JavaScriptEngineArguments = javaScriptEngineArguments;
+            Aot = aot;
+            RuntimeSrcDir = runtimeSrcDir;
         }
 
         // this ctor exists only for the purpose of having .Default property that returns something consumable by RuntimeInformation.GetCurrentRuntime()
@@ -52,9 +59,9 @@ public override bool Equals(object obj)
             => obj is WasmRuntime other && Equals(other);
 
         public bool Equals(WasmRuntime other)
-            => other != null && base.Equals(other) && other.MainJs == MainJs && other.JavaScriptEngine == JavaScriptEngine && other.JavaScriptEngineArguments == JavaScriptEngineArguments;
+            => other != null && base.Equals(other) && other.MainJs == MainJs && other.JavaScriptEngine == JavaScriptEngine && other.JavaScriptEngineArguments == JavaScriptEngineArguments && other.Aot == Aot && other.RuntimeSrcDir == RuntimeSrcDir;
 
         public override int GetHashCode()
-            => base.GetHashCode() ^ MainJs.GetHashCode() ^ (JavaScriptEngine?.GetHashCode() ?? 0) ^ (JavaScriptEngineArguments?.GetHashCode() ?? 0);
+            => base.GetHashCode() ^ MainJs.GetHashCode() ^ (JavaScriptEngine?.GetHashCode() ?? 0) ^ (JavaScriptEngineArguments?.GetHashCode() ?? 0 ^ Aot.GetHashCode() ^ (RuntimeSrcDir?.GetHashCode() ?? 0));
     }
 }

src/BenchmarkDotNet/Environments/Runtimes/WasmRuntime.cs

@@ -0,0 +1,35 @@
+<Project Sdk="$SDKNAME$" DefaultTargets="publish">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <OutputPath>bin</OutputPath>
+    <RuntimeSrcDir>$RUNTIMESRCDIR$</RuntimeSrcDir>
+    <RuntimeConfig>Release</RuntimeConfig>
+    <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
+    <TargetFramework>$TFM$</TargetFramework>
+    <AppDir>$(MSBuildThisFileDirectory)\bin\$TFM$\browser-wasm\publish</AppDir>
+    <AssemblyName>$PROGRAMNAME$</AssemblyName>
+    <RuntimeIdentifier>browser-wasm</RuntimeIdentifier>
+    <PublishTrimmed>true</PublishTrimmed>
+    <RunAOTCompilation>true</RunAOTCompilation>
+    <WasmMainJSPath>$(RuntimeSrcDir)\src\mono\wasm\runtime-test.js</WasmMainJSPath>
+    <WasmGenerateRunV8Script>true</WasmGenerateRunV8Script>
+    $COPIEDSETTINGS$
+  </PropertyGroup>
+
+  <Import Project="$(RuntimeSrcDir)/src/mono/wasm/build/WasmApp.LocalBuild.props" />
+  <Import Project="$(RuntimeSrcDir)/src/mono/wasm/build/WasmApp.LocalBuild.targets" />
+
+
+  <ItemGroup>
+        <WasmAssembliesToBundle Include="$(AppDir)/*.dll" />
+  </ItemGroup>
+
+
+  <ItemGroup>
+    <Compile Include="$CODEFILENAME$" Exclude="bin\**;obj\**;**\*.xproj;packages\**" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="$CSPROJPATH$" />
+  </ItemGroup>
+</Project>

src/BenchmarkDotNet/Templates/WasmAotCsProj.txt

@@ -3,6 +3,7 @@
     public enum MonoAotCompilerMode
     {
         mini = 0, // default
-        llvm
+        llvm,
+        wasm
     }
 }

src/BenchmarkDotNet/Toolchains/MonoAotLLVM/MonoAotCompilerMode.cs

@@ -26,9 +26,11 @@ public BuildResult Build(GenerateResult generateResult, BuildPartition buildPart
         {
             BuildResult buildResult = dotNetCliBuilder.Build(generateResult, buildPartition, logger);
 
-            if (buildResult.IsBuildSuccess)
+            WasmRuntime runtime = (WasmRuntime)buildPartition.Runtime;
+
+            if (buildResult.IsBuildSuccess && !runtime.Aot)
             {
-                BuildApp(buildPartition.ProgramName, generateResult.ArtifactsPaths.BuildArtifactsDirectoryPath, (WasmRuntime)buildPartition.Runtime);
+                BuildApp(buildPartition.ProgramName, generateResult.ArtifactsPaths.BuildArtifactsDirectoryPath, runtime);
             }
 
             return buildResult;

src/BenchmarkDotNet/Toolchains/MonoWasm/WasmBuilder.cs

@@ -1,5 +1,6 @@
 using System.IO;
 using System.Text;
+using BenchmarkDotNet.Environments;
 using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.Helpers;
 using BenchmarkDotNet.Loggers;
@@ -11,14 +12,55 @@ namespace BenchmarkDotNet.Toolchains.MonoWasm
     public class WasmGenerator : CsProjGenerator
     {
         private readonly string CustomRuntimePack;
+        private readonly bool Aot;
 
-        public WasmGenerator(string targetFrameworkMoniker, string cliPath, string packagesPath, string customRuntimePack)
+        public WasmGenerator(string targetFrameworkMoniker, string cliPath, string packagesPath, string customRuntimePack, bool aot)
             : base(targetFrameworkMoniker, cliPath, packagesPath, runtimeFrameworkVersion: null)
         {
+            Aot = aot;
             CustomRuntimePack = customRuntimePack;
         }
 
         protected override void GenerateProject(BuildPartition buildPartition, ArtifactsPaths artifactsPaths, ILogger logger)
+        {
+            if (((WasmRuntime)buildPartition.Runtime).Aot)
+            {
+                GenerateProjectAot(buildPartition, artifactsPaths, logger);
+            }
+            else
+            {
+                GenerateProjectInterpreter(buildPartition, artifactsPaths, logger);
+            }
+        }
+
+        protected  void GenerateProjectAot(BuildPartition buildPartition, ArtifactsPaths artifactsPaths, ILogger logger)
+        {
+            BenchmarkCase benchmark = buildPartition.RepresentativeBenchmarkCase;
+            var projectFile = GetProjectFilePath(benchmark.Descriptor.Type, logger);
+
+            WasmRuntime runtime = (WasmRuntime)buildPartition.Runtime;
+
+            using (var file = new StreamReader(File.OpenRead(projectFile.FullName)))
+            {
+                var (customProperties, sdkName) = GetSettingsThatNeedsToBeCopied(file, projectFile);
+
+                string content = new StringBuilder(ResourceHelper.LoadTemplate("WasmAotCsProj.txt"))
+                    .Replace("$PLATFORM$", buildPartition.Platform.ToConfig())
+                    .Replace("$CODEFILENAME$", Path.GetFileName(artifactsPaths.ProgramCodePath))
+                    .Replace("$CSPROJPATH$", projectFile.FullName)
+                    .Replace("$TFM$", TargetFrameworkMoniker)
+                    .Replace("$PROGRAMNAME$", artifactsPaths.ProgramName)
+                    .Replace("$RUNTIMESRCDIR$", runtime.RuntimeSrcDir.ToString())
+                    .Replace("$COPIEDSETTINGS$", customProperties)
+                    .Replace("$CONFIGURATIONNAME$", buildPartition.BuildConfiguration)
+                    .Replace("$SDKNAME$", sdkName)
+                    .ToString();
+
+                File.WriteAllText(artifactsPaths.ProjectFilePath, content);
+            }
+        }
+
+        protected void GenerateProjectInterpreter(BuildPartition buildPartition, ArtifactsPaths artifactsPaths, ILogger logger)
         {
             BenchmarkCase benchmark = buildPartition.RepresentativeBenchmarkCase;
             var projectFile = GetProjectFilePath(benchmark.Descriptor.Type, logger);
@@ -46,6 +88,15 @@ protected override void GenerateProject(BuildPartition buildPartition, Artifacts
         protected override string GetExecutablePath(string binariesDirectoryPath, string programName) => Path.Combine(binariesDirectoryPath, "runtime.js");
 
         protected override string GetBinariesDirectoryPath(string buildArtifactsDirectoryPath, string configuration)
-            => Path.Combine(buildArtifactsDirectoryPath, "bin", TargetFrameworkMoniker, "browser-wasm", "publish", "output");
+        {
+            if (Aot)
+            {
+                return Path.Combine(buildArtifactsDirectoryPath, "bin", TargetFrameworkMoniker, "browser-wasm", "AppBundle");
+            }
+            else
+            {
+                return Path.Combine(buildArtifactsDirectoryPath, "bin", TargetFrameworkMoniker, "browser-wasm", "publish", "output");
+            }
+        }
     }
 }

src/BenchmarkDotNet/Toolchains/MonoWasm/WasmGenerator.cs

@@ -40,7 +40,8 @@ public static IToolchain From(NetCoreAppSettings netCoreAppSettings)
                     new WasmGenerator(netCoreAppSettings.TargetFrameworkMoniker,
                         netCoreAppSettings.CustomDotNetCliPath,
                         netCoreAppSettings.PackagesPath,
-                        netCoreAppSettings.CustomRuntimePack),
+                        netCoreAppSettings.CustomRuntimePack,
+                        netCoreAppSettings.AOTCompilerMode == MonoAotLLVM.MonoAotCompilerMode.wasm),
                     new WasmBuilder(netCoreAppSettings.TargetFrameworkMoniker,
                         netCoreAppSettings.CustomDotNetCliPath,
                         netCoreAppSettings.Timeout),