mig-gpu-mon

Screen Layout

ASCII 구성도

┌─ mig-gpu-mon ────────────────────────────────── 2026年03月17日 02:15:30 PM ┐
│ pathcosmos@gmail.com │ ← Header
├─ CPU (64 cores) 23.4% ─────────┬─ Devices ────────────────────────────┤
│ 17 ▮▮▮▮▮▮▮ 92% 5 ▮▮▮▯▯ 34% │ > MIG 0 (GPU 0: A100) GPU:45% Mem:... │ ↑ 20%
│ 2 ▮▮▮▮▮▯▯ 65% 40 ▮▮▯▯▯ 18% │ MIG 1 (GPU 0: A100) GPU:12% Mem:... │ ↓
│ 0 ▮▮▮▮▯▯▯ 52% 33 ▮▯▯▯▯ 5% ├─ Detail ─────────────────────────────┤ ← Top 45%
│ 12 ▮▮▮▯▯▯▯ 38% 8 ▯▯▯▯▯ 2% │ Name: MIG 0 (GPU 0: A100-SXM4-80GB) │ ↑
│ ... │ UUID: MIG-a1b2... Arch:Ampere CC:8.0│ │
│ │ VRAM 12288 MB / 20480 MB (60.0%) │ │
│ │ GPU: 45% Mem: 38% SM: 45% │ │ 50%
│ │ Enc: 0% Dec: 0% │ │
│ │ Clk: 1410/1410/1215 MHz P0 │ │
│ │ Temp: 62°C (↓90 ✕92) Power:127/300W│ │
│ │ PCIe: Gen4 x16 TX:12.3 RX:56.7 MB/s│ │
│ │ ECC: On Corr:0 Uncorr:0 │ │
│ │ Throttle: None Processes: 2 │ ↓
│ ├─ Top Processes ──────────────────────┤
│ │ PID Process VRAM │ ↑
│ │ 12345 python3 8192 MB │ │ 30%
│ │ 12400 pt_main_thread 4096 MB │ ↓
├─ GPU Util 45% ──────────────────┬─ CPU Total 23.4% ───────────────────┤
│ ▁▂▃▅▇█▇▅▃▂▁▂▃▅▇█▇▅ │ ▂▂▃▃▂▂▃▂▃▃▂▂▃▃▂▃ │ ← 40%
├─ Mem Ctrl 38% ──────────────────┤RAM ▮▮▮▮▮▮▯▯▯▯▯▯▯▯▯▯▯▯▯ │ ← RAM/SWP 바 (텍스트 없음)
│ ▃▃▃▄▄▅▅▅▄▃▃▃▄▄▅▅▄ │SWP ▮▯▯▯▯▯▯▯▯▯▯▯▯▯▯▯▯▯▯ │ ← Bottom 55%
├─ VRAM 12288/20480 MB (60.0%) ──│ ▮ used ▮ cached ▮ free RAM ... │ ← Memory 범례 (2줄)
│ ▅▅▅▅▆▆▆▆▆▆▇▇▇▇▇▇▇ │ 70.1G/12.5G/6.6G avl:77.5G │
├─ PCIe TX:12.3 RX:56.7 MB/s ────├─ RAM ─────────────────────────────┤
│ ▂▃▃▅▅▆▅▃▂▂▃▅▆▆▅▃ │ ▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅ ← used+cached 색상│ (PCIe 있을 때)
├────────────────────────────────────────────────────────────────────────┤
│ q Quit Tab/↑↓ Switch GPU [1/3] │ ← Footer
└────────────────────────────────────────────────────────────────────────┘

레이아웃 계층 구조

draw()
├── Header Length(3)
├── Main Min(10)
│ ├── [Top 45%] ─── Horizontal ──────────────────────────
│ │ ├── System Panel 50%
│ │ │ └── CPU Cores (전체 영역) " CPU ({N} cores) {pct}% "
│ │ │ └── dynamic N-column bars "{idx} ▮▮▯▯ {pct}%" (사용량 높은 순 정렬)
│ │ └── GPU Panel 50%
│ │ ├── Device List 20% " Devices "
│ │ │ └── "{>} {MIG|GPU} {idx}: {name} | GPU:{pct}% Mem:{pct}%"
│ │ ├── GPU Detail 50% " Detail "
│ │ │ ├── Name: {name} [Parent: GPU {n}] (MIG일 때)
│ │ │ ├── UUID: {uuid} Arch:{arch} CC:{major.minor}
│ │ │ ├── VRAM {used} MB / {total} MB ({pct}%)
│ │ │ ├── GPU: {pct}% Mem: {pct}% SM: {pct}% (가로 압축)
│ │ │ ├── Enc: {pct}% Dec: {pct}%
│ │ │ ├── Clk: {gfx}/{sm}/{mem} MHz {PState}
│ │ │ ├── Temp: {val}°C (↓{slowdown} ✕{shutdown}) Power: {u}/{l}W
│ │ │ ├── PCIe: Gen{n} x{w} TX:{mb} RX:{mb} MB/s
│ │ │ ├── ECC: On/Off Corr:{n} Uncorr:{n}
│ │ │ ├── Throttle: None / {reasons}
│ │ │ └── Processes: {count}
│ │ └── Top Processes 30% " Top Processes "
│ │ ├── Header: PID / Process / VRAM
│ │ └── {pid} {name (max 15)} {vram} MB (top 5 by VRAM desc)
│ └── [Bottom 55%] ─── Horizontal ────────────────────────
│ ├── GPU Charts 50%
│ │ ├── GPU Util {pct}% sparkline 25% (PCIe 있을 때) / 33%
│ │ ├── Mem Ctrl {pct}% sparkline 25% / 33%
│ │ ├── VRAM {u}/{t} MB ({p}%) sparkline 25% / 34%
│ │ └── PCIe TX/RX MB/s sparkline 25% (PCIe 데이터 있을 때만)
│ └── System Charts 50%
│ ├── CPU Total {pct}% sparkline 40%
│ ├── RAM/SWP Bars Length(2) 바만 표시 (텍스트 수치 없음)
│ │ ├── RAM line "RAM ▮▮▮▮▯▯" (segmented: used/cached/free)
│ │ └── SWP line "SWP ▮▮▯▯"
│ ├── Memory Legend Length(2) 2줄 범례 (RAM 차트 바로 위)
│ │ ├── Line 1: "▮ used ▮ cached ▮ free RAM {u}/{t} GiB ({p}%)"
│ │ └── Line 2: "{used}G/{cached}G/{free}G avl:{avail}G"
│ └── RAM segmented chart Min(3)
│ └── 세그먼트 bar chart: used(Green/Yellow/Red) + cached(Blue), 매 tick 수직 막대
└── Footer Length(3)

