시스템 사용율 모니터링 기능 로그 수정

docker-compose-dev.yml

@@ -5,7 +5,13 @@ services:
       dockerfile: Dockerfile-dev
     image: kamco-cd-training-api:${IMAGE_TAG:-latest}
     container_name: kamco-cd-training-api
-    runtime: nvidia
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: all
+              capabilities: [gpu]
     ports:
       - "7200:8080"
     environment:

docker-compose-prod.yml

@@ -5,6 +5,13 @@ services:
       dockerfile: Dockerfile
     image: kamco-train-api:${IMAGE_TAG:-latest}
     container_name: kamco-train-api
+    deploy:
+      resources:
+        reservations:
+          devices:
+            - driver: nvidia
+              count: all
+              capabilities: [gpu]
     expose:
       - "8080"
     environment:

src/main/java/com/kamco/cd/training/common/dto/MonitorDto.java

@@ -1,21 +1,8 @@
 package com.kamco.cd.training.common.dto;
 
-import java.util.ArrayList;
-import java.util.List;
-
 public class MonitorDto {
 
-  public int cpu; // 30초 평균 (%)
+  public int cpu; // CPU 사용률 (%)
-  public String memory; // "3.2/16GB"
+  public long[] memory; // "사용/전체"
-  public List<Gpu> gpus = new ArrayList<>();
+  public int gpu; // 🔥 전체 GPU 평균 (%)
-
-  public static class Gpu {
-    public int index;
-    public int util;
-
-    public Gpu(int index, int util) {
-      this.index = index;
-      this.util = util;
-    }
-  }
 }

src/main/java/com/kamco/cd/training/common/service/GpuDmonReader.java

