@@ -242,11 +242,12 @@ jobs:
         run: |
           mkdir -p benchmark_reports/ir_verifier_smoke
           for level in none basic all; do
+            # Verify tensor IR without invoking the scalar-only legacy backend.
             $PY -m scratchv models/graph/cnn.onnx \
-              --verify-ir --optimize "$level" --dump-ir \
-              -o "benchmark_reports/ir_verifier_smoke/cnn_${level}.s" \
+              --backend ir --verify-ir --optimize "$level" --dump-ir \
+              -o "benchmark_reports/ir_verifier_smoke/cnn_${level}.ir" \
               2>&1 | tee "benchmark_reports/ir_verifier_smoke/cnn_${level}.log"
-            test -s "benchmark_reports/ir_verifier_smoke/cnn_${level}.s"
+            test -s "benchmark_reports/ir_verifier_smoke/cnn_${level}.ir"
           done
         shell: bash
 
 
@@ -29,6 +29,10 @@
 
 ROOT = Path(__file__).resolve().parents[1]
 DEFAULT_MODEL = ROOT / "models/graph/cnn.onnx"
+LEGACY_TENSOR_REJECTION = (
+    "Codegen error: Legacy riscv/llvm backends cannot lower tensor buffers; "
+    "use --backend tensor-c and the RISC-V tensor runtime"
+)
 
 
 def sha256(data: bytes) -> str:
