feat: Wasm MemoryDiagnoser (#3040)

FreyLuis · web-flow · commit 416275cfdb86 · 2026-03-04T13:25:35.000-05:00
* feat: Wasm MemoryDiagnoser

* test(MemoryDiagnoserTests): add AllocateTask wasm test
diff --git a/src/BenchmarkDotNet/Engines/GcStats.cs b/src/BenchmarkDotNet/Engines/GcStats.cs
@@ -141,10 +141,6 @@ public static GcStats FromForced(int forcedFullGarbageCollections)
         [MethodImpl(CodeGenHelper.AggressiveOptimizationOption)]
         private static long? GetAllocatedBytes()
         {
-            // we have no tests for WASM and don't want to risk introducing a new bug (https://github.com/dotnet/BenchmarkDotNet/issues/2226)
-            if (RuntimeInformation.IsWasm)
-                return null;
-
             // Do NOT call GC.Collect() here, as it causes finalizers to run and possibly allocate. https://github.com/dotnet/runtime/issues/101536#issuecomment-2077533242
             // Instead, we call it before we start the measurement in the Engine.
 #if NET6_0_OR_GREATER
diff --git a/tests/BenchmarkDotNet.IntegrationTests/MemoryDiagnoserTests.cs b/tests/BenchmarkDotNet.IntegrationTests/MemoryDiagnoserTests.cs
@@ -10,6 +10,7 @@
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Detectors;
 using BenchmarkDotNet.Diagnosers;
+using BenchmarkDotNet.Environments;
 using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.IntegrationTests.Xunit;
 using BenchmarkDotNet.Jobs;
@@ -19,11 +20,14 @@
 using BenchmarkDotNet.Tests.Loggers;
 using BenchmarkDotNet.Tests.XUnit;
 using BenchmarkDotNet.Toolchains;
-using BenchmarkDotNet.Toolchains.NativeAot;
+using BenchmarkDotNet.Toolchains.DotNetCli;
 using BenchmarkDotNet.Toolchains.InProcess.Emit;
+using BenchmarkDotNet.Toolchains.Mono;
+using BenchmarkDotNet.Toolchains.MonoAotLLVM;
+using BenchmarkDotNet.Toolchains.MonoWasm;
+using BenchmarkDotNet.Toolchains.NativeAot;
 using Xunit;
 using Xunit.Abstractions;
-using BenchmarkDotNet.Toolchains.Mono;
 
 namespace BenchmarkDotNet.IntegrationTests
 {
@@ -86,6 +90,31 @@ public void MemoryDiagnoserSupportsModernMono()
             MemoryDiagnoserIsAccurate(MonoToolchain.Mono80);
         }
 
+        [TheoryEnvSpecific("JSVU does not support ARM on Windows or Linux", EnvRequirement.NonWindowsArm, EnvRequirement.NonLinuxArm)]
+        [InlineData(MonoAotCompilerMode.mini)]
+        // BUG: https://github.com/dotnet/BenchmarkDotNet/issues/3036
+        [InlineData(MonoAotCompilerMode.wasm, Skip = "AOT is broken")]
+        public void MemoryDiagnoserSupportsMonoWasm(MonoAotCompilerMode aotCompilerMode)
+        {
+            var ptrSize = sizeof(Int32); // We can't rely on IntPtr.Size, since we run on a different platform. Wasm is currently 32bit.
+            var objectAllocationOverhead = ptrSize * 2; // pointer to method table + object header word
+            var arraySizeOverhead = ptrSize * 2; // bounds + max_length
+            var intTaskSize = 40; // We can't use CalculateRequiredSpace for AllocateTask since it calculates the size with IntPtr.Size.
+
+            var netCoreAppSettings = new NetCoreAppSettings("net8.0", runtimeFrameworkVersion: null!, "Wasm", aotCompilerMode: aotCompilerMode);
+
+            var runtime = new WasmRuntime(
+                netCoreAppSettings.TargetFrameworkMoniker, RuntimeMoniker.WasmNet80,
+                "Wasm", aotCompilerMode == MonoAotCompilerMode.wasm, "v8");
+
+            AssertAllocations(WasmToolchain.From(netCoreAppSettings), typeof(AccurateAllocations), new Dictionary<string, long>
+            {
+                { nameof(AccurateAllocations.EightBytesArray), 8 + objectAllocationOverhead + arraySizeOverhead },
+                { nameof(AccurateAllocations.SixtyFourBytesArray), 64 + objectAllocationOverhead + arraySizeOverhead },
+                { nameof(AccurateAllocations.AllocateTask), intTaskSize },
+            }, runtime: runtime);
+        }
+
         public class AllocatingGlobalSetupAndCleanup
         {
             private List<int> list = default!;
@@ -322,9 +351,10 @@ public void MemoryDiagnoserIsAccurateForMultiThreadedBenchmarks(IToolchain toolc
             });
         }
 
-        private void AssertAllocations(IToolchain toolchain, Type benchmarkType, Dictionary<string, long> benchmarksAllocationsValidators, bool disableTieredJit = true, int iterationCount = 1)
+        private void AssertAllocations(IToolchain toolchain, Type benchmarkType, Dictionary<string, long> benchmarksAllocationsValidators,
+            bool disableTieredJit = true, int iterationCount = 1, Runtime? runtime = null)
         {
-            var config = CreateConfig(toolchain, disableTieredJit, iterationCount);
+            var config = CreateConfig(toolchain, runtime, disableTieredJit, iterationCount);
             var benchmarks = BenchmarkConverter.TypeToBenchmarks(benchmarkType, config);
 
             var summary = BenchmarkRunner.Run(benchmarks);
@@ -361,6 +391,7 @@ private void AssertAllocations(IToolchain toolchain, Type benchmarkType, Diction
         }
 
         private IConfig CreateConfig(IToolchain toolchain,
+            Runtime? runtime,
             // Tiered JIT can allocate some memory on a background thread, let's disable it by default to make our tests less flaky (#1542).
             // This was mostly fixed in net7.0, but tiered jit thread is not guaranteed to not allocate, so we disable it just in case.
             bool disableTieredJit = true,
@@ -382,6 +413,12 @@ private IConfig CreateConfig(IToolchain toolchain,
                 .WithEnvironmentVariable(Engines.Engine.UnitTestBlockFinalizerEnvKey, Engines.Engine.UnitTestBlockFinalizerEnvValue)
                 .WithToolchain(toolchain);
 #pragma warning restore CS0618 // WithEvaluateOverhead is obsolete
+
+            if (runtime is not null)
+            {
+                job = job.WithRuntime(runtime);
+            }
+
             return ManualConfig.CreateEmpty()
                 .AddJob(disableTieredJit
                     ? job.WithEnvironmentVariables(
diff --git a/tests/BenchmarkDotNet.IntegrationTests/WasmTests.cs b/tests/BenchmarkDotNet.IntegrationTests/WasmTests.cs
@@ -3,7 +3,6 @@
 using System.Linq;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Configs;
-using BenchmarkDotNet.Detectors;
 using BenchmarkDotNet.Environments;
 using BenchmarkDotNet.IntegrationTests.Diagnosers;
 using BenchmarkDotNet.Jobs;
@@ -28,31 +27,23 @@ namespace BenchmarkDotNet.IntegrationTests
     /// </summary>
     public class WasmTests(ITestOutputHelper output) : BenchmarkTestExecutor(output)
     {
-        [Theory]
+        private const string JsvuSkipReason = "JSVU does not support ARM on Windows or Linux";
+
+        [TheoryEnvSpecific(JsvuSkipReason, EnvRequirement.NonWindowsArm, EnvRequirement.NonLinuxArm)]
         [InlineData(MonoAotCompilerMode.mini)]
         // BUG: https://github.com/dotnet/BenchmarkDotNet/issues/3036
         [InlineData(MonoAotCompilerMode.wasm, Skip = "AOT is broken")]
         public void WasmIsSupported(MonoAotCompilerMode aotCompilerMode)
         {
-            if (SkipTestRun())
-            {
-                return;
-            }
-
             CanExecute<WasmBenchmark>(GetConfig(aotCompilerMode));
         }
 
-        [Theory]
+        [TheoryEnvSpecific(JsvuSkipReason, EnvRequirement.NonWindowsArm, EnvRequirement.NonLinuxArm)]
         [InlineData(MonoAotCompilerMode.mini)]
         // BUG: https://github.com/dotnet/BenchmarkDotNet/issues/3036
         [InlineData(MonoAotCompilerMode.wasm, Skip = "AOT is broken")]
         public void WasmSupportsInProcessDiagnosers(MonoAotCompilerMode aotCompilerMode)
         {
-            if (SkipTestRun())
-            {
-                return;
-            }
-
             try
             {
                 var diagnoser = new MockInProcessDiagnoser1(BenchmarkDotNet.Diagnosers.RunMode.NoOverhead);
@@ -69,14 +60,9 @@ public void WasmSupportsInProcessDiagnosers(MonoAotCompilerMode aotCompilerMode)
             }
         }
 
-        [Fact]
+        [FactEnvSpecific(JsvuSkipReason, EnvRequirement.NonWindowsArm, EnvRequirement.NonLinuxArm)]
         public void WasmSupportsCustomMainJs()
         {
-            if (SkipTestRun())
-            {
-                return;
-            }
-
             var summary = CanExecute<WasmBenchmark>(GetConfig(MonoAotCompilerMode.mini, true, true));
 
             var artefactsPaths = summary.Reports.Single().GenerateResult.ArtifactsPaths;
@@ -85,14 +71,9 @@ public void WasmSupportsCustomMainJs()
             Directory.Delete(Path.GetDirectoryName(artefactsPaths.ProjectFilePath)!, true);
         }
 
-        [Fact]
+        [FactEnvSpecific(JsvuSkipReason, EnvRequirement.NonWindowsArm, EnvRequirement.NonLinuxArm)]
         public void WasmSupportsNode()
         {
-            if (SkipTestRun())
-            {
-                return;
-            }
-
             CanExecute<WasmBenchmark>(GetConfig(MonoAotCompilerMode.mini, javaScriptEngine: "node"));
         }
 
@@ -115,17 +96,6 @@ private ManualConfig GetConfig(MonoAotCompilerMode aotCompilerMode, bool useMain
                 .WithOption(ConfigOptions.GenerateMSBuildBinLog, false);
         }
 
-        private static bool SkipTestRun()
-        {
-            // jsvu only supports arm for mac.
-            if (RuntimeInformation.GetCurrentPlatform() != Platform.X64 && !OsDetector.IsMacOS())
-            {
-                return true;
-            }
-
-            return false;
-        }
-
         public class WasmBenchmark
         {
             [Benchmark]
diff --git a/tests/BenchmarkDotNet.Tests/XUnit/EnvRequirement.cs b/tests/BenchmarkDotNet.Tests/XUnit/EnvRequirement.cs
@@ -6,6 +6,7 @@ public enum EnvRequirement
     NonWindows,
     NonWindowsArm,
     NonLinux,
+    NonLinuxArm,
     FullFrameworkOnly,
     NonFullFramework,
     DotNetCoreOnly,
diff --git a/tests/BenchmarkDotNet.Tests/XUnit/EnvRequirementChecker.cs b/tests/BenchmarkDotNet.Tests/XUnit/EnvRequirementChecker.cs
@@ -17,6 +17,7 @@ public static class EnvRequirementChecker
         EnvRequirement.NonWindows => !RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? null : "Non-Windows test",
         EnvRequirement.NonWindowsArm => !RuntimeInformation.IsOSPlatform(OSPlatform.Windows) || !IsArm() ? null : "Non-Windows+Arm test",
         EnvRequirement.NonLinux => !RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ? null : "Non-Linux test",
+        EnvRequirement.NonLinuxArm => !RuntimeInformation.IsOSPlatform(OSPlatform.Linux) || !IsArm() ? null : "Non-Linux+Arm test",
         EnvRequirement.FullFrameworkOnly => BdnRuntimeInformation.IsFullFramework ? null : "Full .NET Framework-only test",
         EnvRequirement.NonFullFramework => !BdnRuntimeInformation.IsFullFramework ? null : "Non-Full .NET Framework test",
         EnvRequirement.DotNetCoreOnly => BdnRuntimeInformation.IsNetCore ? null : ".NET/.NET Core-only test",