색상 코딩

Why

Features

MIG 환경 메트릭 가용성

Requirements

NVML 라이브러리 탐색 경로

환경별 실행 가이드

WSL2 설정 가이드

mig-gpu-mon --nvml-path /custom/path/libnvidia-ml.so.1

Quick Start (처음부터 끝까지)

# git이 없으면 먼저 설치 (Ubuntu: sudo apt install git / Rocky: sudo dnf install git)
git clone https://github.com/pathcosmos/mig-gpu-mon.git
cd mig-gpu-mon
./install.sh

mig-gpu-mon

수동 설치 (단계별)

# 0. 빌드 의존성 (Ubuntu)
sudo apt install -y curl git build-essential
# 0. 빌드 의존성 (Rocky/RHEL)
# sudo dnf install -y curl git gcc
# 1. Rust 설치 (이미 설치되어 있으면 생략)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
source "$HOME/.cargo/env"
# 2. 소스 다운로드
git clone https://github.com/pathcosmos/mig-gpu-mon.git
cd mig-gpu-mon
# 3. 빌드 + 시스템 등록 (한 줄)
cargo install --path .
# 4. 실행
mig-gpu-mon

원라인 설치 (복사-붙여넣기용)

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && source "$HOME/.cargo/env" && git clone https://github.com/pathcosmos/mig-gpu-mon.git /tmp/mig-gpu-mon && cargo install --path /tmp/mig-gpu-mon && mig-gpu-mon --help

다른 서버에 바이너리만 복사 (Rust 없이)

# 빌드 서버에서
scp target/release/mig-gpu-mon user@target-server:/usr/local/bin/
# 대상 서버에서 (Rust 설치 불필요)
mig-gpu-mon

제거

cargo uninstall mig-gpu-mon # cargo install로 설치한 경우
# 또는
rm ~/.cargo/bin/mig-gpu-mon # install.sh로 설치한 경우
rm /usr/local/bin/mig-gpu-mon # 수동 복사한 경우

Build & Install (상세)

# 릴리즈 빌드 (최적화 + LTO + strip)
cargo build --release
# 바이너리 위치
ls -lh target/release/mig-gpu-mon # ~1.5MB
# 시스템 경로에 설치
cp target/release/mig-gpu-mon /usr/local/bin/
# 또는 직접 실행
./target/release/mig-gpu-mon

Usage

# 기본 실행 (1초 간격)
mig-gpu-mon
# 폴링 간격 조정 (밀리초)
mig-gpu-mon --interval 2000 # 2초 간격 (리소스 절약)
mig-gpu-mon -i 500 # 0.5초 간격 (빠른 반응)
# NVML 라이브러리 경로 수동 지정 (자동 탐지 실패 시)
mig-gpu-mon --nvml-path /usr/local/nvidia/lib64/libnvidia-ml.so.1
# 디버그 모드 (NVML API 호출 로깅)
mig-gpu-mon --debug # /tmp/mig-gpu-mon-debug.log에 기록
# 도움말
mig-gpu-mon --help

키보드 조작

Tech Stack

Architecture

src/
 main.rs 진입점, 메인 루프 (collect → draw → event poll)
 app.rs 앱 상태 (메트릭, 히스토리, 선택 GPU)
 event.rs 키보드 / tick 이벤트 핸들링
 gpu/
 mod.rs 모듈 선언
 nvml.rs NVML 래퍼 + MIG raw FFI + 디바이스 캐시
 metrics.rs GPU/시스템 메트릭 구조체 + VecDeque 링 버퍼 히스토리
 ui/
 mod.rs 모듈 선언
 dashboard.rs 전체 TUI 레이아웃 및 위젯 렌더링

메인 루프 흐름

loop {
 tick_start = Instant::now()
 1. GPU 메트릭 수집 (NVML API)
 - 물리 GPU: utilization_rates(), memory_info(), temperature(), ...
 - MIG 인스턴스: utilization_rates() 실패 시
 → nvmlDeviceGetProcessUtilization() 폴백으로 SM/Mem util 집계
 2. 시스템 메트릭 수집 (sysinfo)
 - CPU 코어별 usage, 총 RAM/Swap
 3. TUI 렌더링 (ratatui)
 4. CPU 버퍼 재활용 (이전 SystemMetrics에서 회수 → zero-alloc)
 5. 이벤트 대기 (crossterm poll, interval - elapsed 만큼 블로킹)
 - 드리프트 보정: 작업 시간을 빼고 남은 시간만 poll
 - 키 입력 처리 또는 tick → 다음 루프
}

MIG Utilization 수집 메커니즘

4단계 폴백 아키텍처

nvmlDeviceGetMigDeviceHandleByIndex(parent, idx)
 → mig_handle
1단계: nvmlDeviceGetUtilizationRates(mig_handle)
 → 성공: gpu_util, memory_util 직접 사용
 → 실패 (NVML_ERROR_NOT_SUPPORTED): 2단계로 진행
2단계: nvmlDeviceGetProcessUtilization(mig_handle, samples, &count, 0)
 → 1차 호출: count=0 → NVML_ERROR_INSUFFICIENT_SIZE, count에 필요 크기 반환
 → 2차 호출: 버퍼 전달 → 프로세스별 smUtil, memUtil 수집
 → max(smUtil), max(memUtil) 집계하여 인스턴스 레벨 값 산출
 → 모든 샘플이 0이거나 fetch 실패 시: 3단계로 진행
3단계: nvmlDeviceGetSamples(parent_handle, GPU_UTILIZATION_SAMPLES) — gpu_util 전용
 → 부모 GPU에서 raw GPU utilization 샘플 수집 (20ms 간격)
 → 최근 5개 샘플 평균, /10000으로 0-100% 스케일 변환
 → MIG 슬라이스 비율로 스케일링: mig_util = parent_util ×ばつ total_slices / mig_slices
 → 예: parent=29%, MIG 3g.40gb → 29% ×ばつ 7/3 ≈ 67%
 → 불가능 시: "N/A" 표시
