fos-blog/study
01 / 홈02 / 카테고리03 / 시리즈
01 / 홈02 / 카테고리03 / 시리즈

카테고리

  • AI 페이지로 이동
    • RAG 페이지로 이동
    • langgraph 페이지로 이동
    • agents.md
    • BMAD Method — AI 에이전트로 애자일 개발하는 방법론
    • Claude Code의 Skill 시스템 - 개발자를 위한 AI 자동화의 새로운 차원
    • Claude Code를 5주 더 쓴 결과 — 스킬·CLAUDE.md를 키워가는 방식
    • Claude Code를 11일 동안 쓴 결과 — 데이터로 본 나의 사용 패턴
    • Claude Code 멀티 에이전트 — Teams
    • AI 에이전트와 디자인의 새 컨벤션 — DESIGN.md, Google Stitch, Claude Design
    • Docling — IBM Research 의 문서 파싱 toolkit 상세 정리
    • 하네스 엔지니어링 실전 — 4인 에이전트 팀으로 코딩 파이프라인 구축하기
    • 하네스 엔지니어링 — 오래 실행되는 AI 에이전트를 위한 설계
    • 멀티모달 LLM (Multimodal Large Language Model)
    • AI 에이전트와 함께 MVP 만들기 — dooray-cli 사례
  • ai 페이지로 이동
    • agent 페이지로 이동
  • algorithm 페이지로 이동
    • live-coding 페이지로 이동
    • 분산 계산을 위한 알고리즘
  • apartment 페이지로 이동
    • 구리 럭키아파트 24평 인테리어 레퍼런스 모음
  • architecture 페이지로 이동
    • [초안] 시니어 백엔드를 위한 API 설계 실전 스터디 팩 — REST · 멱등성 · 페이지네이션 · 버전 전략
    • [초안] API Versioning과 Backward Compatibility: 시니어 백엔드 관점 정리
    • 캐시 설계 전략 총정리
    • [초안] CJ푸드빌 디지털 채널 면접: 슬롯 도메인 경험을 커머스 도메인 설계 능력으로 번역하기
    • [초안] 커머스 Spring 서비스에 Clean/Hexagonal Architecture를 실용적으로 적용하기
    • [초안] 커머스 도메인 모델링: 주문·재고·노출의 세 축을 분리해서 설계하기
    • 커머스 주문 상태와 데이터 정합성 기본기 — CJ푸드빌 면접 대비
    • [초안] 쿠폰/프로모션 동시성과 정합성 기본기 — 선착순·중복 사용 방지·발급/사용/복구
    • [초안] DDD와 도메인 모델링: 시니어 백엔드 관점의 전술/전략 패턴 실전 가이드
    • [초안] Decorator & Chain of Responsibility — 행동을 체인으로 조립하는 두 가지 방식
    • 디자인 패턴
    • [초안] 분산 아키텍처 완전 정복: Java 백엔드 시니어 인터뷰 대비 실전 가이드
    • [초안] 분산 트랜잭션과 Outbox 패턴 — 왜 2PC를 피하고 어떻게 대신할 것인가
    • 분산 트랜잭션
    • [초안] e-Commerce 주문·결제 도메인 모델링: 상태머신, 멱등성, Outbox/Saga 실전 정리
    • [초안] F&B 쿠폰·프로모션·멤버십·포인트 설계
    • [초안] F&B · e-Commerce 디지털 채널 도메인 한 장 정리 — CJ푸드빌 디지털 채널 백엔드 면접 대비
    • [초안] F&B 주문/매장/픽업 상태머신 설계 — CJ푸드빌 디지털 채널 백엔드 관점
    • [초안] F&B 이커머스 결제·환불·정산 운영 가이드
    • [초안] Hexagonal / Clean Architecture를 Spring 백엔드에 적용하기
    • [초안] 대규모 커머스 트래픽 처리 패턴 — 1,600만 고객과 올영세일을 버티는 설계
    • [초안] 레거시 JSP/jQuery 화면과 신규 API가 공존하는 백엔드 운영 전략
    • [초안] MSA 서비스 간 통신: Redis [Cache-Aside](../database/redis/cache-aside.md) × Kafka 이벤트 하이브리드 설계
    • [초안] Observability 입문: 시니어 백엔드가 장애를 탐지하고 대응하는 방식
    • [초안] Outbox / Inbox Pattern 심화 — 분산 메시징의 정합성 문제를 DB 트랜잭션으로 풀어내기
    • [초안] 결제 도메인 멱등성과 트랜잭션 재시도 기본기
    • [초안] 시니어 백엔드를 위한 Resilience 패턴 실전 가이드 — Timeout, Retry, Circuit Breaker, Bulkhead, Backpressure
    • [초안] REST API 버저닝과 모바일 앱 하위 호환성 — CJ푸드빌 디지털 채널 백엔드 관점
    • [초안] Spring Batch vs Event-Driven — 같은 비동기처럼 보이지만 전혀 다른 두 패러다임
    • [초안] Strategy Pattern — 분기문을 없애는 설계, 시니어 백엔드 인터뷰 핵심 패턴
    • [초안] 시니어 백엔드를 위한 시스템 설계 입문 스터디 팩
    • [초안] 템플릿 메서드 패턴 - 백엔드 처리 골격을 강제하는 가장 오래되고 가장 위험한 패턴
    • [초안] 대규모 트래픽 중 무중단 마이그레이션 — Feature Flag + Shadow Mode 실전
  • database 페이지로 이동
    • mysql 페이지로 이동
    • opensearch 페이지로 이동
    • redis 페이지로 이동
    • 김영한의-실전-데이터베이스-설계 페이지로 이동
    • [초안] DB Connection Pool Saturation과 Thread Pool 격리
    • 커넥션 풀 크기는 얼마나 조정해야 할까?
    • 인덱스 - DB 성능 최적화의 핵심
    • [초안] JPA N+1과 커머스 조회 모델: 주문/메뉴/쿠폰 도메인에서 살아남기
    • [초안] MyBatis 기본기 — XML Mapper, resultMap, 동적 SQL, 운영 패턴 정리
    • [초안] MyBatis와 JPA/Hibernate 트레이드오프 — 레거시 백엔드를 다루는 시니어 관점
    • 역정규화 (Denormalization)
    • 데이터 베이스 정규화
  • devops 페이지로 이동
    • docker 페이지로 이동
    • k8s 페이지로 이동
    • k8s-in-action 페이지로 이동
    • observability 페이지로 이동
    • [초안] 커머스/F&B 채널 장애 첫 5분과 관측성 기본기
    • Envoy Proxy
    • [초안] F&B / e-Commerce 운영 장애 대응과 모니터링 — 백엔드 관점 정리
    • Graceful Shutdown
    • [초안] 시니어 백엔드를 위한 SLO와 Error Budget 기반 장애 대응
  • finance 페이지로 이동
    • industry-cycle 페이지로 이동
    • investing 페이지로 이동
  • http 페이지로 이동
    • HTTP Connection Pool
  • interview 페이지로 이동
    • [초안] AI 서비스 팀 경험 기반 시니어 백엔드 면접 질문 뱅크 — Spring Batch RAG / gRPC graceful shutdown / 전략 패턴 / 12일 AI 웹툰 MVP
    • [초안] 커머스/F&B 면접 답변집 — 슬롯 도메인 경험을 주문·결제·쿠폰·매장 설계로 매핑하기
    • [초안] F&B / e-Commerce 운영 모니터링과 장애 대응 인터뷰 정리
    • Observability — 면접 답변 프레임
    • [초안] 시니어 Java 백엔드 면접 마스터 플레이북 — 김병태
    • [초안] NSC 슬롯팀 경험 기반 질문 은행 — 도메인 모델링·동시성·성능·AI 협업
  • java 페이지로 이동
    • concurrency 페이지로 이동
    • jdbc 페이지로 이동
    • opentelemetry 페이지로 이동
    • spring 페이지로 이동
    • spring-batch 페이지로 이동
    • 더_자바_코드를_조작하는_다양한_방법 페이지로 이동
    • [초안] Java 동시성 락 정리 — 커머스 메뉴/프로모션 정책 캐시 갱신 관점
    • [초안] JVM 튜닝 실전: 메모리 구조부터 Virtual Threads, GC 튜닝, 프로파일링까지
    • Java의 로깅 환경
    • MDC (Mapped Diagnostic Context)
    • Java StampedLock — 읽기 폭주에도 쓰기가 밀리지 않는 락
    • Virtual Thread와 Project Loom
  • javascript 페이지로 이동
    • typescript 페이지로 이동
    • AbortController
    • Async Iterator와 제너레이터
    • CommonJS와 ECMAScript Modules
    • 제너레이터(Generator)
    • Http Client
    • Node 백엔드 운영 패턴 — Streams 백프레셔, pipe/pipeline, 멱등성 vs 분산 락
    • Node.js
    • npm vs pnpm — 어떤 기준으로 선택했나
    • `setImmediate()`
  • kafka 페이지로 이동
    • [초안] Kafka 기본 개념 — 토픽, 파티션, 오프셋, 복제
    • Kafka를 사용하여 **데이터 정합성**은 어떻게 유지해야 할까?
    • [초안] Kafka 실전 설계: 파티션 전략, 컨슈머 그룹, 전달 보장, 재시도, 순서 보장 트레이드오프
    • 메시지 전송 신뢰성
  • linux 페이지로 이동
    • fsync — 리눅스 파일 동기화 시스템 콜
    • tmux — Terminal Multiplexer
  • network 페이지로 이동
    • L2(스위치)와 L3(라우터)의 역할 차이
    • L4와 VIP(Virtual IP Address)
    • IP Subnet
  • python 페이지로 이동
    • Python async/await — CompletableFuture·Reactor 와 다른 점, 그리고 blocking I/O 함정
    • Python 의존성 관리 — Java Maven/Gradle 사용자가 만나는 첫 충격
    • FastAPI 기초 — Spring Boot 사용자가 빠르게 익히는 법
    • GPU·CUDA·MPS 기초 — 자바 백엔드 개발자가 처음 만나는 그림
    • Multi-process GPU 워크로드 — 자바 ThreadPool 사용자가 만나는 모델 차이
    • Java 개발자를 위한 Python 심화 — OOP·데코레이터·컨텍스트 매니저
    • PyTorch 기초 — 텐서, 디바이스, 그리고 모델 로딩이 무거운 이유
    • Java 개발자를 위한 Python 문법 핵심
    • ML 서비스 성능 분석 워크플로 — 자바 백엔드 트러블슈팅과 다른 점
    • OCR 동작 원리 — Layout · Text · Post-process 3단계
    • Python 서버의 RSS 가 안 줄어드는 이유 — gc.collect 의 한계와 malloc_trim
  • rabbitmq 페이지로 이동
    • [초안] RabbitMQ Basics — 실전 백엔드 관점에서 정리하는 메시지 브로커 기본기
    • [초안] RabbitMQ vs Kafka — 백엔드 메시징 선택 기준과 실전 운영 관점
  • security 페이지로 이동
    • [초안] 시니어 백엔드를 위한 보안 / 인증 스터디 팩 — Spring Security, JWT, OAuth2, OWASP Top 10
    • [초안] Spring Security 6.x OAuth2 + JWT 상용 인증 설계 — Grant 선택, Resource Server, Refresh Rotation, 로그아웃
  • task 페이지로 이동
    • ai-service-team 페이지로 이동
    • nsc-slot 페이지로 이동
    • sb-dev-team 페이지로 이동
    • the-future-company 페이지로 이동
  • testing 페이지로 이동
    • [초안] 시니어 Java 백엔드를 위한 테스트 전략 완전 정리 — 피라미드부터 TestContainers, 마이크로벤치, Contract까지
  • travel 페이지로 이동
    • 오사카 3박 4일 일정표: 우메다 쇼핑, USJ, 난바·도톤보리, 오사카성
  • web 페이지로 이동
    • [초안] HTTP / Cookie / Session / Token 인증 기본기 — 레거시 JSP와 모바일 API가 공존하는 백엔드 관점
