sstable: add blob value liveness writer random test

Add a randomized test of blob value liveness writer.

Author: annrpom

sstable/blob_reference_index.go

@@ -46,12 +46,10 @@ func (s *blobRefValueLivenessState) finishCurrentBlock() {
 }
 
 // blobRefValueLivenessWriter helps maintain the liveness of values in blob value
-// blocks for a sstable's blob references. It maintains:
-//   - bufs: serialized value liveness encodings that will be written to the
-//     sstable.
-//   - refState: a slice of blobRefValueLivenessState. This tracks the
-//     in-progress value liveness for each blob value block for our sstable's
-//     blob references. The index of the slice corresponds to the blob.ReferenceID.
+// blocks for a sstable's blob references. It maintains a refState, a slice of
+// blobRefValueLivenessState. This tracks the in-progress value liveness for
+// each blob value block for our sstable's blob references. The index of the
+// slice corresponds to the blob.ReferenceID.
 type blobRefValueLivenessWriter struct {
 	refState []blobRefValueLivenessState
 }
@@ -70,14 +68,11 @@ func (w *blobRefValueLivenessWriter) numReferences() int {
 
 // addLiveValue adds a live value to the state maintained by refID. If the
 // current blockID for this in-progress state is different from the provided
-// blockID, a new state is created and the old one is preserved to the buffer
-// at w.bufs[refID].
+// blockID, a new state is created.
 //
 // addLiveValue adds a new state for the provided refID if one does
 // not already exist. It assumes that any new blob.ReferenceIDs are visited in
 // monotonically increasing order.
-//
-// INVARIANT: len(w.refState) == len(w.bufs).
 func (w *blobRefValueLivenessWriter) addLiveValue(
 	refID blob.ReferenceID, blockID blob.BlockID, valueID blob.BlockValueID, valueSize uint64,
 ) error {
@@ -137,7 +132,8 @@ type BlobRefLivenessEncoding struct {
 
 // DecodeBlobRefLivenessEncoding decodes a sequence of blob reference liveness
 // encodings from the provided buffer. Each encoding has the format:
-// <block ID> <values size> <n bytes of bitmap> [<bitmap>]
+//
+//	<block ID> <values size> <len of bitmap> [<bitmap>]
 func DecodeBlobRefLivenessEncoding(buf []byte) []BlobRefLivenessEncoding {
 	var encodings []BlobRefLivenessEncoding
 	for len(buf) > 0 {

sstable/blob_reference_index_test.go

@@ -5,9 +5,13 @@
 package sstable
 
 import (
+	"iter"
 	"maps"
+	"math/rand/v2"
 	"testing"
+	"time"
 
+	"github.com/cockroachdb/pebble/internal/testutils"
 	"github.com/cockroachdb/pebble/sstable/blob"
 	"github.com/stretchr/testify/require"
 )
@@ -77,3 +81,68 @@ func TestBlobRefValueLivenessWriter(t *testing.T) {
 		require.Equal(t, uint8(0x7), blocks[0].Bitmap[0])
 	})
 }
+
+func TestBlobRefLivenessEncoding_Randomized(t *testing.T) {
+	const valueSize = uint64(10)
+	prng := rand.New(rand.NewPCG(uint64(time.Now().UnixNano()), 0))
+	w := blobRefValueLivenessWriter{}
+
+	collectSlice := func(i iter.Seq2[blob.ReferenceID, []byte]) [][]byte {
+		var s [][]byte
+		for _, enc := range i {
+			s = append(s, enc)
+		}
+		return s
+	}
+
+	for range 20 {
+		w.init()
+		numRefs := testutils.RandIntInRange(prng, 1, 10)
+		for refID := range numRefs {
+			numBlocks := testutils.RandIntInRange(prng, 1, 6)
+			currentBlockID := blob.BlockID(testutils.RandIntInRange(prng, 0, 4))
+
+			for range numBlocks {
+				// Generate blockIDs that are increasing -- with occasional
+				// duplicates. Allow a 70% chance to repeat the previous block
+				// ID.
+				if prng.Float64() < 0.3 {
+					currentBlockID += blob.BlockID(testutils.RandIntInRange(prng, 1, 4))
+				}
+				numValues := testutils.RandIntInRange(prng, 10, 101)
+				currentValueID := blob.BlockValueID(testutils.RandIntInRange(prng, 0, 4))
+				for range numValues {
+					require.NoError(t, w.addLiveValue(
+						blob.ReferenceID(refID),
+						currentBlockID,
+						currentValueID,
+						valueSize,
+					))
+					currentValueID += blob.BlockValueID(testutils.RandIntInRange(prng, 1, 4))
+				}
+			}
+		}
+		encoded := collectSlice(w.finish())
+
+		// Test the encoding/decoding roundtrip to ensure idempotence.
+		// Reinitialize the writer before reconstructing values.
+		w.init()
+		for refID, blockEnc := range encoded {
+			for _, block := range DecodeBlobRefLivenessEncoding(blockEnc) {
+				// Reconstruct the live values from the bitmap and add them to
+				// the writer.
+				for valueID := range IterSetBitsInRunLengthBitmap(block.Bitmap) {
+					require.NoError(t, w.addLiveValue(
+						blob.ReferenceID(refID),
+						block.BlockID,
+						blob.BlockValueID(valueID),
+						valueSize,
+					))
+				}
+			}
+		}
+
+		reencoded := collectSlice(w.finish())
+		require.Equal(t, encoded, reencoded)
+	}
+}