Halo, Sobat Kampus dan pencinta AI! Buat kalian yang lagi sibuk riset skripsi, bereksperimen dengan model Large Language Model (LLM) ukuran jumbo seperti DeepSeek-R1, atau sekadar penasaran dengan cara kerja kluster GPU skala besar, kalian berada di artikel yang tepat. Kali ini kita bakal bedah tuntas framework keren dari NVIDIA, yaitu srt-slurm, yang dirancang khusus buat bikin workflow benchmark sistem distributed LLM serving jadi jauh lebih gampang, terstruktur, dan pastinya reproducible!

Di dunia riset Artificial Intelligence modern, menjalankan model bahasa besar secara terdistribusi di atas kluster GPU bukanlah hal yang sepele. Dibutuhkan konfigurasi yang presisi, mulai dari manajemen memori KV-cache, pengaturan tensor-parallel-size, hingga pemisahan tugas (disaggregated deployment) antara fase prefill dan decode. Untungnya, framework srt-slurm hadir dengan command-line interface bernama srtctl yang siap mengubah file konfigurasi YAML deklaratif menjadi skrip SLURM siap pakai tanpa bikin kepala pusing.

Mengenal Arsitektur Repository dan Persiapan Lingkungan Kerja

Sebelum kita terjun lebih jauh ke konfigurasi kluster, penting banget buat tahu bagaimana isi perut dari repository srt-slurm ini. Bayangkan struktur folder ini sebagai peta harta karun yang bakal ngebantu kita memahami komponen-komponen utamanya:

  • src/srtctl/cli/: Berisi modul untuk menjalankan perintah submit, dry-run, preflight, monitor, hingga mode interaktif.
  • src/srtctl/core/: Inti logika seperti skema tipe data, engine sweep, generator skrip sbatch SLURM, validasi, health check, topology, dan fingerprint.
  • src/srtctl/backends/: Berbagai engine adapter seperti sglang, trtllm, vllm, dan mocker untuk pengujian.
  • recipes/: Kumpulan resep siap pakai untuk berbagai platform GPU seperti GB200, H100, B200, serta model populer termasuk Qwen dan DeepSeek.
  • analysis/: Alat parser log (srtlog) dan dashboard berbasis Streamlit buat visualisasi Pareto frontier.

Meskipun kita biasanya butuh kluster GPU fisik yang mahal buat ngejalanin SLURM, tenang aja! Kita bisa pakai Google Colab sebagai workspace praktis buat belajar, nyobain kode, dan memvalidasi resep benchmark sebelum benar-benar di-deploy ke server kampus atau enterprise.

Berikut adalah potongan kode dasar untuk menginstal srt-slurm dan memverifikasi CLI srtctl langsung dari environment Colab kalian:

import os, sys, subprocess, textwrap, json, shutil, importlib
from pathlib import Path

def run(cmd, check=True, quiet=False):
    print(f"\n$ {cmd}")
    r = subprocess.run(cmd, shell=True, text=True, capture_output=True)
    out = (r.stdout or "") + (r.stderr or "")
    if not quiet:
        print(out[-6000:])
    if check and r.returncode != 0:
        raise RuntimeError(f"Command failed ({r.returncode}): {cmd}")
    return out

REPO = Path("/content/srt-slurm") if Path("/content").exists() else Path.cwd()/"srt-slurm"
if not REPO.exists():
    run(f"git clone --depth 1 https://github.com/NVIDIA/srt-slurm.git {REPO}", quiet=True)

run(f"{sys.executable} -m pip install -q -e {REPO}", quiet=True)
sys.path.insert(0, str(REPO / "src"))
importlib.invalidate_caches()
os.chdir(REPO)
run("srtctl --help")

Mengonfigurasi Kluster Simulasi dan Resep Disaggregated

Langkah selanjutnya adalah mendefinisikan file konfigurasi kluster tiruan bernama srtslurm.yaml. File ini berfungsi sebagai cetak biru (blueprint) yang mendefinisikan nama kluster, akun default, partisi GPU, pembatasan waktu, hingga path kontainer dan direktori model. Di lingkungan kampus, file konfigurasi ini bisa disesuaikan dengan spesifikasi supercomputer lab riset kalian.

