all: using testing.B.Loop (#1554)

gzliudan · web-flow · commit 241a5b3fb210 · 2025-09-24T07:59:48.000+08:00
* p2p: using testing.B.Loop

* core/state: using testing.B.Loop

* eth: using testing.B.Loop

* log: using testing.B.Loop

* core: using testing.B.Loop

* core/vm: using testing.B.Loop

* core/types: using testing.B.Loop

* crypto: using testing.B.Loop
diff --git a/core/bench_test.go b/core/bench_test.go
@@ -245,7 +245,7 @@ func makeChainForBench(db ethdb.Database, full bool, count uint64) {
 }
 
 func benchWriteChain(b *testing.B, full bool, count uint64) {
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		dir := b.TempDir()
 		db, err := rawdb.NewLevelDBDatabase(dir, 128, 1024, "", false)
 		if err != nil {
@@ -268,9 +268,7 @@ func benchReadChain(b *testing.B, full bool, count uint64) {
 	db.Close()
 
 	b.ReportAllocs()
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		db, err := rawdb.NewLevelDBDatabase(dir, 128, 1024, "", false)
 		if err != nil {
 			b.Fatalf("error opening database at %v: %v", dir, err)
diff --git a/core/state/state_object_test.go b/core/state/state_object_test.go
@@ -25,22 +25,22 @@ import (
 
 func BenchmarkCutOriginal(b *testing.B) {
 	value := common.HexToHash("0x01")
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		bytes.TrimLeft(value[:], "\x00")
 	}
 }
 
 func BenchmarkCutsetterFn(b *testing.B) {
 	value := common.HexToHash("0x01")
 	cutSetFn := func(r rune) bool { return r == 0 }
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		bytes.TrimLeftFunc(value[:], cutSetFn)
 	}
 }
 
 func BenchmarkCutCustomTrim(b *testing.B) {
 	value := common.HexToHash("0x01")
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		common.TrimLeftZeroes(value[:])
 	}
 }
diff --git a/core/types/block_test.go b/core/types/block_test.go
@@ -139,9 +139,8 @@ var benchBuffer = bytes.NewBuffer(make([]byte, 0, 32000))
 
 func BenchmarkEncodeBlock(b *testing.B) {
 	block := makeBenchBlock()
-	b.ResetTimer()
 
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		benchBuffer.Reset()
 		if err := rlp.Encode(benchBuffer, block); err != nil {
 			b.Fatal(err)
diff --git a/core/types/hashing_test.go b/core/types/hashing_test.go
@@ -67,17 +67,16 @@ func BenchmarkDeriveSha200(b *testing.B) {
 	var exp common.Hash
 	var got common.Hash
 	b.Run("std_trie", func(b *testing.B) {
-		b.ResetTimer()
 		b.ReportAllocs()
-		for i := 0; i < b.N; i++ {
+		for b.Loop() {
 			exp = types.DeriveSha(txs, trie.NewEmpty(trie.NewDatabase(rawdb.NewMemoryDatabase())))
 		}
 	})
 
 	b.Run("stack_trie", func(b *testing.B) {
 		b.ResetTimer()
 		b.ReportAllocs()
-		for i := 0; i < b.N; i++ {
+		for b.Loop() {
 			got = types.DeriveSha(txs, trie.NewStackTrie(nil))
 		}
 	})
diff --git a/core/vm/contracts_test.go b/core/vm/contracts_test.go
@@ -605,12 +605,10 @@ func benchmarkPrecompiled(addr string, test precompiledTest, bench *testing.B) {
 	)
 
 	bench.Run(fmt.Sprintf("%s-Gas=%d", test.name, reqGas), func(bench *testing.B) {
-		bench.ResetTimer()
-		for i := 0; i < bench.N; i++ {
+		for bench.Loop() {
 			copy(data, in)
 			res, _, err = RunPrecompiledContract(nil, p, data, reqGas, nil)
 		}
-		bench.StopTimer()
 		//Check if it is correct
 		if err != nil {
 			bench.Error(err)
diff --git a/core/vm/instructions_test.go b/core/vm/instructions_test.go
@@ -313,15 +313,13 @@ func opBenchmark(bench *testing.B, op executionFunc, args ...string) {
 		intArgs[i] = new(uint256.Int).SetBytes(common.Hex2Bytes(arg))
 	}
 	pc := uint64(0)
-	bench.ResetTimer()
-	for i := 0; i < bench.N; i++ {
+	for bench.Loop() {
 		for _, arg := range intArgs {
 			stack.push(arg)
 		}
 		op(&pc, evmInterpreter, scope)
 		stack.pop()
 	}
-	bench.StopTimer()
 
 	for i, arg := range args {
 		want := new(uint256.Int).SetBytes(common.Hex2Bytes(arg))
@@ -579,8 +577,7 @@ func BenchmarkOpMstore(bench *testing.B) {
 	memStart := new(uint256.Int)
 	value := new(uint256.Int).SetUint64(0x1337)
 
-	bench.ResetTimer()
-	for i := 0; i < bench.N; i++ {
+	for bench.Loop() {
 		stack.push(value)
 		stack.push(memStart)
 		opMstore(&pc, evmInterpreter, &ScopeContext{mem, stack, nil})
@@ -642,8 +639,7 @@ func BenchmarkOpKeccak256(bench *testing.B) {
 	pc := uint64(0)
 	start := new(uint256.Int)
 
-	bench.ResetTimer()
-	for i := 0; i < bench.N; i++ {
+	for bench.Loop() {
 		stack.push(uint256.NewInt(32))
 		stack.push(start)
 		opKeccak256(&pc, evmInterpreter, &ScopeContext{mem, stack, nil})
diff --git a/core/vm/runtime/runtime_test.go b/core/vm/runtime/runtime_test.go
@@ -149,8 +149,7 @@ func BenchmarkCall(b *testing.B) {
 		b.Fatal(err)
 	}
 
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		for j := 0; j < 400; j++ {
 			Execute(code, cpurchase, nil)
 			Execute(code, creceived, nil)
@@ -190,11 +189,9 @@ func benchmarkEVM_Create(bench *testing.B, code string) {
 		EVMConfig: vm.Config{},
 	}
 	// Warm up the intpools and stuff
-	bench.ResetTimer()
-	for i := 0; i < bench.N; i++ {
+	for bench.Loop() {
 		Call(receiver, []byte{}, &runtimeConfig)
 	}
-	bench.StopTimer()
 }
 
 func BenchmarkEVM_CREATE_500(bench *testing.B) {
diff --git a/crypto/blake2b/blake2b_test.go b/crypto/blake2b/blake2b_test.go
@@ -303,8 +303,7 @@ func benchmarkSum(b *testing.B, size int, sse4, avx, avx2 bool) {
 
 	data := make([]byte, size)
 	b.SetBytes(int64(size))
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		Sum512(data)
 	}
 }
@@ -319,8 +318,7 @@ func benchmarkWrite(b *testing.B, size int, sse4, avx, avx2 bool) {
 	data := make([]byte, size)
 	h, _ := New512(nil)
 	b.SetBytes(int64(size))
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		h.Write(data)
 	}
 }
diff --git a/crypto/crypto_test.go b/crypto/crypto_test.go
@@ -59,7 +59,7 @@ func TestToECDSAErrors(t *testing.T) {
 
 func BenchmarkSha3(b *testing.B) {
 	a := []byte("hello world")
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		Keccak256(a)
 	}
 }
diff --git a/crypto/ecies/ecies_test.go b/crypto/ecies/ecies_test.go
@@ -164,7 +164,7 @@ func TestTooBigSharedKey(t *testing.T) {
 
 // Benchmark the generation of P256 keys.
 func BenchmarkGenerateKeyP256(b *testing.B) {
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		if _, err := GenerateKey(rand.Reader, elliptic.P256(), nil); err != nil {
 			b.Fatal(err)
 		}
@@ -177,8 +177,7 @@ func BenchmarkGenSharedKeyP256(b *testing.B) {
 	if err != nil {
 		b.Fatal(err)
 	}
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		_, err := prv.GenerateShared(&prv.PublicKey, 16, 16)
 		if err != nil {
 			b.Fatal(err)
@@ -192,8 +191,7 @@ func BenchmarkGenSharedKeyS256(b *testing.B) {
 	if err != nil {
 		b.Fatal(err)
 	}
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		_, err := prv.GenerateShared(&prv.PublicKey, 16, 16)
 		if err != nil {
 			b.Fatal(err)
diff --git a/crypto/secp256k1/secp256_test.go b/crypto/secp256k1/secp256_test.go
@@ -221,9 +221,7 @@ func TestRecoverSanity(t *testing.T) {
 func BenchmarkSign(b *testing.B) {
 	_, seckey := generateKeyPair()
 	msg := csprngEntropy(32)
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		Sign(msg, seckey)
 	}
 }
@@ -232,8 +230,6 @@ func BenchmarkRecover(b *testing.B) {
 	msg := csprngEntropy(32)
 	_, seckey := generateKeyPair()
 	sig, _ := Sign(msg, seckey)
-	b.ResetTimer()
-
 	for i := 0; i < b.N; i++ {
 		RecoverPubkey(msg, sig)
 	}
diff --git a/crypto/signature_test.go b/crypto/signature_test.go
@@ -135,7 +135,7 @@ func TestPubkeyRandom(t *testing.T) {
 }
 
 func BenchmarkEcrecoverSignature(b *testing.B) {
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		if _, err := Ecrecover(testmsg, testsig); err != nil {
 			b.Fatal("ecrecover error", err)
 		}
@@ -144,15 +144,15 @@ func BenchmarkEcrecoverSignature(b *testing.B) {
 
 func BenchmarkVerifySignature(b *testing.B) {
 	sig := testsig[:len(testsig)-1] // remove recovery id
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		if !VerifySignature(testpubkey, testmsg, sig) {
 			b.Fatal("verify error")
 		}
 	}
 }
 
 func BenchmarkDecompressPubkey(b *testing.B) {
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		if _, err := DecompressPubkey(testpubkeyc); err != nil {
 			b.Fatal(err)
 		}
diff --git a/eth/tracers/internal/tracetest/calltrace_test.go b/eth/tracers/internal/tracetest/calltrace_test.go
@@ -225,8 +225,7 @@ func benchTracer(tracerName string, test *callTracerTest, b *testing.B) {
 	state := tests.MakePreState(rawdb.NewMemoryDatabase(), test.Genesis.Alloc)
 
 	b.ReportAllocs()
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		tracer, err := tracers.DefaultDirectory.New(tracerName, new(tracers.Context), nil, test.Genesis.Config)
 		if err != nil {
 			b.Fatalf("failed to create call tracer: %v", err)
diff --git a/eth/tracers/internal/tracetest/flat_calltrace_test.go b/eth/tracers/internal/tracetest/flat_calltrace_test.go
@@ -196,7 +196,7 @@ func BenchmarkFlatCallTracer(b *testing.B) {
 	for _, file := range files {
 		filename := strings.TrimPrefix(file, "testdata/call_tracer_flat/")
 		b.Run(camel(strings.TrimSuffix(filename, ".json")), func(b *testing.B) {
-			for n := 0; n < b.N; n++ {
+			for b.Loop() {
 				err := flatCallTracerTestRunner("flatCallTracer", filename, "call_tracer_flat", b)
 				if err != nil {
 					b.Fatal(err)
diff --git a/eth/tracers/tracers_test.go b/eth/tracers/tracers_test.go
@@ -93,10 +93,9 @@ func BenchmarkTransactionTrace(b *testing.B) {
 	if err != nil {
 		b.Fatalf("failed to prepare transaction for tracing: %v", err)
 	}
-	b.ResetTimer()
 	b.ReportAllocs()
 
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		snap := state.Snapshot()
 		tracer.OnTxStart(evm.GetVMContext(), tx, msg.From)
 		st := core.NewStateTransition(evm, msg, new(core.GasPool).AddGas(tx.Gas()))
diff --git a/log/format_test.go b/log/format_test.go
@@ -10,15 +10,15 @@ var sink []byte
 func BenchmarkPrettyInt64Logfmt(b *testing.B) {
 	buf := make([]byte, 100)
 	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		sink = appendInt64(buf, rand.Int63())
 	}
 }
 
 func BenchmarkPrettyUint64Logfmt(b *testing.B) {
 	buf := make([]byte, 100)
 	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		sink = appendUint64(buf, rand.Uint64(), false)
 	}
 }
diff --git a/log/logger_test.go b/log/logger_test.go
@@ -70,9 +70,10 @@ func TestJSONHandler(t *testing.T) {
 
 func BenchmarkTraceLogging(b *testing.B) {
 	SetDefault(NewLogger(NewTerminalHandler(io.Discard, true)))
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+	i := 0
+	for b.Loop() {
 		Trace("a message", "v", i)
+		i++
 	}
 }
 
@@ -99,8 +100,8 @@ func benchmarkLogger(b *testing.B, l Logger) {
 		err    = errors.New("oh nooes it's crap")
 	)
 	b.ReportAllocs()
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
+	i := 0
+	for b.Loop() {
 		l.Info("This is a message",
 			"foo", int16(i),
 			"bytes", bb,
@@ -109,8 +110,8 @@ func benchmarkLogger(b *testing.B, l Logger) {
 			"bigint", bigint,
 			"nilbig", nilbig,
 			"err", err)
+		i++
 	}
-	b.StopTimer()
 }
 
 func TestLoggerOutput(t *testing.T) {
@@ -161,18 +162,18 @@ const termTimeFormat = "01-02|15:04:05.000"
 func BenchmarkAppendFormat(b *testing.B) {
 	var now = time.Now()
 	b.Run("fmt time.Format", func(b *testing.B) {
-		for i := 0; i < b.N; i++ {
+		for b.Loop() {
 			fmt.Fprintf(io.Discard, "%s", now.Format(termTimeFormat))
 		}
 	})
 	b.Run("time.AppendFormat", func(b *testing.B) {
-		for i := 0; i < b.N; i++ {
+		for b.Loop() {
 			now.AppendFormat(nil, termTimeFormat)
 		}
 	})
 	var buf = new(bytes.Buffer)
 	b.Run("time.Custom", func(b *testing.B) {
-		for i := 0; i < b.N; i++ {
+		for b.Loop() {
 			writeTimeTermFormat(buf, now)
 			buf.Reset()
 		}
diff --git a/p2p/enr/enr_test.go b/p2p/enr/enr_test.go
@@ -310,9 +310,8 @@ func TestSignEncodeAndDecodeRandom(t *testing.T) {
 
 func BenchmarkDecode(b *testing.B) {
 	var r Record
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		rlp.DecodeBytes(pyRecord, &r)
 	}
-	b.StopTimer()
 	r.NodeAddr()
 }
diff --git a/p2p/netutil/net_test.go b/p2p/netutil/net_test.go
@@ -169,7 +169,7 @@ func TestCheckRelayIP(t *testing.T) {
 func BenchmarkCheckRelayIP(b *testing.B) {
 	sender := parseIP("23.55.1.242")
 	addr := parseIP("23.55.1.2")
-	for i := 0; i < b.N; i++ {
+	for b.Loop() {
 		CheckRelayIP(sender, addr)
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -25,22 +25,22 @@ import (`
`25`	`25`
`26`	`26`	`func BenchmarkCutOriginal(b *testing.B) {`
`27`	`27`	`value := common.HexToHash("0x01")`
`28`		`- for i := 0; i < b.N; i++ {`
	`28`	`+ for b.Loop() {`
`29`	`29`	`bytes.TrimLeft(value[:], "\x00")`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`func BenchmarkCutsetterFn(b *testing.B) {`
`34`	`34`	`value := common.HexToHash("0x01")`
`35`	`35`	`cutSetFn := func(r rune) bool { return r == 0 }`
`36`		`- for i := 0; i < b.N; i++ {`
	`36`	`+ for b.Loop() {`
`37`	`37`	`bytes.TrimLeftFunc(value[:], cutSetFn)`
`38`	`38`	`}`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`func BenchmarkCutCustomTrim(b *testing.B) {`
`42`	`42`	`value := common.HexToHash("0x01")`
`43`		`- for i := 0; i < b.N; i++ {`
	`43`	`+ for b.Loop() {`
`44`	`44`	`common.TrimLeftZeroes(value[:])`
`45`	`45`	`}`
`46`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -605,12 +605,10 @@ func benchmarkPrecompiled(addr string, test precompiledTest, bench *testing.B) {`
`605`	`605`	`)`
`606`	`606`
`607`	`607`	`bench.Run(fmt.Sprintf("%s-Gas=%d", test.name, reqGas), func(bench *testing.B) {`
`608`		`- bench.ResetTimer()`
`609`		`- for i := 0; i < bench.N; i++ {`
	`608`	`+ for bench.Loop() {`
`610`	`609`	`copy(data, in)`
`611`	`610`	`res, _, err = RunPrecompiledContract(nil, p, data, reqGas, nil)`
`612`	`611`	`}`
`613`		`- bench.StopTimer()`
`614`	`612`	`//Check if it is correct`
`615`	`613`	`if err != nil {`
`616`	`614`	`bench.Error(err)`
Original file line number	Diff line number	Diff line change
`@@ -149,8 +149,7 @@ func BenchmarkCall(b *testing.B) {`
`149`	`149`	`b.Fatal(err)`
`150`	`150`	`}`
`151`	`151`
`152`		`- b.ResetTimer()`
`153`		`- for i := 0; i < b.N; i++ {`
	`152`	`+ for b.Loop() {`
`154`	`153`	`for j := 0; j < 400; j++ {`
`155`	`154`	`Execute(code, cpurchase, nil)`
`156`	`155`	`Execute(code, creceived, nil)`
`@@ -190,11 +189,9 @@ func benchmarkEVM_Create(bench *testing.B, code string) {`
`190`	`189`	`EVMConfig: vm.Config{},`
`191`	`190`	`}`
`192`	`191`	`// Warm up the intpools and stuff`
`193`		`- bench.ResetTimer()`
`194`		`- for i := 0; i < bench.N; i++ {`
	`192`	`+ for bench.Loop() {`
`195`	`193`	`Call(receiver, []byte{}, &runtimeConfig)`
`196`	`194`	`}`
`197`		`- bench.StopTimer()`
`198`	`195`	`}`
`199`	`196`
`200`	`197`	`func BenchmarkEVM_CREATE_500(bench *testing.B) {`
Original file line number	Diff line number	Diff line change
`@@ -303,8 +303,7 @@ func benchmarkSum(b *testing.B, size int, sse4, avx, avx2 bool) {`
`303`	`303`
`304`	`304`	`data := make([]byte, size)`
`305`	`305`	`b.SetBytes(int64(size))`
`306`		`- b.ResetTimer()`
`307`		`- for i := 0; i < b.N; i++ {`
	`306`	`+ for b.Loop() {`
`308`	`307`	`Sum512(data)`
`309`	`308`	`}`
`310`	`309`	`}`
`@@ -319,8 +318,7 @@ func benchmarkWrite(b *testing.B, size int, sse4, avx, avx2 bool) {`
`319`	`318`	`data := make([]byte, size)`
`320`	`319`	`h, _ := New512(nil)`
`321`	`320`	`b.SetBytes(int64(size))`
`322`		`- b.ResetTimer()`
`323`		`- for i := 0; i < b.N; i++ {`
	`321`	`+ for b.Loop() {`
`324`	`322`	`h.Write(data)`
`325`	`323`	`}`
`326`	`324`	`}`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ func TestToECDSAErrors(t *testing.T) {`
`59`	`59`
`60`	`60`	`func BenchmarkSha3(b *testing.B) {`
`61`	`61`	`a := []byte("hello world")`
`62`		`- for i := 0; i < b.N; i++ {`
	`62`	`+ for b.Loop() {`
`63`	`63`	`Keccak256(a)`
`64`	`64`	`}`
`65`	`65`	`}`