Experiment with string interning on BlockMeta

pkg/intern/intern.go

@@ -0,0 +1,41 @@
+package intern
+
+import "sync"
+
+// A Value pointer is the handle to an underlying comparable value.
+type Value struct {
+	cmpVal string
+}
+
+// Get returns the comparable value passed to the Get func that returned v.
+func (v *Value) Get() string { return v.cmpVal }
+
+// Our pool of interned values and a lock to serialize access.
+var (
+	mu  sync.Mutex
+	val = map[string]*Value{}
+)
+
+// Get returns a pointer representing the comparable value cmpVal.
+//
+// The returned pointer will be the same for Get(v) and Get(v2)
+// if and only if v == v2, and can be used as a map key.
+//
+// Note that Get returns a *Value so we only return one word of data
+// to the caller, despite potentially storing a large amount of data
+// within the Value itself.
+func Get(cmpVal string) *Value {
+	mu.Lock()
+	defer mu.Unlock()
+
+	v := val[cmpVal]
+	if v != nil {
+		// Value is already interned in the pool.
+		return v
+	}
+
+	// Value must be created now and then interned.
+	v = &Value{cmpVal: cmpVal}
+	val[cmpVal] = v
+	return v
+}

pkg/intern/intern_test.go

@@ -0,0 +1,35 @@
+package intern
+
+import (
+	"fmt"
+	"testing"
+	"unsafe"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestBasics(t *testing.T) {
+	x := Get("abc123")
+	y := Get("abc123")
+
+	if x.Get() != y.Get() {
+		t.Error("abc123 values differ")
+	}
+	if x.Get() != "abc123" {
+		t.Error("x.Get not abc123")
+	}
+	if x != y {
+		t.Error("abc123 pointers differ")
+	}
+
+	a1 := x.Get()
+	a2 := y.Get()
+
+	p1 := fmt.Sprintf("%08x\n", stringAddr(a1))
+	p2 := fmt.Sprintf("%08x\n", stringAddr(a2))
+	require.Equal(t, p1, p2)
+}
+
+func stringAddr(s string) uintptr {
+	return uintptr(unsafe.Pointer(unsafe.StringData(s)))
+}

tempodb/backend/block_meta.go

@@ -10,6 +10,7 @@ import (
 	"github.com/cespare/xxhash/v2"
 	"github.com/google/uuid"
 
+	"github.com/grafana/tempo/pkg/intern"
 	"github.com/grafana/tempo/pkg/tempopb"
 	"github.com/grafana/tempo/pkg/traceql"
 )
@@ -89,6 +90,28 @@ type CompactedBlockMeta struct {
 	CompactedTime time.Time `json:"compactedTime"`
 }
 
+func (b *CompactedBlockMeta) UnmarshalJSON(data []byte) error {
+	if err := json.Unmarshal(data, &b.BlockMeta); err != nil {
+		return fmt.Errorf("failed at unmarshal for dedicated columns: %w", err)
+	}
+
+	var msg interface{}
+	err := json.Unmarshal(data, &msg)
+	if err != nil {
+		return err
+	}
+	msgMap := msg.(map[string]interface{})
+
+	if v, ok := msgMap["compactedTime"]; ok {
+		b.CompactedTime, err = time.Parse(time.RFC3339, v.(string))
+		if err != nil {
+			return fmt.Errorf("failed to parse time at compactedTime: %w", err)
+		}
+	}
+
+	return nil
+}
+
 const (
 	DefaultReplicationFactor          = 0 // Replication factor for blocks from the ingester. This is the default value to indicate RF3.
 	MetricsGeneratorReplicationFactor = 1
@@ -136,6 +159,19 @@ type BlockMeta struct {
 	ReplicationFactor uint32 `json:"replicationFactor,omitempty"`
 }
 
+func (b *BlockMeta) UnmarshalJSON(data []byte) error {
+	type metaAlias BlockMeta
+
+	err := json.Unmarshal(data, (*metaAlias)(b))
+	if err != nil {
+		return err
+	}
+	b.Version = intern.Get(b.Version).Get()
+	b.TenantID = intern.Get(b.TenantID).Get()
+
+	return nil
+}
+
 // DedicatedColumn contains the configuration for a single attribute with the given name that should
 // be stored in a dedicated column instead of the generic attribute column.
 type DedicatedColumn struct {
@@ -173,6 +209,11 @@ func (dc *DedicatedColumn) UnmarshalJSON(b []byte) error {
 	if dc.Type == "" {
 		dc.Type = DefaultDedicatedColumnType
 	}
+
+	dc.Scope = DedicatedColumnScope(intern.Get(string(dc.Scope)).Get())
+	dc.Type = DedicatedColumnType(intern.Get(string(dc.Type)).Get())
+	dc.Name = intern.Get(dc.Name).Get()
+
 	return nil
 }
 

tempodb/backend/block_meta_test.go

@@ -111,7 +111,7 @@ func TestBlockMetaParsing(t *testing.T) {
 
 	meta := BlockMeta{
 		Version:         "vParquet3",
-		BlockID:         uuid.MustParse("00000000-0000-0000-0000-000000000000"),
+		BlockID:         uuid.MustParse("00000000-0000-0000-0000-000000000001"),
 		MinID:           minID,
 		MaxID:           maxID,
 		TenantID:        "single-tenant",
@@ -135,7 +135,7 @@ func TestBlockMetaParsing(t *testing.T) {
 
 	expectedJSON := `{
     	"format": "vParquet3",
-    	"blockID": "00000000-0000-0000-0000-000000000000",
+    	"blockID": "00000000-0000-0000-0000-000000000001",
     	"minID": "ACA/8tpRKjtPqxHXJDrBzA==",
     	"maxID": "8St6GtMRX/IHc0+rDQqyNQ==",
     	"tenantID": "single-tenant",
@@ -165,6 +165,14 @@ func TestBlockMetaParsing(t *testing.T) {
 	err = json.Unmarshal(metaJSON, &metaRoundtrip)
 	require.NoError(t, err)
 	assert.Equal(t, meta, metaRoundtrip)
+
+	var metaRoundtrip2 BlockMeta
+	err = json.Unmarshal(metaJSON, &metaRoundtrip2)
+	require.NoError(t, err)
+	assert.Equal(t, meta, metaRoundtrip2)
+
+	assert.Exactly(t, metaRoundtrip.Version, metaRoundtrip2.Version)
+	assert.Exactly(t, metaRoundtrip.TenantID, metaRoundtrip2.TenantID)
 }
 
 func TestDedicatedColumnsFromTempopb(t *testing.T) {

tempodb/backend/tenantindex_test.go

@@ -87,3 +87,81 @@ func TestIndexUnmarshalErrors(t *testing.T) {
 	err := test.unmarshal([]byte("bad data"))
 	assert.Error(t, err)
 }
+
+func BenchmarkIndexMarshal(b *testing.B) {
+	idx := &TenantIndex{
+		Meta: []*BlockMeta{
+			NewBlockMeta("test", uuid.New(), "v1", EncGZIP, "adsf"),
+			NewBlockMeta("test", uuid.New(), "v2", EncNone, "adsf"),
+			NewBlockMeta("test", uuid.New(), "v3", EncLZ4_4M, "adsf"),
+		},
+		CompactedMeta: []*CompactedBlockMeta{
+			{
+				BlockMeta:     *NewBlockMeta("test", uuid.New(), "v1", EncGZIP, "adsf"),
+				CompactedTime: time.Now(),
+			},
+			{
+				BlockMeta:     *NewBlockMeta("test", uuid.New(), "v1", EncZstd, "adsf"),
+				CompactedTime: time.Now(),
+			},
+			{
+				BlockMeta:     *NewBlockMeta("test", uuid.New(), "v1", EncSnappy, "adsf"),
+				CompactedTime: time.Now(),
+			},
+		},
+	}
+
+	for i := range idx.Meta {
+		idx.Meta[i].DedicatedColumns = DedicatedColumns{
+			{Scope: "resource", Name: "namespace", Type: "string"},
+			{Scope: "span", Name: "http.method", Type: "string"},
+			{Scope: "span", Name: "namespace", Type: "string"},
+		}
+	}
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_, _ = idx.marshal()
+	}
+}
+
+func BenchmarkIndexUnmarshal(b *testing.B) {
+	idx := &TenantIndex{
+		Meta: []*BlockMeta{
+			NewBlockMeta("test", uuid.New(), "v1", EncGZIP, "adsf"),
+			NewBlockMeta("test", uuid.New(), "v2", EncNone, "adsf"),
+			NewBlockMeta("test", uuid.New(), "v3", EncLZ4_4M, "adsf"),
+		},
+		CompactedMeta: []*CompactedBlockMeta{
+			{
+				BlockMeta:     *NewBlockMeta("test", uuid.New(), "v1", EncGZIP, "adsf"),
+				CompactedTime: time.Now(),
+			},
+			{
+				BlockMeta:     *NewBlockMeta("test", uuid.New(), "v1", EncZstd, "adsf"),
+				CompactedTime: time.Now(),
+			},
+			{
+				BlockMeta:     *NewBlockMeta("test", uuid.New(), "v1", EncSnappy, "adsf"),
+				CompactedTime: time.Now(),
+			},
+		},
+	}
+
+	for i := range idx.Meta {
+		idx.Meta[i].DedicatedColumns = DedicatedColumns{
+			{Scope: "resource", Name: "namespace", Type: "string"},
+			{Scope: "span", Name: "http.method", Type: "string"},
+			{Scope: "span", Name: "namespace", Type: "string"},
+		}
+	}
+
+	buf, err := idx.marshal()
+	require.NoError(b, err)
+
+	unIdx := &TenantIndex{}
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = unIdx.unmarshal(buf)
+	}
+}