用 tegrastats 绘制实时性能曲线 + Roofline Model 瓶颈定位实战

目标：将 tegrastats 的实时监控数据转化为可视化的性能曲线，并与 Roofline Model 理论天花板对比，精确定位当前推理任务的瓶颈是 计算受限、内存带宽受限，还是 功耗/温度降频受限。

---

📐 第一步：理解 tegrastats → Roofline 的映射关系

Roofline 需要两个核心指标：

Roofline 轴	tegrastats 对应字段	如何计算/获取
Y 轴：性能 (FLOPs/s)	无法直接读取	需要通过 模型已知算量 ÷ 推理耗时 计算
X 轴：运算强度 (FLOPs/Byte)	EMC_FREQ 占用率 + 理论带宽	通过 模型算量 ÷ EMC 搬运数据量 估算（或用 NVIDIA Nsight 精确测量）

简化方案（工程实用版）：

• 用 GPU 频率 + 占用率 作为性能的“相对指标”
• 用 EMC 占用率 作为内存带宽压力的“相对指标”
• 通过 温度 + 功耗 判断是否降频

---

🛠️ 第二步：数据采集脚本（实时记录 tegrastats）

脚本 capture_tegrastats.sh

#!/bin/bash
# 用法：./capture_tegrastats.sh > perf_log.csv
# 运行推理任务前启动，推理结束后 Ctrl+C 停止

echo "timestamp,ram_used,ram_total,swap_used,swap_total,emc_usage,emc_freq,gpu_usage,gpu_freq,cpu0_freq,cpu1_freq,cpu2_freq,cpu3_freq,cpu4_freq,cpu5_freq,tj_temp,power_total"

sudo tegrastats --interval 500 | while read line; do
    # 提取字段（使用 awk/sed 简化版，实际生产用 Python）
    timestamp=$(echo "$line" | awk '{print $1" "$2}')
    ram=$(echo "$line" | grep -oP 'RAM \K[0-9]+')
    ram_total=$(echo "$line" | grep -oP 'RAM [0-9]+/\K[0-9]+')
    swap=$(echo "$line" | grep -oP 'SWAP \K[0-9]+')
    swap_total=$(echo "$line" | grep -oP 'SWAP [0-9]+/\K[0-9]+')
    emc=$(echo "$line" | grep -oP 'EMC_FREQ \K[0-9]+%')
    emc_freq=$(echo "$line" | grep -oP 'EMC_FREQ [0-9]+%@\K[0-9]+')
    gpu=$(echo "$line" | grep -oP 'GR3D_FREQ \K[0-9]+%')
    gpu_freq=$(echo "$line" | grep -oP 'GR3D_FREQ [0-9]+%@\[\K[0-9]+')
    cpu_freqs=$(echo "$line" | grep -oP 'CPU \[[^\]]*' | grep -oP '[0-9]+MHz')
    tj=$(echo "$line" | grep -oP 'tj@\K[0-9.]+')
    power=$(echo "$line" | grep -oP 'VDD_IN \K[0-9]+')
    
    echo "$timestamp,$ram,$ram_total,$swap,$swap_total,$emc,$emc_freq,$gpu,$gpu_freq,$cpu_freqs,$tj,$power"
done

Python 采集器（推荐）

import subprocess
import time
import csv
import re

def parse_tegrastats(line):
    """解析 tegrastats 一行输出"""
    data = {}
    # RAM
    ram_match = re.search(r'RAM (\d+)/(\d+)MB', line)
    if ram_match:
        data['ram_used'] = int(ram_match.group(1))
        data['ram_total'] = int(ram_match.group(2))
    # EMC
    emc_match = re.search(r'EMC_FREQ (\d+)%@(\d+)', line)
    if emc_match:
        data['emc_usage'] = int(emc_match.group(1))
        data['emc_freq'] = int(emc_match.group(2))
    # GPU
    gpu_match = re.search(r'GR3D_FREQ (\d+)%@\[(\d+)\]', line)
    if gpu_match:
        data['gpu_usage'] = int(gpu_match.group(1))
        data['gpu_freq'] = int(gpu_match.group(2))
    # 温度
    tj_match = re.search(r'tj@([\d.]+)C', line)
    if tj_match:
        data['tj_temp'] = float(tj_match.group(1))
    # 功耗
    power_match = re.search(r'VDD_IN (\d+)mW', line)
    if power_match:
        data['power'] = int(power_match.group(1)) / 1000.0  # 转 W
    return data