FOS-BLOG · FOOTERall systems normal·v0.1 · 2026.04.27·seoul, kr
Ffos-blog/study

개발 학습 기록을 정리하는 블로그입니다. 공부하면서 기록하고, 기록하면서 다시 배웁니다.

visitors
01site
  • Home↗
  • Posts↗
  • Categories↗
  • About↗
02policy
  • 소개/about
  • 개인정보처리방침/privacy
  • 연락처/contact
03categories
  • AI↗
  • Algorithm↗
  • DB↗
  • DevOps↗
  • Java/Spring↗
  • JS/TS↗
  • React↗
  • Next.js↗
  • System↗
04connect
  • GitHub@jon890↗
  • Source repositoryjon890/fos-study↗
  • RSS feed/rss.xml↗
  • Newsletter매주 1 회 · 한 편의 글→
© 2026 FOS Study. All posts MIT-licensed.
built with·Next.js·Tailwind v4·Geist·Pretendard·oklch
fos-blog/python/GPU·CUDA·MPS 기초 — 자바 백엔드…
system

GPU·CUDA·MPS 기초 — 자바 백엔드 개발자가 처음 만나는 그림

자바로 백엔드만 짤 때는 컴퓨팅 자원이 단순했다. CPU 코어 수, JVM heap (-Xmx), 시스템 RAM. 워크로드가 커지면 인스턴스를 늘리거나 스레드를 늘리는 게 답이었다. ML 서비스를 다루기 시작하면 그림이 한 층 더 생긴다. GPU 라는 별도 컴퓨팅 장치, 그 안의 VRAM 이라는 별도 메모리, 그리고 그것들을 다루는 CUDA·cuDNN·MP...

