GPU를 쪼개면 빨라질까 - 추론 클러스터에서 가설을 하나씩 실측으로 검증한 기록

파드가 GPU 한 장에 몰리고 예약과 실사용이 크게 어긋난 상황에서 시작해, MPS·HAMi·DRA 같은 GPU 분할 기술이 처리량을 늘려줄지 직접 재 봤다. 결과적으로 분할의 이득은 작았고, 처리량을 바꾼 것은 TensorRT와 GPU 간 분산이었다. 틀렸던 중간 결론까지 포함해 정리한다.

2026-10-1422 min read
#GPU#Kubernetes#MPS#HAMi#DRA#TensorRT#DCGM#ONNX Runtime#추론 최적화

요약

위성영상 AI 추론용 쿠버네티스 GPU 클러스터에서 "GPU를 더 잘게 쪼개 공유하면 처리량이 늘지 않을까"라는 질문으로 조사를 시작했다. 결론부터 적으면 다음과 같다.

  • 한 GPU 안에서 작업을 동시에 돌리는 방식(시분할, MPS 계열)으로 얻은 처리량 이득은 0.92~1.09배 범위였다.
  • 처리량을 크게 바꾼 것은 두 가지였다. TensorRT(FP16) 적용 시 OBB 3.21배·SEG 1.54배, 같은 일을 GPU 여러 장에 분산했을 때 1.97~1.98배.
  • 그 이유는 DCGM으로 직접 재 보고 나서야 확인했다. GPU는 놀고 있던 게 아니라 전력 한계(140W)에 닿아 있었다.

중간에 내린 결론 중 세 개는 나중 측정으로 뒤집혔다. 이 글은 그 과정까지 같이 남긴다.

GPU 공유 방식(MIG, MPS, 시분할, GPUShare)의 개념과 처음 GPUShare를 고른 이유는 이전 글에 정리했다. 이 글은 그 선택을 운영하면서 실제로 재 본 후속편이다.

환경

항목내용
클러스터4노드 (컨트롤플레인 3 + 워커 1), 합계 vCPU 184 · 메모리 469 GiB
노드 사양48 vCPU / 125 GiB × 3, 40 vCPU / 94 GiB × 1
OS / 쿠버네티스Rocky Linux 8 · kubeadm · Kubernetes v1.35.6
CNICilium (kube-proxy 대체, VXLAN 터널)
런타임containerd + nvidia-container-runtime (기본 런타임)
GPUNVIDIA RTX A4000 16 GB × 4 (한 노드) + 12 GiB급 GPU × 5 (다른 노드)
GPU 공유Aliyun gpushare (scheduler extender + device plugin)
드라이버 / CUDA595.45.04 / 컨테이너 CUDA 12.1
추론 스택ONNX Runtime 1.19.2 (CUDA EP), TensorRT 10.3 (실험)

측정은 모두 RTX A4000(물리 16,376 MiB, 전력 상한 140W, MIG 미지원)에서 했다.

워크로드는 위성영상을 1024×1024 타일로 잘라 추론하는 서비스다. 모델은 세 종류다.

모델                               타일당 지연 (CUDA EP)   GPU 메모리
OBB  회전 박스 객체탐지 (20클래스)     51.4 ms                 1,430 MiB
HBB  수평 박스 객체탐지               22.6 ms                 (미측정)
SEG  세그멘테이션 (FP32, 4ch 입력)   580.1 ms                 6,532 MiB
SEG  세그멘테이션 (FP16, DPT 계열)   159.5 ms                 2,420 MiB

입력은 batch=1 고정, 타일 크기 1024×1024다.

문제: 장부와 실물이 다르다

출발점은 관측 두 개였다.

          예약(gpu-mem)   실제 사용    GPU 사용률
