💡 왼쪽 원문을 읽으면서 오른쪽에 따라 써보세요. Tab 키로 힌트를 받을 수 있습니다.

원문 렌더가 준비되기 전까지 텍스트 가이드로 표시합니다.

1. Slurm이란

**Slurm(Simple Linux Utility for Resource Management)**은 리눅스 클러스터를 위한 오픈소스, 내결함성, 고확장성 워크로드 매니저다. HPC(High-Performance Computing)와 AI 학습 인프라 세계의 **사실상 표준**이다.

1.1 핵심 기능 3가지

1. **리소스 할당**: 사용자에게 지정 시간 동안 컴퓨트 노드의 독점/공유 접근 부여

2. **작업 실행 프레임워크**: 할당된 노드에서 병렬 작업을 시작·실행·모니터링

3. **큐 관리**: 정교한 스케줄링 알고리즘으로 리소스 경합 조정

1.2 역사

| 연도 | 이벤트 |

| ------- | ------------------------------------------------------------ |

| 2002 | Lawrence Livermore National Laboratory(LLNL)에서 최초 릴리스 |

| 2010 | 핵심 개발자들이 **SchedMD** 설립 (상용 지원, 개발, 교육) |

| 2025.12 | **NVIDIA가 SchedMD 인수** — 오픈소스·벤더 중립 유지 약속 |

1.3 누가 쓰나

- **TOP500 슈퍼컴퓨터의 ~60-65%**가 Slurm 사용

