fix(rocke): address #13205 review: develop merge, sinks gates, case study

.github/actions/ci-env/action.yml

@@ -4,7 +4,7 @@ description: "Single source of truth for shared CI constants (TheRock ref, Docke
 outputs:
   therock-ref:
     description: "TheRock commit hash to use"
-    value: "05add1921fd03b0649f054ec2a7c54d162c0cd99" # 2026-10-08
+    value: "c01e3a3f3f67966dd35612cf363b49964f33cd47" # 2026-10-12
   kpack-ref:
     description: "rocm-systems commit whose shared/kpack provides the rocm_kpack packing tooling"
     # Copied into dnn-providers/hip-kernel-provider/cmake/KpackPython.cmake and
@@ -13,7 +13,7 @@ outputs:
     value: "a022846cf553c2b135410a5168f97705f1b9c6ac" # 2026-08-22
   baseline-run-id:
     description: "TheRock workflow run ID for prebuilt stage artifacts"
-    value: "37655107204" # Updated by assistant-librarian[bot] on submodule bumps
+    value: "38220501023" # Updated by assistant-librarian[bot] on submodule bumps
   docker-image:
     description: "Docker container image for Linux builds"
     value: "ghcr.io/rocm/therock_build_manylinux_x86_64@sha256:cf4f6d9909056906e4a1c0bc4c245658a0af4c6a6174082a86adfa2d518b7aeb"

.github/scripts/check_probe_junit.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+# Copyright (c) Advanced Micro Devices, Inc., or its affiliates.
+# SPDX-License-Identifier: MIT
+
+"""Prove that every declared hipDNN packaging probe ran and passed.
+
+The superbuild lanes run the whole ctest suite once with --output-junit. ctest
+exits 0 when a test is disabled or not run, so this script reads that junit file
+and checks it against the manifest the CMake configure wrote (one ctest test
+name per line). Testcases not named in the manifest are ignored.
+
+The manifest always names the probe tooling test "hkp-probe-tools", plus one entry
+per declared probe. A lane whose GPU_TARGETS cover every architecture the
+descriptors name declares no probe, so "hkp-probe-tools" alone is a valid manifest;
+an empty one means the configure did not write it properly.
+
+The manifest is written by the same configure that discovers the probes, so on its
+own it cannot tell "this lane builds every architecture" from "discovery found
+nothing". A lane that must always declare probes passes --min-probes N: the check
+fails when the manifest names fewer than N tests besides "hkp-probe-tools". The
+default is 0, which accepts a manifest with no probe.
+
+For every manifest name, the junit must hold exactly one testcase with that
+name, and that testcase must have run (status "run" or "fail"; without a status
+attribute, no <skipped> child) and must have no <failure> or <error> child.
+
+Usage:
+    check_probe_junit.py --junit build/ctest-junit.xml \
+        --manifest build/hkp-probes/manifest.txt [--min-probes N]
+
+Exit codes:
+    0  every manifest name ran exactly once and passed
+    1  one or more checks failed; each prints
+       "check_probe_junit: FAIL <id>: <detail>", where <id> is one of
+       manifest-unreadable, manifest-too-small, probes-too-few, junit-unreadable,
+       name-missing, name-duplicate, not-run, failure, error
+"""
+
+import argparse
+import sys
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+# The "hkp-probe-tools" test; probes are optional unless --min-probes asks for them.
+MIN_MANIFEST_ENTRIES = 1
+TOOLS_TEST = "hkp-probe-tools"
+
+
+def read_manifest(path: Path) -> list[str]:
+    return [line.strip() for line in path.read_text().splitlines() if line.strip()]
+
+
+def ran(case: ET.Element) -> bool:
+    """Return whether ctest ran the testcase.
+
+    ctest writes status "run", "fail", "disabled" or "notrun"; only the first
+    two mean the test executed.
+    """
+    status = case.get("status")
+    if status is None:
+        return case.find("skipped") is None
+    return status in ("run", "fail")
+
+
+def check(
+    junit_path: Path, manifest_path: Path, min_probes: int = 0
+) -> list[tuple[str, str]]:
+    """Return (id, detail) for every failed check; empty means green."""
+    try:
+        names = read_manifest(manifest_path)
+    except OSError as exc:
+        return [("manifest-unreadable", f"{manifest_path}: {exc}")]
+
+    failures: list[tuple[str, str]] = []
+    if len(names) < MIN_MANIFEST_ENTRIES:
+        failures.append(
+            (
+                "manifest-too-small",
+                f"{manifest_path} lists {len(names)} test(s), expected at least "
+                f"{MIN_MANIFEST_ENTRIES} (hkp-probe-tools)",
+            )
+        )
+
+    probes = [name for name in names if name != TOOLS_TEST]
+    if len(probes) < min_probes:
+        failures.append(
+            (
+                "probes-too-few",
+                f"{manifest_path} declares {len(probes)} probe(s), expected at "
+                f"least {min_probes}; if this lane now builds every architecture "
+                f"the descriptors name, drop --min-probes for it, otherwise probe "
+                f"discovery found nothing",
+            )
+        )
+
+    try:
+        root = ET.parse(junit_path).getroot()
+    except (OSError, ET.ParseError) as exc:
+        failures.append(("junit-unreadable", f"{junit_path}: {exc}"))
+        return failures
+
+    cases: dict[str, list[ET.Element]] = {name: [] for name in names}
+    for case in root.iter("testcase"):
+        found = cases.get(case.get("name", ""))
+        if found is not None:
+            found.append(case)
+
+    for name, found in cases.items():
+        if not found:
+            failures.append(
+                ("name-missing", f"declared test '{name}' is not in the junit")
+            )
+            continue
+        if len(found) > 1:
+            failures.append(
+                (
+                    "name-duplicate",
+                    f"declared test '{name}' appears {len(found)} times in the junit",
+                )
+            )
+        for case in found:
+            if not ran(case):
+                status = case.get("status")
+                failures.append(
+                    ("not-run", f"test '{name}' did not run (status={status})")
+                )
+            if case.get("status") == "fail" or case.find("failure") is not None:
+                failures.append(("failure", f"test '{name}' failed"))
+            if case.find("error") is not None:
+                failures.append(("error", f"test '{name}' errored"))
+
+    return failures
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument(
+        "--junit", required=True, type=Path, help="ctest --output-junit file"
+    )
+    parser.add_argument(
+        "--manifest",
+        required=True,
+        type=Path,
+        help="file listing one declared ctest test name per line",
+    )
+    parser.add_argument(
+        "--min-probes",
+        type=int,
+        default=0,
+        help="fail when the manifest names fewer probes than this, not counting "
+        f"{TOOLS_TEST} (default 0: no probe is acceptable)",
+    )
+    args = parser.parse_args(argv)
+
+    failures = check(args.junit, args.manifest, args.min_probes)
+    for check_id, detail in failures:
+        print(f"check_probe_junit: FAIL {check_id}: {detail}")
+    if failures:
+        return 1
+    count = len(read_manifest(args.manifest))
+    print(f"check_probe_junit: OK {count} declared test(s) ran and passed")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

