invariants: fix non-inlined empty function call

internal/invalidating/iter.go

@@ -15,7 +15,7 @@ import (
 // MaybeWrapIfInvariants wraps some iterators with an invalidating iterator.
 // MaybeWrapIfInvariants does nothing in non-invariant builds.
 func MaybeWrapIfInvariants(iter base.InternalIterator) base.InternalIterator {
-	if invariants.Sometimes(10) {
+	if invariants.Enabled && invariants.Sometimes(10) {
 		return NewIter(iter)
 	}
 	return iter

internal/invariants/invariants.go

@@ -5,7 +5,6 @@
 package invariants
 
 import (
-	"math/rand/v2"
 	"runtime"
 
 	"github.com/cockroachdb/pebble/internal/buildtags"
@@ -22,13 +21,6 @@ const Enabled = buildtags.Race || buildtags.Invariants
 // RaceEnabled is true if we were built with the "race" build tag.
 const RaceEnabled = buildtags.Race
 
-// Sometimes returns true percent% of the time if invariants are Enabled (i.e.
-// we were built with the "invariants" or "race" build tags). Otherwise, always
-// returns false.
-func Sometimes(percent int) bool {
-	return Enabled && rand.Uint32N(100) < uint32(percent)
-}
-
 // UseFinalizers is true if we want to use finalizers for assertions around
 // object lifetime and cleanup. This happens when the invariants or tracing tags
 // are set, but we exclude race builds because we historically ran into some
@@ -43,7 +35,8 @@ const UseFinalizers = !buildtags.Race && (buildtags.Invariants || buildtags.Trac
 // bugs related to finalizers.
 //
 // This function is a no-op if UseFinalizers is false and it should inline to
-// nothing.
+// nothing. However, note that it might not inline so in very hot paths it's
+// best to check UseFinalizers first.
 func SetFinalizer(obj, finalizer interface{}) {
 	if UseFinalizers {
 		runtime.SetFinalizer(obj, finalizer)

internal/invariants/off.go

@@ -6,6 +6,13 @@
 
 package invariants
 
+// Sometimes returns true percent% of the time if invariants are Enabled (i.e.
+// we were built with the "invariants" or "race" build tags). Otherwise, always
+// returns false.
+func Sometimes(percent int) bool {
+	return false
+}
+
 // CloseChecker is used to check that objects are closed exactly once. It is
 // empty and does nothing in non-invariant builds.
 //

internal/invariants/on.go

@@ -6,6 +6,15 @@
 
 package invariants
 
+import "math/rand/v2"
+
+// Sometimes returns true percent% of the time if invariants are Enabled (i.e.
+// we were built with the "invariants" or "race" build tags). Otherwise, always
+// returns false.
+func Sometimes(percent int) bool {
+	return rand.Uint32N(100) < uint32(percent)
+}
+
 // CloseChecker is used to check that objects are closed exactly once. It is
 // empty and does nothing in non-invariant builds.
 //

objstorage/objstorageprovider/vfs_readable.go

@@ -49,12 +49,14 @@ func newFileReadable(
 		fs:              fs,
 		readaheadConfig: readaheadConfig,
 	}
-	invariants.SetFinalizer(r, func(obj interface{}) {
-		if obj.(*fileReadable).file != nil {
-			fmt.Fprintf(os.Stderr, "Readable was not closed")
-			os.Exit(1)
-		}
-	})
+	if invariants.UseFinalizers {
+		invariants.SetFinalizer(r, func(obj interface{}) {
+			if obj.(*fileReadable).file != nil {
+				fmt.Fprintf(os.Stderr, "Readable was not closed")
+				os.Exit(1)
+			}
+		})
+	}
 	return r, nil
 }
 
@@ -104,13 +106,14 @@ var _ objstorage.ReadHandle = (*vfsReadHandle)(nil)
 var readHandlePool = sync.Pool{
 	New: func() interface{} {
 		i := &vfsReadHandle{}
-		// Note: this is a no-op if invariants are disabled or race is enabled.
-		invariants.SetFinalizer(i, func(obj interface{}) {
-			if obj.(*vfsReadHandle).r != nil {
-				fmt.Fprintf(os.Stderr, "ReadHandle was not closed")
-				os.Exit(1)
-			}
-		})
+		if invariants.UseFinalizers {
+			invariants.SetFinalizer(i, func(obj interface{}) {
+				if obj.(*vfsReadHandle).r != nil {
+					fmt.Fprintf(os.Stderr, "ReadHandle was not closed")
+					os.Exit(1)
+				}
+			})
+		}
 		return i
 	},
 }

sstable/colblk/keyspan.go

@@ -336,12 +336,14 @@ func NewKeyspanIter(
 var keyspanIterPool = sync.Pool{
 	New: func() interface{} {
 		i := &KeyspanIter{}
-		invariants.SetFinalizer(i, func(obj interface{}) {
-			if i := obj.(*KeyspanIter); i.handle.Valid() {
-				fmt.Fprintf(os.Stderr, "KeyspanIter.handle is not nil: %#v\n", i.handle)
-				os.Exit(1)
-			}
-		})
+		if invariants.UseFinalizers {
+			invariants.SetFinalizer(i, func(obj interface{}) {
+				if i := obj.(*KeyspanIter); i.handle.Valid() {
+					fmt.Fprintf(os.Stderr, "KeyspanIter.handle is not nil: %#v\n", i.handle)
+					os.Exit(1)
+				}
+			})
+		}
 		return i
 	},
 }

sstable/colblk/uints.go

@@ -221,7 +221,7 @@ func (b *UintBuilder) Reset() {
 		b.stats.maximum = 0
 		// We could reset all values as a precaution, but it has a visible cost
 		// in benchmarks.
-		if invariants.Sometimes(50) {
+		if invariants.Enabled && invariants.Sometimes(50) {
 			for i := 0; i < b.array.n; i++ {
 				b.array.elems.set(i, math.MaxUint64)
 			}
@@ -302,7 +302,7 @@ func (b *UintBuilder) determineEncoding(rows int) (_ UintEncoding, deltaBase uin
 		// Note that b.stats.minimum includes all rows set so far so it might be
 		// strictly smaller than all values up to [rows]; but it is still a suitable
 		// base for b.stats.encoding.
-		if invariants.Sometimes(1) && rows > 0 {
+		if invariants.Enabled && invariants.Sometimes(1) && rows > 0 {
 			if enc, _ := b.recalculateEncoding(rows); enc != b.stats.encoding {
 				panic(fmt.Sprintf("fast and slow paths don't agree: %s vs %s", b.stats.encoding, enc))
 			}

sstable/reader_iter.go

@@ -155,16 +155,18 @@ func init() {
 	singleLevelIterRowBlockPool = sync.Pool{
 		New: func() interface{} {
 			i := &singleLevelIteratorRowBlocks{pool: &singleLevelIterRowBlockPool}
-			// Note: this is a no-op if invariants are disabled or race is enabled.
-			invariants.SetFinalizer(i, checkSingleLevelIterator[rowblk.IndexIter, *rowblk.IndexIter, rowblk.Iter, *rowblk.Iter])
+			if invariants.UseFinalizers {
+				invariants.SetFinalizer(i, checkSingleLevelIterator[rowblk.IndexIter, *rowblk.IndexIter, rowblk.Iter, *rowblk.Iter])
+			}
 			return i
 		},
 	}
 	twoLevelIterRowBlockPool = sync.Pool{
 		New: func() interface{} {
 			i := &twoLevelIteratorRowBlocks{pool: &twoLevelIterRowBlockPool}
-			// Note: this is a no-op if invariants are disabled or race is enabled.
-			invariants.SetFinalizer(i, checkTwoLevelIterator[rowblk.IndexIter, *rowblk.IndexIter, rowblk.Iter, *rowblk.Iter])
+			if invariants.UseFinalizers {
+				invariants.SetFinalizer(i, checkTwoLevelIterator[rowblk.IndexIter, *rowblk.IndexIter, rowblk.Iter, *rowblk.Iter])
+			}
 			return i
 		},
 	}
@@ -173,8 +175,9 @@ func init() {
 			i := &singleLevelIteratorColumnBlocks{
 				pool: &singleLevelIterColumnBlockPool,
 			}
-			// Note: this is a no-op if invariants are disabled or race is enabled.
-			invariants.SetFinalizer(i, checkSingleLevelIterator[colblk.IndexIter, *colblk.IndexIter, colblk.DataBlockIter, *colblk.DataBlockIter])
+			if invariants.UseFinalizers {
+				invariants.SetFinalizer(i, checkSingleLevelIterator[colblk.IndexIter, *colblk.IndexIter, colblk.DataBlockIter, *colblk.DataBlockIter])
+			}
 			return i
 		},
 	}
@@ -183,8 +186,9 @@ func init() {
 			i := &twoLevelIteratorColumnBlocks{
 				pool: &twoLevelIterColumnBlockPool,
 			}
-			// Note: this is a no-op if invariants are disabled or race is enabled.
-			invariants.SetFinalizer(i, checkTwoLevelIterator[colblk.IndexIter, *colblk.IndexIter, colblk.DataBlockIter, *colblk.DataBlockIter])
+			if invariants.UseFinalizers {
+				invariants.SetFinalizer(i, checkTwoLevelIterator[colblk.IndexIter, *colblk.IndexIter, colblk.DataBlockIter, *colblk.DataBlockIter])
+			}
 			return i
 		},
 	}

sstable/rowblk/rowblk_fragment_iter.go

@@ -64,8 +64,9 @@ var _ keyspan.FragmentIterator = (*fragmentIter)(nil)
 var fragmentBlockIterPool = sync.Pool{
 	New: func() interface{} {
 		i := &fragmentIter{}
-		// Note: this is a no-op if invariants are disabled or race is enabled.
-		invariants.SetFinalizer(i, checkFragmentBlockIterator)
+		if invariants.UseFinalizers {
+			invariants.SetFinalizer(i, checkFragmentBlockIterator)
+		}
 		return i
 	},
 }