slices: use dual-pivot quicksort

Dual-pivot quicksort has smaller recursion depth.
Some pattern-defeating technique is added to make this variant.

And use double reversion instead of blockswap for symmerge.

Benchmark results on Xeon-8372C
name                          old time/op   new time/op   delta
SlicesSortInts-4              7.01ms ± 0%  5.84ms ± 0%  -16.64%  (p=0.000 n=10+10)
SlicesSortInts_Sorted-4       80.1µs ± 1%  69.1µs ± 0%  -13.76%  (p=0.000 n=8+10)
SlicesSortInts_Reversed-4      116µs ± 1%   108µs ± 0%   -6.72%  (p=0.000 n=10+10)
SlicesSortInts_Mixed-4        5.36ms ± 0%  4.31ms ± 0%  -19.53%  (p=0.000 n=10+9)
SlicesSortStrings-4           22.5ms ± 0%  20.9ms ± 1%   -7.12%  (p=0.000 n=10+10)
SortFuncStructs-4             13.4ms ± 1%  12.5ms ± 1%   -7.00%  (p=0.000 n=10+10)
SortFuncStructs_Stable-4      31.1ms ± 1%  30.7ms ± 1%   -1.25%  (p=0.000 n=10+10)

For golang/go#52789

Author: PeterRK

slices/sort.go

