block: introduce blockkinds

Introduce an enum of block kinds. This replaces two existing similar
enums - one in the compression analyzer and one in objiotracing.

This will allow integrating the compression analyzer in the read path,
and implementing a more complex `block.Compressor` which can take the
kind into account.

Author: RaduBerinde

objstorage/objstorageprovider/objiotracing/obj_io_tracing.go

@@ -4,7 +4,10 @@
 
 package objiotracing
 
-import "github.com/cockroachdb/pebble/internal/base"
+import (
+	"github.com/cockroachdb/pebble/internal/base"
+	"github.com/cockroachdb/pebble/sstable/block/blockkind"
+)
 
 // OpType indicates the type of operation.
 type OpType uint8
@@ -33,18 +36,6 @@ const (
 	// TODO(radu): add ForUserFacing.
 )
 
-// BlockType indicates the type of data block relevant to an operation.
-type BlockType uint8
-
-// BlockType values.
-const (
-	UnknownBlock BlockType = iota
-	DataBlock
-	ValueBlock
-	FilterBlock
-	MetadataBlock
-)
-
 // Event is the on-disk format of a tracing event. It is exported here so that
 // trace processing tools can use it by importing this package.
 type Event struct {
@@ -54,7 +45,7 @@ type Event struct {
 	StartUnixNano int64
 	Op            OpType
 	Reason        Reason
-	BlockType     BlockType
+	BlockKind     blockkind.Kind
 	// LSM level plus one (with 0 indicating unknown level).
 	LevelPlusOne uint8
 	// Hardcoded padding so that struct layout doesn't depend on architecture.

objstorage/objstorageprovider/objiotracing/obj_io_tracing_off.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/cockroachdb/pebble/internal/base"
 	"github.com/cockroachdb/pebble/objstorage"
+	"github.com/cockroachdb/pebble/sstable/block/blockkind"
 	"github.com/cockroachdb/pebble/vfs"
 )
 
@@ -49,9 +50,9 @@ func (t *Tracer) WrapWritable(
 // traces created under that context).
 func WithReason(ctx context.Context, reason Reason) context.Context { return ctx }
 
-// WithBlockType creates a context that has an associated BlockType (which ends up in
+// WithBlockKind creates a context that has an associated BlockType (which ends up in
 // traces created under that context).
-func WithBlockType(ctx context.Context, blockType BlockType) context.Context { return ctx }
+func WithBlockKind(ctx context.Context, kind blockkind.Kind) context.Context { return ctx }
 
 // WithLevel creates a context that has an associated level (which ends up in
 // traces created under that context).

objstorage/objstorageprovider/objiotracing/obj_io_tracing_on.go

@@ -18,6 +18,7 @@ import (
 
 	"github.com/cockroachdb/pebble/internal/base"
 	"github.com/cockroachdb/pebble/objstorage"
+	"github.com/cockroachdb/pebble/sstable/block/blockkind"
 	"github.com/cockroachdb/pebble/vfs"
 )
 
@@ -234,7 +235,7 @@ func (rh *readHandle) RecordCacheHit(ctx context.Context, offset, size int64) {
 
 type ctxInfo struct {
 	reason       Reason
-	blockType    BlockType
+	blockKind    blockkind.Kind
 	levelPlusOne uint8
 }
 
@@ -243,8 +244,8 @@ func mergeCtxInfo(base, other ctxInfo) ctxInfo {
 	if res.reason == 0 {
 		res.reason = base.reason
 	}
-	if res.blockType == 0 {
-		res.blockType = base.blockType
+	if res.blockKind == 0 {
+		res.blockKind = base.blockKind
 	}
 	if res.levelPlusOne == 0 {
 		res.levelPlusOne = base.levelPlusOne
@@ -274,11 +275,11 @@ func WithReason(ctx context.Context, reason Reason) context.Context {
 	return withInfo(ctx, info)
 }
 
-// WithBlockType creates a context that has an associated BlockType (which ends up in
+// WithBlockKind creates a context that has an associated BlockType (which ends up in
 // traces created under that context).
-func WithBlockType(ctx context.Context, blockType BlockType) context.Context {
+func WithBlockKind(ctx context.Context, kind blockkind.Kind) context.Context {
 	info := infoFromCtx(ctx)
-	info.blockType = blockType
+	info.blockKind = kind
 	return withInfo(ctx, info)
 }
 
@@ -328,7 +329,7 @@ func (g *eventGenerator) add(ctx context.Context, e Event) {
 	info := infoFromCtx(ctx)
 	info = mergeCtxInfo(g.baseCtxInfo, info)
 	e.Reason = info.reason
-	e.BlockType = info.blockType
+	e.BlockKind = info.blockKind
 	e.LevelPlusOne = info.levelPlusOne
 	if g.buf.num == eventsPerBuf {
 		g.flush()

objstorage/objstorageprovider/objiotracing/obj_io_tracing_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/cockroachdb/pebble"
 	"github.com/cockroachdb/pebble/internal/base"
 	"github.com/cockroachdb/pebble/objstorage/objstorageprovider/objiotracing"
+	"github.com/cockroachdb/pebble/sstable/block/blockkind"
 	"github.com/cockroachdb/pebble/vfs"
 	"github.com/stretchr/testify/require"
 )
@@ -128,6 +129,6 @@ func TestTracing(t *testing.T) {
 	events = collectEvents()
 	// Expect L6 data block reads.
 	require.Greater(t, num(func(e Event) bool {
-		return e.Op == objiotracing.ReadOp && e.BlockType == objiotracing.DataBlock && e.LevelPlusOne == 7
+		return e.Op == objiotracing.ReadOp && e.BlockKind == blockkind.SSTableData && e.LevelPlusOne == 7
 	}), 0)
 }

sstable/blob/blob.go

@@ -17,6 +17,7 @@ import (
 	"github.com/cockroachdb/pebble/objstorage"
 	"github.com/cockroachdb/pebble/objstorage/objstorageprovider"
 	"github.com/cockroachdb/pebble/sstable/block"
+	"github.com/cockroachdb/pebble/sstable/block/blockkind"
 )
 
 var (
@@ -460,14 +461,14 @@ func (r *FileReader) InitReadHandle(
 func (r *FileReader) ReadValueBlock(
 	ctx context.Context, env block.ReadEnv, rh objstorage.ReadHandle, h block.Handle,
 ) (block.BufferHandle, error) {
-	return r.r.Read(ctx, env, rh, h, initBlobValueBlockMetadata)
+	return r.r.Read(ctx, env, rh, h, blockkind.BlobValue, initBlobValueBlockMetadata)
 }
 
 // ReadIndexBlock reads the index block from the file.
 func (r *FileReader) ReadIndexBlock(
 	ctx context.Context, env block.ReadEnv, rh objstorage.ReadHandle,
 ) (block.BufferHandle, error) {
-	return r.r.Read(ctx, env, rh, r.footer.indexHandle, initIndexBlockMetadata)
+	return r.r.Read(ctx, env, rh, r.footer.indexHandle, blockkind.Metadata, initIndexBlockMetadata)
 }
 
 // IndexHandle returns the block handle for the file's index block.

sstable/blob/fetcher.go

@@ -13,7 +13,6 @@ import (
 	"github.com/cockroachdb/pebble/internal/invariants"
 	"github.com/cockroachdb/pebble/objstorage"
 	"github.com/cockroachdb/pebble/objstorage/objstorageprovider"
-	"github.com/cockroachdb/pebble/objstorage/objstorageprovider/objiotracing"
 	"github.com/cockroachdb/pebble/sstable/block"
 )
 
@@ -212,7 +211,6 @@ func (cr *cachedReader) GetUnsafeValue(
 	// If we already have a block loaded (eg, we're scanning retrieving multiple
 	// values), the current block might contain the value.
 	if !cr.currentValueBlock.loaded || cr.currentValueBlock.virtualID != vh.BlockID {
-		ctx = objiotracing.WithBlockType(ctx, objiotracing.ValueBlock)
 		if !cr.indexBlock.loaded {
 			// Read the index block.
 			var err error

sstable/block/block.go

@@ -25,8 +25,13 @@ import (
 	"github.com/cockroachdb/pebble/internal/sstableinternal"
 	"github.com/cockroachdb/pebble/objstorage"
 	"github.com/cockroachdb/pebble/objstorage/objstorageprovider"
+	"github.com/cockroachdb/pebble/objstorage/objstorageprovider/objiotracing"
+	"github.com/cockroachdb/pebble/sstable/block/blockkind"
 )
 
+// Kind is a convenience alias.
+type Kind = blockkind.Kind
+
 // Handle is the file offset and length of a block.
 type Handle struct {
 	// Offset identifies the offset of the block within the file.
@@ -447,6 +452,7 @@ func (r *Reader) Read(
 	env ReadEnv,
 	readHandle objstorage.ReadHandle,
 	bh Handle,
+	kind Kind,
 	initBlockMetadataFn func(*Metadata, []byte) error,
 ) (handle BufferHandle, _ error) {
 	// The compaction path uses env.BufferPool, and does not coordinate read
@@ -459,7 +465,7 @@ func (r *Reader) Read(
 				return CacheBufferHandle(cv), nil
 			}
 		}
-		value, err := r.doRead(ctx, env, readHandle, bh, initBlockMetadataFn)
+		value, err := r.doRead(ctx, env, readHandle, bh, kind, initBlockMetadataFn)
 		if err != nil {
 			return BufferHandle{}, env.maybeReportCorruption(err)
 		}
@@ -492,7 +498,7 @@ func (r *Reader) Read(
 		return CacheBufferHandle(cv), nil
 	}
 
-	value, err := r.doRead(ctx, env, readHandle, bh, initBlockMetadataFn)
+	value, err := r.doRead(ctx, env, readHandle, bh, kind, initBlockMetadataFn)
 	if err != nil {
 		crh.SetReadError(err)
 		return BufferHandle{}, env.maybeReportCorruption(err)
@@ -519,8 +525,10 @@ func (r *Reader) doRead(
 	env ReadEnv,
 	readHandle objstorage.ReadHandle,
 	bh Handle,
+	kind Kind,
 	initBlockMetadataFn func(*Metadata, []byte) error,
 ) (Value, error) {
+	ctx = objiotracing.WithBlockKind(ctx, kind)
 	// First acquire loadBlockSema, if needed.
 	if sema := r.opts.LoadBlockSema; sema != nil {
 		if err := sema.Acquire(ctx, 1); err != nil {

sstable/block/blockkind/kind.go

@@ -0,0 +1,52 @@
+// Copyright 2025 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 blockkind
+
+import "iter"
+
+// Kind identifies the type of block.
+type Kind uint8
+
+const (
+	Unknown Kind = iota
+	SSTableData
+	SSTableIndex
+	SSTableValue
+	BlobValue
+	Index
+	Filter
+	RangeDel
+	RangeKey
+	Metadata
+
+	NumKinds
+)
+
+var kindString = [...]string{
+	Unknown:      "unknown",
+	SSTableData:  "data",
+	SSTableValue: "sstval",
+	SSTableIndex: "index",
+	BlobValue:    "blobval",
+	Filter:       "filter",
+	RangeDel:     "rangedel",
+	RangeKey:     "rangekey",
+	Metadata:     "metadata",
+}
+
+func (k Kind) String() string {
+	return kindString[k]
+}
+
+// All returns all block kinds.
+func All() iter.Seq[Kind] {
+	return func(yield func(Kind) bool) {
+		for i := Kind(1); i < NumKinds; i++ {
+			if !yield(i) {
+				break
+			}
+		}
+	}
+}

sstable/compressionanalyzer/block_analyzer.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/cockroachdb/crlib/crtime"
 	"github.com/cockroachdb/pebble/internal/compression"
+	"github.com/cockroachdb/pebble/sstable/block"
 )
 
 // BlockAnalyzer is used to evaluate the performance and compressibility of different
@@ -48,7 +49,7 @@ func (a *BlockAnalyzer) Close() {
 
 // Block analyzes a block by measuring its compressibility and the performance
 // of various compression algorithms on it.
-func (a *BlockAnalyzer) Block(kind BlockKind, block []byte) {
+func (a *BlockAnalyzer) Block(kind block.Kind, block []byte) {
 	size := MakeBlockSize(len(block))
 	compressibility := MakeCompressibility(len(block), len(a.minLZFastest.Compress(a.buf1[:0], block)))
 	bucket := &a.b[kind][size][compressibility]

sstable/compressionanalyzer/buckets.go

@@ -12,35 +12,9 @@ import (
 	"time"
 
 	"github.com/cockroachdb/pebble/internal/compression"
+	"github.com/cockroachdb/pebble/sstable/block/blockkind"
 )
 
-// BlockKind breaks down the types of blocks into categories which might benefit
-// from individual compressions settings.
-type BlockKind uint8
-
-const (
-	DataBlock BlockKind = iota
-	SSTableValueBlock
-	BlobValueBlock
-	IndexBlock
-	// OtherBlock includes range del/key blocks, and other top-level metadata
-	// blocks.
-	OtherBlock
-	numBlockKinds
-)
-
-var blockKindString = [...]string{
-	DataBlock:         "data",
-	SSTableValueBlock: "sstval",
-	BlobValueBlock:    "blobval",
-	IndexBlock:        "index",
-	OtherBlock:        "other",
-}
-
-func (k BlockKind) String() string {
-	return blockKindString[k]
-}
-
 // BlockSize identifies a range of block sizes.
 type BlockSize uint8
 
@@ -134,7 +108,7 @@ var Settings = [...]compression.Setting{
 const numSettings = 7
 
 // Buckets holds the results of all experiments.
-type Buckets [numBlockKinds][numBlockSizes][numCompressibility]Bucket
+type Buckets [blockkind.NumKinds][numBlockSizes][numCompressibility]Bucket
 
 // Bucket aggregates results for blocks of the same kind, size range, and
 // compressibility.
@@ -161,7 +135,7 @@ func (b *Buckets) String(minSamples int) string {
 		fmt.Fprintf(tw, "\t%s", s.String())
 	}
 	fmt.Fprintf(tw, "\n")
-	for k := BlockKind(0); k < numBlockKinds; k++ {
+	for k := range blockkind.All() {
 		for sz := BlockSize(0); sz < numBlockSizes; sz++ {
 			for c := Compressibility(0); c < numCompressibility; c++ {
 				bucket := &b[k][sz][c]
@@ -223,7 +197,7 @@ func (b *Buckets) ToCSV(minSamples int) string {
 		fmt.Fprintf(&buf, ",%s Decomp±", s.String())
 	}
 	fmt.Fprintf(&buf, "\n")
-	for k := BlockKind(0); k < numBlockKinds; k++ {
+	for k := range blockkind.All() {
 		for sz := BlockSize(0); sz < numBlockSizes; sz++ {
 			for c := Compressibility(0); c < numCompressibility; c++ {
 				bucket := &b[k][sz][c]