paleumm/phantora-train

Phantora training traffic traces

Node-to-node network traffic of distributed LLM training, simulated with Phantora (NSDI 2026). Phantora intercepts the CUDA and NCCL calls of unmodified Megatron, DeepSpeed and TorchTitan scripts and simulates kernels and collectives on a virtual cluster, so no real GPU cluster is used.

Status: Phase 1 complete for W1–W5: 26 runs on simulated L40S and A100-40GB timings, at 2 or 4 nodes with 1, 2 or 4 GPUs per node.

What the data is

• Raw traces (traces/): every simulated communication event, with bytes, source host, destination host, NCCL op, element count, dtype and start/end time. Computation events, with kernel or torch op and duration, are included too.
• Dataset CSVs (data/phantora_v0/): the same traffic in the schema of our v1 FakeTensor dataset. That is bytes per (source node, destination node) per 100 ms bin over a 180 s window, plus one summary row per run and per-window detector features.

How it was made

1. Kernel timings. Phantora (commit 301d9d9, unmodified) replays kernel times from a performance database:
   • L40S: the database that ships with Phantora. It only covers 2-GPU configs, so L40S runs are 2 × 1 only.
   • A100 40GB: recorded by us on an A100-SXM4-40GB, using Phantora's record mode, for every config here. It is included in perfdb/a100_40g/.
2. Simulate. Each config runs in Docker in replay mode, with no GPU and 20 iterations. phantora_server --timeline-file logs every event.
3. Convert. The log is turned into Chrome/Perfetto JSON (timeline.json.gz). We use Phantora's phantora_visualizer with a one-line fix (tools/visualizer.patch): the original panics on NcclSend/NcclRecv events, which make up MoE all-to-all. On traces without those events, its output is byte-identical to the original's.
4. Check. Each trace is checked before it is published (checks.txt in each run folder):
   • network flows exist;
   • every steady step has the same set of collectives;
   • every flow's bytes match the ring formula for its op, with one group size n per communicator: all-reduce 2(n−1)/n × S, all-gather and reduce-scatter (n−1) × S, send/recv S;
   • steady steps have the same bytes and nearly the same duration.
5. Build the dataset. One steady-state step is repeated for 180 s with ±2% step jitter and a random start phase. Each node adds 5 kB/s of control traffic, and the result is summed into 100 ms bins. This is the same code as the v1 dataset. CSV totals were checked to equal the trace's network bytes exactly.

Runs

26 runs from 5 workloads. The step time is the median steady-state step. The bytes are inter-host network bytes per step, both directions combined.