GPU 0     11 / 15 GiB     2,248 MiB    0 %      ← 파드 5개가 몰림
GPU 1      0 / 15 GiB       100 MiB    0 %
GPU 2      0 / 15 GiB       100 MiB    0 %
GPU 3     15 / 15 GiB       100 MiB    0 %      ← 한 장을 통째로 예약, 사용 0
  1. 왜 GPU 0에만 몰리나. gpushare 익스텐더 소스(allocateGPUID)를 보니 "요청이 들어가는 장치 중 남은 메모리가 가장 적은 것"을 고르는 tightest-fit binpack이 하드코딩되어 있었다. 설정으로 바꿀 수 없다.
  2. 왜 예약 26 GiB에 실사용 2.1 GiB(8%)인가. gpushare는 메모리를 강제하지 않는다. gpu-mem은 스케줄링 순간에만 쓰이는 장부다. 모델을 요청이 올 때 올리는 지연 로딩과, 실사용 근거 없이 크게 잡은 요청값이 겹쳐 장부와 실물이 양방향으로 벌어졌다.

gpushare 내부도 따라가 봤다. Device Plugin API는 정수 개수만 다루기 때문에, gpushare는 1 GiB짜리 가짜 디바이스를 GPU당 15개씩 등록해 메모리를 정수 자원처럼 보이게 한다. kubelet이 건네는 디바이스 ID는 개수 세는 데만 쓰이고, 실제 GPU는 익스텐더가 파드 어노테이션에 적은 번호로 정해져 NVIDIA_VISIBLE_DEVICES로 주입된다. 실행 중에는 아무것도 감시하지 않는다.

여기서 자연스럽게 나온 생각은 "메모리만 나누고 연산(SM)은 나누지 않으니 한 장에서 줄을 서는 것이다. 연산까지 나누면 빨라지지 않을까"였다.

가설: 쪼개는 기술을 쓰면 빨라진다?

검토 대상은 이렇게 정리했다.

방식메모리 강제실행 방식비고
gpushare없음 (장부만)드라이버 기본 시분할현재 구성
NVIDIA time-slicing없음시분할한 장을 N개로 광고만 한다
HAMi있음 (CUDA 호출 가로채기)시분할 (자체 time shard)연산 제한은 공간 분할이 아니다
MPS있음공간 분할 (서로 다른 프로세스 커널 동시 실행)Device Plugin 세대에선 hostIPC 필요
DRA + MPS있음공간 분할claim별 데몬, hostIPC 불필요. 클러스터에 resource.k8s.io/v1 GA
MIG있음하드웨어 분할A4000은 미지원

문서상으로는 "DRA + MPS"가 메모리 강제·동시 실행·파드별 설정을 모두 만족했다. 하지만 이 판단에는 전제가 하나 깔려 있었다. 동시 실행이 우리 워크로드에서 실제로 처리량을 늘리는가. 이걸 먼저 재기로 했다.

검증 1: 동시 실행 이득은 거의 없다

같은 GPU에서 워커 시작 시각을 맞춰 20초간 반복 추론했다.

OBB (CUDA EP)
1 프로세스                    19.481/s    51.3 ms
2 프로세스 (컨텍스트 분리)      18.062/s   110.8 ms ×2     0.93배

2개로 늘리니 오히려 느려졌다. 워커당 지연이 정확히 2배가 아니라 2.16배로 늘어난 차이가 컨텍스트 스위치 비용이다.

처음에는 여기서 "MPS 상한은 1/0.93 = 7.9%"라고 계산했다. 이건 틀린 계산이었다. MPS가 컨텍스트 스위치 비용만 없앤다고 가정했기 때문이다. 세션 하나를 여러 스레드가 공유하게 해서(같은 CUDA 컨텍스트, MPS가 만들어주려는 상태와 같다) 다시 쟀다.

             2 프로세스    2 스레드(세션 공유)   순수 동시실행 이득
OBB           0.930배        1.018배              1.8%
SEG (FP16)    0.985배        1.086배              8.6%

정정된 MPS 회수분은 컨텍스트 스위치 회수까지 합쳐 약 10% 였다. "의미 없다"는 과장이었고, 정확히는 "의미는 있으나 비용 대비 우선순위가 낮다"였다.

FP32 SEG는 별도 세션 2개를 띄우자 한쪽이 추론 도중 cuDNN 오류로 죽었다. 장부는 배치를 통과시켰고 실패는 런타임 한복판에서 났다. 메모리 강제(HAMi·MPS)의 가치는 처리량이 아니라 실패를 예측 가능하게 만드는 것이라고 정리했다.

검증 2: TensorRT만 크게 움직였다

