reduce allocations for small maps

Author: lavalamp

fieldpath/serialize.go

@@ -143,19 +143,35 @@ func readIter_v1(iter *jsoniter.Iterator) (children *Set, isMember bool) {
 			if children == nil {
 				children = &Set{}
 			}
-			// TODO: append & sort afterwards
-			children.Members.Insert(pe)
+			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)
+			}
 		}
 		if grandchildren != nil {
 			if children == nil {
 				children = &Set{}
 			}
-			*children.Children.Descend(pe) = *grandchildren
+			// 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
+			}
 		}
 		return true
 	})
 	if children == nil {
 		isMember = true
 	}
+
 	return children, isMember
 }

fieldpath/set.go

@@ -173,9 +173,17 @@ type setNode struct {
 
 // SetNodeMap is a map of PathElement to subset.
 type SetNodeMap struct {
-	members []setNode
+	members sortedSetNode
 }
 
+type sortedSetNode []setNode
+
+// Implement the sort interface; this would permit bulk creation, which would
+// be faster than doing it one at a time via Insert.
+func (s sortedSetNode) Len() int           { return len(s) }
+func (s sortedSetNode) Less(i, j int) bool { return s[i].pathElement.Less(s[j].pathElement) }
+func (s sortedSetNode) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+
 // Descend adds pe to the set if necessary, returning the associated subset.
 func (s *SetNodeMap) Descend(pe PathElement) *Set {
 	loc := sort.Search(len(s.members), func(i int) bool {

value/value.go

@@ -173,7 +173,7 @@ type Map struct {
 	order []int
 }
 
-func (m *Map) computeOrder() {
+func (m *Map) computeOrder() []int {
 	if len(m.order) != len(m.Items) {
 		m.order = make([]int, len(m.Items))
 		for i := range m.order {
@@ -183,28 +183,67 @@ func (m *Map) computeOrder() {
 			return m.Items[m.order[i]].Name < m.Items[m.order[j]].Name
 		})
 	}
+	return m.order
 }
 
 // Less compares two maps lexically.
 func (m *Map) Less(rhs *Map) bool {
-	m.computeOrder()
-	rhs.computeOrder()
+	var noAllocL, noAllocR [2]int
+	var morder, rorder []int
+
+	// For very short maps (<2 elements) this permits us to avoid
+	// allocating the order array. We could make this accomodate larger
+	// maps, but 2 items should be enough to cover most path element
+	// comparisons, and at some point there will be diminishing returns.
+	// This has a large effect on the path element deserialization test,
+	// because everything is sorted / compared, but only once.
+	switch len(m.Items) {
+	case 0:
+		morder = noAllocL[0:0]
+	case 1:
+		morder = noAllocL[0:1]
+	case 2:
+		morder = noAllocL[0:2]
+		if m.Items[0].Name > m.Items[1].Name {
+			morder[0] = 1
+		} else {
+			morder[1] = 1
+		}
+	default:
+		morder = m.computeOrder()
+	}
+
+	switch len(rhs.Items) {
+	case 0:
+		rorder = noAllocR[0:0]
+	case 1:
+		rorder = noAllocR[0:1]
+	case 2:
+		rorder = noAllocR[0:2]
+		if rhs.Items[0].Name > rhs.Items[1].Name {
+			rorder[0] = 1
+		} else {
+			rorder[1] = 1
+		}
+	default:
+		rorder = rhs.computeOrder()
+	}
 
 	i := 0
 	for {
-		if i >= len(m.order) && i >= len(rhs.order) {
+		if i >= len(morder) && i >= len(rorder) {
 			// Maps are the same length and all items are equal.
 			return false
 		}
-		if i >= len(m.order) {
+		if i >= len(morder) {
 			// LHS is shorter.
 			return true
 		}
-		if i >= len(rhs.order) {
+		if i >= len(rorder) {
 			// RHS is shorter.
 			return false
 		}
-		fa, fb := &m.Items[m.order[i]], &rhs.Items[rhs.order[i]]
+		fa, fb := &m.Items[morder[i]], &rhs.Items[rorder[i]]
 		if fa.Name != fb.Name {
 			// the map having the field name that sorts lexically less is "less"
 			return fa.Name < fb.Name