nvidia/aisimulate-fpm-dataset

AISimulate FPM Dataset

Forward Pass Model (FPM) libraries and independent latency measurements. This private repository is the input-data source for FPM Gym.

Layout

data/
  <org>--<model>/<system>/<framework>/<framework-version>/<parallelism>/
    manifest.json           # flat metadata for the promoted snapshot
    fpm/                    # optional self-benchmark FPM libraries and sidecars
      provenance/           # FPM producer configurations
    measurements/           # live or independent measurement evidence
      manifest.json
      <truth files>          # manifest role: truth or derived_truth
      provenance/           # configuration, window, and manifest helpers

  history/<org>--<model>/<system>/<framework>/<framework-version>/<parallelism>/
    aisim-commit-<sha-or-unknown-id>/
      manifest.json
      fpm/
      measurements/

catalog/                    # global discovery indexes
schemas/
audit/
scripts/manage_dataset.py

Model directories use the exact case-sensitive Hugging Face model ID with / replaced by --. Example active leaf:

data/MiniMaxAI--MiniMax-M2.7/h200-sxm/vllm/0.25.1/dep4/

Campaign names never define canonical paths. They remain only in provenance. Multi-configuration source Parquets are split by their exact runtime identity, so a parallelism leaf cannot silently contain rows for another configuration. Usable measurement truth is flat under each measurements/ directory. Supporting summaries, configurations, windows, and manifests retain useful source grouping under measurements/provenance/. Only configurations explicitly linked to an FPM artifact are stored under fpm/provenance/.

Each leaf manifest.json is flat. Model, hardware, framework, parallelism, AISim commit, and collector fields apply directly to the promoted data. There are no identity or current wrappers. Its optional history list points to older immutable snapshots.

Measurement-only configurations use fpm: [] and omit the fpm/ directory. They must contain validated measurement truth; an entirely empty or summary-only configuration is not admitted through this path. The catalog records fpm_file_count: 0 independently of measurement availability. Missing predictor data does not invalidate a measured point.

Four AgentX captures are published at standard configuration leaves. See AgentX collection and processing for their exact identities, grouped representation, provenance, and reproducible checks.

Kimi K3 DCP self-benchmark

The TP8+DCP8 self-benchmark configuration adds 669 primary balanced points, 14 synthetic-attention boundary comparator points, and 56 nonuniform prefill points preserved as calibration provenance. The aic_fpm_forward_perf v6 schema records optional DCP separately from independent CP; this configuration explicitly records dcp: 8. Consumers must preserve that identity or report DCP as unsupported. Existing v6 artifacts and the older Kimi TEP8 configuration remain unchanged. Sidecars and catalogs record collection_method and source_kind; these calibration inputs are not independent measurement truth.

Artifact and measurement contracts

FPM Parquets are predictor inputs. The existing AIC libraries use schema name aic_fpm_forward_perf and schema version 6; they do not have a measurement protocol. Their logical schema is schemas/aisim-fpm-forward-v6.schema.json.

The pinned DSV4-Flash, DSV4-Pro, Kimi-K3, and GLM source Parquets contain reviewed dtype annotation errors. During publication, a strict campaign- and model-scoped policy corrects only these declared fields:

• DSV4-Flash: MoE fp8 → w4a8_mxfp4_mxfp8; FMHA fp8 → bfloat16.
• DSV4-Pro: MoE fp8_block → w4a8_mxfp4_mxfp8.
• Kimi-K3: MoE fp8_block → w4a16_mxfp4.
• GLM-5.2-NVFP4: FMHA fp8 → bfloat16.

DSV4-Flash and GLM FMHA resolution is also corrected from checkpoint_native to aic_data_fallback_from_fp8. The importer fails if the campaign, model, or source labels differ from the reviewed policy. It preserves GEMM, weight quantization, latency, workload kind, batch size, token coordinates, row order, and row count. Each affected sidecar records the runtime-dtype-annotation-v1 policy and exact source-to-published labels.

