Add admitted RTX Vulkan Qwen3-TTS whole-session route

This commit is contained in:
tzhouam committed 2026-09-24 16:14:26 +08:00
1 parent 74d284acba
commit 5bb16af8ee
33 files changed
+3200 -21

No files matched your search

@@ -0,0 +1,163 @@
#!/usr/bin/env python3
"""Audit complete-WAV RTX hybrid TTS evidence and Radeon route regression."""
from __future__ import annotations
import argparse
import hashlib
import json
import math
import wave
from pathlib import Path
ARTIFACT_HASHES = {
"server_sha256": "999c6af252077195adb723b96da9ee5d3cd291dc7c7a4b32dc493ae148035529",
"talker_sha256": "5227dcbc4df7c5533341d111cc469fa491a48e722b23dd10f553181b52dff2d9",
"codec_sha256": "70dc95dbfdd9aa5d9d406236ff771d061bf17b0cda02a72513953355606e719b",
"punc_sha256": "faf4a43e3135bc307a66194685af00f756e6f4c28c7d9e2dd8f3517cddca5c45",
}
RTX_PCM = "d3d071531e2574b933c8acf18e2a0344c8961493bd17c63662307270a99d265c"
RADEON_PCM = "57f60228e2b456f6dfefc7e49df862c7bff6ba7cf39231ef1824f615948a1539"
PREFILL = "qwen3_tts[customvoice]: prefill role="
def sha256(path: Path) -> str:
with path.open("rb") as stream:
return hashlib.file_digest(stream, "sha256").hexdigest()
def clean_ledger(value: dict, *, rtx: bool) -> bool:
empty = {"host_ram": 0, "gpu_vram": 0} if rtx else {"host_ram": 0}
return value["reserved"] == empty and value["owners"] == [] and value["quarantined"] == []
def check_wav(path: Path, frames: int, pcm_hash: str) -> None:
with wave.open(str(path), "rb") as wav:
if (wav.getnchannels(), wav.getsampwidth(), wav.getframerate(), wav.getnframes()) != (1, 2, 24000, frames):
raise ValueError(f"{path.name}: unexpected WAV format or frame count")
if hashlib.sha256(wav.readframes(frames)).hexdigest() != pcm_hash:
raise ValueError(f"{path.name}: PCM differs from the stage output")
def check_log(path: Path, device: str, started: int = 1) -> int:
log = path.read_text(encoding="utf-8", errors="replace")
if (f"0 = {device}" not in log or "using preferred GPU backend: Vulkan0" not in log
or "code_pred CPU-pinned" not in log
or "codec: GPU default - loading weights onto Vulkan0" not in log
or "falling back to CPU" in log):
raise ValueError(f"{path.name}: hybrid device placement not verified")
count = log.count(PREFILL)
if count < started:
raise ValueError(f"{path.name}: expected TTS prefill absent")
return count
def audit(root: Path) -> dict:
profile = json.loads((root / "tts_rtx_profile20_report.json").read_text(encoding="utf-8"))
smoke = json.loads((root / "tts_rtx_smoke_report.json").read_text(encoding="utf-8"))
postguard = json.loads((root / "tts_rtx_postguard_report.json").read_text(encoding="utf-8"))
radeon = json.loads((root / "tts_radeon_regression_report.json").read_text(encoding="utf-8"))
public = json.loads((root / "tts_rtx_public_report.json").read_text(encoding="utf-8"))
asr = json.loads((root / "tts_rtx_smoke_asr.json").read_text(encoding="utf-8"))
refused = json.loads((root / "tts_rtx_refused_3gib.json").read_text(encoding="utf-8"))
hardware = json.loads((root / "hardware.json").read_text(encoding="utf-8"))
if any(report["status"] != "passed" for report in (profile, smoke, postguard, radeon, public, refused)):
raise ValueError("one of the TTS runs failed")
for report, device, gpu, pcm in (
(profile, "NVIDIA GeForce RTX 5090 Laptop GPU", True, RTX_PCM),
(smoke, "NVIDIA GeForce RTX 5090 Laptop GPU", True, RTX_PCM),
(postguard, "NVIDIA GeForce RTX 5090 Laptop GPU", True, RTX_PCM),
(radeon, "AMD Radeon(TM) 890M Graphics", False, RADEON_PCM),
):
plan = report["execution_plan"]
if (plan["artifact_sha256"] != ARTIFACT_HASHES or plan["expected_gpu_name"] != device
or plan["ggml_vk_visible_devices"] != ("0" if gpu else "1")
or ("gpu_vram" in plan["reserved_bytes"]) != gpu):
raise ValueError("TTS artifact, GPU identity or memory pools changed")
if (report["checks"][0]["pcm_sha256"] != pcm
or report["measured"][0]["pcm_sha256"] != pcm
or not clean_ledger(report["ledger_after_shutdown"], rtx=gpu)):
raise ValueError("TTS complete WAV or release changed")
if (profile["warmup_count"] != 1 or profile["measured_count"] != 20
or len(profile["measured"]) != 20 or not profile["all_same_pcm_sha256"]
or any(row["pcm_sha256"] != RTX_PCM or row["frames"] != 65280
for row in profile["measured"])):
raise ValueError("RTX serial profile did not return 20 identical complete WAVs")
walls = sorted(row["wall_s"] for row in profile["measured"])
if (profile["nearest_rank_p50_wall_s"] != walls[math.ceil(20 * .5) - 1]
or profile["nearest_rank_p95_wall_s"] != walls[math.ceil(20 * .95) - 1]):
raise ValueError("RTX p50/p95 do not match the retained 20 samples")
for report, gpu in ((profile, True), (radeon, False)):
abort = report["abort_check"]
restart = report["restart_check"]
old_plan, fresh_plan = report["execution_plan"], restart["fresh_execution_plan"]
if (abort["prefills_after_abort_request_start"] <= abort["prefills_before_abort_request"]
or abort["stale_output"] or not abort["worker_exited"]
or restart["late_output"] or not restart["same_pcm_as_before_abort"]
or old_plan["worker_generation"] == fresh_plan["worker_generation"]
or fresh_plan["artifact_sha256"] != ARTIFACT_HASHES
or fresh_plan["expected_gpu_name"] != old_plan["expected_gpu_name"]
or fresh_plan["reserved_bytes"] != old_plan["reserved_bytes"]
or restart["fresh_request"]["stage_event"]["worker_generation"] != fresh_plan["worker_generation"]
or not all(clean_ledger(value, rtx=gpu) for value in (
abort["ledger_after_abort"], restart["first_runtime_ledger_after_shutdown"]
))):
raise ValueError("in-flight cancellation or fresh-stage recovery failed")
if (len(public["outputs"]) != 1 or public["outputs"][0]["pcm_sha256"] != RTX_PCM
or public["outputs"][0]["frames"] != 65280 or public["outputs"][0]["sample_rate"] != 24000):
raise ValueError("public AsyncOmni audio differs from the RTX stage output")
if (asr["word_error_rate"] != 0.0 or asr["transcript"] != "Hello from the local computer."
or asr["wav_sha256"] != sha256(root / "tts_rtx_smoke.wav")):
raise ValueError("independent ASR proxy or WAV identity failed")
if (refused["server_log_created"] or "GPU-VRAM reservation" not in refused["error"]
or not clean_ledger(refused["ledger_after_refusal"], rtx=True)
or (root / "tts_rtx_refused_should_not_exist.log").exists()):
raise ValueError("undersized GPU reservation launched or retained a worker")
if not any(gpu["Name"] == "NVIDIA GeForce RTX 5090 Laptop GPU" for gpu in hardware["gpus"]):
raise ValueError("RTX hardware identity absent")
counts = {
"smoke": check_log(root / "tts_rtx_smoke_server.log", "NVIDIA GeForce RTX 5090 Laptop GPU", 3),
"postguard": check_log(root / "tts_rtx_postguard_server.log", "NVIDIA GeForce RTX 5090 Laptop GPU", 3),
"profile": check_log(root / "tts_rtx_profile20_server.log", "NVIDIA GeForce RTX 5090 Laptop GPU", 24),
"restart": check_log(root / "tts_rtx_profile20_server_restart.log", "NVIDIA GeForce RTX 5090 Laptop GPU"),
"public": check_log(root / "tts_rtx_public_server.log", "NVIDIA GeForce RTX 5090 Laptop GPU"),
"radeon": check_log(root / "tts_radeon_regression_server.log", "AMD Radeon(TM) 890M Graphics"),
"radeon_restart": check_log(root / "tts_radeon_regression_server_restart.log", "AMD Radeon(TM) 890M Graphics"),
}
check_wav(root / "tts_rtx_smoke.wav", 65280, RTX_PCM)
check_wav(root / "tts_rtx_postguard.wav", 65280, RTX_PCM)
check_wav(root / "tts_rtx_profile20.wav", 65280, RTX_PCM)
check_wav(root / "tts_radeon_regression.wav", 61440, RADEON_PCM)
files = [path for path in root.iterdir() if path.is_file() and path.name not in ("README.md", "audit_report.json")]
return {
"status": "passed",
"scope": "RTX complete-request TTS, 20 serial outputs, public API, in-flight cancel/restart, GPU admission refusal and Radeon regression",
"profile_nearest_rank_p50_wall_s": profile["nearest_rank_p50_wall_s"],
"profile_nearest_rank_p95_wall_s": profile["nearest_rank_p95_wall_s"],
"rtx_pcm_sha256": RTX_PCM,
"radeon_pcm_sha256": RADEON_PCM,
"server_prefill_counts": counts,
"files": {path.name: {"bytes": path.stat().st_size, "sha256": sha256(path)} for path in files},
"limits": [
"ASR exact transcription is an intelligibility proxy, not speaker or perceptual quality qualification.",
"The backend emits complete WAVs and has no playable chunk stream.",
"Declared GPU-VRAM admission is not a measured device-memory loading peak.",
"One fresh-stage restart is not same-session continuation or sustained recovery qualification.",
],
}
def main() -> None:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--evidence-dir", type=Path, required=True)
args = parser.parse_args()
result = audit(args.evidence_dir)
(args.evidence_dir / "audit_report.json").write_text(
json.dumps(result, indent=2) + "\n", encoding="utf-8"
)
print(json.dumps({"status": result["status"], "profile_p50": result["profile_nearest_rank_p50_wall_s"]}))
if __name__ == "__main__":
main()
@@ -0,0 +1,74 @@
#!/usr/bin/env python3
"""Verify that an undersized discrete-GPU TTS reservation fails before load."""
from __future__ import annotations
import argparse
import json
from pathlib import Path
from types import SimpleNamespace
def main() -> None:
parser = argparse.ArgumentParser(description=__doc__)
for name in (
"server_bin", "server_sha256", "talker_file", "talker_sha256", "codec_file",
"codec_sha256", "punc_file", "punc_sha256", "server_log", "output_report",
):
parser.add_argument("--" + name.replace("_", "-"), required=True)
args = parser.parse_args()
from vllm_omni.engine.backends.crisp_tts import CrispTTSStageClient
from vllm_omni.engine.resource_ledger import ResourceLedger, ResourceUnavailable
log_path = Path(args.server_log)
if log_path.exists():
raise FileExistsError("refusal probe needs a fresh server-log path")
ledger = ResourceLedger({"host_ram": 16 << 30, "gpu_vram": 16 << 30})
reservation = ledger.reserve("undersized-rtx-tts", {"host_ram": 8 << 30, "gpu_vram": 3 << 30})
backend = {
"server_bin": args.server_bin,
"server_sha256": args.server_sha256,
"talker_file": args.talker_file,
"talker_sha256": args.talker_sha256,
"codec_file": args.codec_file,
"codec_sha256": args.codec_sha256,
"punc_file": args.punc_file,
"punc_sha256": args.punc_sha256,
"log_file": str(log_path),
"expected_gpu_name": "NVIDIA GeForce RTX 5090 Laptop GPU",
"ggml_vk_visible_devices": "0",
"memory_overhead_bytes": 5 << 30,
"gpu_memory_pool": "gpu_vram",
"gpu_memory_overhead_bytes": 2 << 30,
}
error = None
try:
CrispTTSStageClient(SimpleNamespace(stage_id=0), backend, ledger, reservation)
except ResourceUnavailable as exc:
error = f"{type(exc).__name__}: {exc}"
if error is None:
raise RuntimeError("undersized GPU-VRAM reservation was admitted")
snapshot = ledger.snapshot()
if snapshot["reserved"] != {"host_ram": 0, "gpu_vram": 0} or snapshot["quarantined"] or log_path.exists():
raise RuntimeError("GPU-VRAM refusal left a reservation or launched the server")
report = {
"status": "passed",
"scope": "RTX TTS 3 GiB GPU-VRAM demand is refused before server launch",
"artifact_sha256": {name: getattr(args, name) for name in (
"server_sha256", "talker_sha256", "codec_sha256", "punc_sha256"
)},
"declared_gpu_reservation_bytes": 3 << 30,
"declared_gpu_overhead_bytes": 2 << 30,
"error": error,
"server_log_created": False,
"ledger_after_refusal": snapshot,
}
destination = Path(args.output_report)
destination.parent.mkdir(parents=True, exist_ok=True)
destination.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
print(json.dumps({"status": report["status"], "error": report["error"]}))
if __name__ == "__main__":
main()
@@ -39,6 +39,7 @@ async def main() -> None:
):
parser.add_argument("--" + name.replace("_", "-"), required=True)
parser.add_argument("--expected-gpu-name", default="AMD Radeon(TM) 890M Graphics")
parser.add_argument("--ggml-vk-visible-devices", default="1")
parser.add_argument("--warmups", type=int, default=1)
parser.add_argument("--repeats", type=int, default=20)
parser.add_argument("--abort-check", action="store_true")
@@ -46,9 +47,16 @@ async def main() -> None:
help="After in-flight cancellation, start a fresh stage and verify audio")
parser.add_argument("--capacity-gib", type=int, default=16)
parser.add_argument("--reserve-gib", type=int, default=8)
parser.add_argument("--gpu-capacity-gib", type=int, default=0)
parser.add_argument("--gpu-reserve-gib", type=int, default=0)
args = parser.parse_args()
if args.warmups < 0 or args.repeats <= 0 or args.reserve_gib <= 0 or args.capacity_gib < args.reserve_gib:
parser.error("invalid warmup/repeat count or memory budget")
if args.expected_gpu_name == "NVIDIA GeForce RTX 5090 Laptop GPU":
if args.ggml_vk_visible_devices != "0" or args.gpu_reserve_gib < 4 or args.gpu_capacity_gib < args.gpu_reserve_gib:
parser.error("RTX route requires Vulkan device 0 and at least 4 GiB reserved GPU VRAM")
elif args.gpu_capacity_gib or args.gpu_reserve_gib:
parser.error("Radeon shared-RAM route must not declare discrete GPU VRAM")
if args.restart_check and not args.abort_check:
parser.error("--restart-check requires --abort-check")
@@ -68,7 +76,7 @@ async def main() -> None:
"punc_sha256": args.punc_sha256,
"log_file": args.server_log,
"expected_gpu_name": args.expected_gpu_name,
"ggml_vk_visible_devices": "1",
"ggml_vk_visible_devices": args.ggml_vk_visible_devices,
"memory_overhead_bytes": 5 << 30,
"max_text_bytes": 4096,
"max_wav_bytes": 4 << 20,
@@ -78,14 +86,21 @@ async def main() -> None:
"voice": "ryan",
"seed": 42,
}
capacities = {"host_ram": args.capacity_gib << 30}
demands = {"host_ram": args.reserve_gib << 30}
if args.gpu_reserve_gib:
capacities["gpu_vram"] = args.gpu_capacity_gib << 30
demands["gpu_vram"] = args.gpu_reserve_gib << 30
backend["gpu_memory_pool"] = "gpu_vram"
backend["gpu_memory_overhead_bytes"] = 2 << 30
deploy = DeployConfig(
async_chunk=False,
stages=[StageDeployConfig(
stage_id=0,
backend=backend,
resource_budget={
"capacities": {"host_ram": args.capacity_gib << 30},
"demands": {"host_ram": args.reserve_gib << 30},
"capacities": capacities,
"demands": demands,
},
)],
)
@@ -94,7 +109,7 @@ async def main() -> None:
runtime = StageRuntime(configs, "local-qwen-tts-crisp", "", stage_init_timeout=180, async_chunk=False)
report = {
"scope": "complete resident Qwen3-TTS CustomVoice text-to-WAV through Omni StageRuntime/StagePool",
"placement": "Radeon Vulkan talker/codec + CPU FP32 code predictor",
"placement": f"{args.expected_gpu_name} Vulkan talker/codec + CPU FP32 code predictor",
"warmup_count": args.warmups,
"measured_count": args.repeats,
"memory_budget": deploy.stages[0].resource_budget,
@@ -22,7 +22,18 @@ async def main() -> None:
"codec_file", "codec_sha256", "punc_file", "punc_sha256", "server_log", "output_report",
):
parser.add_argument("--" + name.replace("_", "-"), required=True)
parser.add_argument("--expected-gpu-name", default="AMD Radeon(TM) 890M Graphics")
parser.add_argument("--ggml-vk-visible-devices", default="1")
parser.add_argument("--gpu-capacity-gib", type=int, default=0)
parser.add_argument("--gpu-reserve-gib", type=int, default=0)
parser.add_argument("--expected-frames", type=int, default=61440)
parser.add_argument("--expected-pcm-sha256", default="57f60228e2b456f6dfefc7e49df862c7bff6ba7cf39231ef1824f615948a1539")
args = parser.parse_args()
if args.expected_gpu_name == "NVIDIA GeForce RTX 5090 Laptop GPU":
if args.ggml_vk_visible_devices != "0" or args.gpu_reserve_gib < 4 or args.gpu_capacity_gib < args.gpu_reserve_gib:
parser.error("RTX route requires Vulkan device 0 and at least 4 GiB reserved GPU VRAM")
elif args.gpu_capacity_gib or args.gpu_reserve_gib:
parser.error("Radeon shared-RAM route must not declare discrete GPU VRAM")
from vllm_omni.entrypoints.async_omni import AsyncOmni
from vllm_omni.model_executor.models.qwen3_tts.pipeline import QWEN3_TTS_CRISP_HYBRID_PIPELINE
@@ -38,8 +49,8 @@ async def main() -> None:
"punc_file": args.punc_file,
"punc_sha256": args.punc_sha256,
"log_file": args.server_log,
"expected_gpu_name": "AMD Radeon(TM) 890M Graphics",
"ggml_vk_visible_devices": "1",
"expected_gpu_name": args.expected_gpu_name,
"ggml_vk_visible_devices": args.ggml_vk_visible_devices,
"memory_overhead_bytes": 5 << 30,
"max_text_bytes": 4096,
"max_wav_bytes": 4 << 20,
@@ -47,7 +58,15 @@ async def main() -> None:
"voice": "ryan",
"seed": 42,
}
capacities = {"host_ram": 16 << 30}
demands = {"host_ram": 8 << 30}
if args.gpu_reserve_gib:
capacities["gpu_vram"] = args.gpu_capacity_gib << 30
demands["gpu_vram"] = args.gpu_reserve_gib << 30
backend["gpu_memory_pool"] = "gpu_vram"
backend["gpu_memory_overhead_bytes"] = 2 << 30
report = {"entrypoint": "AsyncOmni.generate", "pipeline": QWEN3_TTS_CRISP_HYBRID_PIPELINE.model_type}
report["memory_budget"] = {"capacities": capacities, "demands": demands}
engine = None
try:
with tempfile.TemporaryDirectory(prefix="omni-crisp-tts-") as temporary:
@@ -59,8 +78,8 @@ async def main() -> None:
"stage_id": 0,
"backend": backend,
"resource_budget": {
"capacities": {"host_ram": 16 << 30},
"demands": {"host_ram": 8 << 30},
"capacities": capacities,
"demands": demands,
},
}],
}), encoding="utf-8")
@@ -89,9 +108,11 @@ async def main() -> None:
})
report["request_wall_s"] = time.perf_counter() - started
report["outputs"] = outputs
assert len(outputs) == 1 and outputs[0]["request_id"] == "public-tts-1"
assert outputs[0]["sample_rate"] == 24000 and outputs[0]["frames"] == 61440
assert outputs[0]["pcm_sha256"] == "57f60228e2b456f6dfefc7e49df862c7bff6ba7cf39231ef1824f615948a1539"
if (len(outputs) != 1 or outputs[0]["request_id"] != "public-tts-1"
or outputs[0]["sample_rate"] != 24000
or outputs[0]["frames"] != args.expected_frames
or outputs[0]["pcm_sha256"] != args.expected_pcm_sha256):
raise RuntimeError("public audio differed from the pinned stage output")
report["status"] = "passed"
except BaseException as exc:
report["status"] = "failed"