4단계: nvmlDeviceGetSamples(parent_handle, MEMORY_UTILIZATION_SAMPLES) — memory_util 전용
 → 부모 GPU에서 memory controller utilization 샘플 수집
 → 3단계와 동일한 /10000 스케일링 + MIG 슬라이스 비율 환산
 → Ampere/Hopper 모든 아키텍처에서 Mem Ctrl 표시 가능
 → 또는 parent utilization_rates().memory 스케일링 (samples 미지원 드라이버 대응)
 → 모두 실패 시: "N/A" 표시

드라이버 535.x MIG 제한사항 (심층 조사)

NVML API 테스트 결과 (드라이버 535.129.03)

디바이스별 메트릭 가용성

Raw 샘플 값 해석

MIG 슬라이스 비율 스케일링

메모리 컨트롤러 Utilization — 전수 조사 결과

시도한 API 목록 및 결과

GPU Util과의 핵심 차이

GPM (GPU Performance Monitoring) — Hopper+ 전용 솔루션

VRAM + Mem Ctrl 동시 표시 버그 분석 및 수정 (v0.3)

증상

근본 원인 분석 — 3가지 연쇄 버그

collect_device_metrics() 호출 순서 (수정 전):
 line 543: get_device_info(mig_device)
 → nvmlGpmQueryDeviceSupport(mig_handle) ← NVML 상태 오염!
 line 546: memory_info() ← 오염된 상태에서 VRAM 쿼리 → 실패

Tick N: VRAM 쿼리(성공) → GPM fallback(nvmlGpmMigSampleGet) → NVML 상태 오염
Tick N+1: VRAM 쿼리(실패 — 이전 tick GPM 오염 잔존) → GPM fallback → 또 오염
Tick N+2: VRAM 쿼리(실패) → ...

// 수정 전: unwrap_or((0, 0)) — 실패 시 0/0으로 조용히 사라짐
let (memory_used, memory_total) = device.memory_info()
 .map(|m| (m.used, m.total))
 .unwrap_or((0, 0)); // ← VRAM 0/0 MB (0.0%) — 사용자는 "비활성화"로 인식

타임라인 재현

Tick 1 (첫 tick):
 ├── get_device_info(mig) → nvmlGpmQueryDeviceSupport(mig_handle) [첫 호출, 캐시 미스]
 │ → NVML 상태 오염 가능 (but 캐시되어 이후 호출 없음)
 ├── memory_info() → 성공 또는 실패 (오염 정도에 따라)
 ├── utilization_rates() → NVML_ERROR_NOT_SUPPORTED (MIG 제한)
 ├── process_util fallback → sm/mem util 수집
 └── GPM fallback → nvmlGpmMigSampleGet(parent, gi_id) → 첫 tick이라 prev_sample 없음 → None
 → 그러나 GPM 호출 자체가 NVML 상태 오염
Tick 2 (이후 tick):
 ├── get_device_info(mig) → 캐시 히트 (GPM 쿼리 안 함)
 ├── memory_info() → 실패! (Tick 1 GPM 호출의 잔존 오염)
 │ → unwrap_or((0, 0)) → VRAM 0/0 MB ← 사용자가 보는 "비활성화"
 ├── ... (나머지 동일)
 └── GPM fallback → nvmlGpmMigSampleGet → prev_sample 있음 → memory_util 값 반환!
 → 그러나 또 NVML 상태 오염 → Tick 3 VRAM도 실패
결과: VRAM은 Tick 1에서만 표시, Tick 2+에서 0/0 MB
 Mem Ctrl은 Tick 2+에서 값 표시 (또는 Ampere에서 항상 N/A)

수정 내용 (3건)

// 수정 전: 모든 디바이스에 대해 GPM 쿼리 실행
fn get_device_info(&self, device: &Device) -> DeviceInfo {
 gpm_supported: nvmlGpmQueryDeviceSupport(device.handle(), ...) // MIG 핸들 → 오염!
}
// 수정 후: skip_gpm_query 파라미터 추가
fn get_device_info(&self, device: &Device, skip_gpm_query: bool) -> DeviceInfo {
 gpm_supported: if skip_gpm_query { false } else { nvmlGpmQueryDeviceSupport(...) }
}
// MIG 핸들: get_device_info(mig_device, true) → GPM 쿼리 스킵
// Parent: get_device_info(parent_device, false) → GPM 쿼리 정상 실행

// 수정 전: MIG 인스턴스별 VRAM + GPM 인터리브
for mig in mig_instances {
 metrics = collect_device_metrics(mig) // VRAM 쿼리
 gpm_fallback(mig) // GPM 호출 → 다음 MIG의 VRAM 쿼리 오염
}
// 수정 후: 2-phase 분리
// Phase 1: 모든 MIG VRAM 수집 (GPM 호출 없음)
for mig in mig_instances {
 metrics = collect_device_metrics(mig) // VRAM + utilization + process util
 phase1.push(metrics)
}
// Phase 2: GPM fallback (모든 VRAM 이미 수집 완료)
for metrics in &mut phase1 {
 gpm_fallback(metrics) // GPM 호출 → 오염되어도 VRAM에 영향 없음
}

// 수정 전: u64 — 실패 시 (0, 0)으로 은닉
pub memory_used: u64,
pub memory_total: u64,
// → "VRAM 0/0 MB (0.0%)" — 사용자에게 혼란
// 수정 후: Option<u64> — 실패 시 "N/A" 명시
pub memory_used: Option<u64>,
pub memory_total: Option<u64>,
// → "VRAM N/A" — gpu_util, memory_util과 동일한 패턴

수정 파일 목록

상호 검증 매트릭스

VRAM 정체(Stagnation) 버그 분석 및 수정 (v0.3.1)

증상

근본 원인 분석 — 2가지 연쇄 버그

Tick N: Phase 1(VRAM 성공) → Phase 2(GPM 호출 → NVML 상태 오염)
Tick N+1: Phase 1(memory_info() 실패 — 이전 tick GPM 오염 잔존) → memory_used = None
Tick N+2: Phase 1(또 실패) → ...

// 수정 전: None이면 push 자체를 건너뜀
if let Some(val) = metrics.memory_used_mb() {
 Self::push_ring(&mut self.memory_used_mb, val, self.max_entries);
}
// → memory_info() 실패 시 ring buffer 업데이트 중단 → sparkline 고정

수정 내용 (2건)

