db: add counts for local tables

This patch adds counts for local [live/zombie/obsolete] tables.

Author: annrpom

db.go

@@ -2049,7 +2049,7 @@ func (d *DB) Metrics() *Metrics {
 	}
 	metrics.Table.ZombieCount = int64(d.mu.versions.zombieTables.Count())
 	metrics.Table.ZombieSize = d.mu.versions.zombieTables.TotalSize()
-	metrics.Table.Local.ZombieSize = d.mu.versions.zombieTables.LocalSize()
+	metrics.Table.Local.ZombieCount, metrics.Table.Local.ZombieSize = d.mu.versions.zombieTables.LocalStats()
 	metrics.private.optionsFileSize = d.optionsFileSize
 
 	// TODO(jackson): Consider making these metrics optional.

metrics.go

@@ -299,10 +299,16 @@ type Metrics struct {
 		Local struct {
 			// LiveSize is the number of bytes in live tables.
 			LiveSize uint64
+			// LiveCount is the number of live tables.
+			LiveCount uint64
 			// ObsoleteSize is the number of bytes in obsolete tables.
 			ObsoleteSize uint64
+			// ObsoleteCount is the number of obsolete tables.
+			ObsoleteCount uint64
 			// ZombieSize is the number of bytes in zombie tables.
 			ZombieSize uint64
+			// ZombieCount is the number of zombie tables.
+			ZombieCount uint64
 		}
 	}
 

obsolete_files.go

@@ -332,6 +332,7 @@ func (d *DB) onObsoleteTableDelete(fileSize uint64, isLocal bool) {
 	d.mu.versions.metrics.Table.ObsoleteSize -= fileSize
 	if isLocal {
 		d.mu.versions.metrics.Table.Local.ObsoleteSize -= fileSize
+		d.mu.versions.metrics.Table.Local.ObsoleteCount--
 	}
 	d.mu.Unlock()
 }