Usable measurement bundles declare one of two semantic protocols:

• forward-pass-measurement-v1:

  • Normalizes exact scheduler observations into one synchronized iteration.
  • Retains one measurement for every contributing rank and caches max_rank_wall_time as the default complete-iteration truth. Consumers may derive another latency policy from the authoritative rank measurements.
  • Distinguishes two source kinds:
    • self_benchmark: a benchmark producer groups ranks by benchmark_id.
    • rank_event_stream: rank-local events are either evaluated directly for one rank, joined using a declared corrected receive-time window, or supplied as pre-grouped rank lists with uploader-provided membership and provenance.
  • producer identifies the component that creates rank-local FPM records. Optional collector provenance identifies a separate capture component; it is required when grouping by listener_receive_time_window.
  • grouping records the membership method and its authority. Consumers do not implicitly join ranks by local counters, file position, or timestamp equality. With pre_grouped, membership is already stored; inferred alignments remain labeled derived and retain their audit provenance.
  • Schema: forward-pass-measurement-v1.schema.json.

• forward-pass-record-v1 contains a reduced, self-contained point: scheduled batch/token coordinates plus observed latency. The current DSV4-Pro reduced measurement records use this protocol because their raw streams are external. See schemas/forward-pass-record-v1.schema.json.

Workload kind (prefill, decode, mixed, or empty) is derived per record; it is not part of the protocol ID. Producer names, traffic sources, collection topology, and release labels such as r4, r6pin, and r16 stay in provenance.

Summary-only artifacts cannot recreate predictor input. They set measurement_protocol_id: null and use evidence_format_id, such as wave-summary-v1 or bucket-summary-v1. They remain visible as supporting evidence but are not usable measurements.

See measurement protocols for field meanings, serialization rules, and normalization behavior.

Promotion and history

One reviewed snapshot is promoted for each full configuration. The identity includes model revision, system, framework version, all parallel dimensions, weight quantization, and KV-cache dtype.

• Explicit release lineage decides between generations such as R17/R16 and DSV4-Pro r9/r8/r3 and DEP8 r6pin/r4.
• A later reviewed campaign supersedes an earlier campaign only where their full configuration identities overlap.
• Legitimate variants from one promoted snapshot, such as KV-warm and KV-off, remain together.
• Superseded FPM and measurement artifacts move together under data/history/.
• A valid recorded producer SHA uses aisim-commit-<first-8> as the snapshot directory. Missing producer SHAs use aisim-commit-unknown-<deterministic-content-id> and keep aisim_commit: null; the importer never invents a commit.

The top-level manifest records collected_by and how that attribution was derived. aisim_commit describes the producer code when known. provenance.source_revision separately records the audited AISimPlayground source commit.

FPM Gym evaluation

This repository stores source evidence, not evaluation output. FPM Gym:

• Parses the measurement artifacts for a selected configuration snapshot.
• Runs AISim against the matching FPM artifact at evaluation time.
• Derives measurement and prediction states independently.
• Applies exclusions and computes coverage and accuracy metrics.

No predictions, normalized comparison rows, selector mappings, or accuracy metrics are persisted here. Configuration identity comes from the leaf path and manifest. Workload coordinates come from the FPM and measurement contents.

See the evaluation state policy for the measurement and prediction state tables, exclusion rules, and metric denominators. The trend page can include history by following manifest history references or filtering catalog/index.parquet by snapshot_status.

Publication policy

• Consumers must pin a full Hugging Face commit SHA.
• Discovery starts from catalog/index.json or an active leaf manifest.
• Consumers verify every recorded SHA-256 before loading data.
• FPM Gym records the pinned dataset commit and AISim commit for each evaluation.
• Missing or invalid measurement evidence remains visible as a gap; it is never scored.
• Raw logs, reproduction scripts, reports, redundant copies of rank streams, and wholesale prediction directories are not mirrored.