// 수정 전: 그대로 저장
pub fn update_metrics(&mut self, new_metrics: Vec<GpuMetrics>) { ... }
// 수정 후: memory_used가 None이면 이전 tick의 동일 UUID에서 마지막 값 계승
pub fn update_metrics(&mut self, mut new_metrics: Vec<GpuMetrics>) {
 for m in &mut new_metrics {
 if m.memory_used.is_none() {
 if let Some(prev) = self.metrics.iter().find(|p| p.uuid == m.uuid) {
 m.memory_used = prev.memory_used;
 m.memory_total = prev.memory_total;
 }
 }
 }
 // ... 기존 로직
}

// 수정 전: None이면 push 건너뜀
if let Some(val) = metrics.gpu_util {
 Self::push_ring(&mut self.gpu_util, val, self.max_entries);
}
// 수정 후: None이면 마지막 값 반복 push → sparkline 계속 롤링
fn push_or_repeat<T: Copy>(buf: &mut VecDeque<T>, val: Option<T>, max: usize) {
 let v = match val {
 Some(v) => v,
 None => match buf.back() {
 Some(&last) => last,
 None => return, // 한 번도 관측 안 된 메트릭은 데이터 조작 방지
 },
 };
 Self::push_ring(buf, v, max);
}

수정 파일 목록

상호 검증 매트릭스

v0.3 수정과의 관계

Top Processes 누락 버그 분석 및 수정 (v0.3.2)

증상

근본 원인 분석 — 3가지 문제

// 수정 전: VRAM 정보 없으면 프로세스 자체를 제외
let mut entries: Vec<(u32, u64)> = procs
 .iter()
 .filter_map(|p| {
 let vram = match p.used_gpu_memory {
 UsedGpuMemory::Used(bytes) => bytes,
 UsedGpuMemory::Unavailable => return None, // ← 프로세스 누락!
 };
 Some((p.pid, vram))
 })
 .collect();

// 수정 전: compute 프로세스만 수집
let (process_count, top_processes) = match device.running_compute_processes() { ... };
// → graphics 프로세스 (Vulkan/OpenGL 등)는 수집되지 않음

// 수정 전: 에러 → 빈 리스트, 원인 파악 불가
Err(_) => (0, Vec::new()),

수정 내용 (3건)

// 수정 전: u64 — Unavailable 프로세스 배제
pub vram_used: u64,
// 수정 후: Option<u64> — Unavailable은 None으로 보존
pub vram_used: Option<u64>,
pub fn vram_used_mb(&self) -> Option<u64> {
 self.vram_used.map(|v| v / (1024 * 1024))
}

// 수정 후: 양쪽 모두 수집, PID 기반 dedup
let mut seen_pids = HashSet::new();
let mut entries: Vec<(u32, Option<u64>)> = Vec::new();
// Compute processes (PyTorch, CUDA)
if let Ok(procs) = device.running_compute_processes() {
 for p in &procs { /* ... */ if seen_pids.insert(p.pid) { entries.push(...); } }
}
// Graphics processes (Vulkan, OpenGL)
if let Ok(procs) = device.running_graphics_processes() {
 for p in &procs { /* ... */ if seen_pids.insert(p.pid) { entries.push(...); } }
}

// 수정 후: VRAM 없으면 "N/A" 표시 (프로세스는 보존)
let vram_str = match proc.vram_used_mb() {
 Some(mb) => format!("{:>7} MB", mb),
 None => format!("{:>10}", "N/A"),
};

정렬 로직 개선

// Known VRAM 내림차순 → Unavailable은 뒤로 → PID 기준 안정 정렬
entries.sort_by(|a, b| match (b.1, a.1) {
 (Some(bv), Some(av)) => bv.cmp(&av),
 (Some(_), None) => Ordering::Less,
 (None, Some(_)) => Ordering::Greater,
 (None, None) => a.0.cmp(&b.0),
});
entries.truncate(5);

수정 파일 목록

상호 검증 매트릭스

MIG Top Processes 부모 디바이스 폴백 버그 분석 및 수정 (v0.3.3)

증상

근본 원인 분석

// collect_device_metrics() 내부 — MIG 핸들 전달
if let Ok(procs) = device.running_compute_processes() { // ← MIG 핸들에서 Err 반환
 for p in &procs { ... }
}
if let Ok(procs) = device.running_graphics_processes() { // ← MIG 핸들에서 Err 반환
 for p in &procs { ... }
}

수정 내용

// === Phase 3: MIG 프로세스 부모 디바이스 폴백 ===
// Phase 1에서 MIG 핸들로 수집 실패한 경우, 부모 GPU에서 프로세스 쿼리 후
// gpu_instance_id로 필터링하여 각 MIG 인스턴스에 분배
// 1. 부모 디바이스에서 compute + graphics 프로세스 1회 쿼리
let parent_procs = parent_device.running_compute_processes()
 + parent_device.running_graphics_processes(); // PID dedup
// 2. 각 MIG 인스턴스에 gpu_instance_id 매칭하여 분배
for (mig_handle, metrics) in &mut phase1 {
 if !metrics.top_processes.is_empty() { continue; } // 이미 수집 성공이면 skip
 let gi_id = get_device_info(mig_device).gpu_instance_id;
 metrics.top_processes = parent_procs
 .filter(|p| p.gpu_instance_id == gi_id)
 .sort_by_vram_desc()
 .truncate(5);
}

3-phase 수집 전체 흐름

collect_mig_instances():
 Phase 1: 각 MIG 인스턴스의 기본 메트릭 수집 (VRAM, util, 프로세스 시도)
 → MIG 핸들에서 프로세스 API 실패 시 top_processes = []
 Phase 2: GPM 폴백 (memory_util, Hopper+ only)
 → 모든 VRAM 이미 수집 완료 → GPM 오염 무관
 Phase 3: 프로세스 부모 디바이스 폴백 (NEW)
 → 부모 GPU에서 프로세스 쿼리 → gpu_instance_id로 MIG 인스턴스별 분배

수정 파일 목록

상호 검증 매트릭스

v0.3.2 → v0.3.3 방어 계층 관계

Top Processes 깜빡임 + 자원 감사 수정 (v0.3.4)

증상

근본 원인 분석 — 3가지 이슈

Tick 1: MIG 디바이스 running_compute_processes() 성공 → 프로세스 표시
Tick 2: 같은 API 실패 → top_processes 빈 배열 → Phase 3 시도
Phase 3: gpu_instance_id 없으면 전부 필터 → "No processes" 표시
Tick 3: API 다시 성공 → 프로세스 깜빡임

// 기존: gpu_instance_id가 None이면 모든 프로세스 필터됨
.filter(|(_, _, proc_gi)| *proc_gi == gi_id && gi_id.is_some())

