Overhead match workload

src/BenchmarkDotNet/Code/CodeGenerator.cs

@@ -33,7 +33,7 @@ internal static string Generate(BuildPartition buildPartition)
             {
                 var benchmark = buildInfo.BenchmarkCase;
 
-                var provider = GetDeclarationsProvider(benchmark.Descriptor);
+                var provider = GetDeclarationsProvider(benchmark);
 
                 string passArguments = GetPassArguments(benchmark);
 
@@ -48,12 +48,12 @@ internal static string Generate(BuildPartition buildPartition)
                     .Replace("$WorkloadMethodDelegate$", provider.WorkloadMethodDelegate(passArguments))
                     .Replace("$WorkloadMethodReturnType$", provider.WorkloadMethodReturnTypeName)
                     .Replace("$WorkloadMethodReturnTypeModifiers$", provider.WorkloadMethodReturnTypeModifiers)
-                    .Replace("$OverheadMethodReturnTypeName$", provider.OverheadMethodReturnTypeName)
                     .Replace("$GlobalSetupMethodName$", provider.GlobalSetupMethodName)
                     .Replace("$GlobalCleanupMethodName$", provider.GlobalCleanupMethodName)
                     .Replace("$IterationSetupMethodName$", provider.IterationSetupMethodName)
                     .Replace("$IterationCleanupMethodName$", provider.IterationCleanupMethodName)
                     .Replace("$OverheadImplementation$", provider.OverheadImplementation)
+                    .Replace("$OverheadDefaultValueHolderField$", provider.OverheadDefaultValueHolderDeclaration)
                     .Replace("$ConsumeField$", provider.ConsumeField)
                     .Replace("$JobSetDefinition$", GetJobsSetDefinition(benchmark))
                     .Replace("$ParamsContent$", GetParamsContent(benchmark))
@@ -148,19 +148,19 @@ private static string GetJobsSetDefinition(BenchmarkCase benchmarkCase)
                 Replace("; ", ";\n                ");
         }
 
-        private static DeclarationsProvider GetDeclarationsProvider(Descriptor descriptor)
+        private static DeclarationsProvider GetDeclarationsProvider(BenchmarkCase benchmark)
         {
-            var method = descriptor.WorkloadMethod;
+            var method = benchmark.Descriptor.WorkloadMethod;
 
             if (method.ReturnType == typeof(Task) || method.ReturnType == typeof(ValueTask))
             {
-                return new TaskDeclarationsProvider(descriptor);
+                return new TaskDeclarationsProvider(benchmark);
             }
             if (method.ReturnType.GetTypeInfo().IsGenericType
                 && (method.ReturnType.GetTypeInfo().GetGenericTypeDefinition() == typeof(Task<>)
                     || method.ReturnType.GetTypeInfo().GetGenericTypeDefinition() == typeof(ValueTask<>)))
             {
-                return new GenericTaskDeclarationsProvider(descriptor);
+                return new GenericTaskDeclarationsProvider(benchmark);
             }
 
             if (method.ReturnType == typeof(void))
@@ -171,19 +171,19 @@ private static DeclarationsProvider GetDeclarationsProvider(Descriptor descripto
                     throw new NotSupportedException("async void is not supported by design");
                 }
 
-                return new VoidDeclarationsProvider(descriptor);
+                return new VoidDeclarationsProvider(benchmark);
             }
 
             if (method.ReturnType.IsByRef)
             {
                 // System.Runtime.CompilerServices.IsReadOnlyAttribute is part of .NET Standard 2.1, we can't use it here..
                 if (method.ReturnParameter.GetCustomAttributes().Any(attribute => attribute.GetType().Name == "IsReadOnlyAttribute"))
-                    return new ByReadOnlyRefDeclarationsProvider(descriptor);
+                    return new ByReadOnlyRefDeclarationsProvider(benchmark);
                 else
-                    return new ByRefDeclarationsProvider(descriptor);
+                    return new ByRefDeclarationsProvider(benchmark);
             }
 
-            return new NonVoidDeclarationsProvider(descriptor);
+            return new NonVoidDeclarationsProvider(benchmark);
         }
 
         // internal for tests

src/BenchmarkDotNet/Code/DeclarationsProvider.cs

@@ -14,9 +14,10 @@ internal abstract class DeclarationsProvider
         // "GlobalSetup" or "GlobalCleanup" methods are optional, so default to an empty delegate, so there is always something that can be invoked
         private const string EmptyAction = "() => { }";
 
-        protected readonly Descriptor Descriptor;
+        protected readonly BenchmarkCase Benchmark;
+        protected Descriptor Descriptor => Benchmark.Descriptor;
 
