db: introduce DBCompressionSettings

This commit introduces `DBCompressionSettings` which contains a
`sstable.CompressionProfile` for each level.

We define three standard levels (fastest, balanced, good).

Author: RaduBerinde

metamorphic/options.go

@@ -811,6 +811,20 @@ func RandomOptions(
 	}
 	opts.Levels[0] = lopts
 
+	// Sometimes apply DBCompressionSettings.
+	if rng.IntN(2) == 0 {
+		csList := []pebble.DBCompressionSettings{
+			pebble.DBCompressionNone,
+			pebble.DBCompressionFastest,
+			pebble.DBCompressionBalanced,
+			pebble.DBCompressionGood,
+		}
+		cs := csList[rng.IntN(len(csList))]
+		opts.ApplyCompressionSettings(func() pebble.DBCompressionSettings {
+			return cs
+		})
+	}
+
 	// Explicitly disable disk-backed FS's for the random configurations. The
 	// single standard test configuration that uses a disk-backed FS is
 	// sufficient.

options.go

@@ -405,6 +405,8 @@ type LevelOptions struct {
 	//
 	// The default value is Snappy for L0, or the function from the previous level
 	// for all other levels.
+	//
+	// ApplyCompressionSettings can be used to initialize this field for all levels.
 	Compression func() *sstable.CompressionProfile
 
 	// FilterPolicy defines a filter algorithm (such as a Bloom filter) that can
@@ -1273,6 +1275,54 @@ func DebugCheckLevels(db *DB) error {
 	return db.CheckLevels(nil)
 }
 
+// DBCompressionSettings contains compression settings for the entire store. It
+// defines compression profiles for each LSM level.
+type DBCompressionSettings struct {
+	Name   string
+	Levels [manifest.NumLevels]*block.CompressionProfile
+}
+
+// Predefined compression settings.
+var (
+	DBCompressionNone     = UniformDBCompressionSettings("NoCompression", block.NoCompression)
+	DBCompressionFastest  = UniformDBCompressionSettings("Fastest", block.FastestCompression)
+	DBCompressionBalanced = func() DBCompressionSettings {
+		profile := UniformDBCompressionSettings("Balanced", block.FastestCompression)
+		profile.Levels[manifest.NumLevels-2] = block.FastCompression     // Zstd1 for value blocks.
+		profile.Levels[manifest.NumLevels-1] = block.BalancedCompression // Zstd1 for data blocks, Zstd3 for value blocks.
+		return profile
+	}()
+	DBCompressionGood = func() DBCompressionSettings {
+		profile := UniformDBCompressionSettings("Good", block.FastestCompression)
+		profile.Levels[manifest.NumLevels-2] = block.BalancedCompression // Zstd1 for data blocks, Zstd3 for value blocks.
+		profile.Levels[manifest.NumLevels-1] = block.GoodCompression     // Zstd3 for data and value blocks.
+		return profile
+	}()
+)
+
+// UniformDBCompressionSettings returns a DBCompressionSettings which uses the
+// same compression profile on all LSM levels.
+func UniformDBCompressionSettings(
+	name string, profile *block.CompressionProfile,
+) DBCompressionSettings {
+	cs := DBCompressionSettings{Name: name}
+	for i := range cs.Levels {
+		cs.Levels[i] = profile
+	}
+	return cs
+}
+
+// ApplyCompressionSettings sets the Compression field in each LevelOptions to
+// call the given function and return the compression profile for that level.
+func (o *Options) ApplyCompressionSettings(csFn func() DBCompressionSettings) {
+	for i := range o.Levels {
+		levelIdx := i
+		o.Levels[i].Compression = func() *block.CompressionProfile {
+			return csFn().Levels[levelIdx]
+		}
+	}
+}
+
 // EnsureDefaults ensures that the default values for all options are set if a
 // valid value was not already specified.
 func (o *Options) EnsureDefaults() {

options_test.go

@@ -14,6 +14,7 @@ import (
 	"github.com/cockroachdb/errors"
 	"github.com/cockroachdb/pebble/internal/base"
 	"github.com/cockroachdb/pebble/internal/testkeys"
+	"github.com/cockroachdb/pebble/sstable/block"
 	"github.com/cockroachdb/pebble/vfs"
 	"github.com/cockroachdb/pebble/wal"
 	"github.com/stretchr/testify/require"
@@ -576,3 +577,26 @@ func TestKeyCategories(t *testing.T) {
 		})
 	}
 }