# 采集 60 秒，间隔 500ms
with open('perf_data.csv', 'w', newline='') as f:
    writer = csv.DictWriter(f, fieldnames=['timestamp', 'ram_used', 'emc_usage', 'emc_freq', 
                                           'gpu_usage', 'gpu_freq', 'tj_temp', 'power'])
    writer.writeheader()
    
    proc = subprocess.Popen(['sudo', 'tegrastats', '--interval', '500'], stdout=subprocess.PIPE)
    start = time.time()
    while time.time() - start < 60:
        line = proc.stdout.readline().decode()
        if line:
            data = parse_tegrastats(line)
            data['timestamp'] = time.time() - start
            writer.writerow(data)
    proc.terminate()

---

📊 第三步：绘制实时性能曲线（Python + matplotlib）

核心可视化代码

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

df = pd.read_csv('perf_data.csv')

fig, axes = plt.subplots(3, 1, figsize=(12, 10), sharex=True)

# 图1：GPU + EMC 使用率（核心指标）
axes[0].plot(df['timestamp'], df['gpu_usage'], label='GPU Usage (%)', linewidth=2, color='blue')
axes[0].plot(df['timestamp'], df['emc_usage'], label='EMC Usage (%)', linewidth=2, color='red')
axes[0].axhline(y=95, color='gray', linestyle='--', alpha=0.5, label='Saturation Line')
axes[0].set_ylabel('Usage (%)')
axes[0].set_title('GPU vs EMC Utilization (Real-time)')
axes[0].legend()
axes[0].grid(True, alpha=0.3)

# 图2：频率变化（判断是否锁频/降频）
axes[1].plot(df['timestamp'], df['gpu_freq'], label='GPU Frequency (MHz)', linewidth=2, color='green')
axes[1].plot(df['timestamp'], df['emc_freq'], label='EMC Frequency (MHz)', linewidth=2, color='orange')
axes[1].set_ylabel('Frequency (MHz)')
axes[1].set_title('Frequency Stability (Check Lock)')
axes[1].legend()
axes[1].grid(True, alpha=0.3)

# 图3：温度 + 功耗（降频预警）
axes[2].plot(df['timestamp'], df['tj_temp'], label='TJ Temperature (°C)', linewidth=2, color='red')
axes[2].plot(df['timestamp'], df['power'], label='Power (W)', linewidth=2, color='purple')
axes[2].axhline(y=85, color='red', linestyle='--', alpha=0.5, label='Throttle Threshold')
axes[2].set_xlabel('Time (seconds)')
axes[2].set_ylabel('Temp (°C) / Power (W)')
axes[2].set_title('Thermal & Power Status')
axes[2].legend()
axes[2].grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('perf_curves.png', dpi=150)
plt.show()

---

🎯 第四步：Roofline Model 对照诊断（4 种典型模式）

🔵 模式 1：理想状态（计算受限）

GPU Usage: 95-100%
EMC Usage: 70-85%
GPU Freq: 918 MHz (锁定)
TJ Temp: 65-72°C
Power: 18-22W

诊断：✅ GPU 满载，EMC 未饱和，温度安全 → 计算受限
优化方向：使用 Tensor Core、Int8 量化、增加指令级并行

---

🔴 模式 2：内存带宽墙（最典型）

GPU Usage: 60-75%
EMC Usage: 95-100%
GPU Freq: 918 MHz (锁定)
TJ Temp: 58-65°C
Power: 15-18W

诊断：⚠️ GPU 没吃饱，但内存带宽已满 → 内存受限
对应 Roofline：程序落在斜线区域
优化方向：

• 使用共享内存（tiling）减少全局内存访问
• 合并访问（coalescing）
• 使用 __ldg() 只读缓存
• TensorRT 层融合减少中间张量读写

---

🟡 模式 3：功耗/温度降频

GPU Usage: 40-60% (但频率跌到 600MHz)
EMC Usage: 60-70%
TJ Temp: 88-92°C
Power: 25W (已拉满但性能下滑)

诊断：🔥 温度超 85°C，触发动态降频 → 热受限
优化方向：

• 加强散热（风扇/散热片）
• 降低 TDP 模式（如 15W 保持稳定）
• 优化算法减少持续峰值功耗

---