The repository must remain private. Retained provenance contains internal paths and network metadata, and the source has no approved redistribution license.

Audit notes

• DSV4-Pro raw serving streams are external; normalized score truth and its source hash are retained.
• Usable measurement truth files are flat under measurements/; summaries, serving configs, window maps, and helper manifests are under measurements/provenance/.
• DSV4-Pro benchmark-lane configs are linked from the matching FPM metadata and stored under fpm/provenance/.
• DSV4-Pro TEP8 r9 is active. Diagnostic r8 and superseded r3 evidence are in history.
• DSV4-Pro DEP8 r6pin (worker-pinned prefill lanes, decode rows identical to r4) is active; the r4 library and its evidence are in history.
• MiniMax H200 R17 is active for dep4 and pure-tp4; R16 is history. The later static snapshot is active for H200 tep4.
• MiniMax B200 repaired evidence supersedes the earlier decode-only E9 snapshot.
• MiniMax B200 dep4/c4 is quarantined, and dep4 prefill has no retained measurement evidence.
• GLM and MiniMax H200 static anchor inputs are incomplete.
• GLM-5.2 GB200 DEP16 (data/nvidia--GLM-5.2-NVFP4/gb200/vllm/0.28.0/dep16/) publishes the paired-rows decode and chunk-boundary prefill self-benchmark library with canonical forward-pass-measurement-v1 iterations of the 16/16 disaggregated truth run, one file per engine role, reconstructed at import from the raw rank-event streams with the campaign's per-node clock correction (estimated for prefill; declared zero for decode, where no shared step exceeds 150 ms) and 8 ms half-open window (listener_receive_time_window, exact decimal timestamp arithmetic, every rank record retained, max_rank_wall_time cached). The raw streams, bucketed tables, reports and aiperf exports are supporting evidence under measurements/provenance/. The campaign's published fidelity figures used the median wall over busy ranks; on complete decode steps the maximum exceeds the median by about 1% at the median (1.7% at p90, 8% at p99). Decode is 3.6% and prefill 24.0% step-level MAPE against the 16/16 disaggregated truth (17.2% when all 16 ranks prefill); vLLM 0.28.0 is not a curated aisimulate version slot. Its source dtype labels already carry the runtime identity, so no publish-time correction applies. The superseded 12-row decode pair is discarded.

See source mapping, reconciliation, and validation output.

Validate or refresh

Validation is source-independent:

uv run --with pyarrow==25.0.1 --with jsonschema --with ijson python scripts/manage_dataset.py validate

Rebuild from the audited internal checkout:

uv run --with pyarrow==25.0.1 --with jsonschema --with ijson python scripts/manage_dataset.py import \
  --source-root /path/to/AISimPlayground/playground \
  --replace

The importer rejects any source revision other than the pinned audited commit. It also refuses to overwrite externally contributed measurement-only leaves. Rebuild the base import into a fresh destination, then reapply reviewed external ingestions. This prevents a Playground refresh from silently deleting AgentX data.

For the pinned AgentX package, scripts/ingest_agentx.py performs a collision- checked migration and regenerates the standard catalogs. Grouped-list reading and canonical normalization live in scripts/pre_grouped.py; its validator uses stored membership and does not rerun alignment or impose a receive-time window.

DeepSeek V4.1 GB200/H200/B200 TP4 full and decoder bounded

The PR #304 profile guide covers six independently collected TP4 profiles: GB200, H200 and B200, each full and decoder_bounded. Each has 145 source-qualified native calibration rows and a separate 38-geometry heldout set. The guide lists coverage, heldout accuracy, replay entry points and limitations, including the 12 geometries excluded by the bounded aggregate API and the retained B200 full prefill errors.

Inkling GB300 calibration import