Selain itu, buat kalian yang lagi mendalami model canggih seperti DeepSeek-R1, kita bisa membuat resep disaggregated deployment (pemisahan prefill dan decode) agar penggunaan memori GPU jadi jauh lebih efisien. Berikut adalah contoh penulisan kodenya di dalam file konfigurasi kustom:

name: "colab-disagg-demo"
model:
  path: "deepseek-r1"
  container: "lmsysorg+sglang+v0.5.5.post2.sqsh"
  precision: "fp8"
resources:
  gpu_type: "gb200"
  gpus_per_node: 4
  prefill_nodes: 1
  decode_nodes: 2
  prefill_workers: 1
  decode_workers: 2
backend:
  prefill_environment: { PYTHONUNBUFFERED: "1" }
  decode_environment:  { PYTHONUNBUFFERED: "1" }
  sglang_config:
    prefill:
      served-model-name: "deepseek-ai/DeepSeek-R1"
      model-path: "/model/"
      trust-remote-code: true
      kv-cache-dtype: "fp8_e4m3"
      tensor-parallel-size: 4
      disaggregation-mode: "prefill"
    decode:
      served-model-name: "deepseek-ai/DeepSeek-R1"
      model-path: "/model/"
      trust-remote-code: true
      kv-cache-dtype: "fp8_e4m3"
      tensor-parallel-size: 4
      disaggregation-mode: "decode"
benchmark:
  type: "sa-bench"
  isl: 1024
  osl: 1024
  concurrencies: [64, 128, 256]
  req_rate: "inf"

Parameter Sweeps dan Analisis Pareto Frontier

Pernahkah kalian bertanya-tanya, bagaimana cara para insinyur AI mencari kombinasi parameter terbaik antara kecepatan throughput dan latensi? Jawabannya adalah menggunakan Parameter Sweeps (pencarian grid Cartesian). Dengan srtctl, kita bisa memperluas satu skrip resep menjadi puluhan kombinasi job otomatis.

Setelah simulasi benchmark berjalan dan menghasilkan data performa, saatnya kita melakukan analisis menggunakan grafik Pareto frontier. Grafik ini sangat berguna buat melihat titik optimal antara throughput (berapa banyak token yang bisa diproses per detik per GPU) dan inter-token latency (seberapa cepat respons teks muncul ke layar pengguna). Berikut adalah cuplikan kode Python untuk memodelkan dan memvisualisasikan hasil benchmark tersebut:

import numpy as np, matplotlib.pyplot as plt

rng = np.random.default_rng(0)

def simulate(variant, base_tps, base_itl):
    rows = []
    for c in [16, 32, 64, 128, 256]:
        tps_gpu = base_tps * c / (c + 90) * rng.uniform(.97, 1.03)
        itl     = base_itl * (1 + c/220) * rng.uniform(.97, 1.03)
        rows.append({"variant": variant, "concurrency":
                     c, "tok_s_gpu": tps_gpu, "itl_ms": itl})
    return rows

results = simulate("chunked=4096", 260, 9.5) + simulate("chunked=8192", 300, 11.5)

plt.figure(figsize=(8, 5))
for variant in ("chunked=4096", "chunked=8192"):
    pts = [(r["itl_ms"], r["tok_s_gpu"], r["concurrency"])
           for r in results if r["variant"] == variant]
    xs, ys, cs = zip(*pts)
    plt.plot(xs, ys, "o-", label=variant)
    for x, y, c in pts:
        plt.annotate(str(c), (x, y), fontsize=7, xytext=(3, 3), textcoords="offset points")

plt.xlabel("Inter-token latency (ms/token)  →  worse")
plt.ylabel("Throughput (tokens/s/GPU)  →  better")
plt.title("Pareto frontier: sweep variants (points labeled by concurrency)")
plt.legend(); plt.grid(alpha=.3); plt.tight_layout(); plt.show()

Dengan menguasai alur kerja ini di ruang pengembangan lokal seperti Colab, kalian sudah selangkah lebih maju untuk memindahkan resep validasi tersebut ke kluster GPU produksi sesungguhnya menggunakan perintah preflight dan apply SLURM!

Yuk, persiapkan portofolio riset AI terbaikmu sekarang juga! Dunia industri dan riset komputasi performa tinggi (HPC) sangat mendambakan talenta muda yang paham cara mengoptimalkan model besar secara efisien. Jangan ragu buat eksplorasi kode ini, oprek konfigurasinya, dan buktikan kemampuan terbaikmu di kancah teknologi global!