addressing PR feedback, #736

Author: adamsitnik

samples/BenchmarkDotNet.Samples/Intro/IntroInProcessWrongEnv.cs

@@ -5,6 +5,7 @@
 using BenchmarkDotNet.Environments;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Order;
+using BenchmarkDotNet.Portability;
 using BenchmarkDotNet.Toolchains.InProcess;
 
 namespace BenchmarkDotNet.Samples.Intro
@@ -18,7 +19,7 @@ private class Config : ManualConfig
         {
             public Config()
             {
-                var wrongPlatform = IntPtr.Size == sizeof(int)
+                var wrongPlatform = RuntimeInformation.GetCurrentPlatform() == Platform.X86
                     ? Platform.X64
                     : Platform.X86;
 

src/BenchmarkDotNet/Diagnosers/WindowsDisassembler.cs

@@ -156,7 +156,7 @@ public static bool Is64Bit(Process process)
                     return !isWow64;
                 }
 
-                return IntPtr.Size == 8; // todo: find the way to cover all scenarios for .NET Core
+                return Portability.RuntimeInformation.GetCurrentPlatform() == Platform.X64; // todo: find the way to cover all scenarios for .NET Core
             }
 
             [DllImport("kernel32.dll", SetLastError = true, CallingConvention = CallingConvention.Winapi)]

src/BenchmarkDotNet/Engines/EngineFactory.cs

@@ -41,7 +41,9 @@ public IEngine CreateReadyToRun(EngineParameters engineParameters)
             }
 
             var needsPilot = !engineParameters.TargetJob.HasValue(RunMode.InvocationCountCharacteristic);
-            if (needsPilot) 
+            var hasUnrollFactorDefined = engineParameters.TargetJob.HasValue(RunMode.UnrollFactorCharacteristic);
+            
+            if (needsPilot && !hasUnrollFactorDefined) 
             {
                 var singleActionEngine = CreateEngine(engineParameters, resolver, engineParameters.TargetJob, engineParameters.IdleSingleAction, engineParameters.MainSingleAction);
 
@@ -70,9 +72,13 @@ private static bool ShouldExecuteOncePerIteration(Measurement jit, TimeInterval
 
         private static Measurement Jit(Engine engine, int unrollFactor)
         {
-            DeadCodeEliminationHelper.KeepAliveWithoutBoxing(engine.RunIteration(new IterationData(IterationMode.IdleJit, index: -1, invokeCount: unrollFactor, unrollFactor: unrollFactor))); // don't forget to JIT idle
+            DeadCodeEliminationHelper.KeepAliveWithoutBoxing(engine.RunIteration(new IterationData(IterationMode.IdleJitting, index: 1, invokeCount: unrollFactor, unrollFactor: unrollFactor))); // don't forget to JIT idle
+            
+            var result = engine.RunIteration(new IterationData(IterationMode.MainJitting, index: 1, invokeCount: unrollFactor, unrollFactor: unrollFactor));
+
+            engine.WriteLine();
 
-            return engine.RunIteration(new IterationData(IterationMode.Jit, index: -1, invokeCount: unrollFactor, unrollFactor: unrollFactor));
+            return result;
         }
 
         private static Engine CreateEngine(EngineParameters engineParameters, IResolver resolver, Job job, Action<long> idle, Action<long> main)

src/BenchmarkDotNet/Engines/IterationMode.cs

@@ -40,6 +40,6 @@ public enum IterationMode
         /// <summary>
         /// executing benchmark for the purpose of JIT wamup
         /// </summary>
-        Jit, IdleJit
+        MainJitting, IdleJitting
     }
 }

src/BenchmarkDotNet/Engines/IterationModeExtensions.cs

@@ -3,6 +3,6 @@
     public static class IterationModeExtensions
     {
         public static bool IsIdle(this IterationMode mode) 
-            => mode == IterationMode.IdleWarmup || mode == IterationMode.IdleTarget || mode == IterationMode.IdleJit;
+            => mode == IterationMode.IdleWarmup || mode == IterationMode.IdleTarget || mode == IterationMode.IdleJitting;
     }
 }