The inkling-gb300-three-run-20261007 campaign covers thinkingmachines/Inkling-NVFP4 revision 42a75a99a40eb2ba1e0717db6357a0bf15205044 on GB300 with vLLM 0.27.0, NVFP4 weights and BF16 attention/KV. This publication contains pure TP4, pure TP8 and DEP4, with three independent full-grid launches per phase (prefill and decode), for 18 launches in total. DEP8 is deferred and excluded from this publication.

The schema-7 estimator takes the maximum latency across DP ranks within each launch, then the median across all three launches. The original source measurement is excluded from the estimator; source comparability remains required. The coefficient of variation (CV) must be at most 5%. Temporal split-half drift is not_assessed for three runs. Held coordinates and their observations remain in the proof populations and are excluded from the published FPM table. The same importer and validator also support the legacy inkling-gb300-six-run-20261005 policy, with six-launch medians and its additional 5% temporal split-half drift gate.

Run scripts/ingest_inkling_six_run.py export --descriptor <private-descriptor.json> --output <new-package> in the pinned producer environment, where the original campaigns are available. The descriptor names topology, evidence_date, parquet (the merged exact-topology canonical pair), optional metadata, and cells, each containing repeatability_dir and its complete assessment path. Export reassesses the original campaigns without scheduling GPUs, preserves canonical duplicate selection and all held observations, and creates a portable package. Import locally with scripts/ingest_inkling_six_run.py import --dataset-root . --package <new-package>. Both commands are offline; neither uploads data or changes repository visibility.

The public projection explicitly selects nested measurement, graph, runtime and CPU fields. It aliases host/process/thread identity while retaining rank placement and affinity relationships. Original artifact/signature hashes remain historical provenance; projected launch files, population JSON, Parquet and sidecar each receive hashes of their actual new bytes. Original files remain in the campaign archive and are required for the original collector resume/reassessment commands. The portable validator independently checks raw internal timing reductions, the declared three- or six-run estimator and gates, row/population bindings, zero-KV duplicate selection, and evidence-backed workload imbalance holds. Latency imbalance alone does not exclude a point.

The proof inventory must include exactly one prefill and one decode population, even when an entire phase is held. Export rederives formal KV provenance with the canonical first-launch aggregator and binds every native seed to the declared launch observations and rank preparation. Canonical legacy prefill keeps formal n/a; its native not_applicable or real_prefix evidence remains separate. This campaign does not claim either generic KV warm-up skip exemption. The validator rejects extra fields recursively, and the Inkling metadata, import proof and launch JSON paths use Git LFS.

These are calibration inputs with scope measurement_repeatability_only; serving accuracy is not_assessed. Configuration manifests use v4 and measurement manifests use v5, with no truth files, collection_runs: [], and a null protocol. Import appends to catalog v6 without rerunning the historical measurement migration; campaign identity remains in the checked portable proof rather than normalized configuration provenance. Holdout, replay, and serving accuracy reports remain outside this dataset. The format extension is documented in the Inkling schema-7 contract.

The original campaign publication and qualification used AISimulate 7d2c0a692ced4a433211819705958c04463dc146. Ordinary FPM loading is now verified with AISimulate PR #379 at commit 20e3eb9d52325a3e5a24e34c54dd09da130346fd: the loader consumes each aggregated Parquet/metadata pair without campaign files, preserves all 10,264 retained latencies, and returns unchanged results for 10,849 checked exact and interpolated queries. This is a loader and numerical-regression check, not an independent accuracy measurement. Use that commit, or a version containing its loader change; compatibility with earlier AISimulate versions is not asserted. Version provenance keeps planning, actual collection, original qualification, and later consumer validation revisions separate.

Profile	Retained prefill coordinates	Retained decode coordinates	Held coordinates
TP4	2,821	788	92
TP8	2,740	938	180
DEP4	2,429	548	132

The archived holdout evaluation is not a full serving-accuracy pass: TP8 decode has 35.3521% p95 relative error against a 20% target, and TP4 and TP8 prefill each have one unsupported holdout. These historical results have not been erased by later loader or query-coverage improvements.

