feat(gpu): add full 1/6/12/24h stats for temp, power, PCIe and unified-memory support

Codex · claude · Codex · commit 41626bb051bb · 2026-03-06T16:13:20.000+08:00
- What: Add PCIe TX/RX history (RingBuffer + TimeWindowAggregator) to
  GpuHistory, recording per-tick throughput when available.
- What: Expand GPU Detail stats to 2 lines per time window showing:
  util avg/max, temp avg/max, mem avg/max, power avg/max with cumulative
  energy (kWh), and PCIe TX/RX avg/max (discrete GPUs only).
- What: Handle unified-memory GPUs (DGX Spark GB10, GH200) where NVML
  reports utilization_memory=0% and mem_clock=N/A. Uses known-specs
  lookup table for theoretical bandwidth and shows "no HW counter"
  instead of misleading 0 GB/s.
- What: Add memory_type_label() for unified-memory type identification
  (LPDDR5X/LPDDR5/LPDDR4x).
- What: Update README with expanded GPU monitoring metrics.
- Why: Provide complete historical analysis of GPU thermal/power/PCIe
  behavior and honest bandwidth reporting on unified-memory architectures.

Tests: cargo fmt, clippy, test all pass.

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/README.md b/README.md
@@ -37,9 +37,9 @@ See [Installation](#installation) for more options.
 |----------|---------|
 | **Utilization** | GPU %, Memory controller %, per-process SM utilization |
 | **Memory** | VRAM used/total/free, BAR1 usage, per-process GPU memory |
-| **Bandwidth** | Memory bandwidth utilization (actual/theoretical GB/s), PCIe TX/RX throughput |
-| **Thermal** | Temperature (with slowdown/shutdown thresholds), fan speed |
-| **Power** | Draw/limit (watts), usage %, total energy consumption (kWh) |
+| **Bandwidth** | Memory bandwidth utilization (actual/theoretical GB/s), unified-memory auto-detection (LPDDR5X), PCIe TX/RX throughput with 1/6/12/24h avg/max stats |
+| **Thermal** | Temperature (with slowdown/shutdown thresholds), fan speed, 1/6/12/24h avg/max |
+| **Power** | Draw/limit (watts), usage %, total energy consumption (kWh), 1/6/12/24h avg/max/cumulative energy |
 | **Clock** | Graphics, SM, Memory, Video frequencies (current/max MHz) |
 | **State** | Performance state (P0–P15), throttle reasons, compute mode, persistence mode |
 | **Health** | ECC errors (corrected/uncorrected), retired pages (SBE/DBE) |
@@ -59,7 +59,7 @@ See [Installation](#installation) for more options.
 ### Time-Series Analytics
 
 - **Line charts** for GPU utilization, memory, temperature, and power with Braille markers
-- **1/6/12/24h statistics** — average and max for CPU, Memory, GPU; avg R/W for Disk; cumulative ↓/↑ for Network
+- **1/6/12/24h statistics** — avg/max for CPU, Memory, GPU utilization, temperature, power (with cumulative kWh), memory, PCIe TX/RX; avg R/W for Disk; cumulative ↓/↑ for Network
 - **Progressive display** — stats windows only appear after enough data has been collected
 - **Minute-resolution aggregation** — memory-efficient 24h storage (~28KB per metric)
 
diff --git a/src/domain/gpu.rs b/src/domain/gpu.rs
@@ -72,20 +72,83 @@ impl GpuStats {
     }
 
     /// Theoretical peak memory bandwidth in GB/s.
-    /// Formula: mem_clock_mhz * bus_width_bits * 2 (DDR) / 8 / 1000
+    ///
+    /// For discrete GPUs: `mem_clock_mhz * bus_width_bits * 2 (DDR) / 8 / 1000`.
+    /// For unified-memory GPUs (GH200, GB10, etc.): uses known specs lookup
+    /// since NVML does not report mem clock or bus width on these architectures.
     pub fn theoretical_mem_bandwidth_gbps(&self) -> Option<f64> {
-        let bus_width = self.memory_bus_width_bits? as f64;
-        if self.clock_memory_mhz <= 0.0 || bus_width <= 0.0 {
-            return None;
+        // Try standard formula first (discrete GPUs)
+        if let Some(bus_width) = self.memory_bus_width_bits {
+            let bw = bus_width as f64;
+            if self.clock_memory_mhz > 0.0 && bw > 0.0 {
+                return Some(self.clock_memory_mhz * bw * 2.0 / 8.0 / 1000.0);
+            }
+        }
+
+        // Unified-memory fallback: lookup by GPU name
+        if self.memory_is_shared {
+            return self.unified_memory_bandwidth_gbps();
         }
-        Some(self.clock_memory_mhz * bus_width * 2.0 / 8.0 / 1000.0)
+
+        None
     }
 
     /// Estimated actual memory bandwidth in GB/s based on utilization.
+    /// Returns None on unified-memory GPUs where NVML always reports 0%.
     pub fn actual_mem_bandwidth_gbps(&self) -> Option<f64> {
         let theoretical = self.theoretical_mem_bandwidth_gbps()?;
+        // On unified memory, NVML reports utilization_memory = 0 always.
+        // Return None so the UI knows the value is not meaningful.
+        if self.memory_is_shared && self.utilization_memory <= 0.0 {
+            return None;
+        }
         Some(theoretical * self.utilization_memory / 100.0)
     }
+
+    /// Known memory bandwidth for unified-memory GPU models.
+    /// These GPUs use LPDDR5X shared with the CPU; NVML cannot report
+    /// mem clock or bus width, so we use published specs.
+    fn unified_memory_bandwidth_gbps(&self) -> Option<f64> {
+        let lower = self.name.to_ascii_lowercase();
+        // DGX Spark / Jetson Thor — GB10 (Blackwell) with LPDDR5X
+        if lower.contains("gb10") {
+            return Some(273.0); // 128-bit LPDDR5X-8533
+        }
+        // GH200 Grace Hopper — LPDDR5X
+        if lower.contains("gh200") || lower.contains("grace hopper") {
+            return Some(546.0); // 512 GB LPDDR5X
+        }
+        // GH100 in Grace Hopper Superchip
+        if lower.contains("gh100") {
+            return Some(546.0);
+        }
+        // Jetson AGX Orin — LPDDR5
+        if lower.contains("orin") {
+            return Some(204.8); // 256-bit LPDDR5
+        }
+        // Jetson AGX Xavier — LPDDR4x
+        if lower.contains("xavier") && !lower.contains("nx") {
+            return Some(136.5);
+        }
+        None
+    }
+
+    /// Descriptive string for the memory type.
+    pub fn memory_type_label(&self) -> &'static str {
+        if !self.memory_is_shared {
+            return "GDDR/HBM";
+        }
+        let lower = self.name.to_ascii_lowercase();
+        if lower.contains("gb10") || lower.contains("gh200") || lower.contains("gh100") {
+            "LPDDR5X (Unified)"
+        } else if lower.contains("orin") {
+            "LPDDR5 (Unified)"
+        } else if lower.contains("xavier") {
+            "LPDDR4x (Unified)"
+        } else {
+            "Unified Memory"
+        }
+    }
 }
 
 /// Per-GPU history buffers for chart/sparkline rendering and long-term aggregation.
@@ -95,10 +158,14 @@ pub struct GpuHistory {
     pub temperature: RingBuffer,
     pub power: RingBuffer,
     pub memory_usage: RingBuffer,
+    pub pcie_tx: RingBuffer,
+    pub pcie_rx: RingBuffer,
     pub utilization_agg: TimeWindowAggregator,
     pub temperature_agg: TimeWindowAggregator,
     pub power_agg: TimeWindowAggregator,
     pub memory_agg: TimeWindowAggregator,
+    pub pcie_tx_agg: TimeWindowAggregator,
+    pub pcie_rx_agg: TimeWindowAggregator,
 }
 
 impl GpuHistory {
@@ -108,10 +175,14 @@ impl GpuHistory {
             temperature: RingBuffer::new(capacity),
             power: RingBuffer::new(capacity),
             memory_usage: RingBuffer::new(capacity),
+            pcie_tx: RingBuffer::new(capacity),
+            pcie_rx: RingBuffer::new(capacity),
             utilization_agg: TimeWindowAggregator::new(),
             temperature_agg: TimeWindowAggregator::new(),
             power_agg: TimeWindowAggregator::new(),
             memory_agg: TimeWindowAggregator::new(),
+            pcie_tx_agg: TimeWindowAggregator::new(),
+            pcie_rx_agg: TimeWindowAggregator::new(),
         }
     }
 
@@ -130,6 +201,17 @@ impl GpuHistory {
         self.temperature_agg.push(temp);
         self.power_agg.push(power);
         self.memory_agg.push(mem);
+
+        if let Some(tx) = stats.pcie_tx_bytes_per_sec {
+            let tx_f = tx as f64;
+            self.pcie_tx.push(tx_f);
+            self.pcie_tx_agg.push(tx_f);
+        }
+        if let Some(rx) = stats.pcie_rx_bytes_per_sec {
+            let rx_f = rx as f64;
+            self.pcie_rx.push(rx_f);
+            self.pcie_rx_agg.push(rx_f);
+        }
     }
 }
 