2026.05.19·7 min read·14 views

자바로 백엔드만 짤 때는 컴퓨팅 자원이 단순했다. CPU 코어 수, JVM heap (-Xmx), 시스템 RAM. 워크로드가 커지면 인스턴스를 늘리거나 스레드를 늘리는 게 답이었다.

ML 서비스를 다루기 시작하면 그림이 한 층 더 생긴다. GPU 라는 별도 컴퓨팅 장치, 그 안의 VRAM 이라는 별도 메모리, 그리고 그것들을 다루는 CUDA·cuDNN·MPS 같은 용어들. 자바 입장에서는 갑자기 "JVM 옆에 별도의 가상 머신이 하나 더 붙는 것 같다" 는 인상을 받는다.

이 글은 자바 백엔드 개발자가 ML 서비스를 운영·분석할 때 알아둬야 할 GPU 관련 기초 개념을 정리한다. 우리 프로젝트의 운영 환경 (Tesla T4 1장, MPS=OFF, Mac 로컬은 Apple MPS) 를 예시로 쓴다.

GPU 는 CPU 와 어떻게 다른가

CPU 는 소수의 강력한 코어로 복잡한 분기·예측·캐싱을 한다. 자바 백엔드 코드는 대부분 분기와 객체 조작이라 CPU 모델에 잘 맞는다.

