35322: workload/tpcc: initial data load perf improvements r=petermattis a=danhhz

See individual commits for details

Touches #34809

Co-authored-by: Daniel Harrison <daniel.harrison@gmail.com>

Give bank's initial table data generation the same love that tpcc just
got in cockroachdb#35322. We use bank for some of the roachtests that just want a
bunch of data, so it's worth speeding up. The generated "payload" field
has changed a bit (a-zA-Z instead of hex encoded), but it wasn't that
way before for any particular reason, so this should be okay.

In summary:
- The slowest part of generating random strings is generating the random
  number. Previously, we made a uint64 and threw away most of it to pick
  one character from an alphabet. Instead, pick as many characters as we
  can get from 64 bits: floor(log(math.MaxUint64)/log(len(alpabet)).
- The current thinking for go2 is to switch to a Permuted Congruential
  Generator (PCG), which is much faster than the current "math/rand"
  generator. It's smaller in memory (128-bit vs 607 64-bit words) and
  _much_ faster to seed. Use the implementation of that proposal that's
  in "golang.org/x/exp/rand"

Benchmark:

    name        old time/op    new time/op      delta
    InitBank-8    12.8ms ± 1%       0.7ms ± 1%    -94.92%  (p=0.008 n=5+5)

    name        old speed      new speed        delta
    InitBank-8  7.88MB/s ± 1%  158.21MB/s ± 1%  +1907.77%  (p=0.008 n=5+5)

    name        old alloc/op   new alloc/op     delta
    InitBank-8    5.88MB ± 0%      0.28MB ± 0%    -95.24%  (p=0.000 n=4+5)

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

Release note: None

Give bank's initial table data generation the same love that tpcc just
got in cockroachdb#35322. We use bank for some of the roachtests that just want a
bunch of data, so it's worth speeding up. The generated "payload" field
has changed a bit (a-zA-Z instead of hex encoded), but it wasn't that
way before for any particular reason, so this should be okay.

In summary:
- The slowest part of generating random strings is generating the random
  number. Previously, we made a uint64 and threw away most of it to pick
  one character from an alphabet. Instead, pick as many characters as we
  can get from 64 bits: floor(log(math.MaxUint64)/log(len(alpabet)).
- The current thinking for go2 is to switch to a Permuted Congruential
  Generator (PCG), which is much faster than the current "math/rand"
  generator. It's smaller in memory (128-bit vs 607 64-bit words) and
  _much_ faster to seed. Use the implementation of that proposal that's
  in "golang.org/x/exp/rand"

Benchmark:

    name        old time/op    new time/op      delta
    InitBank-8    12.6ms ± 1%       0.6ms ± 2%    -95.54%  (p=0.008 n=5+5)

    name        old speed      new speed        delta
    InitBank-8  8.02MB/s ± 1%  183.44MB/s ± 2%  +2187.28%  (p=0.008 n=5+5)

    name        old alloc/op   new alloc/op     delta
    InitBank-8    5.88MB ± 0%      0.23MB ± 0%    -96.05%  (p=0.008 n=5+5)

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

Release note: None

35441: workload/bank: generate random strings much faster r=nvanbenschoten a=danhhz

Give bank's initial table data generation the same love that tpcc just
got in #35322. We use bank for some of the roachtests that just want a
bunch of data, so it's worth speeding up. The generated "payload" field
has changed a bit (a-zA-Z instead of hex encoded), but it wasn't that
way before for any particular reason, so this should be okay.

In summary:
- The slowest part of generating random strings is generating the random
  number. Previously, we made a uint64 and threw away most of it to pick
  one character from an alphabet. Instead, pick as many characters as we
  can get from 64 bits: floor(log(math.MaxUint64)/log(len(alpabet)).
- The current thinking for go2 is to switch to a Permuted Congruential
  Generator (PCG), which is much faster than the current "math/rand"
  generator. It's smaller in memory (128-bit vs 607 64-bit words) and
  _much_ faster to seed. Use the implementation of that proposal that's
  in "golang.org/x/exp/rand"

Benchmark:

    name        old time/op    new time/op      delta
    InitBank-8    12.6ms ± 1%       0.6ms ± 2%    -95.54%  (p=0.008 n=5+5)

    name        old speed      new speed        delta
    InitBank-8  8.02MB/s ± 1%  183.44MB/s ± 2%  +2187.28%  (p=0.008 n=5+5)

    name        old alloc/op   new alloc/op     delta
    InitBank-8    5.88MB ± 0%      0.23MB ± 0%    -96.05%  (p=0.008 n=5+5)

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

Release note: None

Co-authored-by: Daniel Harrison <daniel.harrison@gmail.com>