Handle addresses larger than 2GB for 32-bit benchmarks #1469 (#2145)

* Handle addresses larger than 2GB for 32-bit benchmarks #1469

* Apply suggestions from code review

Co-authored-by: Adam Sitnik <adam.sitnik@gmail.com>

Author: leonvandermeer

docs/articles/configs/jobs.md

@@ -33,6 +33,9 @@ It's a single string characteristic. It allows to name your job. This name will
   * `CpuGroups`:  Specifies whether garbage collection supports multiple CPU groups
   * `Force`: Specifies whether the BenchmarkDotNet's benchmark runner forces full garbage collection after each benchmark invocation
   * `AllowVeryLargeObjects`:  On 64-bit platforms, enables arrays that are greater than 2 gigabytes (GB) in total size
+* `LargeAddressAware`: Specifies that benchmark can handle addresses larger than 2 gigabytes. See also: @BenchmarkDotNet.Samples.IntroLargeAddressAware and [LARGEADDRESSAWARE](https://learn.microsoft.com/cpp/build/reference/largeaddressaware-handle-large-addresses)
+  * `false`: Benchmark uses the defaults (64-bit: enabled; 32-bit: disabled).
+  * `true`: Explicitly specify that benchmark can handle addresses larger than 2 gigabytes.
 * `EnvironmentVariables`: customized environment variables for target benchmark. See also: @BenchmarkDotNet.Samples.IntroEnvVars
 
 BenchmarkDotNet will use host process environment characteristics for non specified values.

docs/articles/samples/IntroLargeAddressAware.md

@@ -0,0 +1,16 @@
+---
+uid: BenchmarkDotNet.Samples.IntroLargeAddressAware
+title: "Sample: IntroLargeAddressAware"
+---
+
+## Sample: IntroLargeAddressAware
+
+### Source code
+
+[!code-csharp[IntroLargeAddressAware.cs](../../../samples/BenchmarkDotNet.Samples/IntroLargeAddressAware.cs)]
+
+### Links
+
+* The permanent link to this sample: @BenchmarkDotNet.Samples.IntroLargeAddressAware
+
+---

docs/articles/samples/toc.yml

@@ -64,6 +64,8 @@
   href: IntroJobBaseline.md
 - name: IntroJoin
   href: IntroJoin.md
+- name: IntroLargeAddressAware
+  href: IntroLargeAddressAware.md
 - name: IntroMonitoring
   href: IntroMonitoring.md
 - name: IntroMultimodal

samples/BenchmarkDotNet.Samples/IntroLargeAddressAware.cs

@@ -0,0 +1,38 @@
+using System;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Environments;
+using BenchmarkDotNet.Jobs;
+
+namespace BenchmarkDotNet.Samples
+{
+    [MemoryDiagnoser]
+    [Config(typeof(Config))]
+    public class IntroLargeAddressAware
+    {
+        private class Config : ManualConfig
+        {
+            public Config()
+            {
+                AddJob(Job.Default
+                    .WithRuntime(ClrRuntime.Net462)
+                    .WithPlatform(Platform.X86)
+                    .WithLargeAddressAware()
+                    .WithId("Framework"));
+            }
+        }
+
+        [Benchmark]
+        public void AllocateMoreThan2GB()
+        {
+            const int oneGB = 1024 * 1024 * 1024;
+            const int halfGB = oneGB / 2;
+            byte[] bytes1 = new byte[oneGB];
+            byte[] bytes2 = new byte[oneGB];
+            byte[] bytes3 = new byte[halfGB];
+            GC.KeepAlive(bytes1);
+            GC.KeepAlive(bytes2);
+            GC.KeepAlive(bytes3);
+        }
+    }
+}

src/BenchmarkDotNet/Jobs/EnvironmentMode.cs

@@ -16,6 +16,7 @@ public sealed class EnvironmentMode : JobMode<EnvironmentMode>
         public static readonly Characteristic<GcMode> GcCharacteristic = CreateCharacteristic<GcMode>(nameof(Gc));
         public static readonly Characteristic<IReadOnlyList<EnvironmentVariable>> EnvironmentVariablesCharacteristic = CreateCharacteristic<IReadOnlyList<EnvironmentVariable>>(nameof(EnvironmentVariables));
         public static readonly Characteristic<Guid?> PowerPlanModeCharacteristic = CreateCharacteristic<Guid?>(nameof(PowerPlanMode));
+        public static readonly Characteristic<bool> LargeAddressAwareCharacteristic = CreateCharacteristic<bool>(nameof(LargeAddressAware));
 
         public static readonly EnvironmentMode LegacyJitX86 = new EnvironmentMode(nameof(LegacyJitX86), Jit.LegacyJit, Platform.X86).Freeze();
         public static readonly EnvironmentMode LegacyJitX64 = new EnvironmentMode(nameof(LegacyJitX64), Jit.LegacyJit, Platform.X64).Freeze();
@@ -96,6 +97,25 @@ public Guid? PowerPlanMode
             set => PowerPlanModeCharacteristic[this] = value;
         }
 
