db: rename LevelMetrics table fields

Rename LevelMetrics fields that refer to 'files' to refer to 'tables' instead.
With the introduction of value separation, significant volumes of data will
live in blob files not accounted within these particular existing metrics.

Author: jbowens

cmd/pebble/write_bench.go

@@ -293,7 +293,7 @@ func runWriteBenchmark(_ *cobra.Command, args []string) error {
 			}
 
 			// Print the current stats.
-			l0Files := m.Levels[0].NumFiles
+			l0Files := m.Levels[0].TablesCount
 			l0Sublevels := m.Levels[0].Sublevels
 			nLevels := 0
 			for _, l := range m.Levels {

compaction.go

@@ -1277,11 +1277,11 @@ func (d *DB) runIngestFlush(c *compaction) (*manifest.VersionEdit, error) {
 			levelMetrics = &LevelMetrics{}
 			c.metrics[level] = levelMetrics
 		}
-		levelMetrics.NumFiles--
-		levelMetrics.Size -= int64(m.Size)
+		levelMetrics.TablesCount--
+		levelMetrics.TablesSize -= int64(m.Size)
 		for i := range added {
-			levelMetrics.NumFiles++
-			levelMetrics.Size += int64(added[i].Meta.Size)
+			levelMetrics.TablesCount++
+			levelMetrics.TablesSize += int64(added[i].Meta.Size)
 		}
 	}
 
@@ -3250,8 +3250,8 @@ func (c *compaction) makeVersionEdit(result compact.Result) (*versionEdit, error
 			outputMetrics.TablesFlushed++
 			outputMetrics.BytesFlushed += fileMeta.Size
 		}
-		outputMetrics.Size += int64(fileMeta.Size)
-		outputMetrics.NumFiles++
+		outputMetrics.TablesSize += int64(fileMeta.Size)
+		outputMetrics.TablesCount++
 		outputMetrics.Additional.BytesWrittenDataBlocks += t.WriterMeta.Properties.DataSize
 		outputMetrics.Additional.BytesWrittenValueBlocks += t.WriterMeta.Properties.ValueBlocksSize
 	}

compaction_picker_test.go

@@ -1661,9 +1661,9 @@ func TestCompactionPickerScores(t *testing.T) {
 			fmt.Fprintf(&buf, "L       Size   Score\n")
 			for l, lm := range d.Metrics().Levels {
 				if l < numLevels-1 {
-					fmt.Fprintf(&buf, "L%-3d\t%-7s%.1f\n", l, humanize.Bytes.Int64(lm.Size), lm.Score)
+					fmt.Fprintf(&buf, "L%-3d\t%-7s%.1f\n", l, humanize.Bytes.Int64(lm.TablesSize), lm.Score)
 				} else {
-					fmt.Fprintf(&buf, "L%-3d\t%-7s-\n", l, humanize.Bytes.Int64(lm.Size))
+					fmt.Fprintf(&buf, "L%-3d\t%-7s-\n", l, humanize.Bytes.Int64(lm.TablesSize))
 				}
 			}
 			return buf.String()

file_cache_test.go

@@ -325,7 +325,7 @@ func TestVirtualReadsWiring(t *testing.T) {
 	require.NoError(t, d.Apply(b, nil))
 	require.NoError(t, d.Flush())
 	require.NoError(t, d.Compact([]byte{'a'}, []byte{'b'}, false))
-	require.Equal(t, 1, int(d.Metrics().Levels[6].NumFiles))
+	require.Equal(t, 1, int(d.Metrics().Levels[6].TablesCount))
 
 	d.mu.Lock()
 
@@ -402,8 +402,8 @@ func TestVirtualReadsWiring(t *testing.T) {
 				lm = &LevelMetrics{}
 				metrics[de.Level] = lm
 			}
-			metrics[de.Level].NumFiles--
-			metrics[de.Level].Size -= int64(f.Size)
+			metrics[de.Level].TablesCount--
+			metrics[de.Level].TablesSize -= int64(f.Size)
 		}
 		return metrics
 	}