- 대표 시스템: Frontier (Oak Ridge, #1), Perlmutter (NERSC), Polaris (Argonne)

- 클라우드: AWS ParallelCluster, Google Cloud HPC, Azure CycleCloud

- AI 기업: 대규모 LLM 학습, 이미지 생성 모델 학습

- 산업: 자율주행, 헬스케어, 에너지, 금융, 정부 연구소

**라이선스**: GNU GPL v2 (오픈소스)

2. 아키텍처

┌─────────────────────────────────────────────────────────────┐

│ Slurm Architecture │

│ │

│ ┌────────────────┐ ┌────────────────┐ │

│ │ slurmctld │ │ slurmctld │ │

│ │ (Primary) │◄──────►│ (Backup) │ │

│ │ Head Node │ HA │ Backup Node │ │

│ └───────┬────────┘ └────────────────┘ │

│ │ RPC (TCP) │

│ ┌───────┼──────────────────────────────────┐ │

│ │ ▼ ▼ ▼ │ │

│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │

│ │ │ slurmd │ │ slurmd │ │ slurmd │ │ Compute Nodes │

│ │ │ Node 01 │ │ Node 02 │ │ Node N │ │ │

│ │ └─────────┘ └─────────┘ └─────────┘ │ │

│ └──────────────────────────────────────────┘ │

│ │

│ ┌────────────────┐ ┌────────────────┐ │

│ │ slurmdbd │ │ slurmrestd │ │

│ │ (Database) │ │ (REST API) │ │

│ │ MySQL/MariaDB │ │ JSON / JWT │ │

│ └────────────────┘ └────────────────┘ │

└─────────────────────────────────────────────────────────────┘

2.1 데몬별 역할

| 데몬 | 역할 | 위치 |

| -------------- | ----------------------------------------------------- | ---------------- |

| **slurmctld** | 중앙 관리 (스케줄링, 리소스 모니터링, 작업 큐) | 헤드 노드 |

| **slurmd** | 태스크 실행, 리소스 사용 모니터링, 상태 보고 | 모든 컴퓨트 노드 |

| **slurmdbd** | 작업 회계, 히스토리, 사용 통계 (MySQL/MariaDB 백엔드) | DB 서버 |

| **slurmrestd** | HTTP RESTful API (JSON, JWT 인증) | API 서버 |

2.2 플러그인 아키텍처

Slurm은 확장 가능한 플러그인 아키텍처를 지원한다:

- 인증 (auth/munge, auth/jwt)

- 컨테이너 (OCI, Singularity, Enroot)

- GPU/GRES 관리

- MPI 구현 (PMIx, PMI2)

- 스케줄링 알고리즘 (backfill, priority multifactor)

- 프로세스 추적 (cgroup, linuxproc)

3. 핵심 개념

3.1 Node, Partition, Job

| 개념 | 설명 |

| ------------- | ----------------------------------------------------------------------- |

| **Node** | 기본 컴퓨트 리소스. CPU, 메모리, GPU, 디스크 속성 보유 |

| **Partition** | 노드의 논리적 그룹 = 작업 큐. 접근 제어, 리소스 한도, 우선순위 설정 |

| **Job** | 사용자에게 지정 시간 할당된 리소스. 고유 ID, 리소스 요구사항, 상태 보유 |

| **Job Step** | 작업 내의 병렬 태스크 집합. 별도 Job보다 오버헤드 적음 |

Job 1234

├── Step 0: 데이터 전처리 (1 노드)

├── Step 1: 학습 (4 노드, 32 태스크)

└── Step 2: 평가 (1 노드)

3.2 Account, QoS, Fairshare

**Account**: 리소스 사용 추적을 위한 계층적 조직 단위

root

├── engineering

│ ├── ml-team

│ └── platform-team

└── research

├── physics

└── biology

**QoS (Quality of Service)**: 작업 행동을 제어하는 한도와 우선순위 세트

1. 스케줄링 우선순위

2. 선점(Preemption) 정책

3. 리소스 한도 (CPU, GPU, 메모리, 실행 작업 수)

**Fairshare**: 역사적 리소스 사용을 고려한 공정 할당 스케줄링

- 각 계정에 투자/자격에 비례한 **share** 할당

- 적게 사용한 사용자 → 높은 우선순위, 많이 사용한 사용자 → 낮은 우선순위

- 최근 사용에 더 큰 가중치 (감쇠 인자)

3.3 우선순위 계산 (Multifactor)

Job Priority = site_factor

+ (WeightAge) × age_factor -- 대기 시간

+ (WeightFairshare) × fairshare_factor -- 공정 분배

+ (WeightJobSize) × job_size_factor -- 작업 크기

+ (WeightPartition) × partition_factor -- 파티션 등급

+ (WeightQOS) × QOS_factor -- QoS 등급

+ TRES weights -- GPU 등 자원 가중치

- nice_factor -- 사용자 양보값

4. 필수 명령어

4.1 sbatch — 배치 작업 제출

기본 제출

sbatch job.sh

옵션 오버라이드

sbatch --partition=gpu --nodes=2 --gres=gpu:4 --time=24:00:00 train.sh

작업 이름과 출력 지정

sbatch --job-name=my_training --output=train_%j.log job.sh

특정 계정과 QoS

sbatch --account=ml-team --qos=high job.sh

4.2 srun — 병렬 작업/스텝 실행

3개 노드에서 호스트명 출력

srun -N3 -l /bin/hostname

인터랙티브 GPU 작업

srun --partition=gpu --gres=gpu:1 --pty bash

GPU 바인딩으로 실행

srun --ntasks=4 --gpus-per-task=1 --gpu-bind=closest python train.py

4.3 salloc — 리소스 인터랙티브 할당

GPU 노드 2개, 4시간 할당

salloc --nodes=2 --gres=gpu:4 --time=04:00:00 --partition=gpu

특정 기능 요구

salloc -N1 --constraint=a100 --gres=gpu:8 --mem=512G

4.4 squeue — 작업 큐 조회

내 작업만 표시

squeue -u $USER

커스텀 포맷

squeue -o "%.10i %.9P %.20j %.8u %.2t %.10M %.6D %R"

PENDING 작업과 이유 표시

squeue -t PENDING -o "%.10i %.20j %.8u %.10M %R"

4.5 sinfo — 시스템 정보 조회

파티션 요약

sinfo

GPU 리소스 표시

sinfo -o "%20N %10c %10m %20G %10t"

유휴 노드

sinfo -t idle

4.6 scancel — 작업 취소

scancel 12345 # 특정 작업 취소

scancel -u $USER # 내 작업 전부 취소

scancel -t PENDING -u $USER # PENDING 작업만 취소

scancel 12345_[1-10] # 특정 Array 태스크 취소

4.7 sacct — 작업 회계

완료된 작업 조회

sacct -u $USER

상세 포맷

sacct -j 12345 --format=JobID,JobName,Partition,State,Elapsed,MaxRSS,MaxVMSize,TotalCPU

날짜 범위 조회

sacct --starttime=2026-01-01 --endtime=2026-01-31 -u $USER

4.8 scontrol — 관리 제어

scontrol show job 12345 # 작업 상세 정보

scontrol show node gpu-001 # 노드 상세 정보

scontrol hold 12345 # 작업 보류

scontrol release 12345 # 보류 해제

scontrol update JobId=12345 TimeLimit=48:00:00 # 시간 변경

scontrol ping # 컨트롤러 연결 테스트

5. 작업 스크립트 예제

5.1 기본 CPU 작업

#!/bin/bash

#SBATCH --job-name=basic_job

#SBATCH --partition=compute

#SBATCH --nodes=1

#SBATCH --ntasks=4

#SBATCH --cpus-per-task=2

#SBATCH --mem=16G

#SBATCH --time=02:00:00

#SBATCH --output=output_%j.log

#SBATCH --error=error_%j.log

module load gcc/12.2.0

module load openmpi/4.1.5

echo "Job started on $(hostname) at $(date)"

echo "SLURM_JOB_ID: $SLURM_JOB_ID"

echo "SLURM_NODELIST: $SLURM_NODELIST"

srun ./my_simulation --input data.csv --output results/

echo "Job completed at $(date)"

5.2 단일 노드 GPU 작업

#!/bin/bash

#SBATCH --job-name=gpu_training

#SBATCH --partition=gpu

#SBATCH --nodes=1

#SBATCH --ntasks=1

#SBATCH --cpus-per-task=8

#SBATCH --mem=64G

#SBATCH --gres=gpu:a100:2

#SBATCH --time=12:00:00

#SBATCH --output=train_%j.log

module load cuda/12.2

module load anaconda/2024

conda activate ml_env

echo "Available GPUs: $CUDA_VISIBLE_DEVICES"

nvidia-smi

python train.py \

--model resnet50 \

--batch-size 256 \

--epochs 100 \

--data /shared/datasets/imagenet \

--output /scratch/$USER/checkpoints/

5.3 다중 노드 MPI 작업

#!/bin/bash

#SBATCH --job-name=mpi_job

#SBATCH --partition=compute

#SBATCH --nodes=8

#SBATCH --ntasks-per-node=32

#SBATCH --cpus-per-task=1

#SBATCH --mem-per-cpu=4G

#SBATCH --time=24:00:00

#SBATCH --exclusive

module load openmpi/4.1.5

echo "Running on $SLURM_NNODES nodes with $SLURM_NTASKS total tasks"

srun ./weather_simulation --grid-size 4096x4096x128 --timesteps 10000

5.4 Job Array (하이퍼파라미터 스윕)

#!/bin/bash

#SBATCH --job-name=hparam_sweep

#SBATCH --partition=gpu

#SBATCH --array=0-19%5 # 20개 태스크, 최대 5개 동시 실행

#SBATCH --nodes=1

#SBATCH --gres=gpu:1

#SBATCH --mem=32G

#SBATCH --time=06:00:00

#SBATCH --output=sweep_%A_%a.log # %A=Array ID, %a=Task ID

LEARNING_RATES=(0.1 0.01 0.001 0.0001 0.00001)

BATCH_SIZES=(32 64 128 256)

LR_IDX=$((SLURM_ARRAY_TASK_ID / 4))

BS_IDX=$((SLURM_ARRAY_TASK_ID % 4))

LR=${LEARNING_RATES[$LR_IDX]}

BS=${BATCH_SIZES[$BS_IDX]}

echo "Task $SLURM_ARRAY_TASK_ID: LR=$LR, BS=$BS"

python train.py --lr $LR --batch-size $BS \

--experiment-name "sweep_${SLURM_ARRAY_JOB_ID}_${SLURM_ARRAY_TASK_ID}"

5.5 Job Dependencies (파이프라인)

Step 1: 전처리

JOB1=$(sbatch --parsable preprocess.sh)

Step 2: 학습 (전처리 성공 후)

JOB2=$(sbatch --parsable --dependency=afterok:$JOB1 train.sh)

Step 3: 평가 (학습 성공 후)

JOB3=$(sbatch --parsable --dependency=afterok:$JOB2 evaluate.sh)

Step 4: 정리 (전부 완료 후, 성공/실패 무관)

JOB4=$(sbatch --parsable --dependency=afterany:$JOB1:$JOB2:$JOB3 cleanup.sh)

**의존성 타입:**

| 타입 | 의미 |

| ------------------ | ------------------------------- |

| `after:jobid` | 작업 시작 후 |

| `afterok:jobid` | 작업 성공 완료 후 |

| `afternotok:jobid` | 작업 실패 후 |

| `afterany:jobid` | 작업 완료 후 (성공/실패 무관) |

| `aftercorr:jobid` | Array: 대응하는 태스크 성공 후 |

| `singleton` | 같은 이름의 작업이 동시에 1개만 |

6. GPU 스케줄링 (GRES)

6.1 설정

**slurm.conf:**

GresTypes=gpu,mps,shard

NodeName=gpu-node[01-08] Gres=gpu:a100:8 CPUs=128 RealMemory=1024000

AccountingStorageTres=gres/gpu

**gres.conf:**

자동 감지 (권장)

AutoDetect=nvml # NVIDIA

AutoDetect=rsmi # AMD

AutoDetect=nrt # Intel Arc

6.2 GPU 요청 방법

아무 타입 GPU 2개

sbatch --gres=gpu:2 job.sh

특정 GPU 타입

sbatch --gres=gpu:a100:4 job.sh

노드당 GPU

sbatch --nodes=4 --gpus-per-node=8 job.sh

태스크당 GPU + CPU/메모리 어피니티

sbatch --ntasks=8 --gpus-per-task=1 --cpus-per-gpu=8 --mem-per-gpu=32G job.sh

Slurm은 GPU 격리를 위해 `CUDA_VISIBLE_DEVICES`를 자동 설정한다.

6.3 GPU 공유 옵션

| 방법 | 설명 | 설정 |

| ------------------------------- | -------------------------------------- | ----------------------------- |

| **MPS** (Multi-Process Service) | 다중 프로세스 GPU 공유, 커널 병렬 실행 | `Gres=gpu:a100:8,mps:800` |

| **MIG** (Multi-Instance GPU) | A100/H100을 독립 인스턴스로 분할 | `AutoDetect=nvml` (자동 감지) |

| **Shard** | 격리 없는 GPU 공유 (경량 추론) | `Gres=gpu:2,shard:64` |

7. AI/ML 분산 학습

7.1 PyTorch DDP (다중 노드)

**sbatch 스크립트 (4노드 × 8GPU = 32GPU):**

#!/bin/bash

#SBATCH --job-name=ddp-multigpu

#SBATCH --partition=gpu

#SBATCH --nodes=4

#SBATCH --ntasks-per-node=1

#SBATCH --gres=gpu:8

#SBATCH --cpus-per-task=64

#SBATCH --mem=0

#SBATCH --exclusive

#SBATCH --time=72:00:00

#SBATCH --output=ddp_%j.log

export MASTER_PORT=$(( RANDOM % (50000 - 30000 + 1) + 30000 ))

export MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)

