Skip to content
Published on

Slurm 완전 정복: HPC/AI 클러스터 워크로드 매니저 실전 가이드

Authors
  • Name
    Twitter

1. Slurm이란

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

1.1 핵심 기능 3가지

  1. 리소스 할당: 사용자에게 지정 시간 동안 컴퓨트 노드의 독점/공유 접근 부여
  2. 작업 실행 프레임워크: 할당된 노드에서 병렬 작업을 시작·실행·모니터링
  3. 큐 관리: 정교한 스케줄링 알고리즘으로 리소스 경합 조정

1.2 역사

연도이벤트
2002Lawrence Livermore National Laboratory(LLNL)에서 최초 릴리스
2010핵심 개발자들이 SchedMD 설립 (상용 지원, 개발, 교육)
2025.12NVIDIA가 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 서버
slurmrestdHTTP 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:jobidArray: 대응하는 태스크 성공 후
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 학습 스크립트 패턴:

import os
import torch
import torch.distributed as dist
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 일반적인 문제와 해결

문제진단해결
노드 DRAINscontrol show node문제 수정 후 scontrol update NodeName=X State=RESUME
작업 PENDINGsqueue -j ID -o "%R" (Reason 확인)리소스, 파티션 한도, QoS, 의존성 확인
GPU 미감지slurmd -C, slurmd -G드라이버, gres.conf AutoDetect, 디바이스 파일 확인
OOM Killsacct --format=MaxRSS,ReqMem더 많은 메모리 요청 또는 cgroup 한도 조정
slurmctld 과부하sdiag (스레드 수)RPC rate limiting, 폴링 빈도 감소

11.3 일반적인 PENDING 사유

사유의미
Resources리소스 대기 중
Priority더 높은 우선순위 작업이 앞에 있음
Dependency의존 작업 완료 대기
QOSMaxJobsPerUserLimitQoS 작업 수 한도 도달
PartitionTimeLimit요청 시간이 파티션 한도 초과
ReqNodeNotAvail요청 노드 사용 불가

12. 다른 스케줄러와 비교

특성SlurmPBS Pro / TorqueIBM LSFKubernetes
라이선스GPL v2 (오픈소스)AGPL / 상용상용 (IBM)Apache 2.0
주요 용도HPC, AI 학습HPC, 전통 배치엔터프라이즈 HPC클라우드 마이크로서비스
확장성100K+ 노드50K+100K+5K+
GPU 지원네이티브 GRES, MIG, MPS훅 기반GPU-awareDevice Plugin
MPI 지원네이티브 (PMIx)네이티브네이티브MPI Operator
Fairshare내장Maui/Moab 필요내장미내장
TOP500 채택~60-65%~10-15%~10-15%드묾

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

13. References

공식 문서

  1. Slurm 공식 문서 — 모든 기능의 기준 레퍼런스
  2. Quick Start User Guide
  3. Quick Start Admin Guide
  4. Slurm GRES Scheduling
  5. Slurm Job Array
  6. Slurm Containers Guide
  7. Slurm Configuration Tool — 웹 기반 slurm.conf 생성기
  8. Slurm Rosetta Stone (PDF) — PBS/LSF/SGE 명령어 대조표
  9. GitHub: SchedMD/slurm

AI/ML 분산 학습

  1. PyTorch DDP Multi-Node Slurm Examples
  2. PyTorch Multi-Node Training Tutorial
  3. NVIDIA DGX Cloud DeepSpeed Examples
  4. Multi-Node Training on Slurm (GitHub Gist)

컨테이너

  1. NVIDIA Pyxis GitHub
  2. AWS ParallelCluster Pyxis Tutorial

튜토리얼

  1. LLNL Slurm Quick Start Guide
  2. Princeton Slurm Resources
  3. NERSC Training Libraries Documentation
  4. Nebius Slurm Blog
  5. NVIDIA Acquires SchedMD
Discuss on Twitter • View on GitHub