feat: implement enhanced garbage collection statistics logging

steamcache/gc.go

@@ -1,73 +1,42 @@
 package steamcache
 
 import (
-	"s1d3sw1ped/SteamCache2/steamcache/logger"
 	"s1d3sw1ped/SteamCache2/vfs"
 	"s1d3sw1ped/SteamCache2/vfs/cachestate"
 	"time"
 
-	"github.com/docker/go-units"
 	"golang.org/x/exp/rand"
 )
 
-func randomgc(vfss vfs.VFS, stats []*vfs.FileInfo) int64 {
-	// Pick a random file to delete
-	randfile := stats[rand.Intn(len(stats))]
-	sz := randfile.Size()
-	err := vfss.Delete(randfile.Name())
-	if err != nil {
-		// If we failed to delete the file, log it and return 0
-		// logger.Logger.Error().Err(err).Msgf("Failed to delete %s", randfile.Name())
-		return 0
+// RandomGC randomly deletes files until we've reclaimed enough space.
+func randomgc(vfss vfs.VFS, size uint) (uint, uint) {
+
+	// Randomly delete files until we've reclaimed enough space.
+	random := func(vfss vfs.VFS, stats []*vfs.FileInfo) int64 {
+		randfile := stats[rand.Intn(len(stats))]
+		sz := randfile.Size()
+		err := vfss.Delete(randfile.Name())
+		if err != nil {
+			return 0
+		}
+
+		return sz
 	}
 
-	return sz
-}
-
-func memorygc(vfss vfs.VFS, size int) {
-	tstart := time.Now()
 	deletions := 0
 	targetreclaim := int64(size)
 	var reclaimed int64
 
 	stats := vfss.StatAll()
 	for {
-		reclaimed += randomgc(vfss, stats)
+		reclaimed += random(vfss, stats)
 		deletions++
 		if reclaimed >= targetreclaim {
 			break
 		}
 	}
 
-	logger.Logger.Info().
-		Str("name", vfss.Name()).
-		Str("duration", time.Since(tstart).String()).
-		Str("reclaimed", units.HumanSize(float64(reclaimed))).
-		Int("deletions", deletions).
-		Msgf("GC")
-}
-
-func diskgc(vfss vfs.VFS, size int) {
-	tstart := time.Now()
-	deletions := 0
-	targetreclaim := int64(size)
-	var reclaimed int64
-
-	stats := vfss.StatAll()
-	for {
-		reclaimed += randomgc(vfss, stats)
-		deletions++
-		if reclaimed >= targetreclaim {
-			break
-		}
-	}
-
-	logger.Logger.Info().
-		Str("name", vfss.Name()).
-		Str("duration", time.Since(tstart).String()).
-		Str("reclaimed", units.HumanSize(float64(reclaimed))).
-		Int("deletions", deletions).
-		Msgf("GC")
+	return uint(reclaimed), uint(deletions)
 }
 
 func cachehandler(fi *vfs.FileInfo, cs cachestate.CacheState) bool {

steamcache/steamcache.go

@@ -30,6 +30,9 @@ type SteamCache struct {
 	memory *memory.MemoryFS
 	disk   *disk.DiskFS
 
+	memorygc *gc.GCFS
+	diskgc   *gc.GCFS
+
 	hits *avgcachestate.AvgCacheState
 
 	dirty bool
@@ -52,49 +55,36 @@ func New(address string, memorySize string, memoryMultiplier int, diskSize strin
 	)
 
 	var m *memory.MemoryFS
+	var mgc *gc.GCFS
 	if memorysize > 0 {
 		m = memory.New(memorysize)
+		mgc = gc.New(m, memoryMultiplier, randomgc)
 	}
 
 	var d *disk.DiskFS
+	var dgc *gc.GCFS
 	if disksize > 0 {
 		d = disk.New(diskPath, disksize)
+		dgc = gc.New(d, diskMultiplier, randomgc)
 	}
 
 	// configure the cache to match the specified mode (memory only, disk only, or memory and disk) based on the provided sizes
 	if disksize == 0 && memorysize != 0 {
 		//memory only mode - no disk
 
+		c.SetSlow(mgc)
 		logger.Logger.Info().Bool("memory", true).Bool("disk", false).Msg("configuration")
-		c.SetSlow(gc.New(
-			m,
-			memoryMultiplier,
-			memorygc,
-		))
 	} else if disksize != 0 && memorysize == 0 {
 		// disk only mode
 
+		c.SetSlow(dgc)
 		logger.Logger.Info().Bool("memory", false).Bool("disk", true).Msg("configuration")
-		c.SetSlow(gc.New(
-			d,
-			diskMultiplier,
-			diskgc,
-		))
 	} else if disksize != 0 && memorysize != 0 {
 		// memory and disk mode
 
+		c.SetFast(mgc)
+		c.SetSlow(dgc)
 		logger.Logger.Info().Bool("memory", true).Bool("disk", true).Msg("configuration")
-		c.SetFast(gc.New(
-			m,
-			memoryMultiplier,
-			memorygc,
-		))
-
-		c.SetSlow(gc.New(
-			d,
-			diskMultiplier,
-			diskgc,
-		))
 	} else {
 		// no memory or disk isn't a valid configuration
 		logger.Logger.Error().Bool("memory", false).Bool("disk", false).Msg("configuration invalid :( exiting")
@@ -108,12 +98,15 @@ func New(address string, memorySize string, memoryMultiplier int, diskSize strin
 		memory: m,
 		disk:   d,
 
+		memorygc: mgc,
+		diskgc:   dgc,
+
 		hits: avgcachestate.New(10000),
 	}
 
 	if d != nil {
 		if d.Size() > d.Capacity() {
-			diskgc(d, int(d.Size()-d.Capacity()))
+			randomgc(d, uint(d.Size()-d.Capacity()))
 		}
 	}
 
@@ -152,19 +145,37 @@ func (sc *SteamCache) LogStats() {
 	if sc.dirty {
 
 		if sc.memory != nil { // only log memory if memory is enabled
+			lifetimeBytes, lifetimeFiles, reclaimedBytes, deletedFiles := sc.memorygc.Stats()
+
 			logger.Logger.Info().
 				Str("size", units.HumanSize(float64(sc.memory.Size()))).
 				Str("capacity", units.HumanSize(float64(sc.memory.Capacity()))).
 				Str("files", fmt.Sprintf("%d", len(sc.memory.StatAll()))).
 				Msg("memory")
+
+			logger.Logger.Info().
+				Str("lifetime", units.HumanSize(float64(lifetimeBytes))).
+				Uint("lifetime_files", lifetimeFiles).
+				Str("reclaimed", units.HumanSize(float64(reclaimedBytes))).
+				Uint("deleted_files", deletedFiles).
+				Msg("memory_gc")
 		}
 
 		if sc.disk != nil { // only log disk if disk is enabled
+			lifetimeBytes, lifetimeFiles, reclaimedBytes, deletedFiles := sc.diskgc.Stats()
+
 			logger.Logger.Info().
 				Str("size", units.HumanSize(float64(sc.disk.Size()))).
 				Str("capacity", units.HumanSize(float64(sc.disk.Capacity()))).
 				Str("files", fmt.Sprintf("%d", len(sc.disk.StatAll()))).
 				Msg("disk")
+
+			logger.Logger.Info().
+				Str("lifetime", units.HumanSize(float64(lifetimeBytes))).
+				Uint("lifetime_files", lifetimeFiles).
+				Str("reclaimed", units.HumanSize(float64(reclaimedBytes))).
+				Uint("deleted_files", deletedFiles).
+				Msg("disk_gc")
 		}
 
 		logger.Logger.Info().