diff --git a/src/ui/views/gpu_detail.rs b/src/ui/views/gpu_detail.rs
@@ -105,22 +105,40 @@ fn render_metrics_column(
         theme,
     ));
 
+    // Memory type (show for unified memory)
+    if gpu.memory_is_shared {
+        lines.push(metric_line(
+            "Type",
+            gpu.memory_type_label(),
+            theme.text_dim,
+            theme,
+        ));
+    }
+
     // Memory bandwidth
-    lines.push(metric_line(
-        "MemBW",
-        &format!(
-            "{:.0}% util{}",
-            gpu.utilization_memory,
-            gpu.actual_mem_bandwidth_gbps()
-                .map(|bw| format!(
-                    " ~{bw:.0}/{:.0} GB/s",
-                    gpu.theoretical_mem_bandwidth_gbps().unwrap_or(0.0)
-                ))
-                .unwrap_or_default()
-        ),
-        theme.percent_color(gpu.utilization_memory),
-        theme,
-    ));
+    let bw_str = match (
+        gpu.actual_mem_bandwidth_gbps(),
+        gpu.theoretical_mem_bandwidth_gbps(),
+    ) {
+        (Some(actual), Some(peak)) => {
+            // Discrete GPU: NVML reports real utilization
+            format!(
+                "{:.0}% util ~{actual:.0}/{peak:.0} GB/s",
+                gpu.utilization_memory
+            )
+        }
+        (None, Some(peak)) if gpu.memory_is_shared => {
+            // Unified memory: NVML cannot measure real-time bandwidth
+            format!("peak {peak:.0} GB/s (no HW counter)")
+        }
+        _ => format!("{:.0}% util", gpu.utilization_memory),
+    };
+    let bw_color = if gpu.memory_is_shared && gpu.utilization_memory <= 0.0 {
+        theme.text_dim
+    } else {
+        theme.percent_color(gpu.utilization_memory)
+    };
+    lines.push(metric_line("MemBW", &bw_str, bw_color, theme));
 
     if let (Some(used), Some(total)) = (gpu.bar1_used_bytes, gpu.bar1_total_bytes) {
         let bar1_pct = if total > 0 {
@@ -407,19 +425,24 @@ fn render_charts_column(
         None => return,
     };
 
+    // Stats: 2 lines per active window (max 4 windows = 8 lines)
+    let elapsed = history.utilization_agg.elapsed_hours();
+    let num_windows = [1, 6, 12, 24]
+        .iter()
+        .filter(|&&h| elapsed >= h as f64)
+        .count() as u16;
+    let stats_h = num_windows * 2;
+
     // Decide how many charts fit: each needs label(1) + chart(min 2) = 3
     let available = area.height;
-    let stats_h: u16 = 2; // stats at bottom
     let chart_budget = available.saturating_sub(stats_h);
     // 4 charts: util, mem, temp, power. Each gets label(1) + Fill
     let num_charts = (chart_budget / 3).min(4) as usize;
 
     if num_charts == 0 {
         // Just show stats
-        if available >= stats_h {
-            let lines = build_gpu_stats_lines(history, theme);
-            frame.render_widget(Paragraph::new(lines), area);
-        }
+        let lines = build_gpu_stats_lines(history, theme);
+        frame.render_widget(Paragraph::new(lines), area);
         return;
     }
 
@@ -569,44 +592,82 @@ fn build_gpu_stats_lines<'a>(history: &GpuHistory, theme: &Theme) -> Vec<Line<'a
         return vec![];
     }
 
-    windows
-        .iter()
-        .map(|&h| {
-            let label = format!("{h:>2}h");
-            let u_avg = history.utilization_agg.average_over_hours(h);
-            let u_max = history.utilization_agg.max_over_hours(h);
-            let t_avg = history.temperature_agg.average_over_hours(h);
-            let t_max = history.temperature_agg.max_over_hours(h);
-            let p_avg = history.power_agg.average_over_hours(h);
-            let m_avg = history.memory_agg.average_over_hours(h);
-
-            Line::from(vec![
-                Span::styled(format!(" {label}"), Style::default().fg(theme.text_muted)),
-                Span::styled("  util ", Style::default().fg(theme.text_dim)),
-                Span::styled(
-                    format!("{u_avg:.0}%"),
-                    Style::default().fg(theme.percent_color(u_avg)),
-                ),
-                Span::styled(format!("/{u_max:.0}%"), Style::default().fg(theme.text_dim)),
-                Span::styled("  temp ", Style::default().fg(theme.text_dim)),
-                Span::styled(
-                    format!("{t_avg:.0}°"),
-                    Style::default().fg(theme.temp_color(t_avg)),
-                ),
-                Span::styled(
-                    format!("/{t_max:.0}°"),
-                    Style::default().fg(theme.temp_color(t_max)),
-                ),
-                Span::styled("  pwr ", Style::default().fg(theme.text_dim)),
-                Span::styled(format!("{p_avg:.0}W"), Style::default().fg(theme.text)),
-                Span::styled("  mem ", Style::default().fg(theme.text_dim)),
-                Span::styled(
-                    format!("{m_avg:.0}%"),
-                    Style::default().fg(theme.percent_color(m_avg)),
+    let has_pcie = !history.pcie_tx.is_empty();
+    let mut lines = Vec::new();
+
+    for &h in &windows {
+        let label = format!("{h:>2}h");
+        let u_avg = history.utilization_agg.average_over_hours(h);
+        let u_max = history.utilization_agg.max_over_hours(h);
+        let t_avg = history.temperature_agg.average_over_hours(h);
+        let t_max = history.temperature_agg.max_over_hours(h);
+        let p_avg = history.power_agg.average_over_hours(h);
+        let p_max = history.power_agg.max_over_hours(h);
+        // Energy: avg_watts * hours = Wh → kWh
+        let energy_kwh = p_avg * h as f64 / 1000.0;
+        let m_avg = history.memory_agg.average_over_hours(h);
+        let m_max = history.memory_agg.max_over_hours(h);
+
+        // Line 1: util + temp + mem
+        lines.push(Line::from(vec![
+            Span::styled(format!(" {label}"), Style::default().fg(theme.text_muted)),
+            Span::styled("  util ", Style::default().fg(theme.text_dim)),
+            Span::styled(
+                format!("{u_avg:.0}/{u_max:.0}%"),
+                Style::default().fg(theme.percent_color(u_avg)),
+            ),
+            Span::styled("  temp ", Style::default().fg(theme.text_dim)),
+            Span::styled(
+                format!("{t_avg:.0}°"),
+                Style::default().fg(theme.temp_color(t_avg)),
+            ),
+            Span::styled(
+                format!("/{t_max:.0}°"),
+                Style::default().fg(theme.temp_color(t_max)),
+            ),
+            Span::styled("  mem ", Style::default().fg(theme.text_dim)),
+            Span::styled(
+                format!("{m_avg:.0}/{m_max:.0}%"),
+                Style::default().fg(theme.percent_color(m_avg)),
+            ),
+        ]));
+
+        // Line 2: power avg/max + energy + PCIe
+        let mut pwr_spans = vec![
+            Span::styled("    ", Style::default()),
+            Span::styled("pwr ", Style::default().fg(theme.text_dim)),
+            Span::styled(
+                format!("{p_avg:.0}/{p_max:.0}W",),
+                Style::default().fg(theme.text),
+            ),
+            Span::styled(
+                format!(" ({energy_kwh:.3}kWh)"),
+                Style::default().fg(theme.text_muted),
+            ),
+        ];
+
+        if has_pcie {
+            let tx_avg = history.pcie_tx_agg.average_over_hours(h);
+            let rx_avg = history.pcie_rx_agg.average_over_hours(h);
+            let tx_max = history.pcie_tx_agg.max_over_hours(h);
+            let rx_max = history.pcie_rx_agg.max_over_hours(h);
+            pwr_spans.push(Span::styled("  PCIe ", Style::default().fg(theme.text_dim)));
+            pwr_spans.push(Span::styled(
+                format!(
+                    "TX:{}/{} RX:{}/{}",
+                    format_rate(tx_avg),
+                    format_rate(tx_max),
+                    format_rate(rx_avg),
+                    format_rate(rx_max),
                 ),
-            ])
-        })
-        .collect()
+                Style::default().fg(theme.text_dim),
+            ));
+        }
+
+        lines.push(Line::from(pwr_spans));
+    }
+
+    lines
 }
 
 fn format_rate(bytes_per_sec: f64) -> String {
