add cpu frequency driver

2026-08-04 15:27:55 -07:00
parent afbae3d3d4
commit 4a94bddd92
8 changed files with 381 additions and 370 deletions
@@ -1,199 +1,47 @@
 package proc

 import (
+	driver "finally-a-monolithic-linux-hw-monitor/app/cpu/drivers"
 	"fmt"
-	"math"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"time"
 )

 type IntelReader struct {
-	hwmonDir    string
-	driver      string
-	energyState map[string]EnergyState
+	temperatureDriver driver.TemperatureDriver
+	powerDriver       driver.PowerDriver
+	clockDriver       driver.ClockDriver
 }

 func NewIntelReader() (*IntelReader, error) {
-	// Locate Intel coretemp hwmon path
-	dirs, err := filepath.Glob("/sys/class/hwmon/hwmon*")
-	if err != nil {
-		return nil, err
+	temperatureDriver := driver.NewHwmonDriver([]string{"coretemp"})
+	if temperatureDriver == nil {
+		return nil, fmt.Errorf("could not initialize hwmon temperature driver")
 	}

-	hwmonDir := ""
-	for _, d := range dirs {
-		nameData, err := os.ReadFile(filepath.Join(d, "name"))
-		if err == nil && strings.TrimSpace(string(nameData)) == "coretemp" {
-			hwmonDir = d
-			break
-		}
+	powerDriver := driver.NewRaplDriver()
+	if powerDriver == nil {
+		return nil, fmt.Errorf("could not initialize hwmon temperature driver")
 	}

-	if hwmonDir == "" {
-		return nil, fmt.Errorf("coretemp driver not found under /sys/class/hwmon/")
+	clockDriver := driver.NewSysDriver()
+	if clockDriver == nil {
+		return nil, fmt.Errorf("could not initialize hwmon temperature driver")
 	}

 	return &IntelReader{
-		hwmonDir: hwmonDir,
-		driver:   "coretemp",
+		temperatureDriver: temperatureDriver,
+		powerDriver:       powerDriver,
+		clockDriver:       clockDriver,
 	}, nil
 }

-func (r *IntelReader) ReadTemperatureSensors() ([]TempSensor, error) {
-	inputs, err := filepath.Glob(filepath.Join(r.hwmonDir, "temp*_input"))
-	if err != nil || len(inputs) == 0 {
-		return nil, fmt.Errorf("no temperature inputs found in %s", r.hwmonDir)
-	}
-
-	temps := []TempSensor{}
-
-	for _, inputPath := range inputs {
-		valBytes, err := os.ReadFile(inputPath)
-		if err != nil {
-			continue
-		}
-
-		milliC, err := strconv.ParseFloat(strings.TrimSpace(string(valBytes)), 64)
-		if err != nil {
-			continue
-		}
-
-		labelPath := strings.TrimSuffix(inputPath, "_input") + "_label"
-		label := ""
-		if lBytes, err := os.ReadFile(labelPath); err == nil {
-			label = strings.TrimSpace(string(lBytes))
-		} else {
-			label = filepath.Base(strings.TrimSuffix(inputPath, "_input"))
-		}
-
-		temps = append(temps, TempSensor{
-			Name:  label,
-			TempC: milliC / 1000.0,
-		})
-	}
-
-	return temps, nil
+func (r *IntelReader) ReadTemperatureSensors() ([]driver.TemperatureSensor, error) {
+	return r.temperatureDriver.ReadTemperatureSensors()
 }

-func (r *IntelReader) ReadPowerSensors() ([]PowerSensor, error) {
-	return r.readRaplPower(), nil
+func (r *IntelReader) ReadPowerSensors() ([]driver.PowerSensor, error) {
+	return r.powerDriver.ReadPowerSensors()
 }

-func (r *IntelReader) readRaplPower() []PowerSensor {
-	powerSensors := []PowerSensor{}
-
-	patterns := []string{
-		"/sys/class/powercap/intel-rapl*/energy_uj",
-		"/sys/class/powercap/intel-rapl/intel-rapl*/energy_uj",
-		"/sys/class/powercap/intel-rapl/intel-rapl*/*/energy_uj",
-		"/sys/class/powercap/intel-rapl:*/energy_uj",
-		"/sys/class/powercap/intel-rapl:*/*/energy_uj",
-	}
-
-	energyInputs := []string{}
-	seen := make(map[string]bool)
-
-	for _, pattern := range patterns {
-		matches, _ := filepath.Glob(pattern)
-
-		for _, match := range matches {
-			realPath, err := filepath.EvalSymlinks(match)
-			if err != nil {
-				realPath = match
-			}
-			if !seen[realPath] {
-				seen[realPath] = true
-				energyInputs = append(energyInputs, realPath)
-			}
-		}
-	}
-
-	if len(energyInputs) == 0 {
-		return powerSensors
-	}
-
-	getLabel := func(inputPath string) string {
-		dir := filepath.Dir(inputPath)
-		if nameBytes, err := os.ReadFile(filepath.Join(dir, "name")); err == nil {
-			return strings.TrimSpace(string(nameBytes))
-		}
-		return filepath.Base(dir)
-	}
-
-	r.calculateEnergyDelta(energyInputs, getLabel, &powerSensors)
-	return powerSensors
-}
-
-func (r *IntelReader) calculateEnergyDelta(inputs []string, getLabel func(string) string, out *[]PowerSensor) {
-	now := time.Now()
-
-	if r.energyState == nil {
-		r.energyState = make(map[string]EnergyState)
-	}
-
-	for _, rawPath := range inputs {
-		key, err := filepath.EvalSymlinks(rawPath)
-		if err != nil {
-			key = filepath.Clean(rawPath)
-		}
-
-		valBytes, err := os.ReadFile(key)
-		if err != nil {
-			continue
-		}
-
-		microJoules, err := strconv.ParseUint(strings.TrimSpace(string(valBytes)), 10, 64)
-		if err != nil {
-			continue
-		}
-
-		prevState, exists := r.energyState[key]
-
-		if !exists {
-			r.energyState[key] = EnergyState{
-				lastEnergy: microJoules,
-				lastTime:   now,
-			}
-			*out = append(*out, PowerSensor{
-				Name:  getLabel(key),
-				Watts: 0.0,
-			})
-			continue
-		}
-
-		timeDiff := now.Sub(prevState.lastTime).Seconds()
-		if timeDiff < 0.05 {
-			continue
-		}
-
-		maxRange := uint64(math.MaxUint64)
-		rangeBytes, err := os.ReadFile(filepath.Join(filepath.Dir(key), "max_energy_range_uj"))
-		if err == nil {
-			if parsedMax, err := strconv.ParseUint(strings.TrimSpace(string(rangeBytes)), 10, 64); err == nil && parsedMax > 0 {
-				maxRange = parsedMax
-			}
-		}
-
-		var energyDiff uint64
-		if microJoules >= prevState.lastEnergy {
-			energyDiff = microJoules - prevState.lastEnergy
-		} else {
-			energyDiff = (maxRange - prevState.lastEnergy) + microJoules
-		}
-
-		watts := (float64(energyDiff) / 1_000_000.0) / timeDiff
-
-		r.energyState[key] = EnergyState{
-			lastEnergy: microJoules,
-			lastTime:   now,
-		}
-
-		*out = append(*out, PowerSensor{
-			Name:  getLabel(key),
-			Watts: watts,
-		})
-	}
+func (r *IntelReader) ReadClockSensors() ([]driver.ClockSensor, error) {
+	return r.clockDriver.ReadClockSensors()
 }