+
+func TestApplyDBCompressionSettings(t *testing.T) {
+	var o Options
+	o.testingRandomized(t)
+
+	var profile DBCompressionSettings
+	o.ApplyCompressionSettings(func() DBCompressionSettings {
+		return profile
+	})
+
+	profile = UniformDBCompressionSettings("Test", block.FastestCompression)
+	profile.Levels[1] = block.FastestCompression
+	profile.Levels[2] = block.BalancedCompression
+	profile.Levels[3] = block.GoodCompression
+	require.Equal(t, block.FastestCompression, o.Levels[1].Compression())
+	require.Equal(t, block.BalancedCompression, o.Levels[2].Compression())
+	require.Equal(t, block.GoodCompression, o.Levels[3].Compression())
+
+	profile = UniformDBCompressionSettings("Test2", block.FastestCompression)
+	require.Equal(t, block.FastestCompression, o.Levels[1].Compression())
+	require.Equal(t, block.FastestCompression, o.Levels[2].Compression())
+	require.Equal(t, block.FastestCompression, o.Levels[3].Compression())
+}

sstable/block/compression.go

@@ -61,17 +61,41 @@ var (
 	MinLZCompression  = simpleCompressionProfile("MinLZ", compression.MinLZFastest)
 
 	DefaultCompression = SnappyCompression
-	FastestCompression = simpleCompressionProfile("Fastest", fastestAlgorithm())
+	FastestCompression = simpleCompressionProfile("Fastest", fastestCompression)
+
+	FastCompression = registerCompressionProfile(CompressionProfile{
+		Name:                "Fast",
+		DataBlocks:          fastestCompression,
+		ValueBlocks:         compression.ZstdLevel1,
+		OtherBlocks:         fastestCompression,
+		MinReductionPercent: 10,
+	})
+
+	BalancedCompression = registerCompressionProfile(CompressionProfile{
+		Name:                "Balanced",
+		DataBlocks:          compression.ZstdLevel1,
+		ValueBlocks:         compression.ZstdLevel3,
+		OtherBlocks:         fastestCompression,
+		MinReductionPercent: 5,
+	})
+
+	GoodCompression = registerCompressionProfile(CompressionProfile{
+		Name:                "Good",
+		DataBlocks:          compression.ZstdLevel3,
+		ValueBlocks:         compression.ZstdLevel3,
+		OtherBlocks:         fastestCompression,
+		MinReductionPercent: 5,
+	})
 )
 
-var fastestAlgorithm = func() compression.Setting {
+var fastestCompression = func() compression.Setting {
 	if runtime.GOARCH == "arm64" {
 		// MinLZ is generally faster and better than Snappy except for arm64: Snappy
 		// has an arm64 assembly implementation and MinLZ does not.
 		return compression.Snappy
 	}
 	return compression.MinLZFastest
-}
+}()
 
 // simpleCompressionProfile returns a CompressionProfile that uses the same
 // compression setting for all blocks and which uses the uncompressed block if
@@ -80,15 +104,13 @@ var fastestAlgorithm = func() compression.Setting {
 //
 // It should only be used during global initialization.
 func simpleCompressionProfile(name string, setting compression.Setting) *CompressionProfile {
-	p := &CompressionProfile{
+	return registerCompressionProfile(CompressionProfile{
 		Name:                name,
 		DataBlocks:          setting,
 		ValueBlocks:         setting,
 		OtherBlocks:         setting,
 		MinReductionPercent: 12,
-	}
-	registerCompressionProfile(p)
-	return p
+	})
 }
 
 // CompressionProfileByName returns the built-in compression profile with the
@@ -102,12 +124,13 @@ func CompressionProfileByName(name string) *CompressionProfile {
 
 var compressionProfileMap = make(map[string]*CompressionProfile)
 
-func registerCompressionProfile(p *CompressionProfile) {
+func registerCompressionProfile(p CompressionProfile) *CompressionProfile {
 	key := strings.ToLower(p.Name)
 	if _, ok := compressionProfileMap[key]; ok {
 		panic(errors.AssertionFailedf("duplicate compression profile: %s", p.Name))
 	}
-	compressionProfileMap[key] = p
+	compressionProfileMap[key] = &p
+	return &p
 }
 
 // CompressionIndicator is the byte stored physically within the block.Trailer