Add metric 'nv_util_eff' like nvtop

collectors/cpustatMetric.go

@@ -27,7 +27,6 @@ const CPUSTATFILE = `/proc/stat`
 
 type CpustatCollectorConfig struct {
 	ExcludeMetrics []string `json:"exclude_metrics,omitempty"`
-	excludeNumCPUs bool
 }
 
 type CpustatCollector struct {
@@ -80,7 +79,6 @@ func (m *CpustatCollector) Init(config json.RawMessage) error {
 			m.matches[match] = index
 		}
 	}
-	m.config.excludeNumCPUs = slices.Contains(m.config.ExcludeMetrics, "num_cpus")
 
 	// Check input file
 	file, err := os.Open(CPUSTATFILE)
@@ -97,13 +95,11 @@ func (m *CpustatCollector) Init(config json.RawMessage) error {
 		line := scanner.Text()
 		linefields := strings.Fields(line)
 		if strings.Compare(linefields[0], "cpu") == 0 {
-			// Kernel system statistics for all CPUs
 			m.olddata["cpu"] = make(map[string]int64)
 			for k, v := range m.matches {
 				m.olddata["cpu"][k], _ = strconv.ParseInt(linefields[v], 0, 64)
 			}
 		} else if strings.HasPrefix(linefields[0], "cpu") && strings.Compare(linefields[0], "cpu") != 0 {
-			// Kernel system statistics per CPU
 			cpustr := strings.TrimLeft(linefields[0], "cpu")
 			cpu, _ := strconv.Atoi(cpustr)
 			m.cputags[linefields[0]] = map[string]string{
@@ -195,10 +191,9 @@ func (m *CpustatCollector) Read(interval time.Duration, output chan lp.CCMessage
 		}
 	}
 
-	if !m.config.excludeNumCPUs {
-		if num_cpus_metric, err := lp.NewMetric("num_cpus", m.nodetags, m.meta, num_cpus, now); err == nil {
-			output <- num_cpus_metric
-		}
+	num_cpus_metric, err := lp.NewMetric("num_cpus", m.nodetags, m.meta, num_cpus, now)
+	if err == nil {
+		output <- num_cpus_metric
 	}
 
 	m.lastTimestamp = now

collectors/infinibandMetric.go

@@ -23,29 +23,20 @@ import (
 	"golang.org/x/sys/unix"
 )
 
-// See: https://www.kernel.org/doc/Documentation/ABI/stable/sysfs-class-infiniband
-const (
-	ibBasePath     = "/sys/class/infiniband/"
-	ibDataUnit     = "bytes"
-	ibDataRateUnit = ibDataUnit + "/sec"
-	ibPkgUnit      = "packets"
-	ibPkgRateUnit  = ibPkgUnit + "/sec"
-)
+const IB_BASEPATH = "/sys/class/infiniband/"
 
 type InfinibandCollectorMetric struct {
-	name               string
-	path               string
-	unit               string
-	unitRates          string
-	scaleByFourLanes   bool
-	addToIBTotal       bool
-	addToIBTotalPkgs   bool
-	lastState          uint64
-	lastStateAvailable bool
+	name             string
+	path             string
+	unit             string
+	scale            int64
+	addToIBTotal     bool
+	addToIBTotalPkgs bool
+	lastState        int64
 }
 
 type InfinibandCollectorInfo struct {
-	lid              string                      // IB local Identifier (LID)
+	LID              string                      // IB local Identifier (LID)
 	device           string                      // IB device
 	port             string                      // IB device port
 	portCounterFiles []InfinibandCollectorMetric // mapping counter name -> InfinibandCollectorMetric
@@ -65,7 +56,7 @@ type InfinibandCollector struct {
 	lastTimestamp time.Time // Store time stamp of last tick to derive bandwidths
 }
 
-// Init initializes the Infiniband collector by walking through files below ibBasePath
+// Init initializes the Infiniband collector by walking through files below IB_BASEPATH
 func (m *InfinibandCollector) Init(config json.RawMessage) error {
 	// Check if already initialized
 	if m.init {
@@ -96,7 +87,7 @@ func (m *InfinibandCollector) Init(config json.RawMessage) error {
 	}
 
 	// Loop for all InfiniBand directories
-	globPattern := filepath.Join(ibBasePath, "*", "ports", "*")
+	globPattern := filepath.Join(IB_BASEPATH, "*", "ports", "*")
 	ibDirs, err := filepath.Glob(globPattern)
 	if err != nil {
 		return fmt.Errorf("%s Init(): unable to glob files with pattern %s: %w", m.name, globPattern, err)
@@ -131,42 +122,36 @@ func (m *InfinibandCollector) Init(config json.RawMessage) error {
 		countersDir := filepath.Join(path, "counters")
 		portCounterFiles := []InfinibandCollectorMetric{
 			{
-				// Total number of data octets, divided by 4 (lanes), received on all VLs.
-				// This is 64 bit counter
-				name:             "ib_recv",
-				path:             filepath.Join(countersDir, "port_rcv_data"),
-				unit:             ibDataUnit,
-				unitRates:        ibDataRateUnit,
-				scaleByFourLanes: true,
-				addToIBTotal:     true,
+				name:         "ib_recv",
+				path:         filepath.Join(countersDir, "port_rcv_data"),
+				unit:         "bytes",
+				scale:        4,
+				addToIBTotal: true,
+				lastState:    -1,
 			},
 			{
-				// Total number of data octets, divided by 4 (lanes), transmitted on all VLs.
-				// This is 64 bit counter
-				name:             "ib_xmit",
-				path:             filepath.Join(countersDir, "port_xmit_data"),
-				unit:             ibDataUnit,
-				unitRates:        ibDataRateUnit,
-				scaleByFourLanes: true,
-				addToIBTotal:     true,
+				name:         "ib_xmit",
+				path:         filepath.Join(countersDir, "port_xmit_data"),
+				unit:         "bytes",
+				scale:        4,
+				addToIBTotal: true,
+				lastState:    -1,
 			},
 			{
-				// Total number of packets received on all VLs from this port (this may include packets containing Errors.
-				// This is 64 bit counter.
 				name:             "ib_recv_pkts",
 				path:             filepath.Join(countersDir, "port_rcv_packets"),
-				unit:             ibPkgUnit,
-				unitRates:        ibPkgRateUnit,
+				unit:             "packets",
+				scale:            1,
 				addToIBTotalPkgs: true,
+				lastState:        -1,
 			},
 			{
-				// Total number of packets transmitted on all VLs from this port. This may include packets with errors.
-				// This is 64 bit counter.
 				name:             "ib_xmit_pkts",
 				path:             filepath.Join(countersDir, "port_xmit_packets"),
-				unit:             ibPkgUnit,
-				unitRates:        ibPkgRateUnit,
+				unit:             "packets",
+				scale:            1,
 				addToIBTotalPkgs: true,
+				lastState:        -1,
 			},
 		}
 		for _, counter := range portCounterFiles {
@@ -178,7 +163,7 @@ func (m *InfinibandCollector) Init(config json.RawMessage) error {
 
 		m.info = append(m.info,
 			InfinibandCollectorInfo{
-				lid:              LID,
+				LID:              LID,
 				device:           device,
 				port:             port,
 				portCounterFiles: portCounterFiles,
@@ -199,7 +184,7 @@ func (m *InfinibandCollector) Init(config json.RawMessage) error {
 	return nil
 }
 
-// Read reads Infiniband counter files below ibBasePath
+// Read reads Infiniband counter files below IB_BASEPATH
 func (m *InfinibandCollector) Read(interval time.Duration, output chan lp.CCMessage) {
 	// Check if already initialized
 	if !m.init {
@@ -216,9 +201,9 @@ func (m *InfinibandCollector) Read(interval time.Duration, output chan lp.CCMess
 	for i := range m.info {
 		info := &m.info[i]
 
-		var ibTotal, ibTotalPkts uint64      // sum of xmit and recv counters
-		var ibTotalBw, ibTotalPktsBw float64 // sum of xmit and recv rates
-		var ibTotalBwAvailable, ibTotalPktsBwAvailable bool
+		var ib_total, ib_total_last_state,
+			ib_total_pkts, ib_total_pkts_last_state int64
+		var ib_total_last_state_available, ib_total_pkts_last_state_available bool
 		for i := range info.portCounterFiles {
 			counterDef := &info.portCounterFiles[i]
 
@@ -228,30 +213,24 @@ func (m *InfinibandCollector) Read(interval time.Duration, output chan lp.CCMess
 				cclog.ComponentError(
 					m.name,
 					fmt.Sprintf("Read(): Failed to read from file '%s': %v", counterDef.path, err))
-				// Current counter can not be saved as last state
-				counterDef.lastStateAvailable = false
 				continue
 			}
 			data := strings.TrimSpace(string(line))
 
-			// convert counter to uint64
-			vRawCounter, err := strconv.ParseUint(data, 10, 64)
+			// convert counter to int64
+			v, err := strconv.ParseInt(data, 10, 64)
 			if err != nil {
 				cclog.ComponentError(
 					m.name,
-					fmt.Sprintf("Read(): Failed to convert Infininiband metrice %s='%s' to uint64: %v", counterDef.name, data, err))
-				// Current counter can not be saved as last state
-				counterDef.lastStateAvailable = false
+					fmt.Sprintf("Read(): Failed to convert Infininiband metrice %s='%s' to int64: %v", counterDef.name, data, err))
 				continue
 			}
-			vScaledCounter := vRawCounter
-			if counterDef.scaleByFourLanes {
-				vScaledCounter *= uint64(4)
-			}
+			// Scale raw value
+			v *= counterDef.scale
 
 			// Send absolut values
 			if m.config.SendAbsoluteValues {
-				if y, err := lp.NewMetric(counterDef.name, info.tagSet, m.meta, vScaledCounter, now); err == nil {
+				if y, err := lp.NewMetric(counterDef.name, info.tagSet, m.meta, v, now); err == nil {
 					y.AddMeta("unit", counterDef.unit)
 					output <- y
 				}
@@ -259,72 +238,63 @@ func (m *InfinibandCollector) Read(interval time.Duration, output chan lp.CCMess
 
 			// Send derived values
 			if m.config.SendDerivedValues {
-				if counterDef.lastStateAvailable {
-					var rate float64
-					// uint64 subtraction handles wraparound automatically
-					// in case vRawCounter < counterDef.lastState we would compute:
-					// math.MaxUint64 - lastState + vRawCounter + 1
-					// = (2^64 - 1) - lastState + vRawCounter + 1
-					// = 2^64 - lastState + vRawCounter
-					// ≡ vRawCounter - lastState (mod 2^64)
-					rate = float64(vRawCounter-counterDef.lastState) / timeDiff
-					if counterDef.scaleByFourLanes {
-						rate *= float64(4)
-					}
+				if counterDef.lastState >= 0 {
+					rate := float64((v - counterDef.lastState)) / timeDiff
 					if y, err := lp.NewMetric(counterDef.name+"_bw", info.tagSet, m.meta, rate, now); err == nil {
-						y.AddMeta("unit", counterDef.unitRates)
+						y.AddMeta("unit", counterDef.unit+"/sec")
 						output <- y
 					}
 
-					// Sum up rates for total rates
+					// Sum up total values of last state
 					if m.config.SendTotalValues {
 						switch {
 						case counterDef.addToIBTotal:
-							ibTotalBw += rate
-							ibTotalBwAvailable = true
+							ib_total_last_state += counterDef.lastState
+							ib_total_last_state_available = true
 						case counterDef.addToIBTotalPkgs:
-							ibTotalPktsBw += rate
-							ibTotalPktsBwAvailable = true
+							ib_total_pkts_last_state += counterDef.lastState
+							ib_total_pkts_last_state_available = true
 						}
 					}
 				}
-				counterDef.lastState = vRawCounter
-				counterDef.lastStateAvailable = true
+				counterDef.lastState = v
 			}
 
 			// Sum up total values
 			if m.config.SendTotalValues {
 				switch {
 				case counterDef.addToIBTotal:
-					ibTotal += vScaledCounter
+					ib_total += v
 				case counterDef.addToIBTotalPkgs:
-					ibTotalPkts += vScaledCounter
+					ib_total_pkts += v
 				}
 			}
 		}
 
 		// Send total values
 		if m.config.SendTotalValues {
-			if y, err := lp.NewMetric("ib_total", info.tagSet, m.meta, ibTotal, now); err == nil {
-				y.AddMeta("unit", ibDataUnit)
+			if y, err := lp.NewMetric("ib_total", info.tagSet, m.meta, ib_total, now); err == nil {
+				y.AddMeta("unit", "bytes")
 				output <- y
 			}
 
-			if y, err := lp.NewMetric("ib_total_pkts", info.tagSet, m.meta, ibTotalPkts, now); err == nil {
-				y.AddMeta("unit", ibPkgUnit)
+			if y, err := lp.NewMetric("ib_total_pkts", info.tagSet, m.meta, ib_total_pkts, now); err == nil {
+				y.AddMeta("unit", "packets")
 				output <- y
 			}
 
-			if m.config.SendDerivedValues && ibTotalBwAvailable {
-				if y, err := lp.NewMetric("ib_total_bw", info.tagSet, m.meta, ibTotalBw, now); err == nil {
-					y.AddMeta("unit", ibDataRateUnit)
+			if m.config.SendDerivedValues && ib_total_last_state_available {
+				rate := float64((ib_total - ib_total_last_state)) / timeDiff
+				if y, err := lp.NewMetric("ib_total_bw", info.tagSet, m.meta, rate, now); err == nil {
+					y.AddMeta("unit", "bytes/sec")
 					output <- y
 				}
 			}
 
-			if m.config.SendDerivedValues && ibTotalPktsBwAvailable {
-				if y, err := lp.NewMetric("ib_total_pkts_bw", info.tagSet, m.meta, ibTotalPktsBw, now); err == nil {
-					y.AddMeta("unit", ibPkgRateUnit)
+			if m.config.SendDerivedValues && ib_total_pkts_last_state_available {
+				rate := float64((ib_total_pkts - ib_total_pkts_last_state)) / timeDiff
+				if y, err := lp.NewMetric("ib_total_pkts_bw", info.tagSet, m.meta, rate, now); err == nil {
+					y.AddMeta("unit", "packets/sec")
 					output <- y
 				}
 			}

collectors/memstatMetric.go

@@ -72,8 +72,7 @@ func getStats(filename string) map[string]MemstatStats {
 	for scanner.Scan() {
 		line := scanner.Text()
 		linefields := strings.Fields(line)
-		switch len(linefields) {
-		case 3:
+		if len(linefields) == 3 {
 			v, err := strconv.ParseFloat(linefields[1], 64)
 			if err == nil {
 				stats[strings.Trim(linefields[0], ":")] = MemstatStats{
@@ -81,7 +80,7 @@ func getStats(filename string) map[string]MemstatStats {
 					unit:  linefields[2],
 				}
 			}
-		case 5:
+		} else if len(linefields) == 5 {
 			v, err := strconv.ParseFloat(linefields[3], 64)
 			if err == nil {
 				cclog.ComponentDebug("getStats", strings.Trim(linefields[2], ":"), v, linefields[4])
@@ -107,10 +106,7 @@ func (m *MemstatCollector) Init(config json.RawMessage) error {
 			return fmt.Errorf("%s Init(): Error decoding JSON config: %w", m.name, err)
 		}
 	}
-	m.meta = map[string]string{
-		"source": m.name,
-		"group":  "Memory",
-	}
+	m.meta = map[string]string{"source": m.name, "group": "Memory"}
 	m.stats = make(map[string]int64)
 	m.matches = make(map[string]string)
 	m.tags = map[string]string{"type": "node"}
@@ -149,7 +145,7 @@ func (m *MemstatCollector) Init(config json.RawMessage) error {
 		"KernelStack":     "mem_kernelstack",
 	}
 	for k, v := range matches {
-		if !slices.Contains(m.config.ExcludeMetrics, v) {
+		if !slices.Contains(m.config.ExcludeMetrics, k) {
 			m.matches[k] = v
 		}
 	}
@@ -157,7 +153,7 @@ func (m *MemstatCollector) Init(config json.RawMessage) error {
 	if !slices.Contains(m.config.ExcludeMetrics, "mem_used") {
 		m.sendMemUsed = true
 	}
-	if len(m.matches) == 0 && !m.sendMemUsed {
+	if len(m.matches) == 0 {
 		return fmt.Errorf("%s Init(): no metrics to collect", m.name)
 	}
 	if err := m.setup(); err != nil {

collectors/nvidiaMetric.go

@@ -1115,6 +1115,31 @@ func readNVLinkStats(device *NvidiaCollectorDevice, output chan lp.CCMessage) er
 	return nil
 }
 
+func readEfficiency(device *NvidiaCollectorDevice, output chan lp.CCMessage) error {
+	if !device.excludeMetrics["nv_util_eff"] {
+		maxPower, ret := nvml.DeviceGetEnforcedPowerLimit(device.device)
+		if ret == nvml.SUCCESS {
+			curPower, ret := nvml.DeviceGetPowerUsage(device.device)
+			if ret == nvml.SUCCESS {
+				util, ret := nvml.DeviceGetUtilizationRates(device.device)
+				if ret == nvml.SUCCESS {
+					factor := float64(curPower) / float64(maxPower)
+					eff := uint32(float64(util.Gpu) * factor)
+					if eff > 100 {
+						eff = 100
+					}
+					y, err := lp.NewMetric("nv_util_eff", device.tags, device.meta, eff, time.Now())
+					if err == nil {
+						y.AddTag("unit", "percent")
+						output <- y
+					}
+				}
+			}
+		}
+	}
+	return nil
+}
+
 func (m *NvidiaCollector) Read(interval time.Duration, output chan lp.CCMessage) {
 	var err error
 	if !m.init {
@@ -1220,6 +1245,11 @@ func (m *NvidiaCollector) Read(interval time.Duration, output chan lp.CCMessage)
 		if err != nil {
 			cclog.ComponentDebug(m.name, "readNVLinkStats for device", name, "failed")
 		}
+
+		err = readEfficiency(device, output)
+		if err != nil {
+			cclog.ComponentDebug(m.name, "readEfficiency for device", name, "failed")
+		}
 	}
 
 	// Actual read loop over all attached Nvidia GPUs

collectors/nvidiaMetric.md

@@ -85,5 +85,6 @@ Metrics:
 * `nv_energy`
 * `nv_energy_abs`
 * `nv_average_power`
+* `nv_util_eff` (`nv_util` * (`nv_power_usage` / `nv_power_max_limit`))
 
 Some metrics add the additional sub type tag (`stype`) like the `nv_nvlink_*` metrics set `stype=nvlink,stype-id=<link_number>`. 

collectors/raplMetric.go

@@ -22,24 +22,15 @@ import (
 )
 
 // running average power limit (RAPL) monitoring attributes for a zone
-// Only for Intel systems
-
 type RAPLZoneInfo struct {
-	energy            int64     // current reading of the energy counter in micro joules
-	maxEnergyRange    int64     // Range of the above energy counter in micro-joules
-	energyTimestamp   time.Time // timestamp when energy counter was read
-	energyFilepath    string    // path to a file containing the zones current energy counter in micro joules
-	shortTermFilepath string    // path to short term power limit
-	longTermFilepath  string    // path to long term power limit
-	enabledFilepath   string    // path to check whether limits are enabled
-	name              string
-
 	// tags describing the RAPL zone:
 	// * zone_name, subzone_name: e.g. psys, dram, core, uncore, package-0
 	// * zone_id: e.g. 0:1 (zone 0 sub zone 1)
-	// type=socket for dram, core, uncore, package-* and type=node for psys
-	// type-id=socket id
-	tags map[string]string
+	tags            map[string]string
+	energyFilepath  string    // path to a file containing the zones current energy counter in micro joules
+	energy          int64     // current reading of the energy counter in micro joules
+	energyTimestamp time.Time // timestamp when energy counter was read
+	maxEnergyRange  int64     // Range of the above energy counter in micro-joules
 }
 
 type RAPLCollector struct {
@@ -51,40 +42,12 @@ type RAPLCollector struct {
 		// * 0:1 for zone 0 subzone 1
 		ExcludeByID []string `json:"exclude_device_by_id,omitempty"`
 		// Exclude names for RAPL zones, e.g. psys, dram, core, uncore, package-0
-		ExcludeByName     []string `json:"exclude_device_by_name,omitempty"`
-		SkipEnergyReading bool     `json:"skip_energy_reading,omitempty"`
-		SkipLimitsReading bool     `json:"skip_limits_reading,omitempty"`
-		OnlyEnabledLimits bool     `json:"only_enabled_limits,omitempty"`
+		ExcludeByName []string `json:"exclude_device_by_name,omitempty"`
 	}
-	raplZoneInfo []RAPLZoneInfo
+	RAPLZoneInfo []RAPLZoneInfo
 	meta         map[string]string // default meta information
 }
 
-// Get the path to the power limit file for zone selectable by limit name
-// Common limit names for Intel systems are
-// - long_term
-// - short_term
-// Does not support AMD as AMD systems do not provide the power limits
-// through sysfs
-func ZoneLimitFile(folder string, limit_name string) string {
-	nameGlob := filepath.Join(folder, "constraint_*_name")
-	candidates, err := filepath.Glob(nameGlob)
-	if err == nil {
-		for _, c := range candidates {
-			if v, err := os.ReadFile(c); err == nil {
-				if strings.TrimSpace(string(v)) == limit_name {
-					var i int
-					n, err := fmt.Sscanf(filepath.Base(c), "constraint_%d_name", &i)
-					if err == nil && n == 1 {
-						return filepath.Join(folder, fmt.Sprintf("constraint_%d_power_limit_uw", i))
-					}
-				}
-			}
-		}
-	}
-	return ""
-}
-
 // Init initializes the running average power limit (RAPL) collector
 func (m *RAPLCollector) Init(config json.RawMessage) error {
 	// Check if already initialized
@@ -104,9 +67,6 @@ func (m *RAPLCollector) Init(config json.RawMessage) error {
 	}
 
 	// Read in the JSON configuration
-	m.config.SkipEnergyReading = false
-	m.config.SkipLimitsReading = false
-	m.config.OnlyEnabledLimits = true
 	if len(config) > 0 {
 		d := json.NewDecoder(bytes.NewReader(config))
 		d.DisallowUnknownFields()
@@ -133,63 +93,49 @@ func (m *RAPLCollector) Init(config json.RawMessage) error {
 	// See: https://www.kernel.org/doc/html/latest/power/powercap/powercap.html#monitoring-attributes
 	readZoneInfo := func(zonePath string) (
 		z struct {
-			name              string    // zones name e.g. psys, dram, core, uncore, package-0
-			energyFilepath    string    // path to a file containing the zones current energy counter in micro joules
-			energy            int64     // current reading of the energy counter in micro joules
-			energyTimestamp   time.Time // timestamp when energy counter was read
-			maxEnergyRange    int64     // Range of the above energy counter in micro-joules
-			shortTermFilepath string
-			longTermFilepath  string
-			enabledFilepath   string
+			name            string    // zones name e.g. psys, dram, core, uncore, package-0
+			energyFilepath  string    // path to a file containing the zones current energy counter in micro joules
+			energy          int64     // current reading of the energy counter in micro joules
+			energyTimestamp time.Time // timestamp when energy counter was read
+			maxEnergyRange  int64     // Range of the above energy counter in micro-joules
+			ok              bool      // Are all information available?
 		},
 	) {
 		// zones name e.g. psys, dram, core, uncore, package-0
-
-		if v, err :=
-			os.ReadFile(
-				filepath.Join(zonePath, "name")); err == nil {
+		foundName := false
+		if v, err := os.ReadFile(
+			filepath.Join(zonePath, "name")); err == nil {
+			foundName = true
 			z.name = strings.TrimSpace(string(v))
 		}
 
-		if !m.config.SkipEnergyReading {
-			// path to a file containing the zones current energy counter in micro joules
-			z.energyFilepath = filepath.Join(zonePath, "energy_uj")
-			// current reading of the energy counter in micro joules
-			if v, err := os.ReadFile(z.energyFilepath); err == nil {
-				if i, err := strconv.ParseInt(strings.TrimSpace(string(v)), 10, 64); err == nil {
-					z.energy = i
-					// timestamp when energy counter was read
-					z.energyTimestamp = time.Now()
-				}
-			} else {
-				cclog.ComponentErrorf(m.name, "Cannot read energy file for %s: %v", z.name, err.Error())
+		// path to a file containing the zones current energy counter in micro joules
+		z.energyFilepath = filepath.Join(zonePath, "energy_uj")
+
+		// current reading of the energy counter in micro joules
+		foundEnergy := false
+		if v, err := os.ReadFile(z.energyFilepath); err == nil {
+			// timestamp when energy counter was read
+			z.energyTimestamp = time.Now()
+			if i, err := strconv.ParseInt(strings.TrimSpace(string(v)), 10, 64); err == nil {
+				foundEnergy = true
+				z.energy = i
 			}
-			// Range of the above energy counter in micro-joules
-			if v, err :=
-				os.ReadFile(
-					filepath.Join(zonePath, "max_energy_range_uj")); err == nil {
-				if i, err := strconv.ParseInt(strings.TrimSpace(string(v)), 10, 64); err == nil {
-					z.maxEnergyRange = i
-				}
-			}
-		} else {
-			cclog.ComponentDebugf(m.name, "Energy readings for %s disabled", zonePath)
 		}
 
-		if !m.config.SkipLimitsReading {
-			z.shortTermFilepath = ZoneLimitFile(zonePath, "short_term")
-			if _, err := os.Stat(z.shortTermFilepath); err != nil {
-				z.shortTermFilepath = ""
+		// Range of the above energy counter in micro-joules
+		foundMaxEnergyRange := false
+		if v, err := os.ReadFile(
+			filepath.Join(zonePath, "max_energy_range_uj")); err == nil {
+			if i, err := strconv.ParseInt(strings.TrimSpace(string(v)), 10, 64); err == nil {
+				foundMaxEnergyRange = true
+				z.maxEnergyRange = i
 			}
-			z.longTermFilepath = ZoneLimitFile(zonePath, "long_term")
-			if _, err := os.Stat(z.longTermFilepath); err != nil {
-				z.longTermFilepath = ""
-			}
-			z.enabledFilepath = filepath.Join(zonePath, "enabled")
-		} else {
-			cclog.ComponentDebugf(m.name, "Power limit readings for %s disabled", zonePath)
 		}
 
+		// Are all information available?
+		z.ok = foundName && foundEnergy && foundMaxEnergyRange
+
 		return
 	}
 
@@ -206,36 +152,14 @@ func (m *RAPLCollector) Init(config json.RawMessage) error {
 
 	for _, zonePath := range zonesPath {
 		zoneID := strings.TrimPrefix(zonePath, zonePrefix)
-
 		z := readZoneInfo(zonePath)
-		if !isIDExcluded[zoneID] &&
+		if z.ok &&
+			!isIDExcluded[zoneID] &&
 			!isNameExcluded[z.name] {
 
-			si := RAPLZoneInfo{
-				tags:              make(map[string]string),
-				energyFilepath:    z.energyFilepath,
-				energy:            z.energy,
-				energyTimestamp:   z.energyTimestamp,
-				maxEnergyRange:    z.maxEnergyRange,
-				shortTermFilepath: z.shortTermFilepath,
-				longTermFilepath:  z.longTermFilepath,
-				enabledFilepath:   z.enabledFilepath,
-				name:              z.name,
-			}
-			si.tags["type"] = "node"
-			si.tags["type-id"] = "0"
-			var pid int = 0
-			if strings.HasPrefix(z.name, "package-") {
-				n, err := fmt.Sscanf(z.name, "package-%d", &pid)
-				if err == nil && n == 1 {
-					si.tags["type-id"] = fmt.Sprintf("%d", pid)
-					si.tags["type"] = "socket"
-				}
-				si.name = "pkg"
-			}
 			// Add RAPL monitoring attributes for a zone
-			m.raplZoneInfo = append(
-				m.raplZoneInfo,
+			m.RAPLZoneInfo = append(
+				m.RAPLZoneInfo,
 				RAPLZoneInfo{
 					tags: map[string]string{
 						"id":        zoneID,
@@ -258,40 +182,37 @@ func (m *RAPLCollector) Init(config json.RawMessage) error {
 		for _, subZonePath := range subZonesPath {
 			subZoneID := strings.TrimPrefix(subZonePath, subZonePrefix)
 			sz := readZoneInfo(subZonePath)
-
 			if len(zoneID) > 0 && len(z.name) > 0 &&
+				sz.ok &&
 				!isIDExcluded[zoneID+":"+subZoneID] &&
 				!isNameExcluded[sz.name] {
-				m.raplZoneInfo = append(
-					m.raplZoneInfo,
+				m.RAPLZoneInfo = append(
+					m.RAPLZoneInfo,
 					RAPLZoneInfo{
 						tags: map[string]string{
 							"id":            zoneID + ":" + subZoneID,
 							"zone_name":     z.name,
 							"sub_zone_name": sz.name,
 						},
-						energyFilepath:    sz.energyFilepath,
-						energy:            sz.energy,
-						energyTimestamp:   sz.energyTimestamp,
-						maxEnergyRange:    sz.maxEnergyRange,
-						shortTermFilepath: sz.shortTermFilepath,
-						longTermFilepath:  sz.longTermFilepath,
-						enabledFilepath:   sz.enabledFilepath,
-						name:              sz.name,
+						energyFilepath:  sz.energyFilepath,
+						energy:          sz.energy,
+						energyTimestamp: sz.energyTimestamp,
+						maxEnergyRange:  sz.maxEnergyRange,
 					})
 			}
 		}
 	}
 
-	if m.raplZoneInfo == nil {
+	if m.RAPLZoneInfo == nil {
 		return fmt.Errorf("no running average power limit (RAPL) device found in %s", controlTypePath)
 	}
 
 	// Initialized
 	cclog.ComponentDebug(
 		m.name,
-		"initialized %d zones with running average power limit (RAPL) monitoring attributes",
-		len(m.raplZoneInfo))
+		"initialized",
+		len(m.RAPLZoneInfo),
+		"zones with running average power limit (RAPL) monitoring attributes")
 	m.init = true
 
 	return err
@@ -300,89 +221,35 @@ func (m *RAPLCollector) Init(config json.RawMessage) error {
 // Read reads running average power limit (RAPL) monitoring attributes for all initialized zones
 // See: https://www.kernel.org/doc/html/latest/power/powercap/powercap.html#monitoring-attributes
 func (m *RAPLCollector) Read(interval time.Duration, output chan lp.CCMessage) {
-	for i := range m.raplZoneInfo {
-		p := &m.raplZoneInfo[i]
+	for i := range m.RAPLZoneInfo {
+		p := &m.RAPLZoneInfo[i]
 
-		if !m.config.SkipEnergyReading {
-			// Read current value of the energy counter in micro joules
-			if v, err := os.ReadFile(p.energyFilepath); err == nil {
-				energyTimestamp := time.Now()
-				if i, err := strconv.ParseInt(strings.TrimSpace(string(v)), 10, 64); err == nil {
-					energy := i
+		// Read current value of the energy counter in micro joules
+		if v, err := os.ReadFile(p.energyFilepath); err == nil {
+			energyTimestamp := time.Now()
+			if i, err := strconv.ParseInt(strings.TrimSpace(string(v)), 10, 64); err == nil {
+				energy := i
 
-					// Compute average power (Δ energy / Δ time)
-					energyDiff := energy - p.energy
-					if energyDiff < 0 {
-						// Handle overflow:
-						// ( p.maxEnergyRange - p.energy ) + energy
-						// = p.maxEnergyRange + ( energy - p.energy )
-						// = p.maxEnergyRange + diffEnergy
-						energyDiff += p.maxEnergyRange
-					}
-					timeDiff := energyTimestamp.Sub(p.energyTimestamp)
-					averagePower := float64(energyDiff) / float64(timeDiff.Microseconds())
-
-					y, err := lp.NewMetric(
-						fmt.Sprintf("rapl_%s_average_power", p.name),
-						p.tags,
-						m.meta,
-						averagePower,
-						energyTimestamp)
-					if err == nil {
-						output <- y
-					}
-
-					e, err := lp.NewMetric(
-						fmt.Sprintf("rapl_%s_energy", p.name),
-						p.tags,
-						m.meta,
-						float64(energyDiff)*1e-3,
-						energyTimestamp)
-					if err == nil {
-						e.AddMeta("unit", "Joules")
-						output <- e
-					}
-
-					// Save current energy counter state
-					p.energy = energy
-					p.energyTimestamp = energyTimestamp
+				// Compute average power (Δ energy / Δ time)
+				energyDiff := energy - p.energy
+				if energyDiff < 0 {
+					// Handle overflow:
+					// ( p.maxEnergyRange - p.energy ) + energy
+					// = p.maxEnergyRange + ( energy - p.energy )
+					// = p.maxEnergyRange + diffEnergy
+					energyDiff += p.maxEnergyRange
 				}
-			}
-		}
-		// https://www.kernel.org/doc/html/latest/power/powercap/powercap.html#constraints
-		if !m.config.SkipLimitsReading {
-			skip := false
-			if m.config.OnlyEnabledLimits {
-				if v, err := os.ReadFile(p.enabledFilepath); err == nil {
-					if strings.TrimSpace(string(v)) == "0" {
-						skip = true
-					}
-				}
-			}
-			if !skip {
-				if len(p.shortTermFilepath) > 0 {
-					if v, err := os.ReadFile(p.shortTermFilepath); err == nil {
-						if i, err := strconv.ParseInt(strings.TrimSpace(string(v)), 10, 64); err == nil {
-							name := fmt.Sprintf("rapl_%s_limit_short_term", p.name)
-							y, err := lp.NewMetric(name, p.tags, m.meta, i/1e6, time.Now())
-							if err == nil {
-								output <- y
-							}
-						}
-					}
+				timeDiff := energyTimestamp.Sub(p.energyTimestamp)
+				averagePower := float64(energyDiff) / float64(timeDiff.Microseconds())
+
+				y, err := lp.NewMetric("rapl_average_power", p.tags, m.meta, averagePower, energyTimestamp)
+				if err == nil {
+					output <- y
 				}
 
-				if len(p.longTermFilepath) > 0 {
-					if v, err := os.ReadFile(p.longTermFilepath); err == nil {
-						if i, err := strconv.ParseInt(strings.TrimSpace(string(v)), 10, 64); err == nil {
-							name := fmt.Sprintf("rapl_%s_limit_long_term", p.name)
-							y, err := lp.NewMetric(name, p.tags, m.meta, i/1e6, time.Now())
-							if err == nil {
-								output <- y
-							}
-						}
-					}
-				}
+				// Save current energy counter state
+				p.energy = energy
+				p.energyTimestamp = energyTimestamp
 			}
 		}
 	}

collectors/raplMetric.md

@@ -11,24 +11,16 @@ hugo_path: docs/reference/cc-metric-collector/collectors/rapl.md
 
 ## `rapl` collector
 
-This collector reads running average power limit (RAPL) monitoring attributes to compute average power consumption metrics. See <https://www.kernel.org/doc/html/latest/power/powercap/powercap.html>.
+This collector reads running average power limit (RAPL) monitoring attributes to compute average power consumption metrics. See <https://www.kernel.org/doc/html/latest/power/powercap/powercap.html#monitoring-attributes>.
+
+The Likwid metric collector provides similar functionality.
 
 ```json
   "rapl": {
     "exclude_device_by_id": ["0:1", "0:2"],
-    "exclude_device_by_name": ["psys"],
-    "skip_energy_reading": false,
-    "skip_limits_reading": false,
-    "only_enabled_limits": true
+    "exclude_device_by_name": ["psys"]
   }
 ```
 
 Metrics:
-* `rapl_<domain>_average_power`: average power consumption in Watt. The average is computed over the entire runtime from the last measurement to the current measurement
-* `rapl_<domain>_energy`: Difference from the last measurement
-* `rapl_<domain>_limit_short_term`: Short term powercap setting for the domain
-* `rapl_<domain>_limit_long_term`: Long term powercap setting for the domain
-
-Only the `rapl_<domain>_average_power` and `rapl_<domain>_energy` metrics require root-permissions. The limits can be read as user. Some domains have limits available but they are not enabled. By default, only enabled domain limits are collected.
-
-Energy and power measurments can also be done with the Likwid metric collector.
+* `rapl_average_power`: average power consumption in Watt. The average is computed over the entire runtime from the last measurement to the current measurement

go.mod

@@ -7,10 +7,10 @@ require (
 	github.com/ClusterCockpit/go-rocm-smi v0.4.0
 	github.com/NVIDIA/go-nvml v0.13.0-1
 	github.com/PaesslerAG/gval v1.2.4
-	github.com/fsnotify/fsnotify v1.10.1
-	github.com/tklauser/go-sysconf v0.4.0
-	golang.design/x/thread v0.3.2
-	golang.org/x/sys v0.45.0
+	github.com/fsnotify/fsnotify v1.10.0
+	github.com/tklauser/go-sysconf v0.3.16
+	golang.design/x/thread v0.0.0-20210122121316-335e9adffdf1
+	golang.org/x/sys v0.43.0
 )
 
 require (
@@ -38,7 +38,7 @@ require (
 	github.com/santhosh-tekuri/jsonschema/v5 v5.3.1 // indirect
 	github.com/shopspring/decimal v1.4.0 // indirect
 	github.com/stmcginnis/gofish v0.21.6 // indirect
-	github.com/tklauser/numcpus v0.12.0 // indirect
+	github.com/tklauser/numcpus v0.11.0 // indirect
 	go.yaml.in/yaml/v2 v2.4.4 // indirect
 	golang.org/x/crypto v0.50.0 // indirect
 	golang.org/x/net v0.53.0 // indirect

go.sum

@@ -53,8 +53,8 @@ github.com/expr-lang/expr v1.17.8 h1:W1loDTT+0PQf5YteHSTpju2qfUfNoBt4yw9+wOEU9VM
 github.com/expr-lang/expr v1.17.8/go.mod h1:8/vRC7+7HBzESEqt5kKpYXxrxkr31SaO8r40VO/1IT4=
 github.com/frankban/quicktest v1.13.0 h1:yNZif1OkDfNoDfb9zZa9aXIpejNR4F23Wely0c+Qdqk=
 github.com/frankban/quicktest v1.13.0/go.mod h1:qLE0fzW0VuyUAJgPU19zByoIr0HtCHN/r/VLSOOIySU=
-github.com/fsnotify/fsnotify v1.10.1 h1:b0/UzAf9yR5rhf3RPm9gf3ehBPpf0oZKIjtpKrx59Ho=
-github.com/fsnotify/fsnotify v1.10.1/go.mod h1:TLheqan6HD6GBK6PrDWyDPBaEV8LspOxvPSjC+bVfgo=
+github.com/fsnotify/fsnotify v1.10.0 h1:Xx/5Ydg9CeBDX/wi4VJqStNtohYjitZhhlHt4h3St1M=
+github.com/fsnotify/fsnotify v1.10.0/go.mod h1:TLheqan6HD6GBK6PrDWyDPBaEV8LspOxvPSjC+bVfgo=
 github.com/go-ole/go-ole v1.3.0 h1:Dt6ye7+vXGIKZ7Xtk4s6/xVdGDQynvom7xCFEdWr6uE=
 github.com/go-ole/go-ole v1.3.0/go.mod h1:5LS6F96DhAwUc7C+1HLexzMXY1xGRSryjyPPKW6zv78=
 github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
@@ -163,18 +163,18 @@ github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/testcontainers/testcontainers-go v0.26.0 h1:uqcYdoOHBy1ca7gKODfBd9uTHVK3a7UL848z09MVZ0c=
 github.com/testcontainers/testcontainers-go v0.26.0/go.mod h1:ICriE9bLX5CLxL9OFQ2N+2N+f+803LNJ1utJb1+Inx0=
-github.com/tklauser/go-sysconf v0.4.0 h1:7H0uAN+7RkwWRaxhYXDLqa5V3LPrJeV8wmD9dRUgPQU=
-github.com/tklauser/go-sysconf v0.4.0/go.mod h1:8mTNWyog7H+MpKijp4VmKJAd2bbYQ2zuUwkYRbUArPI=
-github.com/tklauser/numcpus v0.12.0 h1:NR85qdvHA9pFse3x3weVZ0r0ST8R6l5RHbZrlRaqob4=
-github.com/tklauser/numcpus v0.12.0/go.mod h1:ABHeXzJnr/qqwguhClkZKT1/8VABcYrsyUiUGobwWJg=
+github.com/tklauser/go-sysconf v0.3.16 h1:frioLaCQSsF5Cy1jgRBrzr6t502KIIwQ0MArYICU0nA=
+github.com/tklauser/go-sysconf v0.3.16/go.mod h1:/qNL9xxDhc7tx3HSRsLWNnuzbVfh3e7gh/BmM179nYI=
+github.com/tklauser/numcpus v0.11.0 h1:nSTwhKH5e1dMNsCdVBukSZrURJRoHbSEQjdEbY+9RXw=
+github.com/tklauser/numcpus v0.11.0/go.mod h1:z+LwcLq54uWZTX0u/bGobaV34u6V7KNlTZejzM6/3MQ=
 github.com/yusufpapurcu/wmi v1.2.3 h1:E1ctvB7uKFMOJw3fdOW32DwGE9I7t++CRUEMKvFoFiw=
 github.com/yusufpapurcu/wmi v1.2.3/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQmPyzfmi0=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ=
 go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ=
-golang.design/x/thread v0.3.2 h1:FmD1glspGrQCe6FuQLmSrT6wz2CSzq7vKVDluyiMnqo=
-golang.design/x/thread v0.3.2/go.mod h1:6+Hi2rMOgMHZdKDWaqNHyWtoFUx1HxZ06LfHPh5Z/hQ=
+golang.design/x/thread v0.0.0-20210122121316-335e9adffdf1 h1:P7S/GeHBAFEZIYp0ePPs2kHXoazz8q2KsyxHyQVGCJg=
+golang.design/x/thread v0.0.0-20210122121316-335e9adffdf1/go.mod h1:9CWpnTUmlQkfdpdutA1nNf4iE5lAVt3QZOu0Z6hahBE=
 golang.org/x/crypto v0.50.0 h1:zO47/JPrL6vsNkINmLoo/PH1gcxpls50DNogFvB5ZGI=
 golang.org/x/crypto v0.50.0/go.mod h1:3muZ7vA7PBCE6xgPX7nkzzjiUq87kRItoJQM1Yo8S+Q=
 golang.org/x/exp v0.0.0-20231005195138-3e424a577f31 h1:9k5exFQKQglLo+RoP+4zMjOFE14P6+vyR0baDAi0Rcs=
@@ -183,8 +183,9 @@ golang.org/x/mod v0.13.0 h1:I/DsJXRlw/8l/0c24sM9yb0T4z9liZTduXvdAWYiysY=
 golang.org/x/mod v0.13.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.53.0 h1:d+qAbo5L0orcWAr0a9JweQpjXF19LMXJE8Ey7hwOdUA=
 golang.org/x/net v0.53.0/go.mod h1:JvMuJH7rrdiCfbeHoo3fCQU24Lf5JJwT9W3sJFulfgs=
-golang.org/x/sys v0.45.0 h1:dO4czNzziLiiXplLQgBCEpCvXQ3dnkn0SdaZSYdQ+FY=
-golang.org/x/sys v0.45.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
+golang.org/x/sys v0.0.0-20210122093101-04d7465088b8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
+golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
 golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U=
 golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno=
 golang.org/x/tools v0.14.0 h1:jvNa2pY0M4r62jkRQ6RwEZZyPcymeL9XZMLBbV7U2nc=