// 기존: GPU 수가 동일하면 프루닝 안 됨 → MIG 재구성 시 orphan 누적
if self.history.len() > new_metrics.len() { ... }

수정 내역 (5개 변경)

// NVML 프로세스 API 간헐적 실패 시 이전 틱 프로세스 유지
if m.top_processes.is_empty() {
 if let Some(prev) = self.metrics.iter().find(|p| p.uuid == m.uuid) {
 if !prev.top_processes.is_empty() {
 m.top_processes = prev.top_processes.clone();
 m.process_count = prev.process_count;
 }
 }
}

// 부모 프로세스 중 아무도 gpu_instance_id가 없으면 전체 프로세스 표시
let any_gi_available = parent_procs.iter().any(|(_, _, gi)| gi.is_some());
let entries = if any_gi_available && gi_id.is_some() {
 // 정상 경로: gpu_instance_id 매칭 필터
 parent_procs.filter(|p| p.gpu_instance_id == gi_id)
} else {
 // 폴백: 전체 프로세스 표시 (아무것도 안 보이는 것보다 나음)
 parent_procs.all()
};

// 기존: len 비교만 → MIG 재구성 시 UUID 변경 감지 불가
// 수정: UUID 불일치 시 항상 프루닝 + shrink_to() 추가
if self.history.len() != new_metrics.len()
 || self.history.keys().any(|uuid| !new_metrics.iter().any(|m| m.uuid == *uuid))
{
 self.history.retain(...);
 // 방어적 capacity 축소
 if self.history.capacity() > target * 2 {
 self.history.shrink_to(target);
 }
}

// 기존: len.max(16) * 4 → 1000 PID 사라져도 capacity 유지
// 수정: target * 2 → 더 적극적 메모리 회수
let target = name_cache.len().max(16) * 2;
if name_cache.capacity() > target * 2 {
 name_cache.shrink_to(target);
}

// thread_local 캐시 — 초 단위 변경 시에만 재생성
thread_local! {
 static TIME_CACHE: RefCell<(i64, String)> = RefCell::new((0, String::new()));
}
// 같은 초 내 반복 호출 시 캐시 반환 → 틱당 String 할당 1회 절감

수정 파일

교차 검증 매트릭스

v0.3.3 → v0.3.4 방어 계층 관계

Sparkline 방향 버그 + 장기 운영 최적화 (v0.3.5)

증상

근본 원인 분석

data = [0, 1, 2, 3, 4, 5, 6, 7, 8]
RightToLeft → "xxx█▇▆▅▄▃▂▁ "
// data[8]←→data[0] (오른쪽 끝)

VecDeque: [T0(oldest), T1, T2, ..., T299(newest)]
Sparkline: data[0..80] = [T0, T1, ..., T79] ← 가장 오래된 80개만!
화면: T79 ← T78 ← ... ← T1 ← T0(오른쪽 끝)

// Before: truncation (99.7% → 99)
buf.extend(src.iter().map(|&v| v as u64));

수정 내용 (6개 변경)

// Before: oldest → newest 순서 (data[0]=oldest → 오른쪽 끝)
buf.extend(src.iter().map(|&v| v as u64));
// After: newest → oldest 순서 (data[0]=newest → 오른쪽 끝)
buf.extend(src.iter().rev().map(|&v| v as u64));

// Before: truncation
buf.extend(src.iter().rev().map(|&v| v as u64));
// After: rounding
buf.extend(src.iter().rev().map(|&v| v.round() as u64));

// Before: "PCIe TX:12.3 RX:56.7 MB/s" — 그래프가 TX+RX인 듯 오해
// After: "PCIe TX:12.3 / RX:56.7 MB/s" + 기본 타이틀 "PCIe TX"

// Before: 매 tick String::clone() (힙 복사)
pub name: String,
fn process_name(&self, pid: u32) -> String { cache.get(&pid).clone() }
// After: Rc<str> clone = 포인터 카운트 증가만 (힙 할당 0)
pub name: Rc<str>,
fn process_name(&self, pid: u32) -> Rc<str> { cache.get(&pid).clone() }

// Before: 매 tick String 할당 (빈번한 "None" 포함)
pub throttle_reasons: Option<String>,
fn format_throttle_reasons(tr) -> String { String::from("None") }
// After: 단일 플래그 fast path → Cow::Borrowed (제로 할당)
pub throttle_reasons: Option<Cow<'static, str>>,
fn format_throttle_reasons(tr) -> Cow<'static, str> {
 // "None", "Idle", "SwPwrCap", "HW-Slow", "SW-Therm", "HW-Therm" → Borrowed
 // 복합 플래그만 Cow::Owned 할당
}

수정 파일

교차 검증 매트릭스

v0.3.4 → v0.3.5 방어 계층 관계

VRAM 실시간 반영 실패 + 장기 운영 자원 최적화 (v0.3.6)

증상

근본 원인 분석 — 3가지 연쇄 버그

위치: app.rs update_metrics()

위치: app.rs update_metrics()

위치: metrics.rs push_or_repeat()

수정 내용 (6개 변경)

// 이전: 무조건 이전 tick 프로세스 복사 (무기한)
if m.top_processes.is_empty() {
 m.top_processes = prev.top_processes.clone();
}
// 이후: /proc/{pid} 존재 여부로 살아있는 프로세스만 carry-forward
let alive: Vec<_> = prev.top_processes.iter()
 .filter(|p| {
 buf.clear();
 write!(buf, "/proc/{}", p.pid);
 Path::new(buf.as_str()).exists()
 })
 .cloned().collect();

// 이전: memory_info() 실패 시 무조건 이전 값 복사 (무기한)
// 이후: 연속 3회까지만 carry-forward, 초과 시 None → "N/A"
const VRAM_CARRY_FORWARD_TTL: u32 = 3;
let count = if let Some(c) = self.vram_fail_count.get_mut(&m.uuid) {
 *c += 1; *c
} else {
 self.vram_fail_count.insert(m.uuid.clone(), 1); 1
};
if count <= VRAM_CARRY_FORWARD_TTL { /* carry forward */ }
// else: UI shows "N/A"

// 이전: 매 PID마다 format!("/proc/{}", pid) → String 힙 할당
// 이후: App 구조체에 proc_path_buf: String 재사용
buf.clear();
write!(buf, "/proc/{}", p.pid); // 기존 버퍼 재사용, 할당 0