@@ -16,8 +16,12 @@ import (
 // Use slices.SortFunc(x, func(a, b float64) bool {return a < b || (math.IsNaN(a) && !math.IsNaN(b))})
 // instead if the input may contain NaNs.
 func Sort[E constraints.Ordered](x []E) {
-	n := len(x)
-	pdqsortOrdered(x, 0, n, bits.Len(uint(n)))
+	sortFast(x)
+}
+
+// SortStable sorts the slice x while keeping the original order of equal
+func SortStable[E constraints.Ordered](x []E) {
+	sortStable(x)
 }
 
 // SortFunc sorts the slice x in ascending order as determined by the less function.
@@ -26,14 +30,13 @@ func Sort[E constraints.Ordered](x []E) {
 // SortFunc requires that less is a strict weak ordering.
 // See https://en.wikipedia.org/wiki/Weak_ordering#Strict_weak_orderings.
 func SortFunc[E any](x []E, less func(a, b E) bool) {
-	n := len(x)
-	pdqsortLessFunc(x, 0, n, bits.Len(uint(n)), less)
+	lessFunc[E](less).sortFast(x)
 }
 
 // SortStable sorts the slice x while keeping the original order of equal
 // elements, using less to compare elements.
 func SortStableFunc[E any](x []E, less func(a, b E) bool) {
-	stableLessFunc(x, len(x), less)
+	lessFunc[E](less).sortStable(x)
 }
 
 // IsSorted reports whether x is sorted in ascending order.
@@ -104,24 +107,27 @@ func search(n int, f func(int) bool) int {
 	return i
 }
 
-type sortedHint int // hint for pdqsort when choosing the pivot
-
-const (
-	unknownHint sortedHint = iota
-	increasingHint
-	decreasingHint
-)
-
-// xorshift paper: https://www.jstatsoft.org/article/view/v008i14/xorshift.pdf
-type xorshift uint64
+func log2Ceil(num uint) int {
+	return bits.Len(num)
+}
 
-func (r *xorshift) Next() uint64 {
-	*r ^= *r << 13
-	*r ^= *r >> 17
-	*r ^= *r << 5
-	return uint64(*r)
+func reverse[E any](list []E) {
+	for l, r := 0, len(list)-1; l < r; {
+		list[l], list[r] = list[r], list[l]
+		l++
+		r--
+	}
 }
 
-func nextPowerOfTwo(length int) uint {
-	return 1 << bits.Len(uint(length))
+// With small E, double reversion is faster than the BlockSwap rotation.
+// BlockSwap rotation needs less swaps, but more branches.
+func rotate[E any](list []E, border int) {
+	reverse(list[:border])
+	reverse(list[border:])
+	reverse(list)
 }
+
+const (
+	hintSorted uint8 = 1 << iota
+	hintRevered
+)

slices/sort_benchmark_test.go

@@ -14,27 +14,50 @@ import (
 // These benchmarks compare sorting a large slice of int with sort.Ints vs.
 // slices.Sort
 func makeRandomInts(n int) []int {
-	rand.Seed(42)
 	ints := make([]int, n)
-	for i := 0; i < n; i++ {
+	fillRandomInts(ints)
+	return ints
+}
+
+func fillRandomInts(ints []int) {
+	rand.Seed(42)
+	n := len(ints)
+	for i := 0; i < len(ints); i++ {
 		ints[i] = rand.Intn(n)
 	}
-	return ints
 }
 
 func makeSortedInts(n int) []int {
 	ints := make([]int, n)
-	for i := 0; i < n; i++ {
+	fillSortedInts(ints)
+	return ints
+}
+
+func fillSortedInts(ints []int) {
+	for i := 0; i < len(ints); i++ {
 		ints[i] = i
 	}
-	return ints
 }
 
 func makeReversedInts(n int) []int {
 	ints := make([]int, n)
+	fillReversedInts(ints)
+	return ints
+}
+
+func fillReversedInts(ints []int) {
+	n := len(ints)
 	for i := 0; i < n; i++ {
 		ints[i] = n - i
 	}
+}
+
+func makeMixedInts(n int) []int {
+	ints := make([]int, n)
+	m := n / 3
+	fillSortedInts(ints[:m])
+	fillRandomInts(ints[m : n-m])
+	fillReversedInts(ints[n-m:])
 	return ints
 }
 
@@ -76,6 +99,15 @@ func BenchmarkSlicesSortInts_Reversed(b *testing.B) {
 	}
 }
 
+func BenchmarkSlicesSortInts_Mixed(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		b.StopTimer()
+		ints := makeMixedInts(N)
+		b.StartTimer()
+		Sort(ints)
+	}
+}
+
 // Since we're benchmarking these sorts against each other, make sure that they
 // generate similar results.
 func TestIntSorts(t *testing.T) {
@@ -191,12 +223,31 @@ func BenchmarkSortStructs(b *testing.B) {
 	}
 }
 
+func BenchmarkSortStructs_Stable(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		b.StopTimer()
+		ss := makeRandomStructs(N)
+		b.StartTimer()
+		sort.Stable(ss)
+	}
+}
+
 func BenchmarkSortFuncStructs(b *testing.B) {
-	lessFunc := func(a, b *myStruct) bool { return a.n < b.n }
+	less := func(a, b *myStruct) bool { return a.n < b.n }
+	for i := 0; i < b.N; i++ {
+		b.StopTimer()
+		ss := makeRandomStructs(N)
+		b.StartTimer()
+		SortFunc(ss, less)
+	}
+}
+
+func BenchmarkSortFuncStructs_Stable(b *testing.B) {
+	less := func(a, b *myStruct) bool { return a.n < b.n }
 	for i := 0; i < b.N; i++ {
 		b.StopTimer()
 		ss := makeRandomStructs(N)
 		b.StartTimer()
-		SortFunc(ss, lessFunc)
+		SortStableFunc(ss, less)
 	}
 }

slices/sort_test.go

@@ -90,6 +90,22 @@ func TestSortLarge_Random(t *testing.T) {
 	}
 }
 
+// It's hard to run heapSort from API, test it alone
+func TestHeapSort(t *testing.T) {
+	n := 100
+	data := make([]int, n)
+	for i := 0; i < len(data); i++ {
+		data[i] = rand.Intn(n)
+	}
+	if IsSorted(data) {
+		t.Fatalf("terrible rand.rand")
+	}
+	heapSort(data)
+	if !IsSorted(data) {
+		t.Errorf("heapsort didn't sort - 100 ints")
+	}
+}
+
 type intPair struct {
 	a, b int
 }