@@ -442,7 +442,7 @@ func TestVirtualReadsWiring(t *testing.T) {
 	d.mu.Unlock()
 
 	// Confirm that there were only 2 virtual sstables in L6.
-	require.Equal(t, 2, int(d.Metrics().Levels[6].NumFiles))
+	require.Equal(t, 2, int(d.Metrics().Levels[6].TablesCount))
 
 	// These reads will go through the file cache.
 	iter, _ := d.NewIter(nil)

ingest.go

@@ -2054,8 +2054,8 @@ func (d *DB) ingestApply(
 				levelMetrics = &LevelMetrics{}
 				metrics[f.Level] = levelMetrics
 			}
-			levelMetrics.NumFiles++
-			levelMetrics.Size += int64(m.Size)
+			levelMetrics.TablesCount++
+			levelMetrics.TablesSize += int64(m.Size)
 			levelMetrics.BytesIngested += m.Size
 			levelMetrics.TablesIngested++
 		}
@@ -2072,11 +2072,11 @@ func (d *DB) ingestApply(
 				levelMetrics = &LevelMetrics{}
 				metrics[level] = levelMetrics
 			}
-			levelMetrics.NumFiles--
-			levelMetrics.Size -= int64(m.Size)
+			levelMetrics.TablesCount--
+			levelMetrics.TablesSize -= int64(m.Size)
 			for i := range added {
-				levelMetrics.NumFiles++
-				levelMetrics.Size += int64(added[i].Meta.Size)
+				levelMetrics.TablesCount++
+				levelMetrics.TablesSize += int64(added[i].Meta.Size)
 			}
 		}
 		if exciseSpan.Valid() {

iterator_test.go

@@ -2764,7 +2764,7 @@ func BenchmarkSeekPrefixTombstones(b *testing.B) {
 	}
 
 	d.mu.Lock()
-	require.Equal(b, int64(ks.Count()-1), d.mu.versions.metrics.Levels[numLevels-1].NumFiles)
+	require.Equal(b, int64(ks.Count()-1), d.mu.versions.metrics.Levels[numLevels-1].TablesCount)
 	d.mu.Unlock()
 
 	seekKey := testkeys.Key(ks, 1)
@@ -3053,7 +3053,7 @@ func runBenchmarkQueueWorkload(b *testing.B, deleteRatio float32, initOps int, v
 	for i := 0; i < numLevels; i++ {
 		numTombstones := stats.Levels[i].KindsCount[base.InternalKeyKindDelete]
 		numSets := stats.Levels[i].KindsCount[base.InternalKeyKindSet]
-		numTables := metrics.Levels[i].NumFiles
+		numTables := metrics.Levels[i].TablesCount
 		if numSets > 0 {
 			b.Logf("L%d: %d tombstones, %d sets, %d sstables\n", i, numTombstones, numSets, numTables)
 		}

metrics.go

@@ -46,14 +46,14 @@ type LevelMetrics struct {
 	// sublevel count of 0, implying no read amplification. Only L0 will have
 	// a sublevel count other than 0 or 1.
 	Sublevels int32
-	// The total number of files in the level.
-	NumFiles int64
+	// The total count of sstables in the level.
+	TablesCount int64
+	// The total size in bytes of the sstables in the level.
+	TablesSize int64
 	// The total number of virtual sstables in the level.
-	NumVirtualFiles uint64
-	// The total size in bytes of the files in the level.
-	Size int64
+	VirtualTablesCount uint64
 	// The total size of the virtual sstables in the level.
-	VirtualSize uint64
+	VirtualTablesSize uint64
 	// The level's compaction score. This is the compensatedScoreRatio in the
 	// candidateLevelInfo.
 	Score float64
@@ -118,10 +118,10 @@ type LevelMetrics struct {
 
 // Add updates the counter metrics for the level.
 func (m *LevelMetrics) Add(u *LevelMetrics) {
-	m.NumFiles += u.NumFiles
-	m.NumVirtualFiles += u.NumVirtualFiles
-	m.VirtualSize += u.VirtualSize
-	m.Size += u.Size
+	m.TablesCount += u.TablesCount
+	m.VirtualTablesCount += u.VirtualTablesCount
+	m.VirtualTablesSize += u.VirtualTablesSize
+	m.TablesSize += u.TablesSize
 	m.BytesIn += u.BytesIn
 	m.BytesIngested += u.BytesIngested
 	m.BytesMoved += u.BytesMoved
@@ -399,7 +399,7 @@ func (m *Metrics) DiskSpaceUsage() uint64 {
 func (m *Metrics) NumVirtual() uint64 {
 	var n uint64
 	for _, level := range m.Levels {
-		n += level.NumVirtualFiles
+		n += level.VirtualTablesCount
 	}
 	return n
 }
@@ -410,7 +410,7 @@ func (m *Metrics) NumVirtual() uint64 {
 func (m *Metrics) VirtualSize() uint64 {
 	var size uint64
 	for _, level := range m.Levels {
-		size += level.VirtualSize
+		size += level.VirtualTablesSize
 	}
 	return size
 }
@@ -449,8 +449,8 @@ func (m *Metrics) Total() LevelMetrics {
 func (m *Metrics) RemoteTablesTotal() (count uint64, size uint64) {
 	var liveTables, liveTableBytes int64
 	for level := 0; level < numLevels; level++ {
-		liveTables += m.Levels[level].NumFiles
-		liveTableBytes += m.Levels[level].Size
+		liveTables += m.Levels[level].TablesCount
+		liveTableBytes += m.Levels[level].TablesSize
 	}
 	totalCount := liveTables + m.Table.ObsoleteCount + m.Table.ZombieCount
 	localCount := m.Table.Local.LiveCount + m.Table.Local.ObsoleteCount + m.Table.Local.ZombieCount
@@ -553,10 +553,10 @@ func (m *Metrics) SafeFormat(w redact.SafePrinter, _ rune) {
 		}
 
 		w.Printf("| %5s %6s %6s %7s | %5s | %5s | %5s %6s | %5s %6s | %5s %6s | %5s | %3d %4s",
-			humanize.Count.Int64(m.NumFiles),
-			humanize.Bytes.Int64(m.Size),
+			humanize.Count.Int64(m.TablesCount),
+			humanize.Bytes.Int64(m.TablesSize),
 			humanize.Bytes.Uint64(m.Additional.ValueBlocksSize),
-			humanize.Count.Uint64(m.NumVirtualFiles),
+			humanize.Count.Uint64(m.VirtualTablesCount),
 			redact.Safe(scoreStr),
 			humanize.Bytes.Uint64(m.BytesIn),
 			humanize.Count.Uint64(m.TablesIngested),

metrics_test.go

@@ -82,10 +82,10 @@ func exampleMetrics() Metrics {
 		l := &m.Levels[i]
 		base := uint64((i + 1) * 100)
 		l.Sublevels = int32(i + 1)
-		l.NumFiles = int64(base) + 1
-		l.NumVirtualFiles = uint64(base) + 1
-		l.VirtualSize = base + 3
-		l.Size = int64(base) + 2
+		l.TablesCount = int64(base) + 1
+		l.VirtualTablesCount = uint64(base) + 1
+		l.VirtualTablesSize = base + 3
+		l.TablesSize = int64(base) + 2
 		l.Score = float64(base) + 3
 		l.BytesIn = base + 4
 		l.BytesIngested = base + 4
@@ -394,7 +394,7 @@ func TestMetrics(t *testing.T) {
 					if l >= numLevels {
 						panic(fmt.Sprintf("invalid level %d", l))
 					}
-					buf.WriteString(fmt.Sprintf("%d\n", m.Levels[l].NumVirtualFiles))
+					buf.WriteString(fmt.Sprintf("%d\n", m.Levels[l].VirtualTablesCount))
 				} else if line == "remote-count" {
 					count, _ := m.RemoteTablesTotal()
 					buf.WriteString(fmt.Sprintf("%d\n", count))

obsolete_files.go

@@ -320,7 +320,7 @@ func (d *DB) getDeletionPacerInfo() deletionPacerInfo {
 	pacerInfo.freeBytes = d.calculateDiskAvailableBytes()
 	d.mu.Lock()
 	pacerInfo.obsoleteBytes = d.mu.versions.metrics.Table.ObsoleteSize
-	pacerInfo.liveBytes = uint64(d.mu.versions.metrics.Total().Size)
+	pacerInfo.liveBytes = uint64(d.mu.versions.metrics.Total().TablesSize)
 	d.mu.Unlock()
 	return pacerInfo
 }

version_set.go

@@ -344,9 +344,9 @@ func (vs *versionSet) load(
 
 	for i := range vs.metrics.Levels {
 		l := &vs.metrics.Levels[i]
-		l.NumFiles = int64(newVersion.Levels[i].Len())
+		l.TablesCount = int64(newVersion.Levels[i].Len())
 		files := newVersion.Levels[i].Slice()
-		l.Size = int64(files.SizeSum())
+		l.TablesSize = int64(files.SizeSum())
 	}
 	for _, l := range newVersion.Levels {
 		for f := range l.All() {
@@ -549,7 +549,7 @@ func (vs *versionSet) UpdateVersionLocked(updateFn func() (versionUpdate, error)
 
 	var nextSnapshotFilecount int64
 	for i := range vs.metrics.Levels {
-		nextSnapshotFilecount += vs.metrics.Levels[i].NumFiles
+		nextSnapshotFilecount += vs.metrics.Levels[i].TablesCount
 	}
 	if sizeExceeded && !requireRotation {
 		requireRotation = vs.rotationHelper.ShouldRotate(nextSnapshotFilecount)
@@ -708,30 +708,30 @@ func (vs *versionSet) UpdateVersionLocked(updateFn func() (versionUpdate, error)
 	vs.metrics.updateLevelMetrics(vu.Metrics)
 	for i := range vs.metrics.Levels {
 		l := &vs.metrics.Levels[i]
-		l.NumFiles = int64(newVersion.Levels[i].Len())
-		l.NumVirtualFiles = newVersion.Levels[i].NumVirtual
-		l.VirtualSize = newVersion.Levels[i].VirtualSize
-		l.Size = int64(newVersion.Levels[i].Size())
+		l.TablesCount = int64(newVersion.Levels[i].Len())
+		l.VirtualTablesCount = newVersion.Levels[i].NumVirtual
+		l.VirtualTablesSize = newVersion.Levels[i].VirtualSize
+		l.TablesSize = int64(newVersion.Levels[i].Size())
 
 		l.Sublevels = 0
-		if l.NumFiles > 0 {
+		if l.TablesCount > 0 {
 			l.Sublevels = 1
 		}
 		if invariants.Enabled {
 			levelFiles := newVersion.Levels[i].Slice()
-			if size := int64(levelFiles.SizeSum()); l.Size != size {
-				vs.opts.Logger.Fatalf("versionSet metrics L%d Size = %d, actual size = %d", i, l.Size, size)
+			if size := int64(levelFiles.SizeSum()); l.TablesSize != size {
+				vs.opts.Logger.Fatalf("versionSet metrics L%d Size = %d, actual size = %d", i, l.TablesSize, size)
 			}
-			if nVirtual := levelFiles.NumVirtual(); nVirtual != l.NumVirtualFiles {
+			if nVirtual := levelFiles.NumVirtual(); nVirtual != l.VirtualTablesCount {
 				vs.opts.Logger.Fatalf(
 					"versionSet metrics L%d NumVirtual = %d, actual NumVirtual = %d",
-					i, l.NumVirtualFiles, nVirtual,
+					i, l.VirtualTablesCount, nVirtual,
 				)
 			}
-			if vSize := levelFiles.VirtualSizeSum(); vSize != l.VirtualSize {
+			if vSize := levelFiles.VirtualSizeSum(); vSize != l.VirtualTablesSize {
 				vs.opts.Logger.Fatalf(
 					"versionSet metrics L%d Virtual size = %d, actual size = %d",
-					i, l.VirtualSize, vSize,
+					i, l.VirtualTablesSize, vSize,
 				)
 			}
 		}
@@ -1151,8 +1151,8 @@ func newFileMetrics(newFiles []manifest.NewTableEntry) levelMetricsDelta {
 			lm = &LevelMetrics{}
 			m[nf.Level] = lm
 		}
-		lm.NumFiles++
-		lm.Size += int64(nf.Meta.Size)
+		lm.TablesCount++
+		lm.TablesSize += int64(nf.Meta.Size)
 	}
 	return m
 }