nvprobe 0.1.0__py3-none-any.whl

nvprobe/__init__.py

@@ -0,0 +1,3 @@
+"""nvProbe — NVIDIA GPU benchmark suite for CUDA workload automation."""
+
+__version__ = "0.1.0"

nvprobe/benchmarks/__init__.py

@@ -0,0 +1,24 @@
+"""Benchmark modules for nvProbe."""
+
+from nvprobe.benchmarks.bandwidth import BandwidthBenchmark
+from nvprobe.benchmarks.custom import CustomCudaBenchmark
+from nvprobe.benchmarks.hpl import HplBenchmark
+from nvprobe.benchmarks.hpcg import HpcgBenchmark
+from nvprobe.benchmarks.mlperf import MlperfBenchmark
+
+BENCHMARK_REGISTRY: dict[str, type] = {
+    "bandwidth": BandwidthBenchmark,
+    "custom": CustomCudaBenchmark,
+    "hpl": HplBenchmark,
+    "hpcg": HpcgBenchmark,
+    "mlperf": MlperfBenchmark,
+}
+
+__all__ = [
+    "BENCHMARK_REGISTRY",
+    "BandwidthBenchmark",
+    "CustomCudaBenchmark",
+    "HplBenchmark",
+    "HpcgBenchmark",
+    "MlperfBenchmark",
+]

nvprobe/benchmarks/_cuda/__init__.py

@@ -0,0 +1 @@
+"""nvProbe CUDA test modules — called as subprocesses by benchmark runners."""

