slices: use pdqsort

Sync with CL 371574.

- pdqsort paper: https://arxiv.org/pdf/2106.05123.pdf
- C++ implementation: https://github.com/orlp/pdqsort
- Rust implementation: https://docs.rs/pdqsort/latest/pdqsort/

For golang/go#50154

name                       old time/op  new time/op  delta
SortInts-16                10.8ms ± 3%  10.8ms ± 3%     ~     (p=0.461 n=20+20)
SlicesSortInts-16          6.14ms ± 3%  6.29ms ± 3%   +2.43%  (p=0.000 n=20+19)
SlicesSortInts_Sorted-16   1.78ms ± 4%  0.09ms ± 2%  -95.01%  (p=0.000 n=18+20)
SlicesSortInts_Reversed-16 1.82ms ± 5%  0.13ms ± 2%  -92.67%  (p=0.000 n=20+20)
SortStrings-16             23.0ms ± 2%  23.1ms ± 1%     ~     (p=0.253 n=20+20)
SlicesSortStrings-16       19.1ms ± 2%  19.0ms ± 2%     ~     (p=0.270 n=20+19)
SortStructs-16             15.7ms ± 4%  15.7ms ± 3%     ~     (p=0.989 n=20+20)
SortFuncStructs-16         13.6ms ± 1%  12.7ms ± 3%   -6.39%  (p=0.000 n=19+20)

Change-Id: Ia563fe1c70d6d2ac098a97e1f870040d038cf61c
Reviewed-on: https://go-review.googlesource.com/c/exp/+/399315
Reviewed-by: Keith Randall <[email protected]>
Run-TryBot: Keith Randall <[email protected]>
Auto-Submit: Keith Randall <[email protected]>
Reviewed-by: Keith Randall <[email protected]>
TryBot-Result: Gopher Robot <[email protected]>
Reviewed-by: Eli Bendersky <[email protected]>

Author: zhangyunhao116

slices/sort.go

@@ -4,19 +4,30 @@
 
 package slices
 
-import "golang.org/x/exp/constraints"
+import (
+	"math/bits"
+
+	"golang.org/x/exp/constraints"
+)
 
 // Sort sorts a slice of any ordered type in ascending order.
+// Sort may fail to sort correctly when sorting slices of floating-point
+// numbers containing Not-a-number (NaN) values.
+// 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)
-	quickSortOrdered(x, 0, n, maxDepth(n))
+	pdqsortOrdered(x, 0, n, bits.Len(uint(n)))
 }
 
-// Sort sorts the slice x in ascending order as determined by the less function.
+// SortFunc sorts the slice x in ascending order as determined by the less function.
 // This sort is not guaranteed to be stable.
+//
+// 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)
-	quickSortLessFunc(x, 0, n, maxDepth(n), less)
+	pdqsortLessFunc(x, 0, n, bits.Len(uint(n)), less)
 }
 
 // SortStable sorts the slice x while keeping the original order of equal
@@ -76,16 +87,6 @@ func BinarySearchFunc[E any](x []E, target E, cmp func(E, E) int) (int, bool) {
 	}
 }
 
-// maxDepth returns a threshold at which quicksort should switch
-// to heapsort. It returns 2*ceil(lg(n+1)).
-func maxDepth(n int) int {
-	var depth int
-	for i := n; i > 0; i >>= 1 {
-		depth++
-	}
-	return depth * 2
-}
-
 func search(n int, f func(int) bool) int {
 	// Define f(-1) == false and f(n) == true.
 	// Invariant: f(i-1) == false, f(j) == true.
@@ -102,3 +103,25 @@ func search(n int, f func(int) bool) int {
 	// i == j, f(i-1) == false, and f(j) (= f(i)) == true  =>  answer is i.
 	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 (r *xorshift) Next() uint64 {
+	*r ^= *r << 13
+	*r ^= *r >> 17
+	*r ^= *r << 5
+	return uint64(*r)
+}
+
+func nextPowerOfTwo(length int) uint {
+	return 1 << bits.Len(uint(length))
+}

slices/sort_benchmark_test.go

@@ -22,6 +22,22 @@ func makeRandomInts(n int) []int {
 	return ints
 }
 
+func makeSortedInts(n int) []int {
+	ints := make([]int, n)
+	for i := 0; i < n; i++ {
+		ints[i] = i
+	}
+	return ints
+}
+
+func makeReversedInts(n int) []int {
+	ints := make([]int, n)
+	for i := 0; i < n; i++ {
+		ints[i] = n - i
+	}
+	return ints
+}
+
 const N = 100_000
 
 func BenchmarkSortInts(b *testing.B) {
@@ -42,6 +58,24 @@ func BenchmarkSlicesSortInts(b *testing.B) {
 	}
 }
 
+func BenchmarkSlicesSortInts_Sorted(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		b.StopTimer()
+		ints := makeSortedInts(N)
+		b.StartTimer()
+		Sort(ints)
+	}
+}
+
+func BenchmarkSlicesSortInts_Reversed(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		b.StopTimer()
+		ints := makeReversedInts(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) {

slices/sort_test.go

@@ -7,13 +7,15 @@ package slices
 import (
 	"math"
 	"math/rand"
+	"sort"
 	"strconv"
 	"strings"
 	"testing"
 )
 
 var ints = [...]int{74, 59, 238, -784, 9845, 959, 905, 0, 0, 42, 7586, -5467984, 7586}
-var float64s = [...]float64{74.3, 59.0, math.Inf(1), 238.2, -784.0, 2.3, math.NaN(), math.NaN(), math.Inf(-1), 9845.768, -959.7485, 905, 7.8, 7.8}
+var float64s = [...]float64{74.3, 59.0, math.Inf(1), 238.2, -784.0, 2.3, math.Inf(-1), 9845.768, -959.7485, 905, 7.8, 7.8, 74.3, 59.0, math.Inf(1), 238.2, -784.0, 2.3}
+var float64sWithNaNs = [...]float64{74.3, 59.0, math.Inf(1), 238.2, -784.0, 2.3, math.NaN(), math.NaN(), math.Inf(-1), 9845.768, -959.7485, 905, 7.8, 7.8}
 var strs = [...]string{"", "Hello", "foo", "bar", "foo", "f00", "%*&^*&^&", "***"}
 
 func TestSortIntSlice(t *testing.T) {
@@ -43,6 +45,24 @@ func TestSortFloat64Slice(t *testing.T) {
 	}
 }
 
+func TestSortFloat64SliceWithNaNs(t *testing.T) {
+	data := float64sWithNaNs[:]
+	input := make([]float64, len(float64sWithNaNs))
+	for i := range input {
+		input[i] = float64sWithNaNs[i]
+	}
+	// Make sure Sort doesn't panic when the slice contains NaNs.
+	Sort(data)
+	// Check whether the result is a permutation of the input.
+	sort.Float64s(data)
+	sort.Float64s(input)
+	for i, v := range input {
+		if data[i] != v && !(math.IsNaN(data[i]) && math.IsNaN(v)) {
+			t.Fatalf("the result is not a permutation of the input\ngot %v\nwant %v", data, input)
+		}
+	}
+}
+
 func TestSortStringSlice(t *testing.T) {
 	data := strs[:]
 	Sort(data)