+        /// <summary>
+        /// Specifies that benchmark can handle addresses larger than 2 gigabytes.
+        /// <value>false: Benchmark uses the default (64-bit: enabled; 32-bit:disabled). This is the default.</value>
+        /// <value>true: Explicitly specify that benchmark can handle addresses larger than 2 gigabytes.</value>
+        /// </summary>
+        public bool LargeAddressAware
+        {
+            get => LargeAddressAwareCharacteristic[this];
+            set
+            {
+                if (!RuntimeInformation.IsWindows())
+                {
+                    throw new NotSupportedException("LargeAddressAware is a Windows-specific concept.");
+                }
+
+                LargeAddressAwareCharacteristic[this] = value;
+            }
+        }
+
         /// <summary>
         /// Adds the specified <paramref name="variable"/> to <see cref="EnvironmentVariables"/>.
         /// If <see cref="EnvironmentVariables"/> already contains a variable with the same key,

src/BenchmarkDotNet/Jobs/JobExtensions.cs

@@ -76,6 +76,11 @@ public static class JobExtensions
         /// </summary>
         public static Job WithGcAllowVeryLargeObjects(this Job job, bool value) => job.WithCore(j => j.Environment.Gc.AllowVeryLargeObjects = value);
 
+        /// <summary>
+        /// Specifies that benchmark can handle addresses larger than 2 gigabytes.
+        /// </summary>
+        public static Job WithLargeAddressAware(this Job job, bool value = true) => job.WithCore(j => j.Environment.LargeAddressAware = value);
+
         /// <summary>
         /// Put segments that should be deleted on a standby list for future use instead of releasing them back to the OS
         /// <remarks>The default is false</remarks>

src/BenchmarkDotNet/Running/BenchmarkPartitioner.cs

@@ -41,6 +41,8 @@ public bool Equals(BenchmarkCase x, BenchmarkCase y)
                     return false;
                 if (jobX.Environment.Platform != jobY.Environment.Platform) // platform is set in .csproj
                     return false;
+                if (jobX.Environment.LargeAddressAware != jobY.Environment.LargeAddressAware)
+                    return false;
                 if (AreDifferent(jobX.Infrastructure.BuildConfiguration, jobY.Infrastructure.BuildConfiguration)) // Debug vs Release
                     return false;
                 if (AreDifferent(jobX.Infrastructure.Arguments, jobY.Infrastructure.Arguments)) // arguments can be anything (Mono runtime settings or MsBuild parameters)
@@ -74,6 +76,7 @@ public int GetHashCode(BenchmarkCase obj)
                 hashCode ^= obj.Descriptor.Type.Assembly.Location.GetHashCode();
                 hashCode ^= (int)job.Environment.Jit;
                 hashCode ^= (int)job.Environment.Platform;
+                hashCode ^= job.Environment.LargeAddressAware.GetHashCode();
                 hashCode ^= job.Environment.Gc.GetHashCode();
 
                 if (job.Infrastructure.BuildConfiguration != null)

src/BenchmarkDotNet/Toolchains/DotNetCli/DotNetCliBuilder.cs

@@ -26,7 +26,8 @@ public DotNetCliBuilder(string targetFrameworkMoniker, string customDotNetCliPat
         }
 
         public BuildResult Build(GenerateResult generateResult, BuildPartition buildPartition, ILogger logger)
-            => new DotNetCliCommand(
+        {
+            BuildResult buildResult = new DotNetCliCommand(
                     CustomDotNetCliPath,
                     string.Empty,
                     generateResult,
@@ -37,5 +38,12 @@ public BuildResult Build(GenerateResult generateResult, BuildPartition buildPart
                     logOutput: LogOutput,
                     retryFailedBuildWithNoDeps: RetryFailedBuildWithNoDeps)
                 .RestoreThenBuild();
+            if (buildResult.IsBuildSuccess &&
+                buildPartition.RepresentativeBenchmarkCase.Job.Environment.LargeAddressAware)
+            {
+                LargeAddressAware.SetLargeAddressAware(generateResult.ArtifactsPaths.ExecutablePath);
+            }
+            return buildResult;
+        }
     }
 }

src/BenchmarkDotNet/Toolchains/LargeAddressAware.cs

