fix(mi300x): driverless Triton AOT + HIP exe link for the gfx942 image

Rebuilding the MI300X image surfaced two breakages vs the current tree:

1. Triton 3.7.0's tools/compile.py touches driver.active in two spots that
   need a live GPU despite an explicit --target, so the AITER AOT step died
   in the no-GPU rootless podman build ("0 active drivers"). Add
   patch_triton_driverless_aot.py (drop create_binder + use triton.compiler
   .ASTSource directly; import ty_to_cpp from the amd backend module) and a
   build-time gate that AOT-compiles for gfx942 with NO GPU and fails the
   build if artifacts stop emitting -- the old `--help | grep --target` only
   proved the flag existed, which is how the regression shipped.

2. llama-perplexity failed to link (undefined hip* refs, disallowed by
   --no-allow-shlib-undefined). Add -DCMAKE_EXE_LINKER_FLAGS so the exe links
   the HIP runtime (-L/opt/rocm/lib -lamdhip64), matching the local build.

Verified: gfx942 AOT artifacts emit with no GPU; v2 builds + tags clean.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: kmbandy

ggml/src/ggml-cuda/aiter-integration/cmake/patch_triton_driverless_aot.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""Make Triton's AOT compiler (tools/compile.py) DRIVERLESS.
+
+Why this exists
+---------------
+Triton 3.7.0 (the pinned 4768da5e the MI300X image builds) regressed ahead-of-time
+compilation: `triton.tools.compile.compile_kernel()` touches `driver.active` in two
+spots that require a *live* GPU, even when an explicit `--target hip:gfx942:64` is
+passed. A rootless `podman build` container has no GPU, so the AITER AOT step dies
+with `RuntimeError: 0 active drivers ([])`. AOT cross-compilation must NOT need the
+target (or any) GPU — that's the entire point of compiling ahead of time.
+
+Both accesses are gratuitous:
+  1. `kernel.create_binder()` -> jit.py `driver.active.get_current_target()`. The
+     binder is a *runtime-launch* helper; AOT only needs `ASTSource`. Older Triton
+     called `triton.compiler.ASTSource(...)` directly, with no binder.
+  2. `ty_to_cpp = driver.active.map_python_to_cpp_type`. That method body is just
+     `return ty_to_cpp(ty)` (the instance `self` is unused) — a thin shim over the
+     module-level `ty_to_cpp` in the AMD backend driver. Import it directly.
+
+After patching, `python3 -m triton.tools.compile ... --target hip:gfx942:64` emits
+real gfx942 HIP AOT artifacts with no GPU present (verified: emits the .c/.h pair).
+
+This patch is AMD/HIP-specific (the image only ever AOT-compiles `hip:gfx942`), and
+idempotent. If an anchor is missing AND the patched form is also absent, it exits
+non-zero so a Triton version bump can't silently reintroduce the GPU dependency.
+
+Usage:  patch_triton_driverless_aot.py [/opt/triton]
+"""
+import sys
+from pathlib import Path
+
+root = Path(sys.argv[1] if len(sys.argv) > 1 else "/opt/triton")
+target = root / "python" / "triton" / "tools" / "compile.py"
+if not target.is_file():
+    sys.exit(f"[patch_triton_driverless_aot] not found: {target}")
+
+src = target.read_text()
+
+# (anchor, replacement). An empty replacement means "delete the anchor line".
+EDITS = [
+    # 1a. drop the runtime-only binder (needs the live driver's current target)
+    ("    kernel.create_binder()\n", ""),
+    # 1b. ...and source the AST directly instead of via the binder's class attr
+    ("src = kernel.ASTSource(", "src = triton.compiler.ASTSource("),
+    # 2. pull the python->c++ type map from the module, not the live driver instance
+    ("ty_to_cpp = triton.runtime.driver.active.map_python_to_cpp_type",
+     "from triton.backends.amd.driver import ty_to_cpp"),
+]
+
+for anchor, repl in EDITS:
+    if anchor in src:
+        src = src.replace(anchor, repl)
+        continue
+    # idempotent: already patched?  removal -> anchor simply absent; replace -> repl present
+    if repl == "" or repl in src:
+        continue
+    sys.exit(
+        f"[patch_triton_driverless_aot] ANCHOR NOT FOUND: {anchor!r}\n"
+        f"  Triton's AOT source changed — re-verify the driverless fix before trusting it."
+    )
+
+target.write_text(src)
+print(f"[patch_triton_driverless_aot] patched {target} — AOT is now driverless (gfx942, no GPU)")

scripts/calibration/mi300x/Dockerfile

@@ -50,6 +50,25 @@ WORKDIR /opt/mad-lab/llama.cpp
 # local build trees, model blobs, and datasets so the context stays ~800 MB.
 COPY . .
 
+# --- Make Triton's AOT compiler DRIVERLESS, then PROVE it with no GPU ---
+# Triton 3.7.0's tools/compile.py touches driver.active in two spots that need a
+# live GPU even with an explicit --target; a rootless `podman build` has none, so
+# the AITER AOT step below would die with "0 active drivers". The patcher removes
+# that gratuitous coupling (cross-compilation must not need the target GPU). The
+# gate then AOT-compiles a kernel for gfx942 with NO GPU and fails the build if it
+# ever stops emitting artifacts — the `--help | grep --target` check only proved
+# the flag EXISTS, which is how the original regression shipped. (The Triton install
+# above stays cached; this runs post-COPY so the patcher is in the context.) #170.
+RUN python3 ggml/src/ggml-cuda/aiter-integration/cmake/patch_triton_driverless_aot.py /opt/triton && \
+    python3 -m triton.tools.compile ggml/src/ggml-cuda/aiter-integration/kernels/vector_add.py \
+        --kernel-name add_kernel --target hip:gfx942:64 \
+        --signature "*fp32:16, *fp32:16, *fp32:16, i32, 1024" \
+        --grid "n_elements / 1024, 1, 1" --num-warps 4 --num-stages 1 \
+        --out-name _aotgate --out-path /tmp/_aotgate && \
+    ls /tmp/_aotgate*.c >/dev/null 2>&1 && \
+    echo "[gate] driverless Triton AOT OK (gfx942 artifacts emitted, no GPU)" && \
+    rm -f /tmp/_aotgate*
+
 # --- build llama.cpp HIP libs + the perplexity binary for gfx942 ---
 # GGML_NATIVE=OFF: the local build bakes -march=native for THIS host CPU; off here
 # so the image runs on whatever CPU the MI300X host has.
@@ -72,7 +91,8 @@ RUN cmake -S . -B build-hip -G Ninja \
         -DGGML_NATIVE=OFF -DGGML_RPC=OFF -DLLAMA_CURL=OFF \
         -DCMAKE_C_COMPILER=/opt/rocm/llvm/bin/clang \
         -DCMAKE_CXX_COMPILER=/opt/rocm/llvm/bin/clang++ \
-        -DCMAKE_HIP_COMPILER=/opt/rocm/llvm/bin/clang++ && \
+        -DCMAKE_HIP_COMPILER=/opt/rocm/llvm/bin/clang++ \
+        -DCMAKE_EXE_LINKER_FLAGS="-L/opt/rocm/lib -lamdhip64" && \
     cmake --build build-hip --target llama llama-perplexity -j"${JOBS:-$(nproc)}" && \
     test -e build-hip/bin/libllama.so && test -e build-hip/bin/llama-perplexity