공유 방식으로 처리량이 안 늘면 남는 길은 추론 하나를 싸게 만드는 것이다. 처음엔 TensorRT EP가 provider 목록에는 나오는데 실제로는 libnvinfer가 없어 CPU로 폴백하고 있었다. 런타임 라이브러리를 넣고 FP16 엔진으로 쟀다.

                    CUDA EP              TensorRT FP16        배수
OBB                 51.4 ms · 19.481/s   16.0 ms · 62.556/s   3.21
SEG (FP16/DPT)     159.5 ms ·  6.253/s  103.8 ms ·  9.637/s   1.54

SEG가 상대적으로 덜 빨라진 이유는 빌드 로그에 있었다. MultiHeadAttention 커스텀 연산을 TensorRT가 모르기 때문에 그 부분이 CUDA EP로 떨어져 부분 최적화에 그쳤다.

SEG 기준으로 보면 모델 교체(FP32 → FP16/DPT)와 TensorRT가 곱해져 576.4 ms → 103.8 ms, 약 5.6배다. 다만 모델 구조가 같이 바뀌었으므로 정밀도만의 효과는 아니다.

그리고 TensorRT 위에서 같은 동시 실행 실험을 반복해도 결과는 같았다(2 프로세스 0.994배). 추론을 3배 싸게 만들어도 GPU는 늘어난 여유를 바로 다 흡수했다.

비용도 있다. 엔진 빌드에 OBB 293초·SEG 531초가 걸리고, 엔진은 GPU 아키텍처(sm86)에 묶인다. 캐시를 영속 볼륨에 두지 않으면 파드가 뜰 때마다 수 분씩 빌드한다. 또 이 수치는 속도만 잰 것이고 FP16 변환 후 정확도가 같은지는 별도로 확인해야 한다.

검증 3: 병목 분해, 그리고 반증된 가설들

"왜 쪼개도 안 빨라지나"를 설명하려고 간접 측정을 쌓았다. 이 구간에서 틀린 진단이 가장 많이 나왔다.

클럭 스케일링. SM 클럭을 절반으로 낮췄는데 지연이 20% 안팎만 늘었다. 그래서 "연산이 아니라 데이터 이동이 병목"이라고 판단했다.

트래픽 추정. ONNX 그래프에서 활성값 바이트를 세서 달성 대역폭을 추정했다. OBB는 피크(실측 388 GB/s)의 54%, SEG는 6%. 그래서 "OBB는 대역폭 바운드, SEG는 지연 바운드"로 진단했다.

ArgMax → TopK. ORT 프로파일러로 보니 SEG 157 ms 중 커널 시간이 28%뿐이었다. ONNX Runtime 1.19.2의 CUDA EP에는 ArgMax 커널이 없어 그래프 끝의 ArgMax가 CPU로 떨어지고, 그 때문에 CUDA Graph도 막혀 있었다. "디스패치·동기화가 병목이니 ArgMax를 TopK(k=1)로 바꿔 CUDA Graph를 열면 빨라진다"는 가설을 세웠다.

직접 그래프를 수정해 적용했다.

                              지연         비고
원본 (ArgMax, CPU 폴백)      157~159 ms   기준
TopK 치환 (전부 CUDA)        193~195 ms   23% 느려짐
TopK + CUDA Graph            192~194 ms   개선 0.3%

출력은 1,048,576 픽셀 중 차이 0개로 같았고 CUDA Graph도 열렸다. 수정은 작동했지만 가설은 틀렸다. CUDA Graph로 런치 오버헤드를 없애도 0.3%라면 "72%가 디스패치"라는 진단이 틀린 것이다. 프로파일러의 커널 시간 집계는 OBB로 교차 확인했을 때 이미 맞지 않았는데, SEG 숫자가 그럴듯해 넘어간 것이 원인이었다. TopK는 정렬 연산이라 더 느려졌으니 권고도 철회했다.

검증 4: DCGM으로 보니 전력 한계였다

간접 추정을 멈추고 dcgm-exporter를 임시 파드로 띄워 프로파일 지표를 직접 읽었다. 노드에 설치할 필요가 없었고 띄우는 데 1분도 안 걸렸다.

                      SEG        OBB