-        internal DeclarationsProvider(Descriptor descriptor) => Descriptor = descriptor;
+        internal DeclarationsProvider(BenchmarkCase benchmark) => Benchmark = benchmark;
 
         public string OperationsPerInvoke => Descriptor.OperationsPerInvoke.ToString();
 
@@ -44,12 +45,11 @@ internal abstract class DeclarationsProvider
 
         public virtual string ConsumeField => null;
 
-        protected abstract Type OverheadMethodReturnType { get; }
-
-        public string OverheadMethodReturnTypeName => OverheadMethodReturnType.GetCorrectCSharpTypeName();
 
         public abstract string OverheadImplementation { get; }
 
+        public virtual string OverheadDefaultValueHolderDeclaration => null;
+
         private string GetMethodName(MethodInfo method)
         {
             if (method == null)
@@ -72,44 +72,42 @@ private string GetMethodName(MethodInfo method)
 
     internal class VoidDeclarationsProvider : DeclarationsProvider
     {
-        public VoidDeclarationsProvider(Descriptor descriptor) : base(descriptor) { }
+        public VoidDeclarationsProvider(BenchmarkCase benchmark) : base(benchmark) { }
 
         public override string ReturnsDefinition => "RETURNS_VOID";
 
-        protected override Type OverheadMethodReturnType => typeof(void);
-
         public override string OverheadImplementation => string.Empty;
     }
 
     internal class NonVoidDeclarationsProvider : DeclarationsProvider
     {
-        public NonVoidDeclarationsProvider(Descriptor descriptor) : base(descriptor) { }
+        private readonly bool overheadReturnsDefault;
+
+        public NonVoidDeclarationsProvider(BenchmarkCase benchmark) : base(benchmark)
+        {
+            overheadReturnsDefault = WorkloadMethodReturnType.IsDefaultFasterThanField(Benchmark.GetRuntime().RuntimeMoniker == Jobs.RuntimeMoniker.Mono);
+        }
 
         public override string ConsumeField
             => !Consumer.IsConsumable(WorkloadMethodReturnType) && Consumer.HasConsumableField(WorkloadMethodReturnType, out var field)
                 ? $".{field.Name}"
                 : null;
 
-        protected override Type OverheadMethodReturnType
-            => Consumer.IsConsumable(WorkloadMethodReturnType)
-                ? WorkloadMethodReturnType
-                : (Consumer.HasConsumableField(WorkloadMethodReturnType, out var field)
-                    ? field.FieldType
-                    : typeof(int)); // we return this simple type because creating bigger ValueType could take longer than benchmarked method itself
-
         public override string OverheadImplementation
+            => overheadReturnsDefault
+                ? $"return default({WorkloadMethodReturnType.GetCorrectCSharpTypeName()});"
+                : "return overheadDefaultValueHolder;";
+
+        public override string OverheadDefaultValueHolderDeclaration
         {
             get
             {
-                string value;
-                var type = OverheadMethodReturnType;
-                if (type.GetTypeInfo().IsPrimitive)
-                    value = $"default({type.GetCorrectCSharpTypeName()})";
-                else if (type.GetTypeInfo().IsClass || type.GetTypeInfo().IsInterface)
-                    value = "null";
-                else
-                    value = SourceCodeHelper.ToSourceCode(Activator.CreateInstance(type)) + ";";
-                return $"return {value};";
+                if (overheadReturnsDefault)
+                {
+                    return null;
+                }
+                string typeName = WorkloadMethodReturnType.GetCorrectCSharpTypeName();
+                return $"private {typeName} overheadDefaultValueHolder = default({typeName});";
             }
         }
 
@@ -121,15 +119,22 @@ public override string ReturnsDefinition
 
     internal class ByRefDeclarationsProvider : NonVoidDeclarationsProvider
     {
-        public ByRefDeclarationsProvider(Descriptor descriptor) : base(descriptor) { }
-
-        protected override Type OverheadMethodReturnType => typeof(IntPtr);
+        public ByRefDeclarationsProvider(BenchmarkCase benchmark) : base(benchmark) { }
 
         public override string WorkloadMethodReturnTypeName => base.WorkloadMethodReturnTypeName.Replace("&", string.Empty);
 
         public override string ConsumeField => null;
 
-        public override string OverheadImplementation => $"return default(System.{nameof(IntPtr)});";
+        public override string OverheadImplementation => $"return ref overheadDefaultValueHolder;";
+
+        public override string OverheadDefaultValueHolderDeclaration
+        {
+            get
+            {
+                string typeName = WorkloadMethodReturnType.GetCorrectCSharpTypeName();
+                return $"private {typeName} overheadDefaultValueHolder = default({typeName});";
+            }
+        }
 
         public override string ReturnsDefinition => "RETURNS_BYREF";
 
@@ -138,16 +143,14 @@ public ByRefDeclarationsProvider(Descriptor descriptor) : base(descriptor) { }
 
     internal class ByReadOnlyRefDeclarationsProvider : ByRefDeclarationsProvider
     {
-        public ByReadOnlyRefDeclarationsProvider(Descriptor descriptor) : base(descriptor) { }
-
-        public override string ReturnsDefinition => "RETURNS_BYREF_READONLY";
+        public ByReadOnlyRefDeclarationsProvider(BenchmarkCase benchmark) : base(benchmark) { }
 
         public override string WorkloadMethodReturnTypeModifiers => "ref readonly";
     }
 
     internal class TaskDeclarationsProvider : VoidDeclarationsProvider
     {
-        public TaskDeclarationsProvider(Descriptor descriptor) : base(descriptor) { }
+        public TaskDeclarationsProvider(BenchmarkCase benchmark) : base(benchmark) { }
 
         // we use GetAwaiter().GetResult() because it's fastest way to obtain the result in blocking way,
         // and will eventually throw actual exception, not aggregated one
@@ -164,7 +167,7 @@ public override string WorkloadMethodDelegate(string passArguments)
     /// </summary>
     internal class GenericTaskDeclarationsProvider : NonVoidDeclarationsProvider
     {
-        public GenericTaskDeclarationsProvider(Descriptor descriptor) : base(descriptor) { }
+        public GenericTaskDeclarationsProvider(BenchmarkCase benchmark) : base(benchmark) { }
 
         protected override Type WorkloadMethodReturnType => Descriptor.WorkloadMethod.ReturnType.GetTypeInfo().GetGenericArguments().Single();
 

src/BenchmarkDotNet/Engines/Consumer.cs

@@ -4,20 +4,14 @@
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using System.Threading;
+using BenchmarkDotNet.Extensions;
 using JetBrains.Annotations;
 
 // ReSharper disable NotAccessedField.Local
 namespace BenchmarkDotNet.Engines
 {
     public class Consumer
     {
-        private static readonly HashSet<Type> SupportedTypes
-            = new HashSet<Type>(
-                typeof(Consumer).GetTypeInfo()
-                                .DeclaredFields
-                                .Where(field => !field.IsStatic) // exclude this HashSet itself
-                                .Select(field => field.FieldType));
-
 #pragma warning disable IDE0052 // Remove unread private members
         private volatile byte byteHolder;
         private volatile sbyte sbyteHolder;
@@ -123,39 +117,13 @@ public void Consume<T>(T objectValue) where T : class // class constraint preven
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Consume<T>(in T value)
-        {
-            if (typeof(T) == typeof(byte))
-                byteHolder = (byte)(object)value;
-            else if (typeof(T) == typeof(sbyte))
-                sbyteHolder = (sbyte)(object)value;
-            else if (typeof(T) == typeof(short))
-                shortHolder = (short)(object)value;
-            else if (typeof(T) == typeof(ushort))
-                ushortHolder = (ushort)(object)value;
-            else if (typeof(T) == typeof(int))
-                intHolder = (int)(object)value;
-            else if (typeof(T) == typeof(uint))
-                uintHolder = (uint)(object)value;
-            else if (typeof(T) == typeof(bool))
-                boolHolder = (bool)(object)value;
-            else if (typeof(T) == typeof(char))
-                charHolder = (char)(object)value;
-            else if (typeof(T) == typeof(float))
-                floatHolder = (float)(object)value;
-            else if (typeof(T) == typeof(double))
-                Volatile.Write(ref doubleHolder, (double)(object)value);
-            else if (typeof(T) == typeof(long))
-                Volatile.Write(ref longHolder, (long)(object)value);
-            else if (typeof(T) == typeof(ulong))
-                Volatile.Write(ref ulongHolder, (ulong)(object)value);
-            else if (default(T) == null && !typeof(T).IsValueType)
-                Consume((object) value);
-            else
-                DeadCodeEliminationHelper.KeepAliveWithoutBoxingReadonly(value); // non-primitive and nullable value types
-        }
+            // Read the value as a byte and write it to a volatile field.
+            // This prevents copying large structs, and prevents dead code elimination and out-of-order execution.
+            // (reading as a type larger than byte could possibly read past the memory bounds, causing the application to crash)
+            // This also works for empty structs, because the runtime enforces a minimum size of 1 byte.
+            => byteHolder = Unsafe.As<T, byte>(ref Unsafe.AsRef(in value));
 
-        internal static bool IsConsumable(Type type)
-            => SupportedTypes.Contains(type) || type.GetTypeInfo().IsClass || type.GetTypeInfo().IsInterface;
+        internal static bool IsConsumable(Type type) => !type.IsByRefLike();
 
         internal static bool HasConsumableField(Type type, out FieldInfo consumableField)
         {

src/BenchmarkDotNet/Extensions/ReflectionExtensions.cs

@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
 using BenchmarkDotNet.Attributes;
 
 namespace BenchmarkDotNet.Extensions
@@ -185,9 +187,7 @@ internal static bool IsStackOnlyWithImplicitCast(this Type argumentType, object?
             if (argumentInstance == null)
                 return false;
 
-            // IsByRefLikeAttribute is not exposed for older runtimes, so we need to check it in an ugly way ;)
-            bool isByRefLike = argumentType.GetCustomAttributes().Any(attribute => attribute.ToString()?.Contains("IsByRefLike") ?? false);
-            if (!isByRefLike)
+            if (!argumentType.IsByRefLike())
                 return false;
 
             var instanceType = argumentInstance.GetType();
@@ -209,5 +209,36 @@ private static bool IsRunnableGenericType(TypeInfo typeInfo)
                     && typeInfo.DeclaredConstructors.Any(ctor => ctor.IsPublic && ctor.GetParameters().Length == 0); // we need public parameterless ctor to create it
 
         internal static bool IsLinqPad(this Assembly assembly) => assembly.FullName.IndexOf("LINQPAD", StringComparison.OrdinalIgnoreCase) >= 0;
+
+        internal static bool IsByRefLike(this Type type)
+            // Type.IsByRefLike is not available in netstandard2.0.
+            => type.IsValueType && type.CustomAttributes.Any(attr => attr.AttributeType.FullName == "System.Runtime.CompilerServices.IsByRefLikeAttribute");
+
+        // Struct size of 64 bytes was observed to be the point at which `default` may be slower in classic Mono, from benchmarks.
+        // Between 64 and 128 bytes, both methods may be about the same speed, depending on the complexity of the struct.
+        // For all types > 128 bytes, reading from a field is faster than `default`.
+        private const int MonoDefaultCutoffSize = 64;
+
+        // We use the fastest possible method to return a value of the workload return type in order to prevent the overhead method from taking longer than the workload method.
+        internal static bool IsDefaultFasterThanField(this Type type, bool isClassicMono)
+                // Classic Mono runs `default` slower than reading a field for very large structs. `default` is faster for all types in all other runtimes.
+            => !isClassicMono
+                // ByRefLike and pointer cannot be used as generic arguments, so check for them before getting the size.
+                || type.IsByRefLike() || type.IsPointer
+                // We don't need to check the size for primitives and reference types.
+                || type.IsPrimitive || type.IsEnum || !type.IsValueType
+                || SizeOf(type) <= MonoDefaultCutoffSize;
+
+        private static int SizeOf(Type type)
+        {
+            return (int) GetGenericSizeOfMethod(type).Invoke(null, null);
+        }
+
+        private static MethodInfo GetGenericSizeOfMethod(Type type)
+        {
+            return typeof(Unsafe).GetMethods(BindingFlags.Static | BindingFlags.Public)
+                .Single(m => m.Name == nameof(Unsafe.SizeOf) && m.IsGenericMethodDefinition && m.ReturnType == typeof(int) && m.GetParameters().Length == 0)
+                .MakeGenericMethod(type);
+        }
     }
 }

src/BenchmarkDotNet/Helpers/Reflection.Emit/IlGeneratorDefaultValueExtensions.cs

@@ -19,6 +19,9 @@ public static void EmitSetLocalToDefault(this ILGenerator ilBuilder, LocalBuilde
             {
                 case Type t when t == typeof(void):
                     break;
+                case Type t when t.IsPointer: // Type.IsClass returns true for pointers, so we have to check for pointer type first.
+                    EmitInitObj(ilBuilder, resultType, local);
+                    break;
                 case Type t when t.IsClass || t.IsInterface:
                     ilBuilder.Emit(OpCodes.Ldnull);
                     ilBuilder.EmitStloc(local);
@@ -39,6 +42,14 @@ public static void EmitReturnDefault(this ILGenerator ilBuilder, Type resultType
             {
                 case Type t when t == typeof(void):
                     break;
+                case Type t when t.IsPointer: // Type.IsClass returns true for pointers, so we have to check for pointer type first.
+                    /*
+                        IL_0000: ldc.i4.0
+                        IL_0001: conv.u
+                     */
+                    ilBuilder.Emit(OpCodes.Ldc_I4_0);
+                    ilBuilder.Emit(OpCodes.Conv_U);
+                    break;
                 case Type t when t.IsClass || t.IsInterface:
                     ilBuilder.Emit(OpCodes.Ldnull);
                     break;