export WORLD_SIZE=$(( SLURM_NNODES * 8 ))

echo "MASTER_ADDR=$MASTER_ADDR, MASTER_PORT=$MASTER_PORT, WORLD_SIZE=$WORLD_SIZE"

NCCL 설정

export NCCL_DEBUG=INFO

export NCCL_SOCKET_IFNAME=^docker0,lo

srun torchrun \

--nnodes $SLURM_NNODES \

--nproc_per_node 8 \

--rdzv_id $SLURM_JOB_ID \

--rdzv_backend c10d \

--rdzv_endpoint $MASTER_ADDR:$MASTER_PORT \

train.py \

--model llama-7b \

--data /shared/datasets/openwebtext \

--batch-size 32 \

--gradient-accumulation-steps 4

**Python 학습 스크립트 패턴:**

from torch.nn.parallel import DistributedDataParallel as DDP

from torch.utils.data.distributed import DistributedSampler

def setup():

dist.init_process_group(backend="nccl")

rank = dist.get_rank()

world_size = dist.get_world_size()

local_rank = int(os.environ["LOCAL_RANK"])

torch.cuda.set_device(local_rank)

return rank, world_size, local_rank

def main():

rank, world_size, local_rank = setup()

model = MyModel().cuda(local_rank)

model = DDP(model, device_ids=[local_rank])