The 1,560-request CPU replay was attempted for TP4, TP8 and DEP4; all three are incomplete. Each exits with code 1 at its first observed unsupported prefill query with batch size 1, 1,536 prefill tokens and 253,952 KV-read tokens, without hitting a resource limit. Before stopping, TP4 resolved 1,541 measured and 427,477 interpolated queries; TP8 resolved 1,577 and 433,460; DEP4 resolved 2,049 and 473,890. These counts are native lookup resolutions, not completed requests; the failed CLI does not report a completed-request count, and later coverage gaps remain unassessed. Nearby measured points include (prefill=1,024, KV=254,944) and (prefill=2,048, KV=253,920), but they do not provide the same-batch, two-sided support required by the current token-first or KV-first direct interpolation. No extrapolation, new collection or interpolation change was used to turn these attempts into a pass.

A separate frozen 24-request serial play completes prediction with zero unsupported queries on all three profiles. Each profile also completed three independently reviewed matched-serving repetitions (72 requests), with protocol, runtime and memory checks. TP4 retained its first-repetition TTFT p95 error of 20.37%; DEP4 retained all three TTFT p95 errors of 20.87–21.02%, above the unchanged 20% reference threshold. TP8 TTFT p95 error was 12.21–16.05% and TPOT p95 error was 4.46–4.52%. DEP4 had observed attention-rank imbalance; no accuracy samples were excluded. TP8 ran on AWS GB300 hosts while TP4 and DEP4 ran on OCI GB300 hosts, with a recorded driver difference; performance equivalence is not assumed. These campaign-local diagnostics use reconstructed prompts and include original trace idle gaps, so they do not establish canonical Stage 6 qualification, saturated throughput or broad serving accuracy. The validation record preserves the repetitions and limitations separately from these calibration tables. The table metadata remains serving_accuracy: not_assessed; the accepted larger-replay gap and original holdout results remain unchanged.

Measurement v5 migration and collection runs

Catalog v6 points to configuration v4 and measurement v5 manifests. Measurement protocols keep their scientific meaning; each file separately declares format, storage_schema (including version), logical_row_count, ordering_index, SHA-256, and immutable source references. Readers of older pinned revisions must retain legacy JSON/CSV support.

Bulk iterations, reduced records, iteration indexes, and request metrics use the explicit Arrow schemas in scripts/measurement_storage.py: Zstd level 3, 16,384-row row groups, and bounded conversion batches. Grouped iterations retain rank lists and their original order, completeness and grouping authority. Ungrouped observations remain explicitly ungrouped. Nanoseconds use int64; latencies use float64; missing values are distinct from zero. Index references use record_file_id plus one-based record_id, not physical Parquet row positions. JSON remains canonical for manifests, collection settings and provenance. Original compressed raw captures remain evidence, not a second active truth representation.

collection_runs separates collection type (self_benchmark, static_serving, trace_replay, unknown), benchmark preset, collector, replay mode, dataset, workload, and serving topology. AgentX is recorded through an explicit preset; a dataset or filename does not imply its replay semantics. Numeric/string unknowns are null; categorical unknowns are unknown. not_applicable is distinct.

collection_runs[].serving.layout records deployment independently of collection type: agg uses the same workers for prefill and decode; disagg separates the two roles. Both layouts apply to self-benchmarks when supported by capture evidence. Use unknown when deployment information is missing; use not_applicable only for captures explicitly outside a serving deployment. Starting a real engine or recording prefill/decode phases alone does not establish the deployment layout. worker_roles retains prefill, decode, aggregated, or unknown; topology independently records a known topology such as 1P1D.

Each run binds truth file IDs to disjoint half-open logical record ranges. A null range means the whole file. Every unattributed truth record belongs to an explicit unknown run; empty bundles invent no runs. Configuration and evaluator selection must restrict metadata to the truth actually used. Source references declare which fields they support. Canonical paths and labels omit campaign rounds/scheduler IDs; unchanged upstream evidence and immutable source references preserve original names.

