results-1.0-netcore2.2.txt

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


Sorting arrays of int with 32.0 elements by Int32Order (average over 2520142 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.
    ArraySort_Primitive: mean 11.874~0.006 ns/item; median 12.4; overhead: 46.5%
      ParallelQuickSort: mean 9.1541~0.0077 ns/item; median 7.6; overhead: 52.2%
              QuickSort: mean 8.0229~0.006 ns/item; median 7.6; overhead: 56.4%
       TopDownMergeSort: mean 8.0427~0.006 ns/item; median 7.6; overhead: 56.8%
      BottomUpMergeSort: mean 11.831~0.0079 ns/item; median 10.9; overhead: 48.5%
     DualPivotQuickSort: mean 8.131~0.006 ns/item; median 7.6; overhead: 56.2%
    AltTopDownMergeSort: mean 8.0893~0.0061 ns/item; median 7.6; overhead: 57.1%

Sorting arrays of uint with 32.0 elements by UInt32Order (average over 2520142 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.
    ArraySort_Primitive: mean 12.716~0.0059 ns/item; median 13.3; overhead: 43.8%
      ParallelQuickSort: mean 10.006~0.021 ns/item; median 8.3; overhead: 49.5%
              QuickSort: mean 8.4034~0.006 ns/item; median 7.9; overhead: 54.4%
       TopDownMergeSort: mean 8.5702~0.0061 ns/item; median 8.1; overhead: 54.6%
      BottomUpMergeSort: mean 12.596~0.0088 ns/item; median 11.3; overhead: 47.4%
     DualPivotQuickSort: mean 8.4759~0.0061 ns/item; median 8.1; overhead: 54.4%
    AltTopDownMergeSort: mean 8.6214~0.0062 ns/item; median 8.3; overhead: 54.4%

Sorting arrays of ulong with 32.0 elements by UInt64Order (average over 2520142 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.
    ArraySort_Primitive: mean 12.49~0.0059 ns/item; median 13.2; overhead: 44.4%
      ParallelQuickSort: mean 9.6185~0.0079 ns/item; median 7.9; overhead: 50.1%
              QuickSort: mean 8.1435~0.0057 ns/item; median 7.9; overhead: 55.1%
       TopDownMergeSort: mean 8.2452~0.0059 ns/item; median 7.9; overhead: 55.3%
      BottomUpMergeSort: mean 11.712~0.0081 ns/item; median 10.7; overhead: 48.1%
     DualPivotQuickSort: mean 8.265~0.0058 ns/item; median 7.9; overhead: 54.8%
    AltTopDownMergeSort: mean 8.2765~0.006 ns/item; median 7.9; overhead: 55.1%

Sorting arrays of double with 32.0 elements by DoubleOrdering (average over 2520142 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 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.
    ArraySort_Primitive: mean 15.21~0.0073 ns/item; median 16.2; overhead: 41.0%
      ParallelQuickSort: mean 9.8973~0.0079 ns/item; median 8.3; overhead: 51.0%
              QuickSort: mean 8.4518~0.0057 ns/item; median 8.3; overhead: 55.6%
       TopDownMergeSort: mean 8.5102~0.0059 ns/item; median 8.3; overhead: 55.7%
      BottomUpMergeSort: mean 12.92~0.029 ns/item; median 11.9; overhead: 46.9%
     DualPivotQuickSort: mean 8.5354~0.0058 ns/item; median 8.3; overhead: 55.5%
    AltTopDownMergeSort: mean 8.5238~0.0059 ns/item; median 8.3; overhead: 55.7%

Sorting arrays of int with 32.0 elements by ComparableOrdering<int> (average over 2520142 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.
ArraySort_OrderComparer: mean 19.527~0.0083 ns/item; median 19.3; overhead: 35.3%
      ParallelQuickSort: mean 9.8897~0.0078 ns/item; median 8.3; overhead: 50.7%
              QuickSort: mean 8.5141~0.006 ns/item; median 8.1; overhead: 55.4%
       TopDownMergeSort: mean 8.5324~0.0059 ns/item; median 8.3; overhead: 55.6%
      BottomUpMergeSort: mean 11.996~0.008 ns/item; median 11.1; overhead: 48.6%
     DualPivotQuickSort: mean 8.5901~0.006 ns/item; median 8.3; overhead: 55.2%
    AltTopDownMergeSort: mean 8.5844~0.006 ns/item; median 8.3; overhead: 55.6%

Sorting arrays of uint with 32.0 elements by ComparableOrdering<uint> (average over 2520142 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.
ArraySort_OrderComparer: mean 20.515~0.0088 ns/item; median 20.7; overhead: 33.2%
      ParallelQuickSort: mean 10.065~0.0079 ns/item; median 8.7; overhead: 49.0%
              QuickSort: mean 8.7234~0.0058 ns/item; median 8.7; overhead: 53.5%
       TopDownMergeSort: mean 8.7717~0.0058 ns/item; median 8.7; overhead: 53.6%
      BottomUpMergeSort: mean 12.088~0.0076 ns/item; median 11.2; overhead: 47.5%
     DualPivotQuickSort: mean 8.8597~0.022 ns/item; median 8.7; overhead: 53.2%
    AltTopDownMergeSort: mean 8.872~0.0058 ns/item; median 8.7; overhead: 53.2%

Sorting arrays of ulong with 32.0 elements by ComparableOrdering<ulong> (average over 2520142 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.
ArraySort_OrderComparer: mean 20.358~0.0083 ns/item; median 20.6; overhead: 33.9%
      ParallelQuickSort: mean 9.7136~0.0076 ns/item; median 8.1; overhead: 51.2%
              QuickSort: mean 8.2653~0.0058 ns/item; median 7.9; overhead: 56.0%
       TopDownMergeSort: mean 8.3457~0.0058 ns/item; median 7.9; overhead: 56.3%
      BottomUpMergeSort: mean 12.177~0.011 ns/item; median 11.2; overhead: 48.2%
     DualPivotQuickSort: mean 8.3478~0.0058 ns/item; median 7.9; overhead: 55.9%
    AltTopDownMergeSort: mean 8.4261~0.0059 ns/item; median 7.9; overhead: 56.0%

Sorting arrays of double with 32.0 elements by ComparableOrdering<double> (average over 2520142 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.
ArraySort_OrderComparer: mean 28.8905~0.0085 ns/item; median 31.2; overhead: 27.4%
      ParallelQuickSort: mean 18.442~0.0082 ns/item; median 19.8; overhead: 35.1%
              QuickSort: mean 17.423~0.007 ns/item; median 19.6; overhead: 36.4%
       TopDownMergeSort: mean 17.365~0.0068 ns/item; median 19.6; overhead: 36.7%
      BottomUpMergeSort: mean 19.645~0.017 ns/item; median 20.1; overhead: 36.7%
     DualPivotQuickSort: mean 17.472~0.0068 ns/item; median 19.8; overhead: 36.4%
    AltTopDownMergeSort: mean 17.282~0.0068 ns/item; median 19.2; overhead: 37.1%

Sorting arrays of (int, int, int) with 32.0 elements by SmallTupleOrder (average over 2520142 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.
ArraySort_OrderComparer: mean 26.626~0.01 ns/item; median 28.1; overhead: 34.7%
      ParallelQuickSort: mean 14.662~0.0074 ns/item; median 15.1; overhead: 47.0%
              QuickSort: mean 13.49~0.0063 ns/item; median 14.8; overhead: 49.1%
       TopDownMergeSort: mean 14.184~0.0063 ns/item; median 15.7; overhead: 47.5%
      BottomUpMergeSort: mean 17.174~0.0095 ns/item; median 17.4; overhead: 45.8%
     DualPivotQuickSort: mean 13.571~0.0062 ns/item; median 15.0; overhead: 49.1%
    AltTopDownMergeSort: mean 13.972~0.0063 ns/item; median 15.6; overhead: 48.1%

Sorting arrays of SampleClass with 32.0 elements by SampleClassOrder (average over 2520142 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 16.0 and heap size 16.0.  
Per-sort working set on average 0.0MB (max upto twice that), overall benchmark ~0.0MB; mergesort scratch needs an extra 0.0MB.
ArraySort_OrderComparer: mean 30.612~0.029 ns/item; median 29.5; overhead: 31.4%
      ParallelQuickSort: mean 19.122~0.0085 ns/item; median 18.5; overhead: 41.0%
              QuickSort: mean 17.775~0.0072 ns/item; median 18.2; overhead: 42.8%
       TopDownMergeSort: mean 20.104~0.0076 ns/item; median 20.6; overhead: 39.3%
      BottomUpMergeSort: mean 23.008~0.011 ns/item; median 21.8; overhead: 38.4%
     DualPivotQuickSort: mean 17.72~0.0072 ns/item; median 18.2; overhead: 42.4%
    AltTopDownMergeSort: mean 19.126~0.0075 ns/item; median 19.8; overhead: 40.8%

Sorting arrays of (int, long, DateTime, string, Guid) with 32.0 elements by BigTupleOrder (average over 2520142 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.
ArraySort_OrderComparer: mean 101.251~0.031 ns/item; median 108.3; overhead: 26.1%
      ParallelQuickSort: mean 47.6158~0.01 ns/item; median 51.4; overhead: 41.9%
              QuickSort: mean 46.9841~0.0096 ns/item; median 51.3; overhead: 42.3%
       TopDownMergeSort: mean 54.603~0.056 ns/item; median 59.4; overhead: 38.2%
      BottomUpMergeSort: mean 60.341~0.03 ns/item; median 63.6; overhead: 37.0%
     DualPivotQuickSort: mean 46.9545~0.0099 ns/item; median 51.3; overhead: 42.3%
    AltTopDownMergeSort: mean 52.1525~0.01 ns/item; median 57.3; overhead: 39.5%


Sorting arrays of int with 128.0 elements by Int32Order (average over 732494 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.
    ArraySort_Primitive: mean 17.861~0.0085 ns/item; median 17.4; overhead: 26.6%
      ParallelQuickSort: mean 13.786~0.009 ns/item; median 13.4; overhead: 31.0%
              QuickSort: mean 13.373~0.0098 ns/item; median 13.2; overhead: 31.9%
       TopDownMergeSort: mean 13.555~0.0088 ns/item; median 13.4; overhead: 31.6%
      BottomUpMergeSort: mean 15.919~0.011 ns/item; median 14.7; overhead: 30.0%
     DualPivotQuickSort: mean 13.262~0.018 ns/item; median 13.2; overhead: 31.9%
    AltTopDownMergeSort: mean 13.698~0.0089 ns/item; median 13.5; overhead: 31.5%

Sorting arrays of uint with 128.0 elements by UInt32Order (average over 732494 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.
    ArraySort_Primitive: mean 18.734~0.0086 ns/item; median 18.2; overhead: 25.7%
      ParallelQuickSort: mean 13.849~0.009 ns/item; median 13.5; overhead: 30.7%
              QuickSort: mean 13.453~0.0087 ns/item; median 13.4; overhead: 31.5%
       TopDownMergeSort: mean 14.054~0.0088 ns/item; median 14.0; overhead: 30.6%
      BottomUpMergeSort: mean 15.818~0.01 ns/item; median 14.8; overhead: 29.9%
     DualPivotQuickSort: mean 13.485~0.0087 ns/item; median 13.4; overhead: 31.5%
    AltTopDownMergeSort: mean 13.986~0.0088 ns/item; median 13.9; overhead: 30.8%

Sorting arrays of ulong with 128.0 elements by UInt64Order (average over 732494 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.
    ArraySort_Primitive: mean 18.949~0.0086 ns/item; median 18.5; overhead: 25.3%
      ParallelQuickSort: mean 14.265~0.009 ns/item; median 13.9; overhead: 30.4%
              QuickSort: mean 13.428~0.0085 ns/item; median 13.4; overhead: 31.4%
       TopDownMergeSort: mean 14.126~0.0087 ns/item; median 14.1; overhead: 30.3%
      BottomUpMergeSort: mean 15.757~0.011 ns/item; median 14.8; overhead: 29.3%
     DualPivotQuickSort: mean 13.73~0.047 ns/item; median 13.4; overhead: 31.4%
    AltTopDownMergeSort: mean 14.031~0.0086 ns/item; median 14.0; overhead: 30.5%

Sorting arrays of double with 128.0 elements by DoubleOrdering (average over 732494 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.
    ArraySort_Primitive: mean 22.171~0.0088 ns/item; median 21.8; overhead: 23.9%
      ParallelQuickSort: mean 14.716~0.0089 ns/item; median 14.5; overhead: 31.1%
              QuickSort: mean 14.316~0.0085 ns/item; median 14.4; overhead: 31.8%
       TopDownMergeSort: mean 14.88~0.0087 ns/item; median 15.0; overhead: 30.8%
      BottomUpMergeSort: mean 17.411~0.011 ns/item; median 16.6; overhead: 28.8%
     DualPivotQuickSort: mean 14.331~0.0085 ns/item; median 14.4; overhead: 31.7%
    AltTopDownMergeSort: mean 15.04~0.0087 ns/item; median 15.1; overhead: 30.7%

Sorting arrays of int with 128.0 elements by ComparableOrdering<int> (average over 732494 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.
ArraySort_OrderComparer: mean 26.337~0.0092 ns/item; median 25.7; overhead: 21.2%
      ParallelQuickSort: mean 14.571~0.009 ns/item; median 14.2; overhead: 32.0%
              QuickSort: mean 13.699~0.0087 ns/item; median 13.7; overhead: 33.0%
       TopDownMergeSort: mean 14.461~0.028 ns/item; median 14.2; overhead: 32.2%
      BottomUpMergeSort: mean 16.109~0.011 ns/item; median 15.1; overhead: 30.9%
     DualPivotQuickSort: mean 13.756~0.0086 ns/item; median 13.7; overhead: 33.0%
    AltTopDownMergeSort: mean 14.512~0.0089 ns/item; median 14.4; overhead: 32.1%

Sorting arrays of uint with 128.0 elements by ComparableOrdering<uint> (average over 732494 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.
ArraySort_OrderComparer: mean 28.312~0.0095 ns/item; median 27.9; overhead: 19.1%
      ParallelQuickSort: mean 14.486~0.0086 ns/item; median 14.2; overhead: 30.5%
              QuickSort: mean 14.155~0.0087 ns/item; median 14.1; overhead: 31.3%
       TopDownMergeSort: mean 14.729~0.0087 ns/item; median 14.7; overhead: 30.5%
      BottomUpMergeSort: mean 16.315~0.011 ns/item; median 15.4; overhead: 29.6%
     DualPivotQuickSort: mean 14.254~0.0086 ns/item; median 14.2; overhead: 31.2%
    AltTopDownMergeSort: mean 14.675~0.0087 ns/item; median 14.6; overhead: 30.5%

Sorting arrays of ulong with 128.0 elements by ComparableOrdering<ulong> (average over 732494 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.
ArraySort_OrderComparer: mean 27.398~0.0095 ns/item; median 27.0; overhead: 20.4%
      ParallelQuickSort: mean 14.115~0.0088 ns/item; median 13.8; overhead: 32.0%
              QuickSort: mean 13.719~0.013 ns/item; median 13.7; overhead: 32.9%
       TopDownMergeSort: mean 14.035~0.0085 ns/item; median 14.0; overhead: 32.4%
      BottomUpMergeSort: mean 16.194~0.011 ns/item; median 15.2; overhead: 31.0%
     DualPivotQuickSort: mean 13.756~0.0086 ns/item; median 13.7; overhead: 32.8%
    AltTopDownMergeSort: mean 14.184~0.0088 ns/item; median 14.0; overhead: 32.3%

Sorting arrays of double with 128.0 elements by ComparableOrdering<double> (average over 732494 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.
ArraySort_OrderComparer: mean 42.8079~0.011 ns/item; median 43.1; overhead: 15.4%
      ParallelQuickSort: mean 28.64~0.01  ns/item; median 29.0; overhead: 20.8%
              QuickSort: mean 28.349~0.01 ns/item; median 28.8; overhead: 21.0%
       TopDownMergeSort: mean 29.465~0.01 ns/item; median 29.8; overhead: 20.2%
      BottomUpMergeSort: mean 28.768~0.02 ns/item; median 28.4; overhead: 21.5%
     DualPivotQuickSort: mean 28.286~0.0098 ns/item; median 28.8; overhead: 21.1%
    AltTopDownMergeSort: mean 28.383~0.0096 ns/item; median 29.2; overhead: 20.5%

Sorting arrays of (int, int, int) with 128.0 elements by SmallTupleOrder (average over 732494 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.
ArraySort_OrderComparer: mean 38.7592~0.011 ns/item; median 38.9; overhead: 21.4%
      ParallelQuickSort: mean 21.384~0.0091 ns/item; median 21.7; overhead: 31.9%
              QuickSort: mean 21.296~0.0092 ns/item; median 21.6; overhead: 32.0%
       TopDownMergeSort: mean 22.037~0.0092 ns/item; median 22.3; overhead: 31.4%
      BottomUpMergeSort: mean 24.625~0.012 ns/item; median 23.9; overhead: 30.8%
     DualPivotQuickSort: mean 22.267~0.0091 ns/item; median 22.5; overhead: 31.7%
    AltTopDownMergeSort: mean 22.97~0.0093 ns/item; median 23.3; overhead: 31.0%

Sorting arrays of SampleClass with 128.0 elements by SampleClassOrder (average over 732494 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.
ArraySort_OrderComparer: mean 37.69~0.012 ns/item; median 36.4; overhead: 19.0%
      ParallelQuickSort: mean 24.948~0.01 ns/item; median 24.4; overhead: 25.2%
              QuickSort: mean 24.758~0.01 ns/item; median 24.3; overhead: 25.3%
       TopDownMergeSort: mean 27.549~0.011 ns/item; median 27.4; overhead: 23.6%
      BottomUpMergeSort: mean 29.703~0.012 ns/item; median 28.1; overhead: 23.4%
     DualPivotQuickSort: mean 24.817~0.01 ns/item; median 24.4; overhead: 25.3%
    AltTopDownMergeSort: mean 27.431~0.011 ns/item; median 27.0; overhead: 23.8%

Sorting arrays of (int, long, DateTime, string, Guid) with 128.0 elements by BigTupleOrder (average over 732494 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.
ArraySort_OrderComparer: mean 145.439~0.025 ns/item; median 146.0; overhead: 19.0%
      ParallelQuickSort: mean 67.5718~0.014 ns/item; median 67.7; overhead: 33.4%
              QuickSort: mean 67.6797~0.014 ns/item; median 67.8; overhead: 33.4%
       TopDownMergeSort: mean 80.3353~0.016 ns/item; median 79.2; overhead: 29.2%
      BottomUpMergeSort: mean 85.1979~0.019 ns/item; median 84.7; overhead: 28.8%
     DualPivotQuickSort: mean 67.8363~0.014 ns/item; median 67.8; overhead: 33.4%
    AltTopDownMergeSort: mean 77.928~0.015 ns/item; median 77.8; overhead: 29.9%


Sorting arrays of int with 1022.7 elements by Int32Order (average over 90094 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.
    ArraySort_Primitive: mean 28.581~0.032 ns/item; median 25.8; overhead: 17.2%
      ParallelQuickSort: mean 23.234~0.029 ns/item; median 21.4; overhead: 20.1%
              QuickSort: mean 23.026~0.029 ns/item; median 21.2; overhead: 20.1%
       TopDownMergeSort: mean 24.434~0.029 ns/item; median 22.6; overhead: 19.1%
      BottomUpMergeSort: mean 25.372~0.035 ns/item; median 23.3; overhead: 19.1%
     DualPivotQuickSort: mean 23.655~0.028 ns/item; median 22.0; overhead: 19.5%
    AltTopDownMergeSort: mean 24.691~0.029 ns/item; median 23.1; overhead: 18.9%

Sorting arrays of uint with 1022.7 elements by UInt32Order (average over 90094 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.
    ArraySort_Primitive: mean 29.716~0.034 ns/item; median 26.7; overhead: 16.8%
      ParallelQuickSort: mean 23.373~0.029 ns/item; median 21.5; overhead: 20.0%
              QuickSort: mean 23.368~0.029 ns/item; median 21.5; overhead: 19.9%
       TopDownMergeSort: mean 24.699~0.029 ns/item; median 22.8; overhead: 19.0%
      BottomUpMergeSort: mean 25.567~0.037 ns/item; median 23.1; overhead: 19.3%
     DualPivotQuickSort: mean 23.901~0.027 ns/item; median 22.2; overhead: 19.4%
    AltTopDownMergeSort: mean 24.711~0.03 ns/item; median 23.2; overhead: 19.0%

Sorting arrays of ulong with 1022.7 elements by UInt64Order (average over 90094 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.
    ArraySort_Primitive: mean 30.295~0.036 ns/item; median 27.3; overhead: 16.4%
      ParallelQuickSort: mean 23.404~0.029 ns/item; median 21.6; overhead: 19.7%
              QuickSort: mean 23.688~0.063 ns/item; median 21.6; overhead: 19.8%
       TopDownMergeSort: mean 25.131~0.03 ns/item; median 23.3; overhead: 18.5%
      BottomUpMergeSort: mean 25.858~0.035 ns/item; median 23.6; overhead: 18.7%
     DualPivotQuickSort: mean 23.976~0.028 ns/item; median 22.3; overhead: 19.2%
    AltTopDownMergeSort: mean 25.177~0.029 ns/item; median 23.7; overhead: 18.5%

Sorting arrays of double with 1022.7 elements by DoubleOrdering (average over 90094 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.
    ArraySort_Primitive: mean 35.126~0.04 ns/item; median 31.6; overhead: 15.6%
      ParallelQuickSort: mean 25.3~0.026  ns/item; median 23.5; overhead: 19.9%
              QuickSort: mean 25.351~0.028 ns/item; median 23.5; overhead: 19.9%
       TopDownMergeSort: mean 27.256~0.029 ns/item; median 25.5; overhead: 18.5%
      BottomUpMergeSort: mean 28.691~0.036 ns/item; median 26.6; overhead: 18.4%
     DualPivotQuickSort: mean 26.069~0.029 ns/item; median 24.4; overhead: 19.3%
    AltTopDownMergeSort: mean 27.713~0.029 ns/item; median 26.0; overhead: 18.3%

Sorting arrays of int with 1022.7 elements by ComparableOrdering<int> (average over 90094 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.
ArraySort_OrderComparer: mean 42.063~0.044 ns/item; median 38.0; overhead: 13.6%
      ParallelQuickSort: mean 23.726~0.051 ns/item; median 21.6; overhead: 21.4%
              QuickSort: mean 23.447~0.029 ns/item; median 21.6; overhead: 21.6%
       TopDownMergeSort: mean 25.56~0.086 ns/item; median 23.3; overhead: 20.2%
      BottomUpMergeSort: mean 25.938~0.035 ns/item; median 23.8; overhead: 20.4%
     DualPivotQuickSort: mean 24.884~0.028 ns/item; median 23.2; overhead: 20.3%
    AltTopDownMergeSort: mean 25.207~0.029 ns/item; median 23.6; overhead: 20.3%

Sorting arrays of uint with 1022.7 elements by ComparableOrdering<uint> (average over 90094 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.
ArraySort_OrderComparer: mean 45.866~0.047 ns/item; median 41.5; overhead: 11.9%
      ParallelQuickSort: mean 24.496~0.029 ns/item; median 22.5; overhead: 20.0%
              QuickSort: mean 24.75~0.052 ns/item; median 22.5; overhead: 20.0%
       TopDownMergeSort: mean 26.204~0.062 ns/item; median 23.9; overhead: 19.0%
      BottomUpMergeSort: mean 26.399~0.036 ns/item; median 24.0; overhead: 19.2%
     DualPivotQuickSort: mean 25.563~0.029 ns/item; median 23.8; overhead: 19.1%
    AltTopDownMergeSort: mean 25.834~0.03 ns/item; median 24.1; overhead: 19.0%

Sorting arrays of ulong with 1022.7 elements by ComparableOrdering<ulong> (average over 90094 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.
ArraySort_OrderComparer: mean 43.868~0.046 ns/item; median 39.6; overhead: 13.1%
      ParallelQuickSort: mean 23.64~0.027 ns/item; median 21.8; overhead: 21.4%
              QuickSort: mean 23.658~0.028 ns/item; median 21.8; overhead: 21.4%
       TopDownMergeSort: mean 24.964~0.029 ns/item; median 23.1; overhead: 20.5%
      BottomUpMergeSort: mean 26.251~0.038 ns/item; median 24.0; overhead: 20.6%
     DualPivotQuickSort: mean 24.812~0.026 ns/item; median 23.2; overhead: 20.2%
    AltTopDownMergeSort: mean 25.235~0.028 ns/item; median 23.5; overhead: 20.3%

Sorting arrays of double with 1022.7 elements by ComparableOrdering<double> (average over 90094 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.
ArraySort_OrderComparer: mean 71.609~0.064 ns/item; median 65.5; overhead: 9.4%
      ParallelQuickSort: mean 48.665~0.047 ns/item; median 44.5; overhead: 13.6%
              QuickSort: mean 47.242~0.044 ns/item; median 43.3; overhead: 13.6%
       TopDownMergeSort: mean 50.409~0.045 ns/item; median 44.2; overhead: 12.7%
      BottomUpMergeSort: mean 48.305~0.047 ns/item; median 43.0; overhead: 13.4%
     DualPivotQuickSort: mean 48.15~0.045 ns/item; median 44.4; overhead: 13.3%
    AltTopDownMergeSort: mean 48.413~0.093 ns/item; median 43.2; overhead: 13.4%

Sorting arrays of (int, int, int) with 1022.7 elements by SmallTupleOrder (average over 90094 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.
ArraySort_OrderComparer: mean 63.58~0.06  ns/item; median 58.0; overhead: 14.2%
      ParallelQuickSort: mean 36.63~0.038 ns/item; median 33.9; overhead: 22.3%
              QuickSort: mean 37.855~0.038 ns/item; median 34.7; overhead: 21.6%
       TopDownMergeSort: mean 37.382~0.037 ns/item; median 34.6; overhead: 21.9%
      BottomUpMergeSort: mean 39.516~0.049 ns/item; median 34.7; overhead: 21.3%
     DualPivotQuickSort: mean 38.118~0.038 ns/item; median 35.0; overhead: 21.5%
    AltTopDownMergeSort: mean 38.389~0.039 ns/item; median 34.9; overhead: 21.5%

Sorting arrays of SampleClass with 1022.7 elements by SampleClassOrder (average over 90094 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.
ArraySort_OrderComparer: mean 58.063~0.064 ns/item; median 51.6; overhead: 12.5%
      ParallelQuickSort: mean 40.412~0.045 ns/item; median 36.4; overhead: 18.2%
              QuickSort: mean 40.078~0.044 ns/item; median 36.1; overhead: 18.2%
       TopDownMergeSort: mean 45.389~0.048 ns/item; median 40.1; overhead: 16.4%
      BottomUpMergeSort: mean 47.151~0.057 ns/item; median 42.0; overhead: 16.2%
     DualPivotQuickSort: mean 41.73~0.067 ns/item; median 37.8; overhead: 17.7%
    AltTopDownMergeSort: mean 45.078~0.047 ns/item; median 39.8; overhead: 16.6%

Sorting arrays of (int, long, DateTime, string, Guid) with 1022.7 elements by BigTupleOrder (average over 90094 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.
ArraySort_OrderComparer: mean 227.66~0.24 ns/item; median 205.0; overhead: 13.9%
      ParallelQuickSort: mean 102.63~0.11 ns/item; median 92.1; overhead: 26.9%
              QuickSort: mean 103.36~0.11 ns/item; median 92.0; overhead: 26.4%
       TopDownMergeSort: mean 130.28~0.15 ns/item; median 120.9; overhead: 22.0%
      BottomUpMergeSort: mean 134.08~0.15 ns/item; median 117.4; overhead: 21.6%
     DualPivotQuickSort: mean 107.4~0.1   ns/item; median 97.2; overhead: 25.3%
    AltTopDownMergeSort: mean 125.79~0.12 ns/item; median 115.0; overhead: 22.5%


Sorting arrays of int with 2046.5 elements by Int32Order (average over 43814 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.
    ArraySort_Primitive: mean 32.428~0.059 ns/item; median 28.4; overhead: 15.6%
      ParallelQuickSort: mean 22.282~0.069 ns/item; median 23.9; overhead: 26.1%
              QuickSort: mean 26.704~0.048 ns/item; median 23.9; overhead: 18.1%
       TopDownMergeSort: mean 28.65~0.098 ns/item; median 25.6; overhead: 17.2%
      BottomUpMergeSort: mean 29.176~0.059 ns/item; median 25.1; overhead: 17.1%
     DualPivotQuickSort: mean 26.886~0.046 ns/item; median 24.1; overhead: 17.9%
    AltTopDownMergeSort: mean 28.337~0.046 ns/item; median 25.3; overhead: 17.2%

Sorting arrays of uint with 2046.5 elements by UInt32Order (average over 43814 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.
    ArraySort_Primitive: mean 33.698~0.067 ns/item; median 29.4; overhead: 15.3%
      ParallelQuickSort: mean 22.8~0.073  ns/item; median 24.3; overhead: 25.9%
              QuickSort: mean 26.868~0.046 ns/item; median 24.0; overhead: 18.1%
       TopDownMergeSort: mean 28.693~0.073 ns/item; median 25.8; overhead: 17.3%
      BottomUpMergeSort: mean 29.087~0.064 ns/item; median 25.1; overhead: 17.3%
     DualPivotQuickSort: mean 27.117~0.047 ns/item; median 24.2; overhead: 17.9%
    AltTopDownMergeSort: mean 28.282~0.045 ns/item; median 25.1; overhead: 17.3%

Sorting arrays of ulong with 2046.5 elements by UInt64Order (average over 43814 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.3MB; mergesort scratch needs an extra 0.0MB.
    ArraySort_Primitive: mean 34.246~0.062 ns/item; median 30.0; overhead: 15.0%
      ParallelQuickSort: mean 23.385~0.074 ns/item; median 25.0; overhead: 25.8%
              QuickSort: mean 26.897~0.044 ns/item; median 24.1; overhead: 18.2%
       TopDownMergeSort: mean 28.859~0.046 ns/item; median 26.2; overhead: 17.0%
      BottomUpMergeSort: mean 29.694~0.062 ns/item; median 25.7; overhead: 16.7%
     DualPivotQuickSort: mean 27.229~0.049 ns/item; median 24.4; overhead: 17.7%
    AltTopDownMergeSort: mean 28.978~0.053 ns/item; median 25.8; overhead: 16.8%

Sorting arrays of double with 2046.5 elements by DoubleOrdering (average over 43814 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.3MB; mergesort scratch needs an extra 0.0MB.
    ArraySort_Primitive: mean 39.593~0.07 ns/item; median 34.6; overhead: 14.3%
      ParallelQuickSort: mean 24.882~0.078 ns/item; median 26.8; overhead: 26.1%
              QuickSort: mean 29.329~0.048 ns/item; median 26.4; overhead: 18.0%
       TopDownMergeSort: mean 31.554~0.05 ns/item; median 28.7; overhead: 16.8%
      BottomUpMergeSort: mean 33.434~0.062 ns/item; median 28.9; overhead: 16.4%
     DualPivotQuickSort: mean 29.873~0.051 ns/item; median 26.9; overhead: 17.7%
    AltTopDownMergeSort: mean 31.837~0.055 ns/item; median 28.7; overhead: 16.8%

Sorting arrays of int with 2046.5 elements by ComparableOrdering<int> (average over 43814 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.
ArraySort_OrderComparer: mean 47.845~0.084 ns/item; median 42.0; overhead: 12.4%
      ParallelQuickSort: mean 22.7~0.073  ns/item; median 24.3; overhead: 28.0%
              QuickSort: mean 27.008~0.044 ns/item; median 24.2; overhead: 19.6%
       TopDownMergeSort: mean 28.952~0.05 ns/item; median 26.2; overhead: 18.5%
      BottomUpMergeSort: mean 29.769~0.061 ns/item; median 25.7; overhead: 18.4%
     DualPivotQuickSort: mean 28.42~0.046 ns/item; median 25.7; overhead: 18.6%
    AltTopDownMergeSort: mean 28.975~0.05 ns/item; median 25.8; overhead: 18.5%

Sorting arrays of uint with 2046.5 elements by ComparableOrdering<uint> (average over 43814 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.
ArraySort_OrderComparer: mean 52.062~0.087 ns/item; median 45.9; overhead: 10.7%
      ParallelQuickSort: mean 23.73~0.077 ns/item; median 25.3; overhead: 25.9%
              QuickSort: mean 28.331~0.05 ns/item; median 25.3; overhead: 18.0%
       TopDownMergeSort: mean 29.865~0.053 ns/item; median 26.8; overhead: 17.1%
      BottomUpMergeSort: mean 30.152~0.061 ns/item; median 26.1; overhead: 17.2%
     DualPivotQuickSort: mean 29.157~0.049 ns/item; median 26.2; overhead: 17.4%
    AltTopDownMergeSort: mean 29.701~0.056 ns/item; median 26.3; overhead: 17.2%

Sorting arrays of ulong with 2046.5 elements by ComparableOrdering<ulong> (average over 43814 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.3MB; mergesort scratch needs an extra 0.0MB.
ArraySort_OrderComparer: mean 51.144~0.089 ns/item; median 44.9; overhead: 11.9%
      ParallelQuickSort: mean 22.92~0.072 ns/item; median 24.5; overhead: 27.8%
              QuickSort: mean 27.185~0.048 ns/item; median 24.3; overhead: 19.6%
       TopDownMergeSort: mean 28.772~0.049 ns/item; median 25.9; overhead: 18.6%
      BottomUpMergeSort: mean 30.106~0.065 ns/item; median 25.7; overhead: 18.4%
     DualPivotQuickSort: mean 28.412~0.043 ns/item; median 25.7; overhead: 18.6%
    AltTopDownMergeSort: mean 28.981~0.049 ns/item; median 25.9; overhead: 18.6%

Sorting arrays of double with 2046.5 elements by ComparableOrdering<double> (average over 43814 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.3MB; mergesort scratch needs an extra 0.0MB.
ArraySort_OrderComparer: mean 83.016~0.13 ns/item; median 73.7; overhead: 8.5%
      ParallelQuickSort: mean 44.122~0.13 ns/item; median 47.9; overhead: 19.3%
              QuickSort: mean 54.441~0.13 ns/item; median 47.8; overhead: 12.3%
       TopDownMergeSort: mean 57.876~0.089 ns/item; median 53.5; overhead: 11.5%
      BottomUpMergeSort: mean 55.385~0.094 ns/item; median 49.9; overhead: 12.2%
     DualPivotQuickSort: mean 54.996~0.087 ns/item; median 48.9; overhead: 12.2%
    AltTopDownMergeSort: mean 56.261~0.086 ns/item; median 48.9; overhead: 11.6%

Sorting arrays of (int, int, int) with 2046.5 elements by SmallTupleOrder (average over 43814 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.5MB; mergesort scratch needs an extra 0.0MB.
ArraySort_OrderComparer: mean 74.511~0.12 ns/item; median 65.9; overhead: 13.2%
      ParallelQuickSort: mean 35.439~0.11 ns/item; median 25.4; overhead: 30.2%
              QuickSort: mean 45.388~0.072 ns/item; median 40.3; overhead: 19.8%
       TopDownMergeSort: mean 44.285~0.069 ns/item; median 39.3; overhead: 19.9%
      BottomUpMergeSort: mean 46.33~0.09  ns/item; median 41.1; overhead: 19.6%
     DualPivotQuickSort: mean 44.871~0.072 ns/item; median 39.8; overhead: 19.7%
    AltTopDownMergeSort: mean 45.094~0.098 ns/item; median 39.8; overhead: 19.7%

Sorting arrays of SampleClass with 2046.5 elements by SampleClassOrder (average over 43814 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.1MB (max upto twice that), overall benchmark ~1.0MB; mergesort scratch needs an extra 0.0MB.
ArraySort_OrderComparer: mean 66.166~0.13 ns/item; median 57.3; overhead: 11.6%
      ParallelQuickSort: mean 41.067~0.11 ns/item; median 39.7; overhead: 20.2%
              QuickSort: mean 44.974~0.081 ns/item; median 39.5; overhead: 15.9%
       TopDownMergeSort: mean 51.697~0.088 ns/item; median 46.4; overhead: 14.1%
      BottomUpMergeSort: mean 53.446~0.11 ns/item; median 47.1; overhead: 14.1%
     DualPivotQuickSort: mean 46.998~0.081 ns/item; median 41.5; overhead: 15.3%
    AltTopDownMergeSort: mean 51.462~0.088 ns/item; median 46.4; overhead: 14.2%

Sorting arrays of (int, long, DateTime, string, Guid) with 2046.5 elements by BigTupleOrder (average over 43814 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.1MB (max upto twice that), overall benchmark ~1.5MB; mergesort scratch needs an extra 0.1MB.
ArraySort_OrderComparer: mean 257.81~0.44 ns/item; median 225.6; overhead: 12.8%
      ParallelQuickSort: mean 91.24~0.31  ns/item; median 54.9; overhead: 38.2%
              QuickSort: mean 116.07~0.21 ns/item; median 100.0; overhead: 24.9%
       TopDownMergeSort: mean 147.6~0.25  ns/item; median 124.2; overhead: 20.3%
      BottomUpMergeSort: mean 154.1~0.58  ns/item; median 134.2; overhead: 20.2%
     DualPivotQuickSort: mean 122.11~0.2  ns/item; median 107.2; overhead: 23.6%
    AltTopDownMergeSort: mean 143.36~0.24 ns/item; median 123.4; overhead: 20.7%


Sorting arrays of int with 8179.7 elements by Int32Order (average over 10278 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.
    ArraySort_Primitive: mean 39.88~0.18  ns/item; median 33.6; overhead: 13.5%
      ParallelQuickSort: mean 17.92~0.2   ns/item; median 9.9; overhead: 36.2%
              QuickSort: mean 33.96~0.21  ns/item; median 28.6; overhead: 9.1%
       TopDownMergeSort: mean 36.04~0.14  ns/item; median 31.4; overhead: 8.5%
      BottomUpMergeSort: mean 36.64~0.17  ns/item; median 30.6; overhead: 8.5%
     DualPivotQuickSort: mean 33.76~0.14  ns/item; median 28.9; overhead: 9.1%
    AltTopDownMergeSort: mean 36.14~0.14  ns/item; median 30.9; overhead: 8.5%

Sorting arrays of uint with 8179.7 elements by UInt32Order (average over 10278 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.
    ArraySort_Primitive: mean 41.25~0.2   ns/item; median 34.5; overhead: 13.3%
      ParallelQuickSort: mean 18.53~0.21  ns/item; median 10.2; overhead: 35.5%
              QuickSort: mean 33.81~0.14  ns/item; median 28.8; overhead: 9.1%
       TopDownMergeSort: mean 36.07~0.15  ns/item; median 31.4; overhead: 8.6%
      BottomUpMergeSort: mean 36.29~0.16  ns/item; median 30.4; overhead: 8.5%
     DualPivotQuickSort: mean 34.24~0.15  ns/item; median 29.2; overhead: 9.0%
    AltTopDownMergeSort: mean 36.03~0.14  ns/item; median 30.7; overhead: 8.5%

Sorting arrays of ulong with 8179.7 elements by UInt64Order (average over 10278 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.
    ArraySort_Primitive: mean 41.72~0.2   ns/item; median 34.9; overhead: 13.0%
      ParallelQuickSort: mean 19.15~0.22  ns/item; median 10.5; overhead: 35.4%
              QuickSort: mean 34.49~0.14  ns/item; median 29.4; overhead: 9.5%
       TopDownMergeSort: mean 37.45~0.23  ns/item; median 32.2; overhead: 8.7%
      BottomUpMergeSort: mean 37.72~0.19  ns/item; median 31.4; overhead: 8.7%
     DualPivotQuickSort: mean 34.25~0.14  ns/item; median 29.3; overhead: 9.4%
    AltTopDownMergeSort: mean 37~0.16     ns/item; median 31.5; overhead: 8.7%

Sorting arrays of double with 8179.7 elements by DoubleOrdering (average over 10278 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.
    ArraySort_Primitive: mean 48.25~0.22  ns/item; median 40.4; overhead: 12.4%
      ParallelQuickSort: mean 20.76~0.24  ns/item; median 11.5; overhead: 35.3%
              QuickSort: mean 38.07~0.15  ns/item; median 32.6; overhead: 10.5%
       TopDownMergeSort: mean 40.6~0.16   ns/item; median 35.3; overhead: 9.7%
      BottomUpMergeSort: mean 42.25~0.2   ns/item; median 35.1; overhead: 9.5%
     DualPivotQuickSort: mean 38.05~0.15  ns/item; median 32.7; overhead: 10.3%
    AltTopDownMergeSort: mean 40.88~0.16  ns/item; median 35.2; overhead: 9.7%

Sorting arrays of int with 8179.7 elements by ComparableOrdering<int> (average over 10278 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.
ArraySort_OrderComparer: mean 59.15~0.27  ns/item; median 49.7; overhead: 10.6%
      ParallelQuickSort: mean 18.97~0.21  ns/item; median 10.5; overhead: 38.2%
              QuickSort: mean 33.99~0.14  ns/item; median 29.0; overhead: 11.9%
       TopDownMergeSort: mean 36.96~0.16  ns/item; median 32.1; overhead: 11.0%
      BottomUpMergeSort: mean 37.45~0.18  ns/item; median 31.2; overhead: 11.0%
     DualPivotQuickSort: mean 36.18~0.15  ns/item; median 31.2; overhead: 11.1%
    AltTopDownMergeSort: mean 36.84~0.17  ns/item; median 31.3; overhead: 11.1%

Sorting arrays of uint with 8179.7 elements by ComparableOrdering<uint> (average over 10278 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.
ArraySort_OrderComparer: mean 64.51~0.29  ns/item; median 54.4; overhead: 9.2%
      ParallelQuickSort: mean 19.47~0.25  ns/item; median 10.5; overhead: 35.8%
              QuickSort: mean 35.61~0.15  ns/item; median 30.4; overhead: 11.6%
       TopDownMergeSort: mean 37.6~0.15   ns/item; median 32.4; overhead: 10.9%
      BottomUpMergeSort: mean 37.57~0.17  ns/item; median 31.5; overhead: 10.9%
     DualPivotQuickSort: mean 36.97~0.15  ns/item; median 31.8; overhead: 10.9%
    AltTopDownMergeSort: mean 37.34~0.16  ns/item; median 31.7; overhead: 10.9%

Sorting arrays of ulong with 8179.7 elements by ComparableOrdering<ulong> (average over 10278 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.
ArraySort_OrderComparer: mean 61.51~0.28  ns/item; median 51.8; overhead: 10.2%
      ParallelQuickSort: mean 18.36~0.21  ns/item; median 10.2; overhead: 38.0%
              QuickSort: mean 34.22~0.14  ns/item; median 29.2; overhead: 11.6%
       TopDownMergeSort: mean 36.59~0.15  ns/item; median 31.5; overhead: 11.0%
      BottomUpMergeSort: mean 37.81~0.19  ns/item; median 31.3; overhead: 10.9%
     DualPivotQuickSort: mean 36.27~0.14  ns/item; median 31.3; overhead: 11.0%
    AltTopDownMergeSort: mean 37.05~0.16  ns/item; median 31.6; overhead: 10.9%

Sorting arrays of double with 8179.7 elements by ComparableOrdering<double> (average over 10278 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.
ArraySort_OrderComparer: mean 102.5~0.44  ns/item; median 86.9; overhead: 7.2%
      ParallelQuickSort: mean 35.7~0.42   ns/item; median 18.5; overhead: 29.0%
              QuickSort: mean 67.15~0.29  ns/item; median 56.7; overhead: 7.4%
       TopDownMergeSort: mean 73.62~0.31  ns/item; median 65.3; overhead: 6.5%
      BottomUpMergeSort: mean 69.95~0.31  ns/item; median 60.0; overhead: 7.5%
     DualPivotQuickSort: mean 68.68~0.29  ns/item; median 58.3; overhead: 7.8%
    AltTopDownMergeSort: mean 72.13~0.32  ns/item; median 59.9; overhead: 7.2%

Sorting arrays of (int, int, int) with 8179.7 elements by SmallTupleOrder (average over 10278 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.
ArraySort_OrderComparer: mean 90.49~0.39  ns/item; median 76.5; overhead: 11.3%
      ParallelQuickSort: mean 27.71~0.32  ns/item; median 14.9; overhead: 40.8%
              QuickSort: mean 54.61~0.23  ns/item; median 46.3; overhead: 15.7%
       TopDownMergeSort: mean 56.88~0.24  ns/item; median 49.1; overhead: 15.2%
      BottomUpMergeSort: mean 60.08~0.4   ns/item; median 50.2; overhead: 14.8%
     DualPivotQuickSort: mean 56.2~0.23   ns/item; median 47.9; overhead: 15.3%
    AltTopDownMergeSort: mean 57.02~0.24  ns/item; median 48.4; overhead: 15.1%

Sorting arrays of SampleClass with 8179.7 elements by SampleClassOrder (average over 10278 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.
ArraySort_OrderComparer: mean 81.68~0.38  ns/item; median 68.3; overhead: 11.0%
      ParallelQuickSort: mean 32.78~0.39  ns/item; median 16.9; overhead: 35.2%
              QuickSort: mean 56.28~0.26  ns/item; median 47.1; overhead: 11.7%
       TopDownMergeSort: mean 65.66~0.29  ns/item; median 56.5; overhead: 10.2%
      BottomUpMergeSort: mean 68.46~0.4   ns/item; median 58.7; overhead: 10.1%
     DualPivotQuickSort: mean 59.6~0.27   ns/item; median 50.2; overhead: 11.1%
    AltTopDownMergeSort: mean 65.49~0.31  ns/item; median 56.4; overhead: 10.3%

Sorting arrays of (int, long, DateTime, string, Guid) with 8179.7 elements by BigTupleOrder (average over 10278 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.
ArraySort_OrderComparer: mean 323.7~1.5   ns/item; median 271.7; overhead: 11.5%
      ParallelQuickSort: mean 69.29~0.93  ns/item; median 33.4; overhead: 51.9%
              QuickSort: mean 143.3~0.69  ns/item; median 118.9; overhead: 21.5%
       TopDownMergeSort: mean 183~0.82    ns/item; median 149.5; overhead: 17.4%
      BottomUpMergeSort: mean 197.3~1.3   ns/item; median 162.8; overhead: 16.9%
     DualPivotQuickSort: mean 154~0.68    ns/item; median 130.0; overhead: 20.0%
    AltTopDownMergeSort: mean 178.5~0.79  ns/item; median 148.4; overhead: 17.8%


Sorting arrays of int with 63711.0 elements by Int32Order (average over 1165 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.
    ArraySort_Primitive: mean 51.06~0.85  ns/item; median 41.2; overhead: 6.6%
      ParallelQuickSort: mean 13.4~0.64   ns/item; median 8.0; overhead: 27.4%
              QuickSort: mean 43.91~0.7   ns/item; median 35.6; overhead: 7.6%
       TopDownMergeSort: mean 48.72~0.75  ns/item; median 40.0; overhead: 6.8%
      BottomUpMergeSort: mean 48.6~0.77   ns/item; median 39.9; overhead: 7.0%
     DualPivotQuickSort: mean 44.46~0.7   ns/item; median 36.2; overhead: 7.4%
    AltTopDownMergeSort: mean 48.52~0.76  ns/item; median 39.8; overhead: 6.8%

Sorting arrays of uint with 63711.0 elements by UInt32Order (average over 1165 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.
    ArraySort_Primitive: mean 52.5~0.89   ns/item; median 42.2; overhead: 6.5%
      ParallelQuickSort: mean 13.7~0.66   ns/item; median 8.2; overhead: 27.0%
              QuickSort: mean 44.29~0.71  ns/item; median 35.9; overhead: 7.5%
       TopDownMergeSort: mean 48.03~0.75  ns/item; median 39.1; overhead: 6.9%
      BottomUpMergeSort: mean 48.64~0.77  ns/item; median 40.0; overhead: 6.9%
     DualPivotQuickSort: mean 44.86~0.71  ns/item; median 36.4; overhead: 7.4%
    AltTopDownMergeSort: mean 48.1~0.75   ns/item; median 39.4; overhead: 6.9%

Sorting arrays of ulong with 63711.0 elements by UInt64Order (average over 1165 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.
    ArraySort_Primitive: mean 52.52~0.88  ns/item; median 42.1; overhead: 6.9%
      ParallelQuickSort: mean 13.6~0.66   ns/item; median 8.0; overhead: 28.7%
              QuickSort: mean 44.46~0.71  ns/item; median 36.1; overhead: 7.9%
       TopDownMergeSort: mean 49.26~0.76  ns/item; median 40.1; overhead: 7.2%
      BottomUpMergeSort: mean 50.76~0.83  ns/item; median 41.3; overhead: 7.2%
     DualPivotQuickSort: mean 45.05~0.71  ns/item; median 36.5; overhead: 7.8%
    AltTopDownMergeSort: mean 49.42~0.77  ns/item; median 40.5; overhead: 7.1%

Sorting arrays of double with 63711.0 elements by DoubleOrdering (average over 1165 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.
    ArraySort_Primitive: mean 61.12~1     ns/item; median 49.0; overhead: 7.3%
      ParallelQuickSort: mean 15~0.7      ns/item; median 9.0; overhead: 30.6%
              QuickSort: mean 49.08~0.77  ns/item; median 39.9; overhead: 8.8%
       TopDownMergeSort: mean 54.73~0.83  ns/item; median 44.6; overhead: 7.9%
      BottomUpMergeSort: mean 57.34~0.99  ns/item; median 47.1; overhead: 7.9%
     DualPivotQuickSort: mean 50.49~0.78  ns/item; median 41.1; overhead: 8.5%
    AltTopDownMergeSort: mean 55.25~0.84  ns/item; median 45.3; overhead: 7.8%

Sorting arrays of int with 63711.0 elements by ComparableOrdering<int> (average over 1165 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.
ArraySort_OrderComparer: mean 75.92~1.2   ns/item; median 60.9; overhead: 6.0%
      ParallelQuickSort: mean 13.7~0.66   ns/item; median 8.2; overhead: 33.1%
              QuickSort: mean 44.69~0.72  ns/item; median 36.2; overhead: 9.8%
       TopDownMergeSort: mean 48.97~0.76  ns/item; median 39.8; overhead: 8.9%
      BottomUpMergeSort: mean 49.66~0.78  ns/item; median 40.9; overhead: 8.9%
     DualPivotQuickSort: mean 48.1~0.74   ns/item; median 39.1; overhead: 9.1%
    AltTopDownMergeSort: mean 49.15~0.77  ns/item; median 40.3; overhead: 8.9%

Sorting arrays of uint with 63711.0 elements by ComparableOrdering<uint> (average over 1165 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.
ArraySort_OrderComparer: mean 83.82~1.4   ns/item; median 67.2; overhead: 5.5%
      ParallelQuickSort: mean 13.8~0.67   ns/item; median 8.2; overhead: 33.1%
              QuickSort: mean 45.51~0.73  ns/item; median 36.8; overhead: 9.7%
       TopDownMergeSort: mean 49.4~0.77   ns/item; median 40.1; overhead: 8.9%
      BottomUpMergeSort: mean 49.67~0.79  ns/item; median 40.7; overhead: 9.0%
     DualPivotQuickSort: mean 49.14~0.75  ns/item; median 40.2; overhead: 8.9%
    AltTopDownMergeSort: mean 49.47~0.78  ns/item; median 40.5; overhead: 8.9%

Sorting arrays of ulong with 63711.0 elements by ComparableOrdering<ulong> (average over 1165 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.
ArraySort_OrderComparer: mean 79.19~1.3   ns/item; median 63.4; overhead: 5.8%
      ParallelQuickSort: mean 13.7~0.66   ns/item; median 8.2; overhead: 33.2%
              QuickSort: mean 44.7~0.72   ns/item; median 36.2; overhead: 9.7%
       TopDownMergeSort: mean 49.13~0.76  ns/item; median 39.8; overhead: 9.0%
      BottomUpMergeSort: mean 50.74~0.87  ns/item; median 41.4; overhead: 8.9%
     DualPivotQuickSort: mean 48.2~0.74   ns/item; median 39.5; overhead: 9.2%
    AltTopDownMergeSort: mean 49.24~0.78  ns/item; median 40.1; overhead: 8.9%

Sorting arrays of double with 63711.0 elements by ComparableOrdering<double> (average over 1165 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.
ArraySort_OrderComparer: mean 133.4~2.1   ns/item; median 107.6; overhead: 4.0%
      ParallelQuickSort: mean 25.3~1.3    ns/item; median 14.9; overhead: 23.6%
              QuickSort: mean 86.7~1.4    ns/item; median 69.7; overhead: 6.1%
       TopDownMergeSort: mean 96.18~1.5   ns/item; median 80.6; overhead: 5.4%
      BottomUpMergeSort: mean 93.6~1.5    ns/item; median 74.6; overhead: 5.6%
     DualPivotQuickSort: mean 89.23~1.4   ns/item; median 71.8; overhead: 6.0%
    AltTopDownMergeSort: mean 93.21~1.5   ns/item; median 80.7; overhead: 5.6%

Sorting arrays of (int, int, int) with 63711.0 elements by SmallTupleOrder (average over 1165 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.
ArraySort_OrderComparer: mean 117~1.9     ns/item; median 94.2; overhead: 8.6%
      ParallelQuickSort: mean 21.2~1.1    ns/item; median 12.6; overhead: 42.1%
              QuickSort: mean 70.97~1.2   ns/item; median 57.3; overhead: 13.4%
       TopDownMergeSort: mean 74.58~1.2   ns/item; median 61.2; overhead: 12.8%
      BottomUpMergeSort: mean 78.01~1.3   ns/item; median 62.0; overhead: 12.6%
     DualPivotQuickSort: mean 73.38~1.2   ns/item; median 59.2; overhead: 13.0%
    AltTopDownMergeSort: mean 74.14~1.2   ns/item; median 59.8; overhead: 12.9%

Sorting arrays of SampleClass with 63711.0 elements by SampleClassOrder (average over 1165 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.
ArraySort_OrderComparer: mean 112.5~1.7   ns/item; median 93.8; overhead: 7.9%
      ParallelQuickSort: mean 23.5~1.2    ns/item; median 13.7; overhead: 36.5%
              QuickSort: mean 78.72~1.2   ns/item; median 66.0; overhead: 10.6%
       TopDownMergeSort: mean 90.47~1.3   ns/item; median 74.2; overhead: 9.4%
      BottomUpMergeSort: mean 96.12~1.8   ns/item; median 78.0; overhead: 9.1%
     DualPivotQuickSort: mean 82.65~1.2   ns/item; median 69.4; overhead: 10.1%
    AltTopDownMergeSort: mean 90.12~1.3   ns/item; median 73.9; overhead: 9.6%

Sorting arrays of (int, long, DateTime, string, Guid) with 63711.0 elements by BigTupleOrder (average over 1165 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.
ArraySort_OrderComparer: mean 413.6~6.8   ns/item; median 333.0; overhead: 9.5%
      ParallelQuickSort: mean 50.5~2.8    ns/item; median 29.4; overhead: 54.5%
              QuickSort: mean 184~3.1     ns/item; median 147.7; overhead: 19.1%
       TopDownMergeSort: mean 238~3.9     ns/item; median 195.7; overhead: 15.7%
      BottomUpMergeSort: mean 261~7.7     ns/item; median 197.7; overhead: 14.8%
     DualPivotQuickSort: mean 203.2~3.2   ns/item; median 165.9; overhead: 17.5%
    AltTopDownMergeSort: mean 232.6~3.8   ns/item; median 191.2; overhead: 15.9%


Sorting arrays of int with 488154.3 elements by Int32Order (average over 137 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.
    ArraySort_Primitive: mean 62.5~3.5    ns/item; median 50.8; overhead: 5.8%
      ParallelQuickSort: mean 12.3~1.2    ns/item; median 8.8; overhead: 26.6%
              QuickSort: mean 54.8~3      ns/item; median 45.2; overhead: 6.5%
       TopDownMergeSort: mean 60.9~3.2    ns/item; median 50.4; overhead: 5.9%
      BottomUpMergeSort: mean 61.5~3.3    ns/item; median 49.7; overhead: 5.9%
     DualPivotQuickSort: mean 55.4~3      ns/item; median 45.2; overhead: 6.4%
    AltTopDownMergeSort: mean 60.8~3.2    ns/item; median 50.0; overhead: 5.9%

Sorting arrays of uint with 488154.3 elements by UInt32Order (average over 137 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.
    ArraySort_Primitive: mean 64.1~3.6    ns/item; median 52.1; overhead: 5.7%
      ParallelQuickSort: mean 11.9~1.2    ns/item; median 8.6; overhead: 27.2%
              QuickSort: mean 54.8~3      ns/item; median 44.7; overhead: 6.5%
       TopDownMergeSort: mean 60.1~3.2    ns/item; median 49.7; overhead: 6.0%
      BottomUpMergeSort: mean 60.7~3.3    ns/item; median 49.2; overhead: 5.9%
     DualPivotQuickSort: mean 55.8~3      ns/item; median 46.0; overhead: 6.4%
    AltTopDownMergeSort: mean 60.2~3.2    ns/item; median 49.4; overhead: 6.0%

Sorting arrays of ulong with 488154.3 elements by UInt64Order (average over 137 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.
    ArraySort_Primitive: mean 64.1~3.6    ns/item; median 52.0; overhead: 6.1%
      ParallelQuickSort: mean 12.1~1.3    ns/item; median 8.7; overhead: 28.5%
              QuickSort: mean 55.2~3      ns/item; median 45.5; overhead: 7.0%
       TopDownMergeSort: mean 61.8~3.3    ns/item; median 51.0; overhead: 6.4%
      BottomUpMergeSort: mean 63.4~3.4    ns/item; median 51.4; overhead: 6.2%
     DualPivotQuickSort: mean 56.1~3.1    ns/item; median 45.8; overhead: 6.9%
    AltTopDownMergeSort: mean 62~3.3      ns/item; median 50.9; overhead: 6.4%

Sorting arrays of double with 488154.3 elements by DoubleOrdering (average over 137 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.
    ArraySort_Primitive: mean 74.2~4.3    ns/item; median 59.9; overhead: 6.5%
      ParallelQuickSort: mean 14.8~1.7    ns/item; median 10.1; overhead: 30.2%
              QuickSort: mean 61.3~3.3    ns/item; median 50.7; overhead: 7.7%
       TopDownMergeSort: mean 69.8~3.6    ns/item; median 57.8; overhead: 7.0%
      BottomUpMergeSort: mean 72.1~3.8    ns/item; median 58.3; overhead: 6.6%
     DualPivotQuickSort: mean 63.2~3.4    ns/item; median 51.8; overhead: 7.5%
    AltTopDownMergeSort: mean 69.3~3.7    ns/item; median 57.3; overhead: 7.0%

Sorting arrays of int with 488154.3 elements by ComparableOrdering<int> (average over 137 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.
ArraySort_OrderComparer: mean 93.4~5.2    ns/item; median 76.4; overhead: 5.2%
      ParallelQuickSort: mean 12.6~1.3    ns/item; median 9.1; overhead: 32.3%
              QuickSort: mean 55.3~3      ns/item; median 45.0; overhead: 8.5%
       TopDownMergeSort: mean 61.3~3.2    ns/item; median 50.7; overhead: 7.7%
      BottomUpMergeSort: mean 62.3~3.4    ns/item; median 50.5; overhead: 7.6%
     DualPivotQuickSort: mean 60.5~3.3    ns/item; median 49.9; overhead: 7.8%
    AltTopDownMergeSort: mean 61.9~3.3    ns/item; median 51.0; overhead: 7.7%

Sorting arrays of uint with 488154.3 elements by ComparableOrdering<uint> (average over 137 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.
ArraySort_OrderComparer: mean 104~6.2     ns/item; median 84.3; overhead: 4.8%
      ParallelQuickSort: mean 12.4~1.3    ns/item; median 8.9; overhead: 32.4%
              QuickSort: mean 56.3~3.1    ns/item; median 45.9; overhead: 8.4%
       TopDownMergeSort: mean 61.7~3.3    ns/item; median 51.3; overhead: 7.7%
      BottomUpMergeSort: mean 62.3~3.4    ns/item; median 50.3; overhead: 7.6%
     DualPivotQuickSort: mean 61.6~3.3    ns/item; median 50.9; overhead: 7.6%
    AltTopDownMergeSort: mean 61.8~3.3    ns/item; median 50.7; overhead: 7.7%

Sorting arrays of ulong with 488154.3 elements by ComparableOrdering<ulong> (average over 137 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.
ArraySort_OrderComparer: mean 97.2~5.4    ns/item; median 79.5; overhead: 5.1%
      ParallelQuickSort: mean 12.2~1.3    ns/item; median 8.8; overhead: 33.0%
              QuickSort: mean 55.3~3      ns/item; median 45.0; overhead: 8.6%
       TopDownMergeSort: mean 61.1~3.3    ns/item; median 50.2; overhead: 7.9%
      BottomUpMergeSort: mean 63.2~3.4    ns/item; median 51.4; overhead: 7.6%
     DualPivotQuickSort: mean 60.5~3.2    ns/item; median 49.8; overhead: 8.0%
    AltTopDownMergeSort: mean 61.4~3.3    ns/item; median 50.6; overhead: 7.9%

Sorting arrays of double with 488154.3 elements by ComparableOrdering<double> (average over 137 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.
ArraySort_OrderComparer: mean 165~9.1     ns/item; median 135.5; overhead: 3.5%
      ParallelQuickSort: mean 22.1~2.2    ns/item; median 16.1; overhead: 23.3%
              QuickSort: mean 107~5.9     ns/item; median 87.2; overhead: 5.4%
       TopDownMergeSort: mean 119~6.5     ns/item; median 100.0; overhead: 4.8%
      BottomUpMergeSort: mean 116~6.1     ns/item; median 96.8; overhead: 4.9%
     DualPivotQuickSort: mean 110~6.1     ns/item; median 89.7; overhead: 5.3%
    AltTopDownMergeSort: mean 117~6.4     ns/item; median 94.5; overhead: 4.8%

Sorting arrays of (int, int, int) with 488154.3 elements by SmallTupleOrder (average over 137 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.
ArraySort_OrderComparer: mean 142~7.9     ns/item; median 116.2; overhead: 7.9%
      ParallelQuickSort: mean 18~1.8      ns/item; median 13.2; overhead: 43.5%
              QuickSort: mean 86~4.7      ns/item; median 69.6; overhead: 12.7%
       TopDownMergeSort: mean 91.5~5      ns/item; median 74.8; overhead: 11.7%
      BottomUpMergeSort: mean 96.3~5      ns/item; median 80.4; overhead: 11.2%
     DualPivotQuickSort: mean 88.3~4.9    ns/item; median 72.2; overhead: 12.2%
    AltTopDownMergeSort: mean 91.5~4.9    ns/item; median 74.7; overhead: 11.8%

Sorting arrays of SampleClass with 488154.3 elements by SampleClassOrder (average over 137 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.
ArraySort_OrderComparer: mean 151~7       ns/item; median 126.7; overhead: 13.7%
      ParallelQuickSort: mean 23.2~2.3    ns/item; median 17.3; overhead: 50.9%
              QuickSort: mean 106~4.9     ns/item; median 89.1; overhead: 17.3%
       TopDownMergeSort: mean 122~5.6     ns/item; median 103.2; overhead: 16.0%
      BottomUpMergeSort: mean 135~5.6     ns/item; median 117.7; overhead: 13.7%
     DualPivotQuickSort: mean 111~5.1     ns/item; median 92.9; overhead: 16.9%
    AltTopDownMergeSort: mean 123~6.1     ns/item; median 103.8; overhead: 16.0%

Sorting arrays of (int, long, DateTime, string, Guid) with 488154.3 elements by BigTupleOrder (average over 137 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.
ArraySort_OrderComparer: mean 507~28      ns/item; median 415.8; overhead: 7.7%
      ParallelQuickSort: mean 44.7~4      ns/item; median 33.6; overhead: 50.7%
              QuickSort: mean 224~12      ns/item; median 183.7; overhead: 15.8%
       TopDownMergeSort: mean 297~16      ns/item; median 238.3; overhead: 12.4%
      BottomUpMergeSort: mean 311~17      ns/item; median 260.7; overhead: 11.8%
     DualPivotQuickSort: mean 252~14      ns/item; median 209.2; overhead: 14.3%
    AltTopDownMergeSort: mean 290~16      ns/item; median 236.2; overhead: 12.7%


Sorting arrays of int with 3635405.3 elements by Int32Order (average over 21 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.
    ArraySort_Primitive: mean 64.1~4.7    ns/item; median 58.6; overhead: 5.2%
      ParallelQuickSort: mean 10.3~0.83   ns/item; median 9.0; overhead: 26.2%
              QuickSort: mean 56.8~4.2    ns/item; median 51.4; overhead: 5.9%
       TopDownMergeSort: mean 64.3~4.6    ns/item; median 58.5; overhead: 5.2%
      BottomUpMergeSort: mean 65.5~4.7    ns/item; median 60.7; overhead: 5.2%
     DualPivotQuickSort: mean 57.7~4.2    ns/item; median 52.6; overhead: 5.8%
    AltTopDownMergeSort: mean 65.1~4.7    ns/item; median 59.0; overhead: 5.2%

Sorting arrays of uint with 3635405.3 elements by UInt32Order (average over 21 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.
    ArraySort_Primitive: mean 65.6~4.8    ns/item; median 60.0; overhead: 5.1%
      ParallelQuickSort: mean 10.3~0.82   ns/item; median 8.9; overhead: 25.9%
              QuickSort: mean 57.1~4.2    ns/item; median 51.7; overhead: 5.8%
       TopDownMergeSort: mean 63.6~4.6    ns/item; median 57.8; overhead: 5.3%
      BottomUpMergeSort: mean 64.8~4.6    ns/item; median 59.8; overhead: 5.2%
     DualPivotQuickSort: mean 58~4.3      ns/item; median 53.0; overhead: 5.8%
    AltTopDownMergeSort: mean 64.1~4.6    ns/item; median 58.4; overhead: 5.3%

Sorting arrays of ulong with 3635405.3 elements by UInt64Order (average over 21 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.
    ArraySort_Primitive: mean 65.7~4.8    ns/item; median 60.1; overhead: 5.8%
      ParallelQuickSort: mean 10.6~0.82   ns/item; median 9.8; overhead: 27.9%
              QuickSort: mean 57.7~4.2    ns/item; median 52.5; overhead: 6.5%
       TopDownMergeSort: mean 66.2~4.6    ns/item; median 60.1; overhead: 5.7%
      BottomUpMergeSort: mean 69.2~4.9    ns/item; median 64.3; overhead: 5.5%
     DualPivotQuickSort: mean 58.4~4.3    ns/item; median 53.6; overhead: 6.5%
    AltTopDownMergeSort: mean 67.1~4.8    ns/item; median 61.1; overhead: 5.7%

Sorting arrays of double with 3635405.3 elements by DoubleOrdering (average over 21 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.
    ArraySort_Primitive: mean 75.6~5.6    ns/item; median 69.2; overhead: 6.1%
      ParallelQuickSort: mean 12~0.94     ns/item; median 11.1; overhead: 29.4%
              QuickSort: mean 64.3~4.7    ns/item; median 58.4; overhead: 7.0%
       TopDownMergeSort: mean 74.1~5.3    ns/item; median 67.4; overhead: 6.2%
      BottomUpMergeSort: mean 79.4~6      ns/item; median 72.6; overhead: 6.5%
     DualPivotQuickSort: mean 66.2~4.8    ns/item; median 60.5; overhead: 6.9%
    AltTopDownMergeSort: mean 75.4~5.4    ns/item; median 68.1; overhead: 6.1%

Sorting arrays of int with 3635405.3 elements by ComparableOrdering<int> (average over 21 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.
ArraySort_OrderComparer: mean 96.1~7.1    ns/item; median 88.3; overhead: 4.7%
      ParallelQuickSort: mean 10.6~0.85   ns/item; median 9.1; overhead: 31.5%
              QuickSort: mean 57.7~4.3    ns/item; median 52.4; overhead: 7.5%
       TopDownMergeSort: mean 65.3~4.7    ns/item; median 59.5; overhead: 6.7%
      BottomUpMergeSort: mean 66.5~4.8    ns/item; median 61.6; overhead: 6.7%
     DualPivotQuickSort: mean 63.6~4.6    ns/item; median 57.7; overhead: 6.9%
    AltTopDownMergeSort: mean 65.8~4.7    ns/item; median 59.9; overhead: 6.7%

Sorting arrays of uint with 3635405.3 elements by ComparableOrdering<uint> (average over 21 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.
ArraySort_OrderComparer: mean 109~9.9     ns/item; median 96.7; overhead: 4.4%
      ParallelQuickSort: mean 10.7~0.84   ns/item; median 9.2; overhead: 31.2%
              QuickSort: mean 58.6~4.3    ns/item; median 53.0; overhead: 7.5%
       TopDownMergeSort: mean 65.5~4.6    ns/item; median 59.3; overhead: 6.7%
      BottomUpMergeSort: mean 66.2~4.7    ns/item; median 61.0; overhead: 6.7%
     DualPivotQuickSort: mean 64.7~4.8    ns/item; median 58.8; overhead: 6.8%
    AltTopDownMergeSort: mean 66~4.8      ns/item; median 60.2; overhead: 6.7%

Sorting arrays of ulong with 3635405.3 elements by ComparableOrdering<ulong> (average over 21 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.
ArraySort_OrderComparer: mean 100~7.3     ns/item; median 91.7; overhead: 4.7%
      ParallelQuickSort: mean 10.7~0.84   ns/item; median 9.4; overhead: 32.0%
              QuickSort: mean 57.8~4.2    ns/item; median 52.5; overhead: 7.9%
       TopDownMergeSort: mean 65.3~4.7    ns/item; median 59.3; overhead: 7.1%
      BottomUpMergeSort: mean 68.6~4.8    ns/item; median 63.9; overhead: 6.7%
     DualPivotQuickSort: mean 63.8~4.6    ns/item; median 58.3; overhead: 7.2%
    AltTopDownMergeSort: mean 66.6~4.8    ns/item; median 60.3; overhead: 6.9%

Sorting arrays of double with 3635405.3 elements by ComparableOrdering<double> (average over 21 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.
ArraySort_OrderComparer: mean 171~13      ns/item; median 157.3; overhead: 3.2%
      ParallelQuickSort: mean 19.5~1.5    ns/item; median 17.1; overhead: 22.8%
              QuickSort: mean 110~8.2     ns/item; median 100.0; overhead: 5.0%
       TopDownMergeSort: mean 124~9       ns/item; median 114.5; overhead: 4.4%
      BottomUpMergeSort: mean 124~8.7     ns/item; median 112.8; overhead: 4.3%
     DualPivotQuickSort: mean 113~8.4     ns/item; median 103.6; overhead: 4.8%
    AltTopDownMergeSort: mean 122~8.9     ns/item; median 115.2; overhead: 4.4%

Sorting arrays of (int, int, int) with 3635405.3 elements by SmallTupleOrder (average over 21 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.
ArraySort_OrderComparer: mean 147~11      ns/item; median 135.2; overhead: 7.0%
      ParallelQuickSort: mean 16.3~1.3    ns/item; median 14.2; overhead: 40.9%
              QuickSort: mean 88.1~6.5    ns/item; median 80.0; overhead: 11.1%
       TopDownMergeSort: mean 97.6~7.1    ns/item; median 89.3; overhead: 10.2%
      BottomUpMergeSort: mean 106~7.5     ns/item; median 97.9; overhead: 9.4%
     DualPivotQuickSort: mean 92.1~6.7    ns/item; median 84.2; overhead: 10.7%
    AltTopDownMergeSort: mean 101~7.3     ns/item; median 95.4; overhead: 10.2%

Sorting arrays of SampleClass with 3635405.3 elements by SampleClassOrder (average over 21 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.
ArraySort_OrderComparer: mean 203~10      ns/item; median 193.8; overhead: 15.6%
      ParallelQuickSort: mean 34.5~1.5    ns/item; median 32.8; overhead: 45.6%
              QuickSort: mean 140~7.2     ns/item; median 133.0; overhead: 17.3%
       TopDownMergeSort: mean 156~8.4     ns/item; median 146.9; overhead: 15.9%
      BottomUpMergeSort: mean 193~11      ns/item; median 177.6; overhead: 13.5%
     DualPivotQuickSort: mean 148~7.8     ns/item; median 140.0; overhead: 16.6%
    AltTopDownMergeSort: mean 155~8.3     ns/item; median 146.4; overhead: 16.0%

Sorting arrays of (int, long, DateTime, string, Guid) with 3635405.3 elements by BigTupleOrder (average over 21 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.
ArraySort_OrderComparer: mean 527~40      ns/item; median 480.6; overhead: 6.7%
      ParallelQuickSort: mean 41.5~3.2    ns/item; median 36.5; overhead: 48.1%
              QuickSort: mean 229~17      ns/item; median 208.6; overhead: 14.2%
       TopDownMergeSort: mean 314~23      ns/item; median 290.5; overhead: 10.8%
      BottomUpMergeSort: mean 325~24      ns/item; median 300.7; overhead: 10.5%
     DualPivotQuickSort: mean 263~19      ns/item; median 242.2; overhead: 12.8%
    AltTopDownMergeSort: mean 329~30      ns/item; median 285.2; overhead: 10.5%


int: 34.2ns/item
uint: 35.0ns/item
ulong: 34.9ns/item
double: 52.3ns/item
(int, int, int): 55.2ns/item
SampleClass: 68.2ns/item
(int, long, DateTime, string, Guid): 174.1ns/item

ArraySort: 85.3ns/item
ParallelQuickSort: 23.6ns/item
QuickSort: 50.4ns/item
TopDownMergeSort: 57.8ns/item
BottomUpMergeSort: 60.7ns/item
DualPivotQuickSort: 52.9ns/item
AltTopDownMergeSort: 57.6ns/item

OVERALL: 55.5ns/item