@@ -620,9 +621,10 @@ func makeZombieObjects() zombieObjects {
 // iterator. Such objects are 'dead,' but cannot be deleted until iterators that
 // may access them are closed.
 type zombieObjects struct {
-	objs      map[base.DiskFileNum]objectInfo
-	totalSize uint64
-	localSize uint64
+	objs       map[base.DiskFileNum]objectInfo
+	totalSize  uint64
+	localSize  uint64
+	localCount uint64
 }
 
 // Add adds an object to the set of zombie objects.
@@ -634,6 +636,7 @@ func (z *zombieObjects) Add(obj objectInfo) {
 	z.totalSize += obj.FileSize
 	if obj.isLocal {
 		z.localSize += obj.FileSize
+		z.localCount++
 	}
 }
 
@@ -674,6 +677,7 @@ func (z *zombieObjects) Extract(fileNum base.DiskFileNum) objectInfo {
 	z.totalSize -= obj.FileSize
 	if obj.isLocal {
 		z.localSize -= obj.FileSize
+		z.localCount--
 	}
 	return obj
 }
@@ -683,9 +687,9 @@ func (z *zombieObjects) TotalSize() uint64 {
 	return z.totalSize
 }
 
-// LocalSize returns the size of all local objects in the set.
-func (z *zombieObjects) LocalSize() uint64 {
-	return z.localSize
+// LocalStats returns the count and size of all local objects in the set.
+func (z *zombieObjects) LocalStats() (count uint64, size uint64) {
+	return z.localCount, z.localSize
 }
 
 func mergeObjectInfos(a, b []objectInfo) []objectInfo {

version_set.go

@@ -353,14 +353,20 @@ func (vs *versionSet) load(
 	for _, l := range newVersion.Levels {
 		for f := range l.All() {
 			if !f.Virtual {
-				_, localSize := sizeIfLocal(f.FileBacking, vs.provider)
+				isLocal, localSize := sizeIfLocal(f.FileBacking, vs.provider)
 				vs.metrics.Table.Local.LiveSize = uint64(int64(vs.metrics.Table.Local.LiveSize) + localSize)
+				if isLocal {
+					vs.metrics.Table.Local.LiveCount++
+				}
 			}
 		}
 	}
 	vs.virtualBackings.ForEach(func(backing *fileBacking) {
-		_, localSize := sizeIfLocal(backing, vs.provider)
+		isLocal, localSize := sizeIfLocal(backing, vs.provider)
 		vs.metrics.Table.Local.LiveSize = uint64(int64(vs.metrics.Table.Local.LiveSize) + localSize)
+		if isLocal {
+			vs.metrics.Table.Local.LiveCount++
+		}
 	})
 
 	vs.setCompactionPicker(
@@ -569,7 +575,7 @@ func (vs *versionSet) UpdateVersionLocked(updateFn func() (versionUpdate, error)
 	nextFileNum := vs.nextFileNum.Load()
 
 	// Note: this call populates ve.RemovedBackingTables.
-	zombieBackings, removedVirtualBackings, localLiveSizeDelta :=
+	zombieBackings, removedVirtualBackings, localLiveSizeDelta, localLiveCountDelta :=
 		getZombiesAndUpdateVirtualBackings(ve, &vs.virtualBackings, vs.provider)
 
 	var l0Update manifest.L0PreparedUpdate
@@ -734,6 +740,7 @@ func (vs *versionSet) UpdateVersionLocked(updateFn func() (versionUpdate, error)
 	}
 	vs.metrics.Levels[0].Sublevels = int32(len(newVersion.L0SublevelFiles))
 	vs.metrics.Table.Local.LiveSize = uint64(int64(vs.metrics.Table.Local.LiveSize) + localLiveSizeDelta)
+	vs.metrics.Table.Local.LiveCount = uint64(int64(vs.metrics.Table.Local.LiveCount) + localLiveCountDelta)
 
 	vs.setCompactionPicker(
 		newCompactionPickerByScore(newVersion, vs.l0Organizer, &vs.virtualBackings, vs.opts, inProgress))
@@ -764,7 +771,10 @@ type fileBackingInfo struct {
 //   - localLiveSizeDelta: the delta in local live bytes.
 func getZombiesAndUpdateVirtualBackings(
 	ve *versionEdit, virtualBackings *manifest.VirtualBackings, provider objstorage.Provider,
-) (zombieBackings, removedVirtualBackings []fileBackingInfo, localLiveSizeDelta int64) {
+) (
+	zombieBackings, removedVirtualBackings []fileBackingInfo,
+	localLiveSizeDelta, localLiveCountDelta int64,
+) {
 	// First, deal with the physical tables.
 	//
 	// A physical backing has become unused if it is in DeletedFiles but not in
@@ -776,8 +786,11 @@ func getZombiesAndUpdateVirtualBackings(
 	for _, nf := range ve.NewTables {
 		if !nf.Meta.Virtual {
 			stillUsed[nf.Meta.FileBacking.DiskFileNum] = struct{}{}
-			_, localFileDelta := sizeIfLocal(nf.Meta.FileBacking, provider)
+			isLocal, localFileDelta := sizeIfLocal(nf.Meta.FileBacking, provider)
 			localLiveSizeDelta += localFileDelta
+			if isLocal {
+				localLiveCountDelta++
+			}
 		}
 	}
 	for _, b := range ve.CreatedBackingTables {
@@ -792,6 +805,9 @@ func getZombiesAndUpdateVirtualBackings(
 			// for the addition.
 			isLocal, localFileDelta := sizeIfLocal(m.FileBacking, provider)
 			localLiveSizeDelta -= localFileDelta
+			if isLocal {
+				localLiveCountDelta--
+			}
 			if _, ok := stillUsed[m.FileBacking.DiskFileNum]; !ok {
 				zombieBackings = append(zombieBackings, fileBackingInfo{
 					backing: m.FileBacking,
@@ -807,8 +823,11 @@ func getZombiesAndUpdateVirtualBackings(
 	// which works out.
 	for _, b := range ve.CreatedBackingTables {
 		virtualBackings.AddAndRef(b)
-		_, localFileDelta := sizeIfLocal(b, provider)
+		isLocal, localFileDelta := sizeIfLocal(b, provider)
 		localLiveSizeDelta += localFileDelta
+		if isLocal {
+			localLiveCountDelta++
+		}
 	}
 	for _, nf := range ve.NewTables {
 		if nf.Meta.Virtual {
@@ -828,6 +847,9 @@ func getZombiesAndUpdateVirtualBackings(
 		for i, b := range unused {
 			isLocal, localFileDelta := sizeIfLocal(b, provider)
 			localLiveSizeDelta -= localFileDelta
+			if isLocal {
+				localLiveCountDelta--
+			}
 			ve.RemovedBackingTables[i] = b.DiskFileNum
 			zombieBackings = append(zombieBackings, fileBackingInfo{
 				backing: b,
@@ -837,7 +859,7 @@ func getZombiesAndUpdateVirtualBackings(
 		}
 		removedVirtualBackings = zombieBackings[len(zombieBackings)-len(unused):]
 	}
-	return zombieBackings, removedVirtualBackings, localLiveSizeDelta
+	return zombieBackings, removedVirtualBackings, localLiveSizeDelta, localLiveCountDelta
 }
 
 // sizeIfLocal returns backing.Size if the backing is a local file, else 0.
@@ -1090,10 +1112,12 @@ func (vs *versionSet) updateObsoleteTableMetricsLocked() {
 	vs.metrics.Table.ObsoleteCount = int64(len(vs.obsoleteTables))
 	vs.metrics.Table.ObsoleteSize = 0
 	vs.metrics.Table.Local.ObsoleteSize = 0
+	vs.metrics.Table.Local.ObsoleteCount = 0
 	for _, fi := range vs.obsoleteTables {
 		vs.metrics.Table.ObsoleteSize += fi.FileSize
 		if fi.isLocal {
 			vs.metrics.Table.Local.ObsoleteSize += fi.FileSize
+			vs.metrics.Table.Local.ObsoleteCount++
 		}
 	}
 }