From ce031369048fbd28732daadce751e25a08f58a6a Mon Sep 17 00:00:00 2001 From: amy-why-3459 Date: Mon, 2 Nov 2026 19:47:00 +0800 Subject: [PATCH 01/17] Record four-device MiniMax-H3 lossless preflight contract Separate the four-device 910B1 campaign from existing eight-device and 910C evidence; preserve unqualified status pending hardware execution. Agent-assisted-by: Codex (implementation) Signed-off-by: amy-why-3459 --- evidence/h3-ref2va-4x910b1-320/README.md | 3 ++ .../h3-ref2va-4x910b1-320/patch/README.md | 3 ++ evidence/h3-ref2va-4x910b1-320/plan/README.md | 9 +++++ .../plan/preflight-integrity.json | 8 +++++ .../h3-ref2va-4x910b1-320/plan/runspec.json | 33 +++++++++++++++++++ .../h3-ref2va-4x910b1-320/results/status.json | 13 ++++++++ .../h3-ref2va-4x910b1-320/validator/README.md | 5 +++ tests/test_evidence_inventory.py | 4 +-- tools/evidence_inventory.json | 12 +++++++ 9 files changed, 88 insertions(+), 2 deletions(-) create mode 100644 evidence/h3-ref2va-4x910b1-320/README.md create mode 100644 evidence/h3-ref2va-4x910b1-320/patch/README.md create mode 100644 evidence/h3-ref2va-4x910b1-320/plan/README.md create mode 100644 evidence/h3-ref2va-4x910b1-320/plan/preflight-integrity.json create mode 100644 evidence/h3-ref2va-4x910b1-320/plan/runspec.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/status.json create mode 100644 evidence/h3-ref2va-4x910b1-320/validator/README.md diff --git a/evidence/h3-ref2va-4x910b1-320/README.md b/evidence/h3-ref2va-4x910b1-320/README.md new file mode 100644 index 000000000..c92733ef6 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/README.md @@ -0,0 +1,3 @@ +# MiniMax-H3 Ref2VA on four Ascend 910B1 devices + +Governing [issue #320](https://github.com/InferMatrixLab/InferRSI/issues/320). This is preparation evidence, **INCONCLUSIVE**, with no performance or quality claim. Original runtime logs, local launch scripts, weights and generated media remain external. Public receipts will retain negative and incomplete results without exposing private paths or unrelated device users. diff --git a/evidence/h3-ref2va-4x910b1-320/patch/README.md b/evidence/h3-ref2va-4x910b1-320/patch/README.md new file mode 100644 index 000000000..4eec00731 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/patch/README.md @@ -0,0 +1,3 @@ +# Candidate status + +No engine change is made by this preparation. Original source is pinned in the RunSpec. Existing eight-device lifecycle and QKV changes are candidate sources, not qualified four-device improvements. Configuration changes also require separate measurements and attribution. diff --git a/evidence/h3-ref2va-4x910b1-320/plan/README.md b/evidence/h3-ref2va-4x910b1-320/plan/README.md new file mode 100644 index 000000000..9e7ff5cf3 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/plan/README.md @@ -0,0 +1,9 @@ +# Four-device preflight plan + +This scope is 4x Ascend 910B1, not eight devices or 910C. See [acceptance issue](https://github.com/InferMatrixLab/InferRSI/issues/320). + +The initial 5s preflight runs two warmups and one measured request, 50 steps, seed zero. It is not a formal A/B or final acceptance. Startup is excluded from HTTP timing. The original baseline shutdown remains intact, so its known eight-device lifecycle concern must be checked here rather than silently repaired. Full 15s execution and independent paired comparisons remain pending. + +Runtime wrapper adapts the existing #293 harness: device-count assertion and all parallelism flags are four; output namespace and service port are isolated. Only the dense baseline arm is enabled. Outer reservation budget is five hours, with a 280-minute command deadline and 180-second kill grace; HTTP and DLO wave timeouts are 7200 seconds. This is a bringup ceiling, not a measured latency or a final experiment budget. + +The allocated physical IDs are recorded at execution. NPU scheduling is respected; no resource is claimed before allocation. Later A/B work must pin the same allocation throughout the pair and independently freeze its budget and order. diff --git a/evidence/h3-ref2va-4x910b1-320/plan/preflight-integrity.json b/evidence/h3-ref2va-4x910b1-320/plan/preflight-integrity.json new file mode 100644 index 000000000..4abf25cb0 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/plan/preflight-integrity.json @@ -0,0 +1,8 @@ +{ + "README.md": "d5822814310a69a38020d9ea161d7fbd65e1172d378ddd3754ec774814ac5f1e", + "plan/runspec.json": "a953c51e12cb5d9d6e3772de7662502495081e63c9bb63ee4ba970fa85e3a90b", + "plan/README.md": "0a69099873380e1df33668c29ac13e446c91f032e6bcc4f9acbf1cfb741dcd03", + "results/status.json": "8e24eafc59dfc6b21ee9fe86f6b31abb7811796c6eab343b817d0a0d67eb5294", + "patch/README.md": "cb31b290e76ef8ae3c416f3cca9558ed8c37d7deaf8bbbb192231004d8fb3760", + "validator/README.md": "f9e01f0416e51c8f86ad7162eeb6fcc7c5f1cc0b3c5ce5f0e8a7651e9d5fc4bc" +} diff --git a/evidence/h3-ref2va-4x910b1-320/plan/runspec.json b/evidence/h3-ref2va-4x910b1-320/plan/runspec.json new file mode 100644 index 000000000..7096175a5 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/plan/runspec.json @@ -0,0 +1,33 @@ +{ + "status": "preflight_only", + "hardware": "4x Ascend 910B1 64GiB", + "baseline": "c7f56f0155953c7d4a77276a2f4fcbd844ab0da2", + "workload": { + "width": 1344, + "height": 768, + "fps": 24, + "steps": 50, + "seed": 0, + "durations_s": [ + 5, + 15 + ], + "concurrency": 1 + }, + "preflight": { + "duration_s": 5, + "warmups": 2, + "measured": 1, + "limitation": "bringup and repeatability only; not formal speedup evidence" + }, + "lossless": "No cache, quantization, sparse attention, distillation or reduced steps. Exact decoded parity is sufficient; nonidentical output is not accepted on perceptual thresholds alone. Assess baseline repeatability first.", + "later_validation": "Freeze individual candidate and final ABBA protocols before search; quality independent of timing; raw complete HTTP samples, stage diagnostics separately, all-rank memory and exits.", + "sources": [ + "https://github.com/vllm-project/vllm-omni/pull/9698", + "https://github.com/InferMatrixLab/InferRSI/pull/318", + "https://github.com/vllm-project/vllm-omni/pull/5929", + "https://github.com/vllm-project/vllm-omni/pull/5764", + "https://github.com/vllm-project/vllm-omni/pull/4150" + ], + "issue": "https://github.com/InferMatrixLab/InferRSI/issues/320" +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/status.json b/evidence/h3-ref2va-4x910b1-320/results/status.json new file mode 100644 index 000000000..31b17270c --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/status.json @@ -0,0 +1,13 @@ +{ + "verdict": "INCONCLUSIVE", + "execution": "queued", + "four_device_samples": 0, + "speedup": null, + "quality_acceptance": false, + "limitations": [ + "No four-device execution result yet", + "No candidate search", + "No final 5s/15s paired measurement", + "No independent review" + ] +} diff --git a/evidence/h3-ref2va-4x910b1-320/validator/README.md b/evidence/h3-ref2va-4x910b1-320/validator/README.md new file mode 100644 index 000000000..356670b5e --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/validator/README.md @@ -0,0 +1,5 @@ +# Validation boundary + +The preflight client uses the upstream H3 Ref2VA request and media shape contract, inherited from the #293 client. Complete decoded media checks and authenticated scorer loading will reuse [the repair in #318](https://github.com/InferMatrixLab/InferRSI/pull/318) at an explicitly frozen revision before candidate search. The old SSIM/PSNR/LPIPS and audio similarity thresholds alone do not establish losslessness. + +Baseline repetition is required before judging nonidentical outputs. Exact decoded parity is sufficient for the media comparison; missing or nonidentical evidence remains INCONCLUSIVE without additional equivalence proof. Both video and audio require expected temporal coverage. No candidate validator is frozen yet and no candidate search has begun. diff --git a/tests/test_evidence_inventory.py b/tests/test_evidence_inventory.py index 661b42972..34175ef9b 100644 --- a/tests/test_evidence_inventory.py +++ b/tests/test_evidence_inventory.py @@ -145,6 +145,6 @@ def test_checked_in_inventory(): repo = Path(__file__).resolve().parents[1] result = validate_inventory(repo) assert result["errors"] == [] - assert len(result["bundles"]) == 20 - assert result["checked_hashes"] == 425 + assert len(result["bundles"]) == 21 + assert result["checked_hashes"] == 431 assert result["unavailable"] # Historical raw artifacts are not in this checkout. diff --git a/tools/evidence_inventory.json b/tools/evidence_inventory.json index 023d17035..84593aeab 100644 --- a/tools/evidence_inventory.json +++ b/tools/evidence_inventory.json @@ -1,6 +1,18 @@ { "version": 1, "bundles": { + "h3-ref2va-4x910b1-320": { + "kind": "campaign", + "manifests": [ + { + "path": "plan/preflight-integrity.json", + "schema": "bundle-sha256" + } + ], + "external": [ + "Original runtime scripts and logs, model and input bytes, physical allocation details and output media are external. No four-device performance or quality validation is claimed." + ] + }, "h3-ref2va-ascend-293": { "kind": "campaign", "manifests": [ From a42a0e04dc9ccf2801f48b351522032066bc4d50 Mon Sep 17 00:00:00 2001 From: amy-why-3459 Date: Mon, 2 Nov 2026 20:08:59 +0800 Subject: [PATCH 02/17] Record first four-device full-compute warmup receipt Preserve its cold-warmup timing boundary and pending independent quality, repeated requests and process cleanup. Agent-assisted-by: Codex (implementation) Signed-off-by: amy-why-3459 --- .../plan/input-source-audit.json | 18 ++++++++ .../results/first-warmup-integrity.json | 4 ++ .../results/first-warmup.json | 46 +++++++++++++++++++ tests/test_evidence_inventory.py | 2 +- tools/evidence_inventory.json | 4 ++ 5 files changed, 73 insertions(+), 1 deletion(-) create mode 100644 evidence/h3-ref2va-4x910b1-320/plan/input-source-audit.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/first-warmup-integrity.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/first-warmup.json diff --git a/evidence/h3-ref2va-4x910b1-320/plan/input-source-audit.json b/evidence/h3-ref2va-4x910b1-320/plan/input-source-audit.json new file mode 100644 index 000000000..91d433cdf --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/plan/input-source-audit.json @@ -0,0 +1,18 @@ +{ + "source_revision": "c7f56f0155953c7d4a77276a2f4fcbd844ab0da2", + "source_file": "tests/e2e/accuracy/minimax_h3/test_minimax_h3_i2va_ref2va_similarity.py", + "prompt_sha256": "91c1340ea893aede82312dec30a6ae8c975c1def921348fc1cc45ccc86b315dd", + "comparisons": [ + { + "constant": "I2VA_PROMPT", + "exact": false, + "stripped_equal": false + }, + { + "constant": "REF2VA_PROMPT", + "exact": true, + "stripped_equal": true + } + ], + "scope": "Source/input identity only; no quality acceptance" +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/first-warmup-integrity.json b/evidence/h3-ref2va-4x910b1-320/results/first-warmup-integrity.json new file mode 100644 index 000000000..a82e478db --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/first-warmup-integrity.json @@ -0,0 +1,4 @@ +{ + "results/first-warmup.json": "4fb8fd266a583519a2ed5b8d71d585e54ffe278f405146376d630b1f5ad3f42c", + "plan/input-source-audit.json": "69decc350628061fbe5c7fed638440797cff75e3b4afa690b93d77418791c4d9" +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/first-warmup.json b/evidence/h3-ref2va-4x910b1-320/results/first-warmup.json new file mode 100644 index 000000000..d568e21de --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/first-warmup.json @@ -0,0 +1,46 @@ +{ + "verdict": "INCONCLUSIVE", + "scope": "First cold warmup only; no speedup, losslessness or lifecycle acceptance", + "source_revision": "c7f56f0155953c7d4a77276a2f4fcbd844ab0da2", + "devices": { + "type": "Ascend 910B1", + "count": 4 + }, + "workload": { + "duration_s": 5, + "steps": 50, + "seed": 0 + }, + "http_status": 200, + "e2e_ms": 965546.0942862555, + "bytes": 6515503, + "client_shape_check": true, + "media_sha256": "0a92630ef195d304f559e2b7e973be363f539912d146af8e4c4eaa5308097fd2", + "stream_fields": [ + { + "codec_type": "video", + "width": 1344, + "height": 768, + "avg_frame_rate": "24/1", + "start_time": "0.000000", + "duration": "5.166667", + "nb_frames": "124" + }, + { + "codec_type": "audio", + "sample_rate": "32000", + "channels": 2, + "avg_frame_rate": "0/0", + "start_time": "0.000000", + "duration": "5.175000", + "nb_frames": "163" + } + ], + "remaining": [ + "Second warmup and measured request", + "Independent decoded media/audio coverage and repeatability", + "Actual four-worker exit receipts and source integrity recheck", + "15s baseline and all candidate comparisons" + ], + "external_artifacts": "Original media and runtime logs remain outside the repository." +} diff --git a/tests/test_evidence_inventory.py b/tests/test_evidence_inventory.py index 34175ef9b..db2a8ccef 100644 --- a/tests/test_evidence_inventory.py +++ b/tests/test_evidence_inventory.py @@ -146,5 +146,5 @@ def test_checked_in_inventory(): result = validate_inventory(repo) assert result["errors"] == [] assert len(result["bundles"]) == 21 - assert result["checked_hashes"] == 431 + assert result["checked_hashes"] == 433 assert result["unavailable"] # Historical raw artifacts are not in this checkout. diff --git a/tools/evidence_inventory.json b/tools/evidence_inventory.json index 84593aeab..bdb453da5 100644 --- a/tools/evidence_inventory.json +++ b/tools/evidence_inventory.json @@ -7,6 +7,10 @@ { "path": "plan/preflight-integrity.json", "schema": "bundle-sha256" + }, + { + "path": "results/first-warmup-integrity.json", + "schema": "bundle-sha256" } ], "external": [ From 8710bbd9637deaeeb5643e0a67cc6d94ea98b31d Mon Sep 17 00:00:00 2001 From: amy-why-3459 Date: Mon, 2 Nov 2026 20:43:31 +0800 Subject: [PATCH 03/17] Record four-card H3 baseline repeatability and shutdown failure Agent-assisted-by: Codex (implementation) Signed-off-by: amy-why-3459 --- .../results/baseline-5s-complete.json | 159 ++++++++++++++++++ .../results/baseline-complete-integrity.json | 7 + .../results/baseline-lifecycle-diagnosis.json | 17 ++ .../results/baseline-w0-m0.json | 34 ++++ .../results/baseline-w0-w1.json | 34 ++++ .../results/baseline-w1-m0.json | 34 ++++ tests/test_evidence_inventory.py | 2 +- tools/evidence_inventory.json | 4 + 8 files changed, 290 insertions(+), 1 deletion(-) create mode 100644 evidence/h3-ref2va-4x910b1-320/results/baseline-5s-complete.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/baseline-complete-integrity.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/baseline-lifecycle-diagnosis.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/baseline-w0-m0.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/baseline-w0-w1.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/baseline-w1-m0.json diff --git a/evidence/h3-ref2va-4x910b1-320/results/baseline-5s-complete.json b/evidence/h3-ref2va-4x910b1-320/results/baseline-5s-complete.json new file mode 100644 index 000000000..72aa23580 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/baseline-5s-complete.json @@ -0,0 +1,159 @@ +{ + "run": "baseline-5s-preflight", + "source_revision": "c7f56f0155953c7d4a77276a2f4fcbd844ab0da2", + "configuration": { + "pipeline_profiler": false, + "heldout_quality_cases": false, + "diagnostic_shutdown_override": false, + "shutdown_mode": "native", + "arm": "base", + "steps": 50, + "requests": 1, + "serve_args": [ + "--num-gpus", + "4", + "--usp", + "4", + "--ring", + "1", + "--text-encoder-tp-size", + "4", + "--vae-parallel-mode", + "tile", + "--vae-use-tiling", + "--vae-patch-parallel-size", + "4", + "--enable-distributed-layerwise-offload", + "--disable-log-stats", + "--diffusion-attention-backend", + "FLASH_ATTN" + ], + "warmups_per_duration": 2, + "durations_s": [ + 5 + ], + "dlo_wave_timeout_s": 7200.0, + "seeds": [ + 0 + ], + "inputs_sha256": { + "prompt.txt": "91c1340ea893aede82312dec30a6ae8c975c1def921348fc1cc45ccc86b315dd", + "input_video.mp4": "d6edc20ac82aa980c9cbd0b05b371f60d12dc8d018492e571b42de0086819c41", + "input_audio.mp3": "2a48d447b343b38a2c504d5281a0c97c688db0ba87931ed9282c598bd6752454" + } + }, + "runtime_settings_sha256": "b7f691c4621a21611c7ce4d61a7a14db898ba4394d4230a378471c99d5bda6f9", + "cells": [ + { + "duration_s": 5, + "seed": 0, + "expected_measured_requests": 1, + "completed": 1, + "failed": 0, + "missing": 0, + "samples_ms": [ + 814064.1126520932 + ], + "mean_ms": 814064.1126520932, + "median_ms": 814064.1126520932, + "min_ms": 814064.1126520932, + "max_ms": 814064.1126520932, + "request_sample_stdev_ms": null, + "statistics_scope": "Requests within one server; not independent process rounds or a reliable tail-latency estimate" + } + ], + "samples_including_warmups": [ + { + "label": "measured-5-seed0-0", + "seconds": 5, + "seed": 0, + "steps": 50, + "valid": true, + "e2e_ms": 814064.1126520932, + "http_status": 200, + "bytes": 6510797, + "response_metrics": { + "X-Inference-Time-S": "814.003", + "X-Stage-Durations": "{\"queue_wait_ms\":0.4363926127552986,\"stage_0_gen_ms\":812797.1453666687}", + "X-Peak-Memory-MB": "19908.000" + }, + "output_sha256": "76d24b9b6ff0bccfc6f3d09c5cf657ec38fa3b383ad68be161acdaaa3d8592d4" + }, + { + "label": "warmup-5-0", + "seconds": 5, + "seed": 0, + "steps": 50, + "valid": true, + "e2e_ms": 965546.0942862555, + "http_status": 200, + "bytes": 6515503, + "response_metrics": { + "X-Inference-Time-S": "965.448", + "X-Stage-Durations": "{\"queue_wait_ms\":0.4564328119158745,\"stage_0_gen_ms\":964555.6063652039}", + "X-Peak-Memory-MB": "19828.000" + }, + "output_sha256": "0a92630ef195d304f559e2b7e973be363f539912d146af8e4c4eaa5308097fd2" + }, + { + "label": "warmup-5-1", + "seconds": 5, + "seed": 0, + "steps": 50, + "valid": true, + "e2e_ms": 855532.035458833, + "http_status": 200, + "bytes": 6508771, + "response_metrics": { + "X-Inference-Time-S": "855.465", + "X-Stage-Durations": "{\"queue_wait_ms\":0.6018057465553284,\"stage_0_gen_ms\":854387.8092765808}", + "X-Peak-Memory-MB": "19848.000" + }, + "output_sha256": "c30c23c6a753294914ef457789f70f5f0255d279d6233dc8d9fb1b2e82cdd483" + } + ], + "quality": "All three repeated-baseline pairs pass media gates, but decoded video and audio differ; separate repeatability adjudication required", + "lifecycle": { + "status": "fail", + "container_exit": 0, + "server_exit": 0, + "forced_signals": 8, + "host_cleanup_intervention": false, + "expected_workers": 4, + "workers": [ + { + "name": "DiffusionWorker-0", + "exit_code": null, + "alive": true + }, + { + "name": "DiffusionWorker-1", + "exit_code": null, + "alive": true + }, + { + "name": "DiffusionWorker-2", + "exit_code": null, + "alive": true + }, + { + "name": "DiffusionWorker-3", + "exit_code": null, + "alive": true + } + ] + }, + "service_log_sha256": "5f9d2174ff94ee46f2dbbf8ec274321fcfc7ad4e23f2640d551c23d3a8d0dd71", + "verdict": "INCONCLUSIVE", + "scope": "5s feasibility and baseline repeatability only; original lifecycle FAIL; no optimization gain certified", + "hardware": { + "type": "Ascend 910B1", + "count": 4 + }, + "limitations": [ + "One measured request after two warmups, one server; no reliable tail estimate.", + "Warmup reduction is not optimization gain.", + "HTTP, service and container success do not override failed worker teardown.", + "Rank-reported memory header is not an all-rank physical peak." + ] +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/baseline-complete-integrity.json b/evidence/h3-ref2va-4x910b1-320/results/baseline-complete-integrity.json new file mode 100644 index 000000000..31427aa70 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/baseline-complete-integrity.json @@ -0,0 +1,7 @@ +{ + "results/baseline-5s-complete.json": "28ab7da8f3cd6cd2ca96030795833bb9b2b657bada9f765896755b78f39f3fe7", + "results/baseline-w0-w1.json": "f17d234168d6e4e8d3651b683059efd52ba173aea8f15f07ec4ea55becd46837", + "results/baseline-w1-m0.json": "33f38006ed56e4bd7787c786399a40d2380d434fd857f49324f6962a5d57da7f", + "results/baseline-w0-m0.json": "ad624f94d07de9ca68be6ef6ba80f54913d698229951f5f75a342dd3689b25a4", + "results/baseline-lifecycle-diagnosis.json": "ae8c119805fe5a61ff55718828444f9382c220d6300dd9f4af87ff0903fd6040" +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/baseline-lifecycle-diagnosis.json b/evidence/h3-ref2va-4x910b1-320/results/baseline-lifecycle-diagnosis.json new file mode 100644 index 000000000..bc558e2ea --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/baseline-lifecycle-diagnosis.json @@ -0,0 +1,17 @@ +{ + "status": "reproduced_failure_not_yet_fixed_on_four_cards", + "source_revision": "c7f56f0155953c7d4a77276a2f4fcbd844ab0da2", + "service_log_sha256": "5f9d2174ff94ee46f2dbbf8ec274321fcfc7ad4e23f2640d551c23d3a8d0dd71", + "observed_sequence": [ + "Worker event loops terminated.", + "After 15s, executor sent terminate to all four workers.", + "Each rank logged cleanup failure restoring a rank-local block: restore_tensor_storage -> restored.copy_(value) -> signal_handler -> SystemExit(143).", + "Executor then sent kill to all four workers; all four terminal receipts had exit_code=null and alive=true.", + "TBE subprocess and leaked semaphore/shared-memory warnings followed." + ], + "candidate_source": "https://github.com/vllm-project/vllm-omni/pull/9698", + "candidate_revision": "ce216014adb4c037dc15b3d49623e493ca3d3ac3", + "candidate_mechanism": "Terminal shutdown discards weights after stream drainage instead of rebuilding unused CPU weights; ordinary disable preserves restoration. NPU grace is 60s enclosed by 90s orchestration join.", + "claim_limit": "No forward-computation change or inference speedup claimed. Four-card candidate validation queued separately; no independent review claimed.", + "external_artifacts": "Original logs, model inputs, generated media and allocation details retained outside this public repository." +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/baseline-w0-m0.json b/evidence/h3-ref2va-4x910b1-320/results/baseline-w0-m0.json new file mode 100644 index 000000000..2d64a2f05 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/baseline-w0-m0.json @@ -0,0 +1,34 @@ +{ + "verdict": "INCONCLUSIVE", + "media_gate_verdict": "PASS", + "scope": "decoded media equality; unequal outputs require separate baseline-repeatability adjudication", + "exact_video": false, + "exact_audio": false, + "coverage": [ + { + "expected_duration_s": 5.166666666666667, + "decoded_audio_end_s": 5.184 + }, + { + "expected_duration_s": 5.166666666666667, + "decoded_audio_end_s": 5.184 + } + ], + "scorer_identity": { + "alexnet_sha256": "7be5be791159472b1fbf3c69796f7cb30dca7ad8466c2df70058c37116cdee02", + "lpips_sha256": "df73285e35b22355a2df87cdb6b70b343713b667eddbda73e1977e0c860835c0" + }, + "metrics": { + "ssim": 0.985947, + "psnr_db": 46.220381, + "lpips": 0.015869767277411396, + "audio_spectral_cosine": 0.9995913108189901, + "audio_rms_ratio": 0.9981767509659282, + "audio_samples": 165888 + }, + "inputs": { + "baseline": "0a92630ef195d304f559e2b7e973be363f539912d146af8e4c4eaa5308097fd2", + "candidate": "76d24b9b6ff0bccfc6f3d09c5cf657ec38fa3b383ad68be161acdaaa3d8592d4", + "gates": "aa4330075b6da7ab268e6ef092c42b0e037681695b54b238b09692c21d58bb9a" + } +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/baseline-w0-w1.json b/evidence/h3-ref2va-4x910b1-320/results/baseline-w0-w1.json new file mode 100644 index 000000000..5a0f0e8c9 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/baseline-w0-w1.json @@ -0,0 +1,34 @@ +{ + "verdict": "INCONCLUSIVE", + "media_gate_verdict": "PASS", + "scope": "decoded media equality; unequal outputs require separate baseline-repeatability adjudication", + "exact_video": false, + "exact_audio": false, + "coverage": [ + { + "expected_duration_s": 5.166666666666667, + "decoded_audio_end_s": 5.184 + }, + { + "expected_duration_s": 5.166666666666667, + "decoded_audio_end_s": 5.184 + } + ], + "scorer_identity": { + "alexnet_sha256": "7be5be791159472b1fbf3c69796f7cb30dca7ad8466c2df70058c37116cdee02", + "lpips_sha256": "df73285e35b22355a2df87cdb6b70b343713b667eddbda73e1977e0c860835c0" + }, + "metrics": { + "ssim": 0.985956, + "psnr_db": 46.229862, + "lpips": 0.01582889360255532, + "audio_spectral_cosine": 0.9996266067028046, + "audio_rms_ratio": 1.0007995909660834, + "audio_samples": 165888 + }, + "inputs": { + "baseline": "0a92630ef195d304f559e2b7e973be363f539912d146af8e4c4eaa5308097fd2", + "candidate": "c30c23c6a753294914ef457789f70f5f0255d279d6233dc8d9fb1b2e82cdd483", + "gates": "aa4330075b6da7ab268e6ef092c42b0e037681695b54b238b09692c21d58bb9a" + } +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/baseline-w1-m0.json b/evidence/h3-ref2va-4x910b1-320/results/baseline-w1-m0.json new file mode 100644 index 000000000..7a2726079 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/baseline-w1-m0.json @@ -0,0 +1,34 @@ +{ + "verdict": "INCONCLUSIVE", + "media_gate_verdict": "PASS", + "scope": "decoded media equality; unequal outputs require separate baseline-repeatability adjudication", + "exact_video": false, + "exact_audio": false, + "coverage": [ + { + "expected_duration_s": 5.166666666666667, + "decoded_audio_end_s": 5.184 + }, + { + "expected_duration_s": 5.166666666666667, + "decoded_audio_end_s": 5.184 + } + ], + "scorer_identity": { + "alexnet_sha256": "7be5be791159472b1fbf3c69796f7cb30dca7ad8466c2df70058c37116cdee02", + "lpips_sha256": "df73285e35b22355a2df87cdb6b70b343713b667eddbda73e1977e0c860835c0" + }, + "metrics": { + "ssim": 0.985965, + "psnr_db": 46.229545, + "lpips": 0.01594062664756371, + "audio_spectral_cosine": 0.9994688431421915, + "audio_rms_ratio": 0.9973792555234526, + "audio_samples": 165888 + }, + "inputs": { + "baseline": "c30c23c6a753294914ef457789f70f5f0255d279d6233dc8d9fb1b2e82cdd483", + "candidate": "76d24b9b6ff0bccfc6f3d09c5cf657ec38fa3b383ad68be161acdaaa3d8592d4", + "gates": "aa4330075b6da7ab268e6ef092c42b0e037681695b54b238b09692c21d58bb9a" + } +} diff --git a/tests/test_evidence_inventory.py b/tests/test_evidence_inventory.py index db2a8ccef..21e9a511c 100644 --- a/tests/test_evidence_inventory.py +++ b/tests/test_evidence_inventory.py @@ -146,5 +146,5 @@ def test_checked_in_inventory(): result = validate_inventory(repo) assert result["errors"] == [] assert len(result["bundles"]) == 21 - assert result["checked_hashes"] == 433 + assert result["checked_hashes"] == 438 assert result["unavailable"] # Historical raw artifacts are not in this checkout. diff --git a/tools/evidence_inventory.json b/tools/evidence_inventory.json index bdb453da5..e89c0f223 100644 --- a/tools/evidence_inventory.json +++ b/tools/evidence_inventory.json @@ -11,6 +11,10 @@ { "path": "results/first-warmup-integrity.json", "schema": "bundle-sha256" + }, + { + "path": "results/baseline-complete-integrity.json", + "schema": "bundle-sha256" } ], "external": [ From 9c528c7d09a8724690bbc51d3362021a10860a9f Mon Sep 17 00:00:00 2001 From: amy-why-3459 Date: Tue, 3 Nov 2026 08:54:13 +0800 Subject: [PATCH 04/17] Record clean four-rank H3 diagnostic shutdown Agent-assisted-by: Codex (implementation) Signed-off-by: amy-why-3459 --- .../lifecycle-diagnostic-integrity.json | 3 ++ .../results/lifecycle-diagnostic.json | 36 +++++++++++++++++++ tests/test_evidence_inventory.py | 2 +- tools/evidence_inventory.json | 4 +++ 4 files changed, 44 insertions(+), 1 deletion(-) create mode 100644 evidence/h3-ref2va-4x910b1-320/results/lifecycle-diagnostic-integrity.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/lifecycle-diagnostic.json diff --git a/evidence/h3-ref2va-4x910b1-320/results/lifecycle-diagnostic-integrity.json b/evidence/h3-ref2va-4x910b1-320/results/lifecycle-diagnostic-integrity.json new file mode 100644 index 000000000..911f1f034 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/lifecycle-diagnostic-integrity.json @@ -0,0 +1,3 @@ +{ + "results/lifecycle-diagnostic.json": "7e5fc0af6460b393a615d4c90a21f005eebfbe4d074ce5554c3f02f1125377ab" +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/lifecycle-diagnostic.json b/evidence/h3-ref2va-4x910b1-320/results/lifecycle-diagnostic.json new file mode 100644 index 000000000..4ca69d271 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/lifecycle-diagnostic.json @@ -0,0 +1,36 @@ +{ + "source_revision": "ce216014adb4c037dc15b3d49623e493ca3d3ac3", + "scope": "Four-card 5-step diagnostic only; no full-compute performance or losslessness acceptance", + "workers": [ + { + "name": "DiffusionWorker-0", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-1", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-2", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-3", + "exit_code": 0, + "alive": false + } + ], + "container_exit": 0, + "server_exit": 0, + "service_log_sha256": "716741040cf82f251f1755d633921964f3a47cabc27b75c8ae12f1416f96594a", + "profiling": "Start/stop HTTP200. Raw traces retained for all four ranks; online analysis rejected because workers are daemon processes. Offline analysis pending.", + "source": "https://github.com/vllm-project/vllm-omni/pull/9698", + "outputs": { + "diagnostic-warmup": true, + "diagnostic-profile": true + }, + "interpretation": "Terminal-discard and bounded-grace candidate exited cleanly in this diagnostic. Full50-step15s lifecycle remains to be checked." +} diff --git a/tests/test_evidence_inventory.py b/tests/test_evidence_inventory.py index 21e9a511c..f8b753081 100644 --- a/tests/test_evidence_inventory.py +++ b/tests/test_evidence_inventory.py @@ -146,5 +146,5 @@ def test_checked_in_inventory(): result = validate_inventory(repo) assert result["errors"] == [] assert len(result["bundles"]) == 21 - assert result["checked_hashes"] == 438 + assert result["checked_hashes"] == 439 assert result["unavailable"] # Historical raw artifacts are not in this checkout. diff --git a/tools/evidence_inventory.json b/tools/evidence_inventory.json index e89c0f223..4f2cd6126 100644 --- a/tools/evidence_inventory.json +++ b/tools/evidence_inventory.json @@ -15,6 +15,10 @@ { "path": "results/baseline-complete-integrity.json", "schema": "bundle-sha256" + }, + { + "path": "results/lifecycle-diagnostic-integrity.json", + "schema": "bundle-sha256" } ], "external": [ From b8044139a07c1a45b49613eb2a2b5087b4f2160f Mon Sep 17 00:00:00 2001 From: amy-why-3459 Date: Tue, 3 Nov 2026 09:17:11 +0800 Subject: [PATCH 05/17] Freeze requested lossless thirty-percent latency target Agent-assisted-by: Codex (implementation) Signed-off-by: amy-why-3459 --- .../plan/acceptance-30pct-integrity.json | 3 +++ .../plan/acceptance-30pct.json | 19 +++++++++++++++++++ tests/test_evidence_inventory.py | 2 +- tools/evidence_inventory.json | 4 ++++ 4 files changed, 27 insertions(+), 1 deletion(-) create mode 100644 evidence/h3-ref2va-4x910b1-320/plan/acceptance-30pct-integrity.json create mode 100644 evidence/h3-ref2va-4x910b1-320/plan/acceptance-30pct.json diff --git a/evidence/h3-ref2va-4x910b1-320/plan/acceptance-30pct-integrity.json b/evidence/h3-ref2va-4x910b1-320/plan/acceptance-30pct-integrity.json new file mode 100644 index 000000000..558568c1f --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/plan/acceptance-30pct-integrity.json @@ -0,0 +1,3 @@ +{ + "plan/acceptance-30pct.json": "fa3edf7110bb18bf05ed9f95b93fbd3cf7aecff2a57729155bb61c8dd24e1f84" +} diff --git a/evidence/h3-ref2va-4x910b1-320/plan/acceptance-30pct.json b/evidence/h3-ref2va-4x910b1-320/plan/acceptance-30pct.json new file mode 100644 index 000000000..c44b007c6 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/plan/acceptance-30pct.json @@ -0,0 +1,19 @@ +{ + "target": "At least30percent lower E2E latency without quality loss", + "metric": "1 - candidate_e2e_ms / matched_baseline_e2e_ms >= 0.30", + "workloads_s": [ + 5, + 15 + ], + "hardware": "Same4physical Ascend910B1 devices", + "precision": "BF16; full50steps; same dense attention and inputs; no approximate cache, sparsity, quantization or distillation", + "evidence_required": [ + "Separate matched baseline/candidate repetitions at both durations with clean worker lifecycle", + "Individual optimization attribution plus directly measured final combination", + "Independent audio/video coverage and quality checks; baseline nondeterminism explicitly adjudicated", + "Frozen source/runtime/input identity; no profiler or CPU scoring concurrent with timing", + "One engine PR and RSI evidence publication" + ], + "status": "Not achieved. Existing5s814.064s sample is feasibility-only, not the final acceptance denominator.", + "target_note": "Latency reduction30percent is stricter than throughput1.30x; this campaign uses latency reduction to match requested E2E objective." +} diff --git a/tests/test_evidence_inventory.py b/tests/test_evidence_inventory.py index f8b753081..60f2a8096 100644 --- a/tests/test_evidence_inventory.py +++ b/tests/test_evidence_inventory.py @@ -146,5 +146,5 @@ def test_checked_in_inventory(): result = validate_inventory(repo) assert result["errors"] == [] assert len(result["bundles"]) == 21 - assert result["checked_hashes"] == 439 + assert result["checked_hashes"] == 440 assert result["unavailable"] # Historical raw artifacts are not in this checkout. diff --git a/tools/evidence_inventory.json b/tools/evidence_inventory.json index 4f2cd6126..898acbc2e 100644 --- a/tools/evidence_inventory.json +++ b/tools/evidence_inventory.json @@ -19,6 +19,10 @@ { "path": "results/lifecycle-diagnostic-integrity.json", "schema": "bundle-sha256" + }, + { + "path": "plan/acceptance-30pct-integrity.json", + "schema": "bundle-sha256" } ], "external": [ From 9d15818cc863452bbb6ffb01feffedacf7d9a856 Mon Sep 17 00:00:00 2001 From: amy-why-3459 Date: Tue, 3 Nov 2026 12:04:38 +0800 Subject: [PATCH 06/17] Record full fifteen-second baseline and dense attention bottleneck Agent-assisted-by: Codex (implementation) Signed-off-by: amy-why-3459 --- .../results/baseline15-complete.json | 131 ++++++++++ .../results/baseline15-profile-integrity.json | 12 + .../results/baseline15-repeatability-v2.json | 34 +++ .../results/five-step-kernel-summary.json | 197 +++++++++++++++ .../validator-v2/README.md | 9 + .../validator-v2/compare.py | 230 ++++++++++++++++++ .../validator-v2/contract-revision.json | 11 + .../validator-v2/gates.json | 15 ++ .../validator-v2/integrity.py | 106 ++++++++ .../validator-v2/upstream_metrics.py | 100 ++++++++ .../validator-v2/weights.json | 4 + tests/test_evidence_inventory.py | 2 +- tools/evidence_inventory.json | 4 + 13 files changed, 854 insertions(+), 1 deletion(-) create mode 100644 evidence/h3-ref2va-4x910b1-320/results/baseline15-complete.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/baseline15-profile-integrity.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/baseline15-repeatability-v2.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/five-step-kernel-summary.json create mode 100644 evidence/h3-ref2va-4x910b1-320/validator-v2/README.md create mode 100644 evidence/h3-ref2va-4x910b1-320/validator-v2/compare.py create mode 100644 evidence/h3-ref2va-4x910b1-320/validator-v2/contract-revision.json create mode 100644 evidence/h3-ref2va-4x910b1-320/validator-v2/gates.json create mode 100644 evidence/h3-ref2va-4x910b1-320/validator-v2/integrity.py create mode 100644 evidence/h3-ref2va-4x910b1-320/validator-v2/upstream_metrics.py create mode 100644 evidence/h3-ref2va-4x910b1-320/validator-v2/weights.json diff --git a/evidence/h3-ref2va-4x910b1-320/results/baseline15-complete.json b/evidence/h3-ref2va-4x910b1-320/results/baseline15-complete.json new file mode 100644 index 000000000..a1f335080 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/baseline15-complete.json @@ -0,0 +1,131 @@ +{ + "run": "lifecycle-control-15s-preflight", + "source_revision": "ce216014adb4c037dc15b3d49623e493ca3d3ac3", + "configuration": { + "pipeline_profiler": false, + "heldout_quality_cases": false, + "diagnostic_shutdown_override": false, + "shutdown_mode": "native", + "arm": "base", + "steps": 50, + "requests": 1, + "serve_args": [ + "--num-gpus", + "4", + "--usp", + "4", + "--ring", + "1", + "--text-encoder-tp-size", + "4", + "--vae-parallel-mode", + "tile", + "--vae-use-tiling", + "--vae-patch-parallel-size", + "4", + "--enable-distributed-layerwise-offload", + "--disable-log-stats", + "--diffusion-attention-backend", + "FLASH_ATTN" + ], + "warmups_per_duration": 1, + "durations_s": [ + 15 + ], + "dlo_wave_timeout_s": 14400.0, + "seeds": [ + 0 + ], + "inputs_sha256": { + "prompt.txt": "91c1340ea893aede82312dec30a6ae8c975c1def921348fc1cc45ccc86b315dd", + "input_video.mp4": "d6edc20ac82aa980c9cbd0b05b371f60d12dc8d018492e571b42de0086819c41", + "input_audio.mp3": "2a48d447b343b38a2c504d5281a0c97c688db0ba87931ed9282c598bd6752454" + } + }, + "runtime_settings_sha256": "2c493e74e84b1911631ae3ec516241b08699396643f825620851cb80e9698cad", + "cells": [ + { + "duration_s": 15, + "seed": 0, + "expected_measured_requests": 1, + "completed": 1, + "failed": 0, + "missing": 0, + "samples_ms": [ + 2475905.6189153343 + ], + "mean_ms": 2475905.6189153343, + "median_ms": 2475905.6189153343, + "min_ms": 2475905.6189153343, + "max_ms": 2475905.6189153343, + "request_sample_stdev_ms": null, + "statistics_scope": "Requests within one server; not independent process rounds or a reliable tail-latency estimate" + } + ], + "samples_including_warmups": [ + { + "label": "measured-15-seed0-0", + "seconds": 15, + "seed": 0, + "steps": 50, + "valid": true, + "e2e_ms": 2475905.6189153343, + "http_status": 200, + "bytes": 16710840, + "response_metrics": { + "X-Inference-Time-S": "2475.811", + "X-Stage-Durations": "{\"queue_wait_ms\":0.5407044664025307,\"stage_0_gen_ms\":2473616.728067398}", + "X-Peak-Memory-MB": "20768.000" + }, + "output_sha256": "99f24d2e633a3d6ccfa64ba0b97909790b54b572c6cdba6648b96baff1b8e210" + }, + { + "label": "warmup-15", + "seconds": 15, + "seed": 0, + "steps": 50, + "valid": true, + "e2e_ms": 2597199.9981971458, + "http_status": 200, + "bytes": 16690782, + "response_metrics": { + "X-Inference-Time-S": "2597.061", + "X-Stage-Durations": "{\"queue_wait_ms\":0.4240507259964943,\"stage_0_gen_ms\":2594380.5537223816}", + "X-Peak-Memory-MB": "20548.000" + }, + "output_sha256": "93c0b94392b6f8e75d8e788f007d801283983f16c2f105938dae92758aa0cf23" + } + ], + "quality": "See baseline15-repeatability-v2.json; media coverage PASS under model40Hz audio contract, exact decoded equality false, INCONCLUSIVE.", + "lifecycle": { + "status": "pass", + "container_exit": 0, + "server_exit": 0, + "forced_signals": 0, + "host_cleanup_intervention": false, + "expected_workers": 4, + "workers": [ + { + "name": "DiffusionWorker-0", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-1", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-2", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-3", + "exit_code": 0, + "alive": false + } + ] + }, + "service_log_sha256": "226387533cc675bc5e63b27c9f7513725f3a7242abc030a8b56454a25ca82b70" +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/baseline15-profile-integrity.json b/evidence/h3-ref2va-4x910b1-320/results/baseline15-profile-integrity.json new file mode 100644 index 000000000..e91d3df3c --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/baseline15-profile-integrity.json @@ -0,0 +1,12 @@ +{ + "results/baseline15-complete.json": "2637694184f2e31c780dc84d36e9a33cd0dacef0614842c71e178c21991a081d", + "results/baseline15-repeatability-v2.json": "865e4acf0fa5fe34f1d723aa428036d4427333add3569756162f9790c4728901", + "results/five-step-kernel-summary.json": "5087243d2625cd4053ef08f0fe6b7af6fa97452df11d7c648c8b1e3d100e73d5", + "validator-v2/contract-revision.json": "1540951d54bb9c0448aa4fb78ea8c8049837d2ae2ea04c3957272bd4ec333eb9", + "validator-v2/gates.json": "4fc26315d42731cf3af1b63e6a46563783f22e997f46bbc3c946fba6f630651f", + "validator-v2/compare.py": "bd14b3fb51941af9dfe8ce5a3818b745c281ae3ee872ef281d8d52932e2fcad0", + "validator-v2/integrity.py": "0b24bab056d4e8436fb71b6b3d8a6d8ff74006ca4f7757cf9439e83d866e6208", + "validator-v2/upstream_metrics.py": "d76f3c66300e4a396fedb92da7a24e436f6241102c65032eb1eb16593cdabf71", + "validator-v2/weights.json": "605e463a0b64244974f5475dead6b3bdc9cc4899930801e161cdf48d8c057171", + "validator-v2/README.md": "d9e411488ae84e46d6d78e0326d58a99198df8711ea09b1787747318d295d8bd" +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/baseline15-repeatability-v2.json b/evidence/h3-ref2va-4x910b1-320/results/baseline15-repeatability-v2.json new file mode 100644 index 000000000..cc03db019 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/baseline15-repeatability-v2.json @@ -0,0 +1,34 @@ +{ + "verdict": "INCONCLUSIVE", + "media_gate_verdict": "PASS", + "scope": "decoded media equality; unequal outputs require separate baseline-repeatability adjudication", + "exact_video": false, + "exact_audio": false, + "coverage": [ + { + "expected_duration_s": 15.075, + "decoded_audio_end_s": 15.104 + }, + { + "expected_duration_s": 15.075, + "decoded_audio_end_s": 15.104 + } + ], + "scorer_identity": { + "alexnet_sha256": "7be5be791159472b1fbf3c69796f7cb30dca7ad8466c2df70058c37116cdee02", + "lpips_sha256": "df73285e35b22355a2df87cdb6b70b343713b667eddbda73e1977e0c860835c0" + }, + "metrics": { + "ssim": 0.977829, + "psnr_db": 39.603183, + "lpips": 0.01916759709431404, + "audio_spectral_cosine": 0.999756266673406, + "audio_rms_ratio": 0.9999765196760143, + "audio_samples": 483328 + }, + "inputs": { + "baseline": "93c0b94392b6f8e75d8e788f007d801283983f16c2f105938dae92758aa0cf23", + "candidate": "99f24d2e633a3d6ccfa64ba0b97909790b54b572c6cdba6648b96baff1b8e210", + "gates": "4fc26315d42731cf3af1b63e6a46563783f22e997f46bbc3c946fba6f630651f" + } +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/five-step-kernel-summary.json b/evidence/h3-ref2va-4x910b1-320/results/five-step-kernel-summary.json new file mode 100644 index 000000000..33d5024c3 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/five-step-kernel-summary.json @@ -0,0 +1,197 @@ +{ + "scope": "Diagnostic kernel duration sums, potentially overlapping; not exclusive E2E contributions or speedups", + "ranks": { + "diffusion_rank0": { + "top_kernel_duration_s": [ + [ + "LaserAttention", + 47.962475040000044 + ], + [ + "MatMulV3", + 15.532082820000015 + ], + [ + "hcom_alltoall_", + 7.518506319999991 + ], + [ + "hcom_allGather_", + 6.1779494199999965 + ], + [ + "Conv3DV2", + 5.028369639999999 + ], + [ + "Transpose", + 2.9493260399999888 + ], + [ + "TransData", + 2.2346214399999926 + ], + [ + "FlashAttentionScore", + 1.4492670600000013 + ], + [ + "MirrorPad", + 1.4448942400000004 + ], + [ + "Slice", + 1.4134308599999976 + ] + ], + "laser_shapes": { + "\"1,56,7168,128;1,56,7168,128;1,56,7168,128;;;\"": 10, + "\"1,14,82944,128;1,14,82944,128;1,14,82944,128;;;\"": 250 + } + }, + "diffusion_rank1": { + "top_kernel_duration_s": [ + [ + "LaserAttention", + 47.82706016000002 + ], + [ + "MatMulV3", + 15.655371339999991 + ], + [ + "hcom_broadcast_", + 9.332622099999998 + ], + [ + "hcom_alltoall_", + 7.539902520000005 + ], + [ + "hcom_allGather_", + 6.863103599999987 + ], + [ + "Conv3DV2", + 5.0307500199999895 + ], + [ + "Transpose", + 2.9636924200000014 + ], + [ + "TransData", + 2.22240408 + ], + [ + "hcom_allReduce_", + 1.5697454800000001 + ], + [ + "FlashAttentionScore", + 1.4456763800000025 + ] + ], + "laser_shapes": { + "\"1,56,7168,128;1,56,7168,128;1,56,7168,128;;;\"": 10, + "\"1,14,82944,128;1,14,82944,128;1,14,82944,128;;;\"": 250 + } + }, + "diffusion_rank2": { + "top_kernel_duration_s": [ + [ + "LaserAttention", + 47.89467516000001 + ], + [ + "MatMulV3", + 15.703903280000032 + ], + [ + "hcom_broadcast_", + 9.323328980000003 + ], + [ + "hcom_alltoall_", + 7.418067779999994 + ], + [ + "hcom_allGather_", + 6.492386440000017 + ], + [ + "Conv3DV2", + 5.029164460000001 + ], + [ + "Transpose", + 2.9648966199999944 + ], + [ + "TransData", + 2.222301979999992 + ], + [ + "FlashAttentionScore", + 1.448972659999998 + ], + [ + "MirrorPad", + 1.4410472000000007 + ] + ], + "laser_shapes": { + "\"1,56,7168,128;1,56,7168,128;1,56,7168,128;;;\"": 10, + "\"1,14,82944,128;1,14,82944,128;1,14,82944,128;;;\"": 250 + } + }, + "diffusion_rank3": { + "top_kernel_duration_s": [ + [ + "LaserAttention", + 47.885785159999976 + ], + [ + "MatMulV3", + 15.498314460000008 + ], + [ + "hcom_broadcast_", + 9.350753800000007 + ], + [ + "hcom_alltoall_", + 7.627736639999994 + ], + [ + "hcom_allGather_", + 6.86583928 + ], + [ + "Conv3DV2", + 5.028883380000001 + ], + [ + "Transpose", + 2.965658380000016 + ], + [ + "TransData", + 2.219704939999996 + ], + [ + "FlashAttentionScore", + 1.446388499999997 + ], + [ + "MirrorPad", + 1.4437693399999996 + ] + ], + "laser_shapes": { + "\"1,56,7168,128;1,56,7168,128;1,56,7168,128;;;\"": 10, + "\"1,14,82944,128;1,14,82944,128;1,14,82944,128;;;\"": 250 + } + } + } +} diff --git a/evidence/h3-ref2va-4x910b1-320/validator-v2/README.md b/evidence/h3-ref2va-4x910b1-320/validator-v2/README.md new file mode 100644 index 000000000..3c63f1eaa --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/validator-v2/README.md @@ -0,0 +1,9 @@ +# Model-specific audio duration contract + +This version preserves the original failed coverage observation. The 15s baseline has 362 video frames at24FPS and a15.075s audio stream. The earlier validator assumed audio must reach362/24seconds and rejected it. + +At engine source `ce216014adb4c037dc15b3d49623e493ca3d3ac3`, `pipeline_minimax_h3.py` derives `expected_audio_t` from the aligned video duration using `MiniMaxH3ShapePlanner.audio_latent_t`; `time_request.py` implements `round(duration_seconds *40)`. Thus the expected audio duration is603/40=15.075seconds. This contract correction applies equally to baseline and candidates; it does not increase an arbitrary error tolerance. Timestamp continuity, full decoded sample coverage, finite output and bounded codec padding remain required. + +The implementation is adapted from InferRSI PR318 validator at `e59b39a3ced3a18585576bcea8bda325699dde5b`. `upstream_metrics.py` and scorer weight hashes are unchanged. Supply explicit AlexNet and LPIPS weight paths to `compare.py`; it authenticates their bytes and never downloads fallback weights. Model outputs and weights are external artifacts. + +The baseline pair passes coverage and perceptual gates but differs in decoded video and audio. Its verdict remains INCONCLUSIVE. A perceptual threshold pass does not alone establish losslessness. This is not independent review or candidate acceptance. diff --git a/evidence/h3-ref2va-4x910b1-320/validator-v2/compare.py b/evidence/h3-ref2va-4x910b1-320/validator-v2/compare.py new file mode 100644 index 000000000..8b6695761 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/validator-v2/compare.py @@ -0,0 +1,230 @@ +"""Frozen campaign media gate; CPU only, separate from latency measurement. + +SSIM/PSNR use the upstream accuracy helper's FFmpeg filter definitions. +LPIPS and audio metrics are frozen verbatim in upstream_metrics.py. +""" + +import argparse +import hashlib +import json +import math +import re +import subprocess +import tempfile +from pathlib import Path + +import numpy as np +from integrity import audio_coverage, check_pcm_samples, expected_audio_duration, load_scorer +from upstream_metrics import _audio_quality_metrics + + +def run(command): + return subprocess.run(command, check=True, capture_output=True, timeout=3600) + + +def probe(path, gates, frames): + result = json.loads( + run( + ["ffprobe", "-v", "error", "-count_frames", "-show_streams", "-of", "json", str(path)] + ).stdout + ) + streams = result["streams"] + video = [s for s in streams if s["codec_type"] == "video"] + audio = [s for s in streams if s["codec_type"] == "audio"] + if len(video) != 1 or len(audio) != 1: + raise ValueError("Exactly one video and audio stream required") + v, a = video[0], audio[0] + numerator, denominator = map(int, v["avg_frame_rate"].split("/")) + actual = ( + v["width"], + v["height"], + numerator / denominator, + int(v["nb_read_frames"]), + int(a["sample_rate"]), + a["channels"], + ) + expected = ( + gates["width"], + gates["height"], + gates["fps"], + frames, + gates["sample_rate"], + gates["channels"], + ) + if actual != expected: + raise ValueError(f"Media contract mismatch: {actual} != {expected}") + if abs(float(v["start_time"])) > 1 / gates["sample_rate"]: + raise ValueError("Video does not start at zero") + if abs(float(v["duration"]) - frames / gates["fps"]) > 1 / gates["sample_rate"]: + raise ValueError("Video timestamp duration differs from expected frame duration") + audio_start, audio_duration = float(a["start_time"]), float(a["duration"]) + if not math.isfinite(audio_start) or not math.isfinite(audio_duration): + raise ValueError("Invalid audio stream timestamps") + if abs(audio_start) > 1 / gates["sample_rate"]: + raise ValueError("Audio stream does not start at zero") + expected_duration = expected_audio_duration(gates, frames) + if audio_duration < expected_duration - 1 / gates["sample_rate"]: + raise ValueError("Audio stream ends before the expected video duration") + max_duration = expected_duration + gates["max_audio_padding_samples"] / gates["sample_rate"] + if audio_duration > max_duration: + raise ValueError("Audio stream exceeds the allowed codec padding") + return audio_coverage(path, gates, frames) + + +def compare(baseline, candidate, gates, frames, alexnet_path, lpips_path, weights): + coverage = [probe(path, gates, frames) for path in (baseline, candidate)] + loss_fn, scorer_identity = load_scorer(alexnet_path, lpips_path, weights) + metrics = {} + for name, pattern in [ + ("ssim", r"All:([0-9.eE+-]+)"), + ("psnr_db", r"average:([0-9.eE+-]+|inf)"), + ]: + filter_name = "ssim" if name == "ssim" else "psnr" + output = run( + [ + "ffmpeg", + "-nostdin", + "-hide_banner", + "-i", + str(baseline), + "-i", + str(candidate), + "-lavfi", + f"[0:v][1:v]{filter_name}", + "-f", + "null", + "-", + ] + ).stderr.decode() + found = re.findall(pattern, output) + if not found: + raise ValueError(f"Missing {name} metric") + metrics[name] = float(found[-1]) + with tempfile.TemporaryDirectory() as directory: + videos, audios = [], [] + for index, path in enumerate((baseline, candidate)): + raw = Path(directory) / f"{index}.rgb" + run( + [ + "ffmpeg", + "-nostdin", + "-v", + "error", + "-i", + str(path), + "-map", + "0:v:0", + "-f", + "rawvideo", + "-pix_fmt", + "rgb24", + str(raw), + ] + ) + video = np.memmap(raw, dtype=np.uint8, mode="r") + shape = (frames, gates["height"], gates["width"], 3) + if video.size != math.prod(shape): + raise ValueError("Decoded video length mismatch") + videos.append(video.reshape(shape)) + pcm = run( + [ + "ffmpeg", + "-nostdin", + "-v", + "error", + "-i", + str(path), + "-map", + "0:a:0", + "-f", + "f32le", + "-acodec", + "pcm_f32le", + "-", + ] + ).stdout + audio = np.frombuffer(pcm, dtype="= gates["min_ssim"] + and metrics["psnr_db"] >= gates["min_psnr_db"] + and metrics["lpips"] <= gates["max_lpips"] + and metrics["audio_spectral_cosine"] >= gates["min_audio_spectral_cosine"] + and gates["min_audio_rms_ratio"] + <= metrics["audio_rms_ratio"] + <= gates["max_audio_rms_ratio"] + ) + if math.isinf(metrics["psnr_db"]): + metrics["psnr_db"] = "inf" + return { + "verdict": "FAIL" + if not passed + else ("PASS" if exact_video and exact_audio else "INCONCLUSIVE"), + "media_gate_verdict": "PASS" if passed else "FAIL", + "scope": ( + "decoded media equality; unequal outputs require " + "separate baseline-repeatability adjudication" + ), + "exact_video": exact_video, + "exact_audio": exact_audio, + "coverage": coverage, + "scorer_identity": scorer_identity, + "metrics": metrics, + } + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--baseline", type=Path, required=True) + parser.add_argument("--candidate", type=Path, required=True) + parser.add_argument("--frames", type=int, required=True) + parser.add_argument("--output", type=Path, required=True) + parser.add_argument("--alexnet-weights", type=Path, required=True) + parser.add_argument("--lpips-weights", type=Path, required=True) + args = parser.parse_args() + gates_path = Path(__file__).with_name("gates.json") + gates = json.loads(gates_path.read_text()) + weights = json.loads(Path(__file__).with_name("weights.json").read_text()) + result = compare( + args.baseline, + args.candidate, + gates, + args.frames, + args.alexnet_weights, + args.lpips_weights, + weights, + ) + result["inputs"] = { + name: hashlib.sha256(path.read_bytes()).hexdigest() + for name, path in [ + ("baseline", args.baseline), + ("candidate", args.candidate), + ("gates", gates_path), + ] + } + args.output.write_text(json.dumps(result, indent=2, allow_nan=False) + "\n") + raise SystemExit({"PASS": 0, "FAIL": 1, "INCONCLUSIVE": 2}[result["verdict"]]) diff --git a/evidence/h3-ref2va-4x910b1-320/validator-v2/contract-revision.json b/evidence/h3-ref2va-4x910b1-320/validator-v2/contract-revision.json new file mode 100644 index 000000000..873328fde --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/validator-v2/contract-revision.json @@ -0,0 +1,11 @@ +{ + "reason": "Correct model-specific audio duration contract; not a tolerance expansion", + "source_revision": "ce216014adb4c037dc15b3d49623e493ca3d3ac3", + "source_paths": [ + "vllm_omni/diffusion/models/minimax_h3/time_request.py:_audio_latent_t", + "vllm_omni/diffusion/models/minimax_h3/pipeline_minimax_h3.py:expected_audio_t" + ], + "formula": "round((video_frames / fps) * 40) / 40", + "old_failure_retained": "quality/baseline15-w0-m0/scorer.log", + "limits": "Coverage follows exact model audio duration; perceptual metric gates and exact-output adjudication unchanged. No lossless acceptance based on metadata alone." +} diff --git a/evidence/h3-ref2va-4x910b1-320/validator-v2/gates.json b/evidence/h3-ref2va-4x910b1-320/validator-v2/gates.json new file mode 100644 index 000000000..2ae7b3490 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/validator-v2/gates.json @@ -0,0 +1,15 @@ +{ + "width": 1344, + "height": 768, + "fps": 24, + "sample_rate": 32000, + "channels": 2, + "max_audio_padding_samples": 2048, + "min_ssim": 0.97, + "min_psnr_db": 34.0, + "max_lpips": 0.2, + "min_audio_spectral_cosine": 0.8, + "min_audio_rms_ratio": 0.5, + "max_audio_rms_ratio": 2.0, + "audio_latent_rate_hz": 40 +} diff --git a/evidence/h3-ref2va-4x910b1-320/validator-v2/integrity.py b/evidence/h3-ref2va-4x910b1-320/validator-v2/integrity.py new file mode 100644 index 000000000..81cd52c47 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/validator-v2/integrity.py @@ -0,0 +1,106 @@ +"""Coverage and explicit scorer loading for the lossless H3 follow-up. + +The historical campaign validator remains frozen. This version never downloads +weights and authenticates the same in-memory bytes that torch.load consumes. +""" + +import hashlib +import io +import json +import math +import subprocess +from pathlib import Path + + +def checked_bytes(path, expected): + data = Path(path).read_bytes() + actual = hashlib.sha256(data).hexdigest() + if actual != expected: + raise ValueError(f"Scorer weight hash mismatch: {actual} != {expected}") + return data + + +def load_scorer(alexnet_path, lpips_path, weights): + # Authenticate before imports/model construction; no download fallback. + trunk = checked_bytes(alexnet_path, weights["alexnet_sha256"]) + linear = checked_bytes(lpips_path, weights["lpips_sha256"]) + import lpips + import torch + + scorer = lpips.LPIPS(net="alex", pnet_rand=True, pretrained=False, verbose=False) + trunk_state = torch.load(io.BytesIO(trunk), map_location="cpu", weights_only=True) + features = {} + for name in scorer.net.state_dict(): + _, index, parameter = name.split(".") + features[name] = trunk_state[f"features.{index}.{parameter}"] + scorer.net.load_state_dict(features, strict=True) + linear_state = torch.load(io.BytesIO(linear), map_location="cpu", weights_only=True) + expected = {f"lin{index}.model.1.weight" for index in range(5)} + if set(linear_state) != expected: + raise ValueError("Unexpected LPIPS calibration keys") + for index in range(5): + getattr(scorer, f"lin{index}").load_state_dict( + {"model.1.weight": linear_state[f"lin{index}.model.1.weight"]}, strict=True + ) + scorer.eval() + return scorer, dict(weights) + + +def check_timeline(frames, expected_duration, rate, padding_samples): + """Reject missing heads/tails, gaps, overlaps, and non-finite timestamps.""" + tolerance = 1.1 / rate # one sample plus decimal timestamp serialization + padding = padding_samples / rate + end = 0.0 + for frame in frames: + start = float(frame["best_effort_timestamp_time"]) + duration = int(frame["nb_samples"]) / rate + if not math.isfinite(start) or duration <= 0: + raise ValueError("Invalid decoded audio timestamp/duration") + if abs(start - end) > tolerance: + raise ValueError("Audio has a missing head, timestamp gap, or overlap") + end = start + duration + if not frames or end < expected_duration - tolerance or end > expected_duration + padding: + raise ValueError("Audio does not cover the expected video duration") + return end + + +def expected_audio_duration(gates, frames): + duration = frames / gates["fps"] + rate = gates.get("audio_latent_rate_hz") + return duration if rate is None else round(duration * rate) / rate + + +def audio_coverage(path, gates, frames): + duration = expected_audio_duration(gates, frames) + probe = subprocess.run( + [ + "ffprobe", + "-v", + "error", + "-select_streams", + "a:0", + "-show_frames", + "-show_entries", + "frame=best_effort_timestamp_time,nb_samples", + "-of", + "json", + str(path), + ], + check=True, + capture_output=True, + timeout=3600, + ) + audio_frames = json.loads(probe.stdout)["frames"] + end = check_timeline( + audio_frames, duration, gates["sample_rate"], gates["max_audio_padding_samples"] + ) + return {"expected_duration_s": duration, "decoded_audio_end_s": end} + + +def check_pcm_samples(samples, gates, frames): + expected = expected_audio_duration(gates, frames) * gates["sample_rate"] + if ( + samples < math.floor(expected) + or samples > math.ceil(expected) + gates["max_audio_padding_samples"] + ): + raise ValueError("Decoded PCM does not cover the expected video duration") diff --git a/evidence/h3-ref2va-4x910b1-320/validator-v2/upstream_metrics.py b/evidence/h3-ref2va-4x910b1-320/validator-v2/upstream_metrics.py new file mode 100644 index 000000000..96d718b94 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/validator-v2/upstream_metrics.py @@ -0,0 +1,100 @@ +# SPDX-License-Identifier: Apache-2.0 +# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project + +# Frozen metric functions from vLLM-Omni c7f56f0155953c7d4a77276a2f4fcbd844ab0da2. +# Retained verbatim; campaign runner must enforce equal stream lengths first. +import numpy as np +import torch + + +def _canonical_audio(audio: object) -> np.ndarray: + """Return H3 audio as float32 [channels, samples].""" + array = np.asarray(audio, dtype=np.float32) + while array.ndim > 2 and array.shape[0] == 1: + array = array[0] + if array.ndim == 1: + array = array[None, :] + if array.ndim != 2: + raise ValueError(f"Expected mono/stereo audio, got shape {array.shape}") + if array.shape[0] > array.shape[1] and array.shape[1] <= 8: + array = array.T + if not 1 <= array.shape[0] <= 8: + raise ValueError(f"Expected channel-first audio, got shape {array.shape}") + if not np.isfinite(array).all(): + raise ValueError("Audio contains non-finite samples") + return np.ascontiguousarray(array) + +def _audio_quality_metrics(baseline: object, quantized: object) -> tuple[float, float]: + """Compare phase-tolerant spectral structure and overall signal energy.""" + baseline_array = _canonical_audio(baseline) + quantized_array = _canonical_audio(quantized) + if baseline_array.shape != quantized_array.shape: + raise ValueError( + "Audio shapes do not match for metric computation: " + f"baseline={baseline_array.shape}, quantized={quantized_array.shape}" + ) + + baseline_tensor = torch.from_numpy(baseline_array) + quantized_tensor = torch.from_numpy(quantized_array) + similarities: list[float] = [] + for n_fft in (512, 1024, 2048): + window = torch.hann_window(n_fft) + baseline_magnitude = torch.stft( + baseline_tensor, + n_fft=n_fft, + hop_length=n_fft // 4, + window=window, + return_complex=True, + ).abs() + quantized_magnitude = torch.stft( + quantized_tensor, + n_fft=n_fft, + hop_length=n_fft // 4, + window=window, + return_complex=True, + ).abs() + cosine = torch.nn.functional.cosine_similarity( + baseline_magnitude.flatten(1), + quantized_magnitude.flatten(1), + dim=1, + eps=1e-12, + ) + similarities.extend(float(value) for value in cosine) + + baseline_rms = float(torch.sqrt(torch.mean(baseline_tensor.square()))) + quantized_rms = float(torch.sqrt(torch.mean(quantized_tensor.square()))) + rms_ratio = quantized_rms / max(baseline_rms, 1e-12) + return float(np.mean(similarities)), rms_ratio + +def compute_lpips_video( + baseline_frames: np.ndarray, + quantized_frames: np.ndarray, + net: str = "alex", +) -> float: + """Compute mean per-frame LPIPS for a video pair. + + Args: + baseline_frames: (F, H, W, C) float array in [0, 1]. + quantized_frames: same shape. + + Returns: + Mean LPIPS across all frames. + """ + import lpips + + loss_fn = lpips.LPIPS(net=net).eval() + if torch.cuda.is_available(): + loss_fn = loss_fn.cuda() + + num_frames = min(len(baseline_frames), len(quantized_frames)) + scores = [] + for i in range(num_frames): + # Convert (H, W, C) float [0,1] -> (1, C, H, W) float [-1, 1] + f_bl = torch.from_numpy(baseline_frames[i]).permute(2, 0, 1).unsqueeze(0).float() * 2 - 1 + f_qt = torch.from_numpy(quantized_frames[i]).permute(2, 0, 1).unsqueeze(0).float() * 2 - 1 + if torch.cuda.is_available(): + f_bl, f_qt = f_bl.cuda(), f_qt.cuda() + with torch.no_grad(): + score = loss_fn(f_bl, f_qt).item() + scores.append(score) + return float(np.mean(scores)) diff --git a/evidence/h3-ref2va-4x910b1-320/validator-v2/weights.json b/evidence/h3-ref2va-4x910b1-320/validator-v2/weights.json new file mode 100644 index 000000000..977764e83 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/validator-v2/weights.json @@ -0,0 +1,4 @@ +{ + "alexnet_sha256": "7be5be791159472b1fbf3c69796f7cb30dca7ad8466c2df70058c37116cdee02", + "lpips_sha256": "df73285e35b22355a2df87cdb6b70b343713b667eddbda73e1977e0c860835c0" +} diff --git a/tests/test_evidence_inventory.py b/tests/test_evidence_inventory.py index 60f2a8096..8cf590306 100644 --- a/tests/test_evidence_inventory.py +++ b/tests/test_evidence_inventory.py @@ -146,5 +146,5 @@ def test_checked_in_inventory(): result = validate_inventory(repo) assert result["errors"] == [] assert len(result["bundles"]) == 21 - assert result["checked_hashes"] == 440 + assert result["checked_hashes"] == 450 assert result["unavailable"] # Historical raw artifacts are not in this checkout. diff --git a/tools/evidence_inventory.json b/tools/evidence_inventory.json index 898acbc2e..044204385 100644 --- a/tools/evidence_inventory.json +++ b/tools/evidence_inventory.json @@ -23,6 +23,10 @@ { "path": "plan/acceptance-30pct-integrity.json", "schema": "bundle-sha256" + }, + { + "path": "results/baseline15-profile-integrity.json", + "schema": "bundle-sha256" } ], "external": [ From 15f291f1d0800c205547e8d723bcb6f714755686 Mon Sep 17 00:00:00 2001 From: amy-why-3459 Date: Tue, 3 Nov 2026 14:08:41 +0800 Subject: [PATCH 07/17] Preserve negative dense-kernel and QKV screening results Agent-assisted-by: Codex (implementation) Signed-off-by: amy-why-3459 --- .../rejected-candidates-integrity.json | 3 + .../results/rejected-kernel-and-qkv.json | 62 +++++++++++++++++++ tests/test_evidence_inventory.py | 2 +- tools/evidence_inventory.json | 4 ++ 4 files changed, 70 insertions(+), 1 deletion(-) create mode 100644 evidence/h3-ref2va-4x910b1-320/results/rejected-candidates-integrity.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/rejected-kernel-and-qkv.json diff --git a/evidence/h3-ref2va-4x910b1-320/results/rejected-candidates-integrity.json b/evidence/h3-ref2va-4x910b1-320/results/rejected-candidates-integrity.json new file mode 100644 index 000000000..3cf73f8b5 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/rejected-candidates-integrity.json @@ -0,0 +1,3 @@ +{ + "results/rejected-kernel-and-qkv.json": "b9ac42cbdb2a3b585dafe2de446457069ba3521d41e64915d4acf1f32d3bb76c" +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/rejected-kernel-and-qkv.json b/evidence/h3-ref2va-4x910b1-320/results/rejected-kernel-and-qkv.json new file mode 100644 index 000000000..bb7d93784 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/rejected-kernel-and-qkv.json @@ -0,0 +1,62 @@ +{ + "dense_alternate": { + "status": "rejected_slower", + "scope": "Actual-shape synthetic NPU probe only", + "rows": [ + { + "shape": [ + 1, + 56, + 7168, + 128 + ], + "median_ms": { + "ascend_laser_attention": 7.310947403311729, + "fused_attn_score": 8.836026303470135 + }, + "exact": false, + "rmse": 5.222966137807816e-05 + }, + { + "shape": [ + 1, + 14, + 82944, + 128 + ], + "median_ms": { + "ascend_laser_attention": 201.81505428627133, + "fused_attn_score": 311.7461372166872 + }, + "exact": false, + "rmse": 1.554289337946102e-05 + } + ], + "source": "MindIE SD3.1.0 manual attention_forward dispatch; same captured shapes; synthetic BF16 input; not model quality evidence" + }, + "combined_qkv": { + "status": "rejected_slower", + "scope": "Actual-shape synthetic4rank HCCL probe only", + "exact": { + "separate": true, + "combined_views": true, + "combined_contiguous": true + }, + "median_ms": { + "separate": 17.243896484375, + "combined_views": 18.782387733459473, + "combined_contiguous": 20.29022216796875 + }, + "source": "https://github.com/vllm-project/vllm-omni/pull/4150", + "candidate_revision": "379b772b212f08f02433884f80c59306c67af610" + }, + "final_30pct_target": "not achieved", + "raw_result_sha256": { + "attention-probe/result.json": "81c2227e198d381d98b71a480336d1c90aae32da0df91dfff4e1b5c46e785ab3", + "qkv-probe/result.json": "1c915189626368d7b7b501d1b756208234cae4da014f26baaaa3a9f7077cec72" + }, + "execution_failures_retained": [ + "First attention probe could not initialize NPU in restricted container; rerun used baseline-proven container access.", + "First QKV probe failed hostname resolution with isolated network; own unstarted computation container stopped and host-network retry completed." + ] +} diff --git a/tests/test_evidence_inventory.py b/tests/test_evidence_inventory.py index 8cf590306..b3c3fa2b1 100644 --- a/tests/test_evidence_inventory.py +++ b/tests/test_evidence_inventory.py @@ -146,5 +146,5 @@ def test_checked_in_inventory(): result = validate_inventory(repo) assert result["errors"] == [] assert len(result["bundles"]) == 21 - assert result["checked_hashes"] == 450 + assert result["checked_hashes"] == 451 assert result["unavailable"] # Historical raw artifacts are not in this checkout. diff --git a/tools/evidence_inventory.json b/tools/evidence_inventory.json index 044204385..7a162341c 100644 --- a/tools/evidence_inventory.json +++ b/tools/evidence_inventory.json @@ -27,6 +27,10 @@ { "path": "results/baseline15-profile-integrity.json", "schema": "bundle-sha256" + }, + { + "path": "results/rejected-candidates-integrity.json", + "schema": "bundle-sha256" } ], "external": [ From 37e4ad57c36d24ced591acd6344efc6cb96ef91a Mon Sep 17 00:00:00 2001 From: amy-why-3459 Date: Tue, 3 Nov 2026 14:37:59 +0800 Subject: [PATCH 08/17] Record rejected H3 residency and prompt attention screens Preserve incomplete ABBA and numerical quality limitations; no qualified speedup. Agent-assisted-by: Codex (implementation) Signed-off-by: amy-why-3459 --- .../rejected-residency-and-prompt.json | 138 ++++++++++++++++++ .../results/rejected-residency-integrity.json | 3 + tests/test_evidence_inventory.py | 2 +- tools/evidence_inventory.json | 4 + 4 files changed, 146 insertions(+), 1 deletion(-) create mode 100644 evidence/h3-ref2va-4x910b1-320/results/rejected-residency-and-prompt.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/rejected-residency-integrity.json diff --git a/evidence/h3-ref2va-4x910b1-320/results/rejected-residency-and-prompt.json b/evidence/h3-ref2va-4x910b1-320/results/rejected-residency-and-prompt.json new file mode 100644 index 000000000..8b2f713e0 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/rejected-residency-and-prompt.json @@ -0,0 +1,138 @@ +{ + "status": "rejected_candidates_no_qualified_gain", + "target_achieved": false, + "resident24": { + "source": "ce216014adb4c037dc15b3d49623e493ca3d3ac3", + "sources": [ + "https://github.com/vllm-project/vllm-omni/pull/5764", + "https://github.com/vllm-project/vllm-omni/pull/5929" + ], + "variable": "AllGather DiT streaming versus rank-local24resident blocks; text encoder rank-local in both", + "scope": "5steps5s, one warmup and one measured per arm, same four910B1 devices; early rejected, incomplete planned ABBA", + "baseline_ms": [ + 173210.57523414493 + ], + "candidate_ms": [ + 365883.9429579675 + ], + "baseline_lifecycle": { + "status": "pass", + "container_exit": 0, + "server_exit": 0, + "forced_signals": 0, + "host_cleanup_intervention": false, + "expected_workers": 4, + "workers": [ + { + "name": "DiffusionWorker-0", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-1", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-2", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-3", + "exit_code": 0, + "alive": false + } + ] + }, + "candidate_lifecycle": { + "status": "pass", + "container_exit": 0, + "server_exit": 0, + "forced_signals": 0, + "host_cleanup_intervention": false, + "expected_workers": 4, + "workers": [ + { + "name": "DiffusionWorker-0", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-1", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-2", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-3", + "exit_code": 0, + "alive": false + } + ] + }, + "media_gate_verdict": "PASS", + "quality_verdict": "INCONCLUSIVE", + "quality_metrics": { + "ssim": 0.985081, + "psnr_db": 45.843622, + "lpips": 0.01714623005940549, + "audio_spectral_cosine": 0.9987955391407013, + "audio_rms_ratio": 1.0013017132976463, + "audio_samples": 165888 + }, + "reason": "More than2x slower in first measured pair. Final50step5s15s validation not promoted." + }, + "prompt_attention": { + "source": "Installed MindIE SD3.1.0 prompt_flash_attn full-window npu_prompt_flash_attention", + "scope": "Synthetic tensors at captured5s model kernel shapes; not E2E or losslessness acceptance", + "rows": [ + { + "shape": [ + 1, + 56, + 7168, + 128 + ], + "median_ms": { + "ascend_laser_attention": 7.2264596819877625, + "prompt_flash_attn": 11.593843344599009 + }, + "exact": false, + "rmse": 5.215294731897302e-05, + "finite": true + }, + { + "shape": [ + 1, + 14, + 82944, + 128 + ], + "median_ms": { + "ascend_laser_attention": 201.82542828842998, + "prompt_flash_attn": 325.69412514567375 + }, + "exact": false, + "rmse": 1.5541883840342052e-05, + "finite": true + } + ], + "exit_code": 0, + "reason": "Slower on both actual-shape synthetic inputs; numerical outputs differ." + }, + "raw_artifact_hashes": { + "resident-screen/plan.json": "935fcddadf65059f5fd0a81dcd07a0d8a1aaeb409fd7d06461c759df34cc64f6", + "resident-screen/early-rejection.json": "9c808edd1c60339650a7734bc11c02cdb5c4138469e82ab7a9e81137f6f31a9a", + "post-resident-screen/base0.json": "08e107e1c8d93f422aa8d2a98040b7ac26229e45ab7819725d253598aeef73ad", + "post-resident-screen/resident24a.json": "fb11c1ea3f8d17f1eecd784a75bb4aa62d49a08fab567948207971cc4315fdd1", + "quality/resident24-early-rejected/result.json": "e50018e7607aebabd701ac71005b19f441971f7cebcad194f24daf9ce3115889", + "prompt-kernel-probe/result.json": "8baa793c5adede6bfbe61fa7fd039217e68a1b0c70b605f74a178c94437958d1", + "prompt-kernel-probe/probe.py": "836e9f93fccd5adf8210ef1e7793a54722141aaa61eff7c83bf5dafa59301a61", + "prompt-kernel-probe/launch-after-rejection.log": "83c5507470dcc23a28aabf51f6deb9eb8fe4382be189c6ee4c6a177820a93f91" + } +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/rejected-residency-integrity.json b/evidence/h3-ref2va-4x910b1-320/results/rejected-residency-integrity.json new file mode 100644 index 000000000..81cb0017d --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/rejected-residency-integrity.json @@ -0,0 +1,3 @@ +{ + "results/rejected-residency-and-prompt.json": "fcb660c95e5fe38ac149a2ec6bf6277e969299bcaff62781ac1b0ec3d2cbd1c3" +} diff --git a/tests/test_evidence_inventory.py b/tests/test_evidence_inventory.py index b3c3fa2b1..647eeb229 100644 --- a/tests/test_evidence_inventory.py +++ b/tests/test_evidence_inventory.py @@ -146,5 +146,5 @@ def test_checked_in_inventory(): result = validate_inventory(repo) assert result["errors"] == [] assert len(result["bundles"]) == 21 - assert result["checked_hashes"] == 451 + assert result["checked_hashes"] == 452 assert result["unavailable"] # Historical raw artifacts are not in this checkout. diff --git a/tools/evidence_inventory.json b/tools/evidence_inventory.json index 7a162341c..b8d4d6c71 100644 --- a/tools/evidence_inventory.json +++ b/tools/evidence_inventory.json @@ -31,6 +31,10 @@ { "path": "results/rejected-candidates-integrity.json", "schema": "bundle-sha256" + }, + { + "path": "results/rejected-residency-integrity.json", + "schema": "bundle-sha256" } ], "external": [ From 552b5db68b674d90f4bb3fc01b341ab7a4e98dc6 Mon Sep 17 00:00:00 2001 From: amy-why-3459 Date: Tue, 3 Nov 2026 15:05:45 +0800 Subject: [PATCH 09/17] Record interrupted pinned-host screen and TP4 follow-up No candidate request completed; distinguish manual interruption from measured rejection. Agent-assisted-by: Codex (implementation) Signed-off-by: amy-why-3459 --- .../pinned-interruption-and-tp4-plan.json | 57 +++++++++++++++++++ .../pinned-interruption-integrity.json | 3 + tests/test_evidence_inventory.py | 2 +- tools/evidence_inventory.json | 4 ++ 4 files changed, 65 insertions(+), 1 deletion(-) create mode 100644 evidence/h3-ref2va-4x910b1-320/results/pinned-interruption-and-tp4-plan.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/pinned-interruption-integrity.json diff --git a/evidence/h3-ref2va-4x910b1-320/results/pinned-interruption-and-tp4-plan.json b/evidence/h3-ref2va-4x910b1-320/results/pinned-interruption-and-tp4-plan.json new file mode 100644 index 000000000..f0007319a --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/pinned-interruption-and-tp4-plan.json @@ -0,0 +1,57 @@ +{ + "scope": "Interrupted diagnostic and next configuration plan; no qualified lossless gain", + "target_achieved": false, + "pinned_diagnostic": { + "baseline_source": "ce216014adb4c037dc15b3d49623e493ca3d3ac3", + "experimental_source": "10551bba495e5e2c2d9d1889134c75ba93a8916f", + "source_publication": "Local isolated diagnostic commit; not promoted to enginePR", + "change": "DiffusersPipelineLoader constructor sets existing _force_canonical_load=True to exercise canonical loader and pinned host masters; not a production default proposal", + "configuration": "SP4, originalLaser, rank-local24resident DiT blocks", + "baseline_ms": 174885.30493341386, + "baseline_lifecycle": "pass", + "candidate_completed_requests": 0, + "candidate_performance": "not_measured", + "quality": "not_scored_missing_output", + "cpu_tests": "5 pinned resident-group tests passed", + "startup_observation": "Three ranks ready while rank0 spent multiple minutes in torch.zeros(pin_memory=True), native stack aclrtMallocHost/halMemAlloc/ioctl. Root cause unknown.", + "manual_stop_correction": "Rank0 subsequently completed initialization and warmup started while the stop decision was being executed. This is an interrupted screening, not proof of permanent deadlock or initialization failure.", + "exit_code": 137, + "cleanup": "Docker initially reported missing exit event; later container and workerPIDs disappeared and reservation released before nextexperiment.", + "verdict": "INCONCLUSIVE; neither accepted nor rejected on performance" + }, + "next_tp4_plan": { + "scope": "5step5s adaptiveABBA screening only; full50step5s15s acceptance still required", + "source": "ce216014adb4c037dc15b3d49623e493ca3d3ac3", + "sources": [ + "https://github.com/vllm-project/vllm-omni/pull/5691" + ], + "control": "SP4 TP1 AllGather DiT streaming and layer encoder offload", + "candidate": "TP4 SP1 device-resident DiT and module-only text encoder offload", + "hypothesis": "Shard DiT weights across4devices to avoid repeated denoise weight streaming", + "numerical_caveat": "Dense BF16 weights and steps preserved, but TP floating-point reductions differ; no losslessness assumed", + "precision": "BF16 noquant/cache/sparse/referenceKVreuse", + "sequence": [ + "base0", + "tp4a", + "tp4b", + "base1" + ], + "adaptive_rejection": "After first candidate reject if measured E2E exceeds control by20percent or request/lifecycle fails; incompleteABBA recorded", + "warmups_per_server": 1, + "measured_per_server": 1, + "timing": "Run only after pinned-screen timing and CPUquality terminal receipt; allTPscreenarms inone4cardreservation", + "estimated_dit_weights_per_rank_gib": 16, + "estimate_limitation": "Does not include activations, othermodelcomponents, allocator reserve; actualHBM required" + }, + "raw_hashes": { + "pinned-screen/plan.json": "ff803f5655192d1484ebea016950517420607f507346264bdf6324ce3e034cc0", + "pinned-screen/startup-abort.json": "a6782b2125ea35002f5470783f4dd6b8d4e49453685ab921b0830ef9d9fd0343", + "pinned-screen/startup-rank0-stack.txt": "4ac73dabe3b9157fd2216766d94465b661dffabb5c39af558e35a0329966b364", + "pinned-screen/startup-rank0-native-stack.txt": "19fc0d519665e4c5df32d4968c0f54c0fe26e6756a90675deaa06061345fdeba", + "pinned-screen/startup-abort-stop.log": "4d965d8a7e1bbdb46bf1f7d4ad73e6287becf0fd4394b2c0e53ca853e802d2fc", + "pinned-screen/quality-summary.json": "916558d2d4ae8056abbea2b84d39876015e5e921981093398258aafc13d9b163", + "pinned-screen/job.exit_code": "e3b9c2844b5a5c2677b3a2279db2ec8487491dd9a23d6b22fac153391b3bb63c", + "pinned-cpu-check-v2.log": "b378dbe39f615ff4e462381d4700b7ae8ea05452f3eee4c13047eea33ee4cc79", + "tp4-screen/manifest.json": "fe97722e9b85bef71ab233b2f0dd858330db8769a2ec9dee28f344190f398e27" + } +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/pinned-interruption-integrity.json b/evidence/h3-ref2va-4x910b1-320/results/pinned-interruption-integrity.json new file mode 100644 index 000000000..ca702c59c --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/pinned-interruption-integrity.json @@ -0,0 +1,3 @@ +{ + "results/pinned-interruption-and-tp4-plan.json": "de1e33b56e5f22f440e8d0e2a433d1fef32e7c00f8f8206a2925b43fa19be822" +} diff --git a/tests/test_evidence_inventory.py b/tests/test_evidence_inventory.py index 647eeb229..4cbf7b3ef 100644 --- a/tests/test_evidence_inventory.py +++ b/tests/test_evidence_inventory.py @@ -146,5 +146,5 @@ def test_checked_in_inventory(): result = validate_inventory(repo) assert result["errors"] == [] assert len(result["bundles"]) == 21 - assert result["checked_hashes"] == 452 + assert result["checked_hashes"] == 453 assert result["unavailable"] # Historical raw artifacts are not in this checkout. diff --git a/tools/evidence_inventory.json b/tools/evidence_inventory.json index b8d4d6c71..666975d1c 100644 --- a/tools/evidence_inventory.json +++ b/tools/evidence_inventory.json @@ -35,6 +35,10 @@ { "path": "results/rejected-residency-integrity.json", "schema": "bundle-sha256" + }, + { + "path": "results/pinned-interruption-integrity.json", + "schema": "bundle-sha256" } ], "external": [ From c189b2f7f2fcb71a94b529423daed351c27e86a8 Mon Sep 17 00:00:00 2001 From: amy-why-3459 Date: Tue, 3 Nov 2026 15:37:40 +0800 Subject: [PATCH 10/17] Preserve H3 TP4 placement regression and operator screening Include CPU-validated candidate patch, failed NPU request, raw microbenchmark samples, and explicit pending model validation. Agent-assisted-by: Codex (implementation) Signed-off-by: amy-why-3459 --- .../patch/tp4-denoise-placement.patch | 96 ++++++++++++++ .../results/head-layout-probe.json | 119 +++++++++++++++++ .../precision-matched-attention-probe.json | 120 ++++++++++++++++++ .../tp4-placement-failure-and-fix.json | 75 +++++++++++ .../results/tp4-placement-integrity.json | 6 + tests/test_evidence_inventory.py | 2 +- tools/evidence_inventory.json | 4 + 7 files changed, 421 insertions(+), 1 deletion(-) create mode 100644 evidence/h3-ref2va-4x910b1-320/patch/tp4-denoise-placement.patch create mode 100644 evidence/h3-ref2va-4x910b1-320/results/head-layout-probe.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/precision-matched-attention-probe.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/tp4-placement-failure-and-fix.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/tp4-placement-integrity.json diff --git a/evidence/h3-ref2va-4x910b1-320/patch/tp4-denoise-placement.patch b/evidence/h3-ref2va-4x910b1-320/patch/tp4-denoise-placement.patch new file mode 100644 index 000000000..e84a6f0cf --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/patch/tp4-denoise-placement.patch @@ -0,0 +1,96 @@ +diff --git a/docs/design/feature/offloader/module_offload.md b/docs/design/feature/offloader/module_offload.md +index 43ef49194..3b73dcffd 100644 +--- a/docs/design/feature/offloader/module_offload.md ++++ b/docs/design/feature/offloader/module_offload.md +@@ -46,6 +46,11 @@ contract: + setup; and + - disabling removes all model-local offload hooks or contexts. + ++Preparation that reads component buffers before its first `forward` must also ++enter the component's residency context. MiniMax-H3 enters that context before ++denoise-time RoPE table preparation. On context exit, explicit selection still ++controls offloading: an unselected DiT remains device resident. ++ + The delegation is currently duck typed. If another independent implementation + is added, formalize the enable/disable pair as a protocol rather than expanding + attribute-name heuristics. +diff --git a/tests/diffusion/models/minimax_h3/test_ref2va_initial_noise_preparation.py b/tests/diffusion/models/minimax_h3/test_ref2va_initial_noise_preparation.py +index a2f2bc517..1579b690f 100644 +--- a/tests/diffusion/models/minimax_h3/test_ref2va_initial_noise_preparation.py ++++ b/tests/diffusion/models/minimax_h3/test_ref2va_initial_noise_preparation.py +@@ -3,7 +3,9 @@ + + import weakref + from concurrent.futures import ThreadPoolExecutor ++from contextlib import nullcontext + from threading import Event ++from types import SimpleNamespace + + import pytest + import torch +@@ -138,6 +140,45 @@ def test_consumed_host_noise_is_released_before_denoising(pipeline, monkeypatch) + ) + + ++def test_module_offload_places_dit_before_denoise_preparation(pipeline, monkeypatch): ++ from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as module ++ from vllm_omni.diffusion.offloader import apply_sequential_offload, sequential_backend ++ ++ # A real CPU-to-meta move exposes preparation before the first forward ++ # without requiring an accelerator or a model checkpoint. ++ transformer = torch.nn.Module() ++ transformer.register_buffer("inv_freq", torch.ones(4)) ++ pipeline.transformer = transformer ++ pipeline.device = torch.device("meta") ++ # Adapt only the accelerator boundary: Tensor.data cannot be reassigned ++ # from CPU to meta, whereas Module.to supports this allocation-free move. ++ monkeypatch.setattr(sequential_backend.SequentialOffloadHook, "_to_gpu", lambda hook, model: model.to(hook.device)) ++ monkeypatch.setattr( ++ sequential_backend, ++ "current_omni_platform", ++ SimpleNamespace(synchronize=lambda: None, get_free_memory=lambda: 0), ++ ) ++ apply_sequential_offload( ++ [transformer], ++ [], ++ device=pipeline.device, ++ pin_memory=False, ++ offload_dit_modules=(), ++ ) ++ pipeline._model_cpu_offload_modules = [transformer] ++ monkeypatch.setattr(pipeline, "progress_bar", lambda **kwargs: nullcontext(SimpleNamespace(update=lambda: None))) ++ ++ def prepare_before_first_forward(**kwargs): ++ assert kwargs["model"].inv_freq.device == pipeline.device ++ raise RuntimeError("preparation device checked") ++ ++ monkeypatch.setattr(module, "minimax_h3_denoise_loop", prepare_before_first_forward) ++ with pytest.raises(RuntimeError, match="preparation device checked"): ++ pipeline.diffuse(**_ref2va_kwargs(42)) ++ # Encoder-only offload must keep the unselected DiT resident on exit. ++ assert transformer.inv_freq.device == pipeline.device ++ ++ + @pytest.mark.parametrize("failure_stage", ["text", "media"]) + def test_encoder_failure_cancels_pending_noise_and_joins_worker(pipeline, monkeypatch, failure_stage): + from vllm_omni.diffusion.models.minimax_h3 import pipeline_minimax_h3 as module +diff --git a/vllm_omni/diffusion/models/minimax_h3/pipeline_minimax_h3.py b/vllm_omni/diffusion/models/minimax_h3/pipeline_minimax_h3.py +index 476c3cca8..939b06481 100644 +--- a/vllm_omni/diffusion/models/minimax_h3/pipeline_minimax_h3.py ++++ b/vllm_omni/diffusion/models/minimax_h3/pipeline_minimax_h3.py +@@ -2368,7 +2368,14 @@ class MiniMaxH3Pipeline( + cache_runtime = getattr(self, "_cache_dit_runtime", None) + if cache_runtime is not None: + cache_runtime.refresh(len(inputs["sigmas_video"]) - 1) +- with self._resident_dit_layers_on_device(enabled=transformer is self.transformer): ++ # RoPE preparation runs before the first transformer forward, so its ++ # buffers must already be placed by the module-offload hook. ++ component_scope = ( ++ self._component_on_device(transformer) ++ if getattr(self, "_model_cpu_offload_modules", None) ++ else nullcontext() ++ ) ++ with component_scope, self._resident_dit_layers_on_device(enabled=transformer is self.transformer): + with self.progress_bar(total=len(inputs["sigmas_video"]) - 1) as progress: + video_rows, audio_rows = minimax_h3_denoise_loop( + sampler=inputs["sampler"], diff --git a/evidence/h3-ref2va-4x910b1-320/results/head-layout-probe.json b/evidence/h3-ref2va-4x910b1-320/results/head-layout-probe.json new file mode 100644 index 000000000..59999aff2 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/head-layout-probe.json @@ -0,0 +1,119 @@ +{ + "scope": "Synthetic actual-shape probe only; no model losslessness or E2E claim", + "shape": [ + 1, + 14, + 82944, + 128 + ], + "results": [ + { + "batch": 2, + "heads": 7, + "exact": true, + "finite": true, + "samples_ms": { + "1": [ + 202.955131419003, + 202.43406761437654, + 202.0789785310626, + 203.08516547083855, + 202.63673271983862, + 203.53372674435377, + 200.4896979779005, + 199.35925863683224, + 202.2359725087881, + 199.39756952226162 + ], + "2": [ + 202.43658870458603, + 200.36596432328224, + 198.47867358475924, + 200.20360965281725, + 201.11042261123657, + 201.311438344419, + 198.96507635712624, + 202.60901283472776, + 200.176359154284, + 203.16311717033386 + ] + }, + "medians_ms": { + "1": 202.33502006158233, + "2": 200.7381934672594 + } + }, + { + "batch": 7, + "heads": 2, + "exact": true, + "finite": true, + "samples_ms": { + "1": [ + 202.81393732875586, + 201.76278054714203, + 203.65039072930813, + 201.12053398042917, + 203.20020709186792, + 200.531299225986, + 200.73468424379826, + 201.31508819758892, + 203.71572207659483, + 201.4033319428563 + ], + "7": [ + 200.4448752850294, + 198.29999934881926, + 201.07604283839464, + 203.26512027531862, + 200.76643396168947, + 200.48703625798225, + 202.6696540415287, + 199.6534364297986, + 202.56959088146687, + 203.87515518814325 + ] + }, + "medians_ms": { + "1": 201.58305624499917, + "7": 200.92123840004206 + } + }, + { + "batch": 14, + "heads": 1, + "exact": true, + "finite": true, + "samples_ms": { + "1": [ + 203.70931178331375, + 200.7012628018856, + 203.6555800586939, + 200.38026571273804, + 202.70274486392736, + 199.52361285686493, + 203.983168117702, + 200.27263090014458, + 204.11381218582392, + 201.80101133883 + ], + "14": [ + 203.5602070391178, + 203.2361188903451, + 203.58330849558115, + 201.0801024734974, + 200.08645579218864, + 202.8603507205844, + 203.59808765351772, + 203.46098486334085, + 203.21488846093416, + 201.86718460172415 + ] + }, + "medians_ms": { + "1": 202.25187810137868, + "14": 203.22550367563963 + } + } + ] +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/precision-matched-attention-probe.json b/evidence/h3-ref2va-4x910b1-320/results/precision-matched-attention-probe.json new file mode 100644 index 000000000..ac031b3e9 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/precision-matched-attention-probe.json @@ -0,0 +1,120 @@ +{ + "scope": "Synthetic operator screening; no model losslessness or E2E claim", + "baseline_repeat_exact": true, + "shape": [ + 1, + 14, + 82944, + 128 + ], + "results": [ + { + "kernel": "fused_attn_score", + "exact": false, + "finite": true, + "rmse": 1.015250563796144e-05, + "samples_ms": { + "laser": [ + 202.83806882798672, + 202.07594987004995, + 200.0813651829958, + 202.3501256480813, + 203.01278308033943, + 202.27626245468855, + 203.73250171542168, + 200.49748849123716, + 203.96013744175434, + 198.36231134831905 + ], + "fused_attn_score": [ + 316.4913523942232, + 317.63630267232656, + 316.0523111000657, + 316.7968410998583, + 316.43939204514027, + 315.0382451713085, + 313.7580119073391, + 317.07931868731976, + 315.0506056845188, + 316.2420764565468 + ] + }, + "medians_ms": { + "laser": 202.31319405138493, + "fused_attn_score": 316.3407342508435 + } + }, + { + "kernel": "prompt_flash_attn", + "exact": false, + "finite": true, + "rmse": 1.416556642652722e-05, + "samples_ms": { + "laser": [ + 202.05785799771547, + 198.62560741603374, + 202.9068609699607, + 202.86924857646227, + 200.6240114569664, + 203.77877447754145, + 199.85961075872183, + 203.30628100782633, + 199.10737127065659, + 203.15181743353605 + ], + "prompt_flash_attn": [ + 250.58831740170717, + 251.54226459562778, + 251.71683821827173, + 250.71666110306978, + 251.8660807982087, + 250.4017222672701, + 249.7303057461977, + 250.2983110025525, + 248.63953702151775, + 250.29085017740726 + ] + }, + "medians_ms": { + "laser": 202.46355328708887, + "prompt_flash_attn": 250.49501983448863 + } + }, + { + "kernel": "fia", + "exact": false, + "finite": true, + "rmse": 1.0151627975574229e-05, + "samples_ms": { + "laser": [ + 201.1064337566495, + 203.66724021732807, + 203.36985308676958, + 204.07835114747286, + 204.10452224314213, + 204.10394109785557, + 203.28615978360176, + 202.5069184601307, + 204.08944133669138, + 201.96222513914108 + ], + "fia": [ + 302.92276851832867, + 302.3746442049742, + 301.036037504673, + 303.0539508908987, + 301.8576893955469, + 303.40215004980564, + 301.2891747057438, + 302.5648891925812, + 302.0175639539957, + 302.409035153687 + ] + }, + "medians_ms": { + "laser": 203.51854665204883, + "fia": 302.3918396793306 + } + } + ] +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/tp4-placement-failure-and-fix.json b/evidence/h3-ref2va-4x910b1-320/results/tp4-placement-failure-and-fix.json new file mode 100644 index 000000000..e77a92946 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/tp4-placement-failure-and-fix.json @@ -0,0 +1,75 @@ +{ + "status": "No qualified lossless gain", + "target_achieved": false, + "failure": { + "source": "ce216014adb4c037dc15b3d49623e493ca3d3ac3", + "configuration": "4x910B1 TP4SP1 DiT resident and module-only encoder offload, originalLaser,5steps5s", + "warmup_http_status": 500, + "measured_completed": 0, + "error": "Expected all tensors on same device; RoPE preparation accesses CPU buffer with NPU positions before first model forward", + "call_path": [ + "MiniMaxH3Pipeline.diffuse", + "minimax_h3_denoise_loop", + "MiniMaxH3DenoiseBranch.prepare_rope_table", + "MiniMaxH3DiTModel.prepare_rope_table" + ], + "lifecycle": { + "status": "fail", + "container_exit": 1, + "server_exit": 0, + "forced_signals": 0, + "host_cleanup_intervention": false, + "expected_workers": 4, + "workers": [ + { + "name": "DiffusionWorker-0", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-1", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-2", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-3", + "exit_code": 0, + "alive": false + } + ] + } + }, + "candidate_fix": { + "source": "0be853d46bcb1ae880d7582f4bed502ec29017af", + "patch": "patch/tp4-denoise-placement.patch", + "behavior": "Enter existing module-offload component context before denoise preparation; preserve explicit component selection on exit; unchanged RoPE arithmetic", + "regression": "Unmodifiedsource fails CPU-vs-meta buffer-device assertion before firstforward;17focused tests pass withfix", + "precommit": "Passed after initialruff formatting corrections", + "npu_validation": "Single-candidate bringup launched; notyetvalidated in this receipt", + "sources": [ + "https://github.com/vllm-project/vllm-omni/pull/5691", + "https://github.com/InferMatrixLab/InferRSI/issues/320" + ] + }, + "operator_screening": { + "head_layout": "Allthree independenthead refactorings exact, approximately201-203ms, no materialgain demonstrated", + "precision_matched": "BaselineLaser syntheticrepeat exact; FP16input alternates fusedscore/prompt/FIA allslower andnotexact. These match baseline conversion boundaries, not newprecision reductions.", + "source": "Installed MindIE SD3.1.0 and torch_npu2.10post4 under pinnedruntimeimage", + "scope": "Synthetic actual-shape probes, not fullmodelE2E or quality acceptance" + }, + "raw_hashes": { + "tp4-screen/failed-candidate-qualification.json": "937b5c82eb18a2376718b9ce05e9db868ab77efb94066df7f193d231e5a77a52", + "runs/tp4-screen-tp4a/service.log": "990cc2655a7b17d3d839eef30c0fa739b0ddfbbe0b59aa009d756076cc5dfd7d", + "tp-placement-red.log": "3bb44d5408ea8654bb7439c030a03e537fcac4531716af7afa25b3d504ee365a", + "tp-placement-green.log": "132edc352d19cdfb60ed7b6d9eb6eed5fa18295811852f507819adec57223050", + "tp-placement-commit-v2.log": "24e4fe652034c6c5bae0c090b9b143d04e3ce5a90534e492a08a064118fe1857", + "head-layout-probe/manifest.json": "0f9799a885df805f77d045a4bcb8ed8d3a4c345f88c930e1a99e522f6f8cd9c6", + "precision-matched-attention-probe/manifest.json": "f3c425bc58929d139d327862de349fb757e40621702b5348450950af2d006e58", + "tp4-fixed-preflight/manifest.json": "9ea7fb9fbdeb8edecbde5173fde3827d1ff96006b236277e16471c51420d9efe" + } +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/tp4-placement-integrity.json b/evidence/h3-ref2va-4x910b1-320/results/tp4-placement-integrity.json new file mode 100644 index 000000000..997ea9008 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/tp4-placement-integrity.json @@ -0,0 +1,6 @@ +{ + "results/head-layout-probe.json": "367bc4c238624bb0c70ff15b9df54cc6b2bfcdc865c138df930ec2925eb1edf8", + "results/precision-matched-attention-probe.json": "12aa0b3dee329c853d1d7edb3c8d5abe4396a36ceba90cdeb9de9afdd2e19925", + "patch/tp4-denoise-placement.patch": "3b23e3538cfaa2a634ff5e302867a8105c663335987a662e4619231ec1ac35c8", + "results/tp4-placement-failure-and-fix.json": "2ff7130c186ef0242576ef3a7d4a9b7841c7404a01dbe08a2ec93793ab049698" +} diff --git a/tests/test_evidence_inventory.py b/tests/test_evidence_inventory.py index 4cbf7b3ef..a04fd3f48 100644 --- a/tests/test_evidence_inventory.py +++ b/tests/test_evidence_inventory.py @@ -146,5 +146,5 @@ def test_checked_in_inventory(): result = validate_inventory(repo) assert result["errors"] == [] assert len(result["bundles"]) == 21 - assert result["checked_hashes"] == 453 + assert result["checked_hashes"] == 457 assert result["unavailable"] # Historical raw artifacts are not in this checkout. diff --git a/tools/evidence_inventory.json b/tools/evidence_inventory.json index 666975d1c..02a6bf439 100644 --- a/tools/evidence_inventory.json +++ b/tools/evidence_inventory.json @@ -39,6 +39,10 @@ { "path": "results/pinned-interruption-integrity.json", "schema": "bundle-sha256" + }, + { + "path": "results/tp4-placement-integrity.json", + "schema": "bundle-sha256" } ], "external": [ From f5b76d85c5ce924fa877579988332626dc76f93f Mon Sep 17 00:00:00 2001 From: amy-why-3459 Date: Tue, 3 Nov 2026 16:00:53 +0800 Subject: [PATCH 11/17] Record H3 placement fix NPU validation and next dense screening Retain successful requests and clean exits separately from inconclusive media equality and unqualified performance. Freeze hybrid topology and query chunk operator hypotheses. Agent-assisted-by: Codex (implementation) Signed-off-by: amy-why-3459 --- .../results/hybrid-query-screening-plan.json | 66 +++++++ .../results/tp4-followup-integrity.json | 4 + .../results/tp4-placement-npu-validation.json | 183 ++++++++++++++++++ tests/test_evidence_inventory.py | 2 +- tools/evidence_inventory.json | 4 + 5 files changed, 258 insertions(+), 1 deletion(-) create mode 100644 evidence/h3-ref2va-4x910b1-320/results/hybrid-query-screening-plan.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/tp4-followup-integrity.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/tp4-placement-npu-validation.json diff --git a/evidence/h3-ref2va-4x910b1-320/results/hybrid-query-screening-plan.json b/evidence/h3-ref2va-4x910b1-320/results/hybrid-query-screening-plan.json new file mode 100644 index 000000000..2a8653eb3 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/hybrid-query-screening-plan.json @@ -0,0 +1,66 @@ +{ + "tp2-sp2-screen": { + "plan": { + "scope": "Adaptive five-step ABBA topology screening, not target qualification", + "hardware": "local four 910B1 under one reservation", + "arms": [ + "SP4 TP1 baseline", + "TP2 SP2 resident DiT with text encoder module offload" + ], + "order": [ + "base0", + "hybrid_a", + "hybrid_b", + "base1" + ], + "warmups_per_arm": 1, + "measured_per_arm": 1, + "steps": 5, + "duration_s": 5, + "early_rejection": "Continue second pair only if first completed clean candidate at least10percent lower E2E; incomplete ABBA retained on rejection", + "baseline_revision": "ce216014adb4c037dc15b3d49623e493ca3d3ac3", + "candidate_revision": "0be853d46bcb1ae880d7582f4bed502ec29017af", + "source": "Existing H3 TP implementation and module placement fix; hardware scheduling hypothesis from TP4 bringup", + "constraints": "Original Laser, BF16, same dense workload; no approximation; no lossless or30percent claim from this screen", + "quality": "Independent CPU scoring after reservation releases; different reduction topology requires evaluation against baseline repeatability" + }, + "frozen_harness": { + "admit_second_pair.py": "b8741ad8ade0ea1993627dd516c44af2ad073a07182e79ff029346d5259d2848", + "campaign.sh": "5b4e0ab29ce21c874fc6a89c0d97ddd046f1d0a43cdf1198421ff07dd09b84de", + "plan.json": "e78cc6abcc18882bea222dc7d04fefe395f16a914a2598fe341d4e5c4553df03", + "run_client.py": "7a3e697077524c9729ebdae78a533feb55777718b0db72ac3735e5164444bcde", + "run_heldout.py": "489e3048120fa34a1c8d089053f45f1d4cda4fd6fdf1652457d079302f77eded", + "run_host.sh": "79108b262a84db998d75b77f5851e3b184c36820823343d473ee0506024a2adb", + "run_inner.sh": "2f8a6bb1e76bfc0bd34d0c82e496487a8290ef1f721a0f8cc1fa04f84ea8c286" + } + }, + "query-chunk-probe": { + "plan": { + "hypothesis": "Query tiling may change kernel scheduling without omitting keys; reject unless actual exact parity and measured improvement", + "source": "Installed MindIE SD3.1 AscendLaserAttention preprocess/custom laser_attention/postprocess implementation", + "scope": "Single reserved NPU synthetic shape probe; not model quality or E2E", + "shape": [ + 1, + 14, + 82944, + 128 + ], + "precision": "Same BF16-FP16 input conversion, is_high_precision=True, FP16-BF16 output conversion", + "chunks": [ + 41472, + 20736, + 6912 + ], + "warmups": 3, + "rounds": 5, + "order": "ABBA", + "exclusions": "No sparse masks, KV reuse, precision reduction, quantization or step changes" + }, + "frozen_harness": { + "plan.json": "95cd4ff99e171f5c3dda4696d83ae9edbef7a9a45d724911318b42e14b037b76", + "probe.py": "e08408be4df28cbe67a3e75e76e3d651db458012f10570ba11239ac55d075243", + "run.sh": "44f83b61eec3daeb8a476e747d327960ff336d11defb00aaff30f1321e9ebaba" + } + }, + "execution_order": "TP4 cleanup and CPU quality complete, then reserved hybrid model screening and CPU quality, then separate reserved query-chunk operator probe. No combined speedup claim." +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/tp4-followup-integrity.json b/evidence/h3-ref2va-4x910b1-320/results/tp4-followup-integrity.json new file mode 100644 index 000000000..aef3dc4f0 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/tp4-followup-integrity.json @@ -0,0 +1,4 @@ +{ + "results/tp4-placement-npu-validation.json": "291fc85dac9dae0627a18cac231aa468a23f49760424cbcf5327f2b9b9bfb943", + "results/hybrid-query-screening-plan.json": "edc796d81aef0c87a7c641fa877e73eca92559d90344c5cc879ca3b748953833" +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/tp4-placement-npu-validation.json b/evidence/h3-ref2va-4x910b1-320/results/tp4-placement-npu-validation.json new file mode 100644 index 000000000..3d087a2e5 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/tp4-placement-npu-validation.json @@ -0,0 +1,183 @@ +{ + "scope": "Placement correctness bringup only, not paired performance qualification", + "isolated_revision": "0be853d46bcb1ae880d7582f4bed502ec29017af", + "qualification": { + "run": "tp4-fixed-preflight-v1", + "source_revision": "0be853d46bcb1ae880d7582f4bed502ec29017af", + "configuration": { + "dense_kernel": "ascend_laser_attention", + "pipeline_profiler": false, + "heldout_quality_cases": false, + "diagnostic_shutdown_override": false, + "shutdown_mode": "native", + "arm": "base", + "steps": 5, + "requests": 1, + "serve_args": [ + "--num-gpus", + "4", + "--tensor-parallel-size", + "4", + "--usp", + "1", + "--ring", + "1", + "--text-encoder-tp-size", + "4", + "--vae-parallel-mode", + "tile", + "--vae-use-tiling", + "--vae-patch-parallel-size", + "4", + "--disable-log-stats", + "--diffusion-attention-backend", + "FLASH_ATTN", + "--diffusion-offload-config", + "{\"mode\":\"module\",\"components\":[\"text_encoder\"]}" + ], + "warmups_per_duration": 1, + "durations_s": [ + 5 + ], + "dlo_wave_timeout_s": 14400.0, + "seeds": [ + 0 + ], + "inputs_sha256": { + "prompt.txt": "91c1340ea893aede82312dec30a6ae8c975c1def921348fc1cc45ccc86b315dd", + "input_video.mp4": "d6edc20ac82aa980c9cbd0b05b371f60d12dc8d018492e571b42de0086819c41", + "input_audio.mp3": "2a48d447b343b38a2c504d5281a0c97c688db0ba87931ed9282c598bd6752454" + } + }, + "runtime_settings_sha256": "8ae8395e701229695e7a92cce813dd0d7214be20828635183d33ee79723b37f1", + "cells": [ + { + "duration_s": 5, + "seed": 0, + "expected_measured_requests": 1, + "completed": 1, + "failed": 0, + "missing": 0, + "samples_ms": [ + 173936.701846309 + ], + "mean_ms": 173936.701846309, + "median_ms": 173936.701846309, + "min_ms": 173936.701846309, + "max_ms": 173936.701846309, + "request_sample_stdev_ms": null, + "statistics_scope": "Requests within one server; not independent process rounds or a reliable tail-latency estimate" + } + ], + "samples_including_warmups": [ + { + "label": "measured-5-seed0-0", + "seconds": 5, + "seed": 0, + "steps": 5, + "valid": true, + "e2e_ms": 173936.701846309, + "http_status": 200, + "bytes": 6610537, + "response_metrics": { + "X-Request-Id": "video_sync-83bbcaa814f0cc7a", + "X-Inference-Time-S": "173.873", + "X-Stage-Durations": "{\"queue_wait_ms\":0.44232234358787537,\"stage_0_gen_ms\":172658.57577323914}", + "X-Peak-Memory-MB": "45038.000" + }, + "output_sha256": "de7d74949e9171e17518ec070ea835b66a258b724f4700469c24d4c6eeb3d3d4" + }, + { + "label": "warmup-5", + "seconds": 5, + "seed": 0, + "steps": 5, + "valid": true, + "e2e_ms": 249562.89844959974, + "http_status": 200, + "bytes": 6618361, + "response_metrics": { + "X-Request-Id": "video_sync-8676e3adad2fe02b", + "X-Inference-Time-S": "249.469", + "X-Stage-Durations": "{\"queue_wait_ms\":0.4505319520831108,\"stage_0_gen_ms\":248088.7153148651}", + "X-Peak-Memory-MB": "34234.000" + }, + "output_sha256": "16407246fc5b0d0b56c2499994be95ed8ca06a201434e050b09dd0e5c42acd6a" + } + ], + "quality": "unknown; attach matched frozen-validator receipts for every accepted output", + "lifecycle": { + "status": "pass", + "container_exit": 0, + "server_exit": 0, + "forced_signals": 0, + "host_cleanup_intervention": false, + "expected_workers": 4, + "workers": [ + { + "name": "DiffusionWorker-0", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-1", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-2", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-3", + "exit_code": 0, + "alive": false + } + ] + }, + "service_log_sha256": "b9d97c080a3c58dd0e50104e9a7687b0cf97c090b3d6282e5744f85b9a089ae6" + }, + "quality": { + "verdict": "INCONCLUSIVE", + "media_gate_verdict": "PASS", + "scope": "decoded media equality; unequal outputs require separate baseline-repeatability adjudication", + "exact_video": false, + "exact_audio": false, + "coverage": [ + { + "expected_duration_s": 5.175, + "decoded_audio_end_s": 5.184 + }, + { + "expected_duration_s": 5.175, + "decoded_audio_end_s": 5.184 + } + ], + "scorer_identity": { + "alexnet_sha256": "7be5be791159472b1fbf3c69796f7cb30dca7ad8466c2df70058c37116cdee02", + "lpips_sha256": "df73285e35b22355a2df87cdb6b70b343713b667eddbda73e1977e0c860835c0" + }, + "metrics": { + "ssim": 0.984955, + "psnr_db": 45.748864, + "lpips": 0.017237607367156495, + "audio_spectral_cosine": 0.9983421663443247, + "audio_rms_ratio": 1.001951503445255, + "audio_samples": 165888 + }, + "inputs": { + "baseline": "48b8d9a102ee836c1522567ba0544b6aa0218d3e080a9a58a5346acbda0e1aba", + "candidate": "de7d74949e9171e17518ec070ea835b66a258b724f4700469c24d4c6eeb3d3d4", + "gates": "4fc26315d42731cf3af1b63e6a46563783f22e997f46bbc3c946fba6f630651f" + } + }, + "engine_pr": { + "url": "https://github.com/vllm-project/vllm-omni/pull/9698", + "verified_head": "a0e7b09c83d0fa50f7caede18b41654bcfdef7f2", + "validation": "17 focused CPU tests and all applicable precommit hooks pass at integrated revision; actual NPU execution used isolated revision above", + "source": "Reproduced CPU RoPE buffer versus NPU position IDs before first forward; existing component-residency context" + }, + "initial_integration_test_invocation": "Exited4 because one supplied test filename was wrong; corrected invocation completed17tests. Both original and corrected logs retained externally.", + "target_achieved": false +} diff --git a/tests/test_evidence_inventory.py b/tests/test_evidence_inventory.py index a04fd3f48..3d2ff49ca 100644 --- a/tests/test_evidence_inventory.py +++ b/tests/test_evidence_inventory.py @@ -146,5 +146,5 @@ def test_checked_in_inventory(): result = validate_inventory(repo) assert result["errors"] == [] assert len(result["bundles"]) == 21 - assert result["checked_hashes"] == 457 + assert result["checked_hashes"] == 459 assert result["unavailable"] # Historical raw artifacts are not in this checkout. diff --git a/tools/evidence_inventory.json b/tools/evidence_inventory.json index 02a6bf439..fb50751f9 100644 --- a/tools/evidence_inventory.json +++ b/tools/evidence_inventory.json @@ -43,6 +43,10 @@ { "path": "results/tp4-placement-integrity.json", "schema": "bundle-sha256" + }, + { + "path": "results/tp4-followup-integrity.json", + "schema": "bundle-sha256" } ], "external": [ From 54118d0dfd7de1840ebafce2edac2e2a06da7661 Mon Sep 17 00:00:00 2001 From: amy-why-3459 Date: Tue, 3 Nov 2026 16:17:32 +0800 Subject: [PATCH 12/17] Retain H3 hybrid capacity failure and query partition results Record second-request VAE encode OOM separately from completed warmup; reject slower nonexact query partitions and freeze independent queue and residency followups. Agent-assisted-by: Codex (implementation) Signed-off-by: amy-why-3459 --- .../dispatch-queue-stage-offload-plan.json | 62 +++ .../results/hybrid-negative-integrity.json | 4 + .../results/hybrid-oom-query-result.json | 399 ++++++++++++++++++ tests/test_evidence_inventory.py | 2 +- tools/evidence_inventory.json | 4 + 5 files changed, 470 insertions(+), 1 deletion(-) create mode 100644 evidence/h3-ref2va-4x910b1-320/results/dispatch-queue-stage-offload-plan.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/hybrid-negative-integrity.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/hybrid-oom-query-result.json diff --git a/evidence/h3-ref2va-4x910b1-320/results/dispatch-queue-stage-offload-plan.json b/evidence/h3-ref2va-4x910b1-320/results/dispatch-queue-stage-offload-plan.json new file mode 100644 index 000000000..2a231f938 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/dispatch-queue-stage-offload-plan.json @@ -0,0 +1,62 @@ +{ + "task-queue-screen": { + "plan": { + "scope": "Independent task dispatch queue screening; five-step adaptive ABBA only", + "source": "https://www.hiascend.com/document/detail/en/Pytorch/2610/apiref/ENV/docs/en/environment_variable_reference/TASK_QUEUE_ENABLE.md", + "observed_baseline": "Pinned image/container TASK_QUEUE_ENABLE=1; OMP_NUM_THREADS=1; ASCEND_LAUNCH_BLOCKING unset", + "hypothesis": "Move workspace management into second-level dispatch queue, reducing host dispatch gaps without changing model math", + "hardware": "Four local910B1 under one reservation", + "source_revision": "ce216014adb4c037dc15b3d49623e493ca3d3ac3", + "arms": { + "base0": 1, + "queue2a": 2, + "queue2b": 2, + "base1": 1 + }, + "order": [ + "base0", + "queue2a", + "queue2b", + "base1" + ], + "steps": 5, + "duration_s": 5, + "warmups": 1, + "measured": 1, + "same_settings": "SP4 TP1, textTP4, VAEtile4, DLO, BF16, OriginalLaser, seed0 and frozen input hashes", + "admission": "Continue second pair only if first clean pair candidate E2E at least3percent lower; otherwise retain incomplete ABBA as short screening without final rejection proof", + "quality": "Independent CPU scoring after model reservation ends; numerical scheduling parity must be measured", + "acceptance": "No30percent or losslessness claim from configuration documentation or this short screening" + }, + "frozen_harness": { + "admit_second_pair.py": "c68f3c39632620be23b381b19259017128af76a85d81cf69bf510eb20182d558", + "campaign.sh": "05cc22e9b1ad8eaa7d7fa0d4b7faac5ea4bb24ec5c5bad58e8538505245e124b", + "plan.json": "dbf0413d184942cc92d992dcfb4d44bdcb1db6041876d30176aa2182f1d512f4", + "run_client.py": "7a3e697077524c9729ebdae78a533feb55777718b0db72ac3735e5164444bcde", + "run_heldout.py": "489e3048120fa34a1c8d089053f45f1d4cda4fd6fdf1652457d079302f77eded", + "run_host.sh": "0d92bd3554d3a1efa83a50ef7001134974579025c90a98f6b6b800e17037673c", + "run_inner.sh": "7b983d61aa5e93b5182ffd82b92f8b932890e613dbbeda49b974b5e445fce58f" + } + }, + "tp2-sp2-stage-offload": { + "plan": { + "scope": "Single candidate capacity bringup after second-request VAE encode OOM; not matched speedup", + "source_revision": "0be853d46bcb1ae880d7582f4bed502ec29017af", + "failure": "First request succeeds; retained DiT occupies capacity on next reference-video VAE encoding. All ranks fail1.15GiB allocation at57.82GiB active.", + "change": "Existing module offload components include both text_encoder and dit; DiT stays resident for entire denoise context, releases after context before decode/next request", + "unchanged": "TP2SP2, textTP4, VAEtile4, BF16, original denseLaser,5steps,5s,seed0,onewarmup/onemeasured", + "acceptance": "Two completed requests and cleanworker exits before any performance promotion. CPU transfer overhead and output parity remain unqualified.", + "source": "Existing sequential_offload_component selection contract and observed H3 second-request OOM", + "status_at_freeze": "Prepared only; not launched" + }, + "frozen_harness": { + "campaign.sh": "df651c040da9123480de193afe98a15853b10964bc76d881fda5c22b3fd133ac", + "plan.json": "9b3f6e554f01999e63532ea20cf267dda737b4bebbb3f567a2d872c0c92b0a9c", + "run_client.py": "7a3e697077524c9729ebdae78a533feb55777718b0db72ac3735e5164444bcde", + "run_heldout.py": "489e3048120fa34a1c8d089053f45f1d4cda4fd6fdf1652457d079302f77eded", + "run_host.sh": "2c7421771b698065ab8b1712b1c98859831ba2e9d16ef7b16a4a4f81cde23e7b", + "run_inner.sh": "a364ce642e17a6adeeb8687cf7c41e7c722b3baba673ac63861982ecca665334" + } + }, + "status_at_receipt": "Task queue comparison waiting for one four-device reservation; hybrid stage offload prepared, not launched." +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/hybrid-negative-integrity.json b/evidence/h3-ref2va-4x910b1-320/results/hybrid-negative-integrity.json new file mode 100644 index 000000000..116323caa --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/hybrid-negative-integrity.json @@ -0,0 +1,4 @@ +{ + "results/hybrid-oom-query-result.json": "24a307bc0954e4c44b4e739d95d1ba9c857ee2cafc9163d9e41de2b0769ce547", + "results/dispatch-queue-stage-offload-plan.json": "7c5443d84e0dd7b215d368d182a40d109c23dc25be28e4d87d6898bd0b936627" +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/hybrid-oom-query-result.json b/evidence/h3-ref2va-4x910b1-320/results/hybrid-oom-query-result.json new file mode 100644 index 000000000..0f628859f --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/hybrid-oom-query-result.json @@ -0,0 +1,399 @@ +{ + "scope": "Failed hybrid model experiment and rejected synthetic dense operator changes", + "hybrid_control": { + "run": "tp2-sp2-screen-base0", + "source_revision": "ce216014adb4c037dc15b3d49623e493ca3d3ac3", + "configuration": { + "dense_kernel": "ascend_laser_attention", + "pipeline_profiler": false, + "heldout_quality_cases": false, + "diagnostic_shutdown_override": false, + "shutdown_mode": "native", + "arm": "base", + "steps": 5, + "requests": 1, + "serve_args": [ + "--num-gpus", + "4", + "--usp", + "4", + "--ring", + "1", + "--text-encoder-tp-size", + "4", + "--vae-parallel-mode", + "tile", + "--vae-use-tiling", + "--vae-patch-parallel-size", + "4", + "--enable-distributed-layerwise-offload", + "--disable-log-stats", + "--diffusion-attention-backend", + "FLASH_ATTN" + ], + "warmups_per_duration": 1, + "durations_s": [ + 5 + ], + "dlo_wave_timeout_s": 14400.0, + "seeds": [ + 0 + ], + "inputs_sha256": { + "prompt.txt": "91c1340ea893aede82312dec30a6ae8c975c1def921348fc1cc45ccc86b315dd", + "input_video.mp4": "d6edc20ac82aa980c9cbd0b05b371f60d12dc8d018492e571b42de0086819c41", + "input_audio.mp3": "2a48d447b343b38a2c504d5281a0c97c688db0ba87931ed9282c598bd6752454" + } + }, + "runtime_settings_sha256": "a2a956fdb49512b5c4b495706cc8b0ff4465e96348d21b9156ff48e8de826271", + "cells": [ + { + "duration_s": 5, + "seed": 0, + "expected_measured_requests": 1, + "completed": 1, + "failed": 0, + "missing": 0, + "samples_ms": [ + 166571.69562019408 + ], + "mean_ms": 166571.69562019408, + "median_ms": 166571.69562019408, + "min_ms": 166571.69562019408, + "max_ms": 166571.69562019408, + "request_sample_stdev_ms": null, + "statistics_scope": "Requests within one server; not independent process rounds or a reliable tail-latency estimate" + } + ], + "samples_including_warmups": [ + { + "label": "measured-5-seed0-0", + "seconds": 5, + "seed": 0, + "steps": 5, + "valid": true, + "e2e_ms": 166571.69562019408, + "http_status": 200, + "bytes": 6621135, + "response_metrics": { + "X-Request-Id": "video_sync-8a33f8f18397af24", + "X-Inference-Time-S": "166.503", + "X-Stage-Durations": "{\"queue_wait_ms\":0.5019530653953552,\"stage_0_gen_ms\":165265.2485370636}", + "X-Peak-Memory-MB": "19748.000" + }, + "output_sha256": "1ae5d8ce267bf6c1e38e026224b1248c893af21c93c8e1162a2bc8dfe42c4059" + }, + { + "label": "warmup-5", + "seconds": 5, + "seed": 0, + "steps": 5, + "valid": true, + "e2e_ms": 253153.14952470362, + "http_status": 200, + "bytes": 6611456, + "response_metrics": { + "X-Request-Id": "video_sync-866e4e0e70db2b20", + "X-Inference-Time-S": "253.060", + "X-Stage-Durations": "{\"queue_wait_ms\":0.39513036608695984,\"stage_0_gen_ms\":252115.53072929382}", + "X-Peak-Memory-MB": "19688.000" + }, + "output_sha256": "8a7a5b3504a1c566d48b7e918ee57fb85011f13a356c9cb5346e6943a9c5f1ff" + } + ], + "quality": "unknown; attach matched frozen-validator receipts for every accepted output", + "lifecycle": { + "status": "pass", + "container_exit": 0, + "server_exit": 0, + "forced_signals": 0, + "host_cleanup_intervention": false, + "expected_workers": 4, + "workers": [ + { + "name": "DiffusionWorker-0", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-1", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-2", + "exit_code": 0, + "alive": false + }, + { + "name": "DiffusionWorker-3", + "exit_code": 0, + "alive": false + } + ] + }, + "service_log_sha256": "c44b7127d73b90755e6062976ab3b6b27ce67f19e39dd91762e6f6a55d7698ed" + }, + "hybrid_failed_candidate": { + "run": "tp2-sp2-screen-hybrid_a", + "source_revision": "0be853d46bcb1ae880d7582f4bed502ec29017af", + "configuration": { + "dense_kernel": "ascend_laser_attention", + "pipeline_profiler": false, + "heldout_quality_cases": false, + "diagnostic_shutdown_override": false, + "shutdown_mode": "native", + "arm": "base", + "steps": 5, + "requests": 1, + "serve_args": [ + "--num-gpus", + "4", + "--tensor-parallel-size", + "2", + "--usp", + "2", + "--ring", + "1", + "--text-encoder-tp-size", + "4", + "--vae-parallel-mode", + "tile", + "--vae-use-tiling", + "--vae-patch-parallel-size", + "4", + "--disable-log-stats", + "--diffusion-attention-backend", + "FLASH_ATTN", + "--diffusion-offload-config", + "{\"mode\":\"module\",\"components\":[\"text_encoder\"]}" + ], + "warmups_per_duration": 1, + "durations_s": [ + 5 + ], + "dlo_wave_timeout_s": 14400.0, + "seeds": [ + 0 + ], + "inputs_sha256": { + "prompt.txt": "91c1340ea893aede82312dec30a6ae8c975c1def921348fc1cc45ccc86b315dd", + "input_video.mp4": "d6edc20ac82aa980c9cbd0b05b371f60d12dc8d018492e571b42de0086819c41", + "input_audio.mp3": "2a48d447b343b38a2c504d5281a0c97c688db0ba87931ed9282c598bd6752454" + } + }, + "runtime_settings_sha256": "f2e5f4bf21917cbf6212edb8429f2bee25803542708a78e00f650fe42a0b305f", + "cells": [ + { + "duration_s": 5, + "seed": 0, + "expected_measured_requests": 1, + "completed": 0, + "failed": 1, + "missing": 0, + "samples_ms": [], + "mean_ms": null, + "median_ms": null, + "min_ms": null, + "max_ms": null, + "request_sample_stdev_ms": null, + "statistics_scope": "Requests within one server; not independent process rounds or a reliable tail-latency estimate" + } + ], + "samples_including_warmups": [ + { + "label": "measured-5-seed0-0", + "seconds": 5, + "seed": 0, + "steps": 5, + "valid": false, + "e2e_ms": 69119.12425234914, + "http_status": 500, + "bytes": 391, + "response_metrics": {}, + "error": "HTTP 500: {\"error\":{\"message\":\"Video generation failed: NPU out of memory. Tried to allocate 1.15 GiB (NPU 1; 60.96 GiB total capacity; 57.82 GiB already allocated; 57.82 GiB current active; 334.45 MiB free; 57.89 GiB reserved in total by PyTorch).If reserved memory is >> allocated memory try setting max_split_size_mb to avoid fragmentation.\",\"type\":\"Internal Server Error\",\"param\":null,\"code\":500}}" + }, + { + "label": "warmup-5", + "seconds": 5, + "seed": 0, + "steps": 5, + "valid": true, + "e2e_ms": 253081.255200319, + "http_status": 200, + "bytes": 6619706, + "response_metrics": { + "X-Request-Id": "video_sync-be30170c7b93d0f0", + "X-Inference-Time-S": "252.983", + "X-Stage-Durations": "{\"queue_wait_ms\":0.4733521491289139,\"stage_0_gen_ms\":251891.70956611633}", + "X-Peak-Memory-MB": "49898.000" + }, + "output_sha256": "f724d39e65119c29533f8e411cad3f956c371b8e2ac4ba6702376d34ed198c8c" + } + ], + "quality": "unknown; attach matched frozen-validator receipts for every accepted output", + "lifecycle": { + "status": "fail", + "container_exit": 1, + "server_exit": 0, + "forced_signals": 4, + "host_cleanup_intervention": false, + "expected_workers": 4, + "workers": [ + { + "name": "DiffusionWorker-0", + "exit_code": -15, + "alive": false + }, + { + "name": "DiffusionWorker-1", + "exit_code": -15, + "alive": false + }, + { + "name": "DiffusionWorker-2", + "exit_code": -15, + "alive": false + }, + { + "name": "DiffusionWorker-3", + "exit_code": -15, + "alive": false + } + ] + }, + "service_log_sha256": "662dd2c11a7d33cd98ce9e3a944724507853cf2b08e9cfbc7fa0abb74c7adb9d" + }, + "failure_analysis": { + "location": "Second request, reference video VAE encoding; prior request DiT remains resident by explicit selection", + "allocation_requested_GiB": 1.15, + "active_GiB": 57.82, + "total_device_GiB": 60.96, + "scope": "Not a fragmentation diagnosis; active memory nearly exhausts capacity", + "first_request": "Warmup HTTP200; candidate measured request HTTP500, no measured media or speedup", + "lifecycle": "All workers and server exited zero without forced signals, but container exit1 means full lifecycle qualification fails", + "decision": "Stop incomplete ABBA; prepare separate component-offload configuration without changing frozen failed run" + }, + "query_chunk_probe": { + "shape": [ + 1, + 14, + 82944, + 128 + ], + "results": [ + { + "query_chunk": 41472, + "exact": false, + "finite": true, + "rmse": 7.101540177245624e-06, + "samples_ms": { + "baseline": [ + 202.1085973829031, + 201.86828076839447, + 201.55992452055216, + 202.12047826498747, + 201.94504410028458, + 202.308832667768, + 201.50060299783945, + 201.9133735448122, + 202.84561719745398, + 202.27250270545483 + ], + "candidate": [ + 202.77249533683062, + 203.2938590273261, + 201.1196231469512, + 202.42144726216793, + 203.15915532410145, + 202.896848320961, + 203.77180073410273, + 203.56090553104877, + 202.95233000069857, + 203.2683091238141 + ] + }, + "medians_ms": { + "baseline": 202.02682074159384, + "candidate": 203.0557426624 + } + }, + { + "query_chunk": 20736, + "exact": false, + "finite": true, + "rmse": 7.0833234531164635e-06, + "samples_ms": { + "baseline": [ + 202.56038941442966, + 202.16483995318413, + 202.07379665225744, + 202.0931877195835, + 201.6310952603817, + 201.81423984467983, + 201.59291476011276, + 201.80692989379168, + 201.8639324232936, + 202.01321505010128 + ], + "candidate": [ + 202.11930759251118, + 202.18290854245424, + 204.36871703714132, + 203.97595781832933, + 202.9394693672657, + 202.14044861495495, + 202.19954010099173, + 204.78882733732462, + 203.69768980890512, + 203.8127016276121 + ] + }, + "medians_ms": { + "baseline": 201.93857373669744, + "candidate": 203.3185795880854 + } + }, + { + "query_chunk": 6912, + "exact": false, + "finite": true, + "rmse": 7.014911261649104e-06, + "samples_ms": { + "baseline": [ + 202.6188112795353, + 203.4319033846259, + 202.13026739656925, + 203.6263570189476, + 202.2528424859047, + 203.7888616323471, + 202.421136200428, + 203.36578134447336, + 202.15090923011303, + 203.4368123859167 + ], + "candidate": [ + 205.0780951976776, + 204.5427318662405, + 204.13180999457836, + 204.28764540702105, + 203.92265636473894, + 204.95968218892813, + 203.92563473433256, + 205.4731361567974, + 203.65303754806519, + 205.3725542500615 + ] + }, + "medians_ms": { + "baseline": 202.99229631200433, + "candidate": 204.41518863663077 + } + } + ], + "scope": "Synthetic operator only, full dense keys and baseline precision", + "target_achieved": false + }, + "query_decision": "All three schedules slower and not bit-exact; reject promotion", + "target_achieved": false +} diff --git a/tests/test_evidence_inventory.py b/tests/test_evidence_inventory.py index 3d2ff49ca..a6fb632d8 100644 --- a/tests/test_evidence_inventory.py +++ b/tests/test_evidence_inventory.py @@ -146,5 +146,5 @@ def test_checked_in_inventory(): result = validate_inventory(repo) assert result["errors"] == [] assert len(result["bundles"]) == 21 - assert result["checked_hashes"] == 459 + assert result["checked_hashes"] == 461 assert result["unavailable"] # Historical raw artifacts are not in this checkout. diff --git a/tools/evidence_inventory.json b/tools/evidence_inventory.json index fb50751f9..8e0e99f47 100644 --- a/tools/evidence_inventory.json +++ b/tools/evidence_inventory.json @@ -47,6 +47,10 @@ { "path": "results/tp4-followup-integrity.json", "schema": "bundle-sha256" + }, + { + "path": "results/hybrid-negative-integrity.json", + "schema": "bundle-sha256" } ], "external": [ From 6c86fcc7445b68b45b6f8256dc5439c1def6bc08 Mon Sep 17 00:00:00 2001 From: amy-why-3459 Date: Tue, 3 Nov 2026 16:40:35 +0800 Subject: [PATCH 13/17] Preserve H3 denoise interval analysis and fused projection plan Use integer nanosecond interval unions and retain raw trace digests. Reprioritize the fused BF16 projection probe before the unchanged task queue experiment, preserving the canceled unstarted reservation. Agent-assisted-by: Codex (implementation) Signed-off-by: amy-why-3459 --- .../results/analyze-denoise-intervals.py | 58 ++ .../results/critical-path-integrity.json | 5 + .../results/denoise-intervals-v2.json | 497 ++++++++++++++++++ .../fused-projection-followup-plan.json | 91 ++++ tests/test_evidence_inventory.py | 2 +- tools/evidence_inventory.json | 4 + 6 files changed, 656 insertions(+), 1 deletion(-) create mode 100644 evidence/h3-ref2va-4x910b1-320/results/analyze-denoise-intervals.py create mode 100644 evidence/h3-ref2va-4x910b1-320/results/critical-path-integrity.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/denoise-intervals-v2.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/fused-projection-followup-plan.json diff --git a/evidence/h3-ref2va-4x910b1-320/results/analyze-denoise-intervals.py b/evidence/h3-ref2va-4x910b1-320/results/analyze-denoise-intervals.py new file mode 100644 index 000000000..ec0f8fd04 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/analyze-denoise-intervals.py @@ -0,0 +1,58 @@ +"""Union device intervals in the main-attention span; never a clean E2E claim.""" +import collections +import csv +import json +import sys +from decimal import Decimal +from pathlib import Path + +root = Path(sys.argv[1]).resolve() # External campaign root containing retained raw traces +result = {} + +def ns(value): + return int(Decimal(value.strip()) * 1000) + +def union_duration(intervals): + end = None + total = 0 + for start, stop in sorted(intervals): + if end is None or start > end: + total += stop - start + end = stop + elif stop > end: + total += stop - end + end = stop + return total + +for path in sorted((root/'runs/profile-lifecycle-5s-five-steps/traces').glob('diffusion_rank*/*/ASCEND_PROFILER_OUTPUT/kernel_details.csv')): + rows = list(csv.DictReader(path.open())) + attention = [r for r in rows if r['Type'] == 'LaserAttention' and '82944' in r['Input Shapes']] + assert len(attention) == 250 + start = min(ns(r['Start Time(us)']) for r in attention) + stop = max(ns(r['Start Time(us)']) + ns(r['Duration(us)']) for r in attention) + groups = collections.defaultdict(list) + categories = collections.Counter() + for row in rows: + a = max(start, ns(row['Start Time(us)'])) + b = min(stop, ns(row['Start Time(us)']) + ns(row['Duration(us)'])) + if b <= a: + continue + category = 'communication' if row['Type'].startswith('hcom_') else 'other_device_tasks' + groups[category].append((a,b)) + categories[(row['Type'],row['Accelerator Core'])] += (b-a)/1e9 + other = union_duration(groups['other_device_tasks']) + comm = union_duration(groups['communication']) + combined = union_duration(groups['other_device_tasks']+groups['communication']) + result[path.parts[-4]] = { + 'span_s':(stop-start)/1e9, + 'other_device_union_s':other/1e9, + 'communication_union_s':comm/1e9, + 'communication_outside_other_device_tasks_s':(combined-other)/1e9, + 'no_kernel_interval_s':(stop-start-combined)/1e9, + 'largest_task_type_sums_s':[(list(k),v) for k,v in categories.most_common(16)], + } +(root/'profile-denoise-intervals-v2.json').write_text(json.dumps({ + 'arithmetic':'Integer nanosecond interval arithmetic parsed from decimal microseconds; avoids rounding large absolute timestamps.', + 'scope':'Profiled five-step diagnostic, first through last main LaserAttention interval; excludes pre/post edges, not E2E or achievable speedup. Other device tasks include compute/copy; no-kernel intervals can include synchronization and dispatch.', + 'ranks':result},indent=2)+'\n') +print(json.dumps(result,indent=2)) diff --git a/evidence/h3-ref2va-4x910b1-320/results/critical-path-integrity.json b/evidence/h3-ref2va-4x910b1-320/results/critical-path-integrity.json new file mode 100644 index 000000000..3d39b8046 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/critical-path-integrity.json @@ -0,0 +1,5 @@ +{ + "results/denoise-intervals-v2.json": "da25e74b9b8ac8f611eee09ce72cce7d444f7424b31b26c054a7a8c69a8f835f", + "results/analyze-denoise-intervals.py": "52204097845c230f050f3ccf37973931f43fc4243c5d6e27d7659b58794000bd", + "results/fused-projection-followup-plan.json": "ab0d8ffb40f2e2f2af2cba80b259786aed7e9bc0b5a791b8d3c6481d65fcaaa0" +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/denoise-intervals-v2.json b/evidence/h3-ref2va-4x910b1-320/results/denoise-intervals-v2.json new file mode 100644 index 000000000..0decb422a --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/denoise-intervals-v2.json @@ -0,0 +1,497 @@ +{ + "arithmetic": "Integer nanosecond interval arithmetic parsed from decimal microseconds; avoids rounding large absolute timestamps.", + "scope": "Profiled five-step diagnostic, first through last main LaserAttention interval; excludes pre/post edges, not E2E or achievable speedup. Other device tasks include compute/copy; no-kernel intervals can include synchronization and dispatch.", + "ranks": { + "diffusion_rank0": { + "span_s": 77.23553498, + "other_device_union_s": 69.28666108, + "communication_union_s": 13.14966384, + "communication_outside_other_device_tasks_s": 7.7566349, + "no_kernel_interval_s": 0.192239, + "largest_task_type_sums_s": [ + [ + [ + "LaserAttention", + "MIX_AIC" + ], + 47.94897916000001 + ], + [ + [ + "MatMulV3", + "AI_CORE" + ], + 14.332277719999999 + ], + [ + [ + "hcom_alltoall_", + "COMMUNICATION" + ], + 7.493733379999999 + ], + [ + [ + "hcom_allGather_", + "COMMUNICATION" + ], + 6.00113713999999 + ], + [ + [ + "Transpose", + "AI_VECTOR_CORE" + ], + 2.047543980000001 + ], + [ + [ + "Slice", + "AI_VECTOR_CORE" + ], + 0.84261082 + ], + [ + [ + "Cast", + "AI_VECTOR_CORE" + ], + 0.6717586399999982 + ], + [ + [ + "ConcatD", + "AI_VECTOR_CORE" + ], + 0.6082657000000006 + ], + [ + [ + "_indexed_gate_rms_norm_scale_shift_kernel", + "AI_VECTOR_CORE" + ], + 0.42835656000000005 + ], + [ + [ + "SwiGlu", + "AI_VECTOR_CORE" + ], + 0.4179941 + ], + [ + [ + "RealDiv", + "AI_VECTOR_CORE" + ], + 0.39562559999999986 + ], + [ + [ + "RotaryPositionEmbedding", + "MIX_AIV" + ], + 0.32856284000000013 + ], + [ + [ + "RmsNorm", + "AI_VECTOR_CORE" + ], + 0.31209784000000007 + ], + [ + [ + "_rms_norm_indexed_scale_shift_kernel", + "AI_VECTOR_CORE" + ], + 0.28120434 + ], + [ + [ + "AsStrided", + "AI_VECTOR_CORE" + ], + 0.2536545200000001 + ], + [ + [ + "_indexed_gate_kernel", + "AI_VECTOR_CORE" + ], + 0.22251919999999997 + ] + ] + }, + "diffusion_rank1": { + "span_s": 77.23368542, + "other_device_union_s": 69.28512162, + "communication_union_s": 13.54274946, + "communication_outside_other_device_tasks_s": 7.8278398, + "no_kernel_interval_s": 0.120724, + "largest_task_type_sums_s": [ + [ + [ + "LaserAttention", + "MIX_AIC" + ], + 47.81244991999998 + ], + [ + [ + "MatMulV3", + "AI_CORE" + ], + 14.454569199999982 + ], + [ + [ + "hcom_alltoall_", + "COMMUNICATION" + ], + 7.512668579999993 + ], + [ + [ + "hcom_allGather_", + "COMMUNICATION" + ], + 6.357963679999983 + ], + [ + [ + "Transpose", + "AI_VECTOR_CORE" + ], + 2.0510927400000023 + ], + [ + [ + "Slice", + "AI_VECTOR_CORE" + ], + 0.8456157199999995 + ], + [ + [ + "Cast", + "AI_VECTOR_CORE" + ], + 0.6728354799999999 + ], + [ + [ + "ConcatD", + "AI_VECTOR_CORE" + ], + 0.6111412000000008 + ], + [ + [ + "_indexed_gate_rms_norm_scale_shift_kernel", + "AI_VECTOR_CORE" + ], + 0.4275274599999996 + ], + [ + [ + "SwiGlu", + "AI_VECTOR_CORE" + ], + 0.41888922 + ], + [ + [ + "RealDiv", + "AI_VECTOR_CORE" + ], + 0.39606063999999985 + ], + [ + [ + "RotaryPositionEmbedding", + "MIX_AIV" + ], + 0.3260195399999999 + ], + [ + [ + "RmsNorm", + "AI_VECTOR_CORE" + ], + 0.31594848000000003 + ], + [ + [ + "_rms_norm_indexed_scale_shift_kernel", + "AI_VECTOR_CORE" + ], + 0.28261759999999986 + ], + [ + [ + "AsStrided", + "AI_VECTOR_CORE" + ], + 0.25300735999999985 + ], + [ + [ + "_indexed_gate_kernel", + "AI_VECTOR_CORE" + ], + 0.22415591999999998 + ] + ] + }, + "diffusion_rank2": { + "span_s": 77.23209754, + "other_device_union_s": 69.39772194, + "communication_union_s": 13.1439013, + "communication_outside_other_device_tasks_s": 7.646555, + "no_kernel_interval_s": 0.1878206, + "largest_task_type_sums_s": [ + [ + [ + "LaserAttention", + "MIX_AIC" + ], + 47.88038548000003 + ], + [ + [ + "MatMulV3", + "AI_CORE" + ], + 14.502843519999997 + ], + [ + [ + "hcom_alltoall_", + "COMMUNICATION" + ], + 7.389684819999991 + ], + [ + [ + "hcom_allGather_", + "COMMUNICATION" + ], + 6.063644620000014 + ], + [ + [ + "Transpose", + "AI_VECTOR_CORE" + ], + 2.050380139999998 + ], + [ + [ + "Slice", + "AI_VECTOR_CORE" + ], + 0.8445945800000001 + ], + [ + [ + "Cast", + "AI_VECTOR_CORE" + ], + 0.6730067000000005 + ], + [ + [ + "ConcatD", + "AI_VECTOR_CORE" + ], + 0.6108241199999999 + ], + [ + [ + "_indexed_gate_rms_norm_scale_shift_kernel", + "AI_VECTOR_CORE" + ], + 0.4272180600000004 + ], + [ + [ + "SwiGlu", + "AI_VECTOR_CORE" + ], + 0.41855996 + ], + [ + [ + "RealDiv", + "AI_VECTOR_CORE" + ], + 0.39618396000000033 + ], + [ + [ + "RotaryPositionEmbedding", + "MIX_AIV" + ], + 0.3245945799999998 + ], + [ + [ + "RmsNorm", + "AI_VECTOR_CORE" + ], + 0.31899611999999955 + ], + [ + [ + "_rms_norm_indexed_scale_shift_kernel", + "AI_VECTOR_CORE" + ], + 0.28237110000000004 + ], + [ + [ + "AsStrided", + "AI_VECTOR_CORE" + ], + 0.2530499800000002 + ], + [ + [ + "_indexed_gate_kernel", + "AI_VECTOR_CORE" + ], + 0.22169150000000004 + ] + ] + }, + "diffusion_rank3": { + "span_s": 77.23231728, + "other_device_union_s": 69.18469668, + "communication_union_s": 13.59486734, + "communication_outside_other_device_tasks_s": 7.91109678, + "no_kernel_interval_s": 0.13652382, + "largest_task_type_sums_s": [ + [ + [ + "LaserAttention", + "MIX_AIC" + ], + 47.8721051 + ], + [ + [ + "MatMulV3", + "AI_CORE" + ], + 14.298727479999991 + ], + [ + [ + "hcom_alltoall_", + "COMMUNICATION" + ], + 7.598519060000008 + ], + [ + [ + "hcom_allGather_", + "COMMUNICATION" + ], + 6.360974380000011 + ], + [ + [ + "Transpose", + "AI_VECTOR_CORE" + ], + 2.0501051799999974 + ], + [ + [ + "Slice", + "AI_VECTOR_CORE" + ], + 0.8427980599999999 + ], + [ + [ + "Cast", + "AI_VECTOR_CORE" + ], + 0.6732478999999992 + ], + [ + [ + "ConcatD", + "AI_VECTOR_CORE" + ], + 0.6115912600000005 + ], + [ + [ + "_indexed_gate_rms_norm_scale_shift_kernel", + "AI_VECTOR_CORE" + ], + 0.42792618000000016 + ], + [ + [ + "SwiGlu", + "AI_VECTOR_CORE" + ], + 0.41893292000000004 + ], + [ + [ + "RealDiv", + "AI_VECTOR_CORE" + ], + 0.3961361199999998 + ], + [ + [ + "RotaryPositionEmbedding", + "MIX_AIV" + ], + 0.33030809999999966 + ], + [ + [ + "RmsNorm", + "AI_VECTOR_CORE" + ], + 0.30692116000000014 + ], + [ + [ + "_rms_norm_indexed_scale_shift_kernel", + "AI_VECTOR_CORE" + ], + 0.28237123999999986 + ], + [ + [ + "AsStrided", + "AI_VECTOR_CORE" + ], + 0.25295204000000004 + ], + [ + [ + "_indexed_gate_kernel", + "AI_VECTOR_CORE" + ], + 0.22496807999999985 + ] + ] + } + }, + "external_kernel_csv_sha256": { + "diffusion_rank0": "d2798b1c83725c657258570c1ee62d2f3a56ceea49fa6a128db59aacdab30c47", + "diffusion_rank1": "a38453e868db648e5e6d66d18d9b8085743faa1699519240333b982619d64021", + "diffusion_rank2": "39968f30a7ecabcf882eddf119c36e190b66aab2a0e2c528bc44f78f2dc7cb97", + "diffusion_rank3": "e5e483aa7e0bef1b614d9f21a9f676743d29f47e08b09be67cc205ec907824f1" + }, + "interpretation": "Non-overlapped communication and dispatch gaps alone do not account for30percent of this diagnostic denoise span. These are observed intervals, not removable costs or a universal hardware lower bound." +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/fused-projection-followup-plan.json b/evidence/h3-ref2va-4x910b1-320/results/fused-projection-followup-plan.json new file mode 100644 index 000000000..966aa8e49 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/fused-projection-followup-plan.json @@ -0,0 +1,91 @@ +{ + "operator_plan": { + "scope": "Four-rank operator-only screen for TP4 row projections; prepared not launched", + "source": "Pinned torch_npu2.10 installed _op_plugin_docs.py npu_mm_all_reduce_base, and H3 RowParallelLinear projections", + "hypothesis": "Overlap row-projection matrix multiplication with SUM collective while retaining full BF16 computation", + "shapes": [ + [ + 82944, + 1792, + 5376 + ], + [ + 82944, + 3584, + 5376 + ] + ], + "baseline": "F.linear then HCCL all_reduce SUM", + "candidate": "npu_mm_all_reduce_base unquantized BF16, default comm_turn, one HCCL domain", + "hardware_constraint": "Four local910B1, operator requires supported HCCS all-mesh; reject execution errors without fallback or semantic substitution", + "warmups": 3, + "rounds": 5, + "order": "ABBA", + "metrics": "Per-sample maximum rank wall time after device synchronization; timing aggregation excluded", + "parity": "Exact, finite, max error and RMSE on each rank; no model promotion from synthetic timing alone", + "prohibited": "No quantization, reduced precision, sparse math or approximation" + }, + "operator_harness": { + "plan.json": "8f404508254c42ff481462901b3e5259e446a3accbdb96a48d64e7bd6c662b67", + "probe.py": "3485694142898fe5662d41578276545c48a14900f42d643fe8e2839ea0f5d1c1", + "run.sh": "c83930154752e699b0ef4aff5f3176a60f33f1a52fcde8fd1eb7fe61ba10492d" + }, + "topology_preflight": { + "source": "Read-only npu-smi info -t topo, 2026-11-03", + "result": "All distinct NPU pairs reported HCCS connectivity; satisfies documented mesh connectivity prerequisite, not operator execution qualification", + "device_identifiers": "Omitted from public summary", + "execution": "No operator executed in this preflight" + }, + "queue_revision": { + "scope": "Independent task dispatch queue screening; five-step adaptive ABBA only", + "source": "https://www.hiascend.com/document/detail/en/Pytorch/2610/apiref/ENV/docs/en/environment_variable_reference/TASK_QUEUE_ENABLE.md", + "observed_baseline": "Pinned image/container TASK_QUEUE_ENABLE=1; OMP_NUM_THREADS=1; ASCEND_LAUNCH_BLOCKING unset", + "hypothesis": "Move workspace management into second-level dispatch queue, reducing host dispatch gaps without changing model math", + "hardware": "Four local910B1 under one reservation", + "source_revision": "ce216014adb4c037dc15b3d49623e493ca3d3ac3", + "arms": { + "base0": 1, + "queue2a": 2, + "queue2b": 2, + "base1": 1 + }, + "order": [ + "base0", + "queue2a", + "queue2b", + "base1" + ], + "steps": 5, + "duration_s": 5, + "warmups": 1, + "measured": 1, + "same_settings": "SP4 TP1, textTP4, VAEtile4, DLO, BF16, OriginalLaser, seed0 and frozen input hashes", + "admission": "Continue second pair only if first clean pair candidate E2E at least3percent lower; otherwise retain incomplete ABBA as short screening without final rejection proof", + "quality": "Independent CPU scoring after model reservation ends; numerical scheduling parity must be measured", + "acceptance": "No30percent or losslessness claim from configuration documentation or this short screening", + "revision": "v2: unchanged model arms; a separate fused projection operator probe precedes this model campaign within one reservation. Original unstarted queue canceled prospectively after diagnostic overlap analysis." + }, + "queue_harness": { + "admit_second_pair.py": "c68f3c39632620be23b381b19259017128af76a85d81cf69bf510eb20182d558", + "campaign.sh": "ebb0ae149311c7185a5baf8143dbd98bda882ed7766fd499b7adec6b50bf8b2e", + "plan.json": "d50d15bd9c4425f08ba458818f67abfcdad7e15999f3a13ed256c6bf7f972600", + "run_client.py": "7a3e697077524c9729ebdae78a533feb55777718b0db72ac3735e5164444bcde", + "run_heldout.py": "489e3048120fa34a1c8d089053f45f1d4cda4fd6fdf1652457d079302f77eded", + "run_host.sh": "d4065b5b7b90ca8ab46cee8ae52d71605e8b002ef6586079b702c69923aaec5a", + "run_inner.sh": "a3f77d95f78af68aaf0c65e10b563835c6e8c084552cba909eeaf5583efb2012" + }, + "combined_launcher": { + "run_mm_then_queue.py": "e315fdcd4ff65b5576c7107cb75b8a7d8f1772ceb7e87289d4d20b64404d7199", + "mm-then-queue-campaign.sh": "a4836c2b71e139564d0c3427a682ca5e9b5e10fe67efafe69745814d6338a534", + "mm-allreduce-probe/manifest.json": "3372f5547080dce43cae06c554818d5c2f665f77951be1206cb475bb8bc3ac56", + "task-queue-screen-v2/manifest.json": "087ce472e86841f610e47c188a45950d30ff868d6684c7ef13f47432c95bd9a4" + }, + "prior_queue_cancellation": { + "reason": "Prospective reprioritization after interval analysis: execute fused projection probe before model queue A/B in one serial reservation", + "model_runs_started": false, + "original_harness_preserved": true, + "replacement": "run_mm_then_queue.py with task-queue-screen-v2; original mm follower terminated to prevent duplicate launch", + "target_achieved": false + }, + "state": "Replacement four-device reservation queued; neither fused projection probe nor queue model A/B executed yet; one reservation with serial stages and4h outer ceiling" +} diff --git a/tests/test_evidence_inventory.py b/tests/test_evidence_inventory.py index a6fb632d8..5e1d5939a 100644 --- a/tests/test_evidence_inventory.py +++ b/tests/test_evidence_inventory.py @@ -146,5 +146,5 @@ def test_checked_in_inventory(): result = validate_inventory(repo) assert result["errors"] == [] assert len(result["bundles"]) == 21 - assert result["checked_hashes"] == 461 + assert result["checked_hashes"] == 464 assert result["unavailable"] # Historical raw artifacts are not in this checkout. diff --git a/tools/evidence_inventory.json b/tools/evidence_inventory.json index 8e0e99f47..170d43488 100644 --- a/tools/evidence_inventory.json +++ b/tools/evidence_inventory.json @@ -51,6 +51,10 @@ { "path": "results/hybrid-negative-integrity.json", "schema": "bundle-sha256" + }, + { + "path": "results/critical-path-integrity.json", + "schema": "bundle-sha256" } ], "external": [ From b54dc33c8f0555b0889f027739b1cacfd4ac38dd Mon Sep 17 00:00:00 2001 From: amy-why-3459 Date: Tue, 3 Nov 2026 16:55:55 +0800 Subject: [PATCH 14/17] Record FIA v2 negative screen and prospective queue revision Agent-assisted-by: Codex Signed-off-by: amy-why-3459 --- .../results/fia-v2-integrity.json | 4 + .../results/fia-v2-negative.json | 123 ++++++++++++++++++ .../queue-v3-prospective-revision.json | 55 ++++++++ tests/test_evidence_inventory.py | 2 +- tools/evidence_inventory.json | 4 + 5 files changed, 187 insertions(+), 1 deletion(-) create mode 100644 evidence/h3-ref2va-4x910b1-320/results/fia-v2-integrity.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/fia-v2-negative.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/queue-v3-prospective-revision.json diff --git a/evidence/h3-ref2va-4x910b1-320/results/fia-v2-integrity.json b/evidence/h3-ref2va-4x910b1-320/results/fia-v2-integrity.json new file mode 100644 index 000000000..f9559ec33 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/fia-v2-integrity.json @@ -0,0 +1,4 @@ +{ + "results/fia-v2-negative.json": "c49769feaa7d60ac891359885b9a04a9d23c1b56b2117bf68afc4f578708c3b4", + "results/queue-v3-prospective-revision.json": "3ff66e89db0498106ba21ee99c99eb5041b4aa12d8e9f680548ef383ea5590e3" +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/fia-v2-negative.json b/evidence/h3-ref2va-4x910b1-320/results/fia-v2-negative.json new file mode 100644 index 000000000..386db7c00 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/fia-v2-negative.json @@ -0,0 +1,123 @@ +{ + "result": { + "shape": [ + 1, + 82944, + 14, + 128 + ], + "results": [ + { + "layout": "BNSD", + "exact": false, + "finite": true, + "rmse": 1.015155157801928e-05, + "max_abs": 0.000244140625, + "samples_ms": { + "laser": [ + 205.74555918574333, + 205.79206943511963, + 205.13240341097116, + 205.32594807446003, + 205.72339836508036, + 206.46710880100727, + 205.71401715278625, + 206.80509693920612, + 205.89589327573776, + 206.51047956198454 + ], + "BNSD": [ + 305.9376934543252, + 305.43272010982037, + 306.2054207548499, + 304.99286856502295, + 307.80734214931726, + 305.1703432574868, + 305.2462665364146, + 305.47231063246727, + 305.9161836281419, + 307.32628982514143 + ] + }, + "medians_ms": { + "laser": 205.76881431043148, + "BNSD": 305.6942471303046 + } + }, + { + "layout": "BSND", + "exact": false, + "finite": true, + "rmse": 1.015155157801928e-05, + "max_abs": 0.000244140625, + "samples_ms": { + "laser": [ + 206.7936658859253, + 206.5479401499033, + 205.8420917019248, + 206.9407505914569, + 205.88553324341774, + 205.11812344193459, + 206.4286069944501, + 206.60480111837387, + 206.84279687702656, + 206.2547318637371 + ], + "BSND": [ + 312.1731160208583, + 315.87875355035067, + 312.876014970243, + 314.0194145962596, + 314.8815566673875, + 316.0558082163334, + 313.8117492198944, + 313.7896480038762, + 314.11886774003506, + 314.2176205292344 + ] + }, + "medians_ms": { + "laser": 206.4882735721767, + "BSND": 314.0691411681473 + } + } + ], + "scope": "Synthetic attention plus output layout materialization; not E2E or full model quality", + "target_achieved": false + }, + "frozen_plan": { + "scope": "One-NPU synthetic screening, prepared not launched", + "source": "Pinned torch_npu2.10 _op_plugin_docs.py npu_fused_infer_attention_score_v2; separate API from previously rejected FIA v1", + "hypothesis": "Newer dense inference attention path and BSND-native layout may reduce dominant attention cost", + "shape": [ + 1, + 82944, + 14, + 128 + ], + "baseline": "Original Laser via head_first=False on contiguousBSND inputs, with final BSND contiguous output", + "candidates": [ + "FIA_v2 BNSD", + "FIA_v2 BSND" + ], + "precision": "SameBF16 input toFP16 conversion andFP16 output toBF16 as baseline; inner_precise0; noquantization; fullwindow; sparse_mode0", + "warmups": 3, + "rounds": 5, + "order": "ABBA", + "quality": "Exact, finite, max error, RMSE; synthetic parity is not model qualification", + "timing_scope": "Includes conversions and final BSND contiguous output materialization on both arms", + "status": "Prepared only; no performance prediction" + }, + "harness": { + "plan.json": "e2102e4f93ba2a478709708833b9d1993e53a7eb3889476db7748394af58826d", + "probe.py": "e52397d683d5d3e6810a7b16478203bee453ae0ea25b2d6a36f00a496263909b", + "run.sh": "0de0258f19c480c039df6cd5e33e7ca215c3f8806f0c678cf4d552a5e64c15e2" + }, + "artifacts": { + "result.json": "e855969087a57d017a6acf58b1dfd5a5b7b8777ace016cbe2e9b1ed69e2c0a83", + "launch.log": "22a4aa8b6cdea9da299e1d15340369c093e2c916ee74eefd5da0380d179e7de8", + "job.exit_code": "9a271f2a916b0b6ee6cecb2426f0b3206ef074578be55d9bc94f6f3fe3ab86aa" + }, + "job_exit": 0, + "decision": "Rejected: slower and nonexact; no model promotion or E2E gain" +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/queue-v3-prospective-revision.json b/evidence/h3-ref2va-4x910b1-320/results/queue-v3-prospective-revision.json new file mode 100644 index 000000000..c03e6d87b --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/queue-v3-prospective-revision.json @@ -0,0 +1,55 @@ +{ + "state": "Queued, no four-device experiment started as of2026-11-03T08:55Z", + "reason": "Prior unstarted v2 reservation canceled prospectively to execute one-device FIA v2 screen first; that screen completed and was rejected", + "earlier_plans": "Retained immutable; no measured observations discarded", + "plan": { + "scope": "Independent task dispatch queue screening; five-step adaptive ABBA only", + "source": "https://www.hiascend.com/document/detail/en/Pytorch/2610/apiref/ENV/docs/en/environment_variable_reference/TASK_QUEUE_ENABLE.md", + "observed_baseline": "Pinned image/container TASK_QUEUE_ENABLE=1; OMP_NUM_THREADS=1; ASCEND_LAUNCH_BLOCKING unset", + "hypothesis": "Move workspace management into second-level dispatch queue, reducing host dispatch gaps without changing model math", + "hardware": "Four local910B1 under one reservation", + "source_revision": "ce216014adb4c037dc15b3d49623e493ca3d3ac3", + "arms": { + "base0": 1, + "queue2a": 2, + "queue2b": 2, + "base1": 1 + }, + "order": [ + "base0", + "queue2a", + "queue2b", + "base1" + ], + "steps": 5, + "duration_s": 5, + "warmups": 1, + "measured": 1, + "same_settings": "SP4 TP1, textTP4, VAEtile4, DLO, BF16, OriginalLaser, seed0 and frozen input hashes", + "admission": "Continue second pair only if first clean pair candidate E2E at least3percent lower; otherwise retain incomplete ABBA as short screening without final rejection proof", + "quality": "Independent CPU scoring after model reservation ends; numerical scheduling parity must be measured", + "acceptance": "No30percent or losslessness claim from configuration documentation or this short screening", + "revision": "v3: unchanged model arms; original and v2 reservations canceled before execution, a separate one-device FIA v2 probe completed and was rejected before this requeue. Fused projection probe still precedes model A/B within one four-device reservation." + }, + "harness": { + "admit_second_pair.py": "c68f3c39632620be23b381b19259017128af76a85d81cf69bf510eb20182d558", + "campaign.sh": "c661f596b0d4c29bbbad1926d1520178fd2146f1b8be3060ec079c5fcc427c86", + "plan.json": "d3762ea18b4d0188ca22d87a4b5bc6944c9dcd7e4f97417effb22d1b565eea23", + "run_client.py": "7a3e697077524c9729ebdae78a533feb55777718b0db72ac3735e5164444bcde", + "run_heldout.py": "489e3048120fa34a1c8d089053f45f1d4cda4fd6fdf1652457d079302f77eded", + "run_host.sh": "8a8db40ce04c167faf55e49f57c2d147621eb1528c078ea8531875ff7a86f75d", + "run_inner.sh": "7d82eb05cb6c8220b5dc46ef5ae890a0cb996dbd8d20c3fcc2dfb77e240d0d26" + }, + "outer_harness": { + "run_mm_then_queue_v3.py": "b824dd924ab7d543bb898fc6b6a7c6c0be15cf0c211b7b8fde8750709c6f2ead", + "mm-then-queue-v3-campaign.sh": "b0293ddeadf0b5e13bbb5c0ed7c9b310beb319ca389ad50a48537eb1cfc2d5d2", + "mm-allreduce-probe/manifest.json": "3372f5547080dce43cae06c554818d5c2f665f77951be1206cb475bb8bc3ac56", + "task-queue-screen-v3/manifest.json": "73e1d472f9fa69a712afcdceaeadc1fc1a312db499adb5f57239abd7f5c95082" + }, + "order": [ + "fused projection operator probe", + "task queue model adaptive ABBA if operator exits0", + "CPU quality after release" + ], + "target_achieved": false +} diff --git a/tests/test_evidence_inventory.py b/tests/test_evidence_inventory.py index 5e1d5939a..e305f49f4 100644 --- a/tests/test_evidence_inventory.py +++ b/tests/test_evidence_inventory.py @@ -146,5 +146,5 @@ def test_checked_in_inventory(): result = validate_inventory(repo) assert result["errors"] == [] assert len(result["bundles"]) == 21 - assert result["checked_hashes"] == 464 + assert result["checked_hashes"] == 466 assert result["unavailable"] # Historical raw artifacts are not in this checkout. diff --git a/tools/evidence_inventory.json b/tools/evidence_inventory.json index 170d43488..259c66c74 100644 --- a/tools/evidence_inventory.json +++ b/tools/evidence_inventory.json @@ -55,6 +55,10 @@ { "path": "results/critical-path-integrity.json", "schema": "bundle-sha256" + }, + { + "path": "results/fia-v2-integrity.json", + "schema": "bundle-sha256" } ], "external": [ From df3723cd441c772c8ebf6c2eca1f62b8a6efbf9c Mon Sep 17 00:00:00 2001 From: amy-why-3459 Date: Tue, 3 Nov 2026 17:22:13 +0800 Subject: [PATCH 15/17] Record fused projection screening and exact Laser layout candidate Agent-assisted-by: Codex Signed-off-by: amy-why-3459 --- .../patch/laser-fp16-layout-candidate.patch | 152 +++++++ .../results/laser-layout-implementation.json | 15 + .../results/laser-layout-operator.json | 238 ++++++++++ .../results/laser-layout-parity-plan.json | 29 ++ .../results/mm-fused-operator.json | 426 ++++++++++++++++++ .../results/operator-followup-integrity.json | 7 + tests/test_evidence_inventory.py | 2 +- tools/evidence_inventory.json | 4 + 8 files changed, 872 insertions(+), 1 deletion(-) create mode 100644 evidence/h3-ref2va-4x910b1-320/patch/laser-fp16-layout-candidate.patch create mode 100644 evidence/h3-ref2va-4x910b1-320/results/laser-layout-implementation.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/laser-layout-operator.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/laser-layout-parity-plan.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/mm-fused-operator.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/operator-followup-integrity.json diff --git a/evidence/h3-ref2va-4x910b1-320/patch/laser-fp16-layout-candidate.patch b/evidence/h3-ref2va-4x910b1-320/patch/laser-fp16-layout-candidate.patch new file mode 100644 index 000000000..89a6005b1 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/patch/laser-fp16-layout-candidate.patch @@ -0,0 +1,152 @@ +diff --git a/docs/user_guide/diffusion/attention_backends/dense_backends.md b/docs/user_guide/diffusion/attention_backends/dense_backends.md +index 2cb7019be..53535e65e 100644 +--- a/docs/user_guide/diffusion/attention_backends/dense_backends.md ++++ b/docs/user_guide/diffusion/attention_backends/dense_backends.md +@@ -31,6 +31,21 @@ when a compatible package is installed. + vllm-omni serve --diffusion-attention-backend FLASH_ATTN + ``` + ++### Experimental Ascend Laser input layout ++ ++For the packed-prefix BF16 path with `MINDIE_SD_FA_TYPE=ascend_laser_attention`, ++`--additional-config '{"npu_laser_fp16_layout":true}'` requests a contiguous ++head-first FP16 cast before calling the public MindIE attention API. This ++combines dtype conversion with layout materialization while preserving the ++FP16 input and BF16 output conversion boundaries of MindIE-SD 3.1 Laser. ++Model-provided input scaling and valid-prefix slicing remain in effect. ++ ++The option defaults to false. It is intended for the legacy FP16 Laser path; ++it does not preserve the arithmetic of newer native-BF16 Laser implementations. ++Synthetic operator parity is insufficient to establish model quality or ++end-to-end speedup. Validate the installed MindIE version and actual workload ++before enabling it. ++ + ### FlashAttention 4 on Blackwell + + Install the optional CUDA 13 extra: +diff --git a/tests/diffusion/attention/test_flash_attn.py b/tests/diffusion/attention/test_flash_attn.py +index 1da5894cc..1c6798ea3 100644 +--- a/tests/diffusion/attention/test_flash_attn.py ++++ b/tests/diffusion/attention/test_flash_attn.py +@@ -1373,6 +1373,68 @@ def test_prefix_kv_slice_no_scaling_without_factor(monkeypatch): + torch.testing.assert_close(out, torch.ones(1, 8, 2, 4)) + + ++@pytest.mark.cpu ++@pytest.mark.parametrize("input_scale", [1.0, 256.0]) ++@pytest.mark.parametrize("dtype", [torch.bfloat16, torch.float32]) ++def test_laser_fp16_layout_preserves_conversion_boundaries(monkeypatch, input_scale, dtype): ++ monkeypatch.setenv("MINDIE_SD_FA_TYPE", "ascend_laser_attention") ++ calls = [] ++ ++ def reference_adapter(query, key, value, *, head_first=False, **kwargs): ++ calls.append((query, key, value, head_first, kwargs)) ++ output_dtype = query.dtype ++ tensors = (query, key, value) if head_first else (x.transpose(1, 2) for x in (query, key, value)) ++ q, k, v = (x.to(torch.float16).contiguous() for x in tensors) ++ # A deterministic stand-in for the unchanged native kernel. This test ++ # checks the real adapter's dtype/layout/range boundaries, not Laser. ++ out = q.float() * 1.3 + k.float().mean(2, keepdim=True) + v.float().mean(2, keepdim=True) ++ out = out.to(torch.float16).to(output_dtype) ++ return out if head_first else out.transpose(1, 2) ++ ++ _fake_mindiesd(monkeypatch, attention_forward=reference_adapter) ++ impl = _npu_impl() ++ q, k, v = (torch.randn(1, 16, 2, 4, dtype=dtype)[:, ::2] for _ in range(3)) ++ cu = torch.tensor([0, 5, 8], dtype=torch.int32) ++ extra = { ++ "cu_seqlens_q": cu, ++ "cu_seqlens_k": cu, ++ "max_seqlen_q": 5, ++ "max_seqlen_k": 5, ++ "laser_input_scale": input_scale, ++ } ++ baseline = impl._forward_prefix_kv_slice_npu(q, k, v, extra) ++ impl.npu_laser_fp16_layout = True ++ candidate = impl._forward_prefix_kv_slice_npu(q, k, v, extra) ++ assert candidate.dtype == dtype and candidate.shape == q.shape ++ assert torch.equal(baseline, candidate) ++ cq, ck, cv, head_first, kwargs = calls[-1] ++ assert head_first is (dtype == torch.bfloat16) ++ if head_first: ++ assert all(x.is_contiguous() and x.dtype == torch.float16 for x in (cq, ck, cv)) ++ assert cq.shape == (1, 2, 8, 4) and ck.shape == cv.shape == (1, 2, 5, 4) ++ assert kwargs["attn_mask"] is None ++ assert kwargs["scale"] == 0.5 * input_scale**2 ++ ++ ++@pytest.mark.cpu ++def test_laser_fp16_layout_requires_boolean_config(monkeypatch): ++ from vllm_omni.diffusion.attention.backends import flash_attn ++ ++ monkeypatch.setattr( ++ flash_attn, ++ "get_current_diffusion_config_or_none", ++ lambda: SimpleNamespace(additional_config={"npu_laser_fp16_layout": "false"}), ++ ) ++ with pytest.raises(ValueError, match="must be a boolean"): ++ _npu_impl() ++ monkeypatch.setattr( ++ flash_attn, ++ "get_current_diffusion_config_or_none", ++ lambda: SimpleNamespace(additional_config={"npu_laser_fp16_layout": True}), ++ ) ++ assert _npu_impl().npu_laser_fp16_layout is True ++ ++ + # --- Test group E: NPU piecewise block-causal attention ---------------------- + # + # ``forward_fa_npu`` must honour ``full_attn_spans`` the way ``forward_cuda`` +diff --git a/vllm_omni/diffusion/attention/backends/flash_attn.py b/vllm_omni/diffusion/attention/backends/flash_attn.py +index 87cb63121..cd9b95bf4 100644 +--- a/vllm_omni/diffusion/attention/backends/flash_attn.py ++++ b/vllm_omni/diffusion/attention/backends/flash_attn.py +@@ -281,6 +281,10 @@ class FlashAttentionImpl(AttentionImpl[AttentionMetadata]): + self._kernel_variant = "fa4" if IS_FLASH_ATTN_4 else "aiter" if IS_AITER else None + cfg = get_current_diffusion_config_or_none() + self.fa_deterministic = bool(getattr(cfg, "fa_deterministic", False)) if cfg is not None else False ++ additional = getattr(cfg, "additional_config", None) or {} ++ self.npu_laser_fp16_layout = additional.get("npu_laser_fp16_layout", False) ++ if not isinstance(self.npu_laser_fp16_layout, bool): ++ raise ValueError("npu_laser_fp16_layout must be a boolean") + if backend_kwargs: + logger.warning("FlashAttentionImpl ignoring backend_kwargs: %s", list(backend_kwargs.keys())) + +@@ -1313,6 +1317,7 @@ class FlashAttentionImpl(AttentionImpl[AttentionMetadata]): + """ + self._warn_fa_deterministic_non_dense("piecewise-npu") + logger.debug("Using piecewise NPU attention for mixed causal/full mask") ++ assert attn_metadata.full_attn_spans is not None + return piecewise_attn( + query, + key, +@@ -1458,6 +1463,29 @@ class FlashAttentionImpl(AttentionImpl[AttentionMetadata]): + def _postprocess(out: torch.Tensor) -> torch.Tensor: + return out * input_scale if preserve_input_range else out + ++ if self.npu_laser_fp16_layout and query.dtype == torch.bfloat16: ++ # Preserve the MindIE-SD 3.1 Laser FP16 conversion boundaries, ++ # while materializing BNSD during the cast instead of copying ++ # once for dtype and again for contiguous layout. Keep opt-in: ++ # newer native-BF16 Laser implementations have different math. ++ output_dtype = query.dtype ++ q, k, v = ( ++ tensor.transpose(1, 2).to(dtype=torch.float16, memory_format=torch.contiguous_format) ++ for tensor in (query, key, value) ++ ) ++ out = attention_forward( ++ q, ++ k, ++ v, ++ attn_mask=None, ++ head_first=True, ++ opt_mode="manual", ++ op_type="ascend_laser_attention", ++ layout=layout, ++ scale=scale, ++ ) ++ return _postprocess(out.to(output_dtype).transpose(1, 2)) ++ + return _postprocess( + attention_forward( + query, diff --git a/evidence/h3-ref2va-4x910b1-320/results/laser-layout-implementation.json b/evidence/h3-ref2va-4x910b1-320/results/laser-layout-implementation.json new file mode 100644 index 000000000..8abc8cb76 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/laser-layout-implementation.json @@ -0,0 +1,15 @@ +{ + "candidate_revision": "8cbe1a1dd97d965c41c7f8904303243c36a66931", + "baseline_revision": "ce216014adb4c037dc15b3d49623e493ca3d3ac3", + "status": "Local isolated candidate only; not yet included in engine PR or model tested", + "source": "Pinned MindIE-SD3.1 AscendLaserAttention.la_preprocess_input preserves transpose strides during cast, then copies to contiguous; explicit Tensor.to memory_format combines that preparation", + "installed_source_sha256": "8a971c30fc85c38882886298de35492f8ed63ece114fa39cbcc515c5e2aae12d", + "image": "sha256:7fc6c73bd19a6ef4ee8d6048009972234796a1fc1bd3067168a425343cc476f7", + "compatibility": "Opt-in false by default; preserves legacy FP16 roundtrip, not newer native-BF16 Laser arithmetic", + "cpu_tests": "117 passed,7deselected; adapters only, not native numerical validation", + "cpu_log_sha256": "3061400fedb83d2bf8779b4615295d42ca61c648e1437a251c8eed0a98a29745", + "precommit": "All applicable checks passed on v3; initial ruff formatting and existing piecewise Optional type error corrected by an invariant assertion", + "precommit_log_sha256": "2bde30993724d3446a64e2653be46fa6989ed90c2d8a6d1e58e825c1f95630de", + "timing_isolation": "Commit-time automatic check rerun was paused before base0 measured request and resumed after its container exit; no CPU scoring or profiling overlapped measurement", + "target_achieved": false +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/laser-layout-operator.json b/evidence/h3-ref2va-4x910b1-320/results/laser-layout-operator.json new file mode 100644 index 000000000..f07df2a88 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/laser-layout-operator.json @@ -0,0 +1,238 @@ +{ + "direct_kernel": { + "scope": "Synthetic operator screening with H3 power-of-two range protection; not E2E or model parity", + "results": [ + { + "shape": [ + 1, + 7168, + 56, + 128 + ], + "correctness": { + "exact": true, + "baseline_repeat_exact": true, + "finite": true, + "max_abs": 0.0, + "rmse": 0.0 + }, + "samples_ms": { + "baseline": [ + 9.854476898908615, + 9.834175929427147, + 9.79092437773943, + 9.742514230310917, + 9.776316583156586, + 9.771064855158329, + 9.77555476129055, + 9.788784198462963, + 9.799236431717873, + 9.757215157151222 + ], + "cast_layout": [ + 8.530852384865284, + 8.644885383546352, + 8.570043370127678, + 8.491742424666882, + 8.510331623256207, + 8.513151668012142, + 8.518451824784279, + 8.516862988471985, + 8.496102876961231, + 8.522122167050838 + ] + }, + "medians_ms": { + "baseline": 9.782550390809774, + "cast_layout": 8.517657406628132 + } + }, + { + "shape": [ + 1, + 82944, + 14, + 128 + ], + "correctness": { + "exact": true, + "baseline_repeat_exact": true, + "finite": true, + "max_abs": 0.0, + "rmse": 0.0 + }, + "samples_ms": { + "baseline": [ + 208.24792608618736, + 204.96544148772955, + 207.66236074268818, + 208.24297610670328, + 207.45627488940954, + 206.77380822598934, + 206.74585737287998, + 206.84252958744764, + 204.79457546025515, + 208.56887474656105 + ], + "cast_layout": [ + 205.189885571599, + 205.4846929386258, + 204.60172090679407, + 201.26039441674948, + 204.10964731127024, + 205.20443748682737, + 202.72794272750616, + 202.45688501745462, + 203.74196860939264, + 201.96919236332178 + ] + }, + "medians_ms": { + "baseline": 207.1494022384286, + "cast_layout": 203.92580796033144 + } + } + ], + "target_achieved": false + }, + "public_api": { + "scope": "Synthetic operator screening with H3 power-of-two range protection; not E2E or model parity", + "results": [ + { + "shape": [ + 1, + 7168, + 56, + 128 + ], + "correctness": { + "exact": true, + "baseline_repeat_exact": true, + "finite": true, + "max_abs": 0.0, + "rmse": 0.0 + }, + "samples_ms": { + "baseline": [ + 9.922059252858162, + 9.853486903011799, + 9.81677696108818, + 9.83054656535387, + 9.747853502631187, + 9.783096611499786, + 9.84145700931549, + 9.830947034060955, + 9.845866821706295, + 9.805765934288502 + ], + "cast_layout": [ + 8.522382006049156, + 8.459371514618397, + 8.531883358955383, + 8.571702986955643, + 8.525983430445194, + 8.516842499375343, + 8.567123673856258, + 8.523962460458279, + 8.566753938794136, + 8.619215339422226 + ] + }, + "medians_ms": { + "baseline": 9.830746799707413, + "cast_layout": 8.528933394700289 + } + }, + { + "shape": [ + 1, + 82944, + 14, + 128 + ], + "correctness": { + "exact": true, + "baseline_repeat_exact": true, + "finite": true, + "max_abs": 0.0, + "rmse": 0.0 + }, + "samples_ms": { + "baseline": [ + 207.88913685828447, + 207.878396846354, + 208.19944515824318, + 207.34548289328814, + 204.43772803992033, + 207.66261219978333, + 203.84030137211084, + 208.46030209213495, + 208.08132272213697, + 207.4988279491663 + ], + "cast_layout": [ + 203.95177323371172, + 202.5738973170519, + 202.17496808618307, + 200.805451720953, + 204.22998256981373, + 201.39254722744226, + 204.72058467566967, + 203.91780324280262, + 204.4507684186101, + 205.00713121145964 + ] + }, + "medians_ms": { + "baseline": 207.77050452306867, + "cast_layout": 203.93478823825717 + } + } + ], + "target_achieved": false + }, + "direct_harness": { + "plan.json": "474cd7d0839818da775688f16df2f93a38f00221f83128023aa91ea43f347a25", + "probe.py": "64a08c74b147773dac4e73bcbf6a4482bd94309a80ef635be1c9e236d30489b6", + "run.sh": "0e48d682c3280b7e4328001ab7f9a32ec3319591f80dfbd82c19fb0a7be7259e" + }, + "public_harness": { + "plan.json": "b7022f7c3c86cd52decd5ababb76321ccadf87e8a129fce8a0e9788fafeb5fde", + "probe.py": "6b2ff8f49ed92cf71e7394fe87d22c116b7111804c0417371faa7c6a839ea7d2", + "run.sh": "59a06d1fda4764aa16ced24a325bd30c67777bbca46ff08fbd4a3641a1fb0ccc" + }, + "public_plan": { + "scope": "Prepared public-API followup, one reserved NPU synthetic screening", + "source": "Pinned image MindIE-SD3.1 AscendLaserAttention.la_preprocess_input plus PyTorch Tensor.to contiguous memory_format; original H3 flash_attn.py range protection", + "hypothesis": "Avoid separate dtype-preserving-stride copy then layout materialization, retaining original Laser arithmetic", + "shapes": [ + [ + 1, + 7168, + 56, + 128 + ], + [ + 1, + 82944, + 14, + 128 + ] + ], + "unchanged": "BF16 inputs divided by256 before FP16 conversion, full dense Laser highprecisionTrue, same scale and BF16 output before multiplying256; no quantization or sparse approximation", + "candidate": "Transpose view plus explicit contiguous FP16 cast, then same PUBLIC attention_forward head_first=True; restore BF16 BSND before output scaling", + "baseline": "Original attention_forward manual Laser path", + "timing_scope": "Complete attention including input scaling, conversions, layout and contiguous output in both arms", + "warmups": 3, + "rounds": 5, + "order": "ABBA", + "acceptance": "Exact synthetic parity is only first gate; positive timing still requires real activation parity and model A/B", + "estimated_benefit": "Unknown; no30percent prediction" + }, + "jobs_exit": [ + 0, + 0 + ], + "resource_scope": "Each on one reserved device; four-device campaign remained queued throughout both operator runs. No overlap with its model timing.", + "decision": "Exact finite synthetic outputs and small operator improvement; proceed to real-activation diagnostic, not final gain acceptance" +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/laser-layout-parity-plan.json b/evidence/h3-ref2va-4x910b1-320/results/laser-layout-parity-plan.json new file mode 100644 index 000000000..da7a30e38 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/laser-layout-parity-plan.json @@ -0,0 +1,29 @@ +{ + "plan": { + "scope": "Real-activation paired native attention diagnostic, timing excluded", + "source_revision": "8cbe1a1dd97d965c41c7f8904303243c36a66931", + "baseline_path": "same source with npu_laser_fp16_layout false for each reference call", + "candidate_path": "npu_laser_fp16_layout true via public MindIE API", + "hardware": "4 local910B1 under reservation after queue campaign including CPU scoring completes", + "workload": "5s5steps,seed0,onewarmup/onemeasured; SP4TP1textTP4VAEtile4DLOBF16originalLaser", + "precision": "Original BF16/FP16 roundtrip boundaries and power-of-two scaling; full dense math", + "coverage": "Four worker files, ranks0..3, >=500 main attention comparisons per rank across two requests; all exact and finite", + "mismatch": "Fail closed; compare one repeated baseline to diagnose baseline instability if candidate differs", + "timing": "Duplicate attention and synchronizing equality checks make all request timings ineligible for performance claims", + "promotion": "No automatic30percent claim; clean uninstrumented matched model A/B still required", + "source": "Local Laser input-copy audit against pinned MindIE-SD3.1; operator receipts laser-cast-layout-probe and laser-public-layout-probe", + "status_at_freeze": "Prepared, not launched" + }, + "harness": { + "campaign.sh": "1583f99d65944196a7f86456ce78d5eb9e5f56a7c5234d04c1aefbcbc2e1ffc1", + "logging_entry_laser_parity.py": "1872b7a984766571e5036182f9e64e1a00493b672c66d63ec0af7a868b9d8aa5", + "plan.json": "e6c99c5ccf8d2113f479057f3192ae221433fc3efa6b7633849c32191122d73c", + "run_client.py": "7a3e697077524c9729ebdae78a533feb55777718b0db72ac3735e5164444bcde", + "run_heldout.py": "489e3048120fa34a1c8d089053f45f1d4cda4fd6fdf1652457d079302f77eded", + "run_host.sh": "d4cf65d420a1a8c8533dc7d8182846e716a53b6b73a7d041ffe7f92bf28042ae", + "run_inner.sh": "4e560fa9704983cb561778b8e757077859a4b64c3392066ad104d8c8ba806788", + "verify_parity.py": "94a6501aaa8ac31c7b0a0054e853725590524dbcabd4133cd6ae81212d0a8f4c" + }, + "follower_sha256": "6e7e281e22f7980ae3ff1a7de5fd2cadf5dffd367935e882d64b31e205acf183", + "state": "Follower waits for preceding queue A/B and CPU scoring; no diagnostic reservation yet" +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/mm-fused-operator.json b/evidence/h3-ref2va-4x910b1-320/results/mm-fused-operator.json new file mode 100644 index 000000000..d556f361d --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/mm-fused-operator.json @@ -0,0 +1,426 @@ +{ + "result": { + "scope": "Four-rank synthetic operator screening; not model E2E or quality", + "rank_results": { + "0": [ + { + "projection": "attention_output", + "x_shape": [ + 82944, + 1792 + ], + "weight_shape": [ + 5376, + 1792 + ], + "correctness": { + "exact": false, + "finite": true, + "max_abs": 0.0625, + "rmse": 0.005227972753345966 + }, + "samples_ms_max_rank": { + "baseline": [ + 35.71480178833008, + 35.558998107910156, + 35.30302047729492, + 34.54096984863281, + 35.69428253173828, + 36.28462600708008, + 34.55186080932617, + 34.31361770629883, + 36.21543502807617, + 34.75422668457031 + ], + "fused": [ + 29.00004768371582, + 29.11380958557129, + 29.293964385986328, + 29.280134201049805, + 29.10198974609375, + 29.244884490966797, + 30.05089569091797, + 28.89644432067871, + 28.790943145751953, + 29.138561248779297 + ] + }, + "medians_ms_max_rank": { + "baseline": 35.43100929260254, + "fused": 29.126185417175293 + } + }, + { + "projection": "ffn_output", + "x_shape": [ + 82944, + 3584 + ], + "weight_shape": [ + 5376, + 3584 + ], + "correctness": { + "exact": false, + "finite": true, + "max_abs": 0.125, + "rmse": 0.007550136186182499 + }, + "samples_ms_max_rank": { + "baseline": [ + 41.45832443237305, + 39.80379867553711, + 41.706878662109375, + 39.84878921508789, + 39.23906326293945, + 40.6806526184082, + 40.00970458984375, + 39.12171173095703, + 39.26765441894531, + 40.694671630859375 + ], + "fused": [ + 29.246204376220703, + 29.3342342376709, + 29.026268005371094, + 29.29714584350586, + 29.55521011352539, + 30.19850730895996, + 29.213891983032227, + 28.91681480407715, + 28.96112632751465, + 28.9919376373291 + ] + }, + "medians_ms_max_rank": { + "baseline": 39.92924690246582, + "fused": 29.230048179626465 + } + } + ], + "1": [ + { + "projection": "attention_output", + "x_shape": [ + 82944, + 1792 + ], + "weight_shape": [ + 5376, + 1792 + ], + "correctness": { + "exact": false, + "finite": true, + "max_abs": 0.0625, + "rmse": 0.005227972753345966 + }, + "samples_ms_max_rank": { + "baseline": [ + 35.71480178833008, + 35.558998107910156, + 35.30302047729492, + 34.54096984863281, + 35.69428253173828, + 36.28462600708008, + 34.55186080932617, + 34.31361770629883, + 36.21543502807617, + 34.75422668457031 + ], + "fused": [ + 29.00004768371582, + 29.11380958557129, + 29.293964385986328, + 29.280134201049805, + 29.10198974609375, + 29.244884490966797, + 30.05089569091797, + 28.89644432067871, + 28.790943145751953, + 29.138561248779297 + ] + }, + "medians_ms_max_rank": { + "baseline": 35.43100929260254, + "fused": 29.126185417175293 + } + }, + { + "projection": "ffn_output", + "x_shape": [ + 82944, + 3584 + ], + "weight_shape": [ + 5376, + 3584 + ], + "correctness": { + "exact": false, + "finite": true, + "max_abs": 0.125, + "rmse": 0.007550136186182499 + }, + "samples_ms_max_rank": { + "baseline": [ + 41.45832443237305, + 39.80379867553711, + 41.706878662109375, + 39.84878921508789, + 39.23906326293945, + 40.6806526184082, + 40.00970458984375, + 39.12171173095703, + 39.26765441894531, + 40.694671630859375 + ], + "fused": [ + 29.246204376220703, + 29.3342342376709, + 29.026268005371094, + 29.29714584350586, + 29.55521011352539, + 30.19850730895996, + 29.213891983032227, + 28.91681480407715, + 28.96112632751465, + 28.9919376373291 + ] + }, + "medians_ms_max_rank": { + "baseline": 39.92924690246582, + "fused": 29.230048179626465 + } + } + ], + "2": [ + { + "projection": "attention_output", + "x_shape": [ + 82944, + 1792 + ], + "weight_shape": [ + 5376, + 1792 + ], + "correctness": { + "exact": false, + "finite": true, + "max_abs": 0.0625, + "rmse": 0.005227972753345966 + }, + "samples_ms_max_rank": { + "baseline": [ + 35.71480178833008, + 35.558998107910156, + 35.30302047729492, + 34.54096984863281, + 35.69428253173828, + 36.28462600708008, + 34.55186080932617, + 34.31361770629883, + 36.21543502807617, + 34.75422668457031 + ], + "fused": [ + 29.00004768371582, + 29.11380958557129, + 29.293964385986328, + 29.280134201049805, + 29.10198974609375, + 29.244884490966797, + 30.05089569091797, + 28.89644432067871, + 28.790943145751953, + 29.138561248779297 + ] + }, + "medians_ms_max_rank": { + "baseline": 35.43100929260254, + "fused": 29.126185417175293 + } + }, + { + "projection": "ffn_output", + "x_shape": [ + 82944, + 3584 + ], + "weight_shape": [ + 5376, + 3584 + ], + "correctness": { + "exact": false, + "finite": true, + "max_abs": 0.125, + "rmse": 0.007550136186182499 + }, + "samples_ms_max_rank": { + "baseline": [ + 41.45832443237305, + 39.80379867553711, + 41.706878662109375, + 39.84878921508789, + 39.23906326293945, + 40.6806526184082, + 40.00970458984375, + 39.12171173095703, + 39.26765441894531, + 40.694671630859375 + ], + "fused": [ + 29.246204376220703, + 29.3342342376709, + 29.026268005371094, + 29.29714584350586, + 29.55521011352539, + 30.19850730895996, + 29.213891983032227, + 28.91681480407715, + 28.96112632751465, + 28.9919376373291 + ] + }, + "medians_ms_max_rank": { + "baseline": 39.92924690246582, + "fused": 29.230048179626465 + } + } + ], + "3": [ + { + "projection": "attention_output", + "x_shape": [ + 82944, + 1792 + ], + "weight_shape": [ + 5376, + 1792 + ], + "correctness": { + "exact": false, + "finite": true, + "max_abs": 0.0625, + "rmse": 0.005227972753345966 + }, + "samples_ms_max_rank": { + "baseline": [ + 35.71480178833008, + 35.558998107910156, + 35.30302047729492, + 34.54096984863281, + 35.69428253173828, + 36.28462600708008, + 34.55186080932617, + 34.31361770629883, + 36.21543502807617, + 34.75422668457031 + ], + "fused": [ + 29.00004768371582, + 29.11380958557129, + 29.293964385986328, + 29.280134201049805, + 29.10198974609375, + 29.244884490966797, + 30.05089569091797, + 28.89644432067871, + 28.790943145751953, + 29.138561248779297 + ] + }, + "medians_ms_max_rank": { + "baseline": 35.43100929260254, + "fused": 29.126185417175293 + } + }, + { + "projection": "ffn_output", + "x_shape": [ + 82944, + 3584 + ], + "weight_shape": [ + 5376, + 3584 + ], + "correctness": { + "exact": false, + "finite": true, + "max_abs": 0.125, + "rmse": 0.007550136186182499 + }, + "samples_ms_max_rank": { + "baseline": [ + 41.45832443237305, + 39.80379867553711, + 41.706878662109375, + 39.84878921508789, + 39.23906326293945, + 40.6806526184082, + 40.00970458984375, + 39.12171173095703, + 39.26765441894531, + 40.694671630859375 + ], + "fused": [ + 29.246204376220703, + 29.3342342376709, + 29.026268005371094, + 29.29714584350586, + 29.55521011352539, + 30.19850730895996, + 29.213891983032227, + 28.91681480407715, + 28.96112632751465, + 28.9919376373291 + ] + }, + "medians_ms_max_rank": { + "baseline": 39.92924690246582, + "fused": 29.230048179626465 + } + } + ] + }, + "target_achieved": false + }, + "frozen_plan": { + "scope": "Four-rank operator-only screen for TP4 row projections; prepared not launched", + "source": "Pinned torch_npu2.10 installed _op_plugin_docs.py npu_mm_all_reduce_base, and H3 RowParallelLinear projections", + "hypothesis": "Overlap row-projection matrix multiplication with SUM collective while retaining full BF16 computation", + "shapes": [ + [ + 82944, + 1792, + 5376 + ], + [ + 82944, + 3584, + 5376 + ] + ], + "baseline": "F.linear then HCCL all_reduce SUM", + "candidate": "npu_mm_all_reduce_base unquantized BF16, default comm_turn, one HCCL domain", + "hardware_constraint": "Four local910B1, operator requires supported HCCS all-mesh; reject execution errors without fallback or semantic substitution", + "warmups": 3, + "rounds": 5, + "order": "ABBA", + "metrics": "Per-sample maximum rank wall time after device synchronization; timing aggregation excluded", + "parity": "Exact, finite, max error and RMSE on each rank; no model promotion from synthetic timing alone", + "prohibited": "No quantization, reduced precision, sparse math or approximation" + }, + "harness": { + "plan.json": "8f404508254c42ff481462901b3e5259e446a3accbdb96a48d64e7bd6c662b67", + "probe.py": "3485694142898fe5662d41578276545c48a14900f42d643fe8e2839ea0f5d1c1", + "run.sh": "c83930154752e699b0ef4aff5f3176a60f33f1a52fcde8fd1eb7fe61ba10492d" + }, + "job_exit": 0, + "decision": "Faster on both projections but nonexact on every rank; not promoted as lossless or model E2E gain", + "raw_result_sha256": "07885c0d54c270d61cf18c1c1781c55a49ad625b06e06e107b5becee352e9d0a" +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/operator-followup-integrity.json b/evidence/h3-ref2va-4x910b1-320/results/operator-followup-integrity.json new file mode 100644 index 000000000..56a720673 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/operator-followup-integrity.json @@ -0,0 +1,7 @@ +{ + "results/mm-fused-operator.json": "bdc3eab8077bad706c28a5fd1b093013224335da5d8181e1a960b7072782eb35", + "results/laser-layout-operator.json": "7350502320129b55d850d885fb1ebabf29af126dc7613a776282c876759966b6", + "results/laser-layout-implementation.json": "ee4084582339d357083f543a60c67ca59da74846246e1e147545492fecc07a74", + "results/laser-layout-parity-plan.json": "8dec9cd029c4f2cf33c3374e9f32f7a559eb81b19cb44e74e3106685a3b7978e", + "patch/laser-fp16-layout-candidate.patch": "900111861def48441ddf2ba2c2aa204a31a1a3a2db1026ce44fc76d20b47ea38" +} diff --git a/tests/test_evidence_inventory.py b/tests/test_evidence_inventory.py index e305f49f4..71f81970e 100644 --- a/tests/test_evidence_inventory.py +++ b/tests/test_evidence_inventory.py @@ -146,5 +146,5 @@ def test_checked_in_inventory(): result = validate_inventory(repo) assert result["errors"] == [] assert len(result["bundles"]) == 21 - assert result["checked_hashes"] == 466 + assert result["checked_hashes"] == 471 assert result["unavailable"] # Historical raw artifacts are not in this checkout. diff --git a/tools/evidence_inventory.json b/tools/evidence_inventory.json index 259c66c74..68f9e0c6e 100644 --- a/tools/evidence_inventory.json +++ b/tools/evidence_inventory.json @@ -59,6 +59,10 @@ { "path": "results/fia-v2-integrity.json", "schema": "bundle-sha256" + }, + { + "path": "results/operator-followup-integrity.json", + "schema": "bundle-sha256" } ], "external": [ From 14de17a3c6fa52b717a8825fe8190ea44b16a9f3 Mon Sep 17 00:00:00 2001 From: amy-why-3459 Date: Tue, 3 Nov 2026 17:42:30 +0800 Subject: [PATCH 16/17] Record strict elementwise H3 acceptance and operator screens Agent-assisted-by: Codex Signed-off-by: amy-why-3459 --- .../plan/acceptance-elementwise-v2.json | 13 ++ .../results/laser-head-split-operator.json | 98 ++++++++ .../results/nz-weight-operator.json | 214 ++++++++++++++++++ .../results/strict-followup-integrity.json | 6 + .../results/strict-followup.json | 17 ++ tests/test_evidence_inventory.py | 2 +- tools/evidence_inventory.json | 4 + 7 files changed, 353 insertions(+), 1 deletion(-) create mode 100644 evidence/h3-ref2va-4x910b1-320/plan/acceptance-elementwise-v2.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/laser-head-split-operator.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/nz-weight-operator.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/strict-followup-integrity.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/strict-followup.json diff --git a/evidence/h3-ref2va-4x910b1-320/plan/acceptance-elementwise-v2.json b/evidence/h3-ref2va-4x910b1-320/plan/acceptance-elementwise-v2.json new file mode 100644 index 000000000..361f10bf0 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/plan/acceptance-elementwise-v2.json @@ -0,0 +1,13 @@ +{ + "recorded_at": "2026-11-03T09:38:07.485443+00:00", + "supersedes_lossless_adjudication_only": "acceptance-30pct.json", + "user_instruction": "必须逐元素一致；不接受仅靠质量指标判定无损", + "requirements": [ + "Elementwise exact model output tensors and decoded audio/video equality; perceptual thresholds cannot substitute for equality.", + "Baseline nondeterminism does not excuse candidate mismatch. Locate and resolve repeatability before final acceptance.", + "Keep full 50 steps, BF16, dense compute, frozen inputs and same 4x910B1 devices.", + "Matched E2E latency reduction >=30% independently for 5s and 15s, clean lifecycle and complete requests.", + "Operator equality is screening only, not end-to-end lossless acceptance." + ], + "target_achieved": false +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/laser-head-split-operator.json b/evidence/h3-ref2va-4x910b1-320/results/laser-head-split-operator.json new file mode 100644 index 000000000..5eae8b686 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/laser-head-split-operator.json @@ -0,0 +1,98 @@ +{ + "scope": "Synthetic serial head splitting with original Laser; prerequisite for communication overlap, not a pipeline performance claim", + "results": [ + { + "shape": [ + 1, + 82944, + 14, + 128 + ], + "buckets": 2, + "correctness": { + "exact": false, + "baseline_repeat_exact": true, + "finite": true, + "max_abs": 0.0001220703125, + "rmse": 3.6224764698999934e-06 + }, + "samples_ms": { + "baseline": [ + 204.02591954916716, + 204.69807647168636, + 204.3577879667282, + 205.0683768466115, + 204.37862910330296, + 204.62592598050833, + 204.14493326097727, + 203.8610251620412, + 204.15357407182455, + 204.65598721057177 + ], + "split_heads": [ + 207.12636969983578, + 208.83501507341862, + 208.0789851024747, + 209.05367098748684, + 207.03508891165257, + 205.70140331983566, + 207.11091067641973, + 206.50956500321627, + 206.89126383513212, + 206.67001884430647 + ] + }, + "medians_ms": { + "baseline": 204.36820853501558, + "split_heads": 207.07299979403615 + } + }, + { + "shape": [ + 1, + 82944, + 14, + 128 + ], + "buckets": 4, + "correctness": { + "exact": false, + "baseline_repeat_exact": true, + "finite": true, + "max_abs": 0.000244140625, + "rmse": 3.252928991059889e-06 + }, + "samples_ms": { + "baseline": [ + 203.56131717562675, + 204.68030776828527, + 205.66628221422434, + 205.83053771406412, + 205.10541833937168, + 203.03059462457895, + 203.97292915731668, + 203.4556632861495, + 205.07057663053274, + 204.2134953662753 + ], + "split_heads": [ + 205.9911610558629, + 207.67465606331825, + 205.27535304427147, + 206.1683051288128, + 204.0297007188201, + 206.77973236888647, + 205.75305446982384, + 206.59320708364248, + 205.54829947650433, + 204.73256800323725 + ] + }, + "medians_ms": { + "baseline": 204.4469015672803, + "split_heads": 205.87210776284337 + } + } + ], + "target_achieved": false +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/nz-weight-operator.json b/evidence/h3-ref2va-4x910b1-320/results/nz-weight-operator.json new file mode 100644 index 000000000..ea4600338 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/nz-weight-operator.json @@ -0,0 +1,214 @@ +{ + "results": [ + { + "projection": "qkv", + "input_shape": [ + 20736, + 5376 + ], + "weight_shape": [ + 21504, + 5376 + ], + "formats": [ + 2, + 29 + ], + "correctness": { + "exact": true, + "finite": true, + "max_abs": 0.0, + "rmse": 0.0 + }, + "preparation_ms": 13808.023197576404, + "samples_ms": { + "nd": [ + 15.508806332945824, + 15.738180838525295, + 15.641399659216404, + 15.745552256703377, + 15.597366727888584, + 15.520746819674969, + 15.649788081645966, + 15.703151002526283, + 15.753451734781265, + 15.710589475929737 + ], + "nz": [ + 14.292962849140167, + 14.205590821802616, + 14.225861057639122, + 14.22257162630558, + 14.299682341516018, + 14.2201017588377, + 15.043123625218868, + 15.330331400036812, + 15.271118842065334, + 15.25494921952486 + ] + }, + "medians_ms": { + "nd": 15.676469542086124, + "nz": 14.296322595328093 + } + }, + { + "projection": "out", + "input_shape": [ + 20736, + 7168 + ], + "weight_shape": [ + 5376, + 7168 + ], + "formats": [ + 2, + 29 + ], + "correctness": { + "exact": true, + "finite": true, + "max_abs": 0.0, + "rmse": 0.0 + }, + "preparation_ms": 0.44676195830106735, + "samples_ms": { + "nd": [ + 4.92599792778492, + 4.837416112422943, + 4.882766865193844, + 4.873198457062244, + 4.877177998423576, + 4.9080075696110725, + 4.945158958435059, + 4.987770691514015, + 5.00848051160574, + 5.253298208117485 + ], + "nz": [ + 4.619070328772068, + 4.5595187693834305, + 4.617111757397652, + 4.563040100038052, + 4.615270532667637, + 4.559548571705818, + 4.778825677931309, + 4.907198250293732, + 4.671742208302021, + 5.0487518310546875 + ] + }, + "medians_ms": { + "nd": 4.917002748697996, + "nz": 4.61809104308486 + } + }, + { + "projection": "fc1", + "input_shape": [ + 20736, + 5376 + ], + "weight_shape": [ + 28672, + 5376 + ], + "formats": [ + 2, + 29 + ], + "correctness": { + "exact": true, + "finite": true, + "max_abs": 0.0, + "rmse": 0.0 + }, + "preparation_ms": 1.1112289503216743, + "samples_ms": { + "nd": [ + 21.12589217722416, + 21.2634252384305, + 21.265446208417416, + 21.324017085134983, + 21.5900344774127, + 21.646784618496895, + 21.271036006510258, + 21.667075343430042, + 21.26122545450926, + 21.42828982323408 + ], + "nz": [ + 19.033728167414665, + 19.049957394599915, + 20.399522967636585, + 20.038863644003868, + 20.265708677470684, + 20.361142233014107, + 20.077024586498737, + 20.44077403843403, + 20.30384074896574, + 20.05176432430744 + ] + }, + "medians_ms": { + "nd": 21.29752654582262, + "nz": 20.17136663198471 + } + }, + { + "projection": "fc2", + "input_shape": [ + 20736, + 14336 + ], + "weight_shape": [ + 5376, + 14336 + ], + "formats": [ + 2, + 29 + ], + "correctness": { + "exact": true, + "finite": true, + "max_abs": 0.0, + "rmse": 0.0 + }, + "preparation_ms": 0.5113743245601654, + "samples_ms": { + "nd": [ + 9.784705005586147, + 9.789394214749336, + 9.717874228954315, + 10.512723587453365, + 9.934070520102978, + 10.380171239376068, + 9.950390085577965, + 10.31170878559351, + 10.129604488611221, + 10.212077759206295 + ], + "nz": [ + 9.182550013065338, + 9.149628691375256, + 9.521258994936943, + 9.556280449032784, + 9.924880228936672, + 9.550170041620731, + 9.901209734380245, + 9.839827194809914, + 10.077344253659248, + 9.871188551187515 + ] + }, + "medians_ms": { + "nd": 10.039997287094593, + "nz": 9.698053821921349 + } + } + ], + "scope": "Synthetic resident weight-layout screen; DLO reconstruction and transfer costs excluded and unqualified", + "target_achieved": false +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/strict-followup-integrity.json b/evidence/h3-ref2va-4x910b1-320/results/strict-followup-integrity.json new file mode 100644 index 000000000..83cc08a38 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/strict-followup-integrity.json @@ -0,0 +1,6 @@ +{ + "plan/acceptance-elementwise-v2.json": "49d93de40a7e8884ddf43471f98ea69e0814e55288ce02cbe6af98d3effb7f91", + "results/nz-weight-operator.json": "936cafa3213d4d4db743347b1722127fa2f93bfc95cfab3bd36bc7eb7e99e994", + "results/laser-head-split-operator.json": "bb6c6ae2fb0c89cb31922122962266bdbe9fdcf2cee7f9ba2becf3e8028607e7", + "results/strict-followup.json": "10dce86d45cb4ce943620bebf7f928393e4c602960e481bc4b9528461b46284a" +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/strict-followup.json b/evidence/h3-ref2va-4x910b1-320/results/strict-followup.json new file mode 100644 index 000000000..a01c4c1b6 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/strict-followup.json @@ -0,0 +1,17 @@ +{ + "target_achieved": false, + "sources": { + "nz_weight": "Existing vLLM-Omni Qwen3-TTS maybe_trans_nz implementation and NPU platform allow_internal_format; installed torch_npu.npu_format_cast(weight,29).", + "head_split": "Imported head-bucket source f9e5d544d33428e17b818be3a01cb7d0956e4ead; this test retains original Laser and uses serial full-KV head splits." + }, + "decisions": { + "nz_weight": "All four synthetic projection outputs exact; resident operator improvement only; DLO transfer and reconstruction unqualified.", + "head_split": "Rejected: output mismatch with repeatable synthetic baseline, and slower.", + "acceptance": "Elementwise equality is mandatory; perceptual thresholds and baseline variance do not waive it.", + "next_diagnostic": "Unlaunched v1 replaced before reservation by v2 adding full stage tensor hashes to real-activation attention parity. Diagnostic timings invalid." + }, + "timing_scope": { + "nz_weight": "Separate reserved single device; model warmup incomplete at probe exit.", + "head_split": "Separate reserved single device; model warmup incomplete at probe exit." + } +} diff --git a/tests/test_evidence_inventory.py b/tests/test_evidence_inventory.py index 71f81970e..e5e63d21d 100644 --- a/tests/test_evidence_inventory.py +++ b/tests/test_evidence_inventory.py @@ -146,5 +146,5 @@ def test_checked_in_inventory(): result = validate_inventory(repo) assert result["errors"] == [] assert len(result["bundles"]) == 21 - assert result["checked_hashes"] == 471 + assert result["checked_hashes"] == 475 assert result["unavailable"] # Historical raw artifacts are not in this checkout. diff --git a/tools/evidence_inventory.json b/tools/evidence_inventory.json index 68f9e0c6e..2b5e95a92 100644 --- a/tools/evidence_inventory.json +++ b/tools/evidence_inventory.json @@ -63,6 +63,10 @@ { "path": "results/operator-followup-integrity.json", "schema": "bundle-sha256" + }, + { + "path": "results/strict-followup-integrity.json", + "schema": "bundle-sha256" } ], "external": [ From 4298c2ae9fca288e2a2847983bf500b24594df96 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Wed, 4 Nov 2026 08:56:26 +0000 Subject: [PATCH 17/17] Distinguish frozen H3 preflight status from the current receipt results/status.json stays the hashed preparation snapshot. Add status-v2 so a queued, zero-sample reading cannot hide the recorded 5s four-device baseline. The receipt stays INCONCLUSIVE, with no speedup and the sample's failed worker teardown. Review: https://github.com/InferMatrixLab/InferRSI/pull/321#pullrequestreview-5745704057 Inline: https://github.com/InferMatrixLab/InferRSI/pull/321#discussion_r4449687563 Signed-off-by: Cursor Agent Co-authored-by: amy-why-3459 --- .../results/status-v2-integrity.json | 3 + .../results/status-v2.json | 55 ++++++++++++++++++ tests/test_evidence_inventory.py | 2 +- tests/test_h3_ref2va_status_receipt.py | 58 +++++++++++++++++++ tools/evidence_inventory.json | 4 ++ 5 files changed, 121 insertions(+), 1 deletion(-) create mode 100644 evidence/h3-ref2va-4x910b1-320/results/status-v2-integrity.json create mode 100644 evidence/h3-ref2va-4x910b1-320/results/status-v2.json create mode 100644 tests/test_h3_ref2va_status_receipt.py diff --git a/evidence/h3-ref2va-4x910b1-320/results/status-v2-integrity.json b/evidence/h3-ref2va-4x910b1-320/results/status-v2-integrity.json new file mode 100644 index 000000000..ed127087b --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/status-v2-integrity.json @@ -0,0 +1,3 @@ +{ + "results/status-v2.json": "70d39e93969ff82f6b9c9ce0c3b1910e6cd3195963452a19e0d8a70f183bb107" +} diff --git a/evidence/h3-ref2va-4x910b1-320/results/status-v2.json b/evidence/h3-ref2va-4x910b1-320/results/status-v2.json new file mode 100644 index 000000000..7661ddc52 --- /dev/null +++ b/evidence/h3-ref2va-4x910b1-320/results/status-v2.json @@ -0,0 +1,55 @@ +{ + "role": "current_campaign_receipt", + "stage": "progress_after_frozen_preflight_snapshot", + "successor_of": "results/status.json", + "historical_preflight_snapshot": { + "path": "results/status.json", + "stage": "preflight_preparation", + "frozen_by": "plan/preflight-integrity.json", + "execution": "queued", + "four_device_samples": 0, + "limitation": "No four-device execution result yet", + "reader_note": "Frozen preparation snapshot hashed before the four-device HTTP baseline. Its queued execution and zero sample count are not the current campaign status. Do not use them to discard or reclassify the measured sample below." + }, + "verdict": "INCONCLUSIVE", + "speedup": null, + "quality_acceptance": false, + "campaign_acceptance": false, + "baseline_preflight": { + "measured_samples": 1, + "receipt": "results/baseline-5s-complete.json", + "run": "baseline-5s-preflight", + "hardware": { + "type": "Ascend 910B1", + "count": 4 + }, + "steps": 50, + "measured_request": { + "label": "measured-5-seed0-0", + "e2e_ms": 814064.1126520932, + "http_status": 200 + }, + "lifecycle": { + "status": "fail", + "forced_signals": 8, + "expected_workers": 4, + "worker_teardown": "failed" + }, + "verdict": "INCONCLUSIVE", + "scope": "5s feasibility and baseline repeatability only; original lifecycle FAIL; no optimization gain certified" + }, + "later_records": { + "fifteen_second_lifecycle_control": { + "receipt": "results/baseline15-complete.json", + "run": "lifecycle-control-15s-preflight", + "relationship": "Separate later four-device HTTP receipt. It does not replace the 5s baseline preflight sample, does not clear that sample's failed worker teardown, and does not accept the campaign." + }, + "other_results": "Other results records keep their own contents. This receipt does not roll them into a speedup or a campaign PASS." + }, + "limitations": [ + "Campaign verdict remains INCONCLUSIVE", + "No speedup is claimed", + "One 4x910B1 50-step HTTP baseline preflight sample is recorded and its worker teardown failed", + "This receipt is not campaign acceptance" + ] +} diff --git a/tests/test_evidence_inventory.py b/tests/test_evidence_inventory.py index e5e63d21d..2cd0f15f3 100644 --- a/tests/test_evidence_inventory.py +++ b/tests/test_evidence_inventory.py @@ -146,5 +146,5 @@ def test_checked_in_inventory(): result = validate_inventory(repo) assert result["errors"] == [] assert len(result["bundles"]) == 21 - assert result["checked_hashes"] == 475 + assert result["checked_hashes"] == 476 assert result["unavailable"] # Historical raw artifacts are not in this checkout. diff --git a/tests/test_h3_ref2va_status_receipt.py b/tests/test_h3_ref2va_status_receipt.py new file mode 100644 index 000000000..86766879b --- /dev/null +++ b/tests/test_h3_ref2va_status_receipt.py @@ -0,0 +1,58 @@ +"""Current H3 receipt must not let the frozen preflight snapshot hide a sample.""" + +import json +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] / "evidence/h3-ref2va-4x910b1-320" + + +def load(relative): + return json.loads((ROOT / relative).read_text(encoding="utf-8")) + + +def test_preflight_status_stays_a_frozen_snapshot_with_a_current_receipt(): + status = load("results/status.json") + current = load("results/status-v2.json") + baseline = load("results/baseline-5s-complete.json") + snapshot = current["historical_preflight_snapshot"] + + assert status["execution"] == "queued" + assert status["four_device_samples"] == 0 + assert status["verdict"] == "INCONCLUSIVE" + assert snapshot["path"] == "results/status.json" + assert snapshot["stage"] == "preflight_preparation" + assert snapshot["frozen_by"] == "plan/preflight-integrity.json" + assert snapshot["execution"] == status["execution"] + assert snapshot["four_device_samples"] == status["four_device_samples"] + assert current["successor_of"] == "results/status.json" + assert current["role"] == "current_campaign_receipt" + assert current["verdict"] == "INCONCLUSIVE" + assert current["speedup"] is None + assert current["quality_acceptance"] is False + assert current["campaign_acceptance"] is False + + sample = current["baseline_preflight"] + measured = next( + item for item in baseline["samples_including_warmups"] + if item["label"] == "measured-5-seed0-0" + ) + alive = [worker for worker in baseline["lifecycle"]["workers"] if worker["alive"]] + assert sample["receipt"] == "results/baseline-5s-complete.json" + assert sample["measured_samples"] == baseline["cells"][0]["completed"] == 1 + assert sample["measured_request"]["label"] == measured["label"] + assert sample["measured_request"]["e2e_ms"] == measured["e2e_ms"] + assert sample["measured_request"]["http_status"] == measured["http_status"] + assert sample["steps"] == measured["steps"] == 50 + assert sample["hardware"] == baseline["hardware"] + assert sample["lifecycle"]["status"] == baseline["lifecycle"]["status"] == "fail" + assert sample["lifecycle"]["forced_signals"] == baseline["lifecycle"]["forced_signals"] + assert sample["lifecycle"]["worker_teardown"] == "failed" + assert len(alive) == baseline["lifecycle"]["expected_workers"] + assert all(worker["exit_code"] is None for worker in alive) + assert sample["verdict"] == baseline["verdict"] == "INCONCLUSIVE" + assert "PASS" not in (current["verdict"], sample["verdict"], baseline["verdict"]) + + later = current["later_records"]["fifteen_second_lifecycle_control"] + fifteen = load(later["receipt"]) + assert later["run"] == fifteen["run"] + assert fifteen["run"] != baseline["run"] diff --git a/tools/evidence_inventory.json b/tools/evidence_inventory.json index 2b5e95a92..9bde40029 100644 --- a/tools/evidence_inventory.json +++ b/tools/evidence_inventory.json @@ -8,6 +8,10 @@ "path": "plan/preflight-integrity.json", "schema": "bundle-sha256" }, + { + "path": "results/status-v2-integrity.json", + "schema": "bundle-sha256" + }, { "path": "results/first-warmup-integrity.json", "schema": "bundle-sha256"