GR_ENGINE_ACTIVE     91.3 %     96.9 %
PIPE_TENSOR_ACTIVE   48.6 %     20.1 %
DRAM_ACTIVE          43.6 %     58.5 %
POWER_USAGE         139.0 W    139.5 W    ← 상한 140 W
SM_CLOCK            1338 MHz   1356 MHz   ← 최대 2100 MHz에서 스스로 내려감

GPU는 놀고 있지 않았다. 전력이 모자랐다. A4000의 전력 상한은 140W이고 올릴 수 없다. 두 워크로드 모두 상한에 닿아 GPU가 클럭을 1,340 MHz대로 스스로 낮추고 있었다.

이걸로 앞선 진단 세 개가 정정됐다.

  • "SEG 대역폭 6%" → 실측 DRAM_ACTIVE 43.6%. 그래프에서 바이트를 세는 방식은 반복 읽기를 반영하지 못했다.
  • "클럭 민감도 20%" → 기준 클럭을 락 값(2100/1905 MHz)으로 잡은 게 틀렸다. 부하 중 실제 클럭(약 1340 MHz)으로 다시 계산하면 67~75%로, 둘 다 상당히 연산 쪽이다.
  • "SEG는 지연 바운드" → 연산과 메모리를 둘 다 쓰면서 전력 한계에 닿은 상태였다.

OBB는 메모리 쪽, SEG는 연산 쪽으로 기운다는 방향성만 살아남았다.

작업 수를 바꿔 가며 전력을 샘플링해 보면 그림이 단순해진다.

                      GPU0 전력   GPU1 전력   총 처리량 (OBB)
유휴                   17.6 W      17.4 W        -
1 프로세스            139.5 W      17.5 W     19.435/s
2 프로세스, 같은 GPU   139.6 W      17.5 W     18.059/s
2 프로세스, 다른 GPU   139.5 W     139.4 W     38.247/s

같은 GPU에 일을 두 배로 넣어도 전력은 139.5W 그대로였다. 와트당 처리량은 0.13~0.14/s로 거의 일정했다. 총 처리량은 쓸 수 있는 총 와트로 정해진다. 한 장 안에서 SM을 어떻게 나누든 그 장의 140W는 늘지 않는다. 분할 기술이 전부 1배 근처였던 이유가 여기 있었다.

검증 5: 분산하면 1.98배, binpack이 처리량을 버리고 있었다

검증 1 직후에 나는 "binpack 쏠림은 처리량 문제가 아니다. 한 장에 몰든 나눠 놓든 총량은 같다"고 적었다. 같은 GPU 안의 1 대 2 프로세스만 재고 그걸 "GPU를 나눠도 마찬가지"로 확대 해석한 것이다. 전력 예산이 GPU마다 따로라면 이 결론은 틀렸을 수밖에 없다. 실제로 쟀다.

                        OBB                       SEG (FP16)
1 프로세스              19.468/s   51.3 ms        6.200/s  161.1 ms
2 프로세스 · 같은 GPU    17.970/s  111.3 ms ×2     6.069/s  329.5 ms ×2
2 프로세스 · 다른 GPU    38.455/s   51.7/52.2 ms  12.231/s  162.5/163.7 ms
배수 (다른 GPU / 1개)    1.98                     1.97

다른 GPU에 두면 각 워커가 단독 실행 때와 같은 지연을 유지하며 거의 선형으로 늘었다. "어떻게 나눌까"보다 "어디에 둘까"가 훨씬 중요했다. 그동안 앞의 질문만 파고들었고, 뒤의 질문은 잘못된 근거로 일찍 닫아 버렸다.

binpack 익스텐더를 바꾸려면 비교 연산자 하나를 뒤집는 코드 수정(포크 유지보수 발생)이 필요하다. 코드를 안 고치려면 요청값을 키워 한 장에 하나만 들어가게 하는 우회가 있지만, 메모리 요청값을 배치 제어에 쓰는 셈이라 의도를 꼭 주석으로 남겨야 한다.

검증 6: 같은 와트로 3.11배