// 이전: Vec<usize> → cache.retain(|k, _| active_handles.contains(k)) // O(n) per entry
// 이후: HashSet<usize> → contains() O(1)
active_handles: RefCell<HashSet<usize>>,

// 이전: self.history.keys().any(|uuid| !new_metrics.iter().any(...)) // O(n×ばつm)
// 이후: HashSet 사전 구축 → O(1) lookup
let uuid_set: HashSet<&Rc<str>> = new_metrics.iter().map(|m| &m.uuid).collect();
self.history.retain(|uuid, _| uuid_set.contains(uuid));

// 이전: self.vram_fail_count.entry(m.uuid.clone()).or_insert(0) // 매번 Rc clone
// 이후: get_mut/insert 패턴 → cache hit 시 clone 0
let count = if let Some(c) = self.vram_fail_count.get_mut(&m.uuid) {
 *c += 1; *c
} else {
 self.vram_fail_count.insert(m.uuid.clone(), 1); 1
};

수정 파일

교차 검증 매트릭스

v0.3.5 → v0.3.6 방어 계층 관계

VRAM N/A 전환 + 장기 운영 메모리 최적화 (v0.3.8)

증상

근본 원인 분석 — 2가지 문제

위치: nvml.rs collect_mig_instances() Phase 2

Tick 1: Phase 1 memory_info() 성공 → Phase 2 GPM 호출 → 드라이버 상태 오염
Tick 2: Phase 1 memory_info() 실패 (이전 tick 오염) → carry-forward 시작
Tick 4: VRAM_CARRY_FORWARD_TTL(3) 초과 → memory_used = None → "N/A" 고정

수정 내용 (8개 변경)

// 제거: Phase 2 GPM fallback 블록 전체
// nvmlGpmMigSampleGet() 호출 → NVML 상태 오염 원천 차단
// memory_util은 Fallback 1(process utilization)에서 수집 가능한 경우만 표시

// Before: 매 tick 새 Rc<str> 생성
metrics.name = format!("MIG {mig_idx} (GPU {gpu_index}: {})", metrics.name).into();
// After: DeviceInfo.mig_display_name 캐시, Rc::clone()만
let cached = device_cache.get(&key).and_then(|i| i.mig_display_name.clone());
metrics.name = cached.unwrap_or_else(|| { /* format + cache + return */ });

// Before: Vec::new() → push마다 realloc 가능
// After: Vec::with_capacity(max_count) → 1회 할당

// Before: 매 tick per-device HashSet::new()
// After: NvmlCollector.proc_seen_pids: RefCell<HashSet<u32>> 재사용
// + parent_procs/entries Vec::with_capacity(16)

// Before: TIME_CACHE에서 c.1.clone() + format!(" {} ", now) → 2 alloc/draw
// After: 렌더링을 TIME_CACHE.with 클로저 내부로 이동
// + write!(c.1, ...) 버퍼 재사용 + c.1.as_str() 참조 → 0 alloc/draw

// Before: make_bar(usage, bar_width) → 코어당 String 할당 (128코어 = 128 alloc)
// After: BAR_TABLE thread_local! 룩업 테이블
// bar_width+1개 패턴 사전 빌드, bt.1[filled].as_str() 참조
// 터미널 리사이즈 시에만 재빌드 → 0 alloc/draw (첫 draw 이후)

// clippy 권장: thread_local! 초기화자에 const 사용
static TIME_CACHE: ... = const { RefCell::new(...) };
static BAR_TABLE: ... = const { RefCell::new(...) };

// Before: Vec::new() → 첫 push 시 alloc
// After: Vec::with_capacity(16) → process count에 맞는 초기 할당

수정 파일

교차 검증 매트릭스

v0.3.6 → v0.3.8 방어 계층 관계

RAM 세그먼트 차트 시각적 갭 수정 (v0.3.9)

증상

근본 원인 분석

위치: dashboard.rs draw_ram_segmented_chart()

수정 전 (갭 발생):
│█│ ← cached (blue, full block)
│▃│ ← used (green, 3/8 block) — 위쪽 5/8이 빈 배경색
│█│ ← used (green, full block)
수정 후 (밀착):
│█│ ← cached (blue, full block)
│▃│ ← used (green fg, blue bg) — 아래 3/8 녹색, 위 5/8 파란색
│█│ ← used (green, full block)

수정 내용 (1개 변경)

