Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
1 change: 1 addition & 0 deletions slime/__init__.py
Original file line number Diff line number Diff line change
@@ -0,0 +1 @@
"""Compatibility namespace for external code that still imports ``slime``."""
1 change: 1 addition & 0 deletions slime/utils/__init__.py
Original file line number Diff line number Diff line change
@@ -0,0 +1 @@
"""Compatibility shims for legacy ``slime.utils`` imports."""
3 changes: 3 additions & 0 deletions slime/utils/routing_replay.py
Original file line number Diff line number Diff line change
@@ -0,0 +1,3 @@
"""Forward legacy routing replay imports to Vime."""

from vime.utils.routing_replay import * # noqa: F403
232 changes: 232 additions & 0 deletions tests/test_qwen3_30B_A3B_deepep.py
Original file line number Diff line number Diff line change
@@ -0,0 +1,232 @@
"""
Task 2 - DP + EP with DeepEP comm kernel (Qwen3-30B-A3B) P1.

Validates that Qwen3-30B-A3B trains stably with the DeepEP all-to-all
backend in vLLM across two parallel layouts and two dispatcher phases.

Layouts (selected via SLIME_TEST_DEEPEP_LAYOUT):
production TP=4 CP=2 DP=1 EP=8 production layout from test_qwen3_30B_A3B.py
dp TP=4 CP=1 DP=2 EP=8 adds data parallelism (DP=2) on top of EP=8

Phases (selected via SLIME_TEST_DEEPEP_PHASE):
alltoall --moe-token-dispatcher-type alltoall
deepep --moe-token-dispatcher-type flex --moe-enable-deepep
--vllm-all2all-backend deepep_high_throughput

Full matrix (default LAYOUT=both PHASE=both) is 4 runs:
L1 x alltoall, L1 x deepep, L2 x alltoall, L2 x deepep

Acceptance (per issue #11 Task 2), applied PER LAYOUT (within-layout A/B):
- Both phases complete >= 3 rollouts without NCCL / HTTP-400 / OOM errors.
- DeepEP reward within 10% of alltoall reward (same layout, same rollout).
- DeepEP step time <= 115% of alltoall step time (same layout).
Cross-layout comparisons (e.g. L2 step time vs L1 step time) are NOT in scope.

Usage:
python tests/test_qwen3_30B_A3B_deepep.py
SLIME_TEST_DEEPEP_LAYOUT=production python tests/test_qwen3_30B_A3B_deepep.py
SLIME_TEST_DEEPEP_LAYOUT=dp python tests/test_qwen3_30B_A3B_deepep.py
SLIME_TEST_DEEPEP_PHASE=deepep python tests/test_qwen3_30B_A3B_deepep.py
"""

import os
from pathlib import Path

import vime.utils.external_utils.command_utils as U


ENABLE_EVAL = bool(int(os.environ.get("SLIME_TEST_ENABLE_EVAL", "0")))
TIGHT_HOST_MEMORY = bool(int(os.environ.get("SLIME_TEST_TIGHT_HOST_MEMORY", "1")))
USE_FP8_ROLLOUT = bool(int(os.environ.get("SLIME_TEST_USE_FP8_ROLLOUT", "0")))
DEEPEP_PHASE = os.environ.get("SLIME_TEST_DEEPEP_PHASE", "both")
DEEPEP_LAYOUT = os.environ.get("SLIME_TEST_DEEPEP_LAYOUT", "both")
DATA_ROOT = Path(os.environ.get("SLIME_TEST_DATA_ROOT", "/root/vime-data"))

MODEL_NAME = "Qwen3-30B-A3B"
MODEL_TYPE = "qwen3-30B-A3B"
NUM_GPUS = 8

# world_size = TP * CP * DP * PP = 8 (PP=1). EP is independent of world_size
# and groups GPUs for expert routing only.
_LAYOUTS = {
"production": {"TP": 4, "CP": 2, "DP": 1, "EP": 8},
"dp": {"TP": 4, "CP": 1, "DP": 2, "EP": 8},
}


def _select_layouts():
if DEEPEP_LAYOUT not in ("both", *_LAYOUTS):
raise ValueError(f"Unsupported SLIME_TEST_DEEPEP_LAYOUT={DEEPEP_LAYOUT!r}")
return [(name, layout) for name, layout in _LAYOUTS.items() if DEEPEP_LAYOUT in ("both", name)]


