Merge pull request #2011 from sthaha/feat-fake-cpu-meter

chore(device): add fake CPU power meter for testing

Author: sthaha

cmd/kepler/main.go

@@ -167,7 +167,8 @@ func createServices(logger *slog.Logger, cfg *config.Config) ([]service.Service,
 
 func createPowerMonitor(logger *slog.Logger, cfg *config.Config) (*monitor.PowerMonitor, error) {
 	logger.Debug("Creating PowerMonitor")
-	cpuPowerMeter, err := device.NewCPUPowerMeter(cfg.Host.SysFS)
+
+	cpuPowerMeter, err := createCPUMeter(logger, cfg)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create CPU power meter: %w", err)
 	}
@@ -179,3 +180,10 @@ func createPowerMonitor(logger *slog.Logger, cfg *config.Config) (*monitor.Power
 
 	return pm, nil
 }
+
+func createCPUMeter(logger *slog.Logger, cfg *config.Config) (device.CPUPowerMeter, error) {
+	if fake := cfg.Dev.FakeCpuMeter; fake.Enabled {
+		return device.NewFakeCPUMeter(fake.Zones, device.WithFakeLogger(logger))
+	}
+	return device.NewCPUPowerMeter(cfg.Host.SysFS)
+}

config/config.go

@@ -24,9 +24,18 @@ type (
 		ProcFS string `yaml:"procfs"`
 	}
 
+	// Development mode settings; disabled by default
+	Dev struct {
+		FakeCpuMeter struct {
+			Enabled bool     `yaml:"enabled"`
+			Zones   []string `yaml:"zones"`
+		} `yaml:"fake-cpu-meter"`
+	}
+
 	Config struct {
 		Log  Log  `yaml:"log"`
 		Host Host `yaml:"host"`
+		Dev  Dev  `yaml:"dev"` // WARN: do not expose dev settings as flags
 	}
 )
 
@@ -36,6 +45,8 @@ const (
 	LogFormatFlag  = "log.format"
 	HostSysFSFlag  = "host.sysfs"
 	HostProcFSFlag = "host.procfs"
+
+// WARN:  dev settings shouldn't be exposed as flags as flags are intended for end users
 )
 
 // DefaultConfig returns a Config with default values

hack/config.yaml

@@ -1,7 +1,13 @@
 log:
-  level: debug  # debug, info, warn, error (default: info)
-  format: text  # text or json (default: text)
+  level: debug # debug, info, warn, error (default: info)
+  format: text # text or json (default: text)
 
 host:
-  sysfs: /sys   # Path to sysfs filesystem (default: /sys)
+  sysfs: /sys # Path to sysfs filesystem (default: /sys)
   procfs: /proc # Path to procfs filesystem (default: /proc)
+
+# WARN DO NOT ENABLE THIS IN PRODUCTION - for development / testing only
+dev:
+  fake-cpu-meter:
+    enabled: false
+    zones: [] # zones to be enabled, empty enables all default zones

internal/device/fake_cpu_power_meter.go