dataset = MyDataset(...)

sampler = DistributedSampler(dataset, num_replicas=world_size, rank=rank)

dataloader = DataLoader(dataset, sampler=sampler, batch_size=32)

for epoch in range(num_epochs):

sampler.set_epoch(epoch) # 셔플링에 필수

for batch in dataloader:

...

dist.destroy_process_group()

7.2 DeepSpeed (다중 노드)

#!/bin/bash

#SBATCH --job-name=deepspeed-train

#SBATCH --partition=gpu

#SBATCH --nodes=4

#SBATCH --ntasks-per-node=1

#SBATCH --gres=gpu:8

#SBATCH --cpus-per-task=64

#SBATCH --mem=0

#SBATCH --exclusive

#SBATCH --time=96:00:00

export MASTER_ADDR=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1)

export MASTER_PORT=$(( RANDOM % (50000 - 30000 + 1) + 30000 ))

export NNODES=$SLURM_NNODES

export NUM_PROCESSES=$(( NNODES * 8 ))

srun bash -c 'accelerate launch \

--main_process_ip $MASTER_ADDR \

--main_process_port $MASTER_PORT \

--machine_rank $SLURM_NODEID \

--num_processes $NUM_PROCESSES \

--num_machines $NNODES \

--use_deepspeed \

