alu/finally-a-monolithic-linux-hw-monitor
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

simplify the driver interface

Browse Source
This commit is contained in:
alu
2026-08-07 09:29:17 -07:00
parent b99bb45877
commit 31c409a94c
13 changed files with 181 additions and 197 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/proc/drivers/drivers.go
-13
View File
@@ -6,27 +6,14 @@ type TemperatureSensor struct {
TempC float64
}
type TemperatureDriver interface {
ReadTemperatureSensors() ([]TemperatureSensor, error)
}
type PowerSensor struct {
path string
Name string
Watts float64
}
type PowerDriver interface {
ReadPowerSensors() ([]PowerSensor, error)
}
type ClockSensor struct {
path string
number int
Name string
FrequencyGHz float64
}
type ClockDriver interface {
ReadClockSensors() ([]ClockSensor, error)
}
app/proc/drivers/hwmon.go
+23 -4
View File
@@ -13,11 +13,11 @@ type HwmonDriver struct {
hwmonDriver string
}
func NewHwmonDriver(expectedDrivers []string) *HwmonDriver {
func NewHwmonDriver(expectedDrivers []string) (*HwmonDriver, error) {
// Locate hwmon path
dirs, err := filepath.Glob("/sys/class/hwmon/hwmon*")
if err != nil {
return nil
return nil, err
}
for _, dir := range dirs {
@@ -29,16 +29,35 @@ func NewHwmonDriver(expectedDrivers []string) *HwmonDriver {
return &HwmonDriver{
hwmonDir: dir,
hwmonDriver: driver,
}
}, nil
}
}
}
}
return nil, fmt.Errorf("could not find %#v in /sys/class/hwmon", expectedDrivers)
}
func (r *HwmonDriver) Render(console *strings.Builder) error {
t, err := r.Read()
if err != nil {
return err
}
temps := t.([]TemperatureSensor)
fmt.Fprint(console, "--- Temperature ---\n")
for _, sensor := range temps {
tempC := sensor.TempC
tempF := (tempC * 9 / 5) + 32
// \033[K clears from cursor to end of line (prevents lingering chars)
fmt.Fprintf(console, "%-16s | %.2f °C (%.3f °F)\033[K\n", sensor.Name, tempC, tempF)
}
return nil
}
func (r *HwmonDriver) ReadTemperatureSensors() ([]TemperatureSensor, error) {
func (r *HwmonDriver) Read() (any, 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)
app/proc/drivers/rapl.go
+22 -4
View File
@@ -20,14 +20,32 @@ type RaplDriver struct {
energyState map[string]EnergyState
}
func NewRaplDriver() *RaplDriver {
return &RaplDriver{
func NewRaplDriver() (*RaplDriver, error) {
r := RaplDriver{
energyState: map[string]EnergyState{},
}
_, err := r.Read()
return &r, err
}
func (r *RaplDriver) ReadPowerSensors() ([]PowerSensor, error) {
func (r *RaplDriver) Render(console *strings.Builder) error {
fmt.Fprint(console, "--- Power ---\n")
p, err := r.Read()
if err != nil {
return err
}
power := p.([]PowerSensor)
for _, sensor := range power {
// \033[K clears from cursor to end of line (prevents lingering chars)
fmt.Fprintf(console, "%-16s | %.2f W\033[K\n", sensor.Name, sensor.Watts)
}
return nil
}
func (r *RaplDriver) Read() (any, error) {
powerSensors := []PowerSensor{}
patterns := []string{
app/proc/drivers/sys.go
+22 -3
View File
@@ -11,11 +11,30 @@ import (
type SysDriver struct{}
func NewSysDriver() *SysDriver {
return &SysDriver{}
func NewSysDriver() (*SysDriver, error) {
r := SysDriver{}
_, err := r.Read()
return &r, err
}
func (r *SysDriver) ReadClockSensors() ([]ClockSensor, error) {
func (r *SysDriver) Render(console *strings.Builder) error {
fmt.Fprint(console, "--- Clock Frequency ---\n")
c, err := r.Read()
if err != nil {
return err
}
clock := c.([]ClockSensor)
for _, sensor := range clock {
// \033[K clears from cursor to end of line (prevents lingering chars)
fmt.Fprintf(console, "%-16s | %.2f GHz\033[K\n", sensor.Name, sensor.FrequencyGHz)
}
return nil
}
func (r *SysDriver) Read() (any, error) {
// Glob directly targets scaling_cur_freq for all numerical CPU core paths
freqFiles, err := filepath.Glob("/sys/devices/system/cpu/cpu[0-9]*/cpufreq/scaling_cur_freq")
if err != nil {
app/proc/proc.go
+10 -46
View File
@@ -2,58 +2,22 @@ package proc
import (
"bufio"
"finally-a-monolithic-linux-hw-monitor/app/proc/drivers"
"finally-a-monolithic-linux-hw-monitor/app/common"
"fmt"
"os"
"strings"
)
func RenderProc(console *strings.Builder, proc *Proc) {
func (proc *Proc) RenderProc(console *strings.Builder) {
fmt.Fprintf(console, "=== %s ===\n", proc.Model())
RenderTemperatureSensors(console, proc)
RenderPowerSensors(console, proc)
RenderClockSensors(console, proc)
}
func RenderTemperatureSensors(console *strings.Builder, proc *Proc) {
temps, _ := proc.SensorReader.ReadTemperatureSensors()
fmt.Fprint(console, "--- Temperature ---\n")
for _, sensor := range temps {
tempC := sensor.TempC
tempF := (tempC * 9 / 5) + 32
// \033[K clears from cursor to end of line (prevents lingering chars)
fmt.Fprintf(console, "%-16s | %.2f °C (%.3f °F)\033[K\n", sensor.Name, tempC, tempF)
}
}
func RenderPowerSensors(console *strings.Builder, proc *Proc) {
fmt.Fprint(console, "--- Power ---\n")
power, _ := proc.SensorReader.ReadPowerSensors()
for _, sensor := range power {
// \033[K clears from cursor to end of line (prevents lingering chars)
fmt.Fprintf(console, "%-16s | %.2f W\033[K\n", sensor.Name, sensor.Watts)
}
}
func RenderClockSensors(console *strings.Builder, proc *Proc) {
fmt.Fprint(console, "--- Clock Frequency ---\n")
power, _ := proc.SensorReader.ReadClockSensors()
for _, sensor := range power {
// \033[K clears from cursor to end of line (prevents lingering chars)
fmt.Fprintf(console, "%-16s | %.2f GHz\033[K\n", sensor.Name, sensor.FrequencyGHz)
for _, driver := range proc.drivers {
driver.Render(console)
}
}
type Proc struct {
SensorReader ProcSensorReader
Info map[string]string
}
type ProcSensorReader interface {
ReadTemperatureSensors() ([]drivers.TemperatureSensor, error)
ReadPowerSensors() ([]drivers.PowerSensor, error)
ReadClockSensors() ([]drivers.ClockSensor, error)
drivers []common.Driver
Info map[string]string
}
const (
@@ -96,12 +60,12 @@ func GetProc() (Proc, error) {
switch vendor {
case VendorIntel:
intelReader, err := NewIntelReader()
proc.SensorReader = intelReader
drivers, err := NewIntelDrivers()
proc.drivers = drivers
return proc, err
case VendorAMD:
amdReader, err := NewAMDReader()
proc.SensorReader = amdReader
drivers, err := NewAMDDrivers()
proc.drivers = drivers
return proc, err
default:
return proc, fmt.Errorf("proc type %s is not supported", vendor)
app/proc/vendor_amd.go
+13 -29
View File
@@ -1,47 +1,31 @@
package proc
import (
"finally-a-monolithic-linux-hw-monitor/app/common"
driver "finally-a-monolithic-linux-hw-monitor/app/proc/drivers"
"fmt"
)
type AMDReader struct {
temperatureDriver driver.TemperatureDriver
powerDriver driver.PowerDriver
clockDriver driver.ClockDriver
}
func NewAMDDrivers() ([]common.Driver, error) {
drivers := []common.Driver{}
func NewAMDReader() (*AMDReader, error) {
temperatureDriver := driver.NewHwmonDriver([]string{"k10temp", "zenpower"})
if temperatureDriver == nil {
temperatureDriver, err := driver.NewHwmonDriver([]string{"k10temp", "zenpower"})
if err != nil {
return nil, fmt.Errorf("could not initialize hwmon temperature driver")
}
drivers = append(drivers, temperatureDriver)
powerDriver := driver.NewRaplDriver()
if powerDriver == nil {
powerDriver, err := driver.NewRaplDriver()
if err != nil {
return nil, fmt.Errorf("could not initialize hwmon temperature driver")
}
drivers = append(drivers, powerDriver)
clockDriver := driver.NewSysDriver()
if clockDriver == nil {
clockDriver, err := driver.NewSysDriver()
if err != nil {
return nil, fmt.Errorf("could not initialize hwmon temperature driver")
}
drivers = append(drivers, clockDriver)
return &AMDReader{
temperatureDriver: temperatureDriver,
powerDriver: powerDriver,
clockDriver: clockDriver,
}, nil
}
func (r *AMDReader) ReadTemperatureSensors() ([]driver.TemperatureSensor, error) {
return r.temperatureDriver.ReadTemperatureSensors()
}
func (r *AMDReader) ReadPowerSensors() ([]driver.PowerSensor, error) {
return r.powerDriver.ReadPowerSensors()
}
func (r *AMDReader) ReadClockSensors() ([]driver.ClockSensor, error) {
return r.clockDriver.ReadClockSensors()
return drivers, nil
}
app/proc/vendor_intel.go
+13 -30
View File
@@ -1,47 +1,30 @@
package proc
import (
"finally-a-monolithic-linux-hw-monitor/app/common"
driver "finally-a-monolithic-linux-hw-monitor/app/proc/drivers"
"fmt"
)
type IntelReader struct {
temperatureDriver driver.TemperatureDriver
powerDriver driver.PowerDriver
clockDriver driver.ClockDriver
}
func NewIntelReader() (*IntelReader, error) {
temperatureDriver := driver.NewHwmonDriver([]string{"coretemp"})
if temperatureDriver == nil {
func NewIntelDrivers() ([]common.Driver, error) {
drivers := []common.Driver{}
temperatureDriver, err := driver.NewHwmonDriver([]string{"coretemp"})
if err != nil {
return nil, fmt.Errorf("could not initialize hwmon temperature driver")
}
drivers = append(drivers, temperatureDriver)
powerDriver := driver.NewRaplDriver()
if powerDriver == nil {
powerDriver, err := driver.NewRaplDriver()
if err != nil {
return nil, fmt.Errorf("could not initialize hwmon temperature driver")
}
drivers = append(drivers, powerDriver)
clockDriver := driver.NewSysDriver()
if clockDriver == nil {
clockDriver, err := driver.NewSysDriver()
if err != nil {
return nil, fmt.Errorf("could not initialize hwmon temperature driver")
}
drivers = append(drivers, clockDriver)
return &IntelReader{
temperatureDriver: temperatureDriver,
powerDriver: powerDriver,
clockDriver: clockDriver,
}, nil
}
func (r *IntelReader) ReadTemperatureSensors() ([]driver.TemperatureSensor, error) {
return r.temperatureDriver.ReadTemperatureSensors()
}
func (r *IntelReader) ReadPowerSensors() ([]driver.PowerSensor, error) {
return r.powerDriver.ReadPowerSensors()
}
func (r *IntelReader) ReadClockSensors() ([]driver.ClockSensor, error) {
return r.clockDriver.ReadClockSensors()
return drivers, nil
}