Add bench_event and bench_stream and compare script for a summary table

Author: danielfrg

cuda_bindings/benchmarks/benchmarks/bench_ctx_device.py

@@ -8,7 +8,10 @@
 
 from cuda.bindings import driver as cuda
 
-ensure_context()
+CTX = ensure_context()
+
+_, DEVICE = cuda.cuDeviceGet(0)
+ATTRIBUTE = cuda.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR
 
 
 def bench_ctx_get_current(loops: int) -> float:
@@ -18,3 +21,43 @@ def bench_ctx_get_current(loops: int) -> float:
     for _ in range(loops):
         _cuCtxGetCurrent()
     return time.perf_counter() - t0
+
+
+def bench_ctx_set_current(loops: int) -> float:
+    _cuCtxSetCurrent = cuda.cuCtxSetCurrent
+    _ctx = CTX
+
+    t0 = time.perf_counter()
+    for _ in range(loops):
+        _cuCtxSetCurrent(_ctx)
+    return time.perf_counter() - t0
+
+
+def bench_ctx_get_device(loops: int) -> float:
+    _cuCtxGetDevice = cuda.cuCtxGetDevice
+
+    t0 = time.perf_counter()
+    for _ in range(loops):
+        _cuCtxGetDevice()
+    return time.perf_counter() - t0
+
+
+def bench_device_get(loops: int) -> float:
+    _cuDeviceGet = cuda.cuDeviceGet
+
+    t0 = time.perf_counter()
+    for _ in range(loops):
+        _cuDeviceGet(0)
+    return time.perf_counter() - t0
+
+
+def bench_device_get_attribute(loops: int) -> float:
+    _cuDeviceGetAttribute = cuda.cuDeviceGetAttribute
+    _attr = ATTRIBUTE
+    _dev = DEVICE
+
+    t0 = time.perf_counter()
+    for _ in range(loops):
+        _cuDeviceGetAttribute(_attr, _dev)
+    return time.perf_counter() - t0
+

cuda_bindings/benchmarks/benchmarks/bench_event.py

@@ -0,0 +1,62 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import time
+
+from runner.runtime import ensure_context
+
+from cuda.bindings import driver as cuda
+
+ensure_context()
+
+_err, STREAM = cuda.cuStreamCreate(cuda.CUstream_flags.CU_STREAM_NON_BLOCKING.value)
+_err, EVENT = cuda.cuEventCreate(cuda.CUevent_flags.CU_EVENT_DISABLE_TIMING.value)
+
+cuda.cuEventRecord(EVENT, STREAM)
+cuda.cuStreamSynchronize(STREAM)
+
+EVENT_FLAGS = cuda.CUevent_flags.CU_EVENT_DISABLE_TIMING.value
+
+
+def bench_event_create_destroy(loops: int) -> float:
+    _cuEventCreate = cuda.cuEventCreate
+    _cuEventDestroy = cuda.cuEventDestroy
+    _flags = EVENT_FLAGS
+
+    t0 = time.perf_counter()
+    for _ in range(loops):
+        _, e = _cuEventCreate(_flags)
+        _cuEventDestroy(e)
+    return time.perf_counter() - t0
+
+
+def bench_event_record(loops: int) -> float:
+    _cuEventRecord = cuda.cuEventRecord
+    _event = EVENT
+    _stream = STREAM
+
+    t0 = time.perf_counter()
+    for _ in range(loops):
+        _cuEventRecord(_event, _stream)
+    return time.perf_counter() - t0
+
+
+def bench_event_query(loops: int) -> float:
+    _cuEventQuery = cuda.cuEventQuery
+    _event = EVENT
+
+    t0 = time.perf_counter()
+    for _ in range(loops):
+        _cuEventQuery(_event)
+    return time.perf_counter() - t0
+
+
+def bench_event_synchronize(loops: int) -> float:
+    _cuEventSynchronize = cuda.cuEventSynchronize
+    _event = EVENT
+
+    t0 = time.perf_counter()
+    for _ in range(loops):
+        _cuEventSynchronize(_event)
+    return time.perf_counter() - t0

cuda_bindings/benchmarks/benchmarks/bench_stream.py

@@ -0,0 +1,45 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import time
+
+from runner.runtime import ensure_context
+
+from cuda.bindings import driver as cuda
+
+ensure_context()
+
+_err, STREAM = cuda.cuStreamCreate(cuda.CUstream_flags.CU_STREAM_NON_BLOCKING.value)
+
+
+def bench_stream_create_destroy(loops: int) -> float:
+    _cuStreamCreate = cuda.cuStreamCreate
+    _cuStreamDestroy = cuda.cuStreamDestroy
+    _flags = cuda.CUstream_flags.CU_STREAM_NON_BLOCKING.value
+
+    t0 = time.perf_counter()
+    for _ in range(loops):
+        _, s = _cuStreamCreate(_flags)
+        _cuStreamDestroy(s)
+    return time.perf_counter() - t0
+
+
+def bench_stream_query(loops: int) -> float:
+    _cuStreamQuery = cuda.cuStreamQuery
+    _stream = STREAM
+
+    t0 = time.perf_counter()
+    for _ in range(loops):
+        _cuStreamQuery(_stream)
+    return time.perf_counter() - t0
+
+
+def bench_stream_synchronize(loops: int) -> float:
+    _cuStreamSynchronize = cuda.cuStreamSynchronize
+    _stream = STREAM
+
+    t0 = time.perf_counter()
+    for _ in range(loops):
+        _cuStreamSynchronize(_stream)
+    return time.perf_counter() - t0

