Add (*Set).FromJSON benchmarks and switch to post-accumulation sort.

Set deserialization with children in reverse order performs an insertion sort. Sets serialized by
structured-merge-diff are sorted, but in practice the serialization of sets is controlled by clients
and they can (intentionally or not) exercise this worst case. Switching to a bulk insert followed by
a sort appears to perform no worse in the best case (sorted) and is significantly better in the
worst case:

                                              │ master.bench │             bulk.bench              │
                                              │    sec/op    │   sec/op     vs base                │
SetFromJSON/children_in_ascending_order          1.338m ± 0%   1.316m ± 1%   -1.60% (p=0.001 n=10)
SetFromJSON/children_in_descending_order        20.520m ± 1%   1.356m ± 1%  -93.39% (p=0.000 n=10)
SetFromJSON/grandchildren_in_ascending_order     3.001m ± 1%   2.935m ± 1%   -2.20% (p=0.000 n=10)
SetFromJSON/grandchildren_in_descending_order   39.963m ± 0%   2.923m ± 1%  -92.69% (p=0.000 n=10)
geomean                                          7.575m        1.978m       -73.88%

                                              │ master.bench │              bulk.bench              │
                                              │     B/op     │     B/op      vs base                │
SetFromJSON/children_in_ascending_order         1.320Mi ± 0%   1.320Mi ± 0%        ~ (p=0.303 n=10)
SetFromJSON/children_in_descending_order        1.320Mi ± 0%   1.320Mi ± 0%   +0.00% (p=0.000 n=10)
SetFromJSON/grandchildren_in_ascending_order    2.512Mi ± 0%   2.512Mi ± 0%   +0.00% (p=0.001 n=10)
SetFromJSON/grandchildren_in_descending_order   2.908Mi ± 0%   2.512Mi ± 0%  -13.61% (p=0.000 n=10)
geomean                                         1.889Mi        1.821Mi        -3.59%

                                              │ master.bench │              bulk.bench               │
                                              │  allocs/op   │  allocs/op   vs base                  │
SetFromJSON/children_in_ascending_order          25.99k ± 0%   25.99k ± 0%        ~ (p=1.000 n=10) ¹
SetFromJSON/children_in_descending_order         25.99k ± 0%   25.99k ± 0%        ~ (p=1.000 n=10) ¹
SetFromJSON/grandchildren_in_ascending_order     69.24k ± 0%   69.24k ± 0%        ~ (p=1.000 n=10) ¹
SetFromJSON/grandchildren_in_descending_order    77.89k ± 0%   69.24k ± 0%  -11.10% (p=0.000 n=10)
geomean                                          43.68k        42.42k        -2.90%
¹ all samples are equal

Author: benluddy

fieldpath/serialize.go

@@ -19,6 +19,7 @@ package fieldpath
 import (
 	"bytes"
 	"io"
+	"slices"
 	"unsafe"
 
 	jsoniter "github.com/json-iterator/go"
@@ -204,34 +205,25 @@ func readIterV1(iter *jsoniter.Iterator) (children *Set, isMember bool) {
 			if children == nil {
 				children = &Set{}
 			}
-			m := &children.Members.members
-			// Since we expect that most of the time these will have been
-			// serialized in the right order, we just verify that and append.
-			appendOK := len(*m) == 0 || (*m)[len(*m)-1].Less(pe)
-			if appendOK {
-				*m = append(*m, pe)
-			} else {
-				children.Members.Insert(pe)
-			}
+			children.Members.members = append(children.Members.members, pe)
 		}
 		if grandchildren != nil {
 			if children == nil {
 				children = &Set{}
 			}
-			// Since we expect that most of the time these will have been
-			// serialized in the right order, we just verify that and append.
-			m := &children.Children.members
-			appendOK := len(*m) == 0 || (*m)[len(*m)-1].pathElement.Less(pe)
-			if appendOK {
-				*m = append(*m, setNode{pe, grandchildren})
-			} else {
-				*children.Children.Descend(pe) = *grandchildren
-			}
+			children.Children.members = append(children.Children.members, setNode{pe, grandchildren})
 		}
 		return true
 	})
 	if children == nil {
 		isMember = true
+	} else {
+		slices.SortFunc(children.Members.members, func(a, b PathElement) int {
+			return a.Compare(b)
+		})
+		slices.SortFunc(children.Children.members, func(a, b setNode) int {
+			return a.pathElement.Compare(b.pathElement)
+		})
 	}
 
 	return children, isMember

fieldpath/serialize_test.go

@@ -19,6 +19,7 @@ package fieldpath_test
 import (
 	"bytes"
 	"fmt"
+	"os"
 	"strings"
 	"testing"
 
@@ -330,3 +331,30 @@ func TestDropUnknown(t *testing.T) {
 		t.Errorf("Failed;\ngot:  %s\nwant: %s\n", b, expect)
 	}
 }
+
+func BenchmarkSetFromJSON(b *testing.B) {
+	for _, tc := range []struct {
+		name    string
+		fixture string
+	}{
+		{"children in ascending order", "testdata/set_ascending.json"},
+		{"children in descending order", "testdata/set_descending.json"},
+		{"grandchildren in ascending order", "testdata/set_ascending_grandchildren.json"},
+		{"grandchildren in descending order", "testdata/set_descending_grandchildren.json"},
+	} {
+		b.Run(tc.name, func(b *testing.B) {
+			data, err := os.ReadFile(tc.fixture)
+			if err != nil {
+				b.Fatal(err)
+			}
+
+			b.ResetTimer()
+			for range b.N {
+				x := NewSet()
+				if err := x.FromJSON(bytes.NewReader(data)); err != nil {
+					b.Fatal(err)
+				}
+			}
+		})
+	}
+}