@@ -14,20 +14,15 @@ public class GpuDmonReader {
 
   // =========================
   // GPU 사용률 저장소
-  // - key: GPU index (0,1,2...)
+  // key: GPU index (0,1,2...)
-  // - value: 현재 GPU 사용률 (%)
+  // value: 현재 GPU 사용률 (%)
-  // - ConcurrentHashMap → 멀티스레드 안전
+  // ConcurrentHashMap → 멀티스레드 안전
   // =========================
   private final Map<Integer, Integer> gpuUtilMap = new ConcurrentHashMap<>();
 
   // =========================
-  // nvidia-smi dmon 프로세스
+  // 외부 조회용
-  // - 스트리밍으로 GPU 상태를 계속 받아옴
+  // SystemMonitorService에서 호출
-  // =========================
-  private volatile Process process;
-
-  // =========================
-  // 외부에서 GPU 사용률 조회
   // =========================
   public Map<Integer, Integer> getGpuUtilMap() {
     return gpuUtilMap;
@@ -35,123 +30,97 @@ public class GpuDmonReader {
 
   // =========================
   // Bean 초기화 시 실행
-  // - 별도 스레드에서 dmon 실행
+  // - 별도 스레드에서 GPU 모니터링 시작
   // - 메인 스레드 block 방지
   // =========================
   @PostConstruct
   public void start() {
 
+    // nvidia-smi 없는 환경이면 GPU 모니터링 비활성화
     if (!isNvidiaAvailable()) {
       log.warn("nvidia-smi not found. GPU monitoring disabled.");
       return;
     }
 
-    Thread t = new Thread(this::runWithRestart, "gpu-dmon-thread");
+    // 데몬 스레드로 실행 (서버 종료 시 자동 종료)
-    t.setDaemon(true); // 서버 종료 시 같이 종료
+    Thread t = new Thread(this::runLoop, "gpu-dmon-thread");
+    t.setDaemon(true);
     t.start();
   }
 
   // =========================
-  // dmon 실행 + 자동 재시작 루프
+  // 무한 루프
-  // - dmon이 죽어도 계속 재시작
+  // - dmon 실행
+  // - 죽으면 자동 재시작
   // =========================
-  private void runWithRestart() {
+  private void runLoop() {
-    boolean firstError = true;
 
     while (true) {
       try {
-        log.info("Starting nvidia-smi dmon...");
+        runDmon(); // GPU 사용률 수집 시작
-        runDmon();
-        firstError = true; // 정상 실행되면 초기화
-
       } catch (Exception e) {
-
+        // dmon 프로세스 종료되면 여기로 들어옴
-        if (firstError) {
+        log.warn("dmon restart: {}", e.getMessage());
-          log.error("nvidia-smi not available. GPU monitoring disabled.", e);
-          firstError = false;
-        } else {
-          log.warn("dmon retry...");
-        }
       }
 
-      try {
+      // 5초 대기 후 재시작
-        Thread.sleep(5000); // 5초 후에 시작
+      sleep(5000);
-      } catch (InterruptedException ignored) {
-      }
     }
   }
 
   // =========================
-  // nvidia-smi dmon 실행 및 출력 파싱
+  // nvidia-smi dmon 실행
+  // - GPU 사용률 스트리밍으로 계속 수신
   // =========================
   private void runDmon() throws Exception {
 
-    // GPU utilization만 출력 (-s u)
+    // -s u → GPU utilization만 출력
     ProcessBuilder pb = new ProcessBuilder("nvidia-smi", "dmon", "-s", "u");
 
-    process = pb.start();
+    // 프로세스 실행 후 stdout 읽기
+    try (BufferedReader br =
+        new BufferedReader(new InputStreamReader(pb.start().getInputStream()))) {
 
-    // dmon은 stdout으로 계속 데이터를 뿌림 (스트리밍)
-    try (BufferedReader br = new BufferedReader(new InputStreamReader(process.getInputStream()))) {
       String line;
 
+      // dmon은 계속 출력됨 (스트리밍)
       while ((line = br.readLine()) != null) {
 
-        // 디버깅 로그
+        // 헤더 제거 (#로 시작)
-        // log.info("RAW: [{}]", line);
-
-        // 헤더 제거
         if (line.startsWith("#")) continue;
 
         line = line.trim();
         if (line.isEmpty()) continue;
 
+        // 공백 기준 분리
         String[] parts = line.split("\\s+");
 
-        // GPU index 확인
+        // 첫 번째 값이 GPU index인지 확인
         if (!parts[0].matches("\\d+")) continue;
 
         int index = Integer.parseInt(parts[0]);
 
-        int util = 0;
         try {
-          util = Integer.parseInt(parts[1]); // sm 값
+          // 두 번째 값이 GPU 사용률 (sm)
-        } catch (Exception e) {
+          int util = Integer.parseInt(parts[1]);
-          continue;
-        }
 
-        gpuUtilMap.put(index, util);
+          // 최신 값 갱신
+          gpuUtilMap.put(index, util);
+
+        } catch (Exception ignored) {
+          // 파싱 실패 시 무시
+        }
       }
     }
 
-    // 여기 도달했다는 건 dmon 프로세스가 종료된 상태
+    // 여기까지 왔다는 건 dmon 프로세스 종료됨
-    int exitCode = process.waitFor();
+    // → runLoop에서 재시작하도록 예외 발생
-    log.warn("dmon exited. code={}", exitCode);
-
-    // 상위 루프에서 재시작하도록 예외 발생
     throw new IllegalStateException("dmon stopped");
   }
 
   // =========================
-  // dmon 프로세스 살아있는지 확인
+  // nvidia-smi 존재 여부 확인
   // =========================
-  public boolean isAlive() {
-    return process != null && process.isAlive();
-  }
-
-  // =========================
-  // dmon 강제 재시작
-  // - 기존 프로세스 종료 → runWithRestart에서 자동 재시작
-  // =========================
-  public void restart() {
-    try {
-      if (process != null && process.isAlive()) {
-        process.destroy();
-      }
-    } catch (Exception ignored) {
-    }
-  }
-
   private boolean isNvidiaAvailable() {
     try {
       Process p = new ProcessBuilder("which", "nvidia-smi").start();
@@ -160,4 +129,14 @@ public class GpuDmonReader {
       return false;
     }
   }
+
+  // =========================
+  // sleep 유틸
+  // =========================
+  private void sleep(long ms) {
+    try {
+      Thread.sleep(ms);
+    } catch (InterruptedException ignored) {
+    }
+  }
 }

src/main/java/com/kamco/cd/training/common/service/SystemMonitorService.java

@@ -6,6 +6,7 @@ import java.io.FileReader;
 import java.util.ArrayDeque;
 import java.util.Deque;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.log4j.Log4j2;
 import org.springframework.scheduling.annotation.Scheduled;
@@ -17,7 +18,9 @@ import org.springframework.stereotype.Service;
 public class SystemMonitorService {
 
   // =========================
-  // CPU 이전값 (누적값 → delta 계산용)
+  // CPU 이전값 (delta 계산용)
+  // - /proc/stat은 누적값이기 때문에
+  // - 이전 값과 비교해서 사용률 계산
   // =========================
   private long prevIdle = 0;
   private long prevTotal = 0;
@@ -28,27 +31,28 @@ public class SystemMonitorService {
   // - GPU: GPU별 30개
   // =========================
   private final Deque<Double> cpuHistory = new ArrayDeque<>();
-  private final Map<Integer, Deque<Integer>> gpuHistory = new java.util.HashMap<>();
+
+  // key: GPU index
+  // value: 최근 30개 사용률
+  private final Map<Integer, Deque<Integer>> gpuHistory = new ConcurrentHashMap<>();
 
   // =========================
-  // GPU dmon reader (스트리밍)
+  // GPU 데이터 제공 (dmon reader)
   // =========================
   private final GpuDmonReader gpuReader;
 
   // =========================
   // 캐시 (API 응답용)
   // - 매 요청마다 계산하지 않기 위해 사용
-  // - volatile로 동시성 안전 보장
+  // - volatile → 멀티스레드 안전하게 최신값 유지
   // =========================
   private volatile MonitorDto cached = new MonitorDto();
 
   // =========================
-  // 1초마다 실행되는 수집 스케줄러
+  // 1초마다 수집
   // =========================
   @Scheduled(fixedRate = 1000)
   public void collect() {
-    // 디버깅용
-    // log.info("collect instance = {}", this);
     try {
 
       // =====================
@@ -62,16 +66,19 @@ public class SystemMonitorService {
       if (cpuHistory.size() > 30) cpuHistory.poll();
 
       // =====================
-      // 2. GPU (dmon 데이터 사용)
+      // 2. GPU 수집
       // =====================
       Map<Integer, Integer> gpuMap = gpuReader.getGpuUtilMap();
 
       for (Map.Entry<Integer, Integer> entry : gpuMap.entrySet()) {
+
         int index = entry.getKey();
         int util = entry.getValue();
 
+        // GPU별 히스토리 생성 및 추가
         gpuHistory.computeIfAbsent(index, k -> new ArrayDeque<>()).add(util);
 
+        // 30개 유지
         Deque<Integer> q = gpuHistory.get(index);
         if (q.size() > 30) q.poll();
       }
@@ -79,7 +86,7 @@ public class SystemMonitorService {
       // =====================
       // 3. 캐시 업데이트
       // =====================
-      updateCache(gpuMap);
+      updateCache();
 
     } catch (Exception e) {
       log.error("collect error", e);
@@ -87,7 +94,9 @@ public class SystemMonitorService {
   }
 
   // =========================
-  // CPU 사용률 계산 (/proc/stat)
+  // CPU 사용률 계산
+  // - /proc/stat 사용
+  // - 이전값과의 차이로 계산 (delta 방식)
   // =========================
   private double readCpu() throws Exception {
 
@@ -95,8 +104,7 @@ public class SystemMonitorService {
 
     try (BufferedReader br = new BufferedReader(new FileReader("/proc/stat"))) {
 
-      String line = br.readLine();
+      String[] p = br.readLine().split("\\s+");
-      String[] p = line.split("\\s+");
 
       long user = Long.parseLong(p[1]);
       long nice = Long.parseLong(p[2]);
@@ -109,6 +117,7 @@ public class SystemMonitorService {
       long total = user + nice + system + idle + iowait + irq + softirq;
       long idleAll = idle + iowait;
 
+      // 최초 실행 시 기준값만 저장
       if (prevTotal == 0) {
         prevTotal = total;
         prevIdle = idleAll;
@@ -123,58 +132,54 @@ public class SystemMonitorService {
 
       if (totalDiff == 0) return 0;
 
+      // CPU 사용률 (%)
       return (1.0 - (double) idleDiff / totalDiff) * 100;
-
-    } catch (Exception e) {
-      log.warn("CPU read fail", e);
-      return 0;
     }
   }
 
+  // =========================
+  // Linux 환경 체크
+  // =========================
   private boolean isLinux() {
     return System.getProperty("os.name").toLowerCase().contains("linux");
   }
 
   // =========================
-  // Memory (/proc/meminfo)
+  // Memory 조회 (/proc/meminfo)
-  // - 현재값 (평균 아님)
+  // - OS 값 그대로 사용 (kB)
+  // - [사용량, 전체]
   // =========================
-  private String readMemory() throws Exception {
+  private long[] readMemory() throws Exception {
 
-    // linux 환경일때만 실행
+    if (!isLinux()) return new long[] {0, 0};
-    if (!isLinux()) {
-      return "N/A";
-    }
 
-    BufferedReader br = new BufferedReader(new FileReader("/proc/meminfo"));
+    try (BufferedReader br = new BufferedReader(new FileReader("/proc/meminfo"))) {
 
-    long total = 0;
+      long total = 0;
-    long available = 0;
+      long available = 0;
 
-    String line;
+      String line;
-    while ((line = br.readLine()) != null) {
+      while ((line = br.readLine()) != null) {
-      if (line.startsWith("MemTotal")) {
+        if (line.startsWith("MemTotal")) {
-        total = Long.parseLong(line.replaceAll("\\D+", ""));
+          total = Long.parseLong(line.replaceAll("\\D+", ""));
-      } else if (line.startsWith("MemAvailable")) {
+        } else if (line.startsWith("MemAvailable")) {
-        available = Long.parseLong(line.replaceAll("\\D+", ""));
+          available = Long.parseLong(line.replaceAll("\\D+", ""));
+        }
       }
+
+      long used = total - available;
+
+      return new long[] {used, total};
     }
-
-    br.close();
-
-    long used = total - available;
-
-    // kB → GB
-    double usedGB = used / (1024.0 * 1024);
-    double totalGB = total / (1024.0 * 1024);
-
-    return String.format("%.1f/%.0fGB", usedGB, totalGB);
   }
 
   // =========================
   // 캐시 업데이트
+  // - CPU: 30초 평균
+  // - GPU: 전체 샘플 평균
+  // - Memory: 현재값
   // =========================
-  private void updateCache(Map<Integer, Integer> gpuMap) throws Exception {
+  private void updateCache() throws Exception {
 
     MonitorDto dto = new MonitorDto();
 
@@ -184,23 +189,25 @@ public class SystemMonitorService {
     dto.cpu = (int) cpuHistory.stream().mapToDouble(Double::doubleValue).average().orElse(0);
 
     // =====================
-    // Memory (현재값)
+    // Memory (kB 그대로)
     // =====================
     dto.memory = readMemory();
 
     // =====================
-    // GPU 평균 (30초)
+    // GPU 평균 (🔥 전체 샘플 기준)
     // =====================
-    for (Map.Entry<Integer, Deque<Integer>> entry : gpuHistory.entrySet()) {
+    int sum = 0;
+    int count = 0;
 
-      int index = entry.getKey();
+    for (Deque<Integer> q : gpuHistory.values()) {
-      Deque<Integer> q = entry.getValue();
+      for (int v : q) {
-
+        sum += v;
-      int avg = (int) q.stream().mapToInt(i -> i).average().orElse(0);
+        count++;
-
+      }
-      dto.gpus.add(new MonitorDto.Gpu(index, avg));
     }
 
+    dto.gpu = (count == 0) ? 0 : sum / count;
+
     // =====================
     // 캐시 교체 (atomic)
     // =====================
@@ -208,7 +215,8 @@ public class SystemMonitorService {
   }
 
   // =========================
-  // 외부 조회 (Controller에서 호출)
+  // 외부 조회
+  // - Controller에서 호출
   // =========================
   public MonitorDto get() {
     return cached;