working through model performance refactor

Author: daveshanley

datamodel/low/base/example.go

@@ -1,11 +1,12 @@
-// Copyright 2022 Princess B33f Heavy Industries / Dave Shanley
+// Copyright 2022-2026 Princess B33f Heavy Industries / Dave Shanley
 // SPDX-License-Identifier: MIT
 
 package base
 
 import (
 	"context"
 	"hash/maphash"
+	"sync"
 
 	"github.com/pb33f/libopenapi/datamodel/low"
 	"github.com/pb33f/libopenapi/index"
@@ -29,6 +30,8 @@ type Example struct {
 	RootNode        *yaml.Node
 	index           *index.SpecIndex
 	context         context.Context
+	nodeStore       sync.Map
+	reference       low.Reference
 	*low.Reference
 	low.NodeMap
 }
@@ -86,14 +89,21 @@ func (ex *Example) Hash() uint64 {
 // Build extracts extensions and example value
 func (ex *Example) Build(ctx context.Context, keyNode, root *yaml.Node, idx *index.SpecIndex) error {
 	ex.KeyNode = keyNode
-	ex.Reference = new(low.Reference)
+	ex.reference = low.Reference{}
+	ex.Reference = &ex.reference
 	if ok, _, ref := utils.IsNodeRefValue(root); ok {
 		ex.SetReference(ref, root)
 	}
 	root = utils.NodeAlias(root)
 	ex.RootNode = root
 	utils.CheckForMergeNodes(root)
-	ex.Nodes = low.ExtractNodes(ctx, root)
+	ex.nodeStore = sync.Map{}
+	ex.Nodes = &ex.nodeStore
+	if len(root.Content) > 0 {
+		ex.NodeMap.ExtractNodes(root, false)
+	} else {
+		ex.AddNode(root.Line, root)
+	}
 	ex.Extensions = low.ExtractExtensions(root)
 	ex.context = ctx
 	ex.index = idx
@@ -109,14 +119,7 @@ func (ex *Example) Build(ctx context.Context, keyNode, root *yaml.Node, idx *ind
 			ValueNode: vn,
 		}
 
-		// extract nodes for all value nodes down the tree.
-		expChildNodes := low.ExtractNodesRecursive(ctx, vn)
-		expChildNodes.Range(func(k, v interface{}) bool {
-			if arr, ko := v.([]*yaml.Node); ko {
-				ex.Nodes.Store(k, arr)
-			}
-			return true
-		})
+		low.MergeRecursiveNodesIfLineAbsent(ex.Nodes, vn)
 	}
 
 	// OpenAPI 3.2+ dataValue field
@@ -127,14 +130,7 @@ func (ex *Example) Build(ctx context.Context, keyNode, root *yaml.Node, idx *ind
 			ValueNode: dataVn,
 		}
 
-		// extract nodes for all dataValue nodes down the tree.
-		expChildNodes := low.ExtractNodesRecursive(ctx, dataVn)
-		expChildNodes.Range(func(k, v interface{}) bool {
-			if arr, ko := v.([]*yaml.Node); ko {
-				ex.Nodes.Store(k, arr)
-			}
-			return true
-		})
+		low.MergeRecursiveNodesIfLineAbsent(ex.Nodes, dataVn)
 	}
 
 	// OpenAPI 3.2+ serializedValue field

datamodel/low/base/example_bench_test.go

@@ -0,0 +1,64 @@
+// Copyright 2022-2026 Princess B33f Heavy Industries / Dave Shanley
+// SPDX-License-Identifier: MIT
+
+package base
+
+import (
+	"context"
+	"testing"
+
+	"github.com/pb33f/libopenapi/datamodel/low"
+	"github.com/pb33f/libopenapi/index"
+	"go.yaml.in/yaml/v4"
+)
+
+func benchmarkExampleRootNode(b *testing.B) *yaml.Node {
+	b.Helper()
+
+	yml := `summary: hot
+description: cakes
+value:
+  pizza:
+    kind: oven
+    toppings:
+      - cheese
+      - herbs
+  yummy:
+    yes: pizza
+dataValue:
+  payload:
+    nested:
+      flag: true
+serializedValue: '{"pizza":true}'
+x-cake:
+  sweet:
+    maybe: yes`
+
+	var root yaml.Node
+	if err := yaml.Unmarshal([]byte(yml), &root); err != nil {
+		b.Fatalf("failed to unmarshal benchmark example: %v", err)
+	}
+	if len(root.Content) == 0 || root.Content[0] == nil {
+		b.Fatal("failed to unmarshal benchmark example: empty root")
+	}
+	return root.Content[0]
+}
+
+func BenchmarkExample_Build(b *testing.B) {
+	rootNode := benchmarkExampleRootNode(b)
+	idx := index.NewSpecIndex(rootNode)
+	ctx := context.Background()
+
+	b.ReportAllocs()
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		var ex Example
+		if err := low.BuildModel(rootNode, &ex); err != nil {
+			b.Fatalf("build model failed: %v", err)
+		}
+		if err := ex.Build(ctx, nil, rootNode, idx); err != nil {
+			b.Fatalf("example build failed: %v", err)
+		}
+	}
+}