.github/scripts/tests/test_check_probe_junit.py

@@ -0,0 +1,160 @@
+# Copyright (c) Advanced Micro Devices, Inc., or its affiliates.
+# SPDX-License-Identifier: MIT
+
+import os
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, os.fspath(Path(__file__).parent.parent))
+import check_probe_junit as cpj
+
+MANIFEST = ["hkp-probe-gfx950", "hkp-probe-tools"]
+
+
+def case_xml(name: str, child: str = "", status: str | None = None) -> str:
+    body = f"<{child}/>" if child else ""
+    if status is None:
+        status = {"skipped": "notrun", "failure": "fail"}.get(child, "run")
+    status_attr = f' status="{status}"' if status else ""
+    return (
+        f'<testcase name="{name}" classname="{name}" time="1"{status_attr}>'
+        f"{body}</testcase>"
+    )
+
+
+def junit_xml(cases: list[str]) -> str:
+    return (
+        '<?xml version="1.0" encoding="UTF-8"?>'
+        f'<testsuite name="(empty)" tests="{len(cases)}">{"".join(cases)}</testsuite>'
+    )
+
+
+class CheckProbeJunitTest(unittest.TestCase):
+    def setUp(self):
+        tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(tmp.cleanup)
+        self.dir = Path(tmp.name)
+
+    def run_check(
+        self, xml: str, manifest: list[str], min_probes: int = 0
+    ) -> list[str]:
+        junit_path = self.dir / "ctest-junit.xml"
+        manifest_path = self.dir / "manifest.txt"
+        junit_path.write_text(xml)
+        manifest_path.write_text("".join(f"{n}\n" for n in manifest))
+        return [
+            check_id for check_id, _ in cpj.check(junit_path, manifest_path, min_probes)
+        ]
+
+    def test_all_declared_tests_passed(self):
+        xml = junit_xml([case_xml(n) for n in MANIFEST])
+        self.assertEqual(self.run_check(xml, MANIFEST), [])
+
+    def test_skipped_test_fails(self):
+        xml = junit_xml([case_xml(MANIFEST[0]), case_xml(MANIFEST[1], "skipped")])
+        self.assertEqual(self.run_check(xml, MANIFEST), ["not-run"])
+
+    def test_disabled_test_without_skipped_child_fails(self):
+        xml = junit_xml(
+            [case_xml(MANIFEST[0], status="disabled"), case_xml(MANIFEST[1])]
+        )
+        self.assertEqual(self.run_check(xml, MANIFEST), ["not-run"])
+
+    def test_unknown_status_fails(self):
+        xml = junit_xml([case_xml(MANIFEST[0], status="bogus"), case_xml(MANIFEST[1])])
+        self.assertEqual(self.run_check(xml, MANIFEST), ["not-run"])
+
+    def test_skipped_child_without_status_fails(self):
+        xml = junit_xml(
+            [case_xml(MANIFEST[0], "skipped", status=""), case_xml(MANIFEST[1])]
+        )
+        self.assertEqual(self.run_check(xml, MANIFEST), ["not-run"])
+
+    def test_missing_status_without_skipped_child_passes(self):
+        xml = junit_xml([case_xml(n, status="") for n in MANIFEST])
+        self.assertEqual(self.run_check(xml, MANIFEST), [])
+
+    def test_unrelated_testcases_are_ignored(self):
+        xml = junit_xml(
+            [
+                case_xml("hipdnn-unit-tests"),
+                case_xml(MANIFEST[0]),
+                case_xml("other-disabled", status="disabled"),
+                case_xml("other-failed", "failure"),
+                case_xml(MANIFEST[1]),
+            ]
+        )
+        self.assertEqual(self.run_check(xml, MANIFEST), [])
+
+    def test_duplicate_declared_name_fails(self):
+        xml = junit_xml([case_xml(n) for n in MANIFEST] + [case_xml(MANIFEST[0])])
+        self.assertEqual(self.run_check(xml, MANIFEST), ["name-duplicate"])
+
+    def test_declared_name_missing_fails(self):
+        xml = junit_xml([case_xml(MANIFEST[0]), case_xml("hipdnn-unit-tests")])
+        self.assertEqual(self.run_check(xml, MANIFEST), ["name-missing"])
+
+    def test_empty_manifest_fails(self):
+        xml = junit_xml([case_xml(n) for n in MANIFEST])
+        self.assertIn("manifest-too-small", self.run_check(xml, []))
+
+    def test_manifest_without_probe_passes(self):
+        xml = junit_xml([case_xml("hkp-probe-tools")])
+        self.assertEqual(self.run_check(xml, ["hkp-probe-tools"]), [])
+
+    def test_failure_fails(self):
+        xml = junit_xml([case_xml(MANIFEST[0], "failure"), case_xml(MANIFEST[1])])
+        self.assertEqual(self.run_check(xml, MANIFEST), ["failure"])
+
+    def test_fail_status_without_failure_child_fails(self):
+        xml = junit_xml([case_xml(MANIFEST[0], status="fail"), case_xml(MANIFEST[1])])
+        self.assertEqual(self.run_check(xml, MANIFEST), ["failure"])
+
+    def test_error_fails(self):
+        xml = junit_xml([case_xml(MANIFEST[0]), case_xml(MANIFEST[1], "error")])
+        self.assertEqual(self.run_check(xml, MANIFEST), ["error"])
+
+    def test_unparseable_junit_fails(self):
+        self.assertEqual(self.run_check("<testsuite", MANIFEST), ["junit-unreadable"])
+
+    def test_min_probes_fails_on_tools_only_manifest(self):
+        xml = junit_xml([case_xml("hkp-probe-tools")])
+        self.assertEqual(
+            self.run_check(xml, ["hkp-probe-tools"], min_probes=1),
+            ["probes-too-few"],
+        )
+
+    def test_min_probes_met_passes(self):
+        xml = junit_xml([case_xml(n) for n in MANIFEST])
+        self.assertEqual(self.run_check(xml, MANIFEST, min_probes=1), [])
+
+    def test_missing_manifest_fails(self):
+        junit_path = self.dir / "ctest-junit.xml"
+        junit_path.write_text(junit_xml([case_xml(n) for n in MANIFEST]))
+        failures = cpj.check(junit_path, self.dir / "absent.txt")
+        self.assertEqual([c for c, _ in failures], ["manifest-unreadable"])
+
+    def test_main_exit_codes(self):
+        junit_path = self.dir / "ctest-junit.xml"
+        manifest_path = self.dir / "manifest.txt"
+        manifest_path.write_text("".join(f"{n}\n" for n in MANIFEST))
+        argv = [
+            "--junit",
+            os.fspath(junit_path),
+            "--manifest",
+            os.fspath(manifest_path),
+        ]
+        junit_path.write_text(junit_xml([case_xml(n) for n in MANIFEST]))
+        self.assertEqual(cpj.main(argv), 0)
+        junit_path.write_text(junit_xml([case_xml(MANIFEST[0])]))
+        self.assertEqual(cpj.main(argv), 1)
+        junit_path.write_text(junit_xml([case_xml("hkp-probe-tools")]))
+        manifest_path.write_text("hkp-probe-tools\n")
+        self.assertEqual(cpj.main(argv), 0)
+        self.assertEqual(cpj.main([*argv, "--min-probes", "1"]), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()