--zero_stage 2 \

--mixed_precision fp16 \

train.py \

--model_name_or_path meta-llama/Llama-2-7b \

--per_device_train_batch_size 4 \

--gradient_accumulation_steps 8'

7.3 Horovod (MPI 기반)

#!/bin/bash

#SBATCH --job-name=horovod-train

#SBATCH --nodes=4

#SBATCH --ntasks-per-node=4

#SBATCH --gres=gpu:4

module load openmpi/4.1.5 cuda/12.2

srun --mpi=pmix python train_horovod.py --epochs 100 --batch-size 64

8. 컨테이너 통합

8.1 Singularity / Apptainer

#!/bin/bash

#SBATCH --job-name=container_job

#SBATCH --gres=gpu:1

#SBATCH --time=04:00:00

--nv 플래그로 GPU 지원

srun singularity exec --nv \

--bind /scratch/$USER:/data \

--bind /shared/datasets:/datasets \

/shared/containers/pytorch_24.03.sif \

python train.py --data /datasets/imagenet

8.2 Enroot + Pyxis (NVIDIA)

**Enroot**는 NVIDIA의 경량 컨테이너 런타임, **Pyxis**는 Slurm SPANK 플러그인으로 `srun --container-*` 플래그를 제공한다.

#!/bin/bash

#SBATCH --nodes=4

#SBATCH --ntasks-per-node=8

#SBATCH --gres=gpu:8

#SBATCH --exclusive

srun --container-image=nvcr.io/nvidia/pytorch:24.03-py3 \

--container-mounts=/shared/data:/data,/scratch/$USER:/workspace \

--container-workdir=/workspace \

torchrun \

--nnodes=$SLURM_NNODES \

--nproc_per_node=8 \

--rdzv_backend=c10d \

--rdzv_endpoint=$(scontrol show hostnames $SLURM_JOB_NODELIST | head -n 1):29500 \

train.py --data /data

NVIDIA DGX SuperPOD과 DGX Cloud에서 광범위하게 사용된다.

9. 설정 (slurm.conf)

