- Marked Swap() with AggressiveInlining, and used this in SwapIfGreat…

…er(). Together these two changes give a 15% performance improvement in the synthetic benchmark.

- Added IntroSortKVWBenchmarks.

Redzen.Benchmarks/IntroSortKVWBenchmarks.cs

@@ -0,0 +1,46 @@
+using BenchmarkDotNet.Attributes;
+using Redzen.Random;
+using Redzen.Sorting;
+
+namespace Redzen.Benchmarks
+{
+    [InvocationCount(1000)]
+    [MinWarmupCount(6, forceAutoWarmup: true)] // when InvocationCount is set, BDN does not run Pilot Stage, so to get the code promoted to Tier 1 before Actual Workload, we enforce more Warmups
+    public class IntroSortKVWBenchmarks
+    {
+        [Params(50_000)]
+        public int Length;
+
+        int[] _keys;
+        int[] _values;
+        int[] _values2;
+        IRandomSource _rng = RandomDefaults.CreateRandomSource(123);
+
+        [GlobalSetup]
+        public void GlobalSetup()
+        {
+            _keys = new int[Length];
+            _values = new int[Length];
+            _values2 = new int[Length];
+
+            for(int i=0; i < _keys.Length; i++)
+            {
+                _keys[i] = _rng.Next();
+                _values[i] = _keys[i];
+                _values2[i] = _keys[i];
+            }
+        }
+
+        [IterationSetup]
+        public void IterationSetup()
+        {
+            SortUtils.Shuffle<int>(_keys, _rng);
+        }
+
+        [Benchmark]
+        public void Sort()
+        {
+            IntroSort<int,int,int>.Sort(_keys, _values, _values2);
+        }
+    }
+}

Redzen.Benchmarks/Program.cs

@@ -1,4 +1,8 @@
-using BenchmarkDotNet.Running;
+using System;
+using System.Diagnostics;
+using BenchmarkDotNet.Running;
+using Redzen.Random;
+using Redzen.Sorting;
 
 namespace Redzen.Benchmarks
 {
@@ -12,10 +16,10 @@ static void Main(string[] args)
             //var xoshiro256StarStarSummary = BenchmarkRunner.Run<Xoshiro256StarStarRandomBenchmark>();
             //var xoshiro512StarStarSummary = BenchmarkRunner.Run<Xoshiro512StarStarRandomBenchmark>();
 
-            var zigguratGaussianSummary = BenchmarkRunner.Run<ZigguratGaussianDistributionBenchmark>();
+            //var zigguratGaussianSummary = BenchmarkRunner.Run<ZigguratGaussianDistributionBenchmark>();
             //var boxMullerGaussianSummary = BenchmarkRunner.Run<BoxMullerGaussianDistributionBenchmark>();
 
-            //ArraySortPerfTest.RunTests(50_000, 1000);
+            var introSortSummary = BenchmarkRunner.Run<IntroSortKVWBenchmarks>();
         }
     }
 }

Redzen/Sorting/IntroSortKVW.cs

@@ -132,7 +132,7 @@ private static int PickPivotAndPartition(
             Span<V> values,
             Span<W> wspan)
         {
-            Debug.Assert(keys.Length >=  __introsortSizeThreshold);
+            Debug.Assert(keys.Length >= __introsortSizeThreshold);
 
             int hi = keys.Length - 1;
 
@@ -261,27 +261,17 @@ private static void SwapIfGreater(
             Span<K> keys,
             Span<V> vspan,
             Span<W> wspan,
-            int i, int j)
+            int i,int j)
         {
             Debug.Assert(i != j);
 
-            ref K keyRef = ref keys[i];
-            if (GreaterThan(ref keyRef, ref keys[j]))
+            if(GreaterThan(ref keys[i],ref keys[j]))
             {
-                K key = keyRef;
-                keys[i] = keys[j];
-                keys[j] = key;
-
-                V v = vspan[i];
-                vspan[i] = vspan[j];
-                vspan[j] = v;
-
-                W w = wspan[i];
-                wspan[i] = wspan[j];
-                wspan[j] = w;
+                Swap(keys,vspan,wspan,i,j);
             }
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static void Swap(
             Span<K> keys,
             Span<V> vspan,