Merge pull request #48 from swiftraccoon/fix/m5-voltage-states-crash

Fix crash on Apple M5 Max due to renumbered voltage-states keys

Author: vladkens

src/app.rs

@@ -366,10 +366,10 @@ impl App {
 
   fn render(&mut self, f: &mut Frame) {
     let label_l = format!(
-      "{} ({}E+{}P+{}GPU {}GB)",
+      "{} ({}{}+{}{}+{}GPU {}GB)",
       self.soc.chip_name,
-      self.soc.ecpu_cores,
-      self.soc.pcpu_cores,
+      self.soc.ecpu_cores, self.soc.ecpu_label,
+      self.soc.pcpu_cores, self.soc.pcpu_label,
       self.soc.gpu_cores,
       self.soc.memory_gb,
     );
@@ -391,8 +391,10 @@ impl App {
 
     // 1st row
     let (c1, c2) = h_stack(iarea[0]);
-    self.render_freq_block(f, c1, "E-CPU", &self.ecpu_freq);
-    self.render_freq_block(f, c2, "P-CPU", &self.pcpu_freq);
+    let ecpu_block_label = format!("{}-CPU", self.soc.ecpu_label);
+    let pcpu_block_label = format!("{}-CPU", self.soc.pcpu_label);
+    self.render_freq_block(f, c1, &ecpu_block_label, &self.ecpu_freq);
+    self.render_freq_block(f, c2, &pcpu_block_label, &self.pcpu_freq);
 
     // 2nd row
     let (c1, c2) = h_stack(iarea[1]);

src/debug.rs

@@ -44,7 +44,10 @@ pub fn print_debug() -> WithError<()> {
           continue;
         }
 
-        let (volts, freqs) = get_dvfs_mhz(item, &key);
+        let Some((volts, freqs)) = get_dvfs_mhz(item, &key) else {
+          println!("{:>32}: (not found)", key);
+          continue;
+        };
         let volts = volts.iter().map(|x| x.to_string()).collect::<Vec<String>>().join(" ");
         let freqs = freqs.iter().map(|x| x.to_string()).collect::<Vec<String>>().join(" ");
         println!("{:>32}: (v) {}", key, volts);

src/metrics.rs

@@ -111,8 +111,8 @@ fn init_smc() -> WithError<(SMC, Vec<String>, Vec<String>)> {
     // Basically in the code that can be found publicly "Tp" is used for CPU and "Tg" for GPU.
 
     match name {
-      // "Tp" – performance cores, "Te" – efficiency cores
-      name if name.starts_with("Tp") || name.starts_with("Te") => cpu_sensors.push(name.clone()),
+      // "Tp" – performance cores, "Te" – efficiency cores, "Ts" – super cores (M5+)
+      name if name.starts_with("Tp") || name.starts_with("Te") || name.starts_with("Ts") => cpu_sensors.push(name.clone()),
       name if name.starts_with("Tg") => gpu_sensors.push(name.clone()),
       _ => (),
     }
@@ -235,13 +235,14 @@ impl Sampler {
 
       for x in sample {
         if x.group == "CPU Stats" && x.subgroup == CPU_FREQ_CORE_SUBG {
-          if x.channel.contains("ECPU") {
-            ecpu_usages.push(calc_freq(x.item, &self.soc.ecpu_freqs));
+          if x.channel.starts_with("PCPU") {
+            pcpu_usages.push(calc_freq(x.item, &self.soc.pcpu_freqs));
             continue;
           }
 
-          if x.channel.contains("PCPU") {
-            pcpu_usages.push(calc_freq(x.item, &self.soc.pcpu_freqs));
+          // ECPU on M1-M4, MCPU on M5+ (Performance cores)
+          if x.channel.starts_with("ECPU") || x.channel.starts_with("MCPU") {
+            ecpu_usages.push(calc_freq(x.item, &self.soc.ecpu_freqs));
             continue;
           }
         }
@@ -267,6 +268,8 @@ impl Sampler {
         }
       }
 
+      // Filter dead/disabled cores (e.g. M5 Max MCPU0 cluster is all-DOWN)
+      ecpu_usages.retain(|&(_, pct)| pct > 0.0);
       rs.ecpu_usage = calc_freq_final(&ecpu_usages, &self.soc.ecpu_freqs);
       rs.pcpu_usage = calc_freq_final(&pcpu_usages, &self.soc.pcpu_freqs);
       results.push(rs);

src/sources.rs

@@ -376,6 +376,8 @@ pub struct SocInfo {
   pub memory_gb: u8,
   pub ecpu_cores: u8,
   pub pcpu_cores: u8,
+  pub ecpu_label: String, // "E" on M1-M4, "P" on M5+
+  pub pcpu_label: String, // "P" on M1-M4, "S" on M5+
   pub ecpu_freqs: Vec<u32>,
   pub pcpu_freqs: Vec<u32>,
   pub gpu_cores: u8,
@@ -389,9 +391,9 @@ impl SocInfo {
 }
 
 // dynamic voltage and frequency scaling
-pub fn get_dvfs_mhz(dict: CFDictionaryRef, key: &str) -> (Vec<u32>, Vec<u32>) {
+pub fn get_dvfs_mhz(dict: CFDictionaryRef, key: &str) -> Option<(Vec<u32>, Vec<u32>)> {
   unsafe {
-    let obj = cfdict_get_val(dict, key).unwrap() as CFDataRef;
+    let obj = cfdict_get_val(dict, key)? as CFDataRef;
     let obj_len = CFDataGetLength(obj);
     let obj_val = vec![0u8; obj_len as usize];
     CFDataGetBytes(obj, CFRange::init(0, obj_len), obj_val.as_ptr() as *mut u8);
@@ -404,10 +406,40 @@ pub fn get_dvfs_mhz(dict: CFDictionaryRef, key: &str) -> (Vec<u32>, Vec<u32>) {
       freqs[i] = u32::from_le_bytes([x[0], x[1], x[2], x[3]]);
     }
 
-    (volts, freqs)
+    Some((volts, freqs))
   }
 }
 
+// Parse acc-clusters bytes into (ecpu_key, pcpu_key) voltage-states key names.
+// Each 8-byte entry: byte 0 = voltage-states index, byte 1 = cluster type
+// (0 = efficiency/lowest tier, higher = higher perf tier).
+// Picks highest type as pcpu, second-highest as ecpu — handles M5 Max where
+// type 0 (E-core cluster) is absent and the two active tiers are 1 and 2.
+fn parse_acc_clusters(data: &[u8]) -> Option<(String, String)> {
+  let mut clusters: Vec<(u8, String)> = Vec::new();
+  for chunk in data.chunks_exact(8) {
+    clusters.push((chunk[1], format!("voltage-states{}-sram", chunk[0])));
+  }
+  clusters.sort_by_key(|c| c.0);
+  if clusters.len() < 2 { return None; }
+  let ecpu_key = clusters[clusters.len() - 2].1.clone();
+  let pcpu_key = clusters.last()?.1.clone();
+  Some((ecpu_key, pcpu_key))
+}
+
+// Read acc-clusters from pmgr dict and parse into (ecpu_key, pcpu_key).
+fn parse_acc_clusters_from(dict: CFDictionaryRef) -> Option<(String, String)> {
+  let obj = cfdict_get_val(dict, "acc-clusters")? as CFDataRef;
+
+  let len = unsafe { CFDataGetLength(obj) } as usize;
+  if len < 8 { return None; }
+
+  let mut data = vec![0u8; len];
+  unsafe { CFDataGetBytes(obj, CFRange::init(0, len as _), data.as_mut_ptr()) };
+
+  parse_acc_clusters(&data)
+}
+
 pub fn run_system_profiler() -> WithError<serde_json::Value> {
   // system_profiler -listDataTypes
   let out = std::process::Command::new("system_profiler")
@@ -423,6 +455,29 @@ fn to_mhz(vals: Vec<u32>, scale: u32) -> Vec<u32> {
   vals.iter().map(|x| *x / scale).collect()
 }
 
+// Parse "proc T:P:E" (macOS 15) or "proc T:P_or_S:E:M" (macOS 26+) into (ecpu, pcpu, has_mcpu).
+// macOS 26 always uses 4 fields regardless of chip; the 4th field (M-cores) is >0 only on M5+.
+fn parse_cpu_cores(s: &str) -> (u64, u64, bool) {
+  let fields: Vec<u64> = s
+    .strip_prefix("proc ")
+    .unwrap_or("")
+    .split(':')
+    .map(|x| x.parse().unwrap_or(0))
+    .collect();
+
+  match fields.len() {
+    4 => {
+      // macOS 26+: "proc total:P_or_S:E:M"
+      // M5+:   E=0, M>0 → ecpu=M (Performance cores), pcpu=S (Super cores)
+      // M1-M4: M=0, E>0 → ecpu=E (Efficiency cores), pcpu=P (Performance cores)
+      let (e, m) = (fields[2], fields[3]);
+      if m > 0 { (m, fields[1], true) } else { (e, fields[1], false) }
+    }
+    3 => (fields[2], fields[1], false), // macOS 15: "proc total:P:E"
+    _ => (0, 0, false),
+  }
+}
+
 pub fn get_soc_info() -> WithError<SocInfo> {
   let out = run_system_profiler()?;
   let mut info = SocInfo::default();
@@ -443,19 +498,10 @@ pub fn get_soc_info() -> WithError<SocInfo> {
     .parse::<u64>()
     .unwrap_or(0);
 
-  // SPHardwareDataType.0.number_processors -> "proc x:y:z"
-  let cpu_cores = out["SPHardwareDataType"][0]["number_processors"]
-    .as_str()
-    .and_then(|cores| cores.strip_prefix("proc "))
-    .unwrap_or("")
-    .split(':')
-    .map(|x| x.parse::<u64>().unwrap_or(0))
-    .collect::<Vec<_>>();
-  let (ecpu_cores, pcpu_cores) = if cpu_cores.len() == 3 {
-    (cpu_cores[2], cpu_cores[1])
-  } else {
-    (0, 0) // Fallback in case of invalid data
-  };
+  // SPHardwareDataType.0.number_processors -> "proc x:y:z" or "proc x:y:z:w"
+  let number_processors =
+    out["SPHardwareDataType"][0]["number_processors"].as_str().unwrap_or("");
+  let (ecpu_cores, pcpu_cores, has_mcpu) = parse_cpu_cores(number_processors);
 
   // SPDisplaysDataType.0.sppci_cores
   let gpu_cores =
@@ -473,6 +519,8 @@ pub fn get_soc_info() -> WithError<SocInfo> {
   info.gpu_cores = gpu_cores as u8;
   info.ecpu_cores = ecpu_cores as u8;
   info.pcpu_cores = pcpu_cores as u8;
+  info.ecpu_label = if has_mcpu { "P".into() } else { "E".into() };
+  info.pcpu_label = if has_mcpu { "S".into() } else { "P".into() };
 
   // CPU frequencies
   for (entry, name) in IOServiceIterator::new("AppleARMIODevice")? {
@@ -481,9 +529,24 @@ pub fn get_soc_info() -> WithError<SocInfo> {
       // 1) `strings /usr/bin/powermetrics | grep voltage-states` uses non-sram keys
       //    but their values are zero, so sram used here; it looks valid.
       // 2) sudo powermetrics --samplers cpu_power -i 1000 -n 1 | grep "active residency" | grep "Cluster"
-      info.ecpu_freqs = to_mhz(get_dvfs_mhz(item, "voltage-states1-sram").1, cpu_scale);
-      info.pcpu_freqs = to_mhz(get_dvfs_mhz(item, "voltage-states5-sram").1, cpu_scale);
-      info.gpu_freqs = to_mhz(get_dvfs_mhz(item, "voltage-states9").1, gpu_scale);
+      // Try legacy keys first (M1-M4), fall back to acc-clusters discovery (M5+)
+      if let Some((_, freqs)) = get_dvfs_mhz(item, "voltage-states1-sram") {
+        info.ecpu_freqs = to_mhz(freqs, cpu_scale);
+      } else if let Some((ecpu_key, _)) = parse_acc_clusters_from(item) {
+        if let Some((_, freqs)) = get_dvfs_mhz(item, &ecpu_key) {
+          info.ecpu_freqs = to_mhz(freqs, cpu_scale);
+        }
+      }
+      if let Some((_, freqs)) = get_dvfs_mhz(item, "voltage-states5-sram") {
+        info.pcpu_freqs = to_mhz(freqs, cpu_scale);
+      } else if let Some((_, pcpu_key)) = parse_acc_clusters_from(item) {
+        if let Some((_, freqs)) = get_dvfs_mhz(item, &pcpu_key) {
+          info.pcpu_freqs = to_mhz(freqs, cpu_scale);
+        }
+      }
+      if let Some((_, freqs)) = get_dvfs_mhz(item, "voltage-states9") {
+        info.gpu_freqs = to_mhz(freqs, gpu_scale);
+      }
       unsafe { CFRelease(item as _) }
     }
   }
@@ -915,3 +978,65 @@ impl Drop for SMC {
     }
   }
 }
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn parse_acc_clusters_m5_max() {
+    // Real acc-clusters bytes captured from M5 Max via ioreg
+    let data = [
+      0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x17, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x05, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    ];
+    let (e, p) = parse_acc_clusters(&data).unwrap();
+    // Second-highest type (1 = Performance) as ecpu, highest (2 = Super) as pcpu
+    assert_eq!(e, "voltage-states23-sram");
+    assert_eq!(p, "voltage-states5-sram");
+  }
+
+  #[test]
+  fn parse_acc_clusters_incomplete() {
+    assert!(parse_acc_clusters(&[]).is_none());
+    // Single cluster – need both ecpu and pcpu
+    assert!(parse_acc_clusters(&[1, 0, 0, 0, 0, 0, 0, 0]).is_none());
+  }
+
+  #[test]
+  fn parse_cpu_cores_macos26_4field() {
+    // Real data captured from macOS 26 machines
+    // M5 Max: 18 total, 6 super, 0 efficiency, 12 performance(M-cores)
+    assert_eq!(parse_cpu_cores("proc 18:6:0:12"), (12, 6, true));
+    // M4 Max: 16 total, 12 performance, 4 efficiency, 0 M-cores
+    assert_eq!(parse_cpu_cores("proc 16:12:4:0"), (4, 12, false));
+    // M3 Air: 8 total, 4 performance, 4 efficiency, 0 M-cores
+    assert_eq!(parse_cpu_cores("proc 8:4:4:0"), (4, 4, false));
+  }
+
+  #[test]
+  fn parse_cpu_cores_macos15_3field() {
+    // Real data: M3 Air on macOS 15.6.1
+    assert_eq!(parse_cpu_cores("proc 8:4:4"), (4, 4, false));
+  }
+
+  #[test]
+  fn parse_cpu_cores_invalid() {
+    assert_eq!(parse_cpu_cores(""), (0, 0, false));
+    assert_eq!(parse_cpu_cores("garbage"), (0, 0, false));
+    assert_eq!(parse_cpu_cores("10:8:2"), (0, 0, false)); // missing "proc " prefix
+    assert_eq!(parse_cpu_cores("proc 8"), (0, 0, false)); // too few fields
+    assert_eq!(parse_cpu_cores("proc 8:4"), (0, 0, false)); // 2 fields, unsupported
+    assert_eq!(parse_cpu_cores("proc 24:6:0:12:6"), (0, 0, false)); // unknown future format
+  }
+
+  #[test]
+  fn to_mhz_scales() {
+    // M4+: KHz scale
+    assert_eq!(to_mhz(vec![4608000, 3000000], 1000), vec![4608, 3000]);
+    // M1-M3: MHz scale
+    assert_eq!(to_mhz(vec![3_000_000_000, 2_000_000_000], 1000 * 1000), vec![3000, 2000]);
+    assert_eq!(to_mhz(vec![], 1000), Vec::<u32>::new());
+  }
+}