GPU 는 수천 개의 단순한 코어로 같은 연산을 데이터 다발에 일괄 수행한다. 행렬 곱·합성곱 같은 단순 반복 연산에서 CPU 대비 100배 이상의 처리량을 낸다. ML 모델 추론·학습이 사실상 거대한 행렬 곱이라 GPU 의 강점과 정확히 일치한다.

자바로 비유하면 CPU 는 "복잡한 비즈니스 로직 한 트랜잭션", GPU 는 "Hadoop/Spark 가 데이터를 일괄 처리하듯 SIMD (Single Instruction Multiple Data) 방식의 병렬 처리" 라고 보면 가깝다.

CUDA — NVIDIA GPU 의 프로그래밍 인터페이스

CUDA 는 NVIDIA 가 만든 GPU 컴퓨팅 플랫폼 + API 다. 자바의 JVM 자리에 NVIDIA 의 CUDA 런타임이 들어가고, PyTorch·TensorFlow 같은 라이브러리가 그 위에서 동작한다.

자바CUDA
JDK / OpenJDKNVIDIA driver
JVMCUDA Runtime
자바 라이브러리 (예: Netty)cuDNN, cuBLAS, cuFFT
애플리케이션 (Spring Boot)PyTorch, TensorFlow

세 가지 버전이 모두 호환되어야 동작한다. 우리 프로젝트의 Dockerfile 첫 줄 FROM nvidia/cuda:11.8.0-cudnn8-runtime-ubuntu22.04 가 그 의미다.

  • cuda:11.8.0 — CUDA Runtime 버전. PyTorch 빌드가 요구하는 버전과 맞아야 한다.
  • cudnn8 — cuDNN 버전. 딥러닝 연산 (특히 합성곱) 가속 라이브러리.
  • ubuntu22.04 — OS 베이스.