@@ -0,0 +1,174 @@
+// SPDX-FileCopyrightText: 2025 The Kepler Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package device
+
+import (
+	"context"
+	"fmt"
+	"log/slog"
+	"math/rand"
+	"path/filepath"
+	"sync"
+)
+
+// NOTE: This fake meter is not intended to be used in production and is for testing only
+
+type Zone = string
+
+const (
+	ZonePackage Zone = "package"
+	ZoneCore    Zone = "core"
+	ZoneDRAM    Zone = "dram"
+	ZoneUncore  Zone = "uncore"
+)
+
+var defaultFakeZones = []Zone{ZonePackage, ZoneCore, ZoneDRAM}
+
+const defaultRaplPath = "/sys/class/powercap/intel-rapl"
+
+// fakeEnergyZone implements the EnergyZone interface
+type fakeEnergyZone struct {
+	name      string
+	index     int
+	path      string
+	energy    Energy
+	maxEnergy Energy
+	mu        sync.Mutex
+
+	// For generating fake values
+	increment    Energy
+	randomFactor float64
+}
+
+var _ EnergyZone = (*fakeEnergyZone)(nil)
+
+// Name returns the zone name
+func (z *fakeEnergyZone) Name() string {
+	return z.name
+}
+
+// Index returns the index of the zone
+func (z *fakeEnergyZone) Index() int {
+	return z.index
+}
+
+// Path returns the path from which the energy usage value ie being read
+func (z *fakeEnergyZone) Path() string {
+	return z.path
+}
+
+// Energy returns energy consumed by the zone.
+func (z *fakeEnergyZone) Energy() (Energy, error) {
+	z.mu.Lock()
+	defer z.mu.Unlock()
+
+	randomComponent := Energy(rand.Float64() * float64(z.increment) * z.randomFactor)
+	z.energy = (z.energy + z.increment + randomComponent) % z.maxEnergy
+
+	return z.energy, nil
+}
+
+// MaxEnergy returns the maximum value of energy usage that can be read.
+func (z *fakeEnergyZone) MaxEnergy() Energy {
+	return z.maxEnergy
+}
+
+// fakeRaplMeter implements the CPUPowerMeter interface
+type fakeRaplMeter struct {
+	logger     *slog.Logger
+	zones      []EnergyZone
+	devicePath string
+}
+
+var _ CPUPowerMeter = (*fakeRaplMeter)(nil)
+
+// FakeOptFn is a functional option for configuring FakeRaplMeter
+type FakeOptFn func(*fakeRaplMeter)
+
+// WithFakePath sets the base device path for the fake meter
+func WithFakePath(path string) FakeOptFn {
+	return func(m *fakeRaplMeter) {
+		m.devicePath = path
+		for _, z := range m.zones {
+			if fz, ok := z.(*fakeEnergyZone); ok {
+				fz.path = filepath.Join(path, fmt.Sprintf("energy_%s", fz.name))
+			}
+		}
+	}
+}
+
+// WithFakeMaxEnergy sets the maximum energy value before wrap-around
+func WithFakeMaxEnergy(e Energy) FakeOptFn {
+	return func(m *fakeRaplMeter) {
+		for _, z := range m.zones {
+			if fz, ok := z.(*fakeEnergyZone); ok {
+				fz.maxEnergy = e
+			}
+		}
+	}
+}
+
+// WithFakeMaxEnergy sets the maximum energy value before wrap-around
+func WithFakeLogger(l *slog.Logger) FakeOptFn {
+	return func(m *fakeRaplMeter) {
+		m.logger = l.With("meter", m.Name())
+	}
+}
+
+// NewFakeCPUMeter creates a new fake CPU power meter
+func NewFakeCPUMeter(zones []string, opts ...FakeOptFn) (CPUPowerMeter, error) {
+	meter := &fakeRaplMeter{
+		devicePath: defaultRaplPath,
+		logger:     slog.Default().With("meter", "fake-cpu-meter"),
+	}
+
+	// nil and empty slices are equivalent
+	if len(zones) == 0 {
+		zones = defaultFakeZones
+	}
+
+	zoneIncrementFactor := map[Zone]int{
+		ZonePackage: 12,
+		ZoneCore:    8,
+		ZoneDRAM:    5,
+		ZoneUncore:  2,
+	}
+
+	meter.zones = make([]EnergyZone, 0, len(zones))
+
+	for i, zoneName := range zones {
+		meter.zones = append(meter.zones, &fakeEnergyZone{
+			name:         zoneName,
+			index:        i,
+			path:         filepath.Join(defaultRaplPath, fmt.Sprintf("energy_%s", zoneName)),
+			maxEnergy:    1000000,
+			increment:    Energy(100 + zoneIncrementFactor[zoneName]),
+			randomFactor: 0.5,
+		})
+	}
+
+	for _, opt := range opts {
+		opt(meter)
+	}
+
+	return meter, nil
+}
+
+func (m *fakeRaplMeter) Name() string {
+	return "fake-cpu-meter"
+}
+
+func (m *fakeRaplMeter) Start(ctx context.Context) error {
+	m.logger.Info("Starting fake CPU power meter")
+	return nil
+}
+
+func (m *fakeRaplMeter) Stop() error {
+	m.logger.Info("Stopping fake CPU power meter")
+	return nil
+}
+
+func (m *fakeRaplMeter) Zones() ([]EnergyZone, error) {
+	return m.zones, nil
+}