src/BenchmarkDotNet/Extensions/ProcessExtensions.cs

@@ -4,6 +4,7 @@
 using BenchmarkDotNet.Environments;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Loggers;
+using BenchmarkDotNet.Portability;
 using BenchmarkDotNet.Running;
 using JetBrains.Annotations;
 
@@ -31,7 +32,7 @@ private static IntPtr FixAffinity(IntPtr processorAffinity)
         {
             int cpuMask = (1 << Environment.ProcessorCount) - 1;
 
-            return IntPtr.Size == sizeof(Int64) 
+            return RuntimeInformation.GetCurrentPlatform() == Platform.X64
                 ? new IntPtr(processorAffinity.ToInt64() & cpuMask)
                 : new IntPtr(processorAffinity.ToInt32() & cpuMask);
         }

src/BenchmarkDotNet/Portability/RuntimeInformation.cs

@@ -61,7 +61,7 @@ internal static class RuntimeInformation
 
         internal static string ScriptFileExtension => IsWindows() ? ".bat" : ".sh";
 
-        internal static string GetArchitecture() => IntPtr.Size == 4 ? "32bit" : "64bit";
+        internal static string GetArchitecture() => GetCurrentPlatform() == Platform.X86 ? "32bit" : "64bit";
 
         internal static bool IsWindows()
         {
@@ -246,7 +246,7 @@ internal static bool HasRyuJit()
             if (IsNetCore)
                 return true;
 
-            return IntPtr.Size == 8
+            return GetCurrentPlatform() == Platform.X64
                    && GetConfiguration() != DebugConfigurationName
                    && !new JitHelper().IsMsX64();
         }

tests/BenchmarkDotNet.IntegrationTests/CoreRtTests.cs

@@ -17,7 +17,7 @@ public CoreRtTests(ITestOutputHelper outputHelper) : base(outputHelper) { }
         [Fact]
         public void CoreRtIsSupported()
         {
-            if (IntPtr.Size == sizeof(int)) // CoreRT does not support 32bit yet
+            if (RuntimeInformation.GetCurrentPlatform() == Platform.X86) // CoreRT does not support 32bit yet
                 return;
 
             var config = ManualConfig.CreateEmpty()

tests/BenchmarkDotNet.Tests/Engine/EngineFactoryTests.cs

@@ -71,6 +71,32 @@ public void ForJobsThatDontRequireJittingOnlyGlobalSetupIsCalled()
 
             Assert.Equal(1, timesGlobalCleanupCalled);
         }
+
+        [Fact]
+        public void ForJobsWithExplicitUnrollFactorTheGlobalSetupIsCalledAndMultiActionCodeGetsJitted()
+            => AssertGlobalSetupWasCalledAndMultiActionGotJitted(Job.Default.WithUnrollFactor(16));
+
+        [Fact]
+        public void ForJobsThatDontRequirePilotTheGlobalSetupIsCalledAndMultiActionCodeGetsJitted() 
+            => AssertGlobalSetupWasCalledAndMultiActionGotJitted(Job.Default.WithInvocationCount(100));
+
+        public void AssertGlobalSetupWasCalledAndMultiActionGotJitted(Job job)
+        {
+            var engineParameters = CreateEngineParameters(mainSingleAction: Throwing, mainMultiAction: Instant16, job: job);
+
+            var engine = new EngineFactory().CreateReadyToRun(engineParameters);
+
+            Assert.Equal(1, timesGlobalSetupCalled);
+            Assert.Equal(2, timesIterationSetupCalled);
+            Assert.Equal(16, timesBenchmarkCalled);
+            Assert.Equal(16, timesIdleCalled);
+            Assert.Equal(2, timesIterationCleanupCalled);
+            Assert.Equal(0, timesGlobalCleanupCalled); 
+
+            engine.Dispose();
+
+            Assert.Equal(1, timesGlobalCleanupCalled);
+        }
 
         [Fact]
         public void NonVeryTimeConsumingBenchmarksAreExecutedMoreThanOncePerIterationWithUnrollFactorForDefaultSettings()