@@ -0,0 +1,60 @@
+using System;
+using System.IO;
+
+namespace BenchmarkDotNet.Toolchains
+{
+    // From https://github.com/KirillOsenkov/LargeAddressAware/blob/95e5fc6024438f94325df4bac6ef73c77bf90e71/SetLargeAddressAware/LargeAddressAware.cs
+    internal class LargeAddressAware
+    {
+
+        public static void SetLargeAddressAware(string filePath)
+        {
+            PrepareStream(filePath, (stream, binaryReader) =>
+            {
+                var value = binaryReader.ReadInt16();
+                if ((value & 0x20) == 0)
+                {
+                    value = (short)(value | 0x20);
+                    stream.Position -= 2;
+                    var binaryWriter = new BinaryWriter(stream);
+                    binaryWriter.Write(value);
+                    binaryWriter.Flush();
+                }
+            });
+        }
+
+        private static void PrepareStream(string filePath, Action<Stream, BinaryReader> action)
+        {
+            using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.Read))
+            {
+                if (stream.Length < 0x3C)
+                {
+                    return;
+                }
+
+                var binaryReader = new BinaryReader(stream);
+
+                // MZ header
+                if (binaryReader.ReadInt16() != 0x5A4D)
+                {
+                    return;
+                }
+
+                stream.Position = 0x3C;
+                var peHeaderLocation = binaryReader.ReadInt32();
+
+                stream.Position = peHeaderLocation;
+
+                // PE header
+                if (binaryReader.ReadInt32() != 0x4550)
+                {
+                    return;
+                }
+
+                stream.Position += 0x12;
+
+                action(stream, binaryReader);
+            }
+        }
+    }
+}

src/BenchmarkDotNet/Toolchains/Roslyn/Builder.cs

@@ -12,6 +12,7 @@
 using JetBrains.Annotations;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Emit;
 using OurPlatform = BenchmarkDotNet.Environments.Platform;
 
 namespace BenchmarkDotNet.Toolchains.Roslyn
@@ -70,17 +71,17 @@ private BuildResult Build(GenerateResult generateResult, BuildPartition buildPar
                 .Select(uniqueMetadata => uniqueMetadata.GetReference())
                 .ToList();
 
-            var (result, missingReferences) = Build(generateResult, syntaxTree, compilationOptions, references, cancellationToken);
+            var (result, missingReferences) = Build(generateResult, buildPartition, syntaxTree, compilationOptions, references, cancellationToken);
 
             if (result.IsBuildSuccess || !missingReferences.Any())
                 return result;
 
             var withMissingReferences = references.Union(missingReferences.Select(assemblyMetadata => assemblyMetadata.GetReference()));
 
-            return Build(generateResult, syntaxTree, compilationOptions, withMissingReferences, cancellationToken).result;
+            return Build(generateResult, buildPartition, syntaxTree, compilationOptions, withMissingReferences, cancellationToken).result;
         }
 
-        private static (BuildResult result, AssemblyMetadata[] missingReference) Build(GenerateResult generateResult, SyntaxTree syntaxTree,
+        private static (BuildResult result, AssemblyMetadata[] missingReference) Build(GenerateResult generateResult, BuildPartition buildPartition, SyntaxTree syntaxTree,
             CSharpCompilationOptions compilationOptions, IEnumerable<PortableExecutableReference> references, CancellationToken cancellationToken)
         {
             var compilation = CSharpCompilation
@@ -89,25 +90,31 @@ private static (BuildResult result, AssemblyMetadata[] missingReference) Build(G
                 .WithOptions(compilationOptions)
                 .AddReferences(references);
 
+            EmitResult emitResult;
             using (var executable = File.Create(generateResult.ArtifactsPaths.ExecutablePath))
             {
-                var emitResult = compilation.Emit(executable, cancellationToken: cancellationToken);
-
-                if (emitResult.Success)
-                    return (BuildResult.Success(generateResult), default);
+                emitResult = compilation.Emit(executable, cancellationToken: cancellationToken);
+            }
+            if (emitResult.Success)
+            {
+                if (buildPartition.RepresentativeBenchmarkCase.Job.Environment.LargeAddressAware)
+                {
+                    LargeAddressAware.SetLargeAddressAware(generateResult.ArtifactsPaths.ExecutablePath);
+                }
+                return (BuildResult.Success(generateResult), default);
+            }
 
-                var compilationErrors = emitResult.Diagnostics
-                    .Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error)
-                    .ToArray();
+            var compilationErrors = emitResult.Diagnostics
+                .Where(diagnostic => diagnostic.IsWarningAsError || diagnostic.Severity == DiagnosticSeverity.Error)
+                .ToArray();
 
-                var errors = new StringBuilder("The build has failed!").AppendLine();
-                foreach (var diagnostic in compilationErrors)
-                    errors.AppendLine($"{diagnostic.Id}: {diagnostic.GetMessage(CultureInfo.InvariantCulture)}");
+            var errors = new StringBuilder("The build has failed!").AppendLine();
+            foreach (var diagnostic in compilationErrors)
+                errors.AppendLine($"{diagnostic.Id}: {diagnostic.GetMessage(CultureInfo.InvariantCulture)}");
 
-                var missingReferences = GetMissingReferences(compilationErrors);
+            var missingReferences = GetMissingReferences(compilationErrors);
 
-                return (BuildResult.Failure(generateResult, errors.ToString()), missingReferences);
-            }
+            return (BuildResult.Failure(generateResult, errors.ToString()), missingReferences);
         }
 
         private Platform GetPlatform(OurPlatform platform)