Fix the CI

* Fix pointer-returning benchmarks support for InProcessToolchain

* add UIntPtr, nint and unint support

* disable TieredJit so it's background allocations don't show up in allocated memory reported by MemoryDiagnoser tests

Co-authored-by: Adam Sitnik <[email protected]>

Author: radekdoulik

build/common.props

@@ -28,7 +28,7 @@
   </PropertyGroup>
 
   <PropertyGroup Condition=" '$(IsVisualBasic)' != 'true' AND '$(IsFsharp)' != 'true' ">
-    <LangVersion>7.3</LangVersion>
+    <LangVersion>9.0</LangVersion>
 
     <Major>0</Major>
     <Minor>13</Minor>

src/BenchmarkDotNet/Engines/Consumer.cs

@@ -33,6 +33,7 @@ private static readonly HashSet<Type> SupportedTypes
         private string stringHolder;
         private object objectHolder;
         private IntPtr ptrHolder;
+        private UIntPtr uptrHolder;
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [PublicAPI]
@@ -81,6 +82,14 @@ private static readonly HashSet<Type> SupportedTypes
         [PublicAPI]
         public void Consume(long longValue) => Volatile.Write(ref longHolder, longValue);
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [PublicAPI]
+        public void Consume(IntPtr intPtrValue) => Volatile.Write(ref ptrHolder, intPtrValue);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [PublicAPI]
+        public void Consume(UIntPtr uintPtrValue) => Volatile.Write(ref uptrHolder, uintPtrValue);
+
         [CLSCompliant(false)]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [PublicAPI]

src/BenchmarkDotNet/Toolchains/InProcess.Emit.Implementation/Emitters/ConsumableConsumeEmitter.cs

@@ -20,9 +20,18 @@ private static MethodInfo GetConsumeMethod(Type consumableType)
                 {
                     consumeMethod = typeof(Consumer)
                         .GetMethods()
-                        .Single(m => m.Name == nameof(Consumer.Consume) && m.IsGenericMethodDefinition
-                        && m.GetParameterTypes().First().IsByRef == false);
-                    consumeMethod = consumeMethod?.MakeGenericMethod(consumableType);
+                        .Single(m =>
+                        {
+                            Type argType = m.GetParameterTypes().FirstOrDefault();
+
+                            return m.Name == nameof(Consumer.Consume) && m.IsGenericMethodDefinition
+                                && !argType.IsByRef // we are not interested in "Consume<T>(in T value)"
+                                && argType.IsPointer == consumableType.IsPointer; // use "Consume<T>(T objectValue) where T : class" or "Consume<T>(T* ptrValue) where T: unmanaged"
+                        });
+
+                    consumeMethod = consumableType.IsPointer
+                        ? consumeMethod.MakeGenericMethod(consumableType.GetElementType()) // consumableType is T*, we need T for Consume<T>(T* ptrValue)
+                        : consumeMethod.MakeGenericMethod(consumableType);
                 }
                 else
                 {

tests/BenchmarkDotNet.IntegrationTests/MemoryDiagnoserTests.cs

@@ -293,6 +293,7 @@ private IConfig CreateConfig(IToolchain toolchain)
                     .WithWarmupCount(0) // don't run warmup to save some time for our CI runs
                     .WithIterationCount(1) // single iteration is enough for us
                     .WithGcForce(false)
+                    .WithEnvironmentVariable("COMPlus_TieredCompilation", "0") // Tiered JIT can allocate some memory on a background thread, let's disable it to make our tests less flaky (#1542)
                     .WithToolchain(toolchain))
                 .AddColumnProvider(DefaultColumnProviders.Instance)
                 .AddDiagnoser(MemoryDiagnoser.Default)

tests/BenchmarkDotNet.IntegrationTests/ValuesReturnedByBenchmarkTest.cs

@@ -1,7 +1,12 @@
 using System;
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Environments;
+using BenchmarkDotNet.Jobs;
+using BenchmarkDotNet.Toolchains;
+using BenchmarkDotNet.Toolchains.InProcess.Emit;
 using Xunit;
 using Xunit.Abstractions;
 
@@ -11,8 +16,14 @@ public class ValuesReturnedByBenchmarkTest : BenchmarkTestExecutor
     {
         public ValuesReturnedByBenchmarkTest(ITestOutputHelper output) : base(output) { }
 
-        [Fact]
-        public void AnyValueCanBeReturned() => CanExecute<ValuesReturnedByBenchmark>();
+        public static IEnumerable<object[]> GetToolchains() => new[]
+        {
+            new object[] { Job.Default.GetToolchain() },
+            new object[] { InProcessEmitToolchain.Instance },
+        };
+
+        [Theory, MemberData(nameof(GetToolchains))]
+        public void AnyValueCanBeReturned(IToolchain toolchain) => CanExecute<ValuesReturnedByBenchmark>(ManualConfig.CreateEmpty().AddJob(Job.Dry.WithToolchain(toolchain)));
 
         public class ValuesReturnedByBenchmark
         {
@@ -93,6 +104,24 @@ public class Job { }
 
             [Benchmark]
             public NoNamespace TypeWithoutNamespace() => new NoNamespace();
+
+            [Benchmark]
+            public unsafe void* PointerToAnything() => System.IntPtr.Zero.ToPointer();
+
+            [Benchmark]
+            public unsafe int* PointerToUnmanagedType() => (int*)System.IntPtr.Zero.ToPointer();
+
+            [Benchmark]
+            public System.IntPtr IntPtr() => System.IntPtr.Zero;
+
+            [Benchmark]
+            public System.UIntPtr UIntPtr() => System.UIntPtr.Zero;
+
+            [Benchmark]
+            public nint NativeSizeInteger() => 0;
+
+            [Benchmark]
+            public nuint UnsignedNativeSizeInteger() => 0;
         }
     }
 }

tests/BenchmarkDotNet.IntegrationTests/runtimeconfig.template.json

@@ -0,0 +1,7 @@
+{
+  "runtimeOptions": {
+    "configProperties": {
+      "System.Runtime.TieredCompilation": false
+    }
+  }
+}