cuda_bindings/benchmarks/compare.py

@@ -0,0 +1,118 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+
+"""Compare Python and C++ benchmark results in a summary table."""
+
+import argparse
+import json
+import statistics
+import sys
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parent
+DEFAULT_PYTHON = PROJECT_ROOT / "results-python.json"
+DEFAULT_CPP = PROJECT_ROOT / "results-cpp.json"
+
+
+def load_benchmarks(path: Path) -> dict[str, list[float]]:
+    """Load a pyperf JSON file and return {name: [values]}."""
+    with open(path) as f:
+        data = json.load(f)
+
+    results: dict[str, list[float]] = {}
+    for bench in data.get("benchmarks", []):
+        name = bench.get("metadata", {}).get("name", "")
+        if not name:
+            # Try to find name in run metadata
+            for run in bench.get("runs", []):
+                name = run.get("metadata", {}).get("name", "")
+                if name:
+                    break
+        values = []
+        for run in bench.get("runs", []):
+            values.extend(run.get("values", []))
+        if name and values:
+            results[name] = values
+    return results
+
+
+def fmt_ns(seconds: float) -> str:
+    ns = seconds * 1e9
+    if ns >= 1000:
+        return f"{ns / 1000:.2f} us"
+    return f"{ns:.0f} ns"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Compare Python vs C++ benchmark results")
+    parser.add_argument(
+        "--python",
+        type=Path,
+        default=DEFAULT_PYTHON,
+        help=f"Python results JSON (default: {DEFAULT_PYTHON.name})",
+    )
+    parser.add_argument(
+        "--cpp",
+        type=Path,
+        default=DEFAULT_CPP,
+        help=f"C++ results JSON (default: {DEFAULT_CPP.name})",
+    )
+    args = parser.parse_args()
+
+    if not args.python.exists():
+        print(f"Python results not found: {args.python}", file=sys.stderr)
+        print("Run: pixi run -e wheel bench", file=sys.stderr)
+        sys.exit(1)
+
+    py_benchmarks = load_benchmarks(args.python)
+    cpp_benchmarks = load_benchmarks(args.cpp) if args.cpp.exists() else {}
+
+    if not py_benchmarks:
+        print("No benchmarks found in Python results.", file=sys.stderr)
+        sys.exit(1)
+
+    # Column widths
+    all_names = sorted(set(py_benchmarks) | set(cpp_benchmarks))
+    name_width = max(len(n) for n in all_names)
+    name_width = max(name_width, len("Benchmark"))
+
+    # Header
+    if cpp_benchmarks:
+        header = f"{'Benchmark':<{name_width}}  {'C++ (mean)':>12}  {'Python (mean)':>14}  {'Overhead':>10}"
+        sep = "-" * len(header)
+        print(sep)
+        print(header)
+        print(sep)
+    else:
+        header = f"{'Benchmark':<{name_width}}  {'Python (mean)':>14}"
+        sep = "-" * len(header)
+        print(sep)
+        print(header)
+        print(sep)
+
+    for name in all_names:
+        py_vals = py_benchmarks.get(name)
+        cpp_vals = cpp_benchmarks.get(name)
+
+        py_str = fmt_ns(statistics.mean(py_vals)) if py_vals else "-"
+        cpp_str = fmt_ns(statistics.mean(cpp_vals)) if cpp_vals else "-"
+
+        if py_vals and cpp_vals:
+            py_mean = statistics.mean(py_vals)
+            cpp_mean = statistics.mean(cpp_vals)
+            overhead_ns = (py_mean - cpp_mean) * 1e9
+            overhead_str = f"+{overhead_ns:.0f} ns"
+        else:
+            overhead_str = "-"
+
+        if cpp_benchmarks:
+            print(f"{name:<{name_width}}  {cpp_str:>12}  {py_str:>14}  {overhead_str:>10}")
+        else:
+            print(f"{name:<{name_width}}  {py_str:>14}")
+
+    print(sep)
+
+
+if __name__ == "__main__":
+    main()

cuda_bindings/benchmarks/pixi.toml

@@ -29,6 +29,7 @@ cmake = "*"
 ninja = "*"
 cxx-compiler = "*"
 cuda-cudart-dev = "*"
+cuda-nvrtc-dev = "*"
 
 [feature.cpp-bench.target.linux-64.dependencies]
 cuda-crt-dev_linux-64 = "*"
@@ -79,5 +80,8 @@ depends-on = [{ task = "bench-cpp-configure" }]
 cmd = ["python", "$PIXI_PROJECT_ROOT/run_cpp.py"]
 depends-on = [{ task = "bench-cpp-build" }]
 
+[target.linux.tasks.bench-compare]
+cmd = ["python", "$PIXI_PROJECT_ROOT/compare.py"]
+
 [target.linux.tasks.lint]
 cmd = ["pre-commit", "run", "--all-files"]