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     │                 bulk                 │
                                              │     sec/op     │    sec/op     vs base                │
SetFromJSON/children_in_ascending_order            1.286m ± 3%   1.341m ±  1%   +4.27% (p=0.000 n=10)
SetFromJSON/children_in_descending_order          20.189m ± 0%   1.385m ±  1%  -93.14% (p=0.000 n=10)
SetFromJSON/grandchildren_in_ascending_order       7.821m ± 1%   8.211m ±  1%   +4.98% (p=0.000 n=10)
SetFromJSON/grandchildren_in_descending_order      75.16m ± 4%   13.31m ± 13%  -82.28% (p=0.000 n=10)
geomean                                            11.11m        3.774m        -66.04%

                                              │     master     │                 bulk                 │
                                              │      B/op      │     B/op      vs base                │
SetFromJSON/children_in_ascending_order           1.320Mi ± 0%   1.320Mi ± 0%        ~ (p=1.000 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      5.395Mi ± 0%   5.395Mi ± 0%   +0.00% (p=0.000 n=10)
SetFromJSON/grandchildren_in_descending_order     6.187Mi ± 0%   5.395Mi ± 0%  -12.80% (p=0.000 n=10)
geomean                                           2.761Mi        2.668Mi        -3.37%

                                              │     master     │                 bulk                  │
                                              │   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       138.4k ± 0%   138.4k ± 0%        ~ (p=1.000 n=10) ¹
SetFromJSON/grandchildren_in_descending_order      155.7k ± 0%   138.4k ± 0%  -11.11% (p=0.000 n=10)
geomean                                            61.77k        59.98k        -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,40 @@ 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)
+		})
+		children.Members.members = slices.CompactFunc(children.Members.members, func(a, b PathElement) bool {
+			return a.Equals(b)
+		})
+		if children.Children.members != nil {
+			slices.SortStableFunc(children.Children.members, func(a, b setNode) int {
+				return a.pathElement.Compare(b.pathElement)
+			})
+			// Compact duplicates, keeping the last occurrence to preserve historical behavior:
+			var dst int
+			for src := 1; src < len(children.Children.members); src++ {
+				if !children.Children.members[dst].pathElement.Equals(children.Children.members[src].pathElement) {
+					dst++
+				}
+				children.Children.members[dst] = children.Children.members[src]
+			}
+			clear(children.Children.members[dst+1:])
+			children.Children.members = children.Children.members[:dst+1]
+		}
 	}
 
 	return children, isMember

fieldpath/serialize_test.go

@@ -19,6 +19,7 @@ package fieldpath_test
 import (
 	"bytes"
 	"fmt"
+	"os"
 	"strings"
 	"testing"
 
@@ -330,3 +331,55 @@ func TestDropUnknown(t *testing.T) {
 		t.Errorf("Failed;\ngot:  %s\nwant: %s\n", b, expect)
 	}
 }
+
+func TestDuplicateMembers(t *testing.T) {
+	s := NewSet()
+	if err := s.FromJSON(strings.NewReader(`{"f:":{},"f:":{}}`)); err != nil {
+		t.Fatal(err)
+	}
+	if size := s.Members.Size(); size != 1 {
+		t.Errorf("want 1 member, got %d", size)
+	}
+}
+
+func TestDuplicateChildren(t *testing.T) {
+	d := NewSet()
+	if err := d.FromJSON(strings.NewReader(`{"f:":{"f:":{".":{},"f:1":{}}},"f:":{"f:":{".":{},"f:2":{}}}}`)); err != nil {
+		t.Fatal(err)
+	}
+	s := NewSet()
+	if err := s.FromJSON(strings.NewReader(`{"f:":{"f:":{".":{},"f:2":{}}}}`)); err != nil {
+		t.Fatal(err)
+	}
+	if !d.Equals(s) {
+		// The last occurrence of the duplicated child set is preserved.
+		t.Fatalf("want:\n%s\ngot:\n%s", s, d)
+	}
+}
+
+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)
+				}
+			}
+		})
+	}
+}