def _select_phases():
if DEEPEP_PHASE not in ("both", "alltoall", "deepep"):
raise ValueError(f"Unsupported SLIME_TEST_DEEPEP_PHASE={DEEPEP_PHASE!r}")
phases = []
if DEEPEP_PHASE in ("both", "alltoall"):
phases.append(False)
if DEEPEP_PHASE in ("both", "deepep"):
phases.append(True)
return phases


def prepare():
models_dir = DATA_ROOT / "models"
datasets_dir = DATA_ROOT / "datasets"
U.exec_command(f"mkdir -p {models_dir} {datasets_dir}")
U.exec_command(f"hf download Qwen/{MODEL_NAME} --local-dir {models_dir / MODEL_NAME}")
if USE_FP8_ROLLOUT:
U.exec_command(f"hf download Qwen/{MODEL_NAME}-FP8 --local-dir {models_dir / f'{MODEL_NAME}-FP8'}")

U.exec_command(
"hf download --repo-type dataset zhuzilin/dapo-math-17k "
f"--local-dir {datasets_dir / 'dapo-math-17k'}"
)
U.exec_command(
"hf download --repo-type dataset zhuzilin/aime-2024 " f"--local-dir {datasets_dir / 'aime-2024'}"
)
U.convert_checkpoint(
model_name=MODEL_NAME,
megatron_model_type=MODEL_TYPE,
num_gpus_per_node=NUM_GPUS,
dir_dst=str(DATA_ROOT),
hf_checkpoint=str(models_dir / MODEL_NAME),
)


def execute(use_deepep: bool, layout_name: str, layout: dict):
phase_tag = "deepep" if use_deepep else "alltoall"
tp, cp, dp, ep = layout["TP"], layout["CP"], layout["DP"], layout["EP"]
run_tag = f"{layout_name}/{phase_tag}"
print(f"\n{'=' * 60}")
print(f"Run: {run_tag} (TP={tp} CP={cp} DP={dp} EP={ep}, use_deepep={use_deepep})")
print(f"{'=' * 60}")

models_dir = DATA_ROOT / "models"
datasets_dir = DATA_ROOT / "datasets"
hf_ckpt = models_dir / (f"{MODEL_NAME}-FP8" if USE_FP8_ROLLOUT else MODEL_NAME)
ckpt_args = f"--hf-checkpoint {hf_ckpt} --ref-load {DATA_ROOT / f'{MODEL_NAME}_torch_dist'} "

rollout_args = (
f"--prompt-data {datasets_dir / 'dapo-math-17k' / 'dapo-math-17k.jsonl'} "
"--input-key prompt "
"--label-key label "
"--apply-chat-template "
"--rollout-shuffle "
"--rm-type deepscaler "
"--num-rollout 3 "
"--rollout-batch-size 8 "
"--n-samples-per-prompt 4 "
"--rollout-max-response-len 8192 "
"--rollout-temperature 1 "
"--global-batch-size 32 "
"--balance-data "
)

eval_args = (
f"{'--eval-interval 20 ' if ENABLE_EVAL else ''}"
f"--eval-prompt-data aime24 {datasets_dir / 'aime-2024' / 'aime-2024.jsonl'} "
"--n-samples-per-eval-prompt 1 "
"--eval-max-response-len 16384 "
"--eval-top-k 1 "
)

perf_args = (
f"--tensor-model-parallel-size {tp} "
"--sequence-parallel "
"--pipeline-model-parallel-size 1 "
f"--context-parallel-size {cp} "
f"--expert-model-parallel-size {ep} "
"--expert-tensor-parallel-size 1 "
"--recompute-granularity full "
"--recompute-method uniform "
"--recompute-num-layers 1 "
"--use-dynamic-batch-size "
f"--max-tokens-per-gpu {2048 if TIGHT_HOST_MEMORY else 16384} "
)

grpo_args = (
"--advantage-estimator gspo "
f"{'' if TIGHT_HOST_MEMORY else '--use-kl-loss '}"
"--kl-loss-coef 0.00 "
"--kl-loss-type low_var_kl "
"--kl-coef 0.00 "
"--entropy-coef 0.00 "
"--eps-clip 4e-4 "
"--use-tis "
"--use-routing-replay "
)

optimizer_args = (
"--optimizer adam "
"--lr 1e-6 "
"--lr-decay-style constant "
"--weight-decay 0.1 "
"--adam-beta1 0.9 "
"--adam-beta2 0.98 "
"--optimizer-cpu-offload "
"--overlap-cpu-optimizer-d2h-h2d "
"--use-precision-aware-optimizer "
)

# 30B uses a single 8-GPU vLLM engine. In the DP layout, validate rollout
# DP+EP by splitting that engine into TP=4 and DP=2; vLLM derives EP as
# tensor_parallel_size x data_parallel_size, so rollout EP stays 8.
vllm_args = (
"--rollout-num-gpus-per-engine 8 "
"--vllm-enable-expert-parallel "
"--vllm-gpu-memory-utilization 0.8 "
"--vllm-max-num-seqs 512 "
"--vllm-max-cudagraph-capture-size 64 "
)
if dp > 1:
vllm_args += f"--vllm-data-parallel-size {dp} "
if use_deepep:
vllm_args += "--vllm-all2all-backend deepep_high_throughput "

misc_args = (
"--ci-test "
"--attention-dropout 0.0 "
"--hidden-dropout 0.0 "
"--accumulate-allreduce-grads-in-fp32 "
"--attention-softmax-in-fp32 "
"--attention-backend flash "
"--actor-num-nodes 1 "
"--actor-num-gpus-per-node 8 "
"--colocate "
)
if use_deepep:
misc_args += "--moe-token-dispatcher-type flex --moe-enable-deepep "
else:
misc_args += "--moe-token-dispatcher-type alltoall "

train_args = (
f"{ckpt_args} "
f"{rollout_args} "
f"{optimizer_args} "
f"{grpo_args} "
f"{U.get_default_wandb_args(__file__)} "
f"{perf_args} "
f"{eval_args} "
f"{vllm_args} "
f"{misc_args} "
)

U.execute_train(
train_args=train_args,
num_gpus_per_node=NUM_GPUS,
megatron_model_type=MODEL_TYPE,
)

print(f"\nRun {run_tag}: PASSED")


if __name__ == "__main__":
prepare()
for proxy_var in ("http_proxy", "https_proxy", "HTTP_PROXY", "HTTPS_PROXY"):
os.environ.pop(proxy_var, None)

for layout_name, layout in _select_layouts():
for use_deepep in _select_phases():
execute(use_deepep=use_deepep, layout_name=layout_name, layout=layout)
12 changes: 12 additions & 0 deletions tests/unit/backends/vllm_utils/test_arguments.py
Original file line number Diff line number Diff line change
Expand Up @@ -361,6 +361,18 @@ def test_parse_args_tp_default_with_pp(args_mod, monkeypatch):
assert ns.vllm_tensor_parallel_size == 2


@pytest.mark.unit
def test_parse_args_tp_default_with_dp(args_mod, monkeypatch):
monkeypatch.setattr(args_mod, "add_vllm_arguments", lambda p: p)
monkeypatch.setattr(
sys,
"argv",
["train.py", "--rollout-num-gpus-per-engine", "8", "--vllm-data-parallel-size", "2"],
)
ns = args_mod.vllm_parse_args()
assert ns.vllm_tensor_parallel_size == 4


@pytest.mark.unit
def test_parse_args_records_user_provided(args_mod, monkeypatch):
def stub(parser):
Expand Down
62 changes: 59 additions & 3 deletions tests/unit/backends/vllm_utils/test_vllm_engine.py
Original file line number Diff line number Diff line change
Expand Up @@ -149,6 +149,19 @@ def test_build_vllm_subprocess_env_colocate(vllm_args, monkeypatch):
assert "PYTHONPATH" in env


@pytest.mark.unit
def test_build_vllm_subprocess_env_extends_dp_ready_timeout(vllm_args, monkeypatch):
monkeypatch.delenv("VLLM_ENGINE_READY_TIMEOUT_S", raising=False)
env = mod.build_vllm_subprocess_env(
{
"args": vllm_args,
"visible_devices": "0,1,2,3,4,5,6,7",
"dp_size": 2,
}
)
assert env["VLLM_ENGINE_READY_TIMEOUT_S"] == "1800"


@pytest.mark.unit
def test_get_base_gpu_id_colocate(vllm_args):
vllm_args.colocate = True
Expand Down Expand Up @@ -449,6 +462,7 @@ def fake_post(url, *, params=None, timeout=30, json=None):

assert len(seen) == 1
assert seen[0][1] == [("tags", "weights")]
assert seen[0][2] == vllm_args.vllm_weight_transfer_timeout_sec


@pytest.mark.unit
Expand Down Expand Up @@ -578,12 +592,54 @@ def test_compute_topology_heterogeneous_per_group_tp(vllm_args):


@pytest.mark.unit
def test_resolve_parallel_sizes_rejects_dp_gt_1(vllm_args):
def test_resolve_parallel_sizes_accounts_for_dp(vllm_args):
vllm_args.vllm_pipeline_parallel_size = 1
vllm_args.vllm_data_parallel_size = 2
vllm_args.vllm_dp_size = 2
with pytest.raises(NotImplementedError, match="data parallelism"):
mod._resolve_vllm_parallel_sizes(vllm_args, gpus_per_engine=4)
assert mod._resolve_vllm_parallel_sizes(vllm_args, gpus_per_engine=8) == (4, 1)


@pytest.mark.unit
def test_resolve_parallel_sizes_rejects_non_divisible_dp(vllm_args):
vllm_args.vllm_pipeline_parallel_size = 1
vllm_args.vllm_data_parallel_size = 2
vllm_args.vllm_dp_size = 2
with pytest.raises(ValueError, match="vllm_data_parallel_size"):
mod._resolve_vllm_parallel_sizes(vllm_args, gpus_per_engine=6)


@pytest.mark.unit
def test_build_vllm_cmd_uses_conservative_defaults_for_dp_sleep(vllm_args):
vllm_args.vllm_enable_sleep_mode = True
vllm_args.vllm_data_parallel_size = 2
vllm_args.vllm_dp_size = 2
topology = mod.VllmEngineTopology(
nnodes=1,
node_rank=0,
local_num_gpus=8,
tensor_parallel_size=4,
pipeline_parallel_size=1,
)
cmd, _env = mod.build_vllm_cmd_and_env(
{
"args": vllm_args,
"topology": topology,
"visible_devices": "0,1,2,3,4,5,6,7",
"host": "127.0.0.1",
"port": 15000,
"model_path": "/tmp/model",
"tp_size": 4,
"pp_size": 1,
"dp_size": 2,
"seed": 1234,
"master_addr": None,
"master_port": None,
}
)

assert "--no-async-scheduling" in cmd
assert "--enforce-eager" in cmd
assert cmd[cmd.index("--distributed-timeout-seconds") + 1] == "1800"


@pytest.mark.unit
Expand Down
8 changes: 5 additions & 3 deletions vime/backends/vllm_utils/arguments.py
Original file line number Diff line number Diff line change
Expand Up @@ -319,8 +319,8 @@ def validate_args(args):
# NOTE: TP is intentionally NOT precomputed here. A global ``vllm_tp_size`` derived from the
# *global* rollout_num_gpus_per_engine would shadow the per-engine value and break
# heterogeneous per-group engines (different num_gpus_per_engine). TP is resolved per engine
# in ``vllm_engine._resolve_vllm_parallel_sizes`` (tp = gpus_per_engine // pp), mirroring
# upstream slime's sglang_engine. (pp divisibility is validated there, per engine.)
# in ``vllm_engine._resolve_vllm_parallel_sizes`` (tp = gpus_per_engine // (pp * dp)).
# Divisibility is validated there, per engine.

if getattr(args, "vllm_router_ip", None):
args.vllm_router_ip = _wrap_ipv6(args.vllm_router_ip)
Expand All @@ -342,9 +342,11 @@ def vllm_parse_args():
temp_parser = argparse.ArgumentParser(add_help=False)
temp_parser.add_argument("--rollout-num-gpus-per-engine", type=int, default=1)
temp_parser.add_argument("--vllm-pipeline-parallel-size", type=int, default=1)
temp_parser.add_argument("--vllm-data-parallel-size", type=int, default=1)
temp_args, _ = temp_parser.parse_known_args()
pp_size = temp_args.vllm_pipeline_parallel_size
vllm_tp_size = temp_args.rollout_num_gpus_per_engine // pp_size
dp_size = temp_args.vllm_data_parallel_size
vllm_tp_size = temp_args.rollout_num_gpus_per_engine // (pp_size * dp_size)
Comment on lines 347 to +349

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

medium

If vllm-pipeline-parallel-size or vllm-data-parallel-size are passed as 0 or negative values, this division will raise a ZeroDivisionError or result in an invalid negative parallel size. We should enforce a minimum value of 1 for both sizes to ensure robustness.

Suggested change
pp_size = temp_args.vllm_pipeline_parallel_size
vllm_tp_size = temp_args.rollout_num_gpus_per_engine // pp_size
dp_size = temp_args.vllm_data_parallel_size
vllm_tp_size = temp_args.rollout_num_gpus_per_engine // (pp_size * dp_size)
pp_size = max(1, temp_args.vllm_pipeline_parallel_size)
dp_size = max(1, temp_args.vllm_data_parallel_size)
vllm_tp_size = temp_args.rollout_num_gpus_per_engine // (pp_size * dp_size)

parser.set_defaults(vllm_tensor_parallel_size=vllm_tp_size)

args, _ = parser.parse_known_args()
Expand Down
Loading
Loading