run_id	#	Framework	Model	Parallelism	Nodes × GPUs	GPU timings	Step time	Inter-node bytes/step
phantora_l40s_W1_2x1	W1	Megatron	Llama3-8B, 4 layers	tp=2,dp=1	2 × 1	L40S	90.9 ms	0.30 GB
phantora_a100_40g_W1_2x1	W1	Megatron	Llama3-8B, 4 layers	tp=2,dp=1	2 × 1	A100 40GB	61.5 ms	0.30 GB
phantora_a100_40g_W1_2x2	W1	Megatron	Llama3-8B, 4 layers	tp=2,dp=2	2 × 2	A100 40GB	70.3 ms	7.69 GB
phantora_a100_40g_W1_4x1	W1	Megatron	Llama3-8B, 4 layers	tp=2,dp=2	4 × 1	A100 40GB	70.8 ms	8.30 GB
phantora_a100_40g_W1_2x4	W1	Megatron	Llama3-8B, 4 layers	tp=2,dp=4	2 × 4	A100 40GB	75.9 ms	11.54 GB
phantora_a100_40g_W1_4x2	W1	Megatron	Llama3-8B, 4 layers	tp=2,dp=4	4 × 2	A100 40GB	75.9 ms	23.08 GB
phantora_a100_40g_W2_2x2	W2	Megatron	Mixtral 8×7B, 4 layers	ep=4	2 × 2	A100 40GB	147.2 ms	3.12 GB
phantora_a100_40g_W2_4x1	W2	Megatron	Mixtral 8×7B, 4 layers	ep=4	4 × 1	A100 40GB	147.2 ms	5.36 GB
phantora_a100_40g_W2_2x4	W2	Megatron	Mixtral 8×7B, 4 layers	ep=8	2 × 4	A100 40GB	116.2 ms	4.08 GB
phantora_a100_40g_W2_4x2	W2	Megatron	Mixtral 8×7B, 4 layers	ep=8	4 × 2	A100 40GB	116.2 ms	6.02 GB
phantora_l40s_W3_2x1	W3	Megatron	Qwen3-30B-A3B, 4 layers	ep=2	2 × 1	L40S	108.5 ms	3.33 GB
phantora_a100_40g_W3_2x1	W3	Megatron	Qwen3-30B-A3B, 4 layers	ep=2	2 × 1	A100 40GB	122.4 ms	3.33 GB
phantora_a100_40g_W3_2x2	W3	Megatron	Qwen3-30B-A3B, 4 layers	ep=4	2 × 2	A100 40GB	91.8 ms	5.27 GB
phantora_a100_40g_W3_4x1	W3	Megatron	Qwen3-30B-A3B, 4 layers	ep=4	4 × 1	A100 40GB	91.8 ms	8.39 GB
phantora_a100_40g_W3_2x4	W3	Megatron	Qwen3-30B-A3B, 4 layers	ep=8	2 × 4	A100 40GB	82.2 ms	7.04 GB
phantora_a100_40g_W3_4x2	W3	Megatron	Qwen3-30B-A3B, 4 layers	ep=8	4 × 2	A100 40GB	82.2 ms	9.78 GB
phantora_l40s_W4_2x1	W4	DeepSpeed	Llama3-8B, 4 layers	dp=2	2 × 1	L40S	234.9 ms	11.54 GB
phantora_a100_40g_W4_2x1	W4	DeepSpeed	Llama3-8B, 4 layers	dp=2	2 × 1	A100 40GB	178.2 ms	11.54 GB
phantora_a100_40g_W4_2x2	W4	DeepSpeed	Llama3-8B, 4 layers	dp=4	2 × 2	A100 40GB	194.8 ms	17.31 GB
phantora_a100_40g_W4_4x1	W4	DeepSpeed	Llama3-8B, 4 layers	dp=4	4 × 1	A100 40GB	194.8 ms	34.62 GB
phantora_a100_40g_W4_2x4	W4	DeepSpeed	Llama3-8B, 4 layers	dp=8	2 × 4	A100 40GB	203.0 ms	20.19 GB
phantora_a100_40g_W4_4x2	W4	DeepSpeed	Llama3-8B, 4 layers	dp=8	4 × 2	A100 40GB	203.0 ms	40.39 GB
phantora_a100_40g_W5_2x2	W5	DeepSpeed	gpt-oss-20B, 4 layers	dp=4,zero=3	2 × 2	A100 40GB	251.0 ms ¹	38.32 GB
phantora_a100_40g_W5_4x1	W5	DeepSpeed	gpt-oss-20B, 4 layers	dp=4,zero=3	4 × 1	A100 40GB	249.2 ms ¹	76.64 GB
phantora_a100_40g_W5_2x4	W5	DeepSpeed	gpt-oss-20B, 4 layers	dp=8,zero=3	2 × 4	A100 40GB	252.4 ms	44.71 GB
phantora_a100_40g_W5_4x2	W5	DeepSpeed	gpt-oss-20B, 4 layers	dp=8,zero=3	4 × 2	A100 40GB	252.4 ms	89.41 GB

¹ The bytes per step are identical in every step. The simulator's own step times vary by up to 4.4% in this config, which is real simulated jitter.

Configs with no trace. Simulated memory is the card's real capacity (L40S 46 GB, A100 40 GB), so these did not fit:

• phantora_l40s_W2_2x1 (ep=2, 2 × 1, L40S): out of memory
• phantora_a100_40g_W2_2x1 (ep=2, 2 × 1, A100 40GB): out of memory
• phantora_l40s_W5_2x1 (dp=2,zero=3, 2 × 1, L40S): out of memory
• phantora_a100_40g_W5_2x1 (dp=2,zero=3, 2 × 1, A100 40GB): out of memory

Run ids are phantora_<gpu>_<workload>_<nodes>x<gpus>. They match the folder traces/<gpu>/<workload>_<nodes>x<gpus>/.

Parallelism

• W1: TP=2, with data parallelism (DP) over the remaining GPUs.
• W2 and W3: expert parallelism (EP) equals the GPU count; Mixtral (W2) has at most 8 experts.
• W4: data parallelism across all GPUs.
• W5: ZeRO-3 across all GPUs.
• Visibility: traffic between GPUs inside one node stays on the host and is not in the network flows. For example, at 2 or 4 GPUs per node, W1's TP traffic is invisible.

Usage

The repo is private. Log in first with hf auth login, or set HF_TOKEN.

pip install datasets huggingface_hub pandas

Dataset CSVs

from datasets import load_dataset

runs  = load_dataset("paleumm/phantora-train", "runs",        split="train").to_pandas()
flows = load_dataset("paleumm/phantora-train", "flows_100ms", split="train").to_pandas()
# also: "windows"

print(runs[["run_id", "layout", "n_nodes", "step_time_s", "inter_node_bytes_per_step"]])

