README.md

---
pretty_name: ServingStudio workload captures
license: apache-2.0
tags:
  - mixture-of-experts
  - expert-routing
  - llm-serving
  - simulation
size_categories:
  - n<1K
---

# ServingStudio workload captures

This repository holds the routing data that ServingStudio Sim needs to cost the
MoE layers of a model. Each **capture** measures one model on one workload. In
this card, "model" means everything that changes which tokens are routed: the
checkpoint, the serving engine, and the speculative proposer with its draft
length k. The workload is a trace shape plus a prompt source.

The deployment a capture was taken on (GPU, TP/EP/DP, PD or AFD) is **not** part
of the key. A capture is recorded once and then bound by every deployment of the
same model on the same workload: EP4, EP8 and both pools of a PD deployment all
read the same files. Each capture's `provenance.json` records its deployment
under `server`.

Licensed under Apache 2.0. The files hold request lengths, expert ids and counts, not prompt text.

## Layout

```
<model>/<engine>[_<proposer>_k<k>]/<workload>/capture/<YYYYMMDD>/
    provenance.json         every input that produced the capture, and how each value was established
    trace.csv               the request trace the capture actually replayed (and, for some
                            speculative captures, the acceptance each request recorded)
    popularity.json         aggregate expert counts             (popularity captures; beside some corpora)
    draft_popularity.json   the MTP draft layer's counts        (speculative popularity captures)
    manifest.json           corpus dimensions and checksum      (per-token captures)
    routes.u16              per-token routed experts            (per-token captures)
```

- `<model>` names the checkpoint, for example `glm52_nvfp4`. The exact Hugging
  Face id and revision are in `provenance.json`.
- The second level is the engine (`vllm`, `sglang`). When the model serves with
  a speculative proposer, the proposer and its draft length k are appended, as in
  `vllm_mtp_k5`, `vllm_dflash2_k7` or `vllm_dspark_k7`.
- `<YYYYMMDD>` is the date the capture was taken. A second measurement of the
  same key is a **replicate**: it gets a new date directory next to the first and
  never overwrites it. Its `provenance.json` names the first capture in
  `replicate_of`.
- Data files never change after upload. Only `provenance.json` may be revised.
- Some per-token captures also carry the `popularity.json` (and
  `draft_popularity.json`) of a popularity replay of the same model and trace.
  Each file's `files.<name>.extra.same_replay_as_corpus` says whether it came
  from the corpus replay itself or from a separate one in the same Slurm job.

Nothing reads this directory scheme by name. Presets give each capture's full
path, so the layout exists for people browsing the repo.

## Referencing a capture

Pin a commit, never a branch:

```
hf://datasets/UW-SyFI/servingstudio-workload@<commit-sha>/glm53_nvfp4/vllm_dflash2_k7/diverse_100/capture/20260922/
```

The `datasets/` prefix is part of the path, because this is a dataset repo.
`huggingface_hub` calls need `repo_type="dataset"`.

## File formats

### `trace.csv`

The independent-request CSV that ServingStudio Sim and req-frontend share:

```
id,input_len,output_len,arrival_time
```

`arrival_time` is in milliseconds. The file is the exact one the capture
replayed, byte for byte, except for the column below. Whether `arrival_time` was honoured depends on the
replay policy recorded in `provenance.json` under `workload.arrival`: a
`saturated` replay ignores it. When a workload also has a reviewed spec in the
ServingStudioSim git repo, `provenance.json` gives its path in
`workload.spec` (for example `trace/diverse_100.csv`).

A speculative capture whose pass recorded each request's decode progress adds
one column, `accept_rate`, the simulator's `speculative` tag:

```
id,input_len,output_len,arrival_time,accept_rate
```