호스트의 NVIDIA driver 가 컨테이너 안의 CUDA Runtime 보다 같거나 높아야 하고, PyTorch 가 빌드된 CUDA 버전과도 맞아야 한다. 자바에서 JDK 호환성 매트릭스를 신경 쓰는 것과 비슷하지만 한 단계 더 깐깐하다.

VRAM — GPU 전용 메모리

VRAM 은 GPU 카드 위에 붙은 메모리다. 시스템 RAM 과 물리적으로 분리된다. 우리 운영 환경의 Tesla T4 는 VRAM 16GB (실측 가용 15GB). 호스트의 시스템 RAM 32GB 와는 별도.

자바 사고로 가장 헷갈리는 부분이 이거다. JVM heap 은 시스템 RAM 의 한 조각이지만, GPU 의 VRAM 은 완전히 별도의 메모리 풀. 데이터를 GPU 에서 처리하려면 시스템 RAM → VRAM 으로 명시적 복사해야 한다.

python
import torch
 
x = torch.randn(1000, 1000)        # 시스템 RAM 에 있음 (CPU 텐서)
x_gpu = x.to("cuda")                # VRAM 으로 복사 (GPU 텐서)
y = x_gpu @ x_gpu                   # GPU 에서 행렬 곱
result = y.to("cpu")                # 결과를 시스템 RAM 으로 가져옴

이 to(...) 호출이 PCIe 버스를 통한 메모리 전송이다. 비용이 있어서 잦은 transfer 는 성능 손해. 모델을 한 번 GPU 에 올리고 그 안에서 가능한 한 끝까지 계산하는 패턴이 표준.

OOM 의 두 가지 의미

자바에서 OutOfMemoryError 는 JVM heap 이 꽉 찼다는 뜻이다. ML 서비스에서는 두 가지가 따로 있다.

  • 시스템 RAM OOM — 자바 OOM 과 동일. 프로세스가 죽거나 OS 가 OOM killer 로 죽인다.
  • GPU OOM — VRAM 부족. PyTorch 가 RuntimeError: CUDA out of memory 를 던진다. JVM GC 같은 자동 회수가 없어서 손으로 정리해야 한다.

JVM 에서는 GC 가 알아서 회수해주지만 PyTorch 는 더 명시적이다. del tensor 또는 torch.cuda.empty_cache() 같은 호출이 필요할 수 있다. 우리 프로젝트 코드의 clear_cuda_memory() 함수가 그 역할.

python
def clear_cuda_memory():
    gc.collect()
    if torch.cuda.is_available():
        torch.cuda.empty_cache()

자바의 System.gc() 와 비슷한 위치인데, ML 워크로드에서는 호출 빈도가 훨씬 잦다.

nvidia-smi — GPU 의 jstat·jmap

자바에서 JVM 상태를 보려고 jstat, jmap, jstack, JConsole 을 쓴다. GPU 는 nvidia-smi 한 명령으로 거의 모든 게 보인다.

bash
$ nvidia-smi
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 470.57.02   Driver Version: 470.57.02   CUDA Version: 11.4       |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  Tesla T4            Off  | 00000000:00:1B.0 Off |                    0 |
| N/A   48C    P0    27W /  70W |   4580MiB / 15360MiB |     64%      Default |
+-------------------------------+----------------------+----------------------+

