Added a high level cache.

high memory use is a problem in libopenapi, this change moves us a step closer to fixing that. Very reference heavy specs can create an ungodly number of schema proxy calls when the model is being walked.

For example the docusign spec create 4m proxy calls. This is not required as it’s the same ref being called over and over and we already have it after it’s been done once. This change adds a high level cache to prevent the over production of schemas.

Author: daveshanley

datamodel/high/base/schema_proxy.go

@@ -4,6 +4,7 @@
 package base
 
 import (
+	"fmt"
 	"sync"
 
 	"github.com/pb33f/libopenapi/datamodel/high"
@@ -90,15 +91,45 @@ func (sp *SchemaProxy) Schema() *Schema {
 	sp.lock.Lock()
 	if sp.rendered == nil {
 
+		//check the high-level cache first.
+		idx := sp.schema.Value.GetIndex()
+		if idx != nil && sp.schema.Value != nil {
+			if sp.schema.Value.IsReference() && sp.schema.Value.GetReferenceNode() != nil && sp.schema.GetValueNode() != nil {
+				loc := fmt.Sprintf("%s:%d:%d", idx.GetSpecAbsolutePath(), sp.schema.GetValueNode().Line, sp.schema.GetValueNode().Column)
+				if seen, ok := idx.GetHighCache().Load(loc); ok {
+					sp.lock.Unlock()
+					idx.HighCacheHit()
+					return seen.(*Schema)
+				} else {
+					idx.HighCacheMiss()
+				}
+			}
+		}
+
 		s := sp.schema.Value.Schema()
 		if s == nil {
 			sp.buildError = sp.schema.Value.GetBuildError()
 			sp.lock.Unlock()
 			return nil
 		}
 		sch := NewSchema(s)
-		sch.ParentProxy = sp
 
+		if idx != nil {
+
+			// only store the schema in the cache if is a reference!
+			if sp.IsReference() && sp.GetReferenceNode() != nil && sp.schema != nil && sp.schema.GetValueNode() != nil {
+				//if sp.schema.GetValueNode() != nil {
+				loc := fmt.Sprintf("%s:%d:%d", idx.GetSpecAbsolutePath(), sp.schema.GetValueNode().Line, sp.schema.GetValueNode().Column)
+
+				// caching is only performed on traditional $ref nodes with a reference and a value node, any 3.1 additional
+				// will not be cached as libopenapi does not yet support them.
+				if len(sp.GetReferenceNode().Content) == 2 {
+					idx.GetHighCache().Store(loc, sch)
+				}
+			}
+		}
+
+		sch.ParentProxy = sp
 		sp.rendered = sch
 		sp.lock.Unlock()
 		return sch

datamodel/low/base/schema_proxy.go

@@ -179,3 +179,8 @@ func (sp *SchemaProxy) AddNode(key int, node *yaml.Node) {
 		sp.Nodes.Store(key, node)
 	}
 }
+
+// GetIndex will return the index.SpecIndex pointer that was passed to the SchemaProxy during build.
+func (sp *SchemaProxy) GetIndex() *index.SpecIndex {
+	return sp.idx
+}

document_iteration_test.go

@@ -23,57 +23,96 @@ type context struct {
 	stack   []loopFrame
 }
 
+func BenchmarkMemory_Speakeasy(b *testing.B) {
+	// Tell the benchmark to report memory allocations
+	b.ReportAllocs()
+
+	// Run the benchmark the specified number of iterations
+	for i := 0; i < b.N; i++ {
+		runTest(nil, "test_specs/speakeasy-test.yaml")
+	}
+}
+
 func Test_Speakeasy_Document_Iteration(t *testing.T) {
-	spec, err := os.ReadFile("test_specs/speakeasy-test.yaml")
-	require.NoError(t, err)
+	runTest(t, "test_specs/speakeasy-test.yaml")
+}
+
+func runTest(t *testing.T, specLocation string) {
+	spec, err := os.ReadFile(specLocation)
+	if t != nil {
+		require.NoError(t, err)
+	}
 
 	doc, err := NewDocumentWithConfiguration(spec, &datamodel.DocumentConfiguration{
 		BasePath:                            "./test_specs",
 		IgnorePolymorphicCircularReferences: true,
 		IgnoreArrayCircularReferences:       true,
 		AllowFileReferences:                 true,
 	})
-	require.NoError(t, err)
+	if t != nil {
+		require.NoError(t, err)
+	}
 
 	m, errs := doc.BuildV3Model()
-	require.Empty(t, errs)
+	if t != nil {
+		require.Empty(t, errs)
+	}
 
 	for path, pathItem := range m.Model.Paths.PathItems.FromOldest() {
-		t.Log(path)
+		if t != nil {
+			t.Log(path)
+		}
 
 		iterateOperations(t, pathItem.GetOperations())
 	}
 
 	for path, pathItem := range m.Model.Webhooks.FromOldest() {
-		t.Log(path)
+		if t != nil {
+			t.Log(path)
+		}
 
 		iterateOperations(t, pathItem.GetOperations())
 	}
 
 	for name, schemaProxy := range m.Model.Components.Schemas.FromOldest() {
-		t.Log(name)
+		if t != nil {
+			t.Log(name)
+		}
 
 		handleSchema(t, schemaProxy, context{})
 	}
+
+	require.Equal(t, uint64(10), m.Index.GetHighCacheMisses())
+	require.Equal(t, uint64(11), m.Index.GetHighCacheHits())
+	require.Equal(t, uint64(101), m.Index.GetRolodex().GetIndexes()[0].GetHighCacheMisses())
+	require.Equal(t, uint64(206), m.Index.GetRolodex().GetIndexes()[0].GetHighCacheHits())
 }
 
 func iterateOperations(t *testing.T, ops *orderedmap.Map[string, *v3.Operation]) {
 	for method, op := range ops.FromOldest() {
-		t.Log(method)
+		if t != nil {
+			t.Log(method)
+		}
 
 		for i, param := range op.Parameters {
-			t.Log("param", i, param.Name)
+			if t != nil {
+				t.Log("param", i, param.Name)
+			}
 
 			if param.Schema != nil {
 				handleSchema(t, param.Schema, context{})
 			}
 		}
 
 		if op.RequestBody != nil {
-			t.Log("request body")
+			if t != nil {
+				t.Log("request body")
+			}
 
 			for contentType, mediaType := range op.RequestBody.Content.FromOldest() {
-				t.Log(contentType)
+				if t != nil {
+					t.Log(contentType)
+				}
 
 				if mediaType.Schema != nil {
 					handleSchema(t, mediaType.Schema, context{})
@@ -82,14 +121,20 @@ func iterateOperations(t *testing.T, ops *orderedmap.Map[string, *v3.Operation])
 		}
 
 		if orderedmap.Len(op.Responses.Codes) > 0 {
-			t.Log("responses")
+			if t != nil {
+				t.Log("responses")
+			}
 		}
 
 		for code, response := range op.Responses.Codes.FromOldest() {
-			t.Log(code)
+			if t != nil {
+				t.Log(code)
+			}
 
 			for contentType, mediaType := range response.Content.FromOldest() {
-				t.Log(contentType)
+				if t != nil {
+					t.Log(contentType)
+				}
 
 				if mediaType.Schema != nil {
 					handleSchema(t, mediaType.Schema, context{})
@@ -98,14 +143,20 @@ func iterateOperations(t *testing.T, ops *orderedmap.Map[string, *v3.Operation])
 		}
 
 		if orderedmap.Len(op.Responses.Codes) > 0 {
-			t.Log("callbacks")
+			if t != nil {
+				t.Log("callbacks")
+			}
 		}
 
 		for callbackName, callback := range op.Callbacks.FromOldest() {
-			t.Log(callbackName)
+			if t != nil {
+				t.Log(callbackName)
+			}
 
 			for name, pathItem := range callback.Expression.FromOldest() {
-				t.Log(name)
+				if t != nil {
+					t.Log(name)
+				}
 
 				iterateOperations(t, pathItem.GetOperations())
 			}
@@ -119,11 +170,15 @@ func handleSchema(t *testing.T, schProxy *base.SchemaProxy, ctx context) {
 	}
 
 	sch, err := schProxy.BuildSchema()
-	require.NoError(t, err)
+	if t != nil {
+		require.NoError(t, err)
+	}
 
 	typ, subTypes := getResolvedType(sch)
 
-	t.Log("schema", typ, subTypes)
+	if t != nil {
+		t.Log("schema", typ, subTypes)
+	}
 
 	if len(sch.Enum) > 0 {
 		switch typ {
@@ -278,7 +333,9 @@ func checkCircularReference(t *testing.T, ctx *context, schProxy *base.SchemaPro
 				isRestricted = true
 			}
 
-			require.False(t, isRestricted, "circular reference: %s", append(ctx.visited, loopRef))
+			if t != nil {
+				require.False(t, isRestricted, "circular reference: %s", append(ctx.visited, loopRef))
+			}
 			return true
 		}
 

index/cache.go

@@ -0,0 +1,40 @@
+// Copyright 2023-2024 Princess Beef Heavy Industries, LLC / Dave Shanley
+// https://pb33f.io
+
+package index
+
+import "sync"
+
+func (index *SpecIndex) SetCache(sync *sync.Map) {
+	index.cache = sync
+}
+
+// HighCacheHit increments the counter of high cache hits by one, and returns the current value of hits.
+func (index *SpecIndex) HighCacheHit() uint64 {
+	index.highModelCacheHits.Add(1)
+	return index.highModelCacheHits.Load()
+}
+
+// HighCacheMiss increments the counter of high cache misses by one, and returns the current value of misses.
+func (index *SpecIndex) HighCacheMiss() uint64 {
+	index.highModelCacheMisses.Add(1)
+	return index.highModelCacheMisses.Load()
+}
+
+// GetHighCacheHits returns the number of hits on the high model cache.
+func (index *SpecIndex) GetHighCacheHits() uint64 {
+	return index.highModelCacheHits.Load()
+}
+
+// GetHighCacheMisses returns the number of misses on the high model cache.
+func (index *SpecIndex) GetHighCacheMisses() uint64 {
+	return index.highModelCacheMisses.Load()
+}
+
+// GetHighCache returns the high model cache for this index.
+func (index *SpecIndex) GetHighCache() *sync.Map {
+	if index.highModelCache == nil {
+		index.highModelCache = &sync.Map{}
+	}
+	return index.highModelCache
+}