전력이 상한이면 남는 질문은 "같은 와트로 더 많은 일을 할 수 있나"다. 같은 GPU·모델·입력에서 EP만 바꿔 DCGM 지표를 비교했다(OBB).

                  CUDA EP      TensorRT FP16     변화
처리량            18.940/s     58.920/s          3.11배
전력              139.42 W     139.62 W          같다
SM 클럭           1386 MHz     1356 MHz          오히려 낮다
GR_ENGINE_ACTIVE  97 %         92 %              오히려 낮다
DRAM_ACTIVE       59 %         37 %              감소
PIPE_TENSOR       20 %         50 %              2.5배
와트당 처리량      0.136 /W     0.422 /W          3.1배

엔진은 덜 바쁘고 클럭도 낮은데 세 배 빨랐다. 전력 예산의 쓰임새가 바뀐 것이다. 레이어 융합으로 중간 결과의 DRAM 왕복이 줄면서, 데이터를 나르던 에너지가 텐서 코어 연산으로 옮겨 갔다. DRAM 접근은 연산 한 번보다 에너지가 두 자릿수 이상 비싸다는 일반적인 추정과도 맞는 결과다.

"GPU를 극한으로 쓴다"에는 뜻이 두 가지 있었다. 하드웨어를 바쁘게 만드는 것(엔진 가동률 91~97%)은 이미 꽉 차 있었다. 하드웨어가 쓸모 있는 일을 하게 만드는 것(텐서 가동률 20%)에 여지가 있었다.

결과 정리

시도측정 조건처리량 배수판정
같은 GPU 2 프로세스 (시분할)OBB / SEG FP16, CUDA EP0.93 / 0.985이득 없음
세션 공유 2 스레드 (MPS 상한 근사)OBB / SEG FP16, CUDA EP1.018 / 1.086작음 (~10%)
TensorRT FP16OBB / SEG FP16, 단일 프로세스3.21 / 1.54유효
TensorRT 위 2 프로세스OBB0.994이득 없음
ArgMax → TopK + CUDA GraphSEG FP16약 0.81 (23% 느려짐)가설 반증, 철회
다른 GPU에 분산OBB / SEG FP161.98 / 1.97유효
와트당 처리량 (TensorRT)OBB, 전력 약 139W 동일3.11유효

두 축(와트당 효율과 총 와트)은 서로 독립적이라 곱해질 것으로 예상한다. 단순 계산으로 TensorRT 적용 후 세 장에 분산하면 현재의 약 9배가 나오지만, 둘을 함께 적용한 상태는 재지 않았다.

배운 것

측정이 직관을 여러 번 뒤집었다. "쪼개면 빨라진다", "쏠림은 문제가 아니다", "SEG는 디스패치 바운드다", "SEG는 대역폭을 거의 안 쓴다". 전부 그럴듯했고 전부 틀렸다.

계측기부터 구했어야 했다. 간접 추정(그래프 바이트 계산, 프로파일러 집계, 락 클럭 기준 민감도) 위에 문서를 몇 개씩 쌓았다. dcgm-exporter는 노드에 아무것도 설치하지 않고 파드 하나로 바로 떴다. 처음부터 그걸 했다면 우회를 많이 줄였을 것이다. 측정 도구가 교차 검증에서 한 번이라도 어긋나면 그 위에 결론을 쌓지 않아야 한다.

직접 개입하는 검증은 매번 옳았다. CUDA Graph를 실제로 켜 본 것이 디스패치 가설을 한 번에 깼고, DCGM을 띄운 것이 나머지를 정리했다. 추론을 더 쌓기보다 고쳐서 재 보는 쪽이 빨랐다.

틀린 결론도 지우지 않고 남겼다. 정정은 원래 문서에 "철회"로 표시하고 근거를 달았다. 나중에 보면 어떤 가정이 어디서 깨졌는지가 정답보다 더 쓸모 있었다.

마지막으로, 이 결론은 이 워크로드(1024 타일 단건 추론, 전력 상한 140W 카드)에 한정된다. 작은 모델을 짧게 여러 개 돌리는 패턴이나 지연 보장이 필요한 환경에서는 MPS·Green Contexts 같은 분할 기술의 가치가 달라질 수 있다. 분할 기술의 가치는 처리량보다 격리와 예측 가능성 쪽에 있다고 본다.