x/tools/go/types/objectpath: reduce allocations with sync.Pool

[ewhauser]

Summary

The objectpath.Encoder.For() function allocates heavily, causing significant GC pressure in tools that call it frequently (e.g., static analyzers like nilaway that compute object paths for cross-package inference).

Problem

Profiling nogo with ~40 analyzers on a large monorepo (~9000 packages) revealed that objectpath functions consumed 504MB (60%) of allocations on hot packages:

271MB (32%) objectpath.(*finder).find
101MB (12%) strconv.AppendInt
68MB (8%) objectpath.(*Encoder).For
65MB (8%) objectpath.appendOpArg

The main allocation sources are:

1. make([]byte, 0, 48) in Encoder.For() - allocated per call
2. strconv.AppendInt in appendOpArg - allocates for each method/field index
3. &finder{} in find() - new struct per search with lazily-allocated maps

Proposed Solution

1. Pool path buffers using sync.Pool instead of allocating per call
2. Pre-compute small integers (0-99) to avoid strconv.AppendInt for common indices
3. Pool finder structs with pre-allocated maps, using clear() to reset between uses

Results

On a package with heavy objectpath usage:

Metric	Before	After	Improvement
Allocations	929MB	445MB	52% reduction
GC cycles	21	14	33% reduction
GC pause	1.77ms	0.81ms	54% reduction

After the change, objectpath functions no longer appear in the top allocators.

Patch

I have a working patch ready to submit as a PR. The changes are backward-compatible and do not change any public APIs.

/cc @adonovan @findleyr

[ewhauser]

Proposed Patch

diff --git a/go/types/objectpath/objectpath.go b/go/types/objectpath/objectpath.go
index 6646bf5..a3e1b3a 100644
--- a/go/types/objectpath/objectpath.go
+++ b/go/types/objectpath/objectpath.go
@@ -28,11 +28,30 @@ import (
 	"go/types"
 	"strconv"
 	"strings"
+	"sync"
 
 	"golang.org/x/tools/internal/aliases"
 	"golang.org/x/tools/internal/typesinternal"
 )
 
+// pathBufPool reduces allocations by reusing path buffers.
+var pathBufPool = sync.Pool{
+	New: func() interface{} {
+		buf := make([]byte, 0, 128)
+		return &buf
+	},
+}
+
+// smallInts contains pre-computed string representations of integers 0-99
+// to avoid strconv.AppendInt allocations for common method/field indices.
+var smallInts [100]string
+
+func init() {
+	for i := range smallInts {
+		smallInts[i] = strconv.Itoa(i)
+	}
+}
+
 // TODO(adonovan): think about generic aliases.
 
 // A Path is an opaque name that identifies a types.Object
@@ -268,7 +287,12 @@ func (enc *Encoder) For(obj types.Object) (Path, error) {
 	// In the presence of path aliases, these give
 	// the best paths because non-types may
 	// refer to types, but not the reverse.
-	empty := make([]byte, 0, 48) // initial space
+
+	// Get a buffer from the pool to reduce allocations.
+	bufPtr := pathBufPool.Get().(*[]byte)
+	empty := (*bufPtr)[:0]
+	defer pathBufPool.Put(bufPtr)
+
 	objs := enc.scopeObjects(scope)
 	for _, o := range objs {
 		tname, ok := o.(*types.TypeName)
@@ -344,7 +368,12 @@ func (enc *Encoder) For(obj types.Object) (Path, error) {
 
 func appendOpArg(path []byte, op byte, arg int) []byte {
 	path = append(path, op)
-	path = strconv.AppendInt(path, int64(arg), 10)
+	// Use pre-computed strings for small integers to avoid allocations.
+	if arg >= 0 && arg < len(smallInts) {
+		path = append(path, smallInts[arg]...)
+	} else {
+		path = strconv.AppendInt(path, int64(arg), 10)
+	}
 	return path
 }
 
@@ -443,6 +472,16 @@ func (enc *Encoder) concreteMethod(meth *types.Func) (Path, bool) {
 	// panic(fmt.Sprintf("couldn't find method %s on type %s; methods: %#v", meth, named, enc.namedMethods(named)))
 }
 
+// finderPool reduces allocations by reusing finder structs.
+var finderPool = sync.Pool{
+	New: func() interface{} {
+		return &finder{
+			seenTParamNames: make(map[*types.TypeName]bool),
+			seenMethods:     make(map[*types.Func]bool),
+		}
+	},
+}
+
 // find finds obj within type T, returning the path to it, or nil if not found.
 //
 // The seen map is used to short circuit cycles through type parameters. If
@@ -455,7 +494,14 @@ func (enc *Encoder) concreteMethod(meth *types.Func) (Path, bool) {
 //
 // See golang/go#68046 for details.
 func find(obj types.Object, T types.Type, path []byte) []byte {
-	return (&finder{obj: obj}).find(T, path)
+	f := finderPool.Get().(*finder)
+	f.obj = obj
+	// Clear maps but keep allocated backing storage
+	clear(f.seenTParamNames)
+	clear(f.seenMethods)
+	result := f.find(T, path)
+	finderPool.Put(f)
+	return result
 }
 
 // finder closes over search state for a call to find.
@@ -561,7 +607,13 @@ func (f *finder) find(T types.Type, path []byte) []byte {
 }
 
 func findTypeParam(obj types.Object, list *types.TypeParamList, path []byte, op byte) []byte {
-	return (&finder{obj: obj}).findTypeParam(list, path, op)
+	f := finderPool.Get().(*finder)
+	f.obj = obj
+	clear(f.seenTParamNames)
+	clear(f.seenMethods)
+	result := f.findTypeParam(list, path, op)
+	finderPool.Put(f)
+	return result
 }
 
 func (f *finder) findTypeParam(list *types.TypeParamList, path []byte, op byte) []byte {

Happy to submit this as a PR once the issue is triaged.

[gabyhelp]

Related Issues

• x/tools/go/types/objectpath: add Encoder type, to amortize Scope.Names #58668 (closed)
• x/tools/go/types/objectpath: frequent use of scope.Names burns significant cycles #51017 (closed)

Related Code Changes

• go/types: speed up ExprString by using sync.Pool

_{(Emoji vote if this was helpful or unhelpful; more detailed feedback welcome in this discussion.)}

[Jorropo]

If you already have a fix feel free to always send a PR along with your issue.

[ewhauser]

Thanks - here you go: golang/tools#613

[gopherbot]

Change https://go.dev/cl/734140 mentions this issue: go/types/objectpath: reduce allocations with sync.Pool

[JunyangShao]

@golang/tools-team