results-1.1-netcore2.2.txt

Benchmarking on .NETCoreApp,Version=v2.2; 64-bit; Intel64 Family 6 Model 158 Stepping 10, GenuineIntel with quality constant 1000000000000maxIters: 200000
With arrays lengths approximating: 32, 128, 1024, 8192, 65536, 524288, 4194304


Sorting arrays of int with 32.0 elements by Int32Ordering (average over 200000 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type int: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
     PrimitiveArraySort: mean 11.531~0.02 ns/item; median 12.0; overhead: 38.8%
      ParallelQuickSort: mean 7.6514~0.02 ns/item; median 7.3; overhead: 48.7%
              QuickSort: mean 7.5311~0.02 ns/item; median 7.3; overhead: 48.9%
       TopDownMergeSort: mean 7.5715~0.02 ns/item; median 7.3; overhead: 49.1%
      BottomUpMergeSort: mean 9.458~0.031 ns/item; median 8.9; overhead: 42.5%
     DualPivotQuickSort: mean 7.583~0.02  ns/item; median 7.3; overhead: 49.0%
    AltTopDownMergeSort: mean 7.5988~0.023 ns/item; median 7.3; overhead: 48.4%

Sorting arrays of int with 32.0 elements by ComparableOrdering<int> (average over 200000 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type int: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 19.969~0.025 ns/item; median 20.9; overhead: 29.5%
      ParallelQuickSort: mean 8.73~0.021  ns/item; median 8.7; overhead: 47.6%
              QuickSort: mean 8.4767~0.02 ns/item; median 8.3; overhead: 48.5%
       TopDownMergeSort: mean 8.5982~0.021 ns/item; median 8.5; overhead: 48.4%
      BottomUpMergeSort: mean 10.018~0.026 ns/item; median 10.0; overhead: 44.5%
     DualPivotQuickSort: mean 8.5044~0.02 ns/item; median 8.3; overhead: 49.1%
    AltTopDownMergeSort: mean 8.8679~0.024 ns/item; median 8.7; overhead: 47.3%

Sorting arrays of uint with 32.0 elements by UInt32Ordering (average over 200000 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type uint: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
     PrimitiveArraySort: mean 12.349~0.02 ns/item; median 13.0; overhead: 35.5%
      ParallelQuickSort: mean 8.0868~0.02 ns/item; median 7.9; overhead: 46.2%
              QuickSort: mean 8.0432~0.02 ns/item; median 7.9; overhead: 46.0%
       TopDownMergeSort: mean 8.102~0.021 ns/item; median 7.9; overhead: 46.0%
      BottomUpMergeSort: mean 9.1902~0.027 ns/item; median 8.9; overhead: 42.9%
     DualPivotQuickSort: mean 8.1347~0.02 ns/item; median 7.9; overhead: 46.1%
    AltTopDownMergeSort: mean 8.0913~0.024 ns/item; median 7.9; overhead: 45.8%

Sorting arrays of uint with 32.0 elements by ComparableOrdering<uint> (average over 200000 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type uint: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 19.502~0.039 ns/item; median 20.6; overhead: 29.5%
      ParallelQuickSort: mean 8.2349~0.02 ns/item; median 7.9; overhead: 48.9%
              QuickSort: mean 7.9496~0.02 ns/item; median 7.8; overhead: 49.4%
       TopDownMergeSort: mean 8.0565~0.02 ns/item; median 7.8; overhead: 49.3%
      BottomUpMergeSort: mean 11.18~0.044 ns/item; median 10.7; overhead: 45.2%
     DualPivotQuickSort: mean 8.831~0.046 ns/item; median 8.3; overhead: 48.6%
    AltTopDownMergeSort: mean 8.6765~0.024 ns/item; median 8.5; overhead: 47.5%

Sorting arrays of ulong with 32.0 elements by UInt64Ordering (average over 200000 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type ulong: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
     PrimitiveArraySort: mean 12.916~0.02 ns/item; median 13.6; overhead: 35.4%
      ParallelQuickSort: mean 8.066~0.02  ns/item; median 7.9; overhead: 46.8%
              QuickSort: mean 7.8655~0.019 ns/item; median 7.6; overhead: 46.3%
       TopDownMergeSort: mean 7.9912~0.02 ns/item; median 7.8; overhead: 46.9%
      BottomUpMergeSort: mean 9.4093~0.029 ns/item; median 9.1; overhead: 42.9%
     DualPivotQuickSort: mean 8.0675~0.021 ns/item; median 7.9; overhead: 46.5%
    AltTopDownMergeSort: mean 8.1702~0.024 ns/item; median 7.9; overhead: 46.1%

Sorting arrays of ulong with 32.0 elements by ComparableOrdering<ulong> (average over 200000 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type ulong: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 19.932~0.026 ns/item; median 20.6; overhead: 30.1%
      ParallelQuickSort: mean 8.4876~0.021 ns/item; median 8.1; overhead: 49.1%
              QuickSort: mean 8.2436~0.02 ns/item; median 7.9; overhead: 49.8%
       TopDownMergeSort: mean 8.2767~0.021 ns/item; median 7.9; overhead: 49.7%
      BottomUpMergeSort: mean 10.24~0.049 ns/item; median 9.9; overhead: 44.2%
     DualPivotQuickSort: mean 8.3514~0.02 ns/item; median 8.1; overhead: 49.5%
    AltTopDownMergeSort: mean 8.4201~0.024 ns/item; median 8.1; overhead: 49.3%

Sorting arrays of double with 32.0 elements by DoubleOrdering (average over 200000 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type double: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
     PrimitiveArraySort: mean 14.871~0.021 ns/item; median 16.0; overhead: 34.9%
      ParallelQuickSort: mean 8.4548~0.021 ns/item; median 8.3; overhead: 49.0%
              QuickSort: mean 8.2953~0.02 ns/item; median 8.1; overhead: 49.0%
       TopDownMergeSort: mean 8.3892~0.021 ns/item; median 8.1; overhead: 48.9%
      BottomUpMergeSort: mean 10.28~0.039 ns/item; median 10.0; overhead: 43.4%
     DualPivotQuickSort: mean 8.413~0.02  ns/item; median 8.1; overhead: 48.8%
    AltTopDownMergeSort: mean 8.4691~0.024 ns/item; median 8.3; overhead: 48.2%

Sorting arrays of double with 32.0 elements by ComparableOrdering<double> (average over 200000 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type double: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 29.957~0.029 ns/item; median 32.3; overhead: 23.1%
      ParallelQuickSort: mean 17.364~0.026 ns/item; median 19.6; overhead: 31.1%
              QuickSort: mean 17.224~0.024 ns/item; median 19.3; overhead: 31.2%
       TopDownMergeSort: mean 17.314~0.024 ns/item; median 19.6; overhead: 31.1%
      BottomUpMergeSort: mean 17.524~0.029 ns/item; median 18.9; overhead: 32.4%
     DualPivotQuickSort: mean 17.274~0.024 ns/item; median 19.6; overhead: 31.2%
    AltTopDownMergeSort: mean 17.296~0.027 ns/item; median 19.2; overhead: 31.3%

Sorting arrays of float with 32.0 elements by FloatOrdering (average over 200000 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type float: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
     PrimitiveArraySort: mean 14.737~0.021 ns/item; median 15.8; overhead: 33.8%
      ParallelQuickSort: mean 8.3943~0.02 ns/item; median 8.1; overhead: 47.1%
              QuickSort: mean 8.3435~0.02 ns/item; median 8.1; overhead: 47.2%
       TopDownMergeSort: mean 8.3343~0.02 ns/item; median 8.1; overhead: 47.2%
      BottomUpMergeSort: mean 9.8659~0.031 ns/item; median 9.9; overhead: 42.8%
     DualPivotQuickSort: mean 8.3983~0.021 ns/item; median 8.1; overhead: 47.6%
    AltTopDownMergeSort: mean 8.3927~0.024 ns/item; median 8.1; overhead: 47.1%

Sorting arrays of float with 32.0 elements by ComparableOrdering<float> (average over 200000 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type float: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 29.714~0.04 ns/item; median 32.4; overhead: 22.0%
      ParallelQuickSort: mean 16.747~0.024 ns/item; median 19.0; overhead: 31.1%
              QuickSort: mean 16.558~0.023 ns/item; median 18.7; overhead: 31.2%
       TopDownMergeSort: mean 16.66~0.023 ns/item; median 18.9; overhead: 31.1%
      BottomUpMergeSort: mean 16.535~0.028 ns/item; median 18.1; overhead: 32.5%
     DualPivotQuickSort: mean 16.697~0.023 ns/item; median 18.9; overhead: 31.2%
    AltTopDownMergeSort: mean 16.639~0.027 ns/item; median 18.7; overhead: 31.1%

Sorting arrays of (int, int, int) with 32.0 elements by SmallTupleOrder (average over 200000 benchmarked arrays).
Insertion sorts below 34; faster quicksort median below 16000; no parallelism below 1000 items.
type (int, int, int): total size 16.0 bytes of which value 16.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 27.892~0.029 ns/item; median 30.2; overhead: 30.6%
      ParallelQuickSort: mean 20.885~0.035 ns/item; median 19.0; overhead: 33.0%
              QuickSort: mean 13.202~0.022 ns/item; median 14.6; overhead: 46.4%
       TopDownMergeSort: mean 13.04~0.023 ns/item; median 14.2; overhead: 46.7%
      BottomUpMergeSort: mean 34.667~0.039 ns/item; median 35.7; overhead: 25.2%
     DualPivotQuickSort: mean 13.287~0.022 ns/item; median 14.6; overhead: 46.3%
    AltTopDownMergeSort: mean 13.409~0.023 ns/item; median 14.6; overhead: 45.9%

Sorting arrays of SampleClass with 32.0 elements by SampleClassOrder (average over 200000 benchmarked arrays).
Insertion sorts below 24; faster quicksort median below 10000; no parallelism below 1500 items.
type SampleClass: total size 32.0 bytes of which value 8.0 and heap size 24.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 30.096~0.034 ns/item; median 29.5; overhead: 29.0%
      ParallelQuickSort: mean 17.322~0.026 ns/item; median 17.8; overhead: 39.2%
              QuickSort: mean 17.056~0.025 ns/item; median 17.6; overhead: 39.7%
       TopDownMergeSort: mean 18.423~0.028 ns/item; median 19.1; overhead: 37.4%
      BottomUpMergeSort: mean 20.783~0.03 ns/item; median 20.2; overhead: 36.3%
     DualPivotQuickSort: mean 17.471~0.025 ns/item; median 18.2; overhead: 39.3%
    AltTopDownMergeSort: mean 18.159~0.027 ns/item; median 18.7; overhead: 38.1%

Sorting arrays of (int, long, DateTime, string, Guid) with 32.0 elements by BigTupleOrder (average over 200000 benchmarked arrays).
Insertion sorts below 11; faster quicksort median below 16000; no parallelism below 1000 items.
type (int, long, DateTime, string, Guid): total size 48.5 bytes of which value 48.0 and heap size 0.5.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 99.611~0.059 ns/item; median 107.1; overhead: 24.0%
      ParallelQuickSort: mean 47.794~0.034 ns/item; median 52.0; overhead: 39.0%
              QuickSort: mean 47.504~0.034 ns/item; median 51.9; overhead: 39.2%
       TopDownMergeSort: mean 53.261~0.046 ns/item; median 58.0; overhead: 36.6%
      BottomUpMergeSort: mean 58.133~0.05 ns/item; median 62.3; overhead: 35.5%
     DualPivotQuickSort: mean 47.665~0.034 ns/item; median 51.9; overhead: 39.9%
    AltTopDownMergeSort: mean 51.01~0.042 ns/item; median 55.3; overhead: 37.8%

Sorting arrays of string with 32.0 elements by StringOrder (average over 200000 benchmarked arrays).
Insertion sorts below 18; faster quicksort median below 2000; no parallelism below 800 items.
type string: total size 56.7 bytes of which value 8.0 and heap size 48.7.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
        StringArraySort: mean 42.148~0.028 ns/item; median 43.6; overhead: 38.1%
      ParallelQuickSort: mean 34.96~0.031 ns/item; median 38.5; overhead: 40.0%
              QuickSort: mean 35.089~0.031 ns/item; median 38.5; overhead: 40.2%
       TopDownMergeSort: mean 35.242~0.038 ns/item; median 38.5; overhead: 40.3%
      BottomUpMergeSort: mean 38.063~0.039 ns/item; median 40.8; overhead: 39.1%
     DualPivotQuickSort: mean 36.186~0.031 ns/item; median 40.1; overhead: 39.5%
    AltTopDownMergeSort: mean 34.655~0.032 ns/item; median 38.1; overhead: 40.6%


Sorting arrays of int with 128.0 elements by Int32Ordering (average over 200000 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type int: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
     PrimitiveArraySort: mean 17.619~0.016 ns/item; median 17.3; overhead: 18.6%
      ParallelQuickSort: mean 12.774~0.016 ns/item; median 12.8; overhead: 23.2%
              QuickSort: mean 12.735~0.016 ns/item; median 12.8; overhead: 23.1%
       TopDownMergeSort: mean 13.109~0.016 ns/item; median 13.1; overhead: 22.7%
      BottomUpMergeSort: mean 14.573~0.018 ns/item; median 14.4; overhead: 21.0%
     DualPivotQuickSort: mean 12.733~0.016 ns/item; median 12.8; overhead: 23.2%
    AltTopDownMergeSort: mean 13.342~0.016 ns/item; median 13.2; overhead: 22.5%

Sorting arrays of int with 128.0 elements by ComparableOrdering<int> (average over 200000 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type int: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 27.583~0.018 ns/item; median 27.2; overhead: 15.4%
      ParallelQuickSort: mean 14.554~0.017 ns/item; median 14.6; overhead: 25.3%
              QuickSort: mean 14.533~0.016 ns/item; median 14.6; overhead: 25.2%
       TopDownMergeSort: mean 14.369~0.016 ns/item; median 14.4; overhead: 24.8%
      BottomUpMergeSort: mean 15.182~0.017 ns/item; median 15.0; overhead: 24.0%
     DualPivotQuickSort: mean 13.966~0.017 ns/item; median 14.0; overhead: 25.4%
    AltTopDownMergeSort: mean 14.315~0.016 ns/item; median 14.4; overhead: 24.8%

Sorting arrays of uint with 128.0 elements by UInt32Ordering (average over 200000 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type uint: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
     PrimitiveArraySort: mean 18.565~0.016 ns/item; median 18.2; overhead: 17.7%
      ParallelQuickSort: mean 13.477~0.016 ns/item; median 13.5; overhead: 22.1%
              QuickSort: mean 13.346~0.016 ns/item; median 13.4; overhead: 22.2%
       TopDownMergeSort: mean 13.788~0.016 ns/item; median 13.9; overhead: 21.6%
      BottomUpMergeSort: mean 14.614~0.017 ns/item; median 14.4; overhead: 20.8%
     DualPivotQuickSort: mean 13.412~0.017 ns/item; median 13.4; overhead: 22.3%
    AltTopDownMergeSort: mean 13.713~0.016 ns/item; median 13.8; overhead: 21.6%

Sorting arrays of uint with 128.0 elements by ComparableOrdering<uint> (average over 200000 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type uint: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 26.867~0.017 ns/item; median 26.5; overhead: 15.3%
      ParallelQuickSort: mean 13.769~0.016 ns/item; median 13.8; overhead: 25.0%
              QuickSort: mean 13.574~0.016 ns/item; median 13.6; overhead: 25.3%
       TopDownMergeSort: mean 13.909~0.016 ns/item; median 14.0; overhead: 24.8%
      BottomUpMergeSort: mean 14.8~0.018  ns/item; median 14.6; overhead: 24.0%
     DualPivotQuickSort: mean 13.606~0.016 ns/item; median 13.6; overhead: 25.4%
    AltTopDownMergeSort: mean 13.703~0.016 ns/item; median 13.7; overhead: 25.1%

Sorting arrays of ulong with 128.0 elements by UInt64Ordering (average over 200000 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type ulong: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
     PrimitiveArraySort: mean 18.938~0.016 ns/item; median 18.7; overhead: 17.5%
      ParallelQuickSort: mean 13.363~0.017 ns/item; median 13.4; overhead: 22.5%
              QuickSort: mean 13.322~0.016 ns/item; median 13.4; overhead: 22.3%
       TopDownMergeSort: mean 13.875~0.017 ns/item; median 13.9; overhead: 21.6%
      BottomUpMergeSort: mean 14.875~0.019 ns/item; median 14.6; overhead: 20.8%
     DualPivotQuickSort: mean 13.346~0.016 ns/item; median 13.4; overhead: 22.3%
    AltTopDownMergeSort: mean 13.753~0.016 ns/item; median 13.8; overhead: 21.7%

Sorting arrays of ulong with 128.0 elements by ComparableOrdering<ulong> (average over 200000 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type ulong: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 26.754~0.018 ns/item; median 26.2; overhead: 15.8%
      ParallelQuickSort: mean 13.352~0.016 ns/item; median 13.4; overhead: 26.0%
              QuickSort: mean 13.315~0.016 ns/item; median 13.4; overhead: 26.2%
       TopDownMergeSort: mean 13.564~0.017 ns/item; median 13.5; overhead: 25.8%
      BottomUpMergeSort: mean 14.962~0.019 ns/item; median 14.6; overhead: 24.3%
     DualPivotQuickSort: mean 13.354~0.017 ns/item; median 13.4; overhead: 26.1%
    AltTopDownMergeSort: mean 13.724~0.017 ns/item; median 13.7; overhead: 25.8%

Sorting arrays of double with 128.0 elements by DoubleOrdering (average over 200000 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type double: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
     PrimitiveArraySort: mean 22.088~0.016 ns/item; median 21.7; overhead: 18.5%
      ParallelQuickSort: mean 14.34~0.016 ns/item; median 14.5; overhead: 24.7%
              QuickSort: mean 14.287~0.016 ns/item; median 14.5; overhead: 23.9%
       TopDownMergeSort: mean 14.616~0.017 ns/item; median 14.8; overhead: 24.5%
      BottomUpMergeSort: mean 16.259~0.019 ns/item; median 16.1; overhead: 22.6%
     DualPivotQuickSort: mean 14.34~0.017 ns/item; median 14.5; overhead: 24.6%
    AltTopDownMergeSort: mean 14.774~0.017 ns/item; median 14.8; overhead: 24.3%

Sorting arrays of double with 128.0 elements by ComparableOrdering<double> (average over 200000 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type double: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 42.653~0.02 ns/item; median 42.8; overhead: 11.4%
      ParallelQuickSort: mean 27.613~0.018 ns/item; median 28.2; overhead: 15.9%
              QuickSort: mean 27.522~0.018 ns/item; median 28.2; overhead: 15.9%
       TopDownMergeSort: mean 28.06~0.02  ns/item; median 28.6; overhead: 15.7%
      BottomUpMergeSort: mean 27.219~0.027 ns/item; median 27.3; overhead: 16.6%
     DualPivotQuickSort: mean 27.563~0.018 ns/item; median 28.2; overhead: 15.9%
    AltTopDownMergeSort: mean 27.252~0.018 ns/item; median 28.1; overhead: 15.9%

Sorting arrays of float with 128.0 elements by FloatOrdering (average over 200000 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type float: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
     PrimitiveArraySort: mean 22.06~0.017 ns/item; median 21.6; overhead: 17.3%
      ParallelQuickSort: mean 14.439~0.016 ns/item; median 14.6; overhead: 22.7%
              QuickSort: mean 14.374~0.016 ns/item; median 14.6; overhead: 22.0%
       TopDownMergeSort: mean 14.483~0.016 ns/item; median 14.6; overhead: 21.9%
      BottomUpMergeSort: mean 15.981~0.018 ns/item; median 16.0; overhead: 20.6%
     DualPivotQuickSort: mean 14.412~0.016 ns/item; median 14.5; overhead: 22.2%
    AltTopDownMergeSort: mean 14.697~0.017 ns/item; median 14.7; overhead: 21.9%

Sorting arrays of float with 128.0 elements by ComparableOrdering<float> (average over 200000 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type float: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 43.07~0.02  ns/item; median 43.4; overhead: 10.6%
      ParallelQuickSort: mean 26.627~0.018 ns/item; median 27.2; overhead: 15.5%
              QuickSort: mean 26.615~0.018 ns/item; median 27.2; overhead: 15.5%
       TopDownMergeSort: mean 27.218~0.019 ns/item; median 27.7; overhead: 15.2%
      BottomUpMergeSort: mean 25.941~0.019 ns/item; median 26.2; overhead: 16.1%
     DualPivotQuickSort: mean 26.689~0.018 ns/item; median 27.2; overhead: 15.4%
    AltTopDownMergeSort: mean 26.308~0.018 ns/item; median 27.1; overhead: 15.4%

Sorting arrays of (int, int, int) with 128.0 elements by SmallTupleOrder (average over 200000 benchmarked arrays).
Insertion sorts below 34; faster quicksort median below 16000; no parallelism below 1000 items.
type (int, int, int): total size 16.0 bytes of which value 16.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 42.546~0.021 ns/item; median 42.6; overhead: 18.4%
      ParallelQuickSort: mean 34.191~0.032 ns/item; median 32.7; overhead: 21.8%
              QuickSort: mean 22.023~0.017 ns/item; median 22.5; overhead: 29.2%
       TopDownMergeSort: mean 21.582~0.018 ns/item; median 21.9; overhead: 30.0%
      BottomUpMergeSort: mean 48.432~0.033 ns/item; median 47.7; overhead: 16.6%
     DualPivotQuickSort: mean 22.295~0.018 ns/item; median 22.8; overhead: 29.0%
    AltTopDownMergeSort: mean 22.058~0.019 ns/item; median 22.3; overhead: 29.5%

Sorting arrays of SampleClass with 128.0 elements by SampleClassOrder (average over 200000 benchmarked arrays).
Insertion sorts below 24; faster quicksort median below 10000; no parallelism below 1500 items.
type SampleClass: total size 32.0 bytes of which value 8.0 and heap size 24.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.1MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 37.993~0.021 ns/item; median 36.5; overhead: 16.3%
      ParallelQuickSort: mean 24.516~0.02 ns/item; median 24.0; overhead: 22.2%
              QuickSort: mean 24.436~0.019 ns/item; median 24.0; overhead: 22.2%
       TopDownMergeSort: mean 27.136~0.02 ns/item; median 27.2; overhead: 20.5%
      BottomUpMergeSort: mean 28.504~0.024 ns/item; median 27.4; overhead: 20.4%
     DualPivotQuickSort: mean 24.959~0.019 ns/item; median 24.5; overhead: 21.9%
    AltTopDownMergeSort: mean 26.615~0.02 ns/item; median 26.3; overhead: 20.8%

Sorting arrays of (int, long, DateTime, string, Guid) with 128.0 elements by BigTupleOrder (average over 200000 benchmarked arrays).
Insertion sorts below 11; faster quicksort median below 16000; no parallelism below 1000 items.
type (int, long, DateTime, string, Guid): total size 48.0 bytes of which value 48.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.1MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 143.15~0.048 ns/item; median 143.7; overhead: 17.5%
      ParallelQuickSort: mean 67.905~0.027 ns/item; median 68.2; overhead: 31.0%
              QuickSort: mean 67.869~0.027 ns/item; median 68.1; overhead: 31.0%
       TopDownMergeSort: mean 79.511~0.035 ns/item; median 78.4; overhead: 27.3%
      BottomUpMergeSort: mean 83.245~0.039 ns/item; median 83.0; overhead: 26.9%
     DualPivotQuickSort: mean 70.611~0.028 ns/item; median 70.9; overhead: 31.0%
    AltTopDownMergeSort: mean 76.369~0.032 ns/item; median 76.3; overhead: 28.1%

Sorting arrays of string with 128.0 elements by StringOrder (average over 200000 benchmarked arrays).
Insertion sorts below 18; faster quicksort median below 2000; no parallelism below 800 items.
type string: total size 56.0 bytes of which value 8.0 and heap size 48.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.1MB; mergesort scratch needs an extra 0.0MB.
        StringArraySort: mean 59.878~0.022 ns/item; median 59.1; overhead: 27.9%
      ParallelQuickSort: mean 56.997~0.024 ns/item; median 58.1; overhead: 27.8%
              QuickSort: mean 57.128~0.024 ns/item; median 58.1; overhead: 27.8%
       TopDownMergeSort: mean 55.784~0.025 ns/item; median 56.1; overhead: 28.5%
      BottomUpMergeSort: mean 57.173~0.024 ns/item; median 57.2; overhead: 28.3%
     DualPivotQuickSort: mean 58.061~0.024 ns/item; median 58.9; overhead: 27.6%
    AltTopDownMergeSort: mean 54.545~0.025 ns/item; median 54.9; overhead: 28.9%


Sorting arrays of int with 1023.3 elements by Int32Ordering (average over 171096 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type int: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.1MB; mergesort scratch needs an extra 0.0MB.
     PrimitiveArraySort: mean 28.551~0.024 ns/item; median 25.8; overhead: 10.5%
      ParallelQuickSort: mean 22.587~0.019 ns/item; median 20.9; overhead: 12.6%
              QuickSort: mean 22.537~0.02 ns/item; median 20.8; overhead: 12.6%
       TopDownMergeSort: mean 23.959~0.019 ns/item; median 22.4; overhead: 11.8%
      BottomUpMergeSort: mean 24.871~0.022 ns/item; median 23.4; overhead: 11.8%
     DualPivotQuickSort: mean 23.195~0.02 ns/item; median 21.5; overhead: 12.3%
    AltTopDownMergeSort: mean 24.624~0.02 ns/item; median 23.0; overhead: 11.6%

Sorting arrays of int with 1023.3 elements by ComparableOrdering<int> (average over 171096 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type int: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.1MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 44.779~0.033 ns/item; median 40.6; overhead: 9.0%
      ParallelQuickSort: mean 23.836~0.021 ns/item; median 22.0; overhead: 15.4%
              QuickSort: mean 23.835~0.021 ns/item; median 22.0; overhead: 15.4%
       TopDownMergeSort: mean 26.483~0.02 ns/item; median 24.5; overhead: 14.4%
      BottomUpMergeSort: mean 25.786~0.023 ns/item; median 23.9; overhead: 14.6%
     DualPivotQuickSort: mean 24.755~0.021 ns/item; median 23.0; overhead: 14.8%
    AltTopDownMergeSort: mean 25.56~0.022 ns/item; median 24.0; overhead: 14.5%

Sorting arrays of uint with 1023.3 elements by UInt32Ordering (average over 171096 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type uint: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.1MB; mergesort scratch needs an extra 0.0MB.
     PrimitiveArraySort: mean 29.75~0.025 ns/item; median 26.8; overhead: 10.2%
      ParallelQuickSort: mean 23.453~0.02 ns/item; median 21.6; overhead: 12.2%
              QuickSort: mean 23.353~0.019 ns/item; median 21.6; overhead: 12.2%
       TopDownMergeSort: mean 24.803~0.019 ns/item; median 23.1; overhead: 11.5%
      BottomUpMergeSort: mean 25.038~0.022 ns/item; median 23.3; overhead: 11.6%
     DualPivotQuickSort: mean 23.774~0.019 ns/item; median 22.0; overhead: 12.0%
    AltTopDownMergeSort: mean 24.808~0.02 ns/item; median 23.4; overhead: 11.6%

Sorting arrays of uint with 1023.3 elements by ComparableOrdering<uint> (average over 171096 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type uint: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.1MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 43.592~0.032 ns/item; median 39.5; overhead: 8.9%
      ParallelQuickSort: mean 23.975~0.021 ns/item; median 22.1; overhead: 14.9%
              QuickSort: mean 23.822~0.021 ns/item; median 22.0; overhead: 15.0%
       TopDownMergeSort: mean 24.917~0.02 ns/item; median 23.1; overhead: 14.4%
      BottomUpMergeSort: mean 25.266~0.024 ns/item; median 23.5; overhead: 14.5%
     DualPivotQuickSort: mean 24.637~0.02 ns/item; median 22.9; overhead: 14.4%
    AltTopDownMergeSort: mean 24.77~0.02  ns/item; median 23.3; overhead: 14.4%

Sorting arrays of ulong with 1023.3 elements by UInt64Ordering (average over 171096 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type ulong: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.1MB; mergesort scratch needs an extra 0.0MB.
     PrimitiveArraySort: mean 30.269~0.025 ns/item; median 27.3; overhead: 10.2%
      ParallelQuickSort: mean 23.3~0.021  ns/item; median 21.5; overhead: 12.5%
              QuickSort: mean 23.256~0.02 ns/item; median 21.5; overhead: 12.5%
       TopDownMergeSort: mean 25.082~0.022 ns/item; median 23.3; overhead: 11.6%
      BottomUpMergeSort: mean 25.375~0.022 ns/item; median 23.5; overhead: 11.8%
     DualPivotQuickSort: mean 23.496~0.02 ns/item; median 21.7; overhead: 12.4%
    AltTopDownMergeSort: mean 24.959~0.021 ns/item; median 23.6; overhead: 11.8%

Sorting arrays of ulong with 1023.3 elements by ComparableOrdering<ulong> (average over 171096 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type ulong: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.1MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 42.772~0.032 ns/item; median 38.6; overhead: 9.5%
      ParallelQuickSort: mean 23.338~0.02 ns/item; median 21.5; overhead: 15.9%
              QuickSort: mean 23.274~0.019 ns/item; median 21.5; overhead: 15.9%
       TopDownMergeSort: mean 24.491~0.019 ns/item; median 22.8; overhead: 15.1%
      BottomUpMergeSort: mean 25.312~0.024 ns/item; median 23.5; overhead: 15.0%
     DualPivotQuickSort: mean 24.006~0.019 ns/item; median 22.4; overhead: 15.4%
    AltTopDownMergeSort: mean 24.819~0.02 ns/item; median 23.2; overhead: 15.0%

Sorting arrays of double with 1023.3 elements by DoubleOrdering (average over 171096 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type double: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.1MB; mergesort scratch needs an extra 0.0MB.
     PrimitiveArraySort: mean 35.064~0.028 ns/item; median 31.6; overhead: 10.8%
      ParallelQuickSort: mean 25.643~0.021 ns/item; median 23.8; overhead: 13.9%
              QuickSort: mean 25.619~0.021 ns/item; median 23.8; overhead: 13.8%
       TopDownMergeSort: mean 27.126~0.021 ns/item; median 25.5; overhead: 13.0%
      BottomUpMergeSort: mean 28.248~0.024 ns/item; median 26.5; overhead: 13.0%
     DualPivotQuickSort: mean 25.871~0.021 ns/item; median 24.0; overhead: 13.4%
    AltTopDownMergeSort: mean 27.581~0.021 ns/item; median 25.9; overhead: 12.8%

Sorting arrays of double with 1023.3 elements by ComparableOrdering<double> (average over 171096 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type double: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.1MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 70.608~0.047 ns/item; median 64.4; overhead: 6.5%
      ParallelQuickSort: mean 46.962~0.033 ns/item; median 43.0; overhead: 9.4%
              QuickSort: mean 46.93~0.032 ns/item; median 43.0; overhead: 9.4%
       TopDownMergeSort: mean 48.811~0.032 ns/item; median 43.4; overhead: 9.1%
      BottomUpMergeSort: mean 46.965~0.033 ns/item; median 42.3; overhead: 9.5%
     DualPivotQuickSort: mean 47.415~0.032 ns/item; median 43.5; overhead: 9.4%
    AltTopDownMergeSort: mean 46.83~0.032 ns/item; median 42.5; overhead: 9.5%

Sorting arrays of float with 1023.3 elements by FloatOrdering (average over 171096 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type float: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.1MB; mergesort scratch needs an extra 0.0MB.
     PrimitiveArraySort: mean 34.701~0.029 ns/item; median 31.2; overhead: 9.7%
      ParallelQuickSort: mean 25.762~0.02 ns/item; median 23.9; overhead: 12.1%
              QuickSort: mean 25.725~0.02 ns/item; median 23.9; overhead: 12.0%
       TopDownMergeSort: mean 26.938~0.02 ns/item; median 25.3; overhead: 11.4%
      BottomUpMergeSort: mean 27.882~0.023 ns/item; median 26.3; overhead: 11.4%
     DualPivotQuickSort: mean 26.014~0.021 ns/item; median 24.2; overhead: 12.1%
    AltTopDownMergeSort: mean 27.435~0.021 ns/item; median 25.8; overhead: 11.3%

Sorting arrays of float with 1023.3 elements by ComparableOrdering<float> (average over 171096 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type float: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.1MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 72.206~0.047 ns/item; median 66.0; overhead: 5.8%
      ParallelQuickSort: mean 47.615~0.033 ns/item; median 43.7; overhead: 8.8%
              QuickSort: mean 47.551~0.033 ns/item; median 43.6; overhead: 8.8%
       TopDownMergeSort: mean 49.437~0.032 ns/item; median 43.9; overhead: 8.4%
      BottomUpMergeSort: mean 47.279~0.032 ns/item; median 42.7; overhead: 8.8%
     DualPivotQuickSort: mean 47.942~0.033 ns/item; median 44.0; overhead: 8.8%
    AltTopDownMergeSort: mean 47.341~0.032 ns/item; median 43.0; overhead: 8.9%

Sorting arrays of (int, int, int) with 1023.3 elements by SmallTupleOrder (average over 171096 benchmarked arrays).
Insertion sorts below 34; faster quicksort median below 16000; no parallelism below 1000 items.
type (int, int, int): total size 16.0 bytes of which value 16.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.3MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 67.706~0.05 ns/item; median 60.8; overhead: 12.6%
      ParallelQuickSort: mean 45.735~0.054 ns/item; median 38.6; overhead: 18.8%
              QuickSort: mean 39.887~0.028 ns/item; median 36.8; overhead: 19.7%
       TopDownMergeSort: mean 36.809~0.027 ns/item; median 34.2; overhead: 20.5%
      BottomUpMergeSort: mean 68.109~0.069 ns/item; median 64.4; overhead: 13.4%
     DualPivotQuickSort: mean 38.619~0.026 ns/item; median 35.9; overhead: 19.5%
    AltTopDownMergeSort: mean 38.126~0.029 ns/item; median 35.2; overhead: 20.5%

Sorting arrays of SampleClass with 1023.3 elements by SampleClassOrder (average over 171096 benchmarked arrays).
Insertion sorts below 24; faster quicksort median below 10000; no parallelism below 1500 items.
type SampleClass: total size 32.0 bytes of which value 8.0 and heap size 24.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.5MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 58.373~0.047 ns/item; median 51.9; overhead: 10.0%
      ParallelQuickSort: mean 38.988~0.032 ns/item; median 35.1; overhead: 13.9%
              QuickSort: mean 39.067~0.033 ns/item; median 35.1; overhead: 13.9%
       TopDownMergeSort: mean 45.076~0.034 ns/item; median 40.0; overhead: 12.2%
      BottomUpMergeSort: mean 46.066~0.038 ns/item; median 41.6; overhead: 11.9%
     DualPivotQuickSort: mean 40.953~0.032 ns/item; median 37.2; overhead: 13.2%
    AltTopDownMergeSort: mean 44.514~0.033 ns/item; median 39.6; overhead: 12.2%

Sorting arrays of (int, long, DateTime, string, Guid) with 1023.3 elements by BigTupleOrder (average over 171096 benchmarked arrays).
Insertion sorts below 11; faster quicksort median below 16000; no parallelism below 1000 items.
type (int, long, DateTime, string, Guid): total size 48.0 bytes of which value 48.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.8MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 228.35~0.16 ns/item; median 206.3; overhead: 13.2%
      ParallelQuickSort: mean 104.9~0.082 ns/item; median 94.5; overhead: 25.5%
              QuickSort: mean 109.63~0.082 ns/item; median 97.9; overhead: 25.1%
       TopDownMergeSort: mean 129.26~0.1  ns/item; median 120.4; overhead: 20.9%
      BottomUpMergeSort: mean 132.63~0.11 ns/item; median 117.1; overhead: 20.5%
     DualPivotQuickSort: mean 112.09~0.077 ns/item; median 101.6; overhead: 23.6%
    AltTopDownMergeSort: mean 129.78~0.098 ns/item; median 118.9; overhead: 21.3%

Sorting arrays of string with 1023.3 elements by StringOrder (average over 171096 benchmarked arrays).
Insertion sorts below 18; faster quicksort median below 2000; no parallelism below 800 items.
type string: total size 56.0 bytes of which value 8.0 and heap size 48.0.  
Per-sort working set on average 0.1MB (max upto twice that), overall benchmark ~0.9MB; mergesort scratch needs an extra 0.0MB.
        StringArraySort: mean 102.75~0.068 ns/item; median 93.8; overhead: 19.6%
      ParallelQuickSort: mean 93.108~0.089 ns/item; median 94.2; overhead: 23.5%
              QuickSort: mean 103.63~0.062 ns/item; median 95.7; overhead: 19.3%
       TopDownMergeSort: mean 98.71~0.058 ns/item; median 91.5; overhead: 19.9%
      BottomUpMergeSort: mean 99.068~0.059 ns/item; median 91.6; overhead: 19.9%
     DualPivotQuickSort: mean 102.58~0.062 ns/item; median 94.5; overhead: 19.4%
    AltTopDownMergeSort: mean 96.679~0.056 ns/item; median 91.0; overhead: 20.2%


Sorting arrays of int with 8228.3 elements by Int32Ordering (average over 19513 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type int: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.5MB; mergesort scratch needs an extra 0.0MB.
     PrimitiveArraySort: mean 40.02~0.13  ns/item; median 33.6; overhead: 7.9%
      ParallelQuickSort: mean 18.31~0.14  ns/item; median 10.2; overhead: 23.7%
              QuickSort: mean 33.197~0.1  ns/item; median 28.3; overhead: 9.2%
       TopDownMergeSort: mean 35.81~0.12  ns/item; median 30.9; overhead: 8.6%
      BottomUpMergeSort: mean 36.553~0.11 ns/item; median 30.4; overhead: 8.4%
     DualPivotQuickSort: mean 34.087~0.099 ns/item; median 29.2; overhead: 9.0%
    AltTopDownMergeSort: mean 36.224~0.11 ns/item; median 31.0; overhead: 8.6%

Sorting arrays of int with 8228.3 elements by ComparableOrdering<int> (average over 19513 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type int: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.5MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 63.6~0.21   ns/item; median 53.5; overhead: 6.8%
      ParallelQuickSort: mean 19.31~0.16  ns/item; median 10.5; overhead: 29.1%
              QuickSort: mean 36.054~0.11 ns/item; median 30.6; overhead: 11.7%
       TopDownMergeSort: mean 37.544~0.11 ns/item; median 32.2; overhead: 10.9%
      BottomUpMergeSort: mean 39.124~0.12 ns/item; median 32.8; overhead: 10.9%
     DualPivotQuickSort: mean 37.365~0.11 ns/item; median 32.1; overhead: 11.0%
    AltTopDownMergeSort: mean 37.525~0.11 ns/item; median 31.9; overhead: 10.9%

Sorting arrays of uint with 8228.3 elements by UInt32Ordering (average over 19513 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type uint: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.5MB; mergesort scratch needs an extra 0.0MB.
     PrimitiveArraySort: mean 41.28~0.14  ns/item; median 34.5; overhead: 7.7%
      ParallelQuickSort: mean 18.16~0.15  ns/item; median 9.9; overhead: 23.6%
              QuickSort: mean 33.966~0.11 ns/item; median 28.9; overhead: 9.1%
       TopDownMergeSort: mean 36.624~0.11 ns/item; median 31.5; overhead: 8.4%
      BottomUpMergeSort: mean 36.81~0.12  ns/item; median 30.9; overhead: 8.4%
     DualPivotQuickSort: mean 34.799~0.1  ns/item; median 29.8; overhead: 8.8%
    AltTopDownMergeSort: mean 36.694~0.11 ns/item; median 31.2; overhead: 8.4%

Sorting arrays of uint with 8228.3 elements by ComparableOrdering<uint> (average over 19513 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type uint: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.5MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 61.65~0.2   ns/item; median 51.8; overhead: 6.7%
      ParallelQuickSort: mean 18.22~0.15  ns/item; median 10.0; overhead: 28.3%
              QuickSort: mean 34.082~0.1  ns/item; median 29.0; overhead: 11.8%
       TopDownMergeSort: mean 36.7~0.12   ns/item; median 31.4; overhead: 10.7%
      BottomUpMergeSort: mean 36.85~0.12  ns/item; median 30.8; overhead: 10.7%
     DualPivotQuickSort: mean 38.152~0.11 ns/item; median 32.8; overhead: 10.6%
    AltTopDownMergeSort: mean 36.564~0.11 ns/item; median 31.1; overhead: 10.7%

Sorting arrays of ulong with 8228.3 elements by UInt64Ordering (average over 19513 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type ulong: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 0.1MB (max upto twice that), overall benchmark ~1.0MB; mergesort scratch needs an extra 0.1MB.
     PrimitiveArraySort: mean 41.53~0.14  ns/item; median 34.8; overhead: 7.9%
      ParallelQuickSort: mean 18.27~0.15  ns/item; median 10.0; overhead: 24.7%
              QuickSort: mean 33.789~0.1  ns/item; median 28.7; overhead: 9.4%
       TopDownMergeSort: mean 37.071~0.11 ns/item; median 32.3; overhead: 8.7%
      BottomUpMergeSort: mean 37.49~0.12  ns/item; median 31.5; overhead: 8.6%
     DualPivotQuickSort: mean 34.253~0.1  ns/item; median 29.2; overhead: 9.5%
    AltTopDownMergeSort: mean 37.12~0.12  ns/item; median 31.6; overhead: 8.7%

Sorting arrays of ulong with 8228.3 elements by ComparableOrdering<ulong> (average over 19513 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type ulong: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 0.1MB (max upto twice that), overall benchmark ~1.0MB; mergesort scratch needs an extra 0.1MB.
   IComparableArraySort: mean 60.06~0.2   ns/item; median 50.4; overhead: 7.2%
      ParallelQuickSort: mean 19.1~0.16   ns/item; median 10.5; overhead: 29.6%
              QuickSort: mean 33.989~0.1  ns/item; median 28.9; overhead: 12.1%
       TopDownMergeSort: mean 36.649~0.11 ns/item; median 31.6; overhead: 11.4%
      BottomUpMergeSort: mean 37.8~0.14   ns/item; median 31.5; overhead: 11.2%
     DualPivotQuickSort: mean 37.156~0.11 ns/item; median 31.9; overhead: 11.5%
    AltTopDownMergeSort: mean 37.04~0.12  ns/item; median 31.5; overhead: 11.4%

Sorting arrays of double with 8228.3 elements by DoubleOrdering (average over 19513 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type double: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 0.1MB (max upto twice that), overall benchmark ~1.0MB; mergesort scratch needs an extra 0.1MB.
     PrimitiveArraySort: mean 48.3~0.16   ns/item; median 40.4; overhead: 8.5%
      ParallelQuickSort: mean 20.86~0.17  ns/item; median 11.6; overhead: 25.8%
              QuickSort: mean 37.689~0.11 ns/item; median 32.2; overhead: 12.0%
       TopDownMergeSort: mean 40.911~0.13 ns/item; median 35.4; overhead: 9.6%
      BottomUpMergeSort: mean 42.25~0.15  ns/item; median 35.2; overhead: 9.4%
     DualPivotQuickSort: mean 38.202~0.12 ns/item; median 32.7; overhead: 10.0%
    AltTopDownMergeSort: mean 41.26~0.14  ns/item; median 35.3; overhead: 9.6%

Sorting arrays of double with 8228.3 elements by ComparableOrdering<double> (average over 19513 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type double: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 0.1MB (max upto twice that), overall benchmark ~1.0MB; mergesort scratch needs an extra 0.1MB.
   IComparableArraySort: mean 100.53~0.32 ns/item; median 84.9; overhead: 4.9%
      ParallelQuickSort: mean 34.87~0.3   ns/item; median 18.2; overhead: 20.7%
              QuickSort: mean 66.649~0.21 ns/item; median 56.2; overhead: 7.3%
       TopDownMergeSort: mean 70.9~0.23   ns/item; median 60.1; overhead: 6.8%
      BottomUpMergeSort: mean 68.37~0.22  ns/item; median 58.4; overhead: 7.1%
     DualPivotQuickSort: mean 67.754~0.21 ns/item; median 57.3; overhead: 7.2%
    AltTopDownMergeSort: mean 69.397~0.21 ns/item; median 58.0; overhead: 6.9%

Sorting arrays of float with 8228.3 elements by FloatOrdering (average over 19513 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type float: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.5MB; mergesort scratch needs an extra 0.0MB.
     PrimitiveArraySort: mean 47.71~0.16  ns/item; median 39.8; overhead: 7.4%
      ParallelQuickSort: mean 20.06~0.16  ns/item; median 11.1; overhead: 23.1%
              QuickSort: mean 37.927~0.11 ns/item; median 32.4; overhead: 8.8%
       TopDownMergeSort: mean 40.456~0.11 ns/item; median 35.0; overhead: 8.3%
      BottomUpMergeSort: mean 41.46~0.14  ns/item; median 34.6; overhead: 8.2%
     DualPivotQuickSort: mean 38.498~0.11 ns/item; median 33.0; overhead: 8.8%
    AltTopDownMergeSort: mean 40.784~0.12 ns/item; median 35.0; overhead: 8.3%

Sorting arrays of float with 8228.3 elements by ComparableOrdering<float> (average over 19513 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type float: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.5MB; mergesort scratch needs an extra 0.0MB.
   IComparableArraySort: mean 102.64~0.32 ns/item; median 86.8; overhead: 4.3%
      ParallelQuickSort: mean 34.13~0.29  ns/item; median 17.9; overhead: 19.0%
              QuickSort: mean 64.987~0.2  ns/item; median 54.9; overhead: 6.7%
       TopDownMergeSort: mean 68.659~0.21 ns/item; median 57.7; overhead: 6.3%
      BottomUpMergeSort: mean 65.911~0.2  ns/item; median 56.5; overhead: 6.6%
     DualPivotQuickSort: mean 66.102~0.2  ns/item; median 56.0; overhead: 6.6%
    AltTopDownMergeSort: mean 67.117~0.2  ns/item; median 56.2; overhead: 6.3%

Sorting arrays of (int, int, int) with 8228.3 elements by SmallTupleOrder (average over 19513 benchmarked arrays).
Insertion sorts below 34; faster quicksort median below 16000; no parallelism below 1000 items.
type (int, int, int): total size 16.0 bytes of which value 16.0 and heap size 0.0.  
Per-sort working set on average 0.1MB (max upto twice that), overall benchmark ~2.0MB; mergesort scratch needs an extra 0.1MB.
   IComparableArraySort: mean 93.34~0.31  ns/item; median 77.9; overhead: 10.1%
      ParallelQuickSort: mean 30.33~0.31  ns/item; median 14.8; overhead: 38.1%
              QuickSort: mean 57.05~0.18  ns/item; median 48.2; overhead: 15.8%
       TopDownMergeSort: mean 56.57~0.2   ns/item; median 47.8; overhead: 15.4%
      BottomUpMergeSort: mean 91.87~0.4   ns/item; median 69.5; overhead: 10.4%
     DualPivotQuickSort: mean 60.752~0.18 ns/item; median 52.0; overhead: 14.9%
    AltTopDownMergeSort: mean 56.846~0.18 ns/item; median 48.0; overhead: 15.3%

Sorting arrays of SampleClass with 8228.3 elements by SampleClassOrder (average over 19513 benchmarked arrays).
Insertion sorts below 24; faster quicksort median below 10000; no parallelism below 1500 items.
type SampleClass: total size 32.0 bytes of which value 8.0 and heap size 24.0.  
Per-sort working set on average 0.3MB (max upto twice that), overall benchmark ~4.0MB; mergesort scratch needs an extra 0.1MB.
   IComparableArraySort: mean 81.85~0.3   ns/item; median 68.0; overhead: 8.3%
      ParallelQuickSort: mean 32~0.27     ns/item; median 16.4; overhead: 28.6%
              QuickSort: mean 56.69~0.19  ns/item; median 47.3; overhead: 11.5%
       TopDownMergeSort: mean 66.23~0.22  ns/item; median 56.7; overhead: 10.1%
      BottomUpMergeSort: mean 67.92~0.23  ns/item; median 58.6; overhead: 9.9%
     DualPivotQuickSort: mean 59.39~0.2   ns/item; median 50.0; overhead: 11.0%
    AltTopDownMergeSort: mean 65.45~0.22  ns/item; median 56.4; overhead: 10.2%

Sorting arrays of (int, long, DateTime, string, Guid) with 8228.3 elements by BigTupleOrder (average over 19513 benchmarked arrays).
Insertion sorts below 11; faster quicksort median below 16000; no parallelism below 1000 items.
type (int, long, DateTime, string, Guid): total size 48.0 bytes of which value 48.0 and heap size 0.0.  
Per-sort working set on average 0.4MB (max upto twice that), overall benchmark ~6.0MB; mergesort scratch needs an extra 0.4MB.
   IComparableArraySort: mean 327.2~1.1   ns/item; median 273.7; overhead: 10.6%
      ParallelQuickSort: mean 69.72~0.67  ns/item; median 33.7; overhead: 48.9%
              QuickSort: mean 149.6~0.53  ns/item; median 123.8; overhead: 21.1%
       TopDownMergeSort: mean 187.8~1.1   ns/item; median 151.3; overhead: 17.3%
      BottomUpMergeSort: mean 187.5~0.72  ns/item; median 157.7; overhead: 17.4%
     DualPivotQuickSort: mean 161~0.52    ns/item; median 135.6; overhead: 19.6%
    AltTopDownMergeSort: mean 179.4~0.6   ns/item; median 148.3; overhead: 17.7%

Sorting arrays of string with 8228.3 elements by StringOrder (average over 19513 benchmarked arrays).
Insertion sorts below 18; faster quicksort median below 2000; no parallelism below 800 items.
type string: total size 56.0 bytes of which value 8.0 and heap size 48.0.  
Per-sort working set on average 0.4MB (max upto twice that), overall benchmark ~7.0MB; mergesort scratch needs an extra 0.1MB.
        StringArraySort: mean 151~0.48    ns/item; median 128.5; overhead: 18.2%
      ParallelQuickSort: mean 63.79~0.62  ns/item; median 31.4; overhead: 47.9%
              QuickSort: mean 152.56~0.45 ns/item; median 130.4; overhead: 17.9%
       TopDownMergeSort: mean 148.02~0.44 ns/item; median 128.6; overhead: 18.5%
      BottomUpMergeSort: mean 150.6~0.44  ns/item; median 130.0; overhead: 18.1%
     DualPivotQuickSort: mean 152.6~0.46  ns/item; median 130.3; overhead: 18.1%
    AltTopDownMergeSort: mean 145.69~0.42 ns/item; median 124.4; overhead: 18.7%


Sorting arrays of int with 64104.9 elements by Int32Ordering (average over 2207 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type int: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.3MB (max upto twice that), overall benchmark ~4.0MB; mergesort scratch needs an extra 0.3MB.
     PrimitiveArraySort: mean 50.62~0.6   ns/item; median 41.3; overhead: 6.6%
      ParallelQuickSort: mean 13.3~0.46   ns/item; median 8.1; overhead: 27.3%
              QuickSort: mean 43.44~0.49  ns/item; median 35.9; overhead: 7.5%
       TopDownMergeSort: mean 48.44~0.54  ns/item; median 39.9; overhead: 6.8%
      BottomUpMergeSort: mean 48.57~0.55  ns/item; median 41.1; overhead: 6.9%
     DualPivotQuickSort: mean 44.84~0.5   ns/item; median 37.0; overhead: 7.3%
    AltTopDownMergeSort: mean 49.01~0.54  ns/item; median 40.6; overhead: 6.8%

Sorting arrays of int with 64104.9 elements by ComparableOrdering<int> (average over 2207 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type int: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.3MB (max upto twice that), overall benchmark ~4.0MB; mergesort scratch needs an extra 0.3MB.
   IComparableArraySort: mean 81.58~0.97  ns/item; median 66.9; overhead: 5.6%
      ParallelQuickSort: mean 13.6~0.49   ns/item; median 8.2; overhead: 33.3%
              QuickSort: mean 44.79~0.51  ns/item; median 36.9; overhead: 9.7%
       TopDownMergeSort: mean 50.54~0.58  ns/item; median 41.6; overhead: 8.7%
      BottomUpMergeSort: mean 49.92~0.58  ns/item; median 41.6; overhead: 8.8%
     DualPivotQuickSort: mean 48.47~0.53  ns/item; median 40.1; overhead: 8.9%
    AltTopDownMergeSort: mean 50.18~0.56  ns/item; median 41.7; overhead: 8.7%

Sorting arrays of uint with 64104.9 elements by UInt32Ordering (average over 2207 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type uint: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.3MB (max upto twice that), overall benchmark ~4.0MB; mergesort scratch needs an extra 0.3MB.
     PrimitiveArraySort: mean 52.12~0.64  ns/item; median 42.4; overhead: 6.4%
      ParallelQuickSort: mean 13.3~0.48   ns/item; median 8.0; overhead: 27.4%
              QuickSort: mean 44.09~0.51  ns/item; median 36.3; overhead: 7.5%
       TopDownMergeSort: mean 49.3~0.56   ns/item; median 40.7; overhead: 6.7%
      BottomUpMergeSort: mean 48.96~0.57  ns/item; median 40.9; overhead: 6.8%
     DualPivotQuickSort: mean 45.58~0.51  ns/item; median 37.6; overhead: 7.2%
    AltTopDownMergeSort: mean 49.15~0.55  ns/item; median 40.8; overhead: 6.8%

Sorting arrays of uint with 64104.9 elements by ComparableOrdering<uint> (average over 2207 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type uint: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.3MB (max upto twice that), overall benchmark ~4.0MB; mergesort scratch needs an extra 0.3MB.
   IComparableArraySort: mean 78.68~0.93  ns/item; median 64.3; overhead: 5.6%
      ParallelQuickSort: mean 13.4~0.48   ns/item; median 8.1; overhead: 32.5%
              QuickSort: mean 44.17~0.51  ns/item; median 36.3; overhead: 9.5%
       TopDownMergeSort: mean 49.08~0.55  ns/item; median 40.6; overhead: 8.6%
      BottomUpMergeSort: mean 48.74~0.56  ns/item; median 40.8; overhead: 8.7%
     DualPivotQuickSort: mean 48.64~0.53  ns/item; median 40.3; overhead: 8.7%
    AltTopDownMergeSort: mean 49.01~0.54  ns/item; median 40.7; overhead: 8.6%

Sorting arrays of ulong with 64104.9 elements by UInt64Ordering (average over 2207 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type ulong: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 0.5MB (max upto twice that), overall benchmark ~8.0MB; mergesort scratch needs an extra 0.5MB.
     PrimitiveArraySort: mean 52.26~0.65  ns/item; median 42.5; overhead: 6.7%
      ParallelQuickSort: mean 13.3~0.48   ns/item; median 8.0; overhead: 28.7%
              QuickSort: mean 43.9~0.5    ns/item; median 36.1; overhead: 7.8%
       TopDownMergeSort: mean 50.02~0.57  ns/item; median 41.2; overhead: 7.1%
      BottomUpMergeSort: mean 49.4~0.59   ns/item; median 41.1; overhead: 7.3%
     DualPivotQuickSort: mean 44.65~0.51  ns/item; median 36.7; overhead: 7.7%
    AltTopDownMergeSort: mean 49.13~0.55  ns/item; median 40.7; overhead: 7.3%

Sorting arrays of ulong with 64104.9 elements by ComparableOrdering<ulong> (average over 2207 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type ulong: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 0.5MB (max upto twice that), overall benchmark ~8.0MB; mergesort scratch needs an extra 0.5MB.
   IComparableArraySort: mean 76.52~0.92  ns/item; median 62.5; overhead: 6.1%
      ParallelQuickSort: mean 13.5~0.47   ns/item; median 8.2; overhead: 33.9%
              QuickSort: mean 44.28~0.5   ns/item; median 36.4; overhead: 10.1%
       TopDownMergeSort: mean 48.95~0.56  ns/item; median 40.2; overhead: 9.4%
      BottomUpMergeSort: mean 48.77~0.59  ns/item; median 40.6; overhead: 9.5%
     DualPivotQuickSort: mean 47.11~0.52  ns/item; median 39.0; overhead: 9.5%
    AltTopDownMergeSort: mean 48.51~0.55  ns/item; median 39.9; overhead: 9.5%

Sorting arrays of double with 64104.9 elements by DoubleOrdering (average over 2207 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type double: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 0.5MB (max upto twice that), overall benchmark ~8.0MB; mergesort scratch needs an extra 0.5MB.
     PrimitiveArraySort: mean 60.68~0.76  ns/item; median 49.2; overhead: 7.3%
      ParallelQuickSort: mean 15~0.52     ns/item; median 9.2; overhead: 29.3%
              QuickSort: mean 49.4~0.55   ns/item; median 40.7; overhead: 9.0%
       TopDownMergeSort: mean 55.46~0.62  ns/item; median 45.7; overhead: 7.8%
      BottomUpMergeSort: mean 55.65~0.65  ns/item; median 46.7; overhead: 8.0%
     DualPivotQuickSort: mean 50.22~0.56  ns/item; median 41.4; overhead: 8.4%
    AltTopDownMergeSort: mean 55.19~0.61  ns/item; median 45.7; overhead: 8.0%

Sorting arrays of double with 64104.9 elements by ComparableOrdering<double> (average over 2207 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type double: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 0.5MB (max upto twice that), overall benchmark ~8.0MB; mergesort scratch needs an extra 0.5MB.
   IComparableArraySort: mean 129.4~1.5   ns/item; median 105.6; overhead: 4.1%
      ParallelQuickSort: mean 24.7~0.94   ns/item; median 14.9; overhead: 23.7%
              QuickSort: mean 85.13~1     ns/item; median 69.4; overhead: 6.1%
       TopDownMergeSort: mean 92.78~1.1   ns/item; median 77.6; overhead: 5.7%
      BottomUpMergeSort: mean 89.24~1     ns/item; median 72.5; overhead: 5.9%
     DualPivotQuickSort: mean 87.12~1     ns/item; median 71.3; overhead: 5.9%
    AltTopDownMergeSort: mean 89.54~1     ns/item; median 77.5; overhead: 5.9%

Sorting arrays of float with 64104.9 elements by FloatOrdering (average over 2207 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type float: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.3MB (max upto twice that), overall benchmark ~4.0MB; mergesort scratch needs an extra 0.3MB.
     PrimitiveArraySort: mean 59.83~0.75  ns/item; median 48.5; overhead: 6.2%
      ParallelQuickSort: mean 15~0.53     ns/item; median 9.3; overhead: 26.2%
              QuickSort: mean 49.62~0.56  ns/item; median 40.9; overhead: 7.2%
       TopDownMergeSort: mean 54.86~0.61  ns/item; median 45.3; overhead: 6.6%
      BottomUpMergeSort: mean 55.27~0.63  ns/item; median 46.6; overhead: 6.6%
     DualPivotQuickSort: mean 50.69~0.56  ns/item; median 41.9; overhead: 7.1%
    AltTopDownMergeSort: mean 55.24~0.6   ns/item; median 45.9; overhead: 6.5%

Sorting arrays of float with 64104.9 elements by ComparableOrdering<float> (average over 2207 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type float: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 0.3MB (max upto twice that), overall benchmark ~4.0MB; mergesort scratch needs an extra 0.3MB.
   IComparableArraySort: mean 132.3~1.6   ns/item; median 108.0; overhead: 3.5%
      ParallelQuickSort: mean 24.3~0.91   ns/item; median 14.7; overhead: 21.7%
              QuickSort: mean 83.2~0.99   ns/item; median 67.9; overhead: 5.5%
       TopDownMergeSort: mean 90.08~1     ns/item; median 76.2; overhead: 5.1%
      BottomUpMergeSort: mean 86.97~0.99  ns/item; median 71.1; overhead: 5.3%
     DualPivotQuickSort: mean 85.02~0.98  ns/item; median 69.8; overhead: 5.4%
    AltTopDownMergeSort: mean 87.76~1     ns/item; median 76.2; overhead: 5.3%

Sorting arrays of (int, int, int) with 64104.9 elements by SmallTupleOrder (average over 2207 benchmarked arrays).
Insertion sorts below 34; faster quicksort median below 16000; no parallelism below 1000 items.
type (int, int, int): total size 16.0 bytes of which value 16.0 and heap size 0.0.  
Per-sort working set on average 1.0MB (max upto twice that), overall benchmark ~16.0MB; mergesort scratch needs an extra 1.0MB.
   IComparableArraySort: mean 118.1~1.5   ns/item; median 96.0; overhead: 8.5%
      ParallelQuickSort: mean 21.1~0.88   ns/item; median 12.5; overhead: 42.5%
              QuickSort: mean 70.78~0.83  ns/item; median 58.0; overhead: 13.4%
       TopDownMergeSort: mean 76.03~0.94  ns/item; median 62.2; overhead: 12.8%
      BottomUpMergeSort: mean 111.5~1.7   ns/item; median 94.6; overhead: 9.6%
     DualPivotQuickSort: mean 76.25~0.88  ns/item; median 62.5; overhead: 12.6%
    AltTopDownMergeSort: mean 75.49~0.89  ns/item; median 62.0; overhead: 12.9%

Sorting arrays of SampleClass with 64104.9 elements by SampleClassOrder (average over 2207 benchmarked arrays).
Insertion sorts below 24; faster quicksort median below 10000; no parallelism below 1500 items.
type SampleClass: total size 32.0 bytes of which value 8.0 and heap size 24.0.  
Per-sort working set on average 2.0MB (max upto twice that), overall benchmark ~32.0MB; mergesort scratch needs an extra 0.5MB.
   IComparableArraySort: mean 111.9~1.3   ns/item; median 94.1; overhead: 7.8%
      ParallelQuickSort: mean 22.8~0.86   ns/item; median 13.6; overhead: 36.8%
              QuickSort: mean 76.42~0.85  ns/item; median 64.1; overhead: 10.8%
       TopDownMergeSort: mean 91.26~1.1   ns/item; median 75.1; overhead: 9.4%
      BottomUpMergeSort: mean 94.16~1.1   ns/item; median 77.2; overhead: 9.1%
     DualPivotQuickSort: mean 81.14~0.87  ns/item; median 68.2; overhead: 10.3%
    AltTopDownMergeSort: mean 89.75~0.99  ns/item; median 74.4; overhead: 9.4%

Sorting arrays of (int, long, DateTime, string, Guid) with 64104.9 elements by BigTupleOrder (average over 2207 benchmarked arrays).
Insertion sorts below 11; faster quicksort median below 16000; no parallelism below 1000 items.
type (int, long, DateTime, string, Guid): total size 48.0 bytes of which value 48.0 and heap size 0.0.  
Per-sort working set on average 3.0MB (max upto twice that), overall benchmark ~48.0MB; mergesort scratch needs an extra 3.0MB.
   IComparableArraySort: mean 408~4.9     ns/item; median 334.2; overhead: 9.4%
      ParallelQuickSort: mean 49.8~2.1    ns/item; median 29.7; overhead: 54.0%
              QuickSort: mean 182.8~2.3   ns/item; median 149.3; overhead: 18.8%
       TopDownMergeSort: mean 239.5~3.1   ns/item; median 198.2; overhead: 15.1%
      BottomUpMergeSort: mean 242.7~3.1   ns/item; median 195.5; overhead: 14.9%
     DualPivotQuickSort: mean 202~2.3     ns/item; median 166.9; overhead: 17.1%
    AltTopDownMergeSort: mean 231.1~2.7   ns/item; median 191.7; overhead: 15.5%

Sorting arrays of string with 64104.9 elements by StringOrder (average over 2207 benchmarked arrays).
Insertion sorts below 18; faster quicksort median below 2000; no parallelism below 800 items.
type string: total size 56.0 bytes of which value 8.0 and heap size 48.0.  
Per-sort working set on average 3.5MB (max upto twice that), overall benchmark ~56.0MB; mergesort scratch needs an extra 0.5MB.
        StringArraySort: mean 204.1~2.2   ns/item; median 169.8; overhead: 16.7%
      ParallelQuickSort: mean 49.1~2      ns/item; median 30.4; overhead: 53.0%
              QuickSort: mean 203.1~2.3   ns/item; median 168.1; overhead: 16.9%
       TopDownMergeSort: mean 207.9~2.5   ns/item; median 172.2; overhead: 16.5%
      BottomUpMergeSort: mean 213.1~2.8   ns/item; median 174.2; overhead: 16.3%
     DualPivotQuickSort: mean 203.1~2.3   ns/item; median 168.5; overhead: 16.9%
    AltTopDownMergeSort: mean 203.9~2.4   ns/item; median 172.3; overhead: 16.7%


Sorting arrays of int with 511394.4 elements by Int32Ordering (average over 254 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type int: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 2.0MB (max upto twice that), overall benchmark ~32.0MB; mergesort scratch needs an extra 2.0MB.
     PrimitiveArraySort: mean 61.4~2.5    ns/item; median 48.5; overhead: 5.8%
      ParallelQuickSort: mean 11.8~0.95   ns/item; median 8.3; overhead: 26.9%
              QuickSort: mean 53.7~2.2    ns/item; median 43.0; overhead: 6.5%
       TopDownMergeSort: mean 60.4~2.4    ns/item; median 48.4; overhead: 5.9%
      BottomUpMergeSort: mean 60.7~2.4    ns/item; median 47.8; overhead: 5.8%
     DualPivotQuickSort: mean 55.5~2.2    ns/item; median 44.3; overhead: 6.3%
    AltTopDownMergeSort: mean 60.9~2.4    ns/item; median 48.6; overhead: 5.8%

Sorting arrays of int with 511394.4 elements by ComparableOrdering<int> (average over 254 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type int: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 2.0MB (max upto twice that), overall benchmark ~32.0MB; mergesort scratch needs an extra 2.0MB.
   IComparableArraySort: mean 99.8~4      ns/item; median 79.8; overhead: 4.8%
      ParallelQuickSort: mean 11.9~0.97   ns/item; median 8.3; overhead: 32.7%
              QuickSort: mean 55.1~2.2    ns/item; median 44.1; overhead: 8.4%
       TopDownMergeSort: mean 62.4~2.5    ns/item; median 50.4; overhead: 7.5%
      BottomUpMergeSort: mean 61.8~2.4    ns/item; median 48.8; overhead: 7.6%
     DualPivotQuickSort: mean 60.3~2.4    ns/item; median 48.2; overhead: 7.7%
    AltTopDownMergeSort: mean 62.4~2.4    ns/item; median 49.9; overhead: 7.5%

Sorting arrays of uint with 511394.4 elements by UInt32Ordering (average over 254 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type uint: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 2.0MB (max upto twice that), overall benchmark ~32.0MB; mergesort scratch needs an extra 2.0MB.
     PrimitiveArraySort: mean 63~2.6      ns/item; median 49.7; overhead: 5.6%
      ParallelQuickSort: mean 11.7~0.96   ns/item; median 8.2; overhead: 27.1%
              QuickSort: mean 54.2~2.2    ns/item; median 43.4; overhead: 6.5%
       TopDownMergeSort: mean 61.3~2.5    ns/item; median 49.5; overhead: 5.8%
      BottomUpMergeSort: mean 60.9~2.4    ns/item; median 48.1; overhead: 5.8%
     DualPivotQuickSort: mean 56.3~2.2    ns/item; median 44.8; overhead: 6.2%
    AltTopDownMergeSort: mean 61.3~2.4    ns/item; median 48.7; overhead: 5.8%

Sorting arrays of uint with 511394.4 elements by ComparableOrdering<uint> (average over 254 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type uint: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 2.0MB (max upto twice that), overall benchmark ~32.0MB; mergesort scratch needs an extra 2.0MB.
   IComparableArraySort: mean 96~3.9      ns/item; median 76.6; overhead: 4.8%
      ParallelQuickSort: mean 11.7~0.94   ns/item; median 8.3; overhead: 32.1%
              QuickSort: mean 54.2~2.2    ns/item; median 43.4; overhead: 8.2%
       TopDownMergeSort: mean 61~2.4      ns/item; median 49.2; overhead: 7.4%
      BottomUpMergeSort: mean 60.7~2.4    ns/item; median 47.9; overhead: 7.4%
     DualPivotQuickSort: mean 60.5~2.3    ns/item; median 48.5; overhead: 7.4%
    AltTopDownMergeSort: mean 61.1~2.4    ns/item; median 48.8; overhead: 7.4%

Sorting arrays of ulong with 511394.4 elements by UInt64Ordering (average over 254 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type ulong: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 4.0MB (max upto twice that), overall benchmark ~64.0MB; mergesort scratch needs an extra 4.0MB.
     PrimitiveArraySort: mean 63~2.6      ns/item; median 49.8; overhead: 6.0%
      ParallelQuickSort: mean 11.6~0.94   ns/item; median 8.2; overhead: 28.6%
              QuickSort: mean 54~2.2      ns/item; median 43.2; overhead: 6.9%
       TopDownMergeSort: mean 62.1~2.4    ns/item; median 50.2; overhead: 6.2%
      BottomUpMergeSort: mean 64.1~2.9    ns/item; median 49.9; overhead: 6.1%
     DualPivotQuickSort: mean 55~2.2      ns/item; median 43.8; overhead: 6.8%
    AltTopDownMergeSort: mean 62.1~2.4    ns/item; median 49.7; overhead: 6.2%

Sorting arrays of ulong with 511394.4 elements by ComparableOrdering<ulong> (average over 254 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type ulong: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 4.0MB (max upto twice that), overall benchmark ~64.0MB; mergesort scratch needs an extra 4.0MB.
   IComparableArraySort: mean 93~3.8      ns/item; median 74.0; overhead: 5.4%
      ParallelQuickSort: mean 11.9~0.96   ns/item; median 8.4; overhead: 33.8%
              QuickSort: mean 54.5~2.2    ns/item; median 43.7; overhead: 8.8%
       TopDownMergeSort: mean 60.8~2.4    ns/item; median 48.9; overhead: 8.1%
      BottomUpMergeSort: mean 63.1~2.9    ns/item; median 49.3; overhead: 7.8%
     DualPivotQuickSort: mean 58.5~2.3    ns/item; median 46.7; overhead: 8.2%
    AltTopDownMergeSort: mean 61.1~2.4    ns/item; median 49.0; overhead: 8.0%

Sorting arrays of double with 511394.4 elements by DoubleOrdering (average over 254 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type double: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 4.0MB (max upto twice that), overall benchmark ~64.0MB; mergesort scratch needs an extra 4.0MB.
     PrimitiveArraySort: mean 72.9~3.1    ns/item; median 57.8; overhead: 6.4%
      ParallelQuickSort: mean 13.4~1      ns/item; median 9.5; overhead: 29.0%
              QuickSort: mean 61.1~2.4    ns/item; median 49.0; overhead: 7.5%
       TopDownMergeSort: mean 69.2~2.6    ns/item; median 55.8; overhead: 6.7%
      BottomUpMergeSort: mean 72.5~3.3    ns/item; median 55.9; overhead: 6.5%
     DualPivotQuickSort: mean 62.3~2.5    ns/item; median 49.5; overhead: 7.4%
    AltTopDownMergeSort: mean 69.6~2.7    ns/item; median 56.1; overhead: 6.7%

Sorting arrays of double with 511394.4 elements by ComparableOrdering<double> (average over 254 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type double: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 4.0MB (max upto twice that), overall benchmark ~64.0MB; mergesort scratch needs an extra 4.0MB.
   IComparableArraySort: mean 158~6.4     ns/item; median 126.5; overhead: 3.5%
      ParallelQuickSort: mean 21.8~1.7    ns/item; median 15.5; overhead: 23.1%
              QuickSort: mean 103~4.3     ns/item; median 82.4; overhead: 5.3%
       TopDownMergeSort: mean 113~4.5     ns/item; median 93.3; overhead: 4.9%
      BottomUpMergeSort: mean 112~4.9     ns/item; median 88.5; overhead: 5.1%
     DualPivotQuickSort: mean 106~4.4     ns/item; median 84.4; overhead: 5.2%
    AltTopDownMergeSort: mean 112~4.5     ns/item; median 88.7; overhead: 5.0%

Sorting arrays of float with 511394.4 elements by FloatOrdering (average over 254 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type float: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 2.0MB (max upto twice that), overall benchmark ~32.0MB; mergesort scratch needs an extra 2.0MB.
     PrimitiveArraySort: mean 71.9~3      ns/item; median 56.7; overhead: 5.4%
      ParallelQuickSort: mean 13.4~1      ns/item; median 9.5; overhead: 25.7%
              QuickSort: mean 61.4~2.4    ns/item; median 49.2; overhead: 6.2%
       TopDownMergeSort: mean 68.6~2.7    ns/item; median 55.2; overhead: 5.6%
      BottomUpMergeSort: mean 69.2~2.7    ns/item; median 54.7; overhead: 5.5%
     DualPivotQuickSort: mean 62.9~2.5    ns/item; median 50.1; overhead: 6.1%
    AltTopDownMergeSort: mean 68.9~2.7    ns/item; median 55.3; overhead: 5.6%

Sorting arrays of float with 511394.4 elements by ComparableOrdering<float> (average over 254 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type float: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 2.0MB (max upto twice that), overall benchmark ~32.0MB; mergesort scratch needs an extra 2.0MB.
   IComparableArraySort: mean 162~6.5     ns/item; median 129.5; overhead: 3.1%
      ParallelQuickSort: mean 21.5~1.7    ns/item; median 15.2; overhead: 21.4%
              QuickSort: mean 101~4.1     ns/item; median 81.1; overhead: 4.9%
       TopDownMergeSort: mean 111~4.4     ns/item; median 91.0; overhead: 4.5%
      BottomUpMergeSort: mean 107~4.2     ns/item; median 87.1; overhead: 4.6%
     DualPivotQuickSort: mean 104~4.2     ns/item; median 82.8; overhead: 4.8%
    AltTopDownMergeSort: mean 110~4.4     ns/item; median 86.4; overhead: 4.5%

Sorting arrays of (int, int, int) with 511394.4 elements by SmallTupleOrder (average over 254 benchmarked arrays).
Insertion sorts below 34; faster quicksort median below 16000; no parallelism below 1000 items.
type (int, int, int): total size 16.0 bytes of which value 16.0 and heap size 0.0.  
Per-sort working set on average 8.0MB (max upto twice that), overall benchmark ~128.0MB; mergesort scratch needs an extra 8.0MB.
   IComparableArraySort: mean 144~5.9     ns/item; median 114.2; overhead: 7.6%
      ParallelQuickSort: mean 18.3~1.4    ns/item; median 13.1; overhead: 41.9%
              QuickSort: mean 86.5~3.5    ns/item; median 69.0; overhead: 11.9%
       TopDownMergeSort: mean 93.5~3.7    ns/item; median 74.9; overhead: 11.2%
      BottomUpMergeSort: mean 134~6.5     ns/item; median 95.8; overhead: 8.3%
     DualPivotQuickSort: mean 93.2~3.8    ns/item; median 74.0; overhead: 11.2%
    AltTopDownMergeSort: mean 93.3~3.6    ns/item; median 74.5; overhead: 11.1%

Sorting arrays of SampleClass with 511394.4 elements by SampleClassOrder (average over 254 benchmarked arrays).
Insertion sorts below 24; faster quicksort median below 10000; no parallelism below 1500 items.
type SampleClass: total size 32.0 bytes of which value 8.0 and heap size 24.0.  
Per-sort working set on average 16.0MB (max upto twice that), overall benchmark ~256.0MB; mergesort scratch needs an extra 4.0MB.
   IComparableArraySort: mean 150~5.1     ns/item; median 123.3; overhead: 13.3%
      ParallelQuickSort: mean 23.9~2.5    ns/item; median 16.9; overhead: 51.0%
              QuickSort: mean 103~3.5     ns/item; median 85.2; overhead: 17.5%
       TopDownMergeSort: mean 123~4.3     ns/item; median 100.6; overhead: 15.6%
      BottomUpMergeSort: mean 135.2~3.9   ns/item; median 117.9; overhead: 13.6%
     DualPivotQuickSort: mean 111~3.8     ns/item; median 91.6; overhead: 16.7%
    AltTopDownMergeSort: mean 122~4.4     ns/item; median 99.9; overhead: 15.8%

Sorting arrays of (int, long, DateTime, string, Guid) with 511394.4 elements by BigTupleOrder (average over 254 benchmarked arrays).
Insertion sorts below 11; faster quicksort median below 16000; no parallelism below 1000 items.
type (int, long, DateTime, string, Guid): total size 48.0 bytes of which value 48.0 and heap size 0.0.  
Per-sort working set on average 24.0MB (max upto twice that), overall benchmark ~384.0MB; mergesort scratch needs an extra 24.0MB.
   IComparableArraySort: mean 501~20      ns/item; median 401.1; overhead: 7.8%
      ParallelQuickSort: mean 44.6~3.1    ns/item; median 32.9; overhead: 50.9%
              QuickSort: mean 224~9.1     ns/item; median 180.1; overhead: 15.9%
       TopDownMergeSort: mean 300~12      ns/item; median 234.4; overhead: 12.5%
      BottomUpMergeSort: mean 306~12      ns/item; median 251.2; overhead: 12.2%
     DualPivotQuickSort: mean 252~10      ns/item; median 201.8; overhead: 14.5%
    AltTopDownMergeSort: mean 303~14      ns/item; median 231.3; overhead: 12.6%

Sorting arrays of string with 511394.4 elements by StringOrder (average over 254 benchmarked arrays).
Insertion sorts below 18; faster quicksort median below 2000; no parallelism below 800 items.
type string: total size 56.0 bytes of which value 8.0 and heap size 48.0.  
Per-sort working set on average 28.0MB (max upto twice that), overall benchmark ~448.0MB; mergesort scratch needs an extra 4.0MB.
        StringArraySort: mean 284~9.1     ns/item; median 241.8; overhead: 25.3%
      ParallelQuickSort: mean 55.3~3.1    ns/item; median 45.6; overhead: 64.2%
              QuickSort: mean 279~9.2     ns/item; median 234.1; overhead: 25.8%
       TopDownMergeSort: mean 283~9.1     ns/item; median 239.2; overhead: 26.0%
      BottomUpMergeSort: mean 326.6~8.3   ns/item; median 304.3; overhead: 22.1%
     DualPivotQuickSort: mean 283~9.1     ns/item; median 241.5; overhead: 25.8%
    AltTopDownMergeSort: mean 281~8.9     ns/item; median 235.9; overhead: 26.1%


Sorting arrays of int with 3132355.8 elements by Int32Ordering (average over 34 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type int: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 16.0MB (max upto twice that), overall benchmark ~256.0MB; mergesort scratch needs an extra 16.0MB.
     PrimitiveArraySort: mean 67.7~4.7    ns/item; median 61.5; overhead: 5.3%
      ParallelQuickSort: mean 11.1~0.82   ns/item; median 10.2; overhead: 25.9%
              QuickSort: mean 60.3~4.2    ns/item; median 55.4; overhead: 5.8%
       TopDownMergeSort: mean 68~4.7      ns/item; median 62.0; overhead: 5.2%
      BottomUpMergeSort: mean 67.9~4.6    ns/item; median 62.1; overhead: 5.2%
     DualPivotQuickSort: mean 62.3~4.3    ns/item; median 56.9; overhead: 5.7%
    AltTopDownMergeSort: mean 68.8~4.7    ns/item; median 62.1; overhead: 5.2%

Sorting arrays of int with 3132355.8 elements by ComparableOrdering<int> (average over 34 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type int: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 16.0MB (max upto twice that), overall benchmark ~256.0MB; mergesort scratch needs an extra 16.0MB.
   IComparableArraySort: mean 111~7.7     ns/item; median 102.5; overhead: 4.3%
      ParallelQuickSort: mean 11.2~0.83   ns/item; median 10.4; overhead: 31.5%
              QuickSort: mean 61.5~4.3    ns/item; median 56.2; overhead: 7.5%
       TopDownMergeSort: mean 70.1~4.8    ns/item; median 63.5; overhead: 6.7%
      BottomUpMergeSort: mean 69.1~4.6    ns/item; median 63.1; overhead: 6.7%
     DualPivotQuickSort: mean 67.9~4.7    ns/item; median 61.5; overhead: 6.9%
    AltTopDownMergeSort: mean 70~4.8      ns/item; median 63.5; overhead: 6.7%

Sorting arrays of uint with 3132355.8 elements by UInt32Ordering (average over 34 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type uint: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 16.0MB (max upto twice that), overall benchmark ~256.0MB; mergesort scratch needs an extra 16.0MB.
     PrimitiveArraySort: mean 69.4~4.8    ns/item; median 63.1; overhead: 5.2%
      ParallelQuickSort: mean 11~0.8      ns/item; median 10.0; overhead: 26.0%
              QuickSort: mean 60.5~4.2    ns/item; median 55.5; overhead: 5.8%
       TopDownMergeSort: mean 68.6~4.7    ns/item; median 62.3; overhead: 5.2%
      BottomUpMergeSort: mean 68.3~4.6    ns/item; median 62.6; overhead: 5.2%
     DualPivotQuickSort: mean 62.9~4.3    ns/item; median 57.4; overhead: 5.6%
    AltTopDownMergeSort: mean 68.7~4.7    ns/item; median 62.3; overhead: 5.2%

Sorting arrays of uint with 3132355.8 elements by ComparableOrdering<uint> (average over 34 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type uint: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 16.0MB (max upto twice that), overall benchmark ~256.0MB; mergesort scratch needs an extra 16.0MB.
   IComparableArraySort: mean 106~7.4     ns/item; median 97.4; overhead: 4.3%
      ParallelQuickSort: mean 11~0.81     ns/item; median 10.0; overhead: 30.8%
              QuickSort: mean 60.3~4.2    ns/item; median 55.4; overhead: 7.3%
       TopDownMergeSort: mean 68.4~4.7    ns/item; median 62.2; overhead: 6.5%
      BottomUpMergeSort: mean 68~4.6      ns/item; median 62.4; overhead: 6.6%
     DualPivotQuickSort: mean 68.1~4.7    ns/item; median 61.8; overhead: 6.6%
    AltTopDownMergeSort: mean 68.6~4.7    ns/item; median 62.1; overhead: 6.5%

Sorting arrays of ulong with 3132355.8 elements by UInt64Ordering (average over 34 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type ulong: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 32.0MB (max upto twice that), overall benchmark ~512.0MB; mergesort scratch needs an extra 32.0MB.
     PrimitiveArraySort: mean 69.4~4.8    ns/item; median 63.3; overhead: 5.9%
      ParallelQuickSort: mean 11.1~0.8    ns/item; median 10.2; overhead: 28.0%
              QuickSort: mean 60.4~4.2    ns/item; median 55.6; overhead: 6.5%
       TopDownMergeSort: mean 70.1~4.8    ns/item; median 63.8; overhead: 5.7%
      BottomUpMergeSort: mean 70.6~4.7    ns/item; median 64.7; overhead: 5.7%
     DualPivotQuickSort: mean 61.5~4.2    ns/item; median 56.3; overhead: 6.5%
    AltTopDownMergeSort: mean 70~4.8      ns/item; median 63.6; overhead: 5.7%

Sorting arrays of ulong with 3132355.8 elements by ComparableOrdering<ulong> (average over 34 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type ulong: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 32.0MB (max upto twice that), overall benchmark ~512.0MB; mergesort scratch needs an extra 32.0MB.
   IComparableArraySort: mean 103~7.2     ns/item; median 94.3; overhead: 5.1%
      ParallelQuickSort: mean 11.3~0.82   ns/item; median 10.3; overhead: 33.1%
              QuickSort: mean 61~4.2      ns/item; median 56.0; overhead: 8.2%
       TopDownMergeSort: mean 68.6~4.7    ns/item; median 62.7; overhead: 7.3%
      BottomUpMergeSort: mean 69.5~4.6    ns/item; median 63.6; overhead: 7.2%
     DualPivotQuickSort: mean 65.9~4.5    ns/item; median 60.2; overhead: 7.6%
    AltTopDownMergeSort: mean 69.1~4.7    ns/item; median 62.6; overhead: 7.2%

Sorting arrays of double with 3132355.8 elements by DoubleOrdering (average over 34 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type double: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 32.0MB (max upto twice that), overall benchmark ~512.0MB; mergesort scratch needs an extra 32.0MB.
     PrimitiveArraySort: mean 80.1~5.6    ns/item; median 72.8; overhead: 6.0%
      ParallelQuickSort: mean 12.8~0.94   ns/item; median 12.0; overhead: 28.6%
              QuickSort: mean 68.6~4.7    ns/item; median 63.1; overhead: 6.9%
       TopDownMergeSort: mean 78.5~5.4    ns/item; median 71.7; overhead: 6.1%
      BottomUpMergeSort: mean 79.9~5.3    ns/item; median 73.0; overhead: 6.0%
     DualPivotQuickSort: mean 69.9~4.8    ns/item; median 64.0; overhead: 6.8%
    AltTopDownMergeSort: mean 79.1~5.4    ns/item; median 71.6; overhead: 6.1%

Sorting arrays of double with 3132355.8 elements by ComparableOrdering<double> (average over 34 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type double: total size 8.0 bytes of which value 8.0 and heap size 0.0.  
Per-sort working set on average 32.0MB (max upto twice that), overall benchmark ~512.0MB; mergesort scratch needs an extra 32.0MB.
   IComparableArraySort: mean 176~12      ns/item; median 161.4; overhead: 3.3%
      ParallelQuickSort: mean 20.8~1.5    ns/item; median 19.1; overhead: 22.6%
              QuickSort: mean 114~8       ns/item; median 105.0; overhead: 4.9%
       TopDownMergeSort: mean 126~8.8     ns/item; median 112.9; overhead: 4.5%
      BottomUpMergeSort: mean 124~8.5     ns/item; median 113.5; overhead: 4.6%
     DualPivotQuickSort: mean 118~8.2     ns/item; median 108.2; overhead: 4.8%
    AltTopDownMergeSort: mean 123~8.5     ns/item; median 112.6; overhead: 4.6%

Sorting arrays of float with 3132355.8 elements by FloatOrdering (average over 34 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type float: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 16.0MB (max upto twice that), overall benchmark ~256.0MB; mergesort scratch needs an extra 16.0MB.
     PrimitiveArraySort: mean 78.8~5.5    ns/item; median 71.8; overhead: 5.0%
      ParallelQuickSort: mean 12.7~0.94   ns/item; median 11.8; overhead: 24.7%
              QuickSort: mean 68.7~4.7    ns/item; median 63.2; overhead: 5.6%
       TopDownMergeSort: mean 77.3~5.3    ns/item; median 70.5; overhead: 5.0%
      BottomUpMergeSort: mean 77.6~5.2    ns/item; median 70.9; overhead: 5.0%
     DualPivotQuickSort: mean 70.4~4.8    ns/item; median 64.3; overhead: 5.5%
    AltTopDownMergeSort: mean 77.9~5.3    ns/item; median 70.5; overhead: 5.0%

Sorting arrays of float with 3132355.8 elements by ComparableOrdering<float> (average over 34 benchmarked arrays).
Insertion sorts below 64; faster quicksort median below 13000; no parallelism below 1100 items.
type float: total size 4.0 bytes of which value 4.0 and heap size 0.0.  
Per-sort working set on average 16.0MB (max upto twice that), overall benchmark ~256.0MB; mergesort scratch needs an extra 16.0MB.
   IComparableArraySort: mean 180~12      ns/item; median 165.3; overhead: 3.2%
      ParallelQuickSort: mean 20.5~1.5    ns/item; median 19.1; overhead: 22.6%
              QuickSort: mean 112~7.8     ns/item; median 102.9; overhead: 4.9%
       TopDownMergeSort: mean 123~8.5     ns/item; median 110.9; overhead: 4.5%
      BottomUpMergeSort: mean 121~8.3     ns/item; median 111.4; overhead: 4.6%
     DualPivotQuickSort: mean 116~8       ns/item; median 106.0; overhead: 4.8%
    AltTopDownMergeSort: mean 126~8.8     ns/item; median 115.9; overhead: 4.7%

Sorting arrays of (int, int, int) with 3132355.8 elements by SmallTupleOrder (average over 34 benchmarked arrays).
Insertion sorts below 34; faster quicksort median below 16000; no parallelism below 1000 items.
type (int, int, int): total size 16.0 bytes of which value 16.0 and heap size 0.0.  
Per-sort working set on average 64.0MB (max upto twice that), overall benchmark ~1024.0MB; mergesort scratch needs an extra 64.0MB.
   IComparableArraySort: mean 158~11      ns/item; median 144.0; overhead: 7.1%
      ParallelQuickSort: mean 17.3~1.2    ns/item; median 16.1; overhead: 41.0%
              QuickSort: mean 93~6.4      ns/item; median 85.5; overhead: 11.2%
       TopDownMergeSort: mean 102~7.1     ns/item; median 94.7; overhead: 10.4%
      BottomUpMergeSort: mean 136~9.4     ns/item; median 123.8; overhead: 8.1%
     DualPivotQuickSort: mean 100~6.9     ns/item; median 91.3; overhead: 10.5%
    AltTopDownMergeSort: mean 103~6.8     ns/item; median 96.9; overhead: 10.1%

Sorting arrays of SampleClass with 3132355.8 elements by SampleClassOrder (average over 34 benchmarked arrays).
Insertion sorts below 24; faster quicksort median below 10000; no parallelism below 1500 items.
type SampleClass: total size 32.0 bytes of which value 8.0 and heap size 24.0.  
Per-sort working set on average 128.0MB (max upto twice that), overall benchmark ~2048.0MB; mergesort scratch needs an extra 32.0MB.
   IComparableArraySort: mean 204~9.5     ns/item; median 196.3; overhead: 15.2%
      ParallelQuickSort: mean 33.12~1     ns/item; median 33.7; overhead: 45.5%
              QuickSort: mean 141~6.7     ns/item; median 135.9; overhead: 17.4%
       TopDownMergeSort: mean 160~8.3     ns/item; median 152.2; overhead: 16.0%
      BottomUpMergeSort: mean 192~9.7     ns/item; median 183.7; overhead: 13.7%
     DualPivotQuickSort: mean 150~7.2     ns/item; median 143.4; overhead: 16.7%
    AltTopDownMergeSort: mean 158~8.2     ns/item; median 150.2; overhead: 16.1%

Sorting arrays of (int, long, DateTime, string, Guid) with 3132355.8 elements by BigTupleOrder (average over 34 benchmarked arrays).
Insertion sorts below 11; faster quicksort median below 16000; no parallelism below 1000 items.
type (int, long, DateTime, string, Guid): total size 48.0 bytes of which value 48.0 and heap size 0.0.  
Per-sort working set on average 192.0MB (max upto twice that), overall benchmark ~3072.0MB; mergesort scratch needs an extra 192.0MB.
   IComparableArraySort: mean 548~38      ns/item; median 503.7; overhead: 6.9%
      ParallelQuickSort: mean 44.5~3.2    ns/item; median 41.2; overhead: 47.8%
              QuickSort: mean 245~17      ns/item; median 223.0; overhead: 14.2%
       TopDownMergeSort: mean 328~23      ns/item; median 295.4; overhead: 11.0%
      BottomUpMergeSort: mean 339~24      ns/item; median 329.0; overhead: 10.6%
     DualPivotQuickSort: mean 278~19      ns/item; median 250.8; overhead: 12.7%
    AltTopDownMergeSort: mean 323~22      ns/item; median 294.2; overhead: 11.1%

Sorting arrays of string with 3132355.8 elements by StringOrder (average over 34 benchmarked arrays).
Insertion sorts below 18; faster quicksort median below 2000; no parallelism below 800 items.
type string: total size 56.0 bytes of which value 8.0 and heap size 48.0.  
Per-sort working set on average 224.0MB (max upto twice that), overall benchmark ~3584.0MB; mergesort scratch needs an extra 32.0MB.
        StringArraySort: mean 384~20      ns/item; median 364.8; overhead: 24.1%
      ParallelQuickSort: mean 78.3~3.4    ns/item; median 76.5; overhead: 60.2%
              QuickSort: mean 370~20      ns/item; median 349.6; overhead: 25.0%
       TopDownMergeSort: mean 381~20      ns/item; median 360.8; overhead: 24.6%
      BottomUpMergeSort: mean 457~26      ns/item; median 430.2; overhead: 21.5%
     DualPivotQuickSort: mean 383~20      ns/item; median 368.7; overhead: 24.3%
    AltTopDownMergeSort: mean 374~19      ns/item; median 355.3; overhead: 24.7%


int/Int32Ordering using PrimitiveArraySort: 39.6ns/item
int/Int32Ordering using ParallelQuickSort: 13.9ns/item
int/Int32Ordering using QuickSort: 33.3ns/item
int/Int32Ordering using TopDownMergeSort: 36.8ns/item
int/Int32Ordering using BottomUpMergeSort: 37.5ns/item
int/Int32Ordering using DualPivotQuickSort: 34.3ns/item
int/Int32Ordering using AltTopDownMergeSort: 37.2ns/item
int/ComparableOrdering<int> using IComparableArraySort: 64.1ns/item
int/ComparableOrdering<int> using ParallelQuickSort: 14.7ns/item
int/ComparableOrdering<int> using QuickSort: 34.9ns/item
int/ComparableOrdering<int> using TopDownMergeSort: 38.6ns/item
int/ComparableOrdering<int> using BottomUpMergeSort: 38.7ns/item
int/ComparableOrdering<int> using DualPivotQuickSort: 37.3ns/item
int/ComparableOrdering<int> using AltTopDownMergeSort: 38.4ns/item
uint/UInt32Ordering using PrimitiveArraySort: 40.9ns/item
uint/UInt32Ordering using ParallelQuickSort: 14.2ns/item
uint/UInt32Ordering using QuickSort: 33.9ns/item
uint/UInt32Ordering using TopDownMergeSort: 37.5ns/item
uint/UInt32Ordering using BottomUpMergeSort: 37.7ns/item
uint/UInt32Ordering using DualPivotQuickSort: 35.0ns/item
uint/UInt32Ordering using AltTopDownMergeSort: 37.5ns/item
uint/ComparableOrdering<uint> using IComparableArraySort: 61.8ns/item
uint/ComparableOrdering<uint> using ParallelQuickSort: 14.3ns/item
uint/ComparableOrdering<uint> using QuickSort: 34.0ns/item
uint/ComparableOrdering<uint> using TopDownMergeSort: 37.4ns/item
uint/ComparableOrdering<uint> using BottomUpMergeSort: 37.9ns/item
uint/ComparableOrdering<uint> using DualPivotQuickSort: 37.5ns/item
uint/ComparableOrdering<uint> using AltTopDownMergeSort: 37.5ns/item
ulong/UInt64Ordering using PrimitiveArraySort: 41.2ns/item
ulong/UInt64Ordering using ParallelQuickSort: 14.1ns/item
ulong/UInt64Ordering using QuickSort: 33.8ns/item
ulong/UInt64Ordering using TopDownMergeSort: 38.0ns/item
ulong/UInt64Ordering using BottomUpMergeSort: 38.7ns/item
ulong/UInt64Ordering using DualPivotQuickSort: 34.3ns/item
ulong/UInt64Ordering using AltTopDownMergeSort: 37.9ns/item
ulong/ComparableOrdering<ulong> using IComparableArraySort: 60.3ns/item
ulong/ComparableOrdering<ulong> using ParallelQuickSort: 14.4ns/item
ulong/ComparableOrdering<ulong> using QuickSort: 34.1ns/item
ulong/ComparableOrdering<ulong> using TopDownMergeSort: 37.3ns/item
ulong/ComparableOrdering<ulong> using BottomUpMergeSort: 38.5ns/item
ulong/ComparableOrdering<ulong> using DualPivotQuickSort: 36.3ns/item
ulong/ComparableOrdering<ulong> using AltTopDownMergeSort: 37.5ns/item
double/DoubleOrdering using PrimitiveArraySort: 47.7ns/item
double/DoubleOrdering using ParallelQuickSort: 15.8ns/item
double/DoubleOrdering using QuickSort: 37.9ns/item
double/DoubleOrdering using TopDownMergeSort: 42.0ns/item
double/DoubleOrdering using BottomUpMergeSort: 43.6ns/item
double/DoubleOrdering using DualPivotQuickSort: 38.5ns/item
double/DoubleOrdering using AltTopDownMergeSort: 42.3ns/item
double/ComparableOrdering<double> using IComparableArraySort: 101.1ns/item
double/ComparableOrdering<double> using ParallelQuickSort: 27.7ns/item
double/ComparableOrdering<double> using QuickSort: 65.9ns/item
double/ComparableOrdering<double> using TopDownMergeSort: 71.0ns/item
double/ComparableOrdering<double> using BottomUpMergeSort: 69.3ns/item
double/ComparableOrdering<double> using DualPivotQuickSort: 67.3ns/item
double/ComparableOrdering<double> using AltTopDownMergeSort: 69.3ns/item
float/FloatOrdering using PrimitiveArraySort: 47.1ns/item
float/FloatOrdering using ParallelQuickSort: 15.7ns/item
float/FloatOrdering using QuickSort: 38.0ns/item
float/FloatOrdering using TopDownMergeSort: 41.6ns/item
float/FloatOrdering using BottomUpMergeSort: 42.5ns/item
float/FloatOrdering using DualPivotQuickSort: 38.8ns/item
float/FloatOrdering using AltTopDownMergeSort: 41.9ns/item
float/ComparableOrdering<float> using IComparableArraySort: 103.2ns/item
float/ComparableOrdering<float> using ParallelQuickSort: 27.3ns/item
float/ComparableOrdering<float> using QuickSort: 64.7ns/item
float/ComparableOrdering<float> using TopDownMergeSort: 69.4ns/item
float/ComparableOrdering<float> using BottomUpMergeSort: 67.3ns/item
float/ComparableOrdering<float> using DualPivotQuickSort: 66.0ns/item
float/ComparableOrdering<float> using AltTopDownMergeSort: 68.6ns/item
(int, int, int)/SmallTupleOrder using IComparableArraySort: 93.1ns/item
(int, int, int)/SmallTupleOrder using ParallelQuickSort: 26.8ns/item
(int, int, int)/SmallTupleOrder using QuickSort: 54.6ns/item
(int, int, int)/SmallTupleOrder using TopDownMergeSort: 57.0ns/item
(int, int, int)/SmallTupleOrder using BottomUpMergeSort: 89.2ns/item
(int, int, int)/SmallTupleOrder using DualPivotQuickSort: 57.8ns/item
(int, int, int)/SmallTupleOrder using AltTopDownMergeSort: 57.4ns/item
SampleClass/SampleClassOrder using IComparableArraySort: 96.3ns/item
SampleClass/SampleClassOrder using ParallelQuickSort: 27.5ns/item
SampleClass/SampleClassOrder using QuickSort: 65.4ns/item
SampleClass/SampleClassOrder using TopDownMergeSort: 75.9ns/item
SampleClass/SampleClassOrder using BottomUpMergeSort: 83.5ns/item
SampleClass/SampleClassOrder using DualPivotQuickSort: 69.3ns/item
SampleClass/SampleClassOrder using AltTopDownMergeSort: 75.0ns/item
(int, long, DateTime, string, Guid)/BigTupleOrder using IComparableArraySort: 322.3ns/item
(int, long, DateTime, string, Guid)/BigTupleOrder using ParallelQuickSort: 61.3ns/item
(int, long, DateTime, string, Guid)/BigTupleOrder using QuickSort: 146.6ns/item
(int, long, DateTime, string, Guid)/BigTupleOrder using TopDownMergeSort: 188.2ns/item
(int, long, DateTime, string, Guid)/BigTupleOrder using BottomUpMergeSort: 192.7ns/item
(int, long, DateTime, string, Guid)/BigTupleOrder using DualPivotQuickSort: 160.4ns/item
(int, long, DateTime, string, Guid)/BigTupleOrder using AltTopDownMergeSort: 184.8ns/item
string/StringOrder using StringArraySort: 175.4ns/item
string/StringOrder using ParallelQuickSort: 61.7ns/item
string/StringOrder using QuickSort: 171.5ns/item
string/StringOrder using TopDownMergeSort: 172.7ns/item
string/StringOrder using BottomUpMergeSort: 191.7ns/item
string/StringOrder using DualPivotQuickSort: 174.1ns/item
string/StringOrder using AltTopDownMergeSort: 170.0ns/item

int/Int32Ordering: 33.2ns/item
int/ComparableOrdering<int>: 38.1ns/item
uint/UInt32Ordering: 33.8ns/item
uint/ComparableOrdering<uint>: 37.2ns/item
ulong/UInt64Ordering: 34.0ns/item
ulong/ComparableOrdering<ulong>: 36.9ns/item
double/DoubleOrdering: 38.2ns/item
double/ComparableOrdering<double>: 67.4ns/item
float/FloatOrdering: 37.9ns/item
float/ComparableOrdering<float>: 66.7ns/item
(int, int, int)/SmallTupleOrder: 62.3ns/item
SampleClass/SampleClassOrder: 70.4ns/item
(int, long, DateTime, string, Guid)/BigTupleOrder: 179.5ns/item
string/StringOrder: 159.6ns/item

OVERALL: 63.9ns/item