nvprobe/benchmarks/_cuda/bandwidth_test.py

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+"""Memory bandwidth benchmark — measures host↔device and device↔device transfer rates.
+
+Usage:
+    python -m nvprobe.benchmarks._cuda.bandwidth_test \
+        --gpu 0 --sizes 1,4,16,64,256,1024 --iterations 100 --precision fp32
+
+Output: JSON to stdout with per-size bandwidth measurements.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import time
+from typing import Any
+
+import cupy as cp
+
+from nvprobe.benchmarks._cuda.utils import get_gpu_info, output_json
+
+
+def run_bandwidth_test(
+    gpu_index: int,
+    sizes_mb: list[int],
+    iterations: int,
+    precision: str,
+) -> dict[str, Any]:
+    """Run bandwidth test across specified buffer sizes."""
+    cp.cuda.Device(gpu_index).use()
+
+    dtype_map = {
+        "fp32": cp.float32,
+        "fp16": cp.float16,
+        "int8": cp.int8,
+    }
+    dtype = dtype_map.get(precision, cp.float32)
+
+    results: dict[str, Any] = {"h2d": {}, "d2h": {}, "d2d": {}}
+
+    for size_mb in sizes_mb:
+        n_elements = (size_mb * 1024 * 1024) // dtype.itemsize
+        host_data = cp.ones(n_elements, dtype=dtype)
+        device_data = cp.empty(n_elements, dtype=dtype)
+
+        # Warmup
+        for _ in range(min(10, iterations)):
+            device_data.copy_from(host_data)
+            cp.cuda.Stream.null.synchronize()
+
+        # Host → Device
+        start = cp.cuda.Event()
+        end = cp.cuda.Event()
+        start.record()
+        for _ in range(iterations):
+            device_data.copy_from(host_data)
+        end.record()
+        end.synchronize()
+        h2d_ms = cp.cuda.get_elapsed_time(start, end)
+        h2d_bw = (size_mb * iterations) / (h2d_ms / 1000)  # MB/s
+        results["h2d"][str(size_mb)] = round(h2d_bw, 2)
+
+        # Device → Host
+        start.record()
+        for _ in range(iterations):
+            host_data.copy_from(device_data)
+        end.record()
+        end.synchronize()
+        d2h_ms = cp.cuda.get_elapsed_time(start, end)
+        d2h_bw = (size_mb * iterations) / (d2h_ms / 1000)
+        results["d2h"][str(size_mb)] = round(d2h_bw, 2)
+
+        # Device → Device
+        device_data2 = cp.empty(n_elements, dtype=dtype)
+        start.record()
+        for _ in range(iterations):
+            device_data2.copy_from(device_data)
+        end.record()
+        end.synchronize()
+        d2d_ms = cp.cuda.get_elapsed_time(start, end)
+        d2d_bw = (size_mb * iterations) / (d2d_ms / 1000)
+        results["d2d"][str(size_mb)] = round(d2d_bw, 2)
+
+    return results
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="nvProbe Bandwidth Test")
+    parser.add_argument("--gpu", type=int, default=0)
+    parser.add_argument("--sizes", type=str, default="1,4,16,64,256,1024")
+    parser.add_argument("--iterations", type=int, default=100)
+    parser.add_argument("--precision", type=str, default="fp32")
+    args = parser.parse_args()
+
+    sizes = [int(s) for s in args.sizes.split(",")]
+    gpu_info = get_gpu_info(args.gpu)
+    bw_results = run_bandwidth_test(args.gpu, sizes, args.iterations, args.precision)
+
+    output_json({
+        "benchmark": "bandwidth",
+        "gpu_model": gpu_info["model"],
+        "gpu_index": args.gpu,
+        "precision": args.precision,
+        "iterations": args.iterations,
+        "sizes_mb": sizes,
+        "metrics": bw_results,
+    })
+
+
+if __name__ == "__main__":
+    main()

nvprobe/benchmarks/_cuda/custom_kernels.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+"""Custom CUDA kernels benchmark — matmul, conv2d, attention microbenchmarks.
+
+Usage:
+    python -m nvprobe.benchmarks._cuda.custom_kernels \
+        --gpu 0 --kernels matmul,conv2d,attention \
+        --sizes 512,1024,2048 --iterations 50 --precision fp32 --batch-size 32
+
+Output: JSON to stdout with per-kernel, per-size performance metrics.
+"""
+
+from __future__ import annotations
+
+import argparse
+import time
+from typing import Any
+
+import cupy as cp
+from cupyx.scipy import ndimage as cp_ndimage
+
+from nvprobe.benchmarks._cuda.utils import get_gpu_info, output_json
+
+
+def bench_matmul(gpu_index: int, sizes: list[int], iterations: int, precision: str, batch_size: int) -> dict[str, Any]:
+    """Benchmark matrix multiplication."""
+    cp.cuda.Device(gpu_index).use()
+    dtype = cp.float32 if precision == "fp32" else cp.float16 if precision == "fp16" else cp.float32
+    results: dict[str, Any] = {}
+
+    for n in sizes:
+        a = cp.random.random((batch_size, n, n), dtype=dtype)
+        b = cp.random.random((batch_size, n, n), dtype=dtype)
+
+        # Warmup
+        for _ in range(min(5, iterations)):
+            _ = a @ b
+        cp.cuda.Stream.null.synchronize()
+
+        start = cp.cuda.Event()
+        end = cp.cuda.Event()
+        start.record()
+        for _ in range(iterations):
+            _ = a @ b
+        end.record()
+        end.synchronize()
+
+        elapsed_ms = cp.cuda.get_elapsed_time(start, end)
+        avg_ms = elapsed_ms / iterations
+        # GFLOPS = 2 * batch_size * n^3 / (avg_time_in_seconds * 1e9)
+        gflops = (2 * batch_size * n**3) / (avg_ms / 1000 * 1e9)
+        results[str(n)] = {"avg_ms": round(avg_ms, 4), "gflops": round(gflops, 2)}
+
+    return results
+
+
+def bench_conv2d(gpu_index: int, sizes: list[int], iterations: int, precision: str, batch_size: int) -> dict[str, Any]:
+    """Benchmark 2D convolution."""
+    cp.cuda.Device(gpu_index).use()
+    dtype = cp.float32 if precision == "fp32" else cp.float16 if precision == "fp16" else cp.float32
+    results: dict[str, Any] = {}
+
+    for n in sizes:
+        channels = 64
+        kernel_size = 3
+        inp = cp.random.random((batch_size, channels, n, n), dtype=dtype)
+        weight = cp.random.random((channels, channels, kernel_size, kernel_size), dtype=dtype)
+
+        # Warmup using correlation (equivalent to conv2d)
+        for _ in range(min(5, iterations)):
+            for b in range(batch_size):
+                for c_out in range(channels):
+                    cp_ndimage.correlate(inp[b, 0], weight[c_out, 0], mode="constant")
+        cp.cuda.Stream.null.synchronize()
+
+        start = cp.cuda.Event()
+        end = cp.cuda.Event()
+        start.record()
+        for _ in range(iterations):
+            for b in range(batch_size):
+                for c_out in range(min(4, channels)):
+                    cp_ndimage.correlate(inp[b, 0], weight[c_out, 0], mode="constant")
+        end.record()
+        end.synchronize()
+
+        elapsed_ms = cp.cuda.get_elapsed_time(start, end)
+        avg_ms = elapsed_ms / iterations
+        results[str(n)] = {"avg_ms": round(avg_ms, 4), "throughput": round(batch_size * min(4, channels) * iterations / (elapsed_ms / 1000), 2)}
+
+    return results
+
+
+def bench_attention(gpu_index: int, sizes: list[int], iterations: int, precision: str, batch_size: int) -> dict[str, Any]:
+    """Benchmark scaled dot-product attention: Q @ K^T / sqrt(d) @ V."""
+    cp.cuda.Device(gpu_index).use()
+    dtype = cp.float32 if precision == "fp32" else cp.float16 if precision == "fp16" else cp.float32
+    results: dict[str, Any] = {}
+
+    for seq_len in sizes:
+        d_model = min(128, seq_len)  # head dimension
+        q = cp.random.random((batch_size, seq_len, d_model), dtype=dtype)
+        k = cp.random.random((batch_size, seq_len, d_model), dtype=dtype)
+        v = cp.random.random((batch_size, seq_len, d_model), dtype=dtype)
+        scale = d_model ** -0.5
+
+        # Warmup
+        for _ in range(min(5, iterations)):
+            scores = q @ k.transpose(0, 2, 1) * scale
+            weights = cp.softmax(scores, axis=-1)
+            _ = weights @ v
+        cp.cuda.Stream.null.synchronize()
+
+        start = cp.cuda.Event()
+        end = cp.cuda.Event()
+        start.record()
+        for _ in range(iterations):
+            scores = q @ k.transpose(0, 2, 1) * scale
+            weights = cp.softmax(scores, axis=-1)
+            _ = weights @ v
+        end.record()
+        end.synchronize()
+
+        elapsed_ms = cp.cuda.get_elapsed_time(start, end)
+        avg_ms = elapsed_ms / iterations
+        # Approximate FLOPS: 2*B*S*D (Q@K^T) + B*S*S (softmax) + 2*B*S*D (W@V)
+        flops = 2 * batch_size * seq_len * d_model + batch_size * seq_len * seq_len + 2 * batch_size * seq_len * d_model
+        tflops = flops / (avg_ms / 1000 * 1e12)
+        results[str(seq_len)] = {"avg_ms": round(avg_ms, 4), "tflops": round(tflops, 4)}
+
+    return results
+
+
+KERNEL_MAP = {
+    "matmul": bench_matmul,
+    "conv2d": bench_conv2d,
+    "attention": bench_attention,
+}
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="nvProbe Custom CUDA Kernels Benchmark")
+    parser.add_argument("--gpu", type=int, default=0)
+    parser.add_argument("--kernels", type=str, default="matmul")
+    parser.add_argument("--sizes", type=str, default="512,1024,2048")
+    parser.add_argument("--iterations", type=int, default=50)
+    parser.add_argument("--precision", type=str, default="fp32")
+    parser.add_argument("--batch-size", type=int, default=32)
+    args = parser.parse_args()
+
+    kernels = [k.strip() for k in args.kernels.split(",")]
+    sizes = [int(s) for s in args.sizes.split(",")]
+    gpu_info = get_gpu_info(args.gpu)
+
+    all_results: dict[str, Any] = {}
+    for kernel_name in kernels:
+        bench_fn = KERNEL_MAP.get(kernel_name)
+        if bench_fn is None:
+            all_results[kernel_name] = {"error": f"unknown kernel '{kernel_name}'"}
+            continue
+        all_results[kernel_name] = bench_fn(args.gpu, sizes, args.iterations, args.precision, args.batch_size)
+
+    output_json({
+        "benchmark": "custom",
+        "gpu_model": gpu_info["model"],
+        "gpu_index": args.gpu,
+        "precision": args.precision,
+        "batch_size": args.batch_size,
+        "iterations": args.iterations,
+        "kernels": kernels,
+        "metrics": all_results,
+    })
+
+
+if __name__ == "__main__":
+    main()

nvprobe/benchmarks/_cuda/utils.py

@@ -0,0 +1,29 @@
+"""Shared utilities for CUDA test modules."""
+
+from __future__ import annotations
+
+import json
+import sys
+from typing import Any
+
+
+def output_json(data: dict[str, Any]) -> None:
+    """Print result as JSON to stdout and exit."""
+    print(json.dumps(data, default=str))
+    sys.exit(0)
+
+
+def get_gpu_info(gpu_index: int) -> dict[str, Any]:
+    """Get GPU name and memory via cupy."""
+    try:
+        import cupy as cp
+        cp.cuda.Device(gpu_index).use()
+        mem = cp.cuda.Device(gpu_index).mem_info
+        props = cp.cuda.runtime.getDeviceProperties()
+        return {
+            "model": props["name"].decode() if isinstance(props["name"], bytes) else str(props["name"]),
+            "memory_total_mb": mem[1] // (1024 * 1024),
+            "memory_free_mb": mem[0] // (1024 * 1024),
+        }
+    except ImportError:
+        return {"model": "unknown (cupy not installed)", "memory_total_mb": 0, "memory_free_mb": 0}

nvprobe/benchmarks/bandwidth.py

@@ -0,0 +1,61 @@
+"""Bandwidth benchmark — measures memory bandwidth (host↔device, device↔device)."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from typing import Any
+
+from nvprobe.benchmarks.base import BaseBenchmark, BenchmarkResult
+
+
+class BandwidthBenchmark(BaseBenchmark):
+    """Memory bandwidth benchmark using cuda-memcheck or custom CUDA kernel."""
+
+    name = "bandwidth"
+
+    def run_local(self, gpu_index: int, precision: str, batch_size: int) -> BenchmarkResult:
+        sizes_mb = self.params.get("sizes_mb", [1, 4, 16, 64, 256, 1024])
+        iterations = self.params.get("iterations", 100)
+
+        cmd = [
+            "python3", "-m", "nvprobe.benchmarks._cuda.bandwidth_test",
+            "--gpu", str(gpu_index),
+            "--sizes", ",".join(str(s) for s in sizes_mb),
+            "--iterations", str(iterations),
+            "--precision", precision,
+        ]
+
+        try:
+            proc = subprocess.run(
+                cmd, capture_output=True, text=True, timeout=600, check=True,
+            )
+            data = json.loads(proc.stdout)
+            return BenchmarkResult(
+                benchmark=self.name,
+                gpu_model=data.get("gpu_model", "unknown"),
+                gpu_index=gpu_index,
+                precision=precision,
+                batch_size=batch_size,
+                metrics=data.get("metrics", {}),
+                raw_output=proc.stdout,
+            )
+        except (subprocess.CalledProcessError, json.JSONDecodeError, subprocess.TimeoutExpired) as exc:
+            return BenchmarkResult(
+                benchmark=self.name, gpu_model="unknown", gpu_index=gpu_index,
+                precision=precision, batch_size=batch_size,
+                success=False, error=str(exc),
+            )
+
+    def build_slurm_script(self, gpu_index: int, precision: str, batch_size: int) -> str:
+        """Return shell commands for this benchmark (without SBATCH headers)."""
+        sizes_mb = self.params.get("sizes_mb", [1, 4, 16, 64, 256, 1024])
+        iterations = self.params.get("iterations", 100)
+        return f"""export CUDA_VISIBLE_DEVICES={gpu_index}
+
+python3 -m nvprobe.benchmarks._cuda.bandwidth_test \\
+    --gpu 0 \\
+    --sizes {','.join(str(s) for s in sizes_mb)} \\
+    --iterations {iterations} \\
+    --precision {precision}
+"""