datamodel/low/base/example_test.go

@@ -280,3 +280,17 @@ serializedValue: '{"name":"John Doe","age":30,"active":true}'`
 	hash2 := n.Hash()
 	assert.NotEqual(t, hash1, hash2)
 }
+
+func TestExample_Build_ScalarRoot(t *testing.T) {
+	var scalar yaml.Node
+	require.NoError(t, yaml.Unmarshal([]byte("hello"), &scalar))
+
+	var ex Example
+	require.NoError(t, low.BuildModel(scalar.Content[0], &ex))
+	require.NoError(t, ex.Build(context.Background(), nil, scalar.Content[0], nil))
+
+	assert.NotNil(t, ex.Nodes)
+	nodes := ex.GetNodes()
+	assert.Len(t, nodes[scalar.Content[0].Line], 1)
+	assert.Equal(t, "hello", nodes[scalar.Content[0].Line][0].Value)
+}

datamodel/low/base/schema_build.go

@@ -277,7 +277,7 @@ func (s *Schema) Build(ctx context.Context, root *yaml.Node, idx *index.SpecInde
 	_, expLabel, expNode := utils.FindKeyNodeFullTop(ExampleLabel, root.Content)
 	if expNode != nil {
 		s.Example = low.NodeReference[*yaml.Node]{Value: expNode, KeyNode: expLabel, ValueNode: expNode}
-		mergeRecursiveNodesIfLineAbsent(s.Nodes, expNode)
+		low.MergeRecursiveNodesIfLineAbsent(s.Nodes, expNode)
 	}
 
 	_, expArrLabel, expArrNode := utils.FindKeyNodeFullTop(ExamplesLabel, root.Content)
@@ -292,7 +292,7 @@ func (s *Schema) Build(ctx context.Context, root *yaml.Node, idx *index.SpecInde
 				ValueNode: expArrNode,
 				KeyNode:   expArrLabel,
 			}
-			mergeRecursiveNodesIfLineAbsent(s.Nodes, expArrNode)
+			low.MergeRecursiveNodesIfLineAbsent(s.Nodes, expArrNode)
 		}
 	}
 
@@ -324,7 +324,7 @@ func (s *Schema) Build(ctx context.Context, root *yaml.Node, idx *index.SpecInde
 		discriminator.RootNode = discNode
 		discriminator.Nodes = low.ExtractNodes(ctx, discNode)
 		s.Discriminator = low.NodeReference[*Discriminator]{Value: &discriminator, KeyNode: discLabel, ValueNode: discNode}
-		appendRecursiveNodes(&discriminator, discNode)
+		low.AppendRecursiveNodes(&discriminator, discNode)
 	}
 
 	_, extDocLabel, extDocNode := utils.FindKeyNodeFullTop(ExternalDocsLabel, root.Content)

datamodel/low/base/schema_build_coverage_test.go

@@ -78,8 +78,8 @@ func TestResolveSchemaBuildInput_NilAndRefFailures(t *testing.T) {
 }
 
 func TestRecursiveSchemaNodeHelpers(t *testing.T) {
-	mergeRecursiveNodesIfLineAbsent(nil, nil)
-	appendRecursiveNodes(nil, nil)
+	low.MergeRecursiveNodesIfLineAbsent(nil, nil)
+	low.AppendRecursiveNodes(nil, nil)
 
 	var root yaml.Node
 	require.NoError(t, yaml.Unmarshal([]byte("example:\n  nested:\n    value: ok\n"), &root))
@@ -89,7 +89,7 @@ func TestRecursiveSchemaNodeHelpers(t *testing.T) {
 	blockedLine := node.Content[0].Line
 	dst.Store(blockedLine, []*yaml.Node{{Value: "existing"}})
 
-	mergeRecursiveNodesIfLineAbsent(&dst, node)
+	low.MergeRecursiveNodesIfLineAbsent(&dst, node)
 
 	_, blocked := dst.Load(blockedLine)
 	assert.True(t, blocked)
@@ -105,6 +105,6 @@ func TestRecursiveSchemaNodeHelpers(t *testing.T) {
 	assert.True(t, foundNested)
 
 	collector := &collectingAddNodes{}
-	appendRecursiveNodes(collector, node)
+	low.AppendRecursiveNodes(collector, node)
 	assert.NotEmpty(t, collector.lines)
 }

datamodel/low/base/schema_build_helpers.go

@@ -7,7 +7,6 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"sync"
 
 	"github.com/pb33f/libopenapi/datamodel/low"
 	"github.com/pb33f/libopenapi/index"
@@ -186,52 +185,6 @@ func assignBuiltSchemaList(ctx context.Context, labelNode, valueNode *yaml.Node,
 	return nil
 }
 
-func mergeRecursiveNodesIfLineAbsent(dst *sync.Map, node *yaml.Node) {
-	if dst == nil || node == nil {
-		return
-	}
-
-	blocked := make(map[int]bool)
-	known := make(map[int]bool)
-	nodeMap := &low.NodeMap{Nodes: dst}
-	walkRecursiveNodes(node, func(current *yaml.Node) {
-		line := current.Line
-		if !known[line] {
-			_, blocked[line] = dst.Load(line)
-			known[line] = true
-		}
-		if !blocked[line] {
-			nodeMap.AddNode(line, current)
-		}
-	})
-}
-
-func appendRecursiveNodes(dst low.AddNodes, node *yaml.Node) {
-	if dst == nil || node == nil {
-		return
-	}
-
-	walkRecursiveNodes(node, func(current *yaml.Node) {
-		dst.AddNode(current.Line, current)
-	})
-}
-
-func walkRecursiveNodes(node *yaml.Node, visit func(*yaml.Node)) {
-	if node == nil || visit == nil || node.Content == nil {
-		return
-	}
-
-	for i := 0; i < len(node.Content); i++ {
-		current := node.Content[i]
-		if current.Line != 0 {
-			visit(current)
-		}
-		if len(current.Content) > 0 {
-			walkRecursiveNodes(current, visit)
-		}
-	}
-}
-
 func resolveSchemaBuildInput(ctx context.Context, valueNode *yaml.Node, idx *index.SpecIndex, errFormat string) (resolvedSchemaBuildInput, error) {
 	resolved := resolvedSchemaBuildInput{
 		ctx:       ctx,

datamodel/low/node_map_merge.go

@@ -0,0 +1,59 @@
+// Copyright 2022-2026 Princess B33f Heavy Industries / Dave Shanley
+// SPDX-License-Identifier: MIT
+
+package low
+
+import (
+	"sync"
+
+	"go.yaml.in/yaml/v4"
+)
+
+// MergeRecursiveNodesIfLineAbsent walks a node tree and adds each discovered node to dst
+// unless that line already exists in the destination map.
+func MergeRecursiveNodesIfLineAbsent(dst *sync.Map, node *yaml.Node) {
+	if dst == nil || node == nil {
+		return
+	}
+
+	blocked := make(map[int]bool)
+	known := make(map[int]bool)
+	nodeMap := &NodeMap{Nodes: dst}
+	walkRecursiveNodes(node, func(current *yaml.Node) {
+		line := current.Line
+		if !known[line] {
+			_, blocked[line] = dst.Load(line)
+			known[line] = true
+		}
+		if !blocked[line] {
+			nodeMap.AddNode(line, current)
+		}
+	})
+}
+
+// AppendRecursiveNodes walks a node tree and appends each discovered node to dst.
+func AppendRecursiveNodes(dst AddNodes, node *yaml.Node) {
+	if dst == nil || node == nil {
+		return
+	}
+
+	walkRecursiveNodes(node, func(current *yaml.Node) {
+		dst.AddNode(current.Line, current)
+	})
+}
+
+func walkRecursiveNodes(node *yaml.Node, visit func(*yaml.Node)) {
+	if node == nil || visit == nil || node.Content == nil {
+		return
+	}
+
+	for i := 0; i < len(node.Content); i++ {
+		current := node.Content[i]
+		if current.Line != 0 {
+			visit(current)
+		}
+		if len(current.Content) > 0 {
+			walkRecursiveNodes(current, visit)
+		}
+	}
+}

datamodel/low/node_map_merge_test.go

@@ -0,0 +1,60 @@
+// Copyright 2022-2026 Princess B33f Heavy Industries / Dave Shanley
+// SPDX-License-Identifier: MIT
+
+package low
+
+import (
+	"sync"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"go.yaml.in/yaml/v4"
+)
+
+type collectingAddNodes struct {
+	lines []int
+}
+
+func (c *collectingAddNodes) AddNode(key int, _ *yaml.Node) {
+	c.lines = append(c.lines, key)
+}
+
+func TestNodeMapMergeHelpers(t *testing.T) {
+	MergeRecursiveNodesIfLineAbsent(nil, nil)
+	AppendRecursiveNodes(nil, nil)
+	walkRecursiveNodes(nil, nil)
+
+	var root yaml.Node
+	require.NoError(t, yaml.Unmarshal([]byte("example:\n  nested:\n    value: ok\n"), &root))
+	node := root.Content[0]
+
+	var dst sync.Map
+	blockedLine := node.Content[0].Line
+	dst.Store(blockedLine, []*yaml.Node{{Value: "existing"}})
+
+	MergeRecursiveNodesIfLineAbsent(&dst, node)
+
+	_, blocked := dst.Load(blockedLine)
+	assert.True(t, blocked)
+
+	var foundNested bool
+	dst.Range(func(key, value any) bool {
+		if key.(int) == node.Content[1].Content[0].Line {
+			foundNested = true
+		}
+		assert.NotNil(t, value)
+		return true
+	})
+	assert.True(t, foundNested)
+
+	collector := &collectingAddNodes{}
+	AppendRecursiveNodes(collector, node)
+	assert.NotEmpty(t, collector.lines)
+
+	var walked []int
+	walkRecursiveNodes(node, func(current *yaml.Node) {
+		walked = append(walked, current.Line)
+	})
+	assert.NotEmpty(t, walked)
+}