`accept_rate` is the acceptance that request had in this capture, a JSON list
with one probability per draft position: the chance position *i* is accepted
given that the positions before it were (a rejection at the first position
counts as a trial). It comes from the same pass as the routing, its per-step
`drafted_tokens` and `accepted_draft_tokens`. A request with no draft reaching
a position takes the pooled rate of the capture's requests there.
`provenance.json` gives, under `files["trace.csv"].extra`, the source files and
their sha256 (`accept_rate.sources`), the pooled rates (which equal the
server's own counters), how many (request, position) cells took them, and the
sha256 of the trace without the column (`requests.sha256`). A speculative
capture without this column recorded only the run's aggregate counters.

### `popularity.json`: aggregate expert counts

`counts_by_layer[layer][logical_expert]` counts routed-token assignments to
logical experts. The counts are taken after EPLB's physical-to-logical mapping
and the EP-group reduction, so they are logical demand and do not depend on
expert placement. `counts_all_layers` sums the counts over layers. The
`probabilities_*` fields are the same counts normalized. Four schema versions
appear here:

| `schema_version` | Adds | `aggregation.scope` |
| --- | --- | --- |
| 1 | `record_count`, `num_moe_layers`, `num_logical_experts`, counts and probabilities only; no EP fields, no aggregation block | — |
| 2 | `expert_parallel_size`, `experts_per_rank`, `experts_per_token`, `count_semantics`, `expert_partitioning`, an `aggregation` block | `all_captured_eplb_steps` |
| 3 | a per-step token ceiling: `raw_record_count`, `discarded_oversized_*`, `max_tokens_per_step` | `captured_eplb_steps_within_token_ceiling` |
| 4 | `model_role` (`target` or `draft`) and a replay time window: `replay_*_monotonic_ns`, `observed_monotonic_ns_*`, `max_forwards_per_step` | `replay_window_within_role_specific_token_ceiling` |

`expert_parallel_size` and `experts_per_rank` describe the deployment the counts
were captured on, not the counts themselves. A consumer takes EP from its own
binding. JSON schemas for v2–v4 are in ServingStudioSim at
`alignment/schema/expert_popularity_v{2,3,4}.schema.json`.

`draft_popularity.json` is the schema-4 `model_role: draft` file from the same
replay. For MTP it covers the one MTP MoE layer.

### `manifest.json` + `routes.u16`: per-token routes

`routes.u16` is a raw array of **little-endian u16**, in C order
`[token, layer, top_k]`. Each value is a logical expert id. `manifest.json`
gives the dimensions and an integrity checksum:

```json
{"schema_version": 1, "data_file": "routes.u16", "num_tokens": 135144,
 "num_layers": 75, "num_experts": 256, "top_k": 8, "checksum_fnv1a64": 9937083654806801569}
```

`checksum_fnv1a64` is 64-bit FNV-1a over the bytes of `routes.u16` (offset basis
`0xcbf29ce484222325`, prime `0x100000001b3`). The simulator's loader checks it.
The file size is `num_tokens * num_layers * top_k * 2` bytes.

The current corpora cover **accepted generated tokens only**. They have no
prompt routes and no routes for rejected drafts. `provenance.json` lists the
model layer index of each corpus layer (`files["routes.u16"].extra.hub_provenance.model_layer_indices`)
and where each request's tokens start and end (`request_segments`). Corpora
copied from the old model repo keep these under `extra.hub_provenance`; corpora
staged from their run directory keep the run's own provenance file under
`extra.run_provenance`, and, when that file has no layer list, give it as
`extra.model_layer_indices`.

### `provenance.json`

| Key | Meaning |
| --- | --- |
| `model` | `checkpoint`, `revision`, and `revision_inferred`. `revision_inferred` is true when the server was given a repo id and the revision is the only snapshot that was in its cache. |
| `engine` | `name`, and `version` as the engine reported it at startup |
| `proposer` | `null`, or `kind`, `k`, `checkpoint` and `revision` |
| `workload` | `name`, `spec` (git path under `trace/`, or null), `prompts`, `requests`, `concurrency`, and `arrival` (the replay policy) |
| `server` | the deployment the capture ran on: `gpu`, `tp`, `ep`, `dp`, plus `other` (full server argv, engine fork commit, and so on) |
| `captured` | `date`, the producing `run` directory (host-qualified), and the Slurm `job` |
| `files` | one entry per data file: `sha256`, `copied_from`, `kind`, `schema_version`, `scope`, and `extra` for structured detail |
| `replicate_of` | the capture this one repeats, or null |
| `missing` | facts that could not be established |
| `notes` | how each value was established, with every check that was run |

Unknown values are `null`; nothing is guessed.

## Captures

| Capture | Checkpoint | Engine | Proposer | Workload | Captured on | Files | Data |
| --- | --- | --- | --- | --- | --- | --- | --- |
| `deepseek_v41_flash/vllm/diverse_100/capture/20260924/` | `deepseek-ai/DeepSeek-V4.1-Flash` | vLLM | — | diverse_100 (100 req, enwik9) | B200 TP4 EP4 DP1 | manifest.json, routes.u16, popularity.json, trace.csv | 135,144 tokens x 40 layers x top-6 of 384; popularity v3 from the same replay, 9,049 records |
| `deepseek_v4_flash/vllm/shape_grid_128/capture/20260822/` | `deepseek-ai/DeepSeek-V4-Flash-0731` | vLLM | — | shape_grid_128 (128 req, enwik8) | H200 TP1 EP4 DP4 | popularity.json, trace.csv | v2, 43 layers x 256 experts, 5,296 records |
| `deepseek_v4_flash/vllm_dspark_k7/diverse_100/capture/20260922/` | `deepseek-ai/DeepSeek-V4-Flash-0731` | vLLM | DSpark k=7 (draft in the checkpoint, greedy draft sampling) | diverse_100 (100 req, enwik9) | B200 TP4 EP4 DP1 | manifest.json, routes.u16, trace.csv | 135,144 tokens x 43 layers x top-6 of 256 |
| `glm52_fp8/vllm/ctx8k_out1k/capture/20260803/` | `zai-org/GLM-5.2-FP8` | vLLM | — | ctx8k_out1k (256 req, enwik8) | H200 TP1 EP8 DP8 | popularity.json, trace.csv | v1, 75 layers x 256 experts, 11,296 records |
| `glm52_nvfp4/sglang/diverse_100/capture/20260829/` | `nvidia/GLM-5.2-NVFP4` | SGLang | — | diverse_100 (100 req, enwik9) | B200 TP4 EP1 DP1 | popularity.json, trace.csv | v3, 75 layers x 256 experts, 1 record (whole replay) |
| `glm52_nvfp4/vllm/c32_long/capture/20260824/` | `nvidia/GLM-5.2-NVFP4` | vLLM | — | c32_long (64 req, enwik9) | B200 TP4 EP4 DP1 | popularity.json, trace.csv | v3, 75 layers x 256 experts, 532 records |
| `glm52_nvfp4/vllm/diverse_100/capture/20260830/` | `nvidia/GLM-5.2-NVFP4` | vLLM | — | diverse_100 (100 req, enwik9) | B200 TP4 EP4 DP1 | popularity.json, trace.csv | v3, 75 layers x 256 experts, 13,577 records |
| `glm52_nvfp4/vllm/diverse_100/capture/20260922/` | `nvidia/GLM-5.2-NVFP4` | vLLM | — | diverse_100 (100 req, enwik9) | B200 TP4 EP4 DP1 | manifest.json, routes.u16, trace.csv | 135,144 tokens x 75 layers x top-8 of 256; replicate of 20260830, on the v0.28 fork |
| `glm52_nvfp4/vllm_mtp_k5/diverse_100/capture/20260830/` | `nvidia/GLM-5.2-NVFP4` | vLLM | MTP k=5 | diverse_100 (100 req, enwik9) | B200 TP4 EP4 DP1 | popularity.json, draft_popularity.json, trace.csv | v4 target (75 layers) + draft (1 layer), 7,973 records |
| `glm52_nvfp4/vllm_mtp_k5/diverse_100/capture/20260902/` | `nvidia/GLM-5.2-NVFP4` | vLLM | MTP k=5 | diverse_100 (100 req, enwik9) | B200 TP8 EP8 DP1 | popularity.json, draft_popularity.json, trace.csv | v4 target + draft, 4,007 records; replicate of 20260830 |
| `glm52_nvfp4/vllm_mtp_k5/diverse_100/capture/20260922/` | `nvidia/GLM-5.2-NVFP4` | vLLM | MTP k=5 | diverse_100 (100 req, enwik9) | B200 TP4 EP4 DP1 | manifest.json, routes.u16, popularity.json, draft_popularity.json, trace.csv | 135,144 tokens x 75 layers (no MTP layer) x top-8 of 256; popularity v4 target + draft from a separate replay, 6,780 records; replicate of 20260830, on the v0.28 fork |
| `glm52_nvfp4/vllm_mtp_k5/quadrant_c48/capture/20260923/` | `nvidia/GLM-5.2-NVFP4` | vLLM | MTP k=5 | quadrant_c48 (192 req, enwik9) | B200 TP4 EP4 DP1 | manifest.json, routes.u16, trace.csv | 307,008 tokens x 76 layers (75 body + MTP) x top-8 of 256 |
| `glm53_flash_fp8/vllm/balanced_c32/capture/20260924/` | `zai-org/GLM-5.3-Flash` | vLLM | — | balanced_c32 (256 req, enwik9) | B200 TP4 EP4 DP1 | manifest.json, routes.u16, trace.csv | 48,896 tokens x 42 layers x top-8 of 288 |
| `glm53_flash_fp8/vllm/diverse_100/capture/20260925/` | `zai-org/GLM-5.3-Flash` | vLLM | — | diverse_100 (100 req, enwik9) | B200 TP4 EP4 DP1 | manifest.json, routes.u16, trace.csv | 135,144 tokens x 42 layers x top-8 of 288 |
| `glm53_flash_fp8/vllm_mtp_k5/diverse_100/capture/20260922/` | `zai-org/GLM-5.3-Flash` | vLLM | MTP k=5 | diverse_100 (100 req, enwik9) | B200 TP4 EP4 DP1 | manifest.json, routes.u16, popularity.json, draft_popularity.json, trace.csv | 135,144 tokens x 42 layers (no MTP layer) x top-8 of 288; popularity v4 target + draft from a separate replay, 2,703 records |
| `glm53_nvfp4/vllm_dflash2_k7/diverse_100/capture/20260920/` | `incoai/GLM-5.3-NVFP4` | vLLM | DFlash2 k=7 (`incoai/GLM-5.3-DFlash2`) | diverse_100 (100 req, enwik9) | B200 TP4 EP4 DP1 | manifest.json, routes.u16, trace.csv | 135,144 tokens x 75 layers x top-8 of 256; replicate of 20260922 |
| `glm53_nvfp4/vllm_dflash2_k7/diverse_100/capture/20260922/` | `incoai/GLM-5.3-NVFP4` | vLLM | DFlash2 k=7 (`incoai/GLM-5.3-DFlash2`) | diverse_100 (100 req, enwik9) | B200 TP4 EP4 DP1 | manifest.json, routes.u16, trace.csv | 135,144 tokens x 75 layers x top-8 of 256 |
| `inkling_nvfp4/vllm/diverse_100/capture/20261009/` | `thinkingmachines/Inkling-NVFP4` | vLLM | — | diverse_100 (100 req, enwik9) | B200 TP8 EP8 DP1 | manifest.json, routes.u16, trace.csv | 135,144 tokens x 64 layers (routed layers 2-65) x top-6 of 256 |
| `inkling_small_nvfp4/vllm/diverse_100/capture/20261008/` | `thinkingmachines/Inkling-Small-NVFP4` | vLLM | — | diverse_100 (100 req, enwik9) | B200 TP4 EP4 DP1 | manifest.json, routes.u16, trace.csv | 135,144 tokens x 40 layers (routed layers 2-41) x top-6 of 256 |
| `qwen36_35b_a3b_fp8/vllm/ctx8k_out1k/capture/20260818/` | `Qwen/Qwen3.6-35B-A3B-FP8` | vLLM | — | ctx8k_out1k (256 req, enwik8) | H200 TP2 EP2 DP1 | popularity.json, trace.csv | v2, 40 layers x 256 experts, 4,170 records |
| `qwen3_235b_thinking_fp8/vllm/ctx8k_out1k/capture/20260803/` | `Qwen/Qwen3-235B-A22B-Thinking-2507-FP8` | vLLM | — | ctx8k_out1k (256 req, enwik8) | H200 TP4 EP4 DP1 | popularity.json, trace.csv | v1, 94 layers x 128 experts, 4,172 records |

The workloads:

- **diverse_100**: ServingStudioSim `trace/diverse_100.csv`. It has 100 requests
  with input 256–131,070 and output 1–8,192 tokens, both log-uniform, and
  Poisson arrivals at a mean of 1 req/s. The four 2026-08 vLLM and SGLang
  popularity captures, and the GLM-5.3-Flash no-spec corpus, replay it at its
  trace times with no client concurrency cap. The two Inkling corpora replay it
  at trace times with at most 100 requests in flight. The other corpora, and
  the popularity files beside them, replay it at trace times with at most 64
  requests in flight.
- **c32_long**: ServingStudioSim `trace/c32_long.csv`. 64 requests, eight of
  each pair in input {256, 1024, 2048, 4096} x output {128, 256}. All arrive
  at t = 0 and replay saturated at concurrency 32.
- **ctx8k_out1k**: ServingStudioSim `trace/ctx8k_out1k.csv`. 256 requests of
  8,192 input and 1,024 output tokens, all at t = 0, at concurrency 64. The
  Qwen3.6 capture's `trace.csv` has the same rows but writes `arrival_time` as
  `0.000000`, so it is not a byte copy of the spec.
- **shape_grid_128**: ServingStudioSim `trace/shape_grid_128.csv`. Four
  requests for each pair in input {128 … 16,384} (8 values) x output {32, 128,
  512, 1024}. All arrive at t = 0 and replay at concurrency 64.
- **quadrant_c48**: no `trace/` spec. Case 07 of the GLM-5.2 spec5 alignment
  campaign, with 192 requests over eight IO shapes, saturated at concurrency 48.
- **balanced_c32**: ServingStudioSim `trace/balanced_c32.csv`. 256 requests, 32
  of each pair in input {256, 1024, 2048, 4096} x output {128, 256}, saturated
  at concurrency 32.

The prompt source is part of the workload. The H200 captures drew their prompts
from enwik8 and the B200 captures from enwik9. Each `provenance.json` records
the prompt file's checksums.