all: reuse the global hash buffer

[nthumann]

As #31769 defined a global hash pool, so we can reuse it, and also remove the unnecessary KeccakState buffering

[MariusVanDerWijden]

I pretty deliberately not changed these cases as I think using the buffer here would be a tiny bit slower than reusing the buffer that we already have. I would be fine with merging it, if you could show that the two approaches are roughly the same time wise

[nthumann]

I pretty deliberately not changed these cases as I think using the buffer here would be a tiny bit slower than reusing the buffer that we already have. I would be fine with merging it, if you could show that the two approaches are roughly the same time wise

I added a benchmark test for rawdb.SafeDeleteRange, here is the result with benchstat:

$ go test -benchmem --benchtime=1m -run=^$ -bench ^BenchmarkSafeDeleteRange github.com/ethereum/go-ethereum/core/rawdb > old.txt
# change the code to reuse the hash pool
$ go test -benchmem --benchtime=1m -run=^$ -bench ^BenchmarkSafeDeleteRange github.com/ethereum/go-ethereum/core/rawdb > new.txt

The diff as below:

$ benchstat old.txt new.txt
goos: darwin
goarch: arm64
pkg: github.com/ethereum/go-ethereum/core/rawdb
cpu: Apple M4 Max
                   │   old.txt    │             new.txt             │
                   │    sec/op    │    sec/op     vs base           │
SafeDeleteRange-16   26.22m ± ∞ ¹   23.07m ± ∞ ¹  ~ (p=1.000 n=1) ²
¹ need >= 6 samples for confidence interval at level 0.95
² need >= 4 samples to detect a difference at alpha level 0.05

                   │    old.txt    │             new.txt              │
                   │     B/op      │     B/op       vs base           │
SafeDeleteRange-16   12.04Mi ± ∞ ¹   11.23Mi ± ∞ ¹  ~ (p=1.000 n=1) ²
¹ need >= 6 samples for confidence interval at level 0.95
² need >= 4 samples to detect a difference at alpha level 0.05

                   │   old.txt    │             new.txt             │
                   │  allocs/op   │  allocs/op    vs base           │
SafeDeleteRange-16   119.9k ± ∞ ¹   119.9k ± ∞ ¹  ~ (p=1.000 n=1) ²
¹ need >= 6 samples for confidence interval at level 0.95
² need >= 4 samples to detect a difference at alpha level 0.05

1. The new approach is about 12% faster than the old one, and the memory usage is also reduced by about 6.7%.
2. The allocs/op is not changed, because the SafeDeleteRange function is not changed, only the hashPool is reused in the SafeDeleteRange function.

So I think the pool reuse performance should be a litter better than the old one?
Please let me know if I've missed sth or anything the benchmark test is not correct.

[rjl493456442]

@MariusVanDerWijden looks like there is no big difference between two approaches.

// goos: darwin
// goarch: arm64
// pkg: github.com/ethereum/go-ethereum/crypto
// cpu: Apple M1 Pro
// BenchmarkKeccak256Hash
// BenchmarkKeccak256Hash-8   	  931095	      1270 ns/op	      32 B/op	       1 allocs/op
func BenchmarkKeccak256Hash(b *testing.B) {
	var input [512]byte
	rand.Read(input[:])

	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		Keccak256Hash(input[:])
	}
}

// goos: darwin
// goarch: arm64
// pkg: github.com/ethereum/go-ethereum/crypto
// cpu: Apple M1 Pro
// BenchmarkHashData
// BenchmarkHashData-8   	  793386	      1278 ns/op	      32 B/op	       1 allocs/op
func BenchmarkHashData(b *testing.B) {
	var (
		input  [512]byte
		buffer = NewKeccakState()
	)
	rand.Read(input[:])

	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		HashData(buffer, input[:])
	}
}

[MariusVanDerWijden]

LGTM