nvprobe/benchmarks/base.py

@@ -0,0 +1,51 @@
+"""Base class for all benchmark modules."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class BenchmarkResult:
+    """Result from a single benchmark execution."""
+
+    benchmark: str
+    gpu_model: str
+    gpu_index: int
+    precision: str
+    batch_size: int
+    metrics: dict[str, Any] = field(default_factory=dict)
+    raw_output: str = ""
+    success: bool = True
+    error: str = ""
+
+
+class BaseBenchmark(ABC):
+    """Abstract base for all benchmark implementations."""
+
+    name: str = "base"
+
+    def __init__(self, params: dict[str, Any]) -> None:
+        self.params = params
+
+    @abstractmethod
+    def run_local(self, gpu_index: int, precision: str, batch_size: int) -> BenchmarkResult:
+        """Run the benchmark locally on a specific GPU. Returns result."""
+
+    @abstractmethod
+    def build_slurm_script(self, gpu_index: int, precision: str, batch_size: int) -> str:
+        """Return sbatch script content for this benchmark."""
+
+    def parse_slurm_output(self, output: str, gpu_index: int, precision: str, batch_size: int) -> BenchmarkResult:
+        """Parse Slurm job output into a BenchmarkResult. Override for custom parsing."""
+        return BenchmarkResult(
+            benchmark=self.name,
+            gpu_model="unknown",
+            gpu_index=gpu_index,
+            precision=precision,
+            batch_size=batch_size,
+            raw_output=output,
+        )

nvprobe/benchmarks/custom.py

@@ -0,0 +1,67 @@
+"""Custom CUDA kernels benchmark — matmul, conv2d, attention microbenchmarks."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from typing import Any
+
+from nvprobe.benchmarks.base import BaseBenchmark, BenchmarkResult
+
+
+class CustomCudaBenchmark(BaseBenchmark):
+    """Benchmark user-defined CUDA kernels (matmul, conv2d, attention)."""
+
+    name = "custom"
+
+    def run_local(self, gpu_index: int, precision: str, batch_size: int) -> BenchmarkResult:
+        kernels = self.params.get("kernels", ["matmul"])
+        matrix_sizes = self.params.get("matrix_sizes", [1024])
+        iterations = self.params.get("iterations", 50)
+
+        cmd = [
+            "python3", "-m", "nvprobe.benchmarks._cuda.custom_kernels",
+            "--gpu", str(gpu_index),
+            "--kernels", ",".join(kernels),
+            "--sizes", ",".join(str(s) for s in matrix_sizes),
+            "--iterations", str(iterations),
+            "--precision", precision,
+            "--batch-size", str(batch_size),
+        ]
+
+        try:
+            proc = subprocess.run(
+                cmd, capture_output=True, text=True, timeout=1200, check=True,
+            )
+            data = json.loads(proc.stdout)
+            return BenchmarkResult(
+                benchmark=self.name,
+                gpu_model=data.get("gpu_model", "unknown"),
+                gpu_index=gpu_index,
+                precision=precision,
+                batch_size=batch_size,
+                metrics=data.get("metrics", {}),
+                raw_output=proc.stdout,
+            )
+        except (subprocess.CalledProcessError, json.JSONDecodeError, subprocess.TimeoutExpired) as exc:
+            return BenchmarkResult(
+                benchmark=self.name, gpu_model="unknown", gpu_index=gpu_index,
+                precision=precision, batch_size=batch_size,
+                success=False, error=str(exc),
+            )
+
+    def build_slurm_script(self, gpu_index: int, precision: str, batch_size: int) -> str:
+        """Return shell commands for this benchmark (without SBATCH headers)."""
+        kernels = self.params.get("kernels", ["matmul"])
+        matrix_sizes = self.params.get("matrix_sizes", [1024])
+        iterations = self.params.get("iterations", 50)
+        return f"""export CUDA_VISIBLE_DEVICES={gpu_index}
+
+python3 -m nvprobe.benchmarks._cuda.custom_kernels \\
+    --gpu 0 \\
+    --kernels {','.join(kernels)} \\
+    --sizes {','.join(str(s) for s in matrix_sizes)} \\
+    --iterations {iterations} \\
+    --precision {precision} \\
+    --batch-size {batch_size}
+"""