핵심 지표:

  • Memory-Usage — VRAM 사용량 / 총 VRAM. 자바 heap 사용량과 같은 위치.
  • GPU-Util — GPU 코어 가동률. 자바 CPU 사용률과 같은 의미.
  • Temp / Pwr — 온도·전력. 자바 백엔드에서는 신경 안 쓰던 부분.
  • Compute M. — Default / Exclusive_Process / Exclusive_Thread 등 동작 모드.

스크립트로 뽑을 때는 --query-gpu 옵션이 편하다.

bash
nvidia-smi --query-gpu=memory.used,memory.total,utilization.gpu --format=csv
# memory.used [MiB], memory.total [MiB], utilization.gpu [%]
# 4580, 15360, 64

운영 중인 어느 PID 가 VRAM 을 점유하는지 보려면:

bash
nvidia-smi --query-compute-apps=pid,used_memory --format=csv
# pid, used_gpu_memory [MiB]
# 626719, 998 MiB
# 703689, 690 MiB

자바에서 jps 로 프로세스 확인하는 것과 같은 자리.

MPS — 같은 약어, 다른 두 가지 의미

MPS 라는 약어가 두 가지 다른 것을 가리킬 수 있다. 처음에 헷갈렸던 부분.

NVIDIA MPS (Multi-Process Service)

여러 프로세스가 같은 GPU 를 효율적으로 공유하기 위한 NVIDIA 의 서비스. 기본 모드에서는 각 프로세스가 GPU 에 접근할 때 자체 CUDA context 를 만든다 (~300-600MB VRAM 소비 + 컨텍스트 전환 비용). MPS 를 켜면 여러 프로세스가 같은 컨텍스트를 공유해 효율이 올라간다.

우리 프로젝트는 단일 T4 에 워커 3개 (KR=2, JA=1) 를 띄우는데, 이런 multi-process GPU 워크로드의 전형. ENABLE_CUDA_MPS=true 옵션으로 켤 수 있지만 현재 운영은 MPS=OFF. 다음 글에서 multi-process GPU 패턴을 자세히 다룬다.

Apple MPS (Metal Performance Shaders)

Apple Silicon (M1/M2/M3) 에서 GPU 가속을 제공하는 Apple 의 프레임워크. NVIDIA CUDA 와 완전히 별개의 스택.

python
import torch
print(torch.backends.mps.is_available())   # True on Apple Silicon
x = torch.randn(1000, 1000).to("mps")      # Apple GPU 사용

Mac M-series 에서 PyTorch 가 자동으로 Apple GPU 를 활용한다. 우리가 로컬 개발 환경을 Mac 에 세팅했을 때 torch.backends.mps.is_available() 가 True 로 나온 게 이 의미. 운영 환경의 NVIDIA T4 와는 다른 GPU 지만 PyTorch 코드는 거의 그대로 돌아간다 (성능 차이는 큼).

같은 약어가 같은 PyTorch 코드 안에 등장할 수 있다는 점 — torch.cuda.* 호출이 안 통할 때 torch.backends.mps.* 로 분기하는 패턴을 자주 본다.

JVM heap 과의 비교 — 명시적 자원 관리

자바 백엔드를 운영할 때 가장 신경 쓰는 게 JVM heap 튜닝 (-Xmx, -Xms, GC 알고리즘 선택) 이었다. GPU 워크로드는 그와 비슷하지만 차이가 있다.

항목자바 (JVM heap)Python (VRAM)
자동 회수GC없음 (수동 del, empty_cache)
최대 크기 지정-Xmx2g거의 없음 (PyTorch 가 자유 할당)
모니터링jstat, JMXnvidia-smi
OOM 동작OutOfMemoryError → 보통 프로세스 죽음RuntimeError → catch 가능, 다음 작업 계속
멀티 프로세스 공유OS 가 관리명시적 (CUDA context 또는 NVIDIA MPS)

