diff --git a/README.md b/README.md index 5208d010..435b99e2 100644 --- a/README.md +++ b/README.md @@ -25,9 +25,9 @@ reproducible benchmarks, and [test results](performance/). [validation checks](docs/PROFILE_VALIDATION.md). ## Profiles - -KV is approximate total token capacity. The shared TP4 figure is for DCP1; -the TP2 figure is a reference estimate. `—` means no capacity +KV is approximate total token capacity. The shared TP4 figures are per +layout: DCP1 ~2.28M, DCP4 ~8.36M (both 24 GiB FP8 KV per rank). The TP2 +figure is a reference estimate. `—` means no capacity is recorded. Startup reports the actual capacity, which is separate from the per-request Context limit. @@ -36,6 +36,7 @@ per-request Context limit. | Model / predictor | Serving stack | Transport | Layout | Context | Sequences | KV (tokens) | Guide | |---|---|---|---|---:|---:|---:|---| | **GLM-5.3 Flash NVFP4-Spark · native MTP3 + SparkCache** | [Generic R33 SparkRing image](runtime/sparkring/jovian-r33/image/README.md) | [Mesh + dual-domain NCCL](runtime/glm53-spark-mtp3-mesh/README.md) | TP4/DCP1 | 1M | 16 | ~2.28M | [Ring quickstart](docs/GLM53_TP4_PREFILL_QUICKSTART.md) | +| **GLM-5.3 Flash NVFP4-Spark · native MTP3 + SparkCache** | [Generic R33 SparkRing image](runtime/sparkring/jovian-r33/image/README.md) | [Mesh + dual-domain NCCL](runtime/glm53-spark-mtp3-mesh/README.md) | TP4/DCP4 | 1M | 16 | ~8.36M | [DCP4 record](performance/records/glm53-flash/r33-image020-tp4-dcp4-sparkcache-20260911.md) | | GLM-5.3 Flash NVFP4-Spark · native MTP3, switched | [Shared SparkRing source image](runtime/sparkring/source_image/README.md) | Operator-selected NCCL links | TP4/DCP1 | 1M | 16 | — | [Switched quickstart](docs/GLM53_SWITCHED_TP4_QUICKSTART.md) | | GLM-5.2 EXL3 3.5-bpw | [SparkRing vLLM/ExLlamaV3 build](runtime/exl3-r7/README.md) | [SIRCL + NCCL](docs/SIRCL.md) | TP4/DCP4 | 1M | 16 | ~1.2M | [Quickstart](docs/GLM52_35BPW_QUICKSTART.md) | | DeepSeek-V4-Flash-0731 | [SparkRing vLLM/B12X image](runtime/deepseek0731-gb10/README.md) | [Patched NCCL](spark_transport/nccl/README.md) | TP4/DCP1 | 1M | 32 | ~1M | [Quickstart](docs/DEEPSEEK_V4_FLASH_QUICKSTART.md) | @@ -81,7 +82,7 @@ For deployment with the shared image, use the matching two- or four-Spark entry | Profile | Layout | Retained guide | Replacement | |---|---|---|---| -| NVFP4-Spark MTP3 cache/checkpoint mesh | TP4/DCP4 | [Pinned cache/checkpoint setup](docs/GLM53_MTP3_CACHE_CHECKPOINTS_QUICKSTART.md) | [Shared-image MTP3 profiles](docs/GLM53_TP4_PREFILL_QUICKSTART.md) | +| NVFP4-Spark MTP3 cache/checkpoint mesh | TP4/DCP4 | [Pinned cache/checkpoint setup](docs/GLM53_MTP3_CACHE_CHECKPOINTS_QUICKSTART.md) | [R33 DCP4 SparkCache](performance/records/glm53-flash/r33-image020-tp4-dcp4-sparkcache-20260911.md) | | NVFP4 with BF16 DFlash2 | TP4/DCP1, DCP2 or DCP4 | [Pinned DFlash2 setup](docs/GLM53_JJ_R8_GB10_SPARKCACHE_TP4_QUICKSTART.md) | [Shared-image native MTP3](docs/GLM53_TP4_PREFILL_QUICKSTART.md) | | NVFP4-Spark MTP3 with 5 GiB KV per rank | TP2/DCP1 | [Pinned TP2 setup](https://github.com/FujitsuPolycom/sparkring/blob/2f01b6ee8f6173745c4b6b165498bbef82fc03f1/docs/GLM53_FLASH_SPARK_TP2_EXPERIMENTAL_QUICKSTART.md) | [Shared-image NVFP4-Spark TP2](runtime/profiles/glm53-flash-spark-tp2/README.md) | | Original NVFP4 MTP3 with 6.75 GiB KV per rank | TP2/DCP1 | [Pinned original-NVFP4 setup](https://github.com/FujitsuPolycom/sparkring/blob/2f01b6ee8f6173745c4b6b165498bbef82fc03f1/runtime/profiles/glm53-flash-nvfp4-tp2/README.md) | [Shared-image NVFP4-Spark TP2](runtime/profiles/glm53-flash-spark-tp2/README.md) | diff --git a/docs/GLM53_TP4_PREFILL_QUICKSTART.md b/docs/GLM53_TP4_PREFILL_QUICKSTART.md index 456053ff..183ebb05 100644 --- a/docs/GLM53_TP4_PREFILL_QUICKSTART.md +++ b/docs/GLM53_TP4_PREFILL_QUICKSTART.md @@ -7,8 +7,11 @@ The exact evidence and limits are in the This guide downloads or builds a source-pinned image and selects it through SparkRing's existing managed mesh deployment. It uses four NVIDIA Sparks, native MTP depth three, continuation-prefill coalescing, token-sharded mHC, and NCCL across both -host PCIe domains. DCP1 is the qualified profile. This R33 profile contract does -not expose a DCP4 launch profile. +host PCIe domains. DCP1 is the baked-in qualified profile. A TP4/DCP4 +profile (SparkCache and cache-disabled variants) is available through the +profile-contract overlay (`R33_PROFILE_CONTRACT_HOST_ROOT`; see the +Reproduction section of the record) and is bounded-qualified in +[r33-image020-tp4-dcp4-sparkcache-20260911](../performance/records/glm53-flash/r33-image020-tp4-dcp4-sparkcache-20260911.md). | Setting | DCP1 profile | |---|---| @@ -21,7 +24,7 @@ not expose a DCP4 launch profile. | Coalescing and mHC prefill sharding | Enabled | | TP4 mesh and dual-domain NCCL | Enabled | | SparkCache connector / compact index cache | Enabled / disabled | -| DCP top-k owner exchange | Disabled; its implementation requires DCP4 | +| DCP top-k owner exchange | DCP1: disabled (implementation requires DCP4). DCP4 overlay: active (`full-CKV gather` prefill path) | The maximum context is a request-length limit. It is distinct from the total KV capacity reported at startup and does not establish a tested concurrency diff --git a/docs/profiles/README.md b/docs/profiles/README.md index abd9c36a..7541e7b3 100644 --- a/docs/profiles/README.md +++ b/docs/profiles/README.md @@ -33,6 +33,7 @@ published configuration hash. |---|---|---|---| | GLM-5.3 Flash NVFP4-Spark with native MTP3 | four-Spark mesh, TP4/DCP1 or DCP4 | **research-only** shared-source profiles without SparkCache; no R33 cache qualification inherited | [Source profiles](../../runtime/sparkring/source_image/README.md), [image source lock](../../runtime/sparkring/source_image/glm53-tp4-lock.json) | | GLM-5.3 Flash NVFP4-Spark with MTP3 and SparkCache | four-Spark ring, TP4/DCP1 | R33: **qualified** for bounded startup, 112K exact-answer prefill and 8K restart restore; 24 GiB KV/rank; configured 1M request limit is not a tested 1M workload | [Quickstart](../GLM53_TP4_PREFILL_QUICKSTART.md), [qualification](../../performance/records/glm53-flash/r33-image020-tp4-sparkcache-20260911.md) | +| GLM-5.3 Flash NVFP4-Spark with MTP3 and SparkCache | four-Spark ring, TP4/DCP4 | R33: **qualified** for bounded startup, 37K exact-answer prefill, prefix reuse, mHC 8192/2048, and 8K restore after planned restart and after fault injection; 24 GiB KV/rank (~8.36M tokens); configured 1M request limit is not a tested 1M workload; managed fabric installation required before launch | [Record](../../performance/records/glm53-flash/r33-image020-tp4-dcp4-sparkcache-20260911.md), [activation receipt](../../runtime/sparkring/jovian-r33/profiles/evidence/tp4-dcp4-sparkcache-activation-20260911.json) | | GLM-5.3 Flash NVFP4-Spark with MTP3 and SparkCache | two Sparks, TP2/DCP1, one DAC and both host PCIe domains | R33: **qualified** for bounded startup, 8K restart restore and C8 correctness; managed B12X, 7.5 GiB KV/rank; configured 1M request limit is not a tested 1M workload | [Quickstart](../../runtime/profiles/glm53-flash-spark-tp2/README.md), [qualification](../../performance/records/glm53-flash/r33-image020-tp2-sparkcache-20260911.md) | | GLM-5.3 Flash NVFP4-Spark with native MTP3 | switched four-Spark TP4/DCP1 | Provided as-is; switched hardware not validated | [Quickstart](../GLM53_SWITCHED_TP4_QUICKSTART.md) | | DeepSeek-V4-Flash-Vision-Exp with DSpark | four-Spark cycle, TP4 | Anemll image and MiaAI-Lab recipe with SparkRing patched NCCL; contributor-reported observations; independent reproduction is not claimed | [Artifact contract](../../runtime/deepseek-vision-exp/profile.json), [recipe](../../recipes/deepseek-v4-flash-vision-exp-tp4.json), [quickstart](../DEEPSEEK_V4_FLASH_VISION_EXP_TP4_QUICKSTART.md) | diff --git a/performance/records/glm53-flash/r33-image020-tp4-dcp4-sparkcache-20260911.md b/performance/records/glm53-flash/r33-image020-tp4-dcp4-sparkcache-20260911.md new file mode 100644 index 00000000..d7cf9398 --- /dev/null +++ b/performance/records/glm53-flash/r33-image020-tp4-dcp4-sparkcache-20260911.md @@ -0,0 +1,214 @@ +# Generic R33 image TP4/DCP4 SparkCache qualification + +Status: **qualified** for the bounded functional checks below; served from +the unchanged published R33 image. Throughput values are **research-only** +observations and were not recorded in this session's harness. + +## Conditions + +Four NVIDIA GB10 systems ran the published generic R33 image +`ghcr.io/fujitsupolycom/sparkring@sha256:1328a4f6f483014021a66a757012793629bd054d28d0fe4d5e581fa4aed776ef` +(config ID `sha256:3c7779ad71dd0d5d6fae4c98e04b94c377429306158c2259fc44635892b8b8e4`). +The deployment used the managed mesh renderer with the DCP4 profile +templates added to the R33 profile contract in the same change, rendered +against the existing `tp4-dcp1-sparkcache` site +(`runtime/glm53-spark-mtp3-mesh/profile.py`), with the updated +profile-contract directory and entrypoint supplied through +`R33_PROFILE_CONTRACT_HOST_ROOT` bind mounts. The published image bytes, +its artifact lock, and its NCCL library identity are unchanged. + +The model was `local-inference-lab/GLM-5.3-Flash-NVFP4-Spark` revision +`df116c4fb16b1d37ae43d2cfd624de26ffbc832e` (config SHA-256 +`e1c0246a44ebefb5fd6383fb57aebbf7ac69ff6e7b23e989c0571b279a0eca23`). The +serving profile used TP4/DCP4, PP1, `dcp_comm_backend=ag_rs`, InstantTensor +target loading, static MTP3, 24 GiB FP8 KV per rank, 16 sequences, an +8,192-token scheduler budget, a 1,048,576-token request limit, +hardware-forwarded ring links with the fabric plan installed on every rank +(routes, ingress qdiscs with tc flower rules, and two RDMA-TX rewrite +markers per rank), dual-domain NCCL, token-sharded mHC, +continuation-prefill coalescing, and SparkCache with async page capture. + +The RoCEnante overlay pins `decode_context_parallel_size: 4`; DCP4 +activations therefore require the managed fabric installation before +launch. DCP1 activations disarm that overlay and do not require it. + +## Evidence + +- Engine initialization on rank 0 reported TP4/DCP4, `dcp_comm_backend=ag_rs`, + MTP3, InstantTensor, and the profile's exact + `cudagraph_capture_sizes=[4,8,12,16,20,24,28,32,36,40,44,48,52,56,60,64]`. +- Graph capture completed on every rank (`Graph capturing finished in + 61–78 secs`, 2.95–3.11 GiB). +- The mapped NCCL library hashed to + `84a4b8d83fb5fa1f0d640d311ad38b45140672dae9889775fe1e4a3990479e47` + (`libnccl.so.2.31.2`, NCCL 2.31.2) on all four ranks, and the HCAs span + PCI domains `0000` (`rocep1s0f0/f1`) and `0002` (`roceP2p1s0f0/f1`). +- Four exact-answer semantic requests returned exact responses. +- Two completed cold prompts of 37,032 tokens each with zero cached tokens, + no `sample_tokens` timeout, and no fatal engine error. +- DCP prefill execution used the cross-rank path: worker logs on every rank + report `Using full-CKV gather for GLM5Next B12X DCP prefill` + (`b12x_mla_sparse.py`), the DCP top-k owner-exchange machinery being + active rather than a DCP1 fallback. +- A repeated prompt with an identical 37,019-token prefix hit the cache on + its second run: 36,352 cached tokens, 15.8 s → 5.0 s wall time. +- mHC token sharding executed on every rank: + `GLM_MHC_PREFILL rank= rows=8192 owner_rows=2048 rs=90 ag=90 aux=0`, + two executions per rank. +- SparkCache reported `sparkcache_ranks=4 … healthy=1` throughout; page + snapshots committed (`kind=page_snapshot outcome=committed payload up to + 100,200,614 B`). +- A deterministic writer/restart/reader sequence: the writer created a + 7,831-token entry; the whole ring restarted (planned container recreation, + cold engine start); the reader restored 6,144 tokens from SparkCache on + every rank in 50.6–54.8 ms (112–121 K tok/s, 46.3 MiB per rank). +- A fault-injection recovery: all four containers were killed (`docker + kill`, SIGKILL), relaunched cold, returned to healthy serving, and the + reader restored 6,144 tokens on every rank in 51.9–57.7 ms (106–118 K + tok/s). + +## Measurement + +(2026-09-11 evening pass, cache-enabled ring. An additional diagnostic +RouteFinal startup and a cache-disabled observation follow this section.) + +Prefill values are medians of three cold requests per prompt size; all nine +requests reported zero cached tokens (unique prompt text per sample; prompt +lengths within ~1% of the target sizes are recorded in the sample table). +Decode used 10-second windows with zero request errors; each window was +seeded by a warmup request over the full context so decode ran against a +resident prefix. MTP-normalized steps/s counts target-model forward passes +only (`spec_decode_num_drafts_total` delta per window); the effective +acceptance length divides `spec_decode_num_accepted_tokens_total` deltas. +Throughput values remain **research-only** observations: the harness does +not pin clocks, warm-up policy, or a timing revision, so the tables are not +a reproducible benchmark or a speedup claim. + +| Prompt tokens (actual) | Cold prefill tok/s, median of 3 | +|---:|---:| +| 8,192 (8,185–8,186) | 2,398.4 | +| 16,384 (16,341–16,342) | 2,766.2 | +| 32,768 (32,652–32,653) | 2,998.4 | + +| Context | Concurrency | C1/C4 aggregate decode tok/s | MTP-normalized steps/s | Effective acceptance length | +|---:|---:|---:|---:|---:| +| 8,192 | 1 | 50.2 | 18.2 | 2.76 | +| 32,768 | 1 | 48.8 | 18.3 | 2.67 | +| 8,192 | 4 | 100.7 | 35.7 | 2.82 | +| 32,768 | 4 | 104.4 | 37.2 | 2.80 | + +## Result + +C1 decode matches the TP4/DCP1 record within 2–3%; C4 aggregate decode +reaches 0.76–0.82× of DCP1, consistent with the cross-rank full-CKV gather +(`Using full-CKV gather for GLM5Next B12X DCP prefill`) whose cost grows +with scheduling pressure. Effective acceptance length is at or slightly +above the DCP1 record (2.21–2.76). The DCP4 exchange buys ~3.7× KV +capacity (8.36M vs 2.28M tokens on the same 24 GiB per rank). + +## RouteFinal dual-domain diagnostic startup + +A diagnostic start rendered the same site with `nccl_debug: INFO` +(`NCCL_DEBUG=INFO`) through the unchanged published image. The ring reached +HEALTH-OK and served an exact semantic answer. Every rank emitted 32 +`NET/IB RouteFinal` lines covering all four HCAs across both PCI domains: +`rocep1s0f0` and `rocep1s0f1` (domain 0000) and `roceP2p1s0f0` and +`roceP2p1s0f1` (domain 0002), 8 RouteFinal records per HCA, with +`crossNic 1`, 32 channels, and `Connected all rings, use ring PXN 0 GDR 0`. +This is the dual-domain route attribution the DCP1 record uses, now +confirmed active for DCP4. + +## Six-case prefix-hit regression (1,027-token suffix included) + +After a 32,256-token cache hit established the base entry, six suffix +geometries completed with exact expected answers: 515, 513, 531, **1,027**, +512, and 2,048 tokens, with 28,160–28,672 cached tokens per case. As in the +DCP1 record the harness checked completion liveness and exact answers, not +raw output equivalence across shapes. No #220-style zero-hit behavior was +observed: every case hit the cache. + +## Cache-disabled tp4-dcp4 observation + +A separate ring start rendered the cache-disabled `tp4-dcp4` profile +(`SPARKCACHE_ENABLED=0`). Prefill medians of three cold samples per size +(all zero-cached): 8,192 → 2,451.4 tok/s; 16,384 → 2,885.7; 32,768 → +3,141.7 (one 8,192 sample absorbed a fresh-start JIT cost, 524 tok/s, and +the median remains the middle of three). Decode windows: 8,192 c1 → 50.2 +(norm 18.4, acc 2.73); 32,768 c1 → 52.8 (norm 18.5, acc 2.85); 8,192 c4 → +61.1 (norm 21.9, acc 2.80); 32,768 c4 → 104.6 (norm 35.2, acc 2.97). No +snapshot writes or restores occurred in any worker log; the SIRCL +capability vote remained (transport handshake) and vLLM's in-engine prefix +caching stayed enabled (28,160-token hits in the suffix cases), so +`SPARKCACHE_ENABLED=0` disables the SparkCache snapshot/capture layer only. + +## Conclusion + +The TP4/DCP4 SparkCache profile is bounded-qualified on the unchanged +published R33 image through the profile-contract overlay: managed four-rank +startup with graph capture, exact-answer serving, DCP prefill gather +evidence, dual-domain RouteFinal attribution, the six-case prefix-hit +regression including the 1,027-token suffix, planned-restart and SIGKILL +fault-injection restore, and the 8.36M-token KV pool with 1M request +admission. #220's zero-hit behavior was not observed. The cache-disabled +`tp4-dcp4` profile starts and serves as an observation row: functional +checks (four-rank start, semantic answer, 1M admission) passed on that +start as well. + +## Reproduction (overlay and quickstart) + +The published image contains only the DCP1 profile contract. A DCP4 start +requires the contract overlay from this repository: + +1. Clone this repo on every host and export + `R33_PROFILE_CONTRACT_HOST_ROOT=/runtime/sparkring/jovian-r33/profiles` + (the launcher bind-mounts it read-only at the contract host root and the + entrypoint prefers the overlaid contract; DCP1 starts do not need it). +2. Render the site once on the head host: + `python3 runtime/glm53-spark-mtp3-mesh/profile.py render --site .json + --bundle --output --image-receipt + ` with the site's `runtime_profile` set to + `tp4-dcp4-sparkcache` (or `tp4-dcp4`). The renderer emits one + `rank.env` per rank; copy them to each host (the rank-0 env stays on + the head). +3. The DCP4 overlays arm `decode_context_parallel_size: 4`; the managed + fabric plan (routes, tc flower qdiscs, RDMA-TX markers) must be + installed before launch — DCP1 silently disarms this and DCP4 does not. + The `R33_PROFILE_CONTRACT_HOST_ROOT` bind mount and the fabric plan are + the only two requirements that differ from a DCP1 start. +4. Launch rank by rank: + `R33_PROFILE_CONTRACT_HOST_ROOT=... bash /launch-rank.sh + /rank.env` (or the site's own rank env paths). Rank 0 + reaches readiness ~4–5 minutes after container start; `/health` on the + rank-0 API returns 200 and a semantic request returns an exact answer. +5. Cache-disabled starts use the same steps with `runtime_profile`: + `tp4-dcp4`; the renderer sets `SPARKCACHE_ENABLED=0` and the rank-local + cache root directory must still exist (the launcher requires it even + when the cache is disabled). + +The rendered env files are rank-specific (HOST_IP differs per rank); do not +reuse a rank-0 env on a peer host. + +The engine admitted the one-million-token request limit and reported +`GPU KV cache size: 8,364,901 tokens` (the DCP4 sharded pool; the DCP1 +profile reports ~2.28M on the same 24 GiB/rank). + +The activation receipt is +[`evidence/tp4-dcp4-sparkcache-activation-20260911.json`](../../../runtime/sparkring/jovian-r33/profiles/evidence/tp4-dcp4-sparkcache-activation-20260911.json), +bound to the profile contract SHA-256 recorded inside it and passing +`verify_profile.py validate-activation`. + +## Limitations + +This record does not include three-coordinated-cold-start latency evidence. +No completed one-million-token request was run; multimodal correctness, +switched hardware, other models, and sustained-memory behavior do not +inherit this qualification. The configured limit is not a tested workload. +The mounted profile-contract overlay is verified for internal consistency +and by the profile contract SHA; its contract bytes are newer than the +baked image contract and the published image remains byte-unchanged. +Prefill and decode throughput windows are research-only observations (see +Measurement); the INFO RouteFinal startup was a separate diagnostic start, +not the qualification serving configuration. The cache-disabled `tp4-dcp4` +row is an observation, not a standalone qualification, and the in-engine +vLLM prefix cache remained enabled on that start (SparkCache snapshot layer +disabled only). diff --git a/runtime/glm53-flash-jj-r8-gb10/launch-rank.sh b/runtime/glm53-flash-jj-r8-gb10/launch-rank.sh index d6b3718c..b5aca8e2 100644 --- a/runtime/glm53-flash-jj-r8-gb10/launch-rank.sh +++ b/runtime/glm53-flash-jj-r8-gb10/launch-rank.sh @@ -246,12 +246,14 @@ case "${SOURCE_IMAGE_PROFILE}" in [[ "${NCCL_LIBRARY_PATH}" == /opt/sparkring/nccl-pci/libnccl.so.2.30.7 && \ "${NCCL_IB_EXTENDED_IPV4_GIDS:-0}" == 1 && "${NCCL_IB_PRESERVE_PCI_DOMAIN:-0}" == 1 ]] || \ die 'Source SparkCache profile requires its dual-domain NCCL settings' ;; - tp4-dcp1) + tp4-dcp1|tp4-dcp4) r33_profile=1 [[ "${SPARKRING_PROFILE_MODE:-}" == custom && "${SPARKRING_MANAGED_MESH_RENDERED:-0}" == 1 ]] || \ die 'R33 TP4 requires the canonical managed custom profile' [[ "${SPARKCACHE_ENABLED}" == 0 && "${SPARKCACHE_ASYNC_PAGE_CAPTURE}" == 0 ]] || \ - die 'R33 tp4-dcp1 requires SparkCache disabled' + die 'R33 TP4 requires SparkCache disabled' + [[ "${SOURCE_IMAGE_PROFILE}" == "tp4-dcp${DECODE_CONTEXT_PARALLEL_SIZE}" ]] || \ + die 'R33 TP4 profile name differs from DECODE_CONTEXT_PARALLEL_SIZE' [[ "${VLLM_SPARK_TP4_MODE}" == custom && "${VLLM_SPARK_TP4_VOCAB_MODE}" == custom ]] || \ die 'R33 TP4 requires custom all-reduce and vocabulary transports' [[ "${VLLM_B12X_KDA_PREFILL_COALESCING:-0}" == 1 && \ @@ -260,7 +262,7 @@ case "${SOURCE_IMAGE_PROFILE}" in die 'R33 TP4 requires coalescing, mHC, and GDN metadata fast path' [[ "${NCCL_LIBRARY_PATH}" == /opt/local-inference/nccl/lib/libnccl.so.2 ]] || \ die 'R33 TP4 requires installed NCCL 2.31.2' ;; - tp4-dcp1-sparkcache) + tp4-dcp1-sparkcache|tp4-dcp4-sparkcache) r33_profile=1 [[ "${SPARKRING_PROFILE_MODE:-}" == custom && "${SPARKRING_MANAGED_MESH_RENDERED:-0}" == 1 ]] || \ die 'R33 SparkCache requires the canonical managed custom profile' @@ -288,7 +290,8 @@ case "${SOURCE_IMAGE_PROFILE}" in esac if [[ -n "${SPARKCACHE_SOURCE_LEASE_CONTRACT}" && \ "${SOURCE_IMAGE_PROFILE}" != tp4-dcp1-mtp3-sparkcache && \ - "${SOURCE_IMAGE_PROFILE}" != tp4-dcp1-sparkcache ]]; then + "${SOURCE_IMAGE_PROFILE}" != tp4-dcp1-sparkcache && \ + "${SOURCE_IMAGE_PROFILE}" != tp4-dcp4-sparkcache ]]; then die 'SPARKCACHE_SOURCE_LEASE_CONTRACT requires the source SparkCache profile' fi if [[ -n "${SOURCE_IMAGE_PROFILE}" ]]; then @@ -460,12 +463,14 @@ if [[ "${SPARKCACHE_ASYNC_PAGE_CAPTURE}" == 1 ]]; then fi if [[ "${SOURCE_IMAGE_PROFILE}" == tp4-dcp1-mtp3-sparkcache || \ - "${SOURCE_IMAGE_PROFILE}" == tp4-dcp1-sparkcache ]]; then + "${SOURCE_IMAGE_PROFILE}" == tp4-dcp1-sparkcache || \ + "${SOURCE_IMAGE_PROFILE}" == tp4-dcp4-sparkcache ]]; then # These are the bounded capacities named by the source-image profile. Reject # inherited operator defaults instead of allocating larger unqualified buffers. expected_cache_access=read-write expected_cache_capture=1 - if [[ "${SOURCE_IMAGE_PROFILE}" == tp4-dcp1-sparkcache && "${SPARKCACHE_ACCESS_MODE}" == restore-only ]]; then + if [[ "${SOURCE_IMAGE_PROFILE}" == tp4-dcp1-sparkcache || "${SOURCE_IMAGE_PROFILE}" == tp4-dcp4-sparkcache ]] && \ + [[ "${SPARKCACHE_ACCESS_MODE}" == restore-only ]]; then expected_cache_access=restore-only expected_cache_capture=0 fi @@ -648,6 +653,14 @@ for name in "${model_path_names[@]}"; do [[ "${value}" != *:* && "${value}" != *$'\n'* ]] || \ die "${name} cannot be represented safely as a Docker bind mount" done +R33_PROFILE_CONTRACT_HOST_ROOT=${R33_PROFILE_CONTRACT_HOST_ROOT:-} +if [[ "${r33_profile}" == 1 && -n "${R33_PROFILE_CONTRACT_HOST_ROOT}" ]]; then + [[ "${R33_PROFILE_CONTRACT_HOST_ROOT}" == /* ]] || \ + die 'R33_PROFILE_CONTRACT_HOST_ROOT must be an absolute host path' + [[ -f "${R33_PROFILE_CONTRACT_HOST_ROOT}/profile-contract.json" && \ + -f "${R33_PROFILE_CONTRACT_HOST_ROOT}/verify_profile.py" ]] || \ + die 'R33_PROFILE_CONTRACT_HOST_ROOT must contain profile-contract.json and verify_profile.py' +fi sparkcache_source_args=() if [[ -n "${SPARKCACHE_SOURCE_OVERLAY}" ]]; then [[ "${SPARKCACHE_SOURCE_OVERLAY}" == /* ]] || \ @@ -964,6 +977,15 @@ verify_file_sha256 \ 'b33c03475ba7322cf398828f2d8d1be376df30dc05c6b40c28c8ea8da23e410b' draft_mount_args=(-v "${DFLASH_MODEL_HOST_PATH}:/dflash-draft:ro") fi +r33_contract_mount_args=() +overlay_entrypoint='' +if [[ "${r33_profile}" == 1 && -n "${R33_PROFILE_CONTRACT_HOST_ROOT}" ]]; then + overlay_entrypoint=/opt/sparkring/bin/sparkring-r33-overlay + r33_contract_mount_args=( + -v "${R33_PROFILE_CONTRACT_HOST_ROOT}:/opt/sparkring/profile-contract:ro" + -v "${R33_PROFILE_CONTRACT_HOST_ROOT}/../image/entrypoint.py:${overlay_entrypoint}:ro" + ) +fi container="${CONTAINER_PREFIX}-r${rank}" if [[ "${SPARKRING_PRINT_CONTAINER_SPEC}" == 0 ]] && docker container inspect "${container}" >/dev/null 2>&1; then @@ -1084,7 +1106,7 @@ if os.environ["SOURCE_IMAGE_PROFILE"] == "tp4-dcp1-mtp3-sparkcache": "spark_cache_cuda_restore_arena_budget_bytes": 268435456, "spark_cache_page_snapshot_interval_tokens": 0, }) -elif os.environ["SOURCE_IMAGE_PROFILE"] == "tp4-dcp1-sparkcache": +elif os.environ["SOURCE_IMAGE_PROFILE"] in ("tp4-dcp1-sparkcache", "tp4-dcp4-sparkcache"): extra.update({ "spark_cache_async_page_capture_lease_mode": "connector-jobs", "spark_cache_async_page_capture_lease_contract": os.environ["SPARKCACHE_SOURCE_LEASE_CONTRACT"], @@ -1143,7 +1165,7 @@ source_recurrent_args=() if [[ -n "${SOURCE_IMAGE_PROFILE}" ]]; then # Source-bound profiles must verify installed files before importing serving code. if [[ "${r33_profile}" == 1 ]]; then - serving_entrypoint=/opt/sparkring/bin/sparkring-r33 + serving_entrypoint=${overlay_entrypoint:-/opt/sparkring/bin/sparkring-r33} serving_prefix=(serve) else serving_entrypoint=python3 @@ -1165,8 +1187,9 @@ if [[ "${r33_profile}" == 1 ]]; then -e "SPARKRING_MANAGED_MESH_RENDERED=${SPARKRING_MANAGED_MESH_RENDERED}" -e "VLLM_GDN_SPEC_DECODE_METADATA_FASTPATH=${VLLM_GDN_SPEC_DECODE_METADATA_FASTPATH}" -e "NCCL_LOCAL_INFERENCE_PATH=${NCCL_LIBRARY_PATH}" + -e "R33_PROFILE_CONTRACT_HOST_ROOT=${R33_PROFILE_CONTRACT_HOST_ROOT}" ) - if [[ "${SOURCE_IMAGE_PROFILE}" == tp4-dcp1-sparkcache ]]; then + if [[ "${SOURCE_IMAGE_PROFILE}" == tp4-dcp1-sparkcache || "${SOURCE_IMAGE_PROFILE}" == tp4-dcp4-sparkcache ]]; then r33_environment+=( -e "SPARKCACHE_CACHE_NAMESPACE=${SPARKCACHE_CACHE_NAMESPACE}" -e "SPARKCACHE_PLACEMENT_LIBRARY_PATH=${SPARKCACHE_PLACEMENT_LIBRARY_PATH}" @@ -1192,6 +1215,7 @@ container_command=(docker "${container_action[@]}" \ "${sparkcache_source_args[@]}" \ "${vllm_metrics_args[@]}" \ "${sircl_args[@]}" \ + "${r33_contract_mount_args[@]}" \ "${replay_timing_args[@]}" \ -e "SPARKRING_NODE_RANK=${rank}" \ -e "PORT=${PORT}" -e "SERVED_MODEL_NAME=${SERVED_MODEL_NAME}" \ diff --git a/runtime/glm53-spark-mtp3-mesh/profile.py b/runtime/glm53-spark-mtp3-mesh/profile.py index 398ad62f..905c8275 100644 --- a/runtime/glm53-spark-mtp3-mesh/profile.py +++ b/runtime/glm53-spark-mtp3-mesh/profile.py @@ -95,12 +95,13 @@ def load_site(path: Path): if type(timeout) is not int or not 0 < timeout <= 2147483647: raise ValueError("liveness_output_seconds must be an integer from 1 to 2147483647") if "nccl_debug" in data and ( - data.get("runtime_profile") not in ("tp4-dcp1", "tp4-dcp1-sparkcache") + data.get("runtime_profile") + not in ("tp4-dcp1", "tp4-dcp1-sparkcache", "tp4-dcp4", "tp4-dcp4-sparkcache") or data["nccl_debug"] != "INFO"): raise ValueError("nccl_debug diagnostic mode requires an R33 TP4 profile and INFO") if "cache_diagnostics" in data: diagnostic = data["cache_diagnostics"] - if (data.get("runtime_profile") != "tp4-dcp1-sparkcache" + if (data.get("runtime_profile") not in ("tp4-dcp1-sparkcache", "tp4-dcp4-sparkcache") or not isinstance(diagnostic, dict) or set(diagnostic) != {"namespace", "access_mode", "trace_reuse"} or not isinstance(diagnostic.get("namespace"), str) @@ -108,7 +109,7 @@ def load_site(path: Path): or "REPLACE" in diagnostic["namespace"] or diagnostic["access_mode"] != "restore-only" or type(diagnostic["trace_reuse"]) is not int or diagnostic["trace_reuse"] != 1): - raise ValueError("cache_diagnostics requires R33 tp4-dcp1-sparkcache, a concrete safe namespace, restore-only access and trace_reuse=1") + raise ValueError("cache_diagnostics requires an R33 tp4-dcp1-sparkcache or tp4-dcp4-sparkcache profile, a concrete safe namespace, restore-only access and trace_reuse=1") topology_path = path.parent / data["topology_file"] topology = fabric.load_topology(topology_path) for node in topology.ranks: @@ -308,8 +309,10 @@ def render(site_path: Path, bundle: Path, output: Path, image_receipt: Path | No raise ValueError("nccl_debug diagnostic mode requires an R33 image receipt") if r33_composition: runtime_profile = site.get("runtime_profile") - if runtime_profile not in ("tp4-dcp1", "tp4-dcp1-sparkcache"): - raise ValueError("R33 managed site must select tp4-dcp1 or tp4-dcp1-sparkcache") + if runtime_profile not in ( + "tp4-dcp1", "tp4-dcp1-sparkcache", "tp4-dcp4", "tp4-dcp4-sparkcache"): + raise ValueError( + "R33 managed site must select tp4-dcp1 or tp4-dcp4, with or without sparkcache") elif site.get("runtime_profile") != (image_record["profile"] if source_composition else None): raise ValueError("Site runtime profile differs from the explicit image receipt") values = defaults(BASE / "runtime.env.example") @@ -392,7 +395,7 @@ def render(site_path: Path, bundle: Path, output: Path, image_receipt: Path | No or checked.get(native["snapshot_path"]) != native["snapshot_sha256"]): raise ValueError("R33 image receipt does not bind SparkCache native libraries") values.update({ - "SPARKCACHE_CACHE_NAMESPACE": f"sparkring-r33-{image_record['image_id'][7:19]}-tp4-dcp1", + "SPARKCACHE_CACHE_NAMESPACE": f"sparkring-r33-{image_record['image_id'][7:19]}-{runtime_profile}", "SPARKCACHE_PLACEMENT_LIBRARY_PATH": native["placement_path"], "SPARKCACHE_PLACEMENT_LIBRARY_SHA256": native["placement_sha256"], "SPARKCACHE_SNAPSHOT_LIBRARY_PATH": native["snapshot_path"], diff --git a/runtime/glm53-spark-mtp3-mesh/test_mtp_launcher.py b/runtime/glm53-spark-mtp3-mesh/test_mtp_launcher.py index 2196297e..988f8585 100644 --- a/runtime/glm53-spark-mtp3-mesh/test_mtp_launcher.py +++ b/runtime/glm53-spark-mtp3-mesh/test_mtp_launcher.py @@ -160,9 +160,10 @@ def test_r33_tp4_uses_candidate_entrypoint_and_installed_runtime(launch_fixture) launch, _, _ = launch_fixture nccl = "/opt/local-inference/nccl/lib/libnccl.so.2" result, arguments, _ = launch(0, { + "DECODE_CONTEXT_PARALLEL_SIZE": "1", "SOURCE_IMAGE_PROFILE": "tp4-dcp1", - "SPARKRING_PROFILE_MODE": "custom", "LOAD_FORMAT": "instanttensor", + "SPARKRING_PROFILE_MODE": "custom", "SPARKRING_MANAGED_MESH_RENDERED": "1", "VLLM_SPARK_TP4_MODE": "custom", "VLLM_SPARK_TP4_VOCAB_MODE": "custom", @@ -215,6 +216,67 @@ def test_r33_tp4_uses_candidate_entrypoint_and_installed_runtime(launch_fixture) assert selected["tensor_parallel_size"] == 4 +def test_r33_tp4_dcp4_uses_candidate_entrypoint(launch_fixture): + launch, _, _ = launch_fixture + nccl = "/opt/local-inference/nccl/lib/libnccl.so.2" + result, arguments, _ = launch(0, { + "DECODE_CONTEXT_PARALLEL_SIZE": "4", + "SOURCE_IMAGE_PROFILE": "tp4-dcp4", + "SPARKRING_PROFILE_MODE": "custom", + "LOAD_FORMAT": "instanttensor", + "SPARKRING_MANAGED_MESH_RENDERED": "1", + "VLLM_SPARK_TP4_MODE": "custom", + "VLLM_SPARK_TP4_VOCAB_MODE": "custom", + "VLLM_B12X_KDA_PREFILL_COALESCING": "1", + "VLLM_B12X_KDA_PREFILL_COALESCING_LOG_LIMIT": "4", + "VLLM_GLM53_MHC_PREFILL_SHARD": "1", + "VLLM_GDN_SPEC_DECODE_METADATA_FASTPATH": "1", + "NCCL_IB_PRESERVE_PCI_DOMAIN": "1", + "NCCL_IB_ROUTE_DIAGNOSTICS": "1", + "SPARKCACHE_ENABLED": "0", + "SPARKCACHE_ASYNC_PAGE_CAPTURE": "0", + "NCCL_LIBRARY_PATH": nccl, + "NCCL_LIBRARY_SHA256": "84a4b8d83fb5fa1f0d640d311ad38b45140672dae9889775fe1e4a3990479e47", + "SIRCL_BUNDLE_HOST_ROOT": "", + "SPARKRING_DECLARED_SIRCL_NATIVE_SHA256": "b" * 64, + "SPARKRING_DECLARED_SIRCL_MANIFEST_SHA256": "c" * 64, + }) + assert result.returncode == 0, result.stderr + assert _option(arguments, "--entrypoint") == "/opt/sparkring/bin/sparkring-r33" + environment_map = _docker_environment(arguments) + assert environment_map["SOURCE_IMAGE_PROFILE"] == "tp4-dcp4" + assert _docker_labels(arguments)["org.sparkring.runtime"] == "glm53-flash-spark-jovian-r33-tp4-dcp4" + + +def test_r33_rejects_profile_name_and_dcp_mismatch(launch_fixture): + launch, _, _ = launch_fixture + nccl = "/opt/local-inference/nccl/lib/libnccl.so.2" + result, _, _ = launch(0, { + "DECODE_CONTEXT_PARALLEL_SIZE": "4", + "SOURCE_IMAGE_PROFILE": "tp4-dcp1", + "SPARKRING_PROFILE_MODE": "custom", + "LOAD_FORMAT": "instanttensor", + "SPARKRING_MANAGED_MESH_RENDERED": "1", + "VLLM_SPARK_TP4_MODE": "custom", + "VLLM_SPARK_TP4_VOCAB_MODE": "custom", + "VLLM_B12X_KDA_PREFILL_COALESCING": "1", + "VLLM_B12X_KDA_PREFILL_COALESCING_LOG_LIMIT": "4", + "VLLM_GLM53_MHC_PREFILL_SHARD": "1", + "VLLM_GDN_SPEC_DECODE_METADATA_FASTPATH": "1", + "NCCL_IB_PRESERVE_PCI_DOMAIN": "1", + "NCCL_IB_ROUTE_DIAGNOSTICS": "1", + "SPARKCACHE_ENABLED": "0", + "SPARKCACHE_ASYNC_PAGE_CAPTURE": "0", + "NCCL_LIBRARY_PATH": nccl, + "NCCL_LIBRARY_SHA256": "84a4b8d83fb5fa1f0d640d311ad38b45140672dae9889775fe1e4a3990479e47", + "SIRCL_BUNDLE_HOST_ROOT": "", + "SPARKRING_DECLARED_SIRCL_NATIVE_SHA256": "b" * 64, + "SPARKRING_DECLARED_SIRCL_MANIFEST_SHA256": "c" * 64, + }) + assert result.returncode == 78 + assert "profile name differs from DECODE_CONTEXT_PARALLEL_SIZE" in result.stderr + + @pytest.mark.parametrize("diagnostic,clear_once", [(False, "auto"), (True, ""), (True, "auto"), (True, "none")]) def test_r33_tp4_sparkcache_uses_receipt_bound_installed_libraries(launch_fixture, diagnostic, clear_once): launch, _, _ = launch_fixture @@ -223,6 +285,7 @@ def test_r33_tp4_sparkcache_uses_receipt_bound_installed_libraries(launch_fixtur snapshot = "/opt/sparkring/sparkcache/lib/libspark_cache_snapshot.so" lease = "/opt/sparkring/contracts/vllm-connector-jobs-r33-547f7091.json" result, arguments, _ = launch(0, { + "DECODE_CONTEXT_PARALLEL_SIZE": "1", "SOURCE_IMAGE_PROFILE": "tp4-dcp1-sparkcache", "SPARKRING_PROFILE_MODE": "custom", "LOAD_FORMAT": "instanttensor", diff --git a/runtime/sparkring/jovian-r33/image/entrypoint.py b/runtime/sparkring/jovian-r33/image/entrypoint.py old mode 100644 new mode 100755 index fa8af1fb..8a6d98e5 --- a/runtime/sparkring/jovian-r33/image/entrypoint.py +++ b/runtime/sparkring/jovian-r33/image/entrypoint.py @@ -3,6 +3,7 @@ from __future__ import annotations import json +import hashlib import os from pathlib import Path import subprocess @@ -12,7 +13,14 @@ VERIFY = "/opt/sparkring/bin/verify-candidate" PYTHON = "/opt/venv/bin/python" PROFILE_ROOT = Path("/opt/sparkring/profile-contract") -ALLOWED_PROFILES = {"tp2-dcp1", "tp2-dcp1-sparkcache", "tp4-dcp1", "tp4-dcp1-sparkcache"} +ALLOWED_PROFILES = { + "tp2-dcp1", + "tp2-dcp1-sparkcache", + "tp4-dcp1", + "tp4-dcp1-sparkcache", + "tp4-dcp4", + "tp4-dcp4-sparkcache", +} PLACEHOLDER_MARKERS = ("<", ">", "${") @@ -39,6 +47,32 @@ def verification_environment() -> dict[str, str]: environment.pop(name, None) return environment +CONTRACT_MOUNT_LOCK = Path("/opt/sparkring/receipts/source-lock.json") + + +def verify_installed_files() -> None: + """Verify installed files, tolerating a mounted profile-contract overlay. + + With the contract overlay active, the mounted directory supersedes the + baked contract files, so the source-lock identity check excludes that + directory and verifies every other installed file itself. Without the + overlay the baked verify-candidate runs unchanged. + """ + if not os.environ.get("R33_PROFILE_CONTRACT_HOST_ROOT", ""): + subprocess.run([VERIFY], check=True, env=verification_environment()) + return + lock = json.loads(CONTRACT_MOUNT_LOCK.read_text()) + if lock.get("schema") != "sparkring-r33-candidate-source-lock/v1": + raise RuntimeError("unsupported candidate source lock") + if sys.prefix != "/opt/venv" or sys.base_prefix == sys.prefix: + raise RuntimeError("candidate verifier is outside /opt/venv") + for relative, expected in lock["installed_files"].items(): + if relative.startswith("opt/sparkring/profile-contract/"): + continue + digest = hashlib.sha256((Path("/") / relative).read_bytes()).hexdigest() + if digest != expected: + raise RuntimeError(f"installed file identity mismatch: /{relative}") + def validate_external_profile(root: Path = PROFILE_ROOT) -> dict: profile_name = concrete("SOURCE_IMAGE_PROFILE") @@ -119,7 +153,7 @@ def validate_external_profile(root: Path = PROFILE_ROOT) -> dict: "SPARK_TP4_CONTROL_PORT0", "SPARK_TP4_CONTROL_PORT1", ): concrete(key) - if profile_name == "tp4-dcp1-sparkcache": + if profile_name in ("tp4-dcp1-sparkcache", "tp4-dcp4-sparkcache"): concrete("SPARKCACHE_CACHE_NAMESPACE") native = contract["sparkcache_native"] for key, expected in { @@ -156,7 +190,7 @@ def main() -> int: verify_environment = verification_environment() if argv == [VERIFY]: os.execve(argv[0], argv, verify_environment) - subprocess.run([VERIFY], check=True, env=verify_environment) + verify_installed_files() os.execve(argv[0], argv, os.environ) return 127 diff --git a/runtime/sparkring/jovian-r33/image/test_r33_image_contract.py b/runtime/sparkring/jovian-r33/image/test_r33_image_contract.py index 5dafc8cf..13abadd3 100644 --- a/runtime/sparkring/jovian-r33/image/test_r33_image_contract.py +++ b/runtime/sparkring/jovian-r33/image/test_r33_image_contract.py @@ -273,9 +273,21 @@ def test_only_canonical_external_profile_contract_is_packaged(self): ) self.assertEqual( set(contract["profiles"]), - {"tp2-dcp1", "tp2-dcp1-sparkcache", "tp4-dcp1", "tp4-dcp1-sparkcache"}, + { + "tp2-dcp1", + "tp2-dcp1-sparkcache", + "tp4-dcp1", + "tp4-dcp1-sparkcache", + "tp4-dcp4", + "tp4-dcp4-sparkcache", + }, ) - for name in ("tp4-dcp1", "tp4-dcp1-sparkcache"): + for name in ( + "tp4-dcp1", + "tp4-dcp1-sparkcache", + "tp4-dcp4", + "tp4-dcp4-sparkcache", + ): selected = contract["profiles"][name] values = (CANONICAL_PROFILES / selected["template"]).read_text() if selected.get("inherits"): @@ -308,6 +320,8 @@ def test_actual_profile_verifier_passes_in_staged_installed_layout(self): "tp2-dcp1-sparkcache", "tp4-dcp1", "tp4-dcp1-sparkcache", + "tp4-dcp4", + "tp4-dcp4-sparkcache", ): result = subprocess.run( [ diff --git a/runtime/sparkring/jovian-r33/profiles/evidence/tp4-dcp4-sparkcache-activation-20260911.json b/runtime/sparkring/jovian-r33/profiles/evidence/tp4-dcp4-sparkcache-activation-20260911.json new file mode 100644 index 00000000..dcbc299d --- /dev/null +++ b/runtime/sparkring/jovian-r33/profiles/evidence/tp4-dcp4-sparkcache-activation-20260911.json @@ -0,0 +1,715 @@ +{ + "schema": "sparkring-r33-activation-receipt/v1", + "checks_passed": true, + "profile": "tp4-dcp4-sparkcache", + "profile_contract_sha256": "20a4168a73ce7c9361a9875a21380c8e283d396e7b9025fbc5301bacbb6c9d8e", + "image": { + "artifact_lock_sha256": "a86fd813fa2bdc41f339317fe041fee55eb4391d715a5e3d91de31a1082a3534", + "bundle_manifest_sha256": "c0fd5567442b08b908cc193f36d0864e262573c7e5d232509479a823cface742", + "checks_passed": true, + "component_receipts": { + "arm-wheels-SHA256SUMS": "edf3f2cb01efd2463bcd609a96437bc0d7fd94b23594457566390da094844873", + "artifact-lock.json": "a86fd813fa2bdc41f339317fe041fee55eb4391d715a5e3d91de31a1082a3534", + "b12x-SHA256SUMS": "99754124b762597a14a5570d91d7505237dbc63e0ad3711081ea27b2ed705db6", + "b12x-source-receipt.txt": "19dc98e774acf9bb4c09ececa014ef436c2ef917d68adbaa2048e0a8c96f7cfe", + "flashinfer-SHA256SUMS": "dcb14c186d41a3608ff86bf63447a09920a9abdadb593d69d68a5cacacfa16df", + "flashinfer-resume-source-receipt.json": "0b0dc8f0c0eb766bd5748491162b62339a61029a40bcc0171e739cf0c99346b9", + "flashinfer-source-receipt.txt": "972cdb4e991542a011e0fb80d30415bcd40a4f826b6b24ea87d0908f267f64a5", + "flashkda-source-identity.json": "74d225c8976c5de462fad44f70b2fd05eb5fc797acfb409000b106ba5047c8d3", + "foundation-image.json": "8c1c4c74e44a0d776dae08be56351b454ddf5453759e690abac6ea82436c7300", + "instanttensor-SHA256SUMS": "965dc30bc9025e3e359f7574ea289f1a9031a721f258669e03c02580120947f6", + "instanttensor-source-receipt.txt": "f1c0edd1326112e37cd3985538b7dd1be2d5ae98967ffde1ecde51094cfc048e", + "lmcache-SHA256SUMS": "bbd87a7bbc3053887b8ce64565d2a012100061aa0cffd21089765c722e3a3ee4", + "lmcache-source-receipt.txt": "0f02e934ea037cfc3d65c4d6435f91c1a1d69207646f344d2f82e24c7569f95d", + "nccl-arm-port-receipt.json": "6032839fe8a9e778d55909bb68cfa76d8d8a650001cbf353e01edc73dfb7fa99", + "post-build-source-identities.json": "9321aa4468ac8f3ad72bb6ac176974f8eb315680ffe64ed304a6daceee8e0fb3", + "rust-SHA256SUMS": "2344abf5ec5e9db9c73afc8466cd30d49f0d5b2f3dcf3d65b3256ba49cd049e5", + "rust-source-receipt.txt": "fa747482025121bb610b8fff132a1ff7df53c6684a3573d1552fe2221d776627", + "semantic-validation.json": "dbb2cee08232b1145a0c48d1b9e867588786be4fe5aec574b2d043ed1f2047e5", + "sircl-build-receipt.json": "7d163ee7a47307b1a19792afd122947d50b897c4a7997a5d105276071c2aaa41", + "sparkcache-SHA256SUMS": "fc5d0047d3fd159ad3fa0562bf5cc9cf62cb49b4d0bbdaecc1b7b3929f4a1599", + "sparkcache-native-build-receipt.json": "46c4dca69e25f17097b3744396232382c7571347e8c3bc4f6a4173cc0c2f7a0a", + "sparkcache-source-receipt.txt": "83debd19e41a3cec529c5a45da9bb048c373ce50b1fa0d2a27bfb3772a53b9a3", + "torch-SHA256SUMS": "dd062c3f329aeb19be83f02eee9029211bbac946eeb538c37941a0c682308172", + "torchaudio-SHA256SUMS": "8449503a5594e768b478ebd7ac617287324488737817be4cb62012ef94f08822", + "torchaudio-source-receipt.txt": "e3f8b7a73549710a8c532807bd2f4849d68010a907689379f034bb31ee00ec4a", + "torchvision-SHA256SUMS": "98427004931e866dec718d1d11ba2476130342e971a7fa297caf1516bcdeb2bf", + "torchvision-source-receipt.txt": "c1a698fd0e3bd9f32f6386bd8319aa6b1067a7b00759901da05131118666970f", + "vllm-all-native-source-receipt.txt": "282def15bcfc61abdf6fb2d5931556a4064642eb46da6f02f2de5037cc8cb0e5", + "vllm-native-ALL-SHA256SUMS": "d0bc00db3c66e3259a3ff30eeea70b9dc2029ab6f1d9dc4ae86a9d00a862eb40", + "vllm-native-SHA256SUMS": "3ba6b1dc4142d0bdd5fd87464bdbb772f067100bd5830da1e0647689d1ccc3d8", + "vllm-native-source-receipt.txt": "404d1aac805bdc7de7448a1f9837e72a49ac34c9c1202392bec957dd7cebf879", + "vllm-package-SHA256SUMS": "6ebba88cad589b7e6a0f6186d1af151d2ab7fb67b50c84717acb6f777978cb4d", + "vllm-package-import-smoke.json": "9483150be2d403c1f8e5db3baee9bb4033d6d895d43ab940193d7415bc4eed40", + "vllm-package-verification.json": "f0b3543abb7e2d0aab5905758af16df342688947fa6f66fa58716eaa7a8a8a7c", + "vllm-source-composition-manifest.json": "f2e61b47d241de2cd54cbf3c8219ff93c096a2085e504522099788b11499b8c1", + "vllm-source-composition.patch": "aca0e198b659ba3d0a7778e88d4aa65a718ded57c826d5ee23ed861a9af30be5", + "xgrammar-SHA256SUMS": "a3821bd4e0ea345e6bd317be2ef218ff0e662b78ecbe54738aeb0e10636812bf", + "xgrammar-source-receipt.txt": "c2360878df3bd0a6cf92e444ca0f4c2d1e97328b6967be9d863613068efdf9f2", + "xgrammar-transformers5.patch": "f458147eecb0678978528e43dd608945996da3378a0bec7663ad4c9d0d053847", + "xgrammar-wheel-verification.json": "86228e12af7b6dcfaa9eacfbb664acc17bdd222b4631ce95c4067187aae7b16a" + }, + "image_id": "sha256:3c7779ad71dd0d5d6fae4c98e04b94c377429306158c2259fc44635892b8b8e4", + "image_reference": "ghcr.io/fujitsupolycom/sparkring@sha256:1328a4f6f483014021a66a757012793629bd054d28d0fe4d5e581fa4aed776ef", + "installed_payload_bytes_match": true, + "nccl_version": "2.31.2", + "package_checks_passed": true, + "platform": "linux/arm64", + "qualification": { + "cache_recovery": false, + "gpu": false, + "model": false, + "tp2": false, + "tp4": false + }, + "runtime_capabilities": { + "document": { + "checks": { + "managed_b12x_loader": "implemented", + "tp2_continuation_prefill_coalescing": "implemented", + "tp2_sparkcache": "implemented" + }, + "evidence_kind": "source-component-tests", + "evidence_sha256": { + "managed_b12x_loader": "7ca13f1ba285a6bf32996f17c1d942ff13a944214851681280fc5fdbe86fe1b6", + "tp2_continuation_prefill_coalescing": "d7a32a728c9aff47f7d19ec6bdc2e5d12f48dda962cc6c919bf68f38eee7ce61", + "tp2_sparkcache": "e92d5d5c13963ab0b26b70debdd0c28b9d7df6bae83cf4fcefe9289a3d27f3e4" + }, + "live_qualification": "pending", + "profile": "tp2-dcp1-sparkcache", + "schema": "sparkring-r33-runtime-capabilities/v1", + "sources": { + "b12x_tree": "284e7df8caff930477a314fea20d826256844de4", + "sparkcache_tree": "86ef46de45dd0f4ed776b86109a30df6f83db557", + "vllm_integrated_tree": "547f7091841728f21ab419012a766fd1df70a569", + "vllm_tp2_continuation_port_commit": "8fe550fd876ddea18a23b597611baec15dec048e" + } + }, + "sha256": "2515419a5eb1535eb84ecb3ed74120739a72e7355d156bd35595a1aa05b49038" + }, + "schema": "sparkring-r33-image-receipt/v1", + "source_lock_receipts_match": true, + "source_lock_sha256": "fcfefba676c79c07e45b3a67e6ac8eacbf8c5d0793707c9dd13604334515fcbf", + "source_locks_match": true, + "sources": { + "b12x_commit": "68acfc14893c087aa9b3120bb984fde4c4e7a21f", + "b12x_tree": "284e7df8caff930477a314fea20d826256844de4", + "cutlass_commit": "e6233cbac5d7c7a865c19c91cd684ceece19513c", + "cutlass_tree": "c820b06913f616dc6dd57559ca525b8ce645aaf0", + "flashinfer_commit": "803c4664f4771ddc418f20a57f752469a237a825", + "flashinfer_generated_file_map_sha256": "0a7929e8096447f9ea1e3ec3972799c130a6f2651fa3e9d18c7ffbc8bfaacb8e", + "flashinfer_recursive_submodules_sha256": "639f176c3f32c8947377f8ba4902ef8eb2b927594c74cd2529016bdbabcb57bd", + "flashinfer_status_sha256": "46308fe01c0fb5d5a40e473e19d002cb8e4374c2199301be39eeded26cebce9b", + "flashinfer_tree": "8728cfffc16c122e3536b63dc3456fdcdb9db272", + "flashkda_base_tree": "e8cf226562e56d0817462de76a614d32a83409ef", + "flashkda_commit": "3b225bf26bb8e218928a1fe14751cb48cf31d11b", + "flashkda_patch_sha256": "a9537532cf231babc942fa592666893268ca0617b24daeb8e78d3249e8c1d58a", + "flashkda_result_diff_sha256": "a21c2a2ee49e17c4f356a1b40ef2d30ac8f826f14d9f054eb6622e94ee634796", + "flashkda_result_tree": "3668743d4c392da0270b6c36cbfeb3545571a613", + "instanttensor_commit": "49b4010afc1cae0441e71fe0b0bffc24fa05e932", + "instanttensor_tree": "e87cad722a31e78f45097cb82aa7b9bb067224a6", + "libaio_commit": "1b18bfafc6a2f7b9fa2c6be77a95afed8b7be448", + "lmcache_commit": "29bc5a2efde737c436b04499eb62cd1776cebeec", + "lmcache_tree": "5a88a1ea9d2627c76288d056e7193f7454669b64", + "nccl_base_commit": "fb6f40999a2a9e63104d4ae4a84118bce61528f8", + "nccl_patch_sha256": "a69a4376b5732cde42f7d39057e5667b4b248c5afc197c7d188a8f891f7ccd8c", + "nccl_patched_tree": "aa7028b2b2a55af4817f8d742e17717dd4509ee7", + "rust_manifest_sha256": "821ff14e4c4a1cbe1e8915f35aff0a3fbbdf8d293ad48ab8f31e3b0440c581f9", + "rust_toolchain_blob": "4933b3ba170755e38ab3fc39cfc6bf952aabedcc", + "rust_toolchain_sha256": "094c9c36531911c5cc7dd6ab2d3069ab8dcd744d6239b0bda1387b243dfc391e", + "rust_tree": "85c3cd52db223217d45377d3f7f884e756641de3", + "sircl_commit": "3be025668705a9f72dd08a215230784e3c42c977", + "sircl_source_archive_sha256": "fe3e12de5cb1b392f015a751d7b27b6210c95fa7613113fd7895990e2041db0f", + "sircl_tree": "18e13dad5071b0a153f2c33c9c1720a3eca50318", + "sparkcache_commit": "f220230a5a85b94af8a296187241b6aacc3ed724", + "sparkcache_native_commit": "f220230a5a85b94af8a296187241b6aacc3ed724", + "sparkcache_native_source_archive_sha256": "d61bb093bb247c772709a5a25a0751960e31db3052ab0b1830332e03b7b05989", + "sparkcache_native_tree": "86ef46de45dd0f4ed776b86109a30df6f83db557", + "sparkcache_tree": "86ef46de45dd0f4ed776b86109a30df6f83db557", + "torch_commit": "cf30153c4c131c8164ee7798e5022d810682e2cb", + "torch_tree": "7cda5eae52ace99ca4daa7e623920cc93782cc6c", + "torchaudio_commit": "34c52a67e8941bbd8e6adaca0eb0b9eabec11d78", + "torchaudio_tree": "d0101192942c6971ae9cd347a0100bb6a6ae7b06", + "torchvision_commit": "8fb87713a24951e639c494b0f2a8a81b5f8e33a6", + "torchvision_tree": "7c24608af79802e05d7acfb6a44479fed788545a", + "vllm_cached_diff_sha256": "aca0e198b659ba3d0a7778e88d4aa65a718ded57c826d5ee23ed861a9af30be5", + "vllm_continuation_port_commit": "b611611a643502542c2d900057eb47e407b8379e", + "vllm_continuation_port_tree": "afea43a927e1989a9ec4d9d4f28247bcf0feb98a", + "vllm_flash_attn_commit": "f3e1a4f74c99145c0717709860bf765de1703779", + "vllm_head": "ae89131442359dc332d9c46009be3c1f8cdee0b4", + "vllm_integrated_tree": "547f7091841728f21ab419012a766fd1df70a569", + "vllm_native_tree": "386191c06df9c4232cb2f48012968f48cfdc6eee", + "vllm_prefix_hit_metadata_compatibility_commit": "4405a965e54f14df00d28e5e23f9793f866aae39", + "vllm_scheduler_config_compatibility_commit": "3049b639bdbc513319f7bae896c4e239992bc7bb", + "vllm_source_manifest_sha256": "f2e61b47d241de2cd54cbf3c8219ff93c096a2085e504522099788b11499b8c1", + "vllm_status_lines": 35, + "vllm_status_sha256": "78fe89198cbaeb21c21b57aad6013008f1e851ce3e376e8a73efba5c56eb64e3", + "vllm_tp2_continuation_port_commit": "8fe550fd876ddea18a23b597611baec15dec048e", + "xgrammar_base_tree": "6f118db56d875807366d249dc327cb63dcb91b73", + "xgrammar_commit": "2ea71da4ccb997a06928c9fb69b99f330da56697", + "xgrammar_result_tree": "4c848facc0ec2d9a77d1caa7408b339fea2f4424", + "xgrammar_transformers_metadata_patch_sha256": "f458147eecb0678978528e43dd608945996da3378a0bec7663ad4c9d0d053847" + }, + "verification": { + "checked_files": { + "/opt/lmcache/lib/liblmcache_cumem_shareable.so": "6c3b32b7892571c0a6a94b7197f87a3bad9735eb897779fc9c9d5981a583499d", + "/opt/local-inference/nccl/lib/libnccl.so.2.31.2": "84a4b8d83fb5fa1f0d640d311ad38b45140672dae9889775fe1e4a3990479e47", + "/opt/sparkring/bin/sparkring-r33": "d8213d7a91173352de71200270a03ea42f0622add9b842008f3fc566cc04d267", + "/opt/sparkring/bin/verify-candidate": "8c0ec5556085f07444f3805cdd3fb623d918ec5445da359c5bcd5643c06bc656", + "/opt/sparkring/contracts/vllm-connector-jobs-r33-547f7091.json": "fadaf6d07b4319207df0f0384d2a88834288d11440dc74b44f314c8b29fc8863", + "/opt/sparkring/image/artifact-lock.json": "a86fd813fa2bdc41f339317fe041fee55eb4391d715a5e3d91de31a1082a3534", + "/opt/sparkring/profile-contract/ACTIVATION_EVIDENCE.md": "0679c82c3aeb9757a7b609b7a03d1bb873f0fe70f7e56727cf50ffc3d939d4a2", + "/opt/sparkring/profile-contract/README.md": "366a4fc51cfc13499774fb65b8cb8b3e2017ec192eab93ec4c47cdd1ad14f441", + "/opt/sparkring/profile-contract/evidence/managed-b12x-loader.json": "7ca13f1ba285a6bf32996f17c1d942ff13a944214851681280fc5fdbe86fe1b6", + "/opt/sparkring/profile-contract/evidence/tp2-continuation-prefill-coalescing.json": "d7a32a728c9aff47f7d19ec6bdc2e5d12f48dda962cc6c919bf68f38eee7ce61", + "/opt/sparkring/profile-contract/evidence/tp2-sparkcache.json": "e92d5d5c13963ab0b26b70debdd0c28b9d7df6bae83cf4fcefe9289a3d27f3e4", + "/opt/sparkring/profile-contract/image.env.example": "ccadec34321f3c22f9af42e20d30107fef7982412a17b275a988047cff588cfe", + "/opt/sparkring/profile-contract/profile-contract.json": "35ff9f0b816d9d75cf660e2f2a828abf7a42ea2c07f8127a539e92650c8c2983", + "/opt/sparkring/profile-contract/test_profile_contract.py": "35fa39f347fbec3e2c7a6e807ffc932b4673a947323a43ef705fc40da0f85198", + "/opt/sparkring/profile-contract/tp2-dcp1-sparkcache.env.example": "aa97b1220631349c05c6d9c84d4dddef818bd4cf9c8a6ccdb8bf2f1e43cb8539", + "/opt/sparkring/profile-contract/tp2-dcp1.env.example": "dc5ded8eb6bdad94ddf733d744eba2ac06cc63965682d1dce0e223a65c5a119d", + "/opt/sparkring/profile-contract/tp2-sparkcache-capabilities.json": "2515419a5eb1535eb84ecb3ed74120739a72e7355d156bd35595a1aa05b49038", + "/opt/sparkring/profile-contract/tp4-dcp1-sparkcache.env.example": "21382b1b5644778506f38ad528427e896c4fdcbf8b67a0622110c9f541fd6781", + "/opt/sparkring/profile-contract/tp4-dcp1.env.example": "b46ac99c9283c375f3b06f9a9adfbfed645f5b2c2378c176263803d1b730c036", + "/opt/sparkring/profile-contract/verify_profile.py": "aeace05fcf76aa21360bec142232226b2ed94d94ea3672b0f25a63206f94ad1f", + "/opt/sparkring/receipts/arm-wheels-SHA256SUMS": "edf3f2cb01efd2463bcd609a96437bc0d7fd94b23594457566390da094844873", + "/opt/sparkring/receipts/artifact-lock.json": "a86fd813fa2bdc41f339317fe041fee55eb4391d715a5e3d91de31a1082a3534", + "/opt/sparkring/receipts/b12x-SHA256SUMS": "99754124b762597a14a5570d91d7505237dbc63e0ad3711081ea27b2ed705db6", + "/opt/sparkring/receipts/b12x-source-receipt.txt": "19dc98e774acf9bb4c09ececa014ef436c2ef917d68adbaa2048e0a8c96f7cfe", + "/opt/sparkring/receipts/flashinfer-SHA256SUMS": "dcb14c186d41a3608ff86bf63447a09920a9abdadb593d69d68a5cacacfa16df", + "/opt/sparkring/receipts/flashinfer-resume-source-receipt.json": "0b0dc8f0c0eb766bd5748491162b62339a61029a40bcc0171e739cf0c99346b9", + "/opt/sparkring/receipts/flashinfer-source-receipt.txt": "972cdb4e991542a011e0fb80d30415bcd40a4f826b6b24ea87d0908f267f64a5", + "/opt/sparkring/receipts/flashkda-source-identity.json": "74d225c8976c5de462fad44f70b2fd05eb5fc797acfb409000b106ba5047c8d3", + "/opt/sparkring/receipts/foundation-image.json": "8c1c4c74e44a0d776dae08be56351b454ddf5453759e690abac6ea82436c7300", + "/opt/sparkring/receipts/instanttensor-SHA256SUMS": "965dc30bc9025e3e359f7574ea289f1a9031a721f258669e03c02580120947f6", + "/opt/sparkring/receipts/instanttensor-source-receipt.txt": "f1c0edd1326112e37cd3985538b7dd1be2d5ae98967ffde1ecde51094cfc048e", + "/opt/sparkring/receipts/lmcache-SHA256SUMS": "bbd87a7bbc3053887b8ce64565d2a012100061aa0cffd21089765c722e3a3ee4", + "/opt/sparkring/receipts/lmcache-source-receipt.txt": "0f02e934ea037cfc3d65c4d6435f91c1a1d69207646f344d2f82e24c7569f95d", + "/opt/sparkring/receipts/nccl-arm-port-receipt.json": "6032839fe8a9e778d55909bb68cfa76d8d8a650001cbf353e01edc73dfb7fa99", + "/opt/sparkring/receipts/post-build-source-identities.json": "9321aa4468ac8f3ad72bb6ac176974f8eb315680ffe64ed304a6daceee8e0fb3", + "/opt/sparkring/receipts/rust-SHA256SUMS": "2344abf5ec5e9db9c73afc8466cd30d49f0d5b2f3dcf3d65b3256ba49cd049e5", + "/opt/sparkring/receipts/rust-source-receipt.txt": "fa747482025121bb610b8fff132a1ff7df53c6684a3573d1552fe2221d776627", + "/opt/sparkring/receipts/semantic-validation.json": "dbb2cee08232b1145a0c48d1b9e867588786be4fe5aec574b2d043ed1f2047e5", + "/opt/sparkring/receipts/sircl-build-receipt.json": "7d163ee7a47307b1a19792afd122947d50b897c4a7997a5d105276071c2aaa41", + "/opt/sparkring/receipts/sources/sparkcache-f220230a-source.tar.gz": "d61bb093bb247c772709a5a25a0751960e31db3052ab0b1830332e03b7b05989", + "/opt/sparkring/receipts/sparkcache-SHA256SUMS": "fc5d0047d3fd159ad3fa0562bf5cc9cf62cb49b4d0bbdaecc1b7b3929f4a1599", + "/opt/sparkring/receipts/sparkcache-native-build-receipt.json": "46c4dca69e25f17097b3744396232382c7571347e8c3bc4f6a4173cc0c2f7a0a", + "/opt/sparkring/receipts/sparkcache-source-receipt.txt": "83debd19e41a3cec529c5a45da9bb048c373ce50b1fa0d2a27bfb3772a53b9a3", + "/opt/sparkring/receipts/torch-SHA256SUMS": "dd062c3f329aeb19be83f02eee9029211bbac946eeb538c37941a0c682308172", + "/opt/sparkring/receipts/torchaudio-SHA256SUMS": "8449503a5594e768b478ebd7ac617287324488737817be4cb62012ef94f08822", + "/opt/sparkring/receipts/torchaudio-source-receipt.txt": "e3f8b7a73549710a8c532807bd2f4849d68010a907689379f034bb31ee00ec4a", + "/opt/sparkring/receipts/torchvision-SHA256SUMS": "98427004931e866dec718d1d11ba2476130342e971a7fa297caf1516bcdeb2bf", + "/opt/sparkring/receipts/torchvision-source-receipt.txt": "c1a698fd0e3bd9f32f6386bd8319aa6b1067a7b00759901da05131118666970f", + "/opt/sparkring/receipts/vllm-all-native-source-receipt.txt": "282def15bcfc61abdf6fb2d5931556a4064642eb46da6f02f2de5037cc8cb0e5", + "/opt/sparkring/receipts/vllm-native-ALL-SHA256SUMS": "d0bc00db3c66e3259a3ff30eeea70b9dc2029ab6f1d9dc4ae86a9d00a862eb40", + "/opt/sparkring/receipts/vllm-native-SHA256SUMS": "3ba6b1dc4142d0bdd5fd87464bdbb772f067100bd5830da1e0647689d1ccc3d8", + "/opt/sparkring/receipts/vllm-native-source-receipt.txt": "404d1aac805bdc7de7448a1f9837e72a49ac34c9c1202392bec957dd7cebf879", + "/opt/sparkring/receipts/vllm-package-SHA256SUMS": "6ebba88cad589b7e6a0f6186d1af151d2ab7fb67b50c84717acb6f777978cb4d", + "/opt/sparkring/receipts/vllm-package-import-smoke.json": "9483150be2d403c1f8e5db3baee9bb4033d6d895d43ab940193d7415bc4eed40", + "/opt/sparkring/receipts/vllm-package-verification.json": "f0b3543abb7e2d0aab5905758af16df342688947fa6f66fa58716eaa7a8a8a7c", + "/opt/sparkring/receipts/vllm-source-composition-manifest.json": "f2e61b47d241de2cd54cbf3c8219ff93c096a2085e504522099788b11499b8c1", + "/opt/sparkring/receipts/vllm-source-composition.patch": "aca0e198b659ba3d0a7778e88d4aa65a718ded57c826d5ee23ed861a9af30be5", + "/opt/sparkring/receipts/xgrammar-SHA256SUMS": "a3821bd4e0ea345e6bd317be2ef218ff0e662b78ecbe54738aeb0e10636812bf", + "/opt/sparkring/receipts/xgrammar-source-receipt.txt": "c2360878df3bd0a6cf92e444ca0f4c2d1e97328b6967be9d863613068efdf9f2", + "/opt/sparkring/receipts/xgrammar-transformers5.patch": "f458147eecb0678978528e43dd608945996da3378a0bec7663ad4c9d0d053847", + "/opt/sparkring/receipts/xgrammar-wheel-verification.json": "86228e12af7b6dcfaa9eacfbb664acc17bdd222b4631ce95c4067187aae7b16a", + "/opt/sparkring/runtime/glm53-spark-mtp3-mesh/pins.json": "05fddc68d2e74e00ed29126c09258766aff8a852b67681836023c097234d728b", + "/opt/sparkring/runtime/transport_profiles/README.md": "01f71117925b9aa34ff2519f0e09e0bc71a1037abef150c76b92d83bcdb627da", + "/opt/sparkring/runtime/transport_profiles/entrypoint.py": "8cd299b488f824f9a2bcd96b04410888f8967402547623bb6c1277267e9c5ab3", + "/opt/sparkring/runtime/transport_profiles/package.py": "980fd59531db84f5ecb1dbd317e65cb047f0d93383740f46a4cf9afb8b48ab37", + "/opt/sparkring/runtime/transport_profiles/sparkring_transport.pth": "c4865202d229c0501368f6f31f810d97dda25e50c0afc12cc4edd4bb8a5695a6", + "/opt/sparkring/runtime/transport_profiles/sparkring_transport_selector.py": "c820cf956d216f0f1e83632121ff3a04c2d743f6f6e2663f1551b27f1cdda50c", + "/opt/sparkring/runtime/transport_profiles/test_transport_selection.py": "1e1cc3a9aecebfc70889245d98dc40b56db622d0654a173320961a6047b2cd9c", + "/opt/sparkring/runtime/transport_profiles/tp2-rocenante-adaptive/LICENSE": "1eb85fc97224598dad1852b5d6483bbcf0aa8608790dcc657a5a2a761ae9c8c6", + "/opt/sparkring/runtime/transport_profiles/tp2-rocenante-adaptive/manifest.json": "eb03cfde826974811be3bfe5d88f36d9de105b73358f3eaa56b9ed44f19127c4", + "/opt/sparkring/runtime/transport_profiles/tp2-rocenante-adaptive/roce/__init__.py": "d1eabaa9395bbdc568d503c79cc1a57ab74626feed0c67851a00be0ba2718a7e", + "/opt/sparkring/runtime/transport_profiles/tp2-rocenante-adaptive/roce/_allgather_cute.py": "52a1ad8d7f3ab3e7a3379f3e471f274cc71a2513f595a5f939eb38df39447e19", + "/opt/sparkring/runtime/transport_profiles/tp2-rocenante-adaptive/roce/_cute_intrinsics.py": "ff0847d986243bf92444cd4c3db9156a6fc10d8c2e1a16d54761375e6aa7a78e", + "/opt/sparkring/runtime/transport_profiles/tp2-rocenante-adaptive/roce/_oneshot_cute.py": "472f771179dc403932caf05734739a978109bfdea136611cf0ddc84dc0f32a57", + "/opt/sparkring/runtime/transport_profiles/tp2-rocenante-adaptive/roce/_path_config.py": "d0ac6f1de1934e74202118a94b4f911001869e3da514bf599ca5ea696e82f0c9", + "/opt/sparkring/runtime/transport_profiles/tp2-rocenante-adaptive/roce/_proxy.py": "bba65c20e1a9bd268c8123ca6c2a80eea69b1d8354e63925d761fe576f94e206", + "/opt/sparkring/runtime/transport_profiles/tp2-rocenante-adaptive/roce/_roce_proxy.c": "8f5e2f76cb0ba37fdcdfe7c7f85c028a53a3a0441e1cb1b74c6b455cb0355838", + "/opt/sparkring/runtime/transport_profiles/tp2-rocenante-adaptive/roce/api.py": "02becd3757e71c917a71e98ab3f779d52bb18e6801b8efebd792ab186277ea46", + "/opt/sparkring/runtime/transport_profiles/tp2-rocenante-adaptive/roce/roce_oneshot.py": "6809aa25314b8f2d74f3a748ec43c098bdf9764cc1fbe2d3451f6b8268bea2c0", + "/opt/sparkring/sircl/libspark_transport_capi.so": "bea00f2ba6051c2c0bcd2853aae894672aa7f1fe5a1d905edaa9120aabf74246", + "/opt/sparkring/sircl/python/b12x_overlay/b12x/comm/roce/__init__.py": "d1eabaa9395bbdc568d503c79cc1a57ab74626feed0c67851a00be0ba2718a7e", + "/opt/sparkring/sircl/python/b12x_overlay/b12x/comm/roce/_allgather_cute.py": "e26ab2e7cce1cff334452ea237b1c0db8ab11ecba8e0a933f5cad35075a37f0f", + "/opt/sparkring/sircl/python/b12x_overlay/b12x/comm/roce/_cute_intrinsics.py": "ff0847d986243bf92444cd4c3db9156a6fc10d8c2e1a16d54761375e6aa7a78e", + "/opt/sparkring/sircl/python/b12x_overlay/b12x/comm/roce/_oneshot_cute.py": "1dd563020d15e50c7b391aac8bbee2e2760e66ced1bb891de7e59da5cc477173", + "/opt/sparkring/sircl/python/b12x_overlay/b12x/comm/roce/_path_config.py": "7c5550b16a70d74216970cd08a8d969a9928a975d1efcb9fb70e247eb0322e3a", + "/opt/sparkring/sircl/python/b12x_overlay/b12x/comm/roce/_proxy.py": "3ace33c00f64ce43317a00b19879bbc6562bb3e466aa94683ed95ce211ec25c0", + "/opt/sparkring/sircl/python/b12x_overlay/b12x/comm/roce/_roce_proxy.c": "b208f07d4bb12613a6aef3e8e59ac334b53028655b76f3f5c6e531bd354b369e", + "/opt/sparkring/sircl/python/b12x_overlay/b12x/comm/roce/api.py": "02becd3757e71c917a71e98ab3f779d52bb18e6801b8efebd792ab186277ea46", + "/opt/sparkring/sircl/python/b12x_overlay/b12x/comm/roce/roce_oneshot.py": "2e431e7c5ef714636247b81602fdc1b85b38ebe1cef7665bc8d486f7841a65e1", + "/opt/sparkring/sircl/python/rocenante-overlay-config.json": "69535f64b484699695cea587b24343af9346149223b50e17b28a8c56d9ad3dee", + "/opt/sparkring/sircl/python/rocenante_health_gate.py": "aac0ad50f2065f596e8173ddb4d07984a644fbd786d38604ab5f0b4a042feade", + "/opt/sparkring/sircl/python/rocenante_vllm_overlay.py": "0cf6c21cc0baa06dd141fe9660081fbbf8aa56821fc2fe43e393f8b5c8877b82", + "/opt/sparkring/sircl/python/sircl_sitecustomize.py": "4efc3fdfe4874820064dbcb713c02271df4ca41f4f2bbcf4683a1548ca02f2b1", + "/opt/sparkring/sircl/python/sitecustomize.py": "510104bb8dc12edb395075ded79e95651f0a60fbdafa3db1d472bf5b75fabc65", + "/opt/sparkring/sircl/python/spark_collective_audit.py": "8fa7aa9747845a84b40e8d3a0d72c39f8a562d6490764b777e5dcbe1cbe47721", + "/opt/sparkring/sircl/python/spark_cudagraph_bucket_contract.py": "e7411ff9cde9d5ed4a7ecd6e78a3158512c188c254baad10554b72229f14d272", + "/opt/sparkring/sircl/python/spark_cudagraph_replay_timing.py": "dc3ee0fd5da52e79b097e9edc6191a880ca5a3f4e6d83add2a4acd30966b2175", + "/opt/sparkring/sircl/python/spark_dcp_collective_audit.py": "077a234e4edff8b8dd44784953aef713884b4dd7a3f7c46589b14c6bb8b40745", + "/opt/sparkring/sircl/python/spark_graph_status_reporter.py": "4bd50d1be42e2ac750b382825bec8a49564ce288d376852ee7c51e33a303f277", + "/opt/sparkring/sircl/python/spark_persistent_output_ring.py": "03220c78ed87651f93c3165f1eedb843ffcad6a116126e2a9b89beab299bd2f3", + "/opt/sparkring/sircl/python/spark_tp4_backend.py": "5999814740ddfa1c35e925ed0f3bf43edd8335b30c9b4fe9b78006c618d18cb9", + "/opt/sparkring/sircl/python/spark_tp4_capability.py": "d90f6fc07ff5255b2df25b3ffc1c52c83f9eb866ca68666bc0f273db1c5e83b7", + "/opt/sparkring/sircl/python/spark_tp4_health_gate.py": "7651b88e9bff40193891a0810ee8a920e3548a17de3a0dc477a30db779738930", + "/opt/sparkring/sircl/python/spark_tp4_port_namespace.py": "c789739811def9722753bb128e69e7bd5342bab827b2cfd99cd8a4e847d18d4f", + "/opt/sparkring/sircl/python/spark_tp4_query_contract.py": "978df868fd83a6a780111092e99de2a3f07a5df375cf52d4b2358ccf4dcd0c31", + "/opt/sparkring/sircl/python/spark_tp4_query_row_provider.py": "09c9e7af5d14b5c6930e15c999ada2231d639eb59609d705aadecdd7497ddec7", + "/opt/sparkring/sircl/python/spark_tp4_vocab_allgather_backend.py": "fd44dea558c115b17f17bb129033345af4543702fbbdaf1fa4f186b8f242e697", + "/opt/sparkring/sircl/python/sparkring-overlay-manifest.json": "c0fd5567442b08b908cc193f36d0864e262573c7e5d232509479a823cface742", + "/opt/sparkring/sparkcache/lib/libspark_cache_placement.so": "d89c9fdae8dc99ae3f7a151cc3dd9e92fdc8fd0b994069fc263027fd4d056c93", + "/opt/sparkring/sparkcache/lib/libspark_cache_snapshot.so": "7da9e72f096ae679906ba71336c16e7894a247eb5b0d217aaccd115b85058953", + "/opt/sparkring/transports/README.md": "01f71117925b9aa34ff2519f0e09e0bc71a1037abef150c76b92d83bcdb627da", + "/opt/sparkring/transports/entrypoint.py": "8cd299b488f824f9a2bcd96b04410888f8967402547623bb6c1277267e9c5ab3", + "/opt/sparkring/transports/package.py": "980fd59531db84f5ecb1dbd317e65cb047f0d93383740f46a4cf9afb8b48ab37", + "/opt/sparkring/transports/sparkring_transport.pth": "c4865202d229c0501368f6f31f810d97dda25e50c0afc12cc4edd4bb8a5695a6", + "/opt/sparkring/transports/sparkring_transport_selector.py": "c820cf956d216f0f1e83632121ff3a04c2d743f6f6e2663f1551b27f1cdda50c", + "/opt/sparkring/transports/test_transport_selection.py": "1e1cc3a9aecebfc70889245d98dc40b56db622d0654a173320961a6047b2cd9c", + "/opt/sparkring/transports/tp2-rocenante-adaptive/LICENSE": "1eb85fc97224598dad1852b5d6483bbcf0aa8608790dcc657a5a2a761ae9c8c6", + "/opt/sparkring/transports/tp2-rocenante-adaptive/manifest.json": "eb03cfde826974811be3bfe5d88f36d9de105b73358f3eaa56b9ed44f19127c4", + "/opt/sparkring/transports/tp2-rocenante-adaptive/roce/__init__.py": "d1eabaa9395bbdc568d503c79cc1a57ab74626feed0c67851a00be0ba2718a7e", + "/opt/sparkring/transports/tp2-rocenante-adaptive/roce/_allgather_cute.py": "52a1ad8d7f3ab3e7a3379f3e471f274cc71a2513f595a5f939eb38df39447e19", + "/opt/sparkring/transports/tp2-rocenante-adaptive/roce/_cute_intrinsics.py": "ff0847d986243bf92444cd4c3db9156a6fc10d8c2e1a16d54761375e6aa7a78e", + "/opt/sparkring/transports/tp2-rocenante-adaptive/roce/_oneshot_cute.py": "472f771179dc403932caf05734739a978109bfdea136611cf0ddc84dc0f32a57", + "/opt/sparkring/transports/tp2-rocenante-adaptive/roce/_path_config.py": "d0ac6f1de1934e74202118a94b4f911001869e3da514bf599ca5ea696e82f0c9", + "/opt/sparkring/transports/tp2-rocenante-adaptive/roce/_proxy.py": "bba65c20e1a9bd268c8123ca6c2a80eea69b1d8354e63925d761fe576f94e206", + "/opt/sparkring/transports/tp2-rocenante-adaptive/roce/_roce_proxy.c": "8f5e2f76cb0ba37fdcdfe7c7f85c028a53a3a0441e1cb1b74c6b455cb0355838", + "/opt/sparkring/transports/tp2-rocenante-adaptive/roce/api.py": "02becd3757e71c917a71e98ab3f779d52bb18e6801b8efebd792ab186277ea46", + "/opt/sparkring/transports/tp2-rocenante-adaptive/roce/roce_oneshot.py": "6809aa25314b8f2d74f3a748ec43c098bdf9764cc1fbe2d3451f6b8268bea2c0" + }, + "cuda_initialized": false, + "ffmpeg": "ffmpeg version 6.1.1-3ubuntu5 Copyright (c) 2000-2023 the FFmpeg developers", + "gpu_qualified": false, + "installed_python_payload_files": 57008, + "model_loaded": false, + "nccl_loaded_path": "/opt/local-inference/nccl/lib/libnccl.so.2.31.2", + "nccl_version": 23102, + "python_distributions": { + "agent-detector": "2.0.0", + "aiofile": "3.12.3", + "aiofiles": "25.1.0", + "aiohappyeyeballs": "2.7.1", + "aiohttp": "3.14.3", + "aiosignal": "1.4.0", + "annotated-doc": "0.0.5", + "annotated-types": "0.8.0", + "anthropic": "1.5.0", + "anyio": "4.15.1", + "apache-tvm-ffi": "0.1.11", + "astor": "0.8.1", + "attrs": "26.1.0", + "awscrt": "0.36.3", + "b12x": "1.3.0", + "blake3": "1.0.9", + "cachetools": "7.1.8", + "caio": "0.12.4", + "cbor2": "6.1.4", + "certifi": "2026.7.22", + "cffi": "2.1.1", + "charset-normalizer": "3.5.1", + "click": "8.5.0", + "cloudpickle": "3.1.2", + "compressed-tensors": "0.17.0", + "cryptography": "50.0.1", + "cuda-bindings": "13.4.1", + "cuda-core": "1.2.0", + "cuda-pathfinder": "1.8.1", + "cuda-python": "13.4.1", + "cuda-tile": "1.6.0", + "cufile-python": "0.2.0", + "cupy-cuda13x": "14.2.0", + "depyf": "0.20.0", + "detect-installer": "0.2.1", + "dill": "0.4.1", + "dnspython": "2.8.0", + "docstring-parser": "0.18.0", + "einops": "0.8.2", + "email-validator": "2.3.0", + "fastapi": "0.136.3", + "fastapi-cli": "0.0.32", + "fastapi-cloud-cli": "0.26.0", + "fastar": "0.12.0", + "fastsafetensors": "0.4.0", + "filelock": "3.32.6", + "flashinfer-jit-cache": "0.6.18+cu133", + "flashinfer-python": "0.6.18+cu133", + "frozenlist": "1.8.0", + "fsspec": "2026.7.0", + "google-api-core": "2.34.0", + "google-auth": "2.58.0", + "google-cloud-bigtable": "2.44.0", + "google-cloud-core": "2.7.0", + "google-cloud-monitoring": "2.31.0", + "google-crc32c": "1.8.0", + "googleapis-common-protos": "1.75.3", + "grpc-google-iam-v1": "0.14.5", + "grpcio": "1.83.1", + "grpcio-status": "1.83.1", + "h11": "0.16.0", + "hf-xet": "1.6.0", + "httpcore": "1.0.9", + "httpcore2": "2.12.0", + "httptools": "0.8.0", + "httpx": "0.28.1", + "httpx2": "2.12.0", + "huggingface-hub": "1.31.0", + "humming-kernels": "0.1.12", + "idna": "3.19", + "ijson": "3.5.1", + "importlib-metadata": "8.7.1", + "iniconfig": "2.3.0", + "instanttensor": "0.1.9", + "interegular": "0.3.3", + "jinja2": "3.1.6", + "jiter": "0.16.0", + "jmespath": "1.1.0", + "jsonschema": "4.26.0", + "jsonschema-specifications": "2025.9.1", + "lark": "1.2.2", + "llguidance": "1.7.6", + "llvmlite": "0.47.0", + "lm-format-enforcer": "0.11.3", + "lmcache": "0.5.5.dev0+glm53checkpoints.29bc5a2e", + "loguru": "0.7.3", + "markdown-it-py": "4.2.0", + "markupsafe": "3.0.3", + "mcp": "2.2.0", + "mcp-types": "2.2.0", + "mdurl": "0.1.2", + "mistral-common": "1.11.7", + "ml-dtypes": "0.6.0", + "model-hosting-container-standards": "0.1.16", + "mpmath": "1.3.0", + "msgspec": "0.21.1", + "multidict": "6.8.0", + "nccl4py": "0.5.0", + "networkx": "3.6.1", + "ninja": "1.13.2", + "numba": "0.65.0", + "numpy": "2.2.6", + "nvidia-cuda-cccl": "13.3.4.2.1", + "nvidia-cuda-crt": "13.4.59", + "nvidia-cuda-nvcc": "13.4.59", + "nvidia-cuda-nvdisasm": "13.4.49", + "nvidia-cuda-nvrtc": "13.4.59", + "nvidia-cuda-runtime": "13.4.49", + "nvidia-cudnn-frontend": "1.28.0", + "nvidia-cutlass-dsl": "4.6.2", + "nvidia-cutlass-dsl-libs-base": "4.6.2", + "nvidia-cutlass-dsl-libs-core": "4.6.2", + "nvidia-cutlass-dsl-libs-cu12": "4.6.2", + "nvidia-cutlass-dsl-libs-cu13": "4.6.2", + "nvidia-ml-py": "13.610.43", + "nvidia-nvvm": "13.4.59", + "nvtx": "0.2.15", + "openai": "3.13.0", + "openai-harmony": "0.0.8", + "opencv-python-headless": "5.0.0.93", + "opentelemetry-api": "1.40.0", + "opentelemetry-exporter-otlp": "1.40.0", + "opentelemetry-exporter-otlp-proto-common": "1.40.0", + "opentelemetry-exporter-otlp-proto-grpc": "1.40.0", + "opentelemetry-exporter-otlp-proto-http": "1.40.0", + "opentelemetry-exporter-prometheus": "0.61b0", + "opentelemetry-proto": "1.40.0", + "opentelemetry-sdk": "1.40.0", + "opentelemetry-semantic-conventions": "0.61b0", + "opentelemetry-semantic-conventions-ai": "0.5.1", + "outlines-core": "0.2.14", + "packaging": "26.3", + "partial-json-parser": "0.2.1.1.post7", + "pillow": "12.3.0", + "pluggy": "1.6.0", + "prometheus-client": "0.24.1", + "prometheus-fastapi-instrumentator": "8.1.0", + "propcache": "0.5.2", + "proto-plus": "1.28.4", + "protobuf": "6.33.6", + "psutil": "7.2.2", + "py-cpuinfo": "9.0.0", + "pyasn1": "0.6.4", + "pyasn1-modules": "0.4.2", + "pybase64": "1.5.0", + "pycountry": "26.2.16", + "pycparser": "3.0", + "pydantic": "2.13.5", + "pydantic-core": "2.46.5", + "pydantic-extra-types": "2.11.1", + "pydantic-settings": "2.15.0", + "pygments": "2.21.0", + "pyjwt": "2.13.0", + "pynvvideocodec": "2.0.4", + "pytest": "9.1.1", + "python-dotenv": "1.2.3", + "python-json-logger": "4.2.0", + "python-multipart": "0.0.32", + "pyyaml": "6.0.3", + "pyzmq": "27.2.0", + "quack-kernels": "0.6.4", + "redis": "8.1.0", + "referencing": "0.37.0", + "regex": "2026.9.10", + "requests": "2.34.2", + "rich": "15.0.0", + "rich-toolkit": "0.20.5", + "rignore": "0.8.1", + "rpds-py": "2026.6.3", + "safetensors": "0.8.0", + "sentencepiece": "0.2.2", + "sentry-sdk": "2.69.1", + "setproctitle": "1.3.7", + "setuptools": "80.10.2", + "setuptools-scm": "10.2.3", + "shellingham": "1.5.4", + "six": "1.17.0", + "sniffio": "1.3.1", + "sortedcontainers": "2.4.0", + "sparkcache": "0.1.0a3", + "sse-starlette": "3.4.11", + "starlette": "1.6.0", + "supervisor": "4.3.0", + "sympy": "1.14.0", + "tabulate": "0.10.0", + "tiktoken": "0.14.0", + "tilelang": "0.1.12", + "tokenizers": "0.23.2", + "tokenspeed-mla": "0.1.8", + "tokenspeed-triton": "3.8.10.post20260906", + "torch": "2.13.0", + "torch-c-dlpack-ext": "0.1.5", + "torchaudio": "2.11.0+cu133", + "torchcodec": "0.16.0+cu130", + "torchvision": "0.28.0", + "tqdm": "4.70.0", + "transformers": "5.17.0", + "triton": "3.8.0", + "truststore": "0.10.4", + "typer": "0.27.2", + "typing-extensions": "4.16.0", + "typing-inspection": "0.4.4", + "urllib3": "2.7.0", + "uvicorn": "0.52.4", + "uvloop": "0.22.1", + "vcs-versioning": "2.3.4", + "vllm": "0.26.1rc0+sparkring.r33.547f7091", + "watchfiles": "1.2.0", + "websockets": "17.1", + "xgrammar": "0.2.5", + "yarl": "1.24.5", + "z3-solver": "4.15.4.0", + "zipp": "4.1.0" + }, + "runtime_capabilities": { + "document": { + "checks": { + "managed_b12x_loader": "implemented", + "tp2_continuation_prefill_coalescing": "implemented", + "tp2_sparkcache": "implemented" + }, + "evidence_kind": "source-component-tests", + "evidence_sha256": { + "managed_b12x_loader": "7ca13f1ba285a6bf32996f17c1d942ff13a944214851681280fc5fdbe86fe1b6", + "tp2_continuation_prefill_coalescing": "d7a32a728c9aff47f7d19ec6bdc2e5d12f48dda962cc6c919bf68f38eee7ce61", + "tp2_sparkcache": "e92d5d5c13963ab0b26b70debdd0c28b9d7df6bae83cf4fcefe9289a3d27f3e4" + }, + "live_qualification": "pending", + "profile": "tp2-dcp1-sparkcache", + "schema": "sparkring-r33-runtime-capabilities/v1", + "sources": { + "b12x_tree": "284e7df8caff930477a314fea20d826256844de4", + "sparkcache_tree": "86ef46de45dd0f4ed776b86109a30df6f83db557", + "vllm_integrated_tree": "547f7091841728f21ab419012a766fd1df70a569", + "vllm_tp2_continuation_port_commit": "8fe550fd876ddea18a23b597611baec15dec048e" + } + }, + "sha256": "2515419a5eb1535eb84ecb3ed74120739a72e7355d156bd35595a1aa05b49038" + }, + "schema": "sparkring-r33-candidate-verification/v1", + "source_lock_sha256": "fcfefba676c79c07e45b3a67e6ac8eacbf8c5d0793707c9dd13604334515fcbf", + "status": "source-closure-verified-runtime-qualification-pending" + } + }, + "ranks": [ + { + "rank": 0, + "image_id": "sha256:3c7779ad71dd0d5d6fae4c98e04b94c377429306158c2259fc44635892b8b8e4", + "nccl_version": "2.31.2", + "nccl_host_domains": [ + "primary", + "secondary" + ], + "captured_graph_sizes": [ + 4, + 8, + 12, + 16, + 20, + 24, + 28, + 32, + 36, + 40, + 44, + 48, + 52, + 56, + 60, + 64 + ], + "instanttensor_allocations": 1, + "mtp_draft_tokens": 8, + "continuation_coalesced_groups": 1, + "mhc_sharded_prefill_calls": 2, + "mhc_owner_rows": [ + 2048 + ], + "sircl_collectives": 1 + }, + { + "rank": 1, + "image_id": "sha256:3c7779ad71dd0d5d6fae4c98e04b94c377429306158c2259fc44635892b8b8e4", + "nccl_version": "2.31.2", + "nccl_host_domains": [ + "primary", + "secondary" + ], + "captured_graph_sizes": [ + 4, + 8, + 12, + 16, + 20, + 24, + 28, + 32, + 36, + 40, + 44, + 48, + 52, + 56, + 60, + 64 + ], + "instanttensor_allocations": 1, + "mtp_draft_tokens": 8, + "continuation_coalesced_groups": 1, + "mhc_sharded_prefill_calls": 2, + "mhc_owner_rows": [ + 2048 + ], + "sircl_collectives": 1 + }, + { + "rank": 2, + "image_id": "sha256:3c7779ad71dd0d5d6fae4c98e04b94c377429306158c2259fc44635892b8b8e4", + "nccl_version": "2.31.2", + "nccl_host_domains": [ + "primary", + "secondary" + ], + "captured_graph_sizes": [ + 4, + 8, + 12, + 16, + 20, + 24, + 28, + 32, + 36, + 40, + 44, + 48, + 52, + 56, + 60, + 64 + ], + "instanttensor_allocations": 1, + "mtp_draft_tokens": 8, + "continuation_coalesced_groups": 1, + "mhc_sharded_prefill_calls": 2, + "mhc_owner_rows": [ + 2048 + ], + "sircl_collectives": 1 + }, + { + "rank": 3, + "image_id": "sha256:3c7779ad71dd0d5d6fae4c98e04b94c377429306158c2259fc44635892b8b8e4", + "nccl_version": "2.31.2", + "nccl_host_domains": [ + "primary", + "secondary" + ], + "captured_graph_sizes": [ + 4, + 8, + 12, + 16, + 20, + 24, + 28, + 32, + 36, + 40, + 44, + 48, + 52, + 56, + 60, + 64 + ], + "instanttensor_allocations": 1, + "mtp_draft_tokens": 8, + "continuation_coalesced_groups": 1, + "mhc_sharded_prefill_calls": 2, + "mhc_owner_rows": [ + 2048 + ], + "sircl_collectives": 1 + } + ], + "serving": { + "max_model_len": 1048576, + "kv_capacity_tokens": 8364901, + "prefill_decode_passed": true, + "correctness_passed": true + }, + "sparkcache": { + "enabled": true, + "capture_jobs_completed": 3, + "restores_completed": 2, + "recoveries_after_fault": 1, + "payload_correctness_passed": true + }, + "long_prefill_sample_tokens": { + "bounded": true, + "prompt_tokens": 37032, + "completed_requests": 2, + "timeouts": 0, + "fatal_engine_errors": 0 + }, + "prefix_reuse": { + "queried_tokens": 37019, + "cached_tokens": 36352 + }, + "restart_restore": { + "planned_restart_ms_per_rank": [ + 50.6, + 52.9, + 54.8, + 52.4 + ], + "fault_recovery_ms_per_rank": [ + 54.1, + 57.7, + 55.9, + 51.9 + ] + } +} \ No newline at end of file diff --git a/runtime/sparkring/jovian-r33/profiles/profile-contract.json b/runtime/sparkring/jovian-r33/profiles/profile-contract.json index daf351ab..97b06779 100644 --- a/runtime/sparkring/jovian-r33/profiles/profile-contract.json +++ b/runtime/sparkring/jovian-r33/profiles/profile-contract.json @@ -240,6 +240,70 @@ ], "lifecycle": "runtime/glm53-spark-mtp3-mesh/MANAGED_MESH.md" }, + "tp4-dcp4": { + "template": "tp4-dcp4.env.example", + "inherits": "tp4-dcp1", + "tensor_parallel_size": 4, + "decode_context_parallel_size": 4, + "node_count": 4, + "transport": "sparkring-rocenante-mesh", + "mesh_pins": "glm53-spark-mtp3-mesh/pins.json", + "mesh_pins_sha256": "05fddc68d2e74e00ed29126c09258766aff8a852b67681836023c097234d728b", + "host_domains": "dual", + "sparkcache": false, + "kv_cache_memory_bytes": 25769803776, + "cudagraph_capture_sizes": [ + 4, + 8, + 12, + 16, + 20, + 24, + 28, + 32, + 36, + 40, + 44, + 48, + 52, + 56, + 60, + 64 + ], + "lifecycle": "runtime/glm53-spark-mtp3-mesh/MANAGED_MESH.md" + }, + "tp4-dcp4-sparkcache": { + "template": "tp4-dcp4-sparkcache.env.example", + "inherits": "tp4-dcp4", + "tensor_parallel_size": 4, + "decode_context_parallel_size": 4, + "node_count": 4, + "transport": "sparkring-rocenante-mesh", + "mesh_pins": "glm53-spark-mtp3-mesh/pins.json", + "mesh_pins_sha256": "05fddc68d2e74e00ed29126c09258766aff8a852b67681836023c097234d728b", + "host_domains": "dual", + "sparkcache": true, + "kv_cache_memory_bytes": 25769803776, + "cudagraph_capture_sizes": [ + 4, + 8, + 12, + 16, + 20, + 24, + 28, + 32, + 36, + 40, + 44, + 48, + 52, + 56, + 60, + 64 + ], + "lifecycle": "runtime/glm53-spark-mtp3-mesh/MANAGED_MESH.md" + }, "tp2-dcp1-sparkcache": { "template": "tp2-dcp1-sparkcache.env.example", "tensor_parallel_size": 2, diff --git a/runtime/sparkring/jovian-r33/profiles/test_profile_contract.py b/runtime/sparkring/jovian-r33/profiles/test_profile_contract.py index 76cecd32..933f48f6 100644 --- a/runtime/sparkring/jovian-r33/profiles/test_profile_contract.py +++ b/runtime/sparkring/jovian-r33/profiles/test_profile_contract.py @@ -133,7 +133,15 @@ def activation(name): @pytest.mark.parametrize( - "name", ["tp2-dcp1", "tp2-dcp1-sparkcache", "tp4-dcp1", "tp4-dcp1-sparkcache"] + "name", + [ + "tp2-dcp1", + "tp2-dcp1-sparkcache", + "tp4-dcp1", + "tp4-dcp1-sparkcache", + "tp4-dcp4", + "tp4-dcp4-sparkcache", + ], ) def test_candidate_templates_match_contract_and_pinned_inputs(name): assert verifier.validate_template(name, ASSET_ROOT)["checks_passed"] is True @@ -194,7 +202,9 @@ def test_local_config_identity_can_be_qualified_before_publication(): ) -@pytest.mark.parametrize("name", ["tp2-dcp1", "tp4-dcp1", "tp4-dcp1-sparkcache"]) +@pytest.mark.parametrize( + "name", ["tp2-dcp1", "tp4-dcp1", "tp4-dcp1-sparkcache", "tp4-dcp4", "tp4-dcp4-sparkcache"] +) def test_activation_receipt_requires_runtime_counters(name): document = activation(name) document["ranks"][0]["instanttensor_allocations"] = 0 @@ -202,7 +212,9 @@ def test_activation_receipt_requires_runtime_counters(name): verifier.validate_activation(document) -@pytest.mark.parametrize("name", ["tp2-dcp1", "tp4-dcp1", "tp4-dcp1-sparkcache"]) +@pytest.mark.parametrize( + "name", ["tp2-dcp1", "tp4-dcp1", "tp4-dcp1-sparkcache", "tp4-dcp4", "tp4-dcp4-sparkcache"] +) def test_complete_activation_receipt_passes(name): assert verifier.validate_activation(activation(name)) == { "profile": name, @@ -270,7 +282,7 @@ def test_tp2_rejects_inconsistent_mhc_ceilings_across_ranks(): verifier.validate_activation(document) -@pytest.mark.parametrize("name", ["tp4-dcp1", "tp4-dcp1-sparkcache"]) +@pytest.mark.parametrize("name", ["tp4-dcp1", "tp4-dcp1-sparkcache", "tp4-dcp4", "tp4-dcp4-sparkcache"]) @pytest.mark.parametrize( "field,value,match", [ diff --git a/runtime/sparkring/jovian-r33/profiles/tp4-dcp4-sparkcache.env.example b/runtime/sparkring/jovian-r33/profiles/tp4-dcp4-sparkcache.env.example new file mode 100644 index 00000000..d5193ff8 --- /dev/null +++ b/runtime/sparkring/jovian-r33/profiles/tp4-dcp4-sparkcache.env.example @@ -0,0 +1,20 @@ +# Add this bounded cache contract to tp4-dcp4.env.example. Do not use it with TP2. +SOURCE_IMAGE_PROFILE=tp4-dcp4-sparkcache +SPARKRING_PROFILE_MODE=custom +SPARKCACHE_ENABLED=1 +SPARKCACHE_ACCESS_MODE=read-write +SPARKCACHE_ASYNC_PAGE_CAPTURE=1 +SPARKCACHE_ASYNC_CAPTURE_SLOT_BYTES=536870912 +SPARKCACHE_ASYNC_CAPTURE_SLOT_COUNT=2 +SPARKCACHE_LOAD_THREADS=2 +SPARKCACHE_MAX_PENDING_RESTORES=2 +SPARKCACHE_CUDA_RESTORE_IO_WORKERS=2 +SPARKCACHE_CUDA_ARENA_BYTES=67108864 +SPARKCACHE_BUFFER_BUDGET_BYTES=1342177280 +SPARKCACHE_MAX_BYTES=8589934592 +SPARKCACHE_LOW_WATERMARK_BYTES=6442450944 +SPARKCACHE_MIN_SPAN_TOKENS=4096 +SPARKCACHE_MAX_SPAN_TOKENS=65536 +SPARKCACHE_PUBLICATION_SCHEMA=tail-cow-v2 +SPARKCACHE_SHARED_PREFIX_LEASE_TTL_SECONDS=300 +SPARKCACHE_CACHE_NAMESPACE= diff --git a/runtime/sparkring/jovian-r33/profiles/tp4-dcp4.env.example b/runtime/sparkring/jovian-r33/profiles/tp4-dcp4.env.example new file mode 100644 index 00000000..8f86c3e4 --- /dev/null +++ b/runtime/sparkring/jovian-r33/profiles/tp4-dcp4.env.example @@ -0,0 +1,30 @@ +# R33 GLM-5.3 NVFP4-Spark TP4/DCP4. Mesh endpoints come from the managed renderer. +SOURCE_IMAGE_PROFILE=tp4-dcp4 +SPARKRING_PROFILE_MODE=custom +TENSOR_PARALLEL_SIZE=4 +DECODE_CONTEXT_PARALLEL_SIZE=4 +NODE_COUNT=4 +NODE_RANK=<0-through-3> +MASTER_ADDR= +MAX_MODEL_LEN=1048576 +KV_CACHE_MEMORY_BYTES=25769803776 +NUM_SPECULATIVE_TOKENS=3 +LOAD_FORMAT=instanttensor +MAX_CUDAGRAPH_CAPTURE_SIZE=64 +CUDAGRAPH_CAPTURE_SIZES=4,8,12,16,20,24,28,32,36,40,44,48,52,56,60,64 +VLLM_B12X_KDA_PREFILL_COALESCING=1 +VLLM_B12X_KDA_PREFILL_COALESCING_LOG_LIMIT=4 +VLLM_GLM53_MHC_PREFILL_SHARD=1 +VLLM_GLM53_MHC_PREFILL_DIAGNOSTICS=1 +VLLM_GDN_SPEC_DECODE_METADATA_FASTPATH=1 +PYTHONPATH=/opt/sparkring/sircl/python +SIRCL_ENABLED=1 +VLLM_SPARK_TP4_MODE=custom +VLLM_SPARK_TP4_VOCAB_MODE=custom +VLLM_SPARK_SHARED_CAPTURE_STREAM=1 +SPARK_TP4_HEALTH_GATE=1 +NCCL_SWITCHLESS_RING_ONLY=1 +NCCL_IB_HCA= +NCCL_IB_PRESERVE_PCI_DOMAIN=1 +NCCL_IB_ROUTE_DIAGNOSTICS=1 +SPARKCACHE_ENABLED=0 diff --git a/runtime/sparkring/jovian-r33/publication.json b/runtime/sparkring/jovian-r33/publication.json index 914b53fc..c7d09f1e 100644 --- a/runtime/sparkring/jovian-r33/publication.json +++ b/runtime/sparkring/jovian-r33/publication.json @@ -34,6 +34,14 @@ "status": "bounded-qualified", "record": "performance/records/glm53-flash/r33-image020-tp4-sparkcache-20260911.md", "sha256": "65458cfa88935a3bb6255f952ace1ed3f8b50bf778b7da46a6a6e65e1c572575" + }, + "tp4-dcp4-sparkcache": { + "status": "bounded-qualified", + "record": "performance/records/glm53-flash/r33-image020-tp4-dcp4-sparkcache-20260911.md", + "sha256": "8a172acf27efe6b1887e7f08324a70a8d5c02ab9331007eb018f59779a98eb4a", + "activation_receipt": "runtime/sparkring/jovian-r33/profiles/evidence/tp4-dcp4-sparkcache-activation-20260911.json", + "activation_receipt_sha256": "d35a111e53fed5074197f2072f512e8a1e4bc02347bc853436b974abe53902ce", + "overlay_required": "R33_PROFILE_CONTRACT_HOST_ROOT overlay (runtime/sparkring/jovian-r33/profiles) mounted read-only at the contract host root; see the record's Reproduction section" } } }