nvprobe/benchmarks/hpcg.py

@@ -0,0 +1,65 @@
+"""HPCG (High Performance Conjugate Gradients) benchmark wrapper."""
+
+from __future__ import annotations
+
+import subprocess
+from typing import Any
+
+from nvprobe.benchmarks.base import BaseBenchmark, BenchmarkResult
+
+
+class HpcgBenchmark(BaseBenchmark):
+    """Wrapper around a pre-compiled HPCG binary (xhpcg) via Slurm."""
+
+    name = "hpcg"
+
+    def run_local(self, gpu_index: int, precision: str, batch_size: int) -> BenchmarkResult:
+        binary = self.params.get("binary", "xhpcg")
+        grid_sizes = self.params.get("grid_sizes", [128])
+
+        try:
+            proc = subprocess.run(
+                [binary, "--grid", str(grid_sizes[0])],
+                capture_output=True, text=True, timeout=3600, check=True,
+                env={"CUDA_VISIBLE_DEVICES": str(gpu_index)},
+            )
+            gflops = _parse_hpcg_output(proc.stdout)
+            return BenchmarkResult(
+                benchmark=self.name,
+                gpu_model="unknown",
+                gpu_index=gpu_index,
+                precision=precision,
+                batch_size=batch_size,
+                metrics={"gflops": gflops, "grid_size": grid_sizes[0]},
+                raw_output=proc.stdout,
+            )
+        except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as exc:
+            return BenchmarkResult(
+                benchmark=self.name, gpu_model="unknown", gpu_index=gpu_index,
+                precision=precision, batch_size=batch_size,
+                success=False, error=str(exc),
+            )
+
+    def build_slurm_script(self, gpu_index: int, precision: str, batch_size: int) -> str:
+        """Return shell commands for this benchmark (without SBATCH headers)."""
+        binary = self.params.get("binary", "xhpcg")
+        grid_sizes = self.params.get("grid_sizes", [128])
+        return f"""export CUDA_VISIBLE_DEVICES={gpu_index}
+
+for GS in {' '.join(str(s) for s in grid_sizes)}; do
+    {binary} --grid $GS
+done
+"""
+
+
+def _parse_hpcg_output(output: str) -> float:
+    """Extract GFLOPS from HPCG output."""
+    for line in output.splitlines():
+        if "gflops" in line.lower():
+            parts = line.split()
+            for part in parts:
+                try:
+                    return float(part)
+                except ValueError:
+                    continue
+    return 0.0