Truth Parquet filenames include verified concurrency settings, for example iterations-c16-decode.parquet. Multiple values with the same recorded unit use their minimum and maximum, such as iterations-c16-128-decode.parquet; this does not imply every intermediate value was measured. The manifest retains the full set of settings. A range with unattributed records adds -unknown, for example iterations-c16-128-unknown-decode.parquet. Missing settings, unknown or conflicting units, and a single known setting mixed with unknown records retain directory-local numbers such as iterations-01.parquet or records-01.parquet. The phase label preserves the source filename's distinction. Existing numbers stay fixed; new numbered files append after the highest number. Provenance retains descriptive source basenames and explicit concurrency folders, for example provenance/c64/agx_windows_decode.tsv, rather than asset-<hash>/evidence.tsv. Same-name assets receive numeric suffixes without overwriting existing captures; converted supporting indexes use names such as iteration_index.parquet. The manifest's measurement_file_id remains the stable identity. Collection metadata and ordering_index are authoritative; names never fill missing metadata or determine evaluation order. Renaming does not rewrite file contents. Immutable source URLs retain their original names, and original archives retain their format.

Request Parquets record run/request identity, original source record, stage, outcome, observed input/output tokens, request-start offset, TTFT, TPOT and E2E. timing_boundaries_compatible gates TPOT derivation. The matched Kimi trace and recovered AIPerf exports supply chart populations; warmup, profiling, drain and outcomes remain explicit. Missing request metrics are never reconstructed from percentiles or FPM iterations.

The migration is repeatable and all active importers normalize at the shared catalog publication boundary. Validate or rebuild the complete audit:

uv run --with pyarrow==25.0.1 --with jsonschema --with ijson \
  python scripts/migrate_measurements.py --root /path/to/migrated-dataset \
  --legacy-root /path/to/legacy-dataset --playground /path/to/AISimPlayground

Run this on an isolated checkout. The legacy source is never modified. The migration audit covers all 39 snapshots, asset renames, source hash verification, recovered runs, unknown fields and chart availability. Static serving sweeps are distinct from trace replay. AIPerf summaries without verified request/capture alignment remain unresolved. Deploy compatible consumers first, evaluate an immutable migrated HF branch, then promote HF main after those consumers are available. Historical evaluations remain unchanged.

Request evidence recovery

The request evidence recovery inputs in audit/request-metrics-recovery-inputs.json pin 19 recovered AIPerf captures to existing measurement truth. Capture matching uses the already-published summary hash or byte-identical uncompressed FPM streams. Original metric-only JSONL exports are losslessly compressed under opaque run paths; AIPerf summaries remain JSON. These archives retain integer nanosecond timestamps and original source-record order. They contain benchmark metadata and metrics, not prompts or generated responses. Their original host, path, file hashes and timezone are recorded in the recovery inputs.

These are NVIDIA measurement artifacts from the same collections already represented in this dataset. They were retrieved from ComputeLab, Slurm and Kubernetes PVC storage on 2026-10-09. The AgentX collector source is SemiAnalysisAI/aiperf at 754356e9; Playground collection evidence is pinned in the existing manifests and recovery audit. Request timing is client-visible; FPM truth remains forward-pass latency.

The source audit also preserves the original H200 benchmark logs and their file inventory under audit/request-metrics-source-evidence/. All 84 benchmark logs disable per-request result export. Their random-dataset arguments conflict with ShareGPT in the copied driver documentation, so dataset identity remains unknown for these captures.

The request recovery audit covers all 39 current and historical manifests. It distinguishes exports recovered from storage, exports disabled by the collector, missing source directories, supporting-only windows and unattributed records. Together with five existing Kimi runs, 24 runs have request metric assets. Historical Gym evaluations remain unchanged until a new evaluation selects this migrated revision.

Recover and refresh catalogs with the shared publication command (requires the archived assets in this branch):