// Before: fg만 설정, bg는 기본(검정)
} else if bottom_row == used_rows && used_frac > 0.05 {
 (bar_chars[(used_frac * 8.0) as usize % 8], used_color)
// After: fg=used_color, bg=Color::Blue (cached 존재 시)
} else if bottom_row == used_rows && used_frac > 0.05 {
 let bg = if has_cached { Color::Blue } else { Color::Reset };
 (bar_chars[(used_frac * 8.0) as usize % 8], used_color, bg)

수정 파일

교차 검증 매트릭스

v0.3.8 → v0.3.9 방어 계층 관계

MIG Mem Ctrl GPM 복원 + per-tick 중복 제거 (v0.3.10)

증상

근본 원인 분석

위치: nvml.rs collect_mig_instances()

수집 경로 분석 (v0.3.8~v0.3.9):
1. utilization_rates() → MIG에서 항상 NVML_ERROR_NOT_SUPPORTED
2. GPM fallback (collect_device_metrics) → !is_mig 조건으로 차단
3. GPM fallback (collect_mig_instances) → v0.3.8에서 삭제됨
4. process utilization → 프로세스 없거나 mem=0이면 None
→ 결과: memory_util 수집 경로 전무 → 항상 "N/A"

수정 내용 (4개 변경)

// Phase 1: 모든 MIG 인스턴스의 VRAM(memory_info()) 수집 완료
// Phase 1.5 (신규): GPM으로 memory_util 수집 — VRAM은 이미 안전
let parent_info = self.get_device_info(parent_device, false);
if parent_info.gpm_supported {
 for (mig_handle, gi_id, metrics) in &mut phase1 {
 if metrics.memory_util.is_some() { continue; }
 if let Some(gi_id) = gi_id {
 let gpm_val = self.get_dram_bw_util_gpm(
 *mig_handle, true, Some(*gi_id), Some(parent_handle),
 );
 if let Some(val) = gpm_val {
 metrics.memory_util = Some(val);
 }
 }
 }
}
// Phase 2: 프로세스 수집 (기존)

// Before: Phase 1, 1.5, 2에서 각각 Device::new() + get_device_info() = 3회/인스턴스
// phase1: Vec<(nvmlDevice_t, GpuMetrics)>
let mig_device = Device::new(*mig_handle, &self.nvml); // Phase 1.5
let mig_info = self.get_device_info(&mig_device, true); // Phase 1.5
let mig_device = Device::new(*mig_handle, &self.nvml); // Phase 2
let mig_info = self.get_device_info(&mig_device, true); // Phase 2
// After: Phase 1에서 gi_id 캐싱, 1.5/2에서 직접 사용 = 1회/인스턴스
// phase1: Vec<(nvmlDevice_t, Option<u32>, GpuMetrics)>
let mig_info = self.get_device_info(&mig_device, true); // Phase 1에서 1회
let gi_id = mig_info.gpu_instance_id; // 캐싱
// Phase 1.5/2에서 gi_id 직접 참조 — Device::new/get_device_info 불필요

// Before: Fallback 2에서 get_device_info(&mig_device, true) 재호출
if metrics.gpu_util.is_none() {
 let mig_info = self.get_device_info(&mig_device, true); // 중복!
 if let Some(mig_slices) = mig_info.gpu_instance_slice_count { ... }
}
// After: Phase 1 상단에서 이미 가져온 mig_info 재사용
if metrics.gpu_util.is_none() {
 if let Some(mig_slices) = mig_info.gpu_instance_slice_count { ... }
}

// Before: 조건 체크용 + retain용 = 2회 HashSet 생성
if self.history.len() != new_metrics.len()
 || {
 let uuid_set: HashSet<_> = new_metrics.iter().map(|m| &m.uuid).collect(); // 1회
 self.history.keys().any(|uuid| !uuid_set.contains(uuid))
 }
{
 let uuid_set: HashSet<_> = new_metrics.iter().map(|m| &m.uuid).collect(); // 2회 (동일)
 self.history.retain(|uuid, _| uuid_set.contains(uuid));
}
// After: 1회 생성 후 조건 체크 + retain 모두에 사용
let uuid_set: HashSet<_> = new_metrics.iter().map(|m| &m.uuid).collect(); // 1회만
if self.history.len() != uuid_set.len()
 || self.history.keys().any(|uuid| !uuid_set.contains(uuid))
{
 self.history.retain(|uuid, _| uuid_set.contains(uuid));
}

수정 파일

교차 검증 매트릭스

자원 누수 감사 결과

v0.3.9 → v0.3.10 방어 계층 관계

v0.3.11 — VRAM 추적 안정성 + GPM 자원 누수 수정 + 장기 운영 최적화

문제 현상

근본 원인 분석

수정 내용 (7개 변경)

// Before: GPM 후유증 3초 내 미복구 시 데이터 소실
const VRAM_CARRY_FORWARD_TTL: u32 = 3;
const SPARKLINE_CARRY_FORWARD_TTL: u32 = 3;
// After: GPM 상태 복구에 충분한 10초 여유
const VRAM_CARRY_FORWARD_TTL: u32 = 10;
const SPARKLINE_CARRY_FORWARD_TTL: u32 = 10;

// memory_total은 GPU당 사실상 정적값 — 별도 캐시로 무제한 복원
last_known_vram_total: HashMap<Rc<str>, u64>,
// 매 tick: 유효값 캐시, None 시 캐시에서 복원
if let Some(total) = m.memory_total {
 self.last_known_vram_total.insert(m.uuid.clone(), total);
} else if let Some(&cached) = self.last_known_vram_total.get(&m.uuid) {
 m.memory_total = Some(cached);
}

// Before: TTL 후 push 중단 → 스파크라인 동결 (정체처럼 보임)
// After: TTL 후 0 push → 스파크라인 계속 전진 (하강 = 데이터 소실 시각 표시)
fn push_with_ttl<T: Copy + Default>(...) {
 None => {
 if *none_count <= TTL { /* carry forward */ }
 else if !buf.is_empty() {
 Self::push_ring(buf, T::default(), max); // 0 push
 }
 }
}

// Before: `?` 연산자로 조기 리턴 시 allocated new_sample 누수
let parent = parent_handle?; // None이면 new_sample 미해제!
let gi_id = gpu_instance_id?; // 동일 누수
// After: match로 명시적 free 후 리턴
let (parent, gi_id) = match (parent_handle, gpu_instance_id) {
 (Some(p), Some(g)) => (p, g),
 _ => {
 self.raw_lib.nvmlGpmSampleFree(new_sample);
 return None;
 }
};

// Before: borrow() + iterate → prune_stale_caches에서 이미 free된 포인터 재 free
let prev_map = self.gpm_prev_samples.borrow();
for &sample in prev_map.values() { nvmlGpmSampleFree(sample); }
// After: get_mut() + drain() → 맵 비우면서 1회만 free
for (_, sample) in self.gpm_prev_samples.get_mut().drain() {
 if !sample.is_null() { nvmlGpmSampleFree(sample); }
}

// Before: 매 GPU마다 iter().find() 선형 탐색
if let Some(prev) = self.metrics.iter().find(|p| p.uuid == m.uuid) { ... }
// After: 사전 빌드 HashMap으로 O(1) 인덱스 조회
let prev_by_uuid: HashMap<&Rc<str>, usize> =
 self.metrics.iter().enumerate().map(|(i, m)| (&m.uuid, i)).collect();
if let Some(&idx) = prev_by_uuid.get(&m.uuid) {
 let prev = &self.metrics[idx]; ...
}

// Before: contains_key + insert + get_mut (3회 해시)
if !self.history.contains_key(&m.uuid) {
 self.history.insert(m.uuid.clone(), MetricsHistory::new(MAX_HISTORY));
}
self.history.get_mut(&m.uuid).unwrap().push(m);
// After: entry API (1회 해시)
self.history.entry(m.uuid.clone())
 .or_insert_with(|| MetricsHistory::new(MAX_HISTORY))
 .push(m);
// GPU 제거 시에만 HashSet 빌드 (history.len() > new_metrics.len())
if self.history.len() > new_metrics.len() { /* prune */ }

수정 파일

교차 검증 매트릭스

자원 누수 감사 결과

v0.3.10 → v0.3.11 방어 계층 관계

v0.3.12: GPM 오염 자동 감지 + VRAM 모니터링 안정성 확보

문제

수정 내용 (3개 변경)

수정 파일 목록

v0.3.13: GPM 오염 무한루프 차단 + 장기 운영 미세 최적화

문제

수정 내용 (3개 변경)

// 수정 전: probe_idx=None → GPM 실행 → 재오염 무한루프
let probe_idx = phase1.iter().position(|(_, _, m)| m.memory_used.is_some());
for (mig_handle, gi_id, metrics) in &mut phase1 { ... } // GPM 무조건 실행
if let Some(idx) = probe_idx { ... } // probe 없으면 스킵
// 수정 후: probe_idx=None → GPM 전체 스킵 → NVML 복구 기회 제공
if let Some(pidx) = probe_idx {
 for (mig_handle, gi_id, metrics) in &mut phase1 { ... } // GPM 실행
 // post-probe (pidx 보장)
 let (probe_handle, _, _) = &phase1[pidx];
 ...
}
// else: skip GPM → break corruption cycle

수정 파일 목록

검증 매트릭스

자원 누수 감사 결과

v0.3.10 → v0.3.13 방어 계층 관계

v0.3.14: MIG Mem Ctrl 근본 해결 + Startup GPM Probe + 렌더링 최적화

문제

수정 내용 (3개 변경)

수정 파일 목록

v0.3.15: Mem Ctrl 다중 폴백 + GPM 방어적 차단 강화

문제

nvmlDeviceGetSamples(type=1) 실패 → parent_sampled_mem_util = None
 → Phase 1 Mem Ctrl 폴백 스킵 → memory_util = None (Mem Ctrl N/A)
 → Phase 1.5 GPM 억제 실패 → GPM 실행 → NVML 오염
 → memory_info() 연쇄 실패 → 10 tick 후 VRAM N/A

근본 원인

수정 내용 (4개 변경)

let parent_util_rates_mem: Option<u32> =
 parent_device.utilization_rates().ok().map(|u| u.memory);

if metrics.memory_util.is_none() {
 if let Some(p_mem_util) = parent_sampled_mem_util {
 // (a) raw samples 스케일링 (기존)
 } else if let Some(p_rates_mem) = parent_util_rates_mem {
 // (b) utilization_rates().memory 스케일링 (NEW)
 }
}

let parent_mem_samples_ok = parent_sampled_mem_util.is_some();
if parent_info.gpm_supported && !gpm_disabled && parent_mem_samples_ok {

수정 파일 목록

검증 매트릭스

자원 누수 감사 결과 (전체 코드베이스)

v0.3.10 → v0.3.15 방어 계층 관계

v0.3.16: GPM 전면 제거 + --debug 진단 플래그

문제

수정 내용 (2개 변경)

수정 파일 목록

v0.3.10 → v0.3.16 방어 계층 관계

v0.3.17: RAM htop-style 정밀 분해 + 장기 운영 코드 감사

문제

수정 내용 (2개 변경)

수정 파일 목록

NVML API 지연시간 벤치마크

Performance Optimization

예상 리소스 소모량

tick당 시간 분해 (1초 interval 기준)

1 tick = 1000ms
├── NVML API 호출 ~7-18ms 드라이버 IPC (GPU당 15-19개 쿼리)
│ ├── device_by_index ~0.1ms
│ ├── utilization_rates ~0.5ms
│ ├── memory_info ~0.5ms
│ ├── temperature ~0.3ms
│ ├── power_usage ~0.3ms
│ ├── power_management_limit ~0.3ms
│ ├── clock_info (×ばつ3) ~0.5ms Graphics/SM/Memory
│ ├── pcie_throughput (×ばつ2) ~0.3ms TX/RX
│ ├── pcie_link_gen/width ~0.1ms
│ ├── performance_state ~0.1ms
│ ├── throttle_reasons ~0.1ms
│ ├── encoder/decoder_util ~0.2ms
│ ├── ecc_errors (×ばつ2) ~0.2ms Corrected/Uncorrected
│ ├── running_compute/graphics_procs ~0.5ms compute+graphics 통합 + top-5만 /proc 이름 읽기
│ └── (MIG) process_util ~1-3ms MIG 인스턴스당, 폴백 시에만
│ └── (MIG) gpu_util_samples ~0.8ms nvmlDeviceGetSamples 폴백, 부모 GPU만
├── sysinfo refresh ~0.1-0.3ms
│ ├── refresh_cpu_usage ~0.1ms /proc/stat 읽기
│ └── refresh_memory ~0.05ms /proc/meminfo 읽기
├── TUI 렌더링 ~0.5-2ms ratatui diff buffer + ANSI 출력
├── 이벤트 대기 (sleep) ~980-993ms crossterm poll, 커널 스케줄링
└── 합계 활성 시간 ~7-20ms = CPU 0.7-2.0%

RSS 메모리 분해

총 RSS ~4-8 MB
├── 바이너리 코드/데이터 세그먼트 ~1.4 MB (mmap)
├── libnvidia-ml.so 공유 라이브러리 ~2-4 MB (mmap, 시스템 공유)
├── 히스토리 링 버퍼 ~80 KB
│ ├── GPU당 MetricsHistory ~22 KB (9 VecDeque ×ばつ 300 ×ばつ 4-8B)
│ │ (×ばつ 3 디바이스 = ~42 KB)
│ └── SystemHistory ~7 KB (4 VecDeque ×ばつ 300 ×ばつ 4-8B, ram_used_pct/ram_cached_pct 포함)
├── ratatui Terminal 더블 버퍼 ~50-400 KB (터미널 크기에 비례)
│ (×ばつ24: ~77KB, ×ばつ50: ~400KB)
├── sysinfo System 구조체 ~30-50 KB (CPU만, 프로세스 제외)
├── 재사용 버퍼들 ~5 KB
│ ├── thread_local sparkline buf ~2.4 KB
│ ├── proc_sample_buf ~1 KB
│ ├── gpu_sample_buf ~2 KB
│ └── cpu_buf ~0.3 KB
└── HashMap, String 캐시 등 ~5-10 KB

interval 별 리소스 비교

최적화 상세: Memory

최적화 상세: CPU (시스템 호출 최소화)

최적화 상세: GPU (NVML 호출 최소화)

최적화 상세: Binary Size

Runtime Stability (장시간 운영 안전성)

메모리 안정성

장시간 메모리 사용량 예측

시작 직후: ~4 MB RSS
5분 후: ~5-8 MB RSS (히스토리 버퍼 300개 채워짐)
5분 이후: 변동 없음 (링 버퍼 → 정상 상태 유지)

런타임 안전성

--debug 로그 무한 성장 주의

Why Rust

License