db: move TargetFileSize out of LevelOptions

`LevelOptions.TargetFileSize` is used in a way that is not consistent
with the rest of the level options. Whereas other level options apply
to the expected level (e.g. `Levels[1]` applies to `L1`), the target
file size applies to the level relative to Lbase. Specifically for
i > 0, `Levels[i].TargetFileSize` is the target file size of Lbase+i-1.

We move this field to its own separate array and add a convenience
`TargetFileSize()` method.

We don't change the options encoding.

Author: RaduBerinde

cmd/pebble/db.go

@@ -103,7 +103,7 @@ func newPebbleDB(dir string) DB {
 		l.FilterType = pebble.TableFilter
 	}
 	opts.Levels[6].FilterPolicy = pebble.NoFilterPolicy
-	opts.FlushSplitBytes = opts.Levels[0].TargetFileSize
+	opts.FlushSplitBytes = opts.TargetFileSizes[0]
 
 	opts.EnsureDefaults()
 

cmd/pebble/replay_test.go

@@ -49,17 +49,19 @@ func TestParseOptionsStr(t *testing.T) {
 		},
 		{
 			c: replayConfig{optionsString: `[Options] [Level "0"] target_file_size=222`},
-			options: &pebble.Options{Levels: [manifest.NumLevels]pebble.LevelOptions{
-				0: {TargetFileSize: 222},
-			}},
+			options: &pebble.Options{
+				TargetFileSizes: [manifest.NumLevels]int64{0: 222},
+			},
 		},
 		{
 			c: replayConfig{optionsString: `[Options] lbase_max_bytes=10  max_open_files=20  [Level "0"] target_file_size=30 [Level "1"] index_block_size=40`},
 			options: &pebble.Options{
 				LBaseMaxBytes: 10,
 				MaxOpenFiles:  20,
+				TargetFileSizes: [manifest.NumLevels]int64{
+					0: 30,
+				},
 				Levels: [manifest.NumLevels]pebble.LevelOptions{
-					0: {TargetFileSize: 30},
 					1: {IndexBlockSize: 40},
 				},
 			},

compaction.go

@@ -46,8 +46,10 @@ var gcLabels = pprof.Labels("pebble", "gc")
 // expandedCompactionByteSizeLimit is the maximum number of bytes in all
 // compacted files. We avoid expanding the lower level file set of a compaction
 // if it would make the total compaction cover more than this many bytes.
-func expandedCompactionByteSizeLimit(opts *Options, level int, availBytes uint64) uint64 {
-	v := uint64(25 * opts.Levels[level].TargetFileSize)
+func expandedCompactionByteSizeLimit(
+	opts *Options, targetFileSize int64, availBytes uint64,
+) uint64 {
+	v := uint64(25 * targetFileSize)
 
 	// Never expand a compaction beyond half the available capacity, divided
 	// by the maximum number of concurrent compactions. Each of the concurrent
@@ -68,14 +70,14 @@ func expandedCompactionByteSizeLimit(opts *Options, level int, availBytes uint64
 
 // maxGrandparentOverlapBytes is the maximum bytes of overlap with level+1
 // before we stop building a single file in a level-1 to level compaction.
-func maxGrandparentOverlapBytes(opts *Options, level int) uint64 {
-	return uint64(10 * opts.Levels[level].TargetFileSize)
+func maxGrandparentOverlapBytes(targetFileSize int64) uint64 {
+	return uint64(10 * targetFileSize)
 }
 
 // maxReadCompactionBytes is used to prevent read compactions which
 // are too wide.
-func maxReadCompactionBytes(opts *Options, level int) uint64 {
-	return uint64(10 * opts.Levels[level].TargetFileSize)
+func maxReadCompactionBytes(targetFileSize int64) uint64 {
+	return uint64(10 * targetFileSize)
 }
 
 // noCloseIter wraps around a FragmentIterator, intercepting and eliding
@@ -774,8 +776,8 @@ func newFlush(
 	}
 
 	if opts.FlushSplitBytes > 0 {
-		c.maxOutputFileSize = uint64(opts.Levels[0].TargetFileSize)
-		c.maxOverlapBytes = maxGrandparentOverlapBytes(opts, 0)
+		c.maxOutputFileSize = uint64(opts.TargetFileSizes[0])
+		c.maxOverlapBytes = maxGrandparentOverlapBytes(opts.TargetFileSizes[0])
 		c.grandparents = c.version.Overlaps(baseLevel, c.bounds)
 		adjustGrandparentOverlapBytesForFlush(c, flushingBytes)
 	}

compaction_picker.go

@@ -230,15 +230,15 @@ func newPickedCompaction(
 			startLevel, baseLevel))
 	}
 
-	adjustedLevel := adjustedOutputLevel(outputLevel, baseLevel)
+	targetFileSize := opts.TargetFileSize(outputLevel, baseLevel)
 	pc := &pickedCompaction{
 		version:                cur,
 		l0Organizer:            l0Organizer,
 		baseLevel:              baseLevel,
 		inputs:                 []compactionLevel{{level: startLevel}, {level: outputLevel}},
-		maxOutputFileSize:      uint64(opts.Levels[adjustedLevel].TargetFileSize),
-		maxOverlapBytes:        maxGrandparentOverlapBytes(opts, adjustedLevel),
-		maxReadCompactionBytes: maxReadCompactionBytes(opts, adjustedLevel),
+		maxOutputFileSize:      uint64(targetFileSize),
+		maxOverlapBytes:        maxGrandparentOverlapBytes(targetFileSize),
+		maxReadCompactionBytes: maxReadCompactionBytes(targetFileSize),
 	}
 	pc.startLevel = &pc.inputs[0]
 	pc.outputLevel = &pc.inputs[1]
@@ -382,9 +382,8 @@ func (pc *pickedCompaction) setupInputs(
 		// maxExpandedBytes is the maximum size of an expanded compaction. If
 		// growing a compaction results in a larger size, the original compaction
 		// is used instead.
-		maxExpandedBytes := expandedCompactionByteSizeLimit(
-			opts, adjustedOutputLevel(pc.outputLevel.level, pc.baseLevel), diskAvailBytes,
-		)
+		targetFileSize := opts.TargetFileSize(pc.outputLevel.level, pc.baseLevel)
+		maxExpandedBytes := expandedCompactionByteSizeLimit(opts, targetFileSize, diskAvailBytes)
 
 		// Grow the sstables in inputLevel.level as long as it doesn't affect the number
 		// of sstables included from pc.outputLevel.level.
@@ -1692,8 +1691,8 @@ func (pc *pickedCompaction) maybeAddLevel(opts *Options, diskAvailBytes uint64)
 	if !opts.Experimental.MultiLevelCompactionHeuristic.allowL0() && pc.startLevel.level == 0 {
 		return pc
 	}
-	if pc.estimatedInputSize() > expandedCompactionByteSizeLimit(
-		opts, adjustedOutputLevel(pc.outputLevel.level, pc.baseLevel), diskAvailBytes) {
+	targetFileSize := opts.TargetFileSize(pc.outputLevel.level, pc.baseLevel)
+	if pc.estimatedInputSize() > expandedCompactionByteSizeLimit(opts, targetFileSize, diskAvailBytes) {
 		// Don't add a level if the current compaction exceeds the compaction size limit
 		return pc
 	}
@@ -1783,8 +1782,8 @@ func (wa WriteAmpHeuristic) pick(
 	// We consider the addition of a level as an "expansion" of the compaction.
 	// If pcMulti is past the expanded compaction byte size limit already,
 	// we don't consider it.
-	if pcMulti.estimatedInputSize() >= expandedCompactionByteSizeLimit(
-		opts, adjustedOutputLevel(pcMulti.outputLevel.level, pcMulti.baseLevel), diskAvailBytes) {
+	targetFileSize := opts.TargetFileSize(pcMulti.outputLevel.level, pcMulti.baseLevel)
+	if pcMulti.estimatedInputSize() >= expandedCompactionByteSizeLimit(opts, targetFileSize, diskAvailBytes) {
 		return pcOrig
 	}
 	picked := pcOrig

compaction_test.go

@@ -467,39 +467,39 @@ func TestPickCompaction(t *testing.T) {
 				1: {
 					newFileMeta(
 						200,
-						expandedCompactionByteSizeLimit(opts, 1, math.MaxUint64)-1,
+						expandedCompactionByteSizeLimit(opts, 4<<20, math.MaxUint64)-1,
 						base.ParseInternalKey("i1.SET.201"),
 						base.ParseInternalKey("i2.SET.202"),
 					),
 					newFileMeta(
 						210,
-						expandedCompactionByteSizeLimit(opts, 1, math.MaxUint64)-1,
+						expandedCompactionByteSizeLimit(opts, 4<<20, math.MaxUint64)-1,
 						base.ParseInternalKey("j1.SET.211"),
 						base.ParseInternalKey("j2.SET.212"),
 					),
 					newFileMeta(
 						220,
-						expandedCompactionByteSizeLimit(opts, 1, math.MaxUint64)-1,
+						expandedCompactionByteSizeLimit(opts, 4<<20, math.MaxUint64)-1,
 						base.ParseInternalKey("k1.SET.221"),
 						base.ParseInternalKey("k2.SET.222"),
 					),
 					newFileMeta(
 						230,
-						expandedCompactionByteSizeLimit(opts, 1, math.MaxUint64)-1,
+						expandedCompactionByteSizeLimit(opts, 4<<20, math.MaxUint64)-1,
 						base.ParseInternalKey("l1.SET.231"),
 						base.ParseInternalKey("l2.SET.232"),
 					),
 				},
 				2: {
 					newFileMeta(
 						300,
-						expandedCompactionByteSizeLimit(opts, 2, math.MaxUint64)-1,
+						expandedCompactionByteSizeLimit(opts, 8<<20, math.MaxUint64)-1,
 						base.ParseInternalKey("a0.SET.301"),
 						base.ParseInternalKey("l0.SET.302"),
 					),
 					newFileMeta(
 						310,
-						expandedCompactionByteSizeLimit(opts, 2, math.MaxUint64)-1,
+						expandedCompactionByteSizeLimit(opts, 8<<20, math.MaxUint64)-1,
 						base.ParseInternalKey("l2.SET.311"),
 						base.ParseInternalKey("z2.SET.312"),
 					),
@@ -2229,8 +2229,8 @@ func TestCompactionErrorCleanup(t *testing.T) {
 		},
 	}
 	opts.WithFSDefaults()
-	for i := range opts.Levels {
-		opts.Levels[i].TargetFileSize = 1
+	for i := range opts.TargetFileSizes {
+		opts.TargetFileSizes[i] = 1
 	}
 	opts.testingRandomized(t)
 	d, err := Open("", opts)
@@ -2932,8 +2932,8 @@ func TestCompactionErrorStats(t *testing.T) {
 		},
 	}
 	opts.WithFSDefaults()
-	for i := range opts.Levels {
-		opts.Levels[i].TargetFileSize = 1
+	for i := range opts.TargetFileSizes {
+		opts.TargetFileSizes[i] = 1
 	}
 	opts.testingRandomized(t)
 	d, err := Open("", opts)

data_test.go

@@ -1779,13 +1779,13 @@ func parseDBOptionsArgs(opts *Options, args []datadriven.CmdArg) error {
 				if err != nil {
 					return err
 				}
-				opts.Levels[i].TargetFileSize = size
+				opts.TargetFileSizes[i] = size
 			}
 			// Set the remaining file sizes. Normally, EnsureDefaults() would do that
 			// for us but it was already called and the target file sizes for all
 			// levels are now set to the defaults.
-			for i := len(cmdArg.Vals); i < len(opts.Levels); i++ {
-				opts.Levels[i].TargetFileSize = opts.Levels[i-1].TargetFileSize * 2
+			for i := len(cmdArg.Vals); i < len(opts.TargetFileSizes); i++ {
+				opts.TargetFileSizes[i] = opts.TargetFileSizes[i-1] * 2
 			}
 		case "value-separation":
 			if len(cmdArg.Vals) != 3 {

iterator_test.go

@@ -2098,25 +2098,25 @@ func TestRangeKeyMaskingRandomized(t *testing.T) {
 	// Define a simple base testOpts, and a randomized testOpts. The results
 	// of iteration will be compared.
 	type testOpts struct {
-		levelOpts []LevelOptions
-		filter    func() BlockPropertyFilterMask
+		levelOpts       []LevelOptions
+		targetFileSizes []int64
+		filter          func() BlockPropertyFilterMask
 	}
 
 	baseOpts := testOpts{
-		levelOpts: make([]LevelOptions, 7),
+		levelOpts:       make([]LevelOptions, 7),
+		targetFileSizes: make([]int64, 7),
 	}
 	for i := 0; i < len(baseOpts.levelOpts); i++ {
-		baseOpts.levelOpts[i].TargetFileSize = 1
+		baseOpts.targetFileSizes[i] = 1
 		baseOpts.levelOpts[i].BlockSize = 1
 	}
 
 	randomOpts := testOpts{
 		levelOpts: []LevelOptions{
-			{
-				TargetFileSize: int64(1 + rng.IntN(2<<20)), // Vary the L0 file size.
-				BlockSize:      1 + rng.IntN(32<<10),
-			},
+			{BlockSize: 1 + rng.IntN(32<<10)},
 		},
+		targetFileSizes: []int64{int64(1 + rng.IntN(2<<20))}, // Vary the L0 file size.
 	}
 	if rng.IntN(2) == 0 {
 		randomOpts.filter = func() BlockPropertyFilterMask {
@@ -2135,6 +2135,7 @@ func TestRangeKeyMaskingRandomized(t *testing.T) {
 			sstable.NewTestKeysBlockPropertyCollector,
 		},
 	}
+	copy(opts1.TargetFileSizes[:], baseOpts.targetFileSizes)
 	copy(opts1.Levels[:], baseOpts.levelOpts)
 	d1, err := Open("", opts1)
 	require.NoError(t, err)
@@ -2148,6 +2149,7 @@ func TestRangeKeyMaskingRandomized(t *testing.T) {
 			sstable.NewTestKeysBlockPropertyCollector,
 		},
 	}
+	copy(opts2.TargetFileSizes[:], randomOpts.targetFileSizes)
 	copy(opts2.Levels[:], randomOpts.levelOpts)
 	d2, err := Open("", opts2)
 	require.NoError(t, err)
@@ -2689,8 +2691,8 @@ func buildFragmentedRangeKey(b testing.TB, seed uint64) (d *DB, keys [][]byte) {
 		L0CompactionFileThreshold: 1,
 	}
 	opts.EnsureDefaults()
-	for l := 0; l < len(opts.Levels); l++ {
-		opts.Levels[l].TargetFileSize = 1
+	for l := range opts.TargetFileSizes {
+		opts.TargetFileSizes[l] = 1
 	}
 	var err error
 	d, err = Open("", opts)

metamorphic/options.go

@@ -770,21 +770,22 @@ func RandomOptions(
 		opts.AllocatorSizeClasses = pebble.JemallocSizeClasses
 	}
 
-	var lopts pebble.LevelOptions
-	lopts.BlockRestartInterval = 1 + rng.IntN(64)  // 1 - 64
-	lopts.BlockSize = 1 << uint(rng.IntN(24))      // 1 - 16MB
-	lopts.BlockSizeThreshold = 50 + rng.IntN(50)   // 50 - 100
-	lopts.IndexBlockSize = 1 << uint(rng.IntN(24)) // 1 - 16MB
-	lopts.TargetFileSize = 1 << uint(rng.IntN(28)) // 1 - 256MB
-	if lopts.TargetFileSize < 1<<12 {
+	opts.TargetFileSizes[0] = 1 << uint(rng.IntN(28)) // 1 - 256MB
+	if opts.TargetFileSizes[0] < 1<<12 {
 		// We will generate a lot of files, which will slow down compactions.
 		// Increase L0StopWritesThreshold to reduce the number of write stalls
 		// that could cause operation timeouts.
 		opts.L0StopWritesThreshold = 100
 	}
 	// The EstimatedSize of an empty table writer is 8 bytes. We want something a
 	// little bigger than that as the minimum target.
-	lopts.TargetFileSize = max(lopts.TargetFileSize, 12)
+	opts.TargetFileSizes[0] = max(opts.TargetFileSizes[0], 12)
+
+	var lopts pebble.LevelOptions
+	lopts.BlockRestartInterval = 1 + rng.IntN(64)  // 1 - 64
+	lopts.BlockSize = 1 << uint(rng.IntN(24))      // 1 - 16MB
+	lopts.BlockSizeThreshold = 50 + rng.IntN(50)   // 50 - 100
+	lopts.IndexBlockSize = 1 << uint(rng.IntN(24)) // 1 - 16MB
 
 	// We either use no bloom filter, the default filter, or a filter with
 	// randomized bits-per-key setting. We zero out the Filters map. It'll get

metrics_test.go

@@ -178,7 +178,7 @@ func TestMetrics(t *testing.T) {
 				MaxBlobReferenceDepth: 5,
 			}
 		}
-		opts.Levels[0] = LevelOptions{TargetFileSize: 50}
+		opts.TargetFileSizes[0] = 50
 
 		// Prevent foreground flushes and compactions from triggering asynchronous
 		// follow-up compactions. This avoids asynchronously-scheduled work from