python scripts/migrate_measurements.py --root .
python scripts/migrate_measurements.py --root . --validate-only
python -m pytest scripts/test_recover_request_metrics.py

Recovery checks archive hashes, published capture identity, model, benchmark ID, profiling windows and request counts before adding canonical request Parquets. TPOT uses AIPerf inter_token_latency, whose end boundary is the last content token; HTTP response-completion latency is not substituted. Naive timestamps are interpreted using the capture's verified timezone. Nanosecond integers are subtracted before converting offsets to milliseconds.

Only collection metadata bindings change: GLM GB200 groups require every rank's receive time to fit one profiling window. Historical MiniMax B200 uses the strict interior of its verified source windows because producer logs and old scoring code disagree on endpoint conventions. Boundary records stay unknown. Truth files, predictor inputs, rank membership and evaluation order are unchanged. Recovered E9 exports omit an explicit replay profile and preset; those fields remain unknown rather than inferring AgentX from a directory name.

GLM-5.3-Flash GB300 TP1/TP2/TP4 (AISimulate PR #324)

The GLM-5.3-Flash guide covers nine GB300 calibration tables for zai-org/GLM-5.3-Flash (FP8) and nvidia/GLM-5.3-Flash-NVFP4. All are collected with engine-native forward-pass metrics (FPM) on the default serving configuration, with prefix caching on. Both backends are final. Admission code is scripts/glm53flash.py; the source revision is AISimulate 055dcc1c. The leaves use configuration manifest v4 and calibration-only measurement manifest v5 (files: [], collection_runs: []); campaign names and job IDs remain only in each leaf's source evidence under fpm/provenance/. Admission checks bind model, hardware, parallelism, quantization, and snapshot identity to the reviewed table, and require the configuration, measurement manifest, and catalog entries to agree. Checksums alone do not establish configuration identity. The shared catalog-v6 validator dispatches GLM, Inkling, DSV4.1, and self-benchmark imports to their own admission policies and requires a unique validated snapshot for each imported catalog entry. GLM and Inkling imports use the shared Parquet catalog writer so remove/re-import round trips preserve catalog checksums.

• vLLM: stock v0.31.0 (campaign glm53flash-vllm-v031-native-fpm). FP8 TP2/TP4 and NVFP4 TP1/TP2/TP4; FP8 does not fit on one GPU, so TP1 is NVFP4 only.
  • latency_ms is the median of ten repetitions of the engine-native Dynamo InstrumentedScheduler FPM wall_time, with vLLM's own scheduler running every request.
  • Prefill inputs are align-4 (prefix and new-token lengths on the 4-token IndexPool grid); this is a collection rule, not a prediction restriction.
• SGLang 0.5.20 (campaign glm53flash-pr324-native-fpm). FP8 and NVFP4 at TP2/TP4. latency_ms is the median of ten repetitions of the native rank-0 ForwardPassMetrics wall_time (DeviceTimer), with the radix cache on.

Holdout FPM MAPE, prefill / decode (gate 10% per phase; all 18 phases pass):

Backend	FP8 TP2	FP8 TP4	NVFP4 TP1	NVFP4 TP2	NVFP4 TP4
vLLM 0.31.0	2.16% / 1.99%	1.28% / 1.63%	2.35% / 1.98%	3.68% / 1.53%	2.47% / 1.13%
SGLang 0.5.20	1.57% (n=142) / 1.99%	2.08% / 1.27%	n/a	2.44% / 1.79%	2.19% / 1.13%

SGLang FP8 TP2 is missing two calibration points, which got no radix hits on the stock server; as a result, two of its 144 prefill holdout points are outside the collected domain and are not predicted. Nothing is imputed.

The earlier custom-timer tables (glm53flash-pr324, glm53flash-pr324-prefill-graph), the native-FPM vLLM 0.30.0+glm53tail tables and the superseded vLLM NVFP4 TP4 table from calibration-decode job 904065 were never merged; the admission policy rejects every one of their hashes.