colblk: add UnsafeIntegerSlice microbenchmark

Add a microbenchmark for the UnsafeIntegerSlice.

```
goos: darwin
goarch: arm64
pkg: github.com/cockroachdb/pebble/sstable/colblk
                                    │   old.txt   │
                                    │   sec/op    │
UnsafeIntegerSlice/uint64,delta8-10   3.651n ± 0%
UnsafeIntegerSlice/uint64,delta4-10   3.557n ± 3%
UnsafeIntegerSlice/uint64,delta2-10   3.468n ± 1%
UnsafeIntegerSlice/uint64,delta1-10   3.418n ± 2%
UnsafeIntegerSlice/uint64,delta0-10   3.397n ± 0%
UnsafeIntegerSlice/uint32,delta4-10   3.542n ± 6%
UnsafeIntegerSlice/uint32,delta2-10   3.530n ± 3%
UnsafeIntegerSlice/uint32,delta1-10   3.496n ± 4%
UnsafeIntegerSlice/uint32,delta0-10   3.448n ± 2%
UnsafeIntegerSlice/uint16,delta2-10   3.512n ± 2%
UnsafeIntegerSlice/uint16,delta1-10   3.483n ± 2%
UnsafeIntegerSlice/uint16,delta0-10   3.536n ± 3%
UnsafeIntegerSlice/uint8,delta1-10    3.405n ± 1%
UnsafeIntegerSlice/uint8,delta0-10    3.421n ± 3%
geomean                               3.490n
```

I experimented with using generics over the delta type too, relying on runtime
dynamic dispatch and it was ~20% slower.

sstable/colblk/unsafe_slice_test.go

@@ -0,0 +1,54 @@
+// Copyright 2024 The LevelDB-Go and Pebble Authors. All rights reserved. Use
+// of this source code is governed by a BSD-style license that can be found in
+// the LICENSE file.
+
+package colblk
+
+import (
+ "fmt"
+ "math"
+ "testing"
+ "time"
+
+ "github.com/cockroachdb/pebble/internal/aligned"
+ "golang.org/x/exp/rand"
+)
+
+func BenchmarkUnsafeIntegerSlice(b *testing.B) {
+ rng := rand.New(rand.NewSource(uint64(time.Now().UnixNano())))
+ benchmarkUnsafeIntegerSlice[uint64](b, rng, 1000, 8, math.MaxUint64)
+ benchmarkUnsafeIntegerSlice[uint64](b, rng, 1000, 4, math.MaxUint32)
+ benchmarkUnsafeIntegerSlice[uint64](b, rng, 1000, 2, math.MaxUint16)
+ benchmarkUnsafeIntegerSlice[uint64](b, rng, 1000, 1, math.MaxUint8)
+ benchmarkUnsafeIntegerSlice[uint64](b, rng, 1000, 0, 1)
+ benchmarkUnsafeIntegerSlice[uint32](b, rng, 1000, 4, math.MaxUint32)
+ benchmarkUnsafeIntegerSlice[uint32](b, rng, 1000, 2, math.MaxUint16)
+ benchmarkUnsafeIntegerSlice[uint32](b, rng, 1000, 1, math.MaxUint8)
+ benchmarkUnsafeIntegerSlice[uint32](b, rng, 1000, 0, 1)
+ benchmarkUnsafeIntegerSlice[uint16](b, rng, 1000, 2, math.MaxUint16)
+ benchmarkUnsafeIntegerSlice[uint16](b, rng, 1000, 1, math.MaxUint8)
+ benchmarkUnsafeIntegerSlice[uint16](b, rng, 1000, 0, 1)
+ benchmarkUnsafeIntegerSlice[uint8](b, rng, 1000, 1, math.MaxUint8)
+ benchmarkUnsafeIntegerSlice[uint8](b, rng, 1000, 0, 1)
+}
+
+func benchmarkUnsafeIntegerSlice[U Uint](
+ b *testing.B, rng *rand.Rand, rows, expectedWidth int, max uint64,
+) {
+ b.Run(fmt.Sprintf("%T,delta%d", U(0), expectedWidth), func(b *testing.B) {
+ var ub UintBuilder[U]
+ ub.Init()
+ for i := 0; i < rows; i++ {
+ ub.Set(i, U(rng.Uint64n(max)))
+ }
+
+ sz := ub.Size(rows, 0)
+ buf := aligned.ByteSlice(int(sz) + 1 /* trailing padding byte */)
+ _ = ub.Finish(0, rows, 0, buf)
+ s, _ := DecodeUnsafeIntegerSlice[U](buf, 0, rows)
+ b.ResetTimer()
+ for i := 0; i < b.N; i++ {
+ _ = s.At(rng.Intn(rows))
+ }
+ })
+}