🟣 模式 4：CPU/IO 瓶颈（预处理卡顿）

GPU Usage: 20-40%（间歇性抖动）
EMC Usage: 30-50%
CPU: 8 核全满载 @ 2400MHz
TJ Temp: 60°C
Power: 12-15W

诊断：📦 GPU 在等 CPU 预处理数据 → CPU/数据搬运瓶颈
优化方向：

• 使用硬件加速器（NVJPEG/NVDEC）解码
• 异步数据搬运（cudaMemcpyAsync + 流水线）
• 增加 batch size 提高 GPU 利用率

---

🔬 第五步：精确 Roofline 定量分析（进阶）

计算实际性能（Y 轴）

# 已知模型算量（如 ResNet-50：约 7.7 GFLOPS）
model_flops = 7.7e9  # FP32
# 从日志获取推理耗时（假设平均 25ms）
inference_time = 0.025  # 秒
achieved_performance = model_flops / inference_time  # 308 GFLOPS
print(f"Achieved Performance: {achieved_performance/1e9:.2f} GFLOPS")

计算运算强度（X 轴）

# 通过 EMC 占用率估算实际带宽使用
peak_bandwidth = 102.4  # GB/s (Orin Nano 理论值)
emc_usage_avg = df['emc_usage'].mean() / 100
used_bandwidth = peak_bandwidth * emc_usage_avg

# 估算 AI = FLOPs / 实际搬运字节
# 或用 NVIDIA Nsight Compute 精确测量
measured_bytes = 2.5e9  # 从 Nsight 获取（示例）
ai = model_flops / measured_bytes  # 约 3.08 FLOPs/Byte

绘制 Roofline 对比图

# 硬件屋顶线（Orin Nano 理论值）
peak_flops = 40e9  # 40 GFLOPS FP32
peak_bandwidth = 102.4e9  # 102.4 GB/s

# 绘制屋顶线
x_vals = np.logspace(-1, 2, 100)
roof_compute = np.full_like(x_vals, peak_flops)
roof_bandwidth = peak_bandwidth * x_vals
roofline = np.minimum(roof_compute, roof_bandwidth)

plt.figure(figsize=(10, 6))
plt.loglog(x_vals, roofline, 'k--', linewidth=2, label='Roofline (Orin Nano)')
# 标记你的程序
plt.scatter([ai], [achieved_performance], color='red', s=200, 
            marker='x', label='My Kernel')
plt.xlabel('Arithmetic Intensity (FLOPs/Byte)')
plt.ylabel('Performance (FLOPs/s)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.title('Roofline Model: My Kernel vs Hardware Cap')
plt.savefig('roofline_analysis.png', dpi=150)

---

✅ 验收 Checklist

步骤	命令/操作	通过标准
采集数据	python3 capture.py 跑 60s	生成 perf_data.csv
绘制曲线	python3 plot.py	生成 perf_curves.png
GPU vs EMC 诊断	查看图 1	能判断哪条先饱和
频率稳定性	查看图 2	频率全程无跌落
温度安全	查看图 3	TJ < 85°C
Roofline 定位	运行定量分析	程序点在图上标注清晰

---

🚀 一键诊断脚本（终极版）

#!/bin/bash
# run_roofline_diagnosis.sh
echo "🔍 Starting Roofline Diagnosis on Jetson..."
echo ""

# 1. 锁频
sudo nvpmodel -m 0
sudo jetson_clocks
echo "✅ Frequency locked"

# 2. 运行你的推理任务（此处替换为你的命令）
echo "🚀 Running inference (3 iterations)..."
time python3 your_inference.py

# 3. 同时采集 tegrastats (后台)
sudo tegrastats --interval 500 > tegrastats.log &
PID=$!
sleep 60  # 采集 60 秒
sudo kill $PID

# 4. 自动分析
python3 analyze_perf.py --input tegrastats.log --output report.html
echo "📊 Report generated: report.html"

---

📖 总结：从数据到决策的口诀

看 GPU/EMC 谁先 100% → 确定是算力墙还是带宽墙
看频率是否恒定 → 确认锁频有效
看温度是否超 85°C → 确认散热是否足够
看 CPU/GPU 关系 → 确认预处理是否成为瓶颈

最终输出：一份性能曲线图 + Roofline 对比图 + 文字诊断报告（计算受限/内存受限/热受限/IO 受限）。