@@ -199,7 +203,7 @@ def run_benchmark(model_path: Path = DEFAULT_MODEL, *, standalone_asm: Path | No
     model_bytes = model_path.read_bytes()
     model = onnx.load_model_from_string(model_bytes)
     cpu_model = model_metadata(llvm_mca)
-    cases = []
+    cases, unsupported_cases = [], []
     with tempfile.TemporaryDirectory(prefix="cnn-schedule-") as directory:
         work = Path(directory)
         out = artifacts.resolve() if artifacts else work
@@ -230,7 +234,7 @@ def run_benchmark(model_path: Path = DEFAULT_MODEL, *, standalone_asm: Path | No
         if standalone_asm is not None and standalone_asm.read_bytes() != default_asm.read_bytes():
             raise ValueError("Standalone assembly does not match this ONNX model and --const-merge")
         primary = analyze_assembly(generated, "standalone/const-merge", llvm_mca)
-        if primary["assembly"]["after"] != scheduled.read_text():
+        if primary["assembly"]["after"] != scheduled.read_bytes().decode("utf-8"):
             raise ValueError("Standalone scheduled binary differs from the public assembly pass")
         if baseline_bin.read_bytes()[metadata["code_bytes"]:] != scheduled_bin.read_bytes()[metadata["code_bytes"]:]:
             raise ValueError("Scheduling changed weight bytes")
@@ -250,6 +254,13 @@ def run_benchmark(model_path: Path = DEFAULT_MODEL, *, standalone_asm: Path | No
             config = CompilerConfig(reg_alloc=allocator, optimize_level="none")
             compiled = CompilerDriver(config).compile(str(model_path), str(path))
             if not compiled.success:
+                if compiled.errors == [LEGACY_TENSOR_REJECTION]:
+                    unsupported_cases.append({
+                        "case": f"CompilerDriver/{allocator}", "role": "supplemental",
+                        "status": "unsupported", "reason": LEGACY_TENSOR_REJECTION,
+                        "compiler_errors": list(compiled.errors),
+                    })
+                    continue
                 raise RuntimeError("; ".join(compiled.errors))
             case = analyze_assembly(path, f"CompilerDriver/{allocator}", llvm_mca)
             (out / f"compiler-{allocator}-after.s").write_text(case["assembly"]["after"])
@@ -273,8 +284,11 @@ def run_benchmark(model_path: Path = DEFAULT_MODEL, *, standalone_asm: Path | No
         if any(value is False for value in primary["acceptance"].values()):
             primary["status"] = "failed"
     return {
-        "schema_version": 4, "benchmark_type": "cnn-scheduling-ab",
+        "schema_version": 5, "benchmark_type": "cnn-scheduling-ab",
         "status": "passed" if all(c["status"] == "passed" for c in cases) else "failed",
+        "acceptance_scope": "standalone CNN scheduling and execution",
+        "supplemental_status": "unsupported" if unsupported_cases else "passed",
+        "unsupported_cases": unsupported_cases,
         "validation_scope": "static_and_llvm" + ("_and_execution" if execute else ""),
         "whole_cnn_execution": primary["execution"]["status"],
         "input": {"path": model_path.relative_to(ROOT).as_posix() if model_path.is_relative_to(ROOT) else str(model_path),
@@ -299,6 +313,11 @@ def markdown(report: dict) -> str:
     lines = ["# Topic 18：CNN 指令调度验证", "", f"验证状态：**{report['status']}**。"]
     if "error" in report:
         return "\n".join(lines + ["", report["error"], ""])
+    lines += ["", "验收范围：**standalone CNN 调度与执行**；是否实际执行见下方完整执行状态。"]
+    if report["unsupported_cases"]:
+        lines += ["", "**CompilerDriver CNN 张量未支持；以下补充路径为 unsupported，未生成汇编、未测量周期，也未通过执行验证。**"]
+        lines += [f"- `{case['case']}`：{case['status']}；{case['reason']}"
+                  for case in report["unsupported_cases"]]
     lines += [
         f"输入：`{report['input']['path']}`，{report['input']['nodes']} 个节点；SHA-256：`{report['input']['sha256']}`。",
         "主路径为 standalone CNN 编译器，固定启用常量合并；CompilerDriver 两种分配器仅作补充回归。",
@@ -392,7 +411,7 @@ def markdown(report: dict) -> str:
               "未建模指令作为调度边界：自身固定，前后指令分别在各自区域内分析，禁止跨越该边界移动。其他未建模原因及所在行见 JSON 的 `scheduling.diagnostics`；CFG 活跃性遇到未知寄存器语义时标为 N/A，不能解释为零活跃寄存器。",
               "",
               "测试对象与结论范围：", "",
-              "- **CompilerDriver 是补充编译回归。** 它将 Conv/Gemm 等算子简化为少量乘加，没有展开完整张量计算；与 standalone 的静态指令数差异不能归因于调度。完整执行列的 `not_run` 表示未执行机器码做结果验证；静态结构检查通过不等于完整 CNN 推理正确。",
+              "- **CompilerDriver 是补充编译回归。** 旧标量后端拒绝 CNN 张量输入，拒绝原因单列于 `unsupported_cases`，不提供虚构的汇编或周期数据。完整执行列的 `not_run` 表示未执行机器码做结果验证；静态结构检查通过不等于完整 CNN 推理正确。",
               "- **静态区域只计一次。** 完整 standalone 代码也包含循环；例如 4 条循环体指令执行 1000 次，静态仍是 4 条，动态执行量为 4000 次。报告不按循环次数或分支频率加权，各区域从周期 0、入口操作数就绪开始独立估算，没有贯通跨区域的动态等待。",
               "- **性能结论限于模型。** llvm-mca 使用 SiFive7 的资源约束；报告未测量真实硬件周期、缓存未命中或分支预测开销，因此局部周期合计下降不能直接换算为整网运行时间下降。",
               "- **执行验证覆盖已测输入。** QEMU 用于比较调度前后执行状态，不用于测量硬件加速；固定输入上的一致性不等于所有输入的证明，也不验证定点结果与 ONNX 浮点参考的精度。", ""]
 
@@ -1,7 +1,7 @@
 """Compare shared-pipeline compilation with IR verification disabled/enabled.
 
 Run with ``python -m benchmarks.bench_ir_verifier``. Timings include parsing,
-optimizations, code generation and writing output; they are not model runtime.
+optimizations, IR serialization and writing output; they are not model runtime.
 """
 
 from __future__ import annotations
@@ -89,7 +89,7 @@ def benchmark(model: Path, *, repeats: int = 5, warmup: int = 1,
     model_hash = hashlib.sha256(model.read_bytes()).hexdigest()
     rows = []
     with tempfile.TemporaryDirectory(prefix="scratchv-ir-bench-") as directory:
-        output = str(Path(directory) / "output.s")
+        output = str(Path(directory) / "output.ir")
         for level in levels:
             samples = {False: [], True: []}
             reference = None
@@ -98,7 +98,7 @@ def benchmark(model: Path, *, repeats: int = 5, warmup: int = 1,
                 order = (False, True) if iteration % 2 == 0 else (True, False)
                 for enabled in order:
                     driver = CompilerDriver(CompilerConfig(
-                        backend="riscv", optimize_level=level, verify_ir=enabled,
+                        backend="ir", optimize_level=level, verify_ir=enabled,
                     ))
                     start = time.perf_counter()
                     result = driver.compile(str(model), output)
@@ -115,7 +115,7 @@ def benchmark(model: Path, *, repeats: int = 5, warmup: int = 1,
                         reference = digest
                     elif digest != reference:
                         raise RuntimeError(
-                            f"optimize={level}: generated assembly differs between runs"
+                            f"optimize={level}: generated IR differs between runs"
                         )
                     if iteration >= warmup:
                         samples[enabled].append(elapsed)
@@ -135,20 +135,20 @@ def benchmark(model: Path, *, repeats: int = 5, warmup: int = 1,
     return {
         "model": str(model), "model_sha256": model_hash,
         "python": platform.python_version(), "platform": platform.platform(),
-        "backend": "riscv", "repeats": repeats, "warmup": warmup,
-        "timing_scope": "parse + optimize + codegen + output write",
+        "backend": "ir", "repeats": repeats, "warmup": warmup,
+        "timing_scope": "parse + optimize + IR serialization + output write",
         "results": rows,
     }
 
 
 def render_markdown(report: dict) -> str:
     lines = [
         "# Topic 21 IR 验证器：编译耗时与规则示例", "",
-        f"模型：`{Path(report['model']).name}`；后端：RISC-V；"
+        f"模型：`{Path(report['model']).name}`；输出：优化后 IR；"
         f"预热 {report['warmup']} 次，采样 {report['repeats']} 次，取中位数。", "",
         "通过 CompilerConfig.verify_ir 开关，在正式编译流程的解析后、每个 IR pass "
         "前后和代码生成前验证。两组均重新解析模型。", "",
-        "| 优化级别 | 关闭验证 (ms) | 开启验证 (ms) | 差值 (ms) | 差值 (%) | 汇编一致 |",
+        "| 优化级别 | 关闭验证 (ms) | 开启验证 (ms) | 差值 (ms) | 差值 (%) | IR 一致 |",
         "| --- | ---: | ---: | ---: | ---: | --- |",
     ]
     for row in report["results"]:
@@ -160,10 +160,11 @@ def render_markdown(report: dict) -> str:
             f"| {row['overhead_s'] * 1000:.3f} | {percent_text} | 是 |"
         )
     lines.extend([
-        "", "计时包含解析、优化、代码生成和写文件，不是模型运行耗时，也不是验证器函数的独立耗时。",
+        "", "计时包含解析、优化、IR 序列化和写文件，不是模型运行耗时，也不是验证器函数的独立耗时。",
         "差值可能受测量噪声影响而为负；不以耗时差值作为 CI 通过门槛。"
-        "编译或验证失败、汇编内容不一致会使 benchmark 失败。",
-        "汇编一致仅检查开关未改变生成结果，不代表与 ONNX Runtime 数值等价。", "",
+        "编译或验证失败、IR 内容不一致会使 benchmark 失败。",
+        "IR 一致仅检查开关未改变生成结果，不代表与 ONNX Runtime 数值等价。"
+        "张量图不再交给仅支持标量的旧后端；本报告不能与旧 RISC-V 代码生成计时直接比较。", "",
     ])
     if "rule_examples" in report:
         lines.extend(["## 七条规则的诊断示例", ""])
 
@@ -1,19 +1,31 @@
 """Run complete standalone CNN binaries under QEMU user mode and compare state."""
 
 import hashlib
+import os
 from pathlib import Path
-import resource
 import shutil
 import struct
 import subprocess
 
 
+def qemu_process_options() -> dict:
+    """Suppress Unix core dumps without requiring Unix-only APIs on Windows."""
+    if os.name != "posix":
+        return {}
+    import resource
+
+    return {"preexec_fn": lambda: resource.setrlimit(resource.RLIMIT_CORE, (0, 0))}
+
+
 def assemble_listing(source: Path, directory: Path) -> bytes:
+    tools = {name: shutil.which(name) for name in ("clang", "ld.lld")}
+    if not all(tools.values()):
+        raise RuntimeError(f"CNN assembly requires clang and ld.lld: {tools}")
     obj, binary = directory / "roundtrip.o", directory / "roundtrip.bin"
-    subprocess.run(["clang", "--target=riscv32-unknown-elf", "-march=rv32im", "-mabi=ilp32",
+    subprocess.run([tools["clang"], "--target=riscv32-unknown-elf", "-march=rv32im", "-mabi=ilp32",
                     "-mno-relax", "-c", str(source), "-o", str(obj)],
                    capture_output=True, check=True, timeout=30)
-    subprocess.run(["ld.lld", "-m", "elf32lriscv", "--no-relax", "--image-base=0", "-Ttext=0", "-e", "0",
+    subprocess.run([tools["ld.lld"], "-m", "elf32lriscv", "--no-relax", "--image-base=0", "-Ttext=0", "-e", "0",
                     "--oformat=binary", str(obj), "-o", str(binary)],
                    capture_output=True, check=True, timeout=30)
     return binary.read_bytes()
@@ -83,7 +95,7 @@ def execute_pair(before: Path, after: Path, metadata: dict, directory: Path) ->
                             "-nostdlib", "-static", "-fuse-ld=lld", "-Wl,--no-relax", str(asm), "-o", str(elf)],
                            check=True, capture_output=True, timeout=30)
             result = subprocess.run([tools["qemu-riscv32"], str(elf)], capture_output=True, timeout=60,
-                                    preexec_fn=lambda: resource.setrlimit(resource.RLIMIT_CORE, (0, 0)))
+                                    **qemu_process_options())
             if result.returncode or len(result.stdout) != total:
                 reason = (f"Full CNN {phase} failed: return={result.returncode}, "
                           f"bytes={len(result.stdout)}/{total}, stderr={result.stderr.decode(errors='replace')}")