use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::time::{Duration, Instant};
use crate::error::IronError;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum PowerDomain {
Package,
Core,
Uncore,
Dram,
Platform,
Gpu,
Other,
}
impl std::fmt::Display for PowerDomain {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Package => write!(f, "Package"),
Self::Core => write!(f, "Core"),
Self::Uncore => write!(f, "Uncore"),
Self::Dram => write!(f, "DRAM"),
Self::Platform => write!(f, "Platform"),
Self::Gpu => write!(f, "GPU"),
Self::Other => write!(f, "Other"),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EnergyReading {
pub domain: PowerDomain,
pub name: String,
pub socket: u32,
pub energy_uj: u64,
pub max_energy_range_uj: Option<u64>,
pub power_limit_uw: Option<u64>,
pub enabled: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PowerSnapshot {
pub domain_watts: HashMap<String, f64>,
pub total_package_watts: Option<f64>,
pub total_core_watts: Option<f64>,
pub total_dram_watts: Option<f64>,
pub measurement_duration_secs: f64,
pub energy_delta_uj: HashMap<String, u64>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PowerEfficiency {
pub avg_package_watts: f64,
pub peak_package_watts: f64,
pub efficiency_ratio: f64,
pub within_tdp: bool,
pub estimated_tdp: f64,
pub headroom_watts: f64,
pub recommendations: Vec<String>,
}
pub struct RaplMonitor {
readings: Vec<EnergyReading>,
prev_readings: Vec<EnergyReading>,
prev_time: Option<Instant>,
snapshot: Option<PowerSnapshot>,
peak_watts: f64,
avg_watts: f64,
sample_count: u64,
}
impl RaplMonitor {
pub fn new() -> Result<Self, IronError> {
let readings = Self::read_energy()?;
Ok(Self {
readings: readings.clone(),
prev_readings: readings,
prev_time: Some(Instant::now()),
snapshot: None,
peak_watts: 0.0,
avg_watts: 0.0,
sample_count: 0,
})
}
pub fn refresh(&mut self) -> Result<(), IronError> {
let now = Instant::now();
self.prev_readings = self.readings.clone();
self.readings = Self::read_energy()?;
if let Some(prev_time) = self.prev_time {
let elapsed = now.duration_since(prev_time);
if elapsed > Duration::from_millis(10) {
self.snapshot = Some(Self::compute_power(
&self.prev_readings,
&self.readings,
elapsed,
));
if let Some(package) = self.snapshot.as_ref().and_then(|s| s.total_package_watts) {
if package > self.peak_watts {
self.peak_watts = package;
}
self.sample_count += 1;
self.avg_watts += (package - self.avg_watts) / self.sample_count as f64;
}
}
}
self.prev_time = Some(now);
Ok(())
}
pub fn readings(&self) -> &[EnergyReading] {
&self.readings
}
pub fn snapshot(&self) -> Option<&PowerSnapshot> {
self.snapshot.as_ref()
}
pub fn efficiency(&self, estimated_tdp: f64) -> Option<PowerEfficiency> {
let current_watts = self.snapshot.as_ref()?.total_package_watts?;
let within_tdp = current_watts <= estimated_tdp;
let headroom = (estimated_tdp - current_watts).max(0.0);
let efficiency_ratio = if estimated_tdp > 0.0 {
(1.0 - (current_watts / estimated_tdp).min(1.0)).max(0.0)
} else {
0.0
};
let mut recommendations = Vec::new();
if current_watts > estimated_tdp * 0.95 {
recommendations.push("Running near TDP limit; may thermal throttle".into());
}
if self.peak_watts > estimated_tdp * 1.2 {
recommendations.push(format!(
"Peak power ({:.1}W) exceeded TDP by {:.0}%",
self.peak_watts,
((self.peak_watts / estimated_tdp) - 1.0) * 100.0
));
}
if current_watts < estimated_tdp * 0.1 && current_watts > 0.0 {
recommendations.push("Very low power draw; system may be mostly idle".into());
}
if headroom > estimated_tdp * 0.5 {
recommendations.push("Significant power headroom available for turbo boost".into());
}
Some(PowerEfficiency {
avg_package_watts: self.avg_watts,
peak_package_watts: self.peak_watts,
efficiency_ratio,
within_tdp,
estimated_tdp,
headroom_watts: headroom,
recommendations,
})
}
fn compute_power(
prev: &[EnergyReading],
curr: &[EnergyReading],
elapsed: Duration,
) -> PowerSnapshot {
let secs = elapsed.as_secs_f64();
let mut domain_watts = HashMap::new();
let mut energy_delta_uj = HashMap::new();
let mut total_package: Option<f64> = None;
let mut total_core: Option<f64> = None;
let mut total_dram: Option<f64> = None;
for c in curr {
if let Some(p) = prev
.iter()
.find(|p| p.name == c.name && p.socket == c.socket)
{
let delta = if c.energy_uj >= p.energy_uj {
c.energy_uj - p.energy_uj
} else {
let Some(range) = c.max_energy_range_uj else {
continue;
};
(range - p.energy_uj) + c.energy_uj
};
let watts = delta as f64 / (secs * 1_000_000.0);
let key = format!("socket{}:{}", c.socket, c.name);
domain_watts.insert(key.clone(), watts);
energy_delta_uj.insert(key, delta);
let total = match c.domain {
PowerDomain::Package | PowerDomain::Platform => &mut total_package,
PowerDomain::Core => &mut total_core,
PowerDomain::Dram => &mut total_dram,
_ => continue,
};
*total = Some(total.unwrap_or(0.0) + watts);
}
}
PowerSnapshot {
domain_watts,
total_package_watts: total_package,
total_core_watts: total_core,
total_dram_watts: total_dram,
measurement_duration_secs: secs,
energy_delta_uj,
}
}
#[cfg(target_os = "linux")]
fn read_energy() -> Result<Vec<EnergyReading>, IronError> {
let mut readings = Vec::new();
let powercap = std::path::Path::new("/sys/class/powercap");
if !powercap.exists() {
return Ok(readings);
}
if let Ok(entries) = std::fs::read_dir(powercap) {
for entry in entries.flatten() {
let name = entry.file_name().to_string_lossy().to_string();
if !name.starts_with("intel-rapl:") {
continue;
}
let path = entry.path();
let socket = name
.strip_prefix("intel-rapl:")
.and_then(|s| s.parse::<u32>().ok())
.unwrap_or(0);
if let Some(reading) = Self::read_domain(&path, socket) {
readings.push(reading);
}
if let Ok(sub_entries) = std::fs::read_dir(&path) {
for sub in sub_entries.flatten() {
let sub_name = sub.file_name().to_string_lossy().to_string();
if sub_name.starts_with("intel-rapl:") {
if let Some(reading) = Self::read_domain(&sub.path(), socket) {
readings.push(reading);
}
}
}
}
}
}
Ok(readings)
}
#[cfg(target_os = "linux")]
fn read_domain(path: &std::path::Path, socket: u32) -> Option<EnergyReading> {
let name = std::fs::read_to_string(path.join("name"))
.ok()?
.trim()
.to_string();
let energy_uj = std::fs::read_to_string(path.join("energy_uj"))
.ok()
.and_then(|s| s.trim().parse::<u64>().ok())?;
let max_energy_range_uj = std::fs::read_to_string(path.join("max_energy_range_uj"))
.ok()
.and_then(|s| s.trim().parse::<u64>().ok());
let enabled = std::fs::read_to_string(path.join("enabled"))
.ok()
.map(|s| s.trim() == "1")
.unwrap_or(true);
let power_limit_uw = std::fs::read_to_string(path.join("constraint_0_power_limit_uw"))
.ok()
.and_then(|s| s.trim().parse::<u64>().ok());
let domain = match name.as_str() {
"package-0" | "package-1" | "package-2" | "package-3" => PowerDomain::Package,
"core" => PowerDomain::Core,
"uncore" => PowerDomain::Uncore,
"dram" => PowerDomain::Dram,
"psys" => PowerDomain::Platform,
_ => PowerDomain::Other,
};
Some(EnergyReading {
domain,
name,
socket,
energy_uj,
max_energy_range_uj,
power_limit_uw,
enabled,
})
}
#[cfg(target_os = "windows")]
fn read_energy() -> Result<Vec<EnergyReading>, IronError> {
Err(IronError::UnsupportedPlatform(
"Windows exposes no RAPL interface to unprivileged code: the MSRs behind it need a kernel driver, and there is no sysfs equivalent"
.into(),
))
}
#[cfg(target_os = "macos")]
fn read_energy() -> Result<Vec<EnergyReading>, IronError> {
Err(IronError::PermissionDenied(
"macOS exposes package energy only through powermetrics, which requires root".into(),
))
}
#[cfg(not(any(target_os = "linux", target_os = "windows", target_os = "macos")))]
fn read_energy() -> Result<Vec<EnergyReading>, IronError> {
Ok(Vec::new())
}
}
impl Default for RaplMonitor {
fn default() -> Self {
Self::new().unwrap_or(Self {
readings: Vec::new(),
prev_readings: Vec::new(),
prev_time: None,
snapshot: None,
peak_watts: 0.0,
avg_watts: 0.0,
sample_count: 0,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_power_computation() {
let prev = vec![EnergyReading {
domain: PowerDomain::Package,
name: "package-0".into(),
socket: 0,
energy_uj: 1_000_000, max_energy_range_uj: Some(u64::MAX),
power_limit_uw: Some(125_000_000),
enabled: true,
}];
let curr = vec![EnergyReading {
domain: PowerDomain::Package,
name: "package-0".into(),
socket: 0,
energy_uj: 11_000_000, max_energy_range_uj: Some(u64::MAX),
power_limit_uw: Some(125_000_000),
enabled: true,
}];
let elapsed = Duration::from_secs(1);
let snap = RaplMonitor::compute_power(&prev, &curr, elapsed);
assert!((snap.total_package_watts.unwrap() - 10.0).abs() < 0.1);
}
#[test]
fn test_counter_wrap() {
let prev = vec![EnergyReading {
domain: PowerDomain::Core,
name: "core".into(),
socket: 0,
energy_uj: 90_000_000,
max_energy_range_uj: Some(100_000_000),
power_limit_uw: None,
enabled: true,
}];
let curr = vec![EnergyReading {
domain: PowerDomain::Core,
name: "core".into(),
socket: 0,
energy_uj: 5_000_000, max_energy_range_uj: Some(100_000_000),
power_limit_uw: None,
enabled: true,
}];
let elapsed = Duration::from_secs(1);
let snap = RaplMonitor::compute_power(&prev, &curr, elapsed);
assert!((snap.total_core_watts.unwrap() - 15.0).abs() < 0.1);
}
#[test]
fn a_wrap_with_no_known_range_reports_no_power_rather_than_terawatts() {
let reading = |energy_uj| EnergyReading {
domain: PowerDomain::Core,
name: "core".into(),
socket: 0,
energy_uj,
max_energy_range_uj: None,
power_limit_uw: None,
enabled: true,
};
let prev = vec![reading(90_000_000)];
let curr = vec![reading(5_000_000)];
let snap = RaplMonitor::compute_power(&prev, &curr, Duration::from_secs(1));
assert!(
snap.domain_watts.is_empty(),
"no delta is recoverable, so the domain must be absent: {:?}",
snap.domain_watts
);
assert_eq!(
snap.total_core_watts, None,
"no core domain produced a delta, so there is no core total"
);
}
#[test]
fn test_efficiency_analysis() {
let monitor = RaplMonitor {
readings: Vec::new(),
prev_readings: Vec::new(),
prev_time: None,
snapshot: Some(PowerSnapshot {
domain_watts: HashMap::new(),
total_package_watts: Some(85.0),
total_core_watts: Some(60.0),
total_dram_watts: Some(8.0),
measurement_duration_secs: 1.0,
energy_delta_uj: HashMap::new(),
}),
peak_watts: 135.0,
avg_watts: 78.0,
sample_count: 100,
};
let eff = monitor
.efficiency(125.0)
.expect("a package total was measured");
assert!(!eff.within_tdp || eff.headroom_watts >= 0.0);
assert!(eff.avg_package_watts > 0.0);
assert!(eff.peak_package_watts > 100.0);
}
#[test]
fn no_measured_package_power_means_no_efficiency_analysis() {
let monitor = RaplMonitor {
readings: Vec::new(),
prev_readings: Vec::new(),
prev_time: None,
snapshot: None,
peak_watts: 0.0,
avg_watts: 0.0,
sample_count: 0,
};
assert!(monitor.efficiency(125.0).is_none());
}
#[test]
fn test_power_domain_display() {
assert_eq!(PowerDomain::Package.to_string(), "Package");
assert_eq!(PowerDomain::Core.to_string(), "Core");
assert_eq!(PowerDomain::Dram.to_string(), "DRAM");
}
#[test]
fn test_monitor_default() {
let monitor = RaplMonitor::default();
let _readings = monitor.readings();
}
#[test]
fn test_serialization() {
let reading = EnergyReading {
domain: PowerDomain::Package,
name: "package-0".into(),
socket: 0,
energy_uj: 12345678,
max_energy_range_uj: Some(u64::MAX),
power_limit_uw: Some(125_000_000),
enabled: true,
};
let json = serde_json::to_string(&reading).unwrap();
assert!(json.contains("package-0"));
let _: EnergyReading = serde_json::from_str(&json).unwrap();
}
}