Reviewed 2 of 3 files at r1.
Reviewable status: complete! 0 of 0 LGTMs obtained (waiting on @danhhz and @tbg)

cpu.prof, line 0 at r1 (raw file):
Woops 😄

pkg/workload/bank/bank.go, line 121 at r1 (raw file):

			b.rows,
			func(rowIdx int) []interface{} {
				rng := rand.New(rand.NewSource(b.seed + uint64(rowIdx)))

If we're just using this as a rand.Source, I bet we can remove an allocation per row by changing this to:

rng := rand.NewSource(b.seed + uint64(rowIdx))

Or if we want to go crazy, pull the variable out of this function and just Seed it each time. The second suggestion is only safe if we never call this function concurrently.

pkg/workload/bank/bank.go, line 122 at r1 (raw file):

			func(rowIdx int) []interface{} {
				rng := rand.New(rand.NewSource(b.seed + uint64(rowIdx)))
				payload := make([]byte, b.payloadBytes)

Do we get any speedup from batch allocating this? Something like:

func (b *bank) Tables() []workload.Table {
    var payloadAlloc []byte
    ...
        func(rowIdx int) []interface{} {
            if len(payloadAlloc) < b.payloadBytes {
                payloadAlloc = make([]byte, 64*b.payloadBytes)
            }
            payload = payloadAlloc[:b.payloadBytes]
            payloadAlloc = payloadAlloc[b.payloadBytes:]

Or if we're confident that this function will be called b.rows, just start with payloadAlloc sized to b.rows*b.payloadBytes?

RFAL

Reviewable status: complete! 0 of 0 LGTMs obtained (waiting on @nvanbenschoten and @tbg)

cpu.prof, line at r1 (raw file):

🙈

pkg/workload/bank/bank.go, line 121 at r1 (raw file):

Ah, great eye. The reason that method takes a rand.Source in the first place is because when I was doing #35322, I noticed that it was faster when you gave it a *rand.PCGSource instead of a *rand.Rand. But when I tried plumbing the source all the way down, I didn't see any difference in the overall InitTPCC benchmark. It does however make a difference here, both in cpu and allocs! Diff from simply removing the rand.New wrapper:

name        old time/op    new time/op    delta
InitBank-8     642µs ± 1%     561µs ± 2%  -12.68%  (p=0.008 n=5+5)

name        old speed      new speed      delta
InitBank-8   160MB/s ± 1%   183MB/s ± 2%  +14.53%  (p=0.008 n=5+5)

name        old alloc/op   new alloc/op   delta
InitBank-8     280kB ± 0%     232kB ± 0%  -17.13%  (p=0.000 n=4+5)

name        old allocs/op  new allocs/op  delta
InitBank-8     7.00k ± 0%     6.00k ± 0%  -14.28%  (p=0.008 n=5+5)

pkg/workload/bank/bank.go, line 122 at r1 (raw file):

Those functions have to be concurrency safe. TPCC gets around this by putting them in a pool using bufalloc.BytesAllocator, which is straightforward, but I'll leave for a followup.

(FWIW, BytesAllocator is probably a better idea here than allocating b.rows * b.payloadBytes, since we seem to be using this workload when we need some large sized cluster but don't particularly care what's in it, so it tends to get a combo that means a very large b.rows * b.payloadBytes.)

Reviewed 2 of 3 files at r2.
Reviewable status: complete! 1 of 0 LGTMs obtained (waiting on @tbg)