큰 차이 한 가지: 자바는 JVM 안에서 모든 게 일어나서 OOM 이 나면 프로세스가 끝나지만, GPU OOM 은 try/except 로 잡고 텐서를 정리한 뒤 다음 요청을 처리할 수 있다. 우리가 분석한 코드의 clear_cuda_memory(force=True) 와 RAM threshold 기반 worker 재시작 패턴이 이 모델 위에 서 있다.

정리

자바 백엔드에서 ML 서비스로 넘어올 때 알아둘 한 줄.

CPU + 시스템 RAM 만 있던 그림에 GPU + VRAM 이라는 별도 컴퓨팅 평면이 추가된다. nvidia-smi 가 jstat 자리, .to("cuda") 가 데이터 전송, clear_cuda_memory() 가 수동 GC.

이걸 머릿속에 두면 다음 글들 — PyTorch 모델 로딩 비용, multi-process GPU 워커 패턴 — 이 자연스럽게 이어진다.

참고

  • NVIDIA CUDA Programming Guide
  • PyTorch CUDA Semantics
  • PyTorch MPS Backend (Apple Silicon)
  • NVIDIA Multi-Process Service
  • nvidia-smi documentation
on this page
  • 01GPU 는 CPU 와 어떻게 다른가
  • 02CUDA — NVIDIA GPU 의 프로그래밍 인터페이스
  • 03VRAM — GPU 전용 메모리
  • 04OOM 의 두 가지 의미
  • 05nvidia-smi — GPU 의 jstat·jmap
  • 06MPS — 같은 약어, 다른 두 가지 의미
  • NVIDIA MPS (Multi-Process Service)
  • Apple MPS (Metal Performance Shaders)
  • 07JVM heap 과의 비교 — 명시적 자원 관리
  • 08정리
  • 09참고

이런 글도

  • Python 서버의 RSS 가 안 줄어드는 이유 — gc.collect 의 한계와 malloc_trim
    Python 으로 long-running 서버 (FastAPI / Flask / Celery / uWSGI 등) 를 운영하다 보면 한 번쯤 마주치는 증상이 있다. - 워커 프로세스의 RSS 가 시간이 지날수록 단조 증가한다 - 큰 객체를 del 하고 gc.collect() 를 불러도 RSS 가 줄지 않는다 - 결국 max-requests / workerma...
    📁 system
    system
    2026.05.22
  • ML 서비스 성능 분석 워크플로 — 자바 백엔드 트러블슈팅과 다른 점
    이 시리즈의 마무리 글이다. 앞선 글들에서 다음 주제를 자바 백엔드 비교 관점으로 정리했다. - Python 문법 - 의존성 관리 - FastAPI - async/await - GPU·CUDA·MPS - PyTorch - multi-process worker pool - OCR 파이프라인 마지막은 이 모든 개념을 적용해 실제 ML 서비스의 성능을 분석하는...
    📁 system
    system
    2026.05.19
  • OCR 동작 원리 — Layout · Text · Post-process 3단계
    자바 백엔드만 다뤄오다가 OCR (Optical Character Recognition) 서비스를 분석할 일이 생겼다. "이미지에서 글자를 뽑는다" 라는 한 줄 요약은 알았지만, 실제 코드를 열어보면 모델이 둘이상이고, 여러 단계가 직렬·병렬로 엮여 있고, "왜 이 단계가 따로 있지" 같은 의문이 계속 생긴다. 이 글은 OCR 파이프라인의 표준 구조를 정리...
    📁 system
    system
    2026.05.19
  • Multi-process GPU 워크로드 — 자바 ThreadPool 사용자가 만나는 모델 차이
    자바 백엔드에서 ThreadPoolExecutor 는 거의 만능이었다. CPU bound 든 I/O bound 든 스레드 풀 크기만 잘 잡으면 동시성을 챙길 수 있었다. JVM 안에서 메모리를 공유하니 작업 간 데이터 전달도 가볍다. Python ML 서비스는 그림이 다르다. ThreadPoolExecutor 가 있지만 CPU/GPU 작업에서는 거의 안 쓰...
    📁 system
    system
    2026.05.19

댓글 (0)