sql/tests: speed-up sysbench micro-benchmarks

The sysbench micro-benchmarks have been sped up by avoiding repeatedly
setting up a new cluster while Go's benchmarking harness ramps up `b.N`.
Prior to this commit the benchmark command below took ~112 seconds and
now takes ~36 seconds on my Mac M1 Pro.

    ./dev bench pkg/sql/tests \
      -f 'BenchmarkSysbench/SQL/1node_local/oltp_point_select' \
      --count 3

See the inline comments for more details.

Release note: None

Author: mgartner

pkg/sql/tests/sysbench_test.go

@@ -863,41 +863,50 @@ func benchmarkSysbenchImpl(b *testing.B, parallel bool) {
 	for _, driver := range drivers {
 		b.Run(driver.name, func(b *testing.B) {
 			for _, workload := range workloads {
+				var sys sysbenchDriver
+				var cleanup func()
 				b.Run(workload.name, func(b *testing.B) {
 					defer func() {
 						if r := recover(); r != nil {
 							b.Fatalf("%+v", r)
 						}
 					}()
 
-					// NB: this can be removed once this test is refactored to use `b.Loop`
-					// available starting in go1.24[1]
+					// NB: this can be removed once this test is refactored to
+					// use `b.Loop` available starting in go1.24[1]
 					//
 					// [1]: https://tip.golang.org/doc/go1.24#new-benchmark-function
-					var benchtime string
-					require.NoError(b, sniffarg.DoEnv("test.benchtime", &benchtime))
-					if strings.HasSuffix(benchtime, "x") && b.N == 1 && benchtime != "1x" {
-						// The Go benchmark harness invokes tests first with b.N == 1 which
-						// helps it adjust the number of iterations to run to the benchtime.
-						// But if we specify the number of iterations, there's no point in
-						// it doing that, so we no-op on the first run.
-						// This speeds up benchmarking (by several seconds per subtest!)
-						// since it avoids setting up an extra test cluster.
-						b.Log("skipping benchmark on initial run; benchtime specifies an iteration count")
-						return
+					if b.N == 1 && sys != nil {
+						// The Go benchmark harness will run a benchmark with
+						// b.N=1 first, and ramp up b.N until the benchmark hits
+						// a time threshold. This means that the setup code will
+						// run multiple times for a single benchmark result. To
+						// avoid repeatedly incurring the overhead of
+						// re-prepping the test cluster, we only run the setup
+						// code when on the first execution of each iteration of
+						// the benchmark, when b.N=1. If the benchmark is run
+						// with --count greater than 1, then b.N will be reset
+						// to 1 for each iteration, and a new cluster will be
+						// created, ensuring benchmark results across
+						// interations remain independent.
+						cleanup()
+						sys = nil
+					}
+					if sys == nil {
+						sys, cleanup = driver.constructorFn(context.Background(), b)
+						sys.prep(rand.New(rand.NewSource(0)))
 					}
-					sys, cleanup := driver.constructorFn(context.Background(), b)
-					defer cleanup()
 					runSysbenchOuter(b, sys, workload.opFn, parallel)
 				})
+				if cleanup != nil {
+					cleanup()
+				}
 			}
 		})
 	}
 }
 
 func runSysbenchOuter(b *testing.B, sys sysbenchDriver, opFn sysbenchWorkload, parallel bool) {
-	sys.prep(rand.New(rand.NewSource(0)))
-
 	defer startAllocsProfile(b).Stop(b)
 	defer b.StopTimer()