9.1 핵심 설정 파라미터

클러스터 식별

ClusterName=my_cluster

SlurmctldHost=controller01

SlurmctldHost=controller02 # 백업 컨트롤러

인증

AuthType=auth/munge

스케줄링

SchedulerType=sched/backfill

SelectType=select/cons_tres # 추적 가능한 소비형 리소스

SelectTypeParameters=CR_Core_Memory

PriorityType=priority/multifactor

PriorityWeightAge=1000

PriorityWeightFairshare=10000

PriorityWeightJobSize=500

PriorityWeightQOS=2000

PriorityDecayHalfLife=7-0 # 7일

리소스 관리

ProctrackType=proctrack/cgroup

TaskPlugin=task/cgroup,task/affinity

GresTypes=gpu,mps,shard

회계

AccountingStorageType=accounting_storage/slurmdbd

AccountingStorageTres=gres/gpu

작업 기본값

DefMemPerCPU=4096 # 4GB

MaxMemPerCPU=16384 # 16GB

DisableRootJobs=YES

MpiDefault=pmix_v4

노드 정의

NodeName=compute[001-100] CPUs=64 RealMemory=256000 State=UNKNOWN

NodeName=gpu[001-032] CPUs=128 RealMemory=1024000 Gres=gpu:a100:8 Feature=a100,nvlink

파티션 정의

PartitionName=compute Nodes=compute[001-100] Default=YES MaxTime=7-00:00:00

PartitionName=gpu Nodes=gpu[001-032] MaxTime=3-00:00:00 AllowGroups=gpu-users

PartitionName=debug Nodes=compute[001-004],gpu[001-002] MaxTime=01:00:00 PriorityTier=100

9.2 cgroup.conf

ConstrainCores=yes # CPU 코어 핀닝

ConstrainRAMSpace=yes # 메모리 한도 강제

AllowedRAMSpace=100 # 할당 메모리의 % (초과 시 OOM Kill)

ConstrainSwapSpace=yes

ConstrainDevices=yes # 디바이스 격리 (GPU)

10. 고급 기능

10.1 Backfill 스케줄링

Slurm의 보조 스케줄링 루프. **짧은 저우선순위 작업**이 긴 고우선순위 작업을 지연시키지 않는 한 먼저 실행되도록 허용한다.

SchedulerType=sched/backfill

SchedulerParameters=bf_interval=30,bf_resolution=300,bf_max_job_test=1200

효과적으로 작동하려면 **작업 시간 한도(`--time`)가 필수**다.

10.2 Preemption (선점)

slurm.conf

PreemptType=preempt/qos

PreemptMode=REQUEUE # CANCEL, REQUEUE, SUSPEND, GANG

PreemptExemptTime=00:05:00 # 선점 전 유예 시간

| 모드 | 동작 |

| ------- | ---------------------------- |

| CANCEL | 저우선순위 작업 종료 |

| REQUEUE | 가능하면 재큐, 불가하면 취소 |

| SUSPEND | 작업 일시 중지 |

| GANG | 시분할 공유 |

10.3 Job Array 대규모 제출

1000개 태스크, 최대 50개 동시 실행

sbatch --array=0-999%50 sweep.sh

환경변수: SLURM_ARRAY_JOB_ID, SLURM_ARRAY_TASK_ID

MaxArraySize: 최대 4,000,001 (설정 가능)

11. 모니터링 및 트러블슈팅

11.1 진단 명령어

scontrol ping # 컨트롤러 연결 테스트

sdiag # 스케줄러 진단 (스레드, 큐, 백필 사이클)

scontrol show node X # 노드 상태 확인

sacct -j ID --format=JobID,Elapsed,TotalCPU,ReqMem,MaxRSS,State # 작업 효율

11.2 일반적인 문제와 해결

| 문제 | 진단 | 해결 |

| ---------------- | ------------------------------------ | ------------------------------------------------------ |

| 노드 DRAIN | `scontrol show node` | 문제 수정 후 `scontrol update NodeName=X State=RESUME` |

