kernelmeter 0.2.0__py3-none-any.whl

kernelmeter/cli.py

@@ -0,0 +1,304 @@
+"""kernelmeter command line interface.
+
+  kernelmeter info                  dump every device attribute + derived peaks
+  kernelmeter bench file.py         run all @kernelmeter.benchmark specs in file
+  kernelmeter roofline              draw the device roofline, place your kernel on it
+  kernelmeter occupancy             theoretical occupancy from block/regs/smem
+  kernelmeter ceiling               measure real achievable bandwidth and FP32
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import sys
+
+from . import attrs as _attrs
+from . import occupancy as _occupancy
+from . import peaks as _peaks
+from . import roofline as _roofline
+from .cudadrv import CudaNotAvailableError, Driver
+
+
+def _fmt(value: float | None, suffix: str = "", nd: int = 1) -> str:
+    return f"{value:.{nd}f}{suffix}" if value is not None else "-"
+
+
+def _device_attrs(ordinal: int = 0) -> dict[str, int]:
+    driver = Driver()
+    return _attrs.query_all(driver, driver.device(ordinal))
+
+
+# ---------------------------------------------------------------------------
+# info
+# ---------------------------------------------------------------------------
+
+def gather_info(driver: Driver) -> dict:
+    major, minor = driver.driver_version()
+    devices = []
+    for ordinal in range(driver.device_count()):
+        dev = driver.device(ordinal)
+        attributes = _attrs.query_all(driver, dev)
+        peaks = _peaks.derive(attributes)
+        devices.append(
+            {
+                "ordinal": ordinal,
+                "name": dev.name,
+                "total_memory_bytes": dev.total_mem_bytes,
+                "derived": peaks.as_dict(),
+                "attributes": attributes,
+            }
+        )
+    return {"driver_version": f"{major}.{minor}", "devices": devices}
+
+
+def cmd_info(args: argparse.Namespace) -> int:
+    try:
+        driver = Driver()
+    except CudaNotAvailableError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+
+    info = gather_info(driver)
+    if args.json:
+        print(json.dumps(info, indent=2))
+        return 0
+
+    print(f"CUDA driver version : {info['driver_version']}")
+    for dev in info["devices"]:
+        gib = dev["total_memory_bytes"] / 2**30
+        print(f"\nDevice {dev['ordinal']}: {dev['name']} ({gib:.1f} GiB)")
+        derived = dev["derived"]
+        print(f"  compute capability        : {derived['compute_capability']}")
+        print(
+            "  theoretical mem bandwidth : "
+            + _fmt(derived["theoretical_mem_bandwidth_gb_s"], " GB/s")
+        )
+        print(
+            "  theoretical FP32 peak     : "
+            + _fmt(derived["theoretical_fp32_tflops"], " TFLOP/s", nd=2)
+        )
+        print(f"\n  {'attribute':<48} value")
+        print(f"  {'-' * 48} {'-' * 12}")
+        for name, value in dev["attributes"].items():
+            print(f"  {name:<48} {value}")
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# bench
+# ---------------------------------------------------------------------------
+
+def _load_module(path: str) -> None:
+    spec = importlib.util.spec_from_file_location("kernelmeter_bench_target", path)
+    if spec is None or spec.loader is None:
+        raise SystemExit(f"error: cannot import {path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+
+def cmd_bench(args: argparse.Namespace) -> int:
+    from . import bench as _bench
+
+    _load_module(args.file)
+    if not _bench.REGISTRY:
+        print(
+            f"error: {args.file} registered no benchmarks. "
+            "Decorate your kernels with @kernelmeter.benchmark(...).",
+            file=sys.stderr,
+        )
+        return 1
+
+    results = _bench.run_registry(flush_l2=not args.no_flush_l2)
+
+    if args.save:
+        with open(args.save, "w") as fh:
+            json.dump([r.as_dict() for r in results], fh, indent=2)
+
+    if args.json:
+        print(json.dumps([r.as_dict() for r in results], indent=2))
+    else:
+        header = (
+            f"{'kernel':<24} {'median ms':>10} {'GB/s':>9} {'TFLOP/s':>9} "
+            f"{'bound':>6} {'%roof':>7} {'vs ref':>8} {'correct':>8}"
+        )
+        print(header)
+        print("-" * len(header))
+        for r in results:
+            if r.error:
+                print(f"{r.name:<24} failed: {r.error}")
+                continue
+            correct = "-" if r.correct is None else ("PASS" if r.correct else "FAIL")
+            speedup = f"{r.speedup_vs_ref:.2f}x" if r.speedup_vs_ref else "-"
+            print(
+                f"{r.name:<24} {r.ms_median:>10.4f} {_fmt(r.gbps):>9} "
+                f"{_fmt(r.tflops, nd=2):>9} {r.bound or '-':>6} "
+                f"{_fmt(r.pct_roofline, '%'):>7} {speedup:>8} {correct:>8}"
+            )
+
+    ok = all(r.error is None and r.correct in (None, True) for r in results)
+
+    if args.compare:
+        with open(args.compare) as fh:
+            baseline = json.load(fh)
+        rows, regressions = _bench.diff_results(baseline, results)
+        if rows:
+            print(f"\n{'kernel':<24} {'baseline ms':>12} {'now ms':>10} {'delta':>8}")
+            for name, old_ms, new_ms, delta in rows:
+                print(f"{name:<24} {old_ms:>12.4f} {new_ms:>10.4f} {delta:>+7.1f}%")
+        for name in regressions:
+            print(f"regression: {name} is more than 5% slower than the baseline")
+        if regressions:
+            ok = False
+
+    return 0 if ok else 1
+
+
+# ---------------------------------------------------------------------------
+# roofline
+# ---------------------------------------------------------------------------
+
+def cmd_roofline(args: argparse.Namespace) -> int:
+    peak_bw, peak_tf = args.peak_bw, args.peak_tflops
+    name = None
+    if peak_bw is None or peak_tf is None:
+        try:
+            driver = Driver()
+            dev = driver.device(args.device)
+            name = dev.name
+            peaks = _peaks.derive(_attrs.query_all(driver, dev))
+            peak_bw = peak_bw or peaks.mem_bandwidth_gbs
+            peak_tf = peak_tf or peaks.fp32_tflops
+        except CudaNotAvailableError:
+            pass
+    if not peak_bw or not peak_tf:
+        print(
+            "error: no CUDA device found. Pass --peak-bw GB/s and "
+            "--peak-tflops to draw a roofline for any card.",
+            file=sys.stderr,
+        )
+        return 1
+
+    ridge = _roofline.ridge_point(peak_tf, peak_bw)
+    if name:
+        print(f"Device {args.device}: {name}")
+    print(f"  peak bandwidth : {peak_bw:.1f} GB/s")
+    print(f"  peak compute   : {peak_tf:.2f} TFLOP/s")
+    print(f"  ridge point    : {ridge:.1f} flop/byte\n")
+    for line in _roofline.render(peak_tf, peak_bw, ai=args.ai):
+        print(line)
+    if args.ai is not None:
+        attainable = _roofline.attainable_tflops(args.ai, peak_tf, peak_bw)
+        which = _roofline.bound(args.ai, peak_tf, peak_bw)
+        kind = "memory" if which == "mem" else "compute"
+        print(
+            f"\nat {args.ai:g} flop/byte the kernel is {kind}-bound; "
+            f"attainable: {attainable:.2f} TFLOP/s"
+        )
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# occupancy
+# ---------------------------------------------------------------------------
+
+def cmd_occupancy(args: argparse.Namespace) -> int:
+    if args.cc:
+        try:
+            major, minor = (int(x) for x in args.cc.split("."))
+            limits = _occupancy.limits_for_cc(major, minor)
+        except ValueError as exc:
+            print(f"error: {exc}", file=sys.stderr)
+            return 1
+        source = f"compute capability {args.cc}"
+    else:
+        try:
+            limits = _occupancy.limits_from_attrs(_device_attrs(args.device))
+            source = f"device {args.device}"
+        except CudaNotAvailableError:
+            print(
+                "error: no CUDA device found. Pass --cc (e.g. --cc 8.6) to "
+                "model a card you don't have.",
+                file=sys.stderr,
+            )
+            return 1
+
+    occ = _occupancy.compute(args.block, args.regs, args.smem, limits)
+    print(f"occupancy for {source}")
+    print(f"  block={args.block} regs/thread={args.regs} smem/block={args.smem}\n")
+    print(f"  occupancy    : {occ.pct:.1f}% ({occ.active_warps}/{occ.max_warps} warps per SM)")
+    print(f"  blocks per SM: {occ.blocks_per_sm}")
+    print(f"  limited by   : {', '.join(occ.limited_by)}\n")
+
+    sweep = _occupancy.block_size_sweep(args.regs, args.smem, limits)
+    print("  block size " + "".join(f"{s:>7}" for s, _ in sweep))
+    print("  occupancy  " + "".join(f"{p:>6.0f}%" for _, p in sweep))
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# ceiling
+# ---------------------------------------------------------------------------
+
+def cmd_ceiling(args: argparse.Namespace) -> int:
+    from . import ceiling as _ceiling
+
+    results = _ceiling.measure(mb=args.mb, matmul_n=args.matmul_n)
+    if args.json:
+        print(json.dumps([r.as_dict() for r in results], indent=2))
+    else:
+        for line in _ceiling.format_table(results):
+            print(line)
+    return 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="kernelmeter", description=__doc__)
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_info = sub.add_parser("info", help="dump all CUDA device attributes and derived peaks")
+    p_info.add_argument("--json", action="store_true", help="machine-readable output")
+    p_info.set_defaults(func=cmd_info)
+
+    p_bench = sub.add_parser("bench", help="run @kernelmeter.benchmark specs from a file")
+    p_bench.add_argument("file", help="python file that registers benchmarks")
+    p_bench.add_argument("--json", action="store_true", help="machine-readable output")
+    p_bench.add_argument("--save", metavar="FILE", help="write results to a json file")
+    p_bench.add_argument(
+        "--compare", metavar="FILE", help="compare against results saved with --save"
+    )
+    p_bench.add_argument(
+        "--no-flush-l2",
+        action="store_true",
+        help="skip the L2 flush between iterations (lets small workloads run hot in cache)",
+    )
+    p_bench.set_defaults(func=cmd_bench)
+
+    p_roof = sub.add_parser("roofline", help="draw the device roofline")
+    p_roof.add_argument("--ai", type=float, help="mark a kernel at this arithmetic intensity")
+    p_roof.add_argument("--device", type=int, default=0)
+    p_roof.add_argument("--peak-bw", type=float, help="override bandwidth in GB/s")
+    p_roof.add_argument("--peak-tflops", type=float, help="override compute in TFLOP/s")
+    p_roof.set_defaults(func=cmd_roofline)
+
+    p_occ = sub.add_parser("occupancy", help="theoretical occupancy calculator")
+    p_occ.add_argument("--block", type=int, required=True, help="threads per block")
+    p_occ.add_argument("--regs", type=int, default=0, help="registers per thread (from ptxas/ncu)")
+    p_occ.add_argument("--smem", type=int, default=0, help="shared memory per block in bytes")
+    p_occ.add_argument("--cc", help="compute capability, e.g. 8.6 (default: ask the device)")
+    p_occ.add_argument("--device", type=int, default=0)
+    p_occ.set_defaults(func=cmd_occupancy)
+
+    p_ceil = sub.add_parser("ceiling", help="measure real achievable bandwidth and FP32")
+    p_ceil.add_argument("--mb", type=int, default=256, help="working-set size per array")
+    p_ceil.add_argument("--matmul-n", type=int, default=4096, help="matmul size for the FP32 test")
+    p_ceil.add_argument("--json", action="store_true", help="machine-readable output")
+    p_ceil.set_defaults(func=cmd_ceiling)
+
+    args = parser.parse_args(argv)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

kernelmeter/cudadrv.py

@@ -0,0 +1,129 @@
+"""Thin ctypes wrapper around the CUDA driver API (libcuda).
+
+The driver API is used instead of the runtime API (libcudart) on purpose:
+libcuda ships with the NVIDIA driver itself, so this works on any machine
+that can run CUDA programs -- no CUDA toolkit installation required. Its C
+ABI is stable, unlike ``cudaDeviceProp`` whose struct layout changes
+between toolkit versions.
+"""
+
+from __future__ import annotations
+
+import ctypes
+import sys
+from dataclasses import dataclass
+
+CUDA_SUCCESS = 0
+CUDA_ERROR_INVALID_VALUE = 1
+CUDA_ERROR_NO_DEVICE = 100
+
+
+class CudaDriverError(RuntimeError):
+    """The CUDA driver returned an unexpected error code."""
+
+    def __init__(self, func: str, code: int):
+        self.func = func
+        self.code = code
+        super().__init__(f"{func} failed with CUresult {code}")
+
+
+class CudaNotAvailableError(RuntimeError):
+    """libcuda could not be loaded or no NVIDIA device is present."""
+
+
+_LIB_CANDIDATES = {
+    "linux": ("libcuda.so.1", "libcuda.so"),
+    "win32": ("nvcuda.dll",),
+    "darwin": (),  # NVIDIA dropped macOS support after CUDA 10.2
+}
+
+
+def load_library() -> ctypes.CDLL:
+    """Locate and load libcuda for the current platform."""
+    platform = "win32" if sys.platform == "win32" else sys.platform
+    candidates = _LIB_CANDIDATES.get(platform, _LIB_CANDIDATES["linux"])
+    if not candidates:
+        raise CudaNotAvailableError(
+            "CUDA is not supported on this platform (no NVIDIA driver for "
+            f"{sys.platform!r}). Run kernelmeter on a machine with an NVIDIA GPU."
+        )
+    errors = []
+    for name in candidates:
+        try:
+            if sys.platform == "win32":
+                return ctypes.WinDLL(name)  # pragma: no cover
+            return ctypes.CDLL(name)
+        except OSError as exc:  # library missing
+            errors.append(f"{name}: {exc}")
+    raise CudaNotAvailableError(
+        "Could not load the CUDA driver library. Is the NVIDIA driver "
+        "installed?\nTried: " + "; ".join(errors)
+    )
+
+
+@dataclass
+class DeviceHandle:
+    ordinal: int
+    handle: int
+    name: str
+    total_mem_bytes: int
+
+
+class Driver:
+    """Minimal, injectable wrapper over the few entry points we need.
+
+    Pass a fake ``lib`` object in tests; production code calls ``Driver()``
+    which loads the real libcuda.
+    """
+
+    def __init__(self, lib=None):
+        self._lib = lib if lib is not None else load_library()
+        self._check("cuInit", self._lib.cuInit(0))
+
+    def _check(self, func: str, code: int) -> None:
+        if code == CUDA_ERROR_NO_DEVICE:
+            raise CudaNotAvailableError(
+                "The NVIDIA driver loaded but reported no CUDA-capable device."
+            )
+        if code != CUDA_SUCCESS:
+            raise CudaDriverError(func, code)
+
+    def driver_version(self) -> tuple[int, int]:
+        v = ctypes.c_int(0)
+        self._check("cuDriverGetVersion", self._lib.cuDriverGetVersion(ctypes.byref(v)))
+        return v.value // 1000, (v.value % 1000) // 10
+
+    def device_count(self) -> int:
+        n = ctypes.c_int(0)
+        self._check("cuDeviceGetCount", self._lib.cuDeviceGetCount(ctypes.byref(n)))
+        return n.value
+
+    def device(self, ordinal: int) -> DeviceHandle:
+        dev = ctypes.c_int(0)
+        self._check("cuDeviceGet", self._lib.cuDeviceGet(ctypes.byref(dev), ordinal))
+
+        buf = ctypes.create_string_buffer(256)
+        self._check("cuDeviceGetName", self._lib.cuDeviceGetName(buf, 256, dev))
+
+        mem = ctypes.c_size_t(0)
+        # cuDeviceTotalMem_v2 is the modern 64-bit symbol; fall back for
+        # exotic builds that only export the unsuffixed name.
+        fn = getattr(self._lib, "cuDeviceTotalMem_v2", None) or self._lib.cuDeviceTotalMem
+        self._check("cuDeviceTotalMem", fn(ctypes.byref(mem), dev))
+
+        return DeviceHandle(
+            ordinal=ordinal,
+            handle=dev.value,
+            name=buf.value.decode("utf-8", errors="replace"),
+            total_mem_bytes=mem.value,
+        )
+
+    def attribute(self, device: DeviceHandle, attr_id: int) -> int | None:
+        """Query one device attribute. Returns None when the driver does
+        not know the attribute id (older driver than the probe range)."""
+        out = ctypes.c_int(0)
+        code = self._lib.cuDeviceGetAttribute(ctypes.byref(out), attr_id, device.handle)
+        if code == CUDA_ERROR_INVALID_VALUE:
+            return None
+        self._check("cuDeviceGetAttribute", code)
+        return out.value

kernelmeter/occupancy.py

@@ -0,0 +1,102 @@
+"""Theoretical occupancy from block size, registers and shared memory.
+
+This reimplements the model behind NVIDIA's old occupancy calculator
+spreadsheet. It is a model, not a measurement: the real limiter can also
+be launch bounds or the driver, but for the everyday question ("why is my
+occupancy 50% and what do I change?") the model is what you want.
+
+Registers are allocated per warp in units of 256. Shared memory is
+allocated per block in architecture-specific units, and on Ampere and
+newer the runtime reserves about 1 KiB per block on top of what you ask
+for.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+REG_ALLOC_UNIT = 256  # registers, rounded up per warp
+
+# Per-SM limits by compute capability. Values from the CUDA C programming
+# guide's compute-capability table.
+ARCH_LIMITS: dict[tuple[int, int], dict] = {
+    (7, 0): dict(max_warps=64, max_blocks=32, regs=65536, smem=98304, smem_gran=256, reserved_smem=0),
+    (7, 5): dict(max_warps=32, max_blocks=16, regs=65536, smem=65536, smem_gran=256, reserved_smem=0),
+    (8, 0): dict(max_warps=64, max_blocks=32, regs=65536, smem=167936, smem_gran=128, reserved_smem=1024),
+    (8, 6): dict(max_warps=48, max_blocks=16, regs=65536, smem=102400, smem_gran=128, reserved_smem=1024),
+    (8, 7): dict(max_warps=48, max_blocks=16, regs=65536, smem=167936, smem_gran=128, reserved_smem=1024),
+    (8, 9): dict(max_warps=48, max_blocks=24, regs=65536, smem=102400, smem_gran=128, reserved_smem=1024),
+    (9, 0): dict(max_warps=64, max_blocks=32, regs=65536, smem=233472, smem_gran=128, reserved_smem=1024),
+    (12, 0): dict(max_warps=48, max_blocks=24, regs=65536, smem=102400, smem_gran=128, reserved_smem=1024),
+}
+
+
+def limits_for_cc(major: int, minor: int) -> dict:
+    if (major, minor) in ARCH_LIMITS:
+        return ARCH_LIMITS[(major, minor)]
+    older = [cc for cc in ARCH_LIMITS if cc <= (major, minor)]
+    if not older:
+        raise ValueError(f"no occupancy data for compute capability {major}.{minor}")
+    return ARCH_LIMITS[max(older)]
+
+
+def limits_from_attrs(attrs: dict[str, int]) -> dict:
+    """Build the limits dict from live device attributes, falling back to
+    the arch table for allocation granularities the driver doesn't report."""
+    cc = (attrs["compute_capability_major"], attrs["compute_capability_minor"])
+    arch = limits_for_cc(*cc)
+    return dict(
+        max_warps=attrs.get("max_threads_per_multiprocessor", arch["max_warps"] * 32) // 32,
+        max_blocks=attrs.get("max_blocks_per_multiprocessor", arch["max_blocks"]),
+        regs=attrs.get("max_registers_per_multiprocessor", arch["regs"]),
+        smem=attrs.get("max_shared_memory_per_multiprocessor", arch["smem"]),
+        smem_gran=arch["smem_gran"],
+        reserved_smem=attrs.get("reserved_shared_memory_per_block", arch["reserved_smem"]),
+    )
+
+
+def _ceil_to(value: int, unit: int) -> int:
+    return (value + unit - 1) // unit * unit
+
+
+@dataclass
+class Occupancy:
+    blocks_per_sm: int
+    active_warps: int
+    max_warps: int
+    pct: float
+    limited_by: list[str]
+
+    def as_dict(self) -> dict:
+        return dict(self.__dict__)
+
+
+def compute(block: int, regs_per_thread: int, smem_per_block: int, limits: dict) -> Occupancy:
+    if block < 1 or block > 1024:
+        raise ValueError("block size must be 1..1024")
+    warps_per_block = (block + 31) // 32
+
+    by = {"blocks": limits["max_blocks"], "threads": limits["max_warps"] // warps_per_block}
+    if regs_per_thread:
+        regs_per_warp = _ceil_to(regs_per_thread * 32, REG_ALLOC_UNIT)
+        by["registers"] = (limits["regs"] // regs_per_warp) // warps_per_block
+    smem_total = smem_per_block + limits["reserved_smem"] if smem_per_block else 0
+    if smem_total:
+        by["shared memory"] = limits["smem"] // _ceil_to(smem_total, limits["smem_gran"])
+
+    blocks = min(by.values())
+    warps = blocks * warps_per_block
+    return Occupancy(
+        blocks_per_sm=blocks,
+        active_warps=warps,
+        max_warps=limits["max_warps"],
+        pct=100.0 * warps / limits["max_warps"],
+        limited_by=[k for k, v in by.items() if v == blocks],
+    )
+
+
+def block_size_sweep(
+    regs_per_thread: int, smem_per_block: int, limits: dict,
+    sizes: tuple = (64, 128, 192, 256, 384, 512, 768, 1024),
+) -> list[tuple[int, float]]:
+    return [(s, compute(s, regs_per_thread, smem_per_block, limits).pct) for s in sizes]

kernelmeter/peaks.py

@@ -0,0 +1,83 @@
+"""Derive theoretical peak throughput ("speed of light") from device attributes.
+
+These numbers are upper bounds computed from the max boost clock the driver
+reports; sustained clocks under load are usually lower, so treat a kernel
+at 85%+ of these peaks as effectively saturating the machine.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+# FP32 CUDA cores per SM, keyed by compute capability. The fallback for an
+# unknown capability is the value of the closest older architecture.
+_FP32_CORES_PER_SM: dict[tuple[int, int], int] = {
+    (3, 0): 192, (3, 5): 192, (3, 7): 192,
+    (5, 0): 128, (5, 2): 128, (5, 3): 128,
+    (6, 0): 64, (6, 1): 128, (6, 2): 128,
+    (7, 0): 64, (7, 2): 64, (7, 5): 64,
+    (8, 0): 64, (8, 6): 128, (8, 7): 128, (8, 9): 128,
+    (9, 0): 128,
+    (10, 0): 128, (10, 3): 128,
+    (12, 0): 128, (12, 1): 128,
+}
+
+
+def fp32_cores_per_sm(major: int, minor: int) -> int:
+    if (major, minor) in _FP32_CORES_PER_SM:
+        return _FP32_CORES_PER_SM[(major, minor)]
+    older = [cc for cc in _FP32_CORES_PER_SM if cc <= (major, minor)]
+    if older:
+        return _FP32_CORES_PER_SM[max(older)]
+    return 64
+
+
+@dataclass
+class Peaks:
+    """Theoretical per-device ceilings derived from driver attributes."""
+
+    mem_bandwidth_gbs: float | None
+    fp32_tflops: float | None
+    compute_capability: tuple[int, int] | None
+
+    def as_dict(self) -> dict:
+        return {
+            "theoretical_mem_bandwidth_gb_s": self.mem_bandwidth_gbs,
+            "theoretical_fp32_tflops": self.fp32_tflops,
+            "compute_capability": (
+                f"{self.compute_capability[0]}.{self.compute_capability[1]}"
+                if self.compute_capability
+                else None
+            ),
+        }
+
+
+def mem_bandwidth_gbs(memory_clock_khz: int, bus_width_bits: int) -> float:
+    """DDR: two transfers per clock. clock(kHz) * 1e3 * width(bytes) * 2 / 1e9."""
+    return 2.0 * memory_clock_khz * 1e3 * (bus_width_bits / 8.0) / 1e9
+
+
+def fp32_tflops(sm_count: int, clock_khz: int, major: int, minor: int) -> float:
+    """One FMA per core per clock = 2 FLOPs."""
+    cores = fp32_cores_per_sm(major, minor)
+    return 2.0 * sm_count * cores * clock_khz * 1e3 / 1e12
+
+
+def derive(attrs: dict[str, int]) -> Peaks:
+    """Compute peaks from a query_all() attribute dict, tolerating gaps."""
+    bw = None
+    if "memory_clock_rate_khz" in attrs and "global_memory_bus_width_bits" in attrs:
+        bw = mem_bandwidth_gbs(
+            attrs["memory_clock_rate_khz"], attrs["global_memory_bus_width_bits"]
+        )
+
+    cc = None
+    flops = None
+    if "compute_capability_major" in attrs and "compute_capability_minor" in attrs:
+        cc = (attrs["compute_capability_major"], attrs["compute_capability_minor"])
+        if "multiprocessor_count" in attrs and "clock_rate_khz" in attrs:
+            flops = fp32_tflops(
+                attrs["multiprocessor_count"], attrs["clock_rate_khz"], cc[0], cc[1]
+            )
+
+    return Peaks(mem_bandwidth_gbs=bw, fp32_tflops=flops, compute_capability=cc)