nvprobe/benchmarks/hpl.py

@@ -0,0 +1,73 @@
+"""HPL (High Performance Linpack) benchmark wrapper."""
+
+from __future__ import annotations
+
+import subprocess
+from typing import Any
+
+from nvprobe.benchmarks.base import BaseBenchmark, BenchmarkResult
+
+
+class HplBenchmark(BaseBenchmark):
+    """Wrapper around a pre-compiled HPL binary (xhpl) via Slurm."""
+
+    name = "hpl"
+
+    def run_local(self, gpu_index: int, precision: str, batch_size: int) -> BenchmarkResult:
+        binary = self.params.get("binary", "xhpl")
+        problem_sizes = self.params.get("problem_sizes", [2048])
+
+        try:
+            proc = subprocess.run(
+                [binary, "--problem-size", str(problem_sizes[0])],
+                capture_output=True, text=True, timeout=3600, check=True,
+                env={"CUDA_VISIBLE_DEVICES": str(gpu_index)},
+            )
+            gflops = _parse_hpl_output(proc.stdout)
+            return BenchmarkResult(
+                benchmark=self.name,
+                gpu_model="unknown",
+                gpu_index=gpu_index,
+                precision=precision,
+                batch_size=batch_size,
+                metrics={"gflops": gflops, "problem_size": problem_sizes[0]},
+                raw_output=proc.stdout,
+            )
+        except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as exc:
+            return BenchmarkResult(
+                benchmark=self.name, gpu_model="unknown", gpu_index=gpu_index,
+                precision=precision, batch_size=batch_size,
+                success=False, error=str(exc),
+            )
+
+    def build_slurm_script(self, gpu_index: int, precision: str, batch_size: int) -> str:
+        """Return shell commands for this benchmark (without SBATCH headers)."""
+        binary = self.params.get("binary", "xhpl")
+        problem_sizes = self.params.get("problem_sizes", [2048])
+        return f"""export CUDA_VISIBLE_DEVICES={gpu_index}
+
+for PS in {' '.join(str(s) for s in problem_sizes)}; do
+    {binary} --problem-size $PS
+done
+"""
+
+
+def _parse_hpl_output(output: str) -> float:
+    """Extract GFLOPS from HPL output. Looks for 'GFLOPS' or 'HPL_outof' patterns."""
+    for line in output.splitlines():
+        line_lower = line.lower()
+        if "gflops" in line_lower:
+            parts = line.split()
+            for part in parts:
+                try:
+                    return float(part)
+                except ValueError:
+                    continue
+        if "hpl_outof" in line_lower or "g_flops" in line_lower:
+            parts = line.split("=")
+            if len(parts) > 1:
+                try:
+                    return float(parts[1].strip().split()[0])
+                except (ValueError, IndexError):
+                    continue
+    return 0.0