Add hybrid sorting with [HybridSortingNetwork] attribute

.github/workflows/ci.yml

@@ -76,7 +76,11 @@ jobs:
             name=${name%SortingBenchmarks}
             echo "## $name" >> benchmark-summary.md
             echo "" >> benchmark-summary.md
-            echo "> **ArraySort** = BCL baseline \`Array.Sort\`, **GeneratedSort** = this library" >> benchmark-summary.md
+            if [[ "$name" == Hybrid* ]]; then
+              echo "> **ArraySort** = BCL baseline \`Array.Sort\`, **HybridSort** = hybrid quicksort with sorting-network base cases" >> benchmark-summary.md
+            else
+              echo "> **ArraySort** = BCL baseline \`Array.Sort\`, **GeneratedSort** = this library" >> benchmark-summary.md
+            fi
             echo "" >> benchmark-summary.md
             cat "$f" >> benchmark-summary.md
             echo "" >> benchmark-summary.md

SortingNetworks.Benchmarks/GeneratedSorters.cs

@@ -183,3 +183,7 @@ namespace SortingNetworks.Benchmarks;
 [SortingNetwork(31, typeof(Record))]
 [SortingNetwork(32, typeof(Record))]
 partial class GeneratedSorters { }
+
+[HybridSortingNetwork(typeof(int))]
+[HybridSortingNetwork(typeof(long))]
+partial class HybridSorters { }

SortingNetworks.Benchmarks/HybridIntSortingBenchmarks.cs

@@ -0,0 +1,64 @@
+using BenchmarkDotNet.Attributes;
+
+namespace SortingNetworks.Benchmarks;
+
+[MemoryDiagnoser]
+[SimpleJob(warmupCount: 5, iterationCount: 15)]
+public class HybridIntSortingBenchmarks
+{
+    private const int OpsPerInvoke = 1000;
+
+    [Params(32, 64, 100, 1000, 10000)]
+    public int Length { get; set; }
+
+    [ParamsAllValues]
+    public InputKind Kind { get; set; }
+
+    private int[] _source = null!;
+    private int[][] _batch = null!;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        var rng = new Random(42);
+        _source = Kind switch
+        {
+            InputKind.Random => Enumerable.Range(0, Length).Select(_ => rng.Next(-1000, 1000)).ToArray(),
+            InputKind.Sorted => Enumerable.Range(0, Length).ToArray(),
+            InputKind.Reversed => Enumerable.Range(0, Length).Reverse().ToArray(),
+            InputKind.Duplicates => Enumerable.Range(0, Length).Select(_ => rng.Next(0, 3)).ToArray(),
+            _ => throw new ArgumentOutOfRangeException()
+        };
+        _batch = new int[OpsPerInvoke][];
+        for (int i = 0; i < OpsPerInvoke; i++)
+            _batch[i] = new int[Length];
+    }
+
+    [IterationSetup]
+    public void IterationSetup()
+    {
+        for (int i = 0; i < OpsPerInvoke; i++)
+            Array.Copy(_source, _batch[i], Length);
+    }
+
+    [Benchmark(Baseline = true, OperationsPerInvoke = OpsPerInvoke)]
+    public void ArraySort()
+    {
+        for (int i = 0; i < OpsPerInvoke; i++)
+            Array.Sort(_batch[i]);
+    }
+
+    [Benchmark(OperationsPerInvoke = OpsPerInvoke)]
+    public void SpanSort()
+    {
+        for (int i = 0; i < OpsPerInvoke; i++)
+            _batch[i].AsSpan().Sort();
+    }
+
+    [Benchmark(OperationsPerInvoke = OpsPerInvoke)]
+    public void HybridSort()
+    {
+        for (int i = 0; i < OpsPerInvoke; i++)
+            HybridSorters.Sort(_batch[i].AsSpan());
+    }
+}

SortingNetworks.Benchmarks/HybridLongSortingBenchmarks.cs

@@ -0,0 +1,57 @@
+using BenchmarkDotNet.Attributes;
+
+namespace SortingNetworks.Benchmarks;
+
+[MemoryDiagnoser]
+[SimpleJob(warmupCount: 5, iterationCount: 15)]
+public class HybridLongSortingBenchmarks
+{
+    private const int OpsPerInvoke = 1000;
+
+    [Params(32, 64, 100, 1000, 10000)]
+    public int Length { get; set; }
+
+    [Params(InputKind.Random)]
+    public InputKind Kind { get; set; }
+
+    private long[] _source = null!;
+    private long[][] _batch = null!;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        var rng = new Random(42);
+        _source = Enumerable.Range(0, Length).Select(_ => (long)rng.Next(-1000, 1000)).ToArray();
+        _batch = new long[OpsPerInvoke][];
+        for (int i = 0; i < OpsPerInvoke; i++)
+            _batch[i] = new long[Length];
+    }
+
+    [IterationSetup]
+    public void IterationSetup()
+    {
+        for (int i = 0; i < OpsPerInvoke; i++)
+            Array.Copy(_source, _batch[i], Length);
+    }
+
+    [Benchmark(Baseline = true, OperationsPerInvoke = OpsPerInvoke)]
+    public void ArraySort()
+    {
+        for (int i = 0; i < OpsPerInvoke; i++)
+            Array.Sort(_batch[i]);
+    }
+
+    [Benchmark(OperationsPerInvoke = OpsPerInvoke)]
+    public void SpanSort()
+    {
+        for (int i = 0; i < OpsPerInvoke; i++)
+            _batch[i].AsSpan().Sort();
+    }
+
+    [Benchmark(OperationsPerInvoke = OpsPerInvoke)]
+    public void HybridSort()
+    {
+        for (int i = 0; i < OpsPerInvoke; i++)
+            HybridSorters.Sort(_batch[i].AsSpan());
+    }
+}