| 작업 PENDING | `squeue -j ID -o "%R"` (Reason 확인) | 리소스, 파티션 한도, QoS, 의존성 확인 |

| GPU 미감지 | `slurmd -C`, `slurmd -G` | 드라이버, gres.conf AutoDetect, 디바이스 파일 확인 |

| OOM Kill | `sacct --format=MaxRSS,ReqMem` | 더 많은 메모리 요청 또는 cgroup 한도 조정 |

| slurmctld 과부하 | `sdiag` (스레드 수) | RPC rate limiting, 폴링 빈도 감소 |

11.3 일반적인 PENDING 사유

| 사유 | 의미 |

| ---------------------- | --------------------------------- |

| Resources | 리소스 대기 중 |

| Priority | 더 높은 우선순위 작업이 앞에 있음 |

| Dependency | 의존 작업 완료 대기 |

| QOSMaxJobsPerUserLimit | QoS 작업 수 한도 도달 |

| PartitionTimeLimit | 요청 시간이 파티션 한도 초과 |

| ReqNodeNotAvail | 요청 노드 사용 불가 |

12. 다른 스케줄러와 비교

| ----------- | ----------------------- | -------------------- | ---------------- | ----------------------- |

| 확장성 | **100K+ 노드** | 50K+ | 100K+ | 5K+ |

| Fairshare | 내장 | Maui/Moab 필요 | 내장 | 미내장 |

| TOP500 채택 | **~60-65%** | ~10-15% | ~10-15% | 드묾 |

**트렌드**: Slurm(학습) + Kubernetes(추론/서빙) 하이브리드 구성이 주류

13. References

공식 문서

1. [Slurm 공식 문서](https://slurm.schedmd.com/) — 모든 기능의 기준 레퍼런스

2. [Quick Start User Guide](https://slurm.schedmd.com/quickstart.html)

3. [Quick Start Admin Guide](https://slurm.schedmd.com/quickstart_admin.html)

4. [Slurm GRES Scheduling](https://slurm.schedmd.com/gres.html)

5. [Slurm Job Array](https://slurm.schedmd.com/job_array.html)

6. [Slurm Containers Guide](https://slurm.schedmd.com/containers.html)

7. [Slurm Configuration Tool](https://slurm.schedmd.com/configurator.html) — 웹 기반 slurm.conf 생성기

8. [Slurm Rosetta Stone (PDF)](https://slurm.schedmd.com/rosetta.pdf) — PBS/LSF/SGE 명령어 대조표

9. [GitHub: SchedMD/slurm](https://github.com/SchedMD/slurm)

AI/ML 분산 학습

10. [PyTorch DDP Multi-Node Slurm Examples](https://github.com/pytorch/examples/tree/main/distributed/ddp-tutorial-series/slurm)

11. [PyTorch Multi-Node Training Tutorial](https://docs.pytorch.org/tutorials/intermediate/ddp_series_multinode.html)

12. [NVIDIA DGX Cloud DeepSpeed Examples](https://docs.nvidia.com/dgx-cloud/workload-examples/latest/deepspeed.html)

13. [Multi-Node Training on Slurm (GitHub Gist)](https://gist.github.com/TengdaHan/1dd10d335c7ca6f13810fff41e809904)

컨테이너

14. [NVIDIA Pyxis GitHub](https://github.com/NVIDIA/pyxis)

15. [AWS ParallelCluster Pyxis Tutorial](https://docs.aws.amazon.com/parallelcluster/latest/ug/tutorials_11_running-containerized-jobs-with-pyxis.html)

튜토리얼

16. [LLNL Slurm Quick Start Guide](https://hpc.llnl.gov/banks-jobs/running-jobs/slurm-quick-start-guide)

17. [Princeton Slurm Resources](https://researchcomputing.princeton.edu/education/external-online-resources/slurm)

18. [NERSC Training Libraries Documentation](https://docs.nersc.gov/machinelearning/training/)

19. [Nebius Slurm Blog](https://nebius.com/blog/posts/slurm-workload-manager)

20. [NVIDIA Acquires SchedMD](https://blogs.nvidia.com/blog/nvidia-acquires-schedmd/)