treesteps: disable in non-invariants mode

Make the treesteps code only active in invariants mode, and add
minimal stubs for non-invariants builds. This will allow using
treesteps for iterators which are performance-sensitive.

Author: RaduBerinde

internal/treesteps/node_state.go

@@ -0,0 +1,42 @@
+// Copyright 2025 The LevelDB-Go and Pebble Authors. All rights reserved. Use
+// of this source code is governed by a BSD-style license that can be found in
+// the LICENSE file.
+
+//go:build !invariants
+
+package treesteps
+
+const Enabled = false
+
+type RecordingOption struct{}
+
+func MaxTreeDepth(maxTreeDepth int) RecordingOption { return RecordingOption{} }
+func MaxOpDepth(maxOpDepth int) RecordingOption     { return RecordingOption{} }
+
+func StartRecording(root Node, name string, opts ...RecordingOption) *Recording { return nil }
+
+func NodeUpdated(n Node, reason string) {}
+
+// Node must be implemented by every node in the hierarchy.
+type Node interface {
+	TreeStepsNode() NodeInfo
+}
+type NodeInfo struct{}
+
+func NodeInfof(format string, args ...any) NodeInfo                  { return NodeInfo{} }
+func (ni *NodeInfo) AddPropf(key string, format string, args ...any) {}
+func (ni *NodeInfo) AddChildren(nodes ...Node)                       {}
+
+type Recording struct{}
+
+func (r *Recording) Finish() Steps { return Steps{} }
+
+func IsRecording(n Node) bool { return false }
+
+type Op struct{}
+
+func StartOpf(node Node, format string, args ...any) *Op { return nil }
+func (op *Op) Updatef(format string, args ...any)        {}
+func (op *Op) Finishf(format string, args ...any)        {}
+
+func TreeToString(n Node) string { return "treesteps not supported in this build" }

internal/treesteps/tree_steps_off.go

@@ -2,18 +2,24 @@
 // of this source code is governed by a BSD-style license that can be found in
 // the LICENSE file.
 
+//go:build invariants
+
 package treesteps
 
 import (
 	"fmt"
 	"reflect"
 	"slices"
 	"strings"
+	"sync"
+	"sync/atomic"
 	"unicode"
 
 	"github.com/cockroachdb/pebble/internal/treeprinter"
 )
 
+const Enabled = true
+
 // StartRecording starts a new recording that captures step-by-step propagation
 // of operations and changes in a hierarchical structure.
 //
@@ -100,7 +106,7 @@ func NodeUpdated(n Node, reason string) {
 	}
 }
 
-// Node must be implemnented by every node in the hierarchy.
+// Node must be implemented by every node in the hierarchy.
 type Node interface {
 	TreeStepsNode() NodeInfo
 }
@@ -273,3 +279,60 @@ func treePrint(n Node, tp treeprinter.Node) {
 		treePrint(child, tpNode)
 	}
 }
+
+type nodeState struct {
+	recording *Recording
+	depth     int
+	node      Node
+	name      string
+
+	// ops currently running for this node.
+	ops []*Op
+}
+
+var mu struct {
+	sync.Mutex
+
+	recordingInProgress atomic.Bool
+	nodeMap             map[Node]*nodeState
+}
+
+func buildTree(n *nodeState) TreeNode {
+	var t TreeNode
+	info := n.node.TreeStepsNode()
+	n.name = info.name
+	t.Name = info.name
+	t.Properties = info.properties
+	if len(n.ops) > 0 {
+		t.Ops = make([]string, len(n.ops))
+		for i := range t.Ops {
+			t.Ops[i] = n.ops[i].details
+			if n.ops[i].state != "" {
+				t.Ops[i] += " " + n.ops[i].state
+			}
+		}
+	}
+	if n.depth < n.recording.maxTreeDepth {
+		for i := range info.children {
+			c := nodeStateLocked(n.recording, info.children[i])
+			c.depth = n.depth + 1
+			t.Children = append(t.Children, buildTree(c))
+		}
+	} else {
+		for range info.children {
+			t.Children = append(t.Children, TreeNode{Name: "..."})
+		}
+	}
+	return t
+}
+
+func nodeStateLocked(w *Recording, n Node) *nodeState {
+	ns, ok := mu.nodeMap[n]
+	if !ok {
+		ns = &nodeState{recording: w, node: n}
+		mu.nodeMap[n] = ns
+	} else if w != ns.recording {
+		panic(fmt.Sprintf("node %v part of multiple recordings", n))
+	}
+	return ns
+}

internal/treesteps/tree_steps.go renamed to internal/treesteps/tree_steps_on.go

@@ -130,6 +130,9 @@ func (t *SegmentTree) sum(nodeIdx int, x1, x2 int) (result int) {
 }
 
 func TestSegmentTree(t *testing.T) {
+	if !Enabled {
+		t.Skip("treesteps not available in this build")
+	}
 	var tree *SegmentTree
 	datadriven.RunTest(t, "testdata/segment_tree", func(t *testing.T, td *datadriven.TestData) string {
 		var r *Recording