# Average bytes/s per directed node pair for one run (180 s window)
f = flows[flows.run_id == "phantora_l40s_W1_2x1"]
print(f.groupby(["src_node", "dst_node"]).bytes.sum() / 180.0)

Join the three tables on run_id. flows_100ms covers every run, so filter it by run_id before plotting.

Raw trace

import gzip, json
from huggingface_hub import hf_hub_download

path = hf_hub_download("paleumm/phantora-train",
                       "traces/l40s/W1_2x1/timeline.json.gz", repo_type="dataset")
events = json.load(gzip.open(path))           # list of Chrome trace events, NOT sorted by time

for e in sorted((e for e in events if e["cat"] == "Communication"), key=lambda e: e["ts"]):
    flow, call = e["args"]["Communication"]
    (op, info), = call.items()                 # e.g. "NcclAllReduce", {count, dtype, comm, ...}
    if flow["src"] != flow["dst"]:             # network flows only
        print(e["ts"], e["dur"], flow["src"], flow["dst"], flow["bytes"], op, info["count"], info["dtype"])

ts and dur are in simulated microseconds. Computation events have "cat": "Computation" and name the kernel or torch op.

Whole run folder, or view in Perfetto

from huggingface_hub import snapshot_download
d = snapshot_download("paleumm/phantora-train", repo_type="dataset",
                      allow_patterns=["traces/l40s/W1_2x1/*"])

To browse a trace, gunzip timeline.json.gz and open it in ui.perfetto.dev. Each host is one process track, and communication spans sit on their own track. To regenerate the JSON from timeline.bin, use phantora_visualizer -t timeline.bin -o timeline.json from the Phantora Docker image. For MoE traces (W2, W3), first apply tools/visualizer.patch.

Layout

traces/<gpu>/<workload>_<nodes>x<gpus>/
    timeline.bin        raw Phantora timeline (read with phantora_visualizer)
    timeline.json.gz    Chrome/Perfetto JSON; open in ui.perfetto.dev
    run.log             training stdout: per-iteration simulated time, peak memory
    config/             compose.yaml, netconfig.toml, hostfile, command.txt (exact commands)
    checks.txt          output of the sanity checks for this trace
data/phantora_v0/
    runs.csv            one row per run
    flows_100ms.csv     run_id, t, src_node, dst_node, bytes
    windows.csv         detector features per 1 s and 15 s window
perfdb/a100_40g/        A100-SXM4-40GB kernel timings (Phantora perf DB format)
tools/visualizer.patch  the one-line visualizer fix

Trace events

In timeline.json.gz, every event with "cat": "Communication" has args.Communication = [flow, nccl_call]:

• flow: bytes, src, dst (host names, host-1 …), id.
• nccl_call: {op: {count, dtype, op, comm: {rank, id}, stream}}.
• ts and dur are in simulated microseconds since the start of the run.

CSV schema

The columns are identical to the v1 dataset (runs.csv, flows_100ms.csv, windows.csv). Units are bytes and seconds. Host host-k is node k−1. In runs.csv, source = phantora_v0. Columns that only make sense for a roofline model (flops_per_step, mfu, peak_flops, alpha) are empty, because timing comes from measured kernel times. nic_bw is the simulated host link in bytes/s.

Simulated cluster

• Topology: two-layer leaf-spine (TwoLayerMultiPath), 2 hosts per rack, 2 spines, ECMP.
• Links: 800 Gbps per host and per rack uplink.
• Flow sharing: per-flow max-min fairness.

Known limits

• Endpoints are hosts, not GPUs or NICs. Traffic between GPUs in the same host is not in the network flows.
• Each ring hop is one bulk flow. Fine burst shape inside a collective is not modelled.
• MoE experts are forced to be balanced. Routing imbalance is not represented.
• Small models. Runs use a 4-layer slice of each model, so per-layer traffic is exact but per-step totals are for 4 layers.
• Kernel timing comes from one GPU of each type. L40S timings come from Phantora's shipped database, and A100 timings come from one A100-SXM4-40GB. Collective timing comes from Phantora's flow-level network simulator.
• Step time barely depends on where GPUs sit. In W2–W5, 2 × 2 and 4 × 1 (and 2 × 4 and 4 × 2) have the same step time even though their network bytes differ. We have not yet checked whether the network is on the critical path in these runs.
• No step markers in the trace. Steps are found from each communicator's repeating sequence of collectives.
• TorchTitan is not included. The Phantora image's pyarrow needs NumPy 2, while the image pins NumPy 1.26.
• Tiny collectives (≤ 4 KiB) show 0 µs duration.
• The ±2% step jitter in the CSVs is added on purpose (as in v1). The simulated steps themselves vary by about 0.1%.

License

Apache-2.0, following Phantora. See LICENSE and NOTICE.