cunumpy 0.6.0__tar.gz → 0.6.2__tar.gz

{cunumpy-0.6.0 → cunumpy-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cunumpy
-Version: 0.6.0
+Version: 0.6.2
 Summary: Simple wrapper for numpy and cupy. Replace `import numpy as np` with `import cunumpy as xp`.
 Author: Max
 Project-URL: Source, https://github.com/max-models/cunumpy
@@ -30,6 +30,8 @@ Requires-Dist: pre-commit; extra == "docs"
 Requires-Dist: pyproject-fmt; extra == "docs"
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: sphinx-book-theme; extra == "docs"
+Provides-Extra: metal
+Requires-Dist: mlx; (sys_platform == "darwin" and platform_machine == "arm64") and extra == "metal"
 Provides-Extra: test
 Requires-Dist: coverage; extra == "test"
 Requires-Dist: pytest; extra == "test"
@@ -64,7 +66,7 @@ never hide a NumPy name:
 
 | Submodule | Contents |
 |---|---|
-| `xp.kernels` | `Kernel`, `KernelCatalog`, `PyccelKernel`, `CudaKernel`, host implementations, `fuse` |
+| `xp.kernels` | `Kernel`, `KernelCatalog`, `PyccelKernel`, `CudaKernel`, `MetalKernel`, host implementations, `fuse` |
 | `xp.arguments` | CUDA only: `CudaStruct`, `CudaStructArguments`, `CudaArguments` |
 | `xp.cuda` | CUDA only: devices, streams, debug mode, CUDA headers |
 | `xp.rng` | `random_streams`, `get_rng`, `philox_*` |
@@ -76,6 +78,8 @@ never hide a NumPy name:
 | `cunumpy.kernel_testing` | pytest helpers for host/CUDA kernel pairs |
 
 Everything except `xp.cuda`, `xp.arguments` and `CudaKernel` works on both backends.
+`MetalKernel` runs Metal kernels on the GPU of an Apple silicon Mac (MLX, float32, NumPy arrays;
+`pip install 'cunumpy[metal]'`, see [the guide](docs/source/kernels/metal-kernel.md)).
 
 ## Install
 
@@ -434,7 +438,7 @@ kernel(particles.args_markers, dt)  # host or CUDA kernel
 Kernels ported from pyccel index arrays like `markers[ip, j]`, which needs
 shapes and strides rather than bare pointers. The shipped header
 `cunumpy/array_view.cuh` (found by every `CudaKernel`) provides the strided
-views `Array1D<T>` to `Array4D<T>`; a parameter or struct field of that type
+views `Array1D<T>` to `Array16D<T>`; a parameter or struct field of that type
 takes a CuPy array, contiguous or not, and indexes `a(i, j)`. The struct can be
 generated from the annotations of the pyccel argument class, so the Python
 class is the one definition, and written to a header that a test keeps in sync:
@@ -444,7 +448,9 @@ class MarkerArguments:
     def __init__(self, markers: "float[:, :]", n_markers: int, valid: "bool[:]"): ...
 
 
-MarkerArgs = xp.arguments.CudaStruct.from_signature(MarkerArguments.__init__, "MarkerArgs")
+MarkerArgs = xp.arguments.CudaStruct.from_signature(
+    MarkerArguments.__init__, "MarkerArgs"
+)
 MarkerArgs.to_header(
     "marker_args.cuh"
 )  # Array2D<double> markers; long long n_markers; ...

{cunumpy-0.6.0 → cunumpy-0.6.2}/README.md

@@ -24,7 +24,7 @@ never hide a NumPy name:
 
 | Submodule | Contents |
 |---|---|
-| `xp.kernels` | `Kernel`, `KernelCatalog`, `PyccelKernel`, `CudaKernel`, host implementations, `fuse` |
+| `xp.kernels` | `Kernel`, `KernelCatalog`, `PyccelKernel`, `CudaKernel`, `MetalKernel`, host implementations, `fuse` |
 | `xp.arguments` | CUDA only: `CudaStruct`, `CudaStructArguments`, `CudaArguments` |
 | `xp.cuda` | CUDA only: devices, streams, debug mode, CUDA headers |
 | `xp.rng` | `random_streams`, `get_rng`, `philox_*` |
@@ -36,6 +36,8 @@ never hide a NumPy name:
 | `cunumpy.kernel_testing` | pytest helpers for host/CUDA kernel pairs |
 
 Everything except `xp.cuda`, `xp.arguments` and `CudaKernel` works on both backends.
+`MetalKernel` runs Metal kernels on the GPU of an Apple silicon Mac (MLX, float32, NumPy arrays;
+`pip install 'cunumpy[metal]'`, see [the guide](docs/source/kernels/metal-kernel.md)).
 
 ## Install
 
@@ -394,7 +396,7 @@ kernel(particles.args_markers, dt)  # host or CUDA kernel
 Kernels ported from pyccel index arrays like `markers[ip, j]`, which needs
 shapes and strides rather than bare pointers. The shipped header
 `cunumpy/array_view.cuh` (found by every `CudaKernel`) provides the strided
-views `Array1D<T>` to `Array4D<T>`; a parameter or struct field of that type
+views `Array1D<T>` to `Array16D<T>`; a parameter or struct field of that type
 takes a CuPy array, contiguous or not, and indexes `a(i, j)`. The struct can be
 generated from the annotations of the pyccel argument class, so the Python
 class is the one definition, and written to a header that a test keeps in sync:
@@ -404,7 +406,9 @@ class MarkerArguments:
     def __init__(self, markers: "float[:, :]", n_markers: int, valid: "bool[:]"): ...
 
 
-MarkerArgs = xp.arguments.CudaStruct.from_signature(MarkerArguments.__init__, "MarkerArgs")
+MarkerArgs = xp.arguments.CudaStruct.from_signature(
+    MarkerArguments.__init__, "MarkerArgs"
+)
 MarkerArgs.to_header(
     "marker_args.cuh"
 )  # Array2D<double> markers; long long n_markers; ...

{cunumpy-0.6.0 → cunumpy-0.6.2}/pyproject.toml

@@ -5,7 +5,7 @@ requires = [ "setuptools", "wheel" ]
 
 [project]
 name = "cunumpy"
-version = "0.6.0"
+version = "0.6.2"
 description = "Simple wrapper for numpy and cupy. Replace `import numpy as np` with `import cunumpy as xp`."
 readme = "README.md"
 keywords = [ "python" ]
@@ -43,6 +43,7 @@ optional-dependencies.docs = [
   "sphinx",
   "sphinx-book-theme",
 ]
+optional-dependencies.metal = [ "mlx; sys_platform == 'darwin' and platform_machine == 'arm64'" ]
 optional-dependencies.test = [ "coverage", "pytest", "scipy" ]
 optional-dependencies.test-compiled = [ "cunumpy[test]", "pyccel" ]
 urls."Source" = "https://github.com/max-models/cunumpy"

{cunumpy-0.6.0 → cunumpy-0.6.2}/src/cunumpy/LLM_GUIDE.md

@@ -72,6 +72,11 @@ https://max-models.github.io/cunumpy/ and in `docs/source/` of the repository.
 | hand data to SciPy/matplotlib/h5py | `xp.to_numpy(a)` |
 | call an existing NumPy-only kernel with GPU arrays (slow, correct) | `xp.kernels.PyccelKernel(fn, outputs=(...))` |
 | launch a hand-written CUDA C kernel | `xp.kernels.CudaKernel(source, "name")` / `CudaKernel.from_file(path)` |
+| run a Metal (MSL) kernel on an Apple silicon GPU, NumPy float32 in and out (float64 raises; `float64="cast"` computes in float32); not part of `Kernel` dispatch | `xp.kernels.MetalKernel(body, inputs=[...], outputs=[...])(*args, out=arrays, n_threads=n)`; check `xp.kernels.metal_available()` |
+| call host-only code (SciPy, file readers) with arguments of either backend | `xp.host_call(fun, *args)`; `@xp.evaluate_on_host` on a method; `@xp.setup_on_host` on `__init__` |
+| keep the live rows of particle arrays at the front | `n = xp.algorithms.compact_by_mask(alive, markers, weights)` |
+| run CUDA kernel launches on the CPU in a test (fake CuPy) | `with kernel_testing.emulated_launches(): ...`; `kernel_testing.host_buffer(a)` reads a fake array; struct arguments are read through their fields |
+| find the arguments a host kernel writes (copy only those back) | `PyccelKernel(fn, outputs=("out",))` (names work positionally); `xp.kernels.outputs_from_annotations(fn)`; `Kernel.from_folder(..., outputs="annotations")` |
 | host kernel + CUDA port, chosen by backend | `xp.kernels.Kernel(host_fn, cuda_kernel_or_None)` |
 | many kernels in a package, ported incrementally | `xp.kernels.KernelCatalog.from_package(__name__, missing_cuda="fallback")` |
 | host kernels compiled at first call (your compile function), NumPy fallback | `from_package(..., host_suffix="_pyccel", compile_host=my_compile, host_fallback={...})` -> `xp.kernels.CompiledHostKernel` |
@@ -96,7 +101,7 @@ https://max-models.github.io/cunumpy/ and in `docs/source/` of the repository.
 | PETSc solve on device arrays without copies | `xp.petsc.petsc_vec(array)` (CUDA/HIP petsc4py for CuPy arrays); `xp.synchronize()` around PETSc calls |
 | reduction inside a CUDA kernel (energy, max velocity) | `<cunumpy/reduce.cuh>`: `cunumpy_block_sum_to(out, v)`, `cunumpy_block_min/max`, `cunumpy_warp_sum` |
 | kernel writes into a host buffer owned by another library | `xp.memory.DeviceMirror(host_array)` + `<cunumpy/atomic.cuh>` |
-| N-D indexing in CUDA, non-contiguous arrays | `Array1D<T>`..`Array4D<T>` params from `<cunumpy/array_view.cuh>` |
+| N-D indexing in CUDA, non-contiguous arrays | `Array1D<T>`..`Array16D<T>` params from `<cunumpy/array_view.cuh>` |
 | one MPI rank per GPU | `bind_local_device()` → `from mpi4py import MPI` → `require_cuda_aware_mpi()` → `synchronize_for_mpi(...)` before each call |
 | timing GPU code | `with xp.profiling.timed_region("name") as t:` → `t.elapsed` |
 | profiler markers | `xp.profiling.nvtx_range("name")` (context manager or decorator) |
@@ -307,7 +312,7 @@ Shipped CUDA headers (always on the include path):
 
 ```c
 #include <cunumpy/index.cuh>       // CUNUMPY_THREAD_1D(i, n) /_2D/_3D, CUNUMPY_GRID_STRIDE_1D(i, n) {...}
-#include <cunumpy/array_view.cuh>  // Array1D<T>..Array4D<T>: data, shape[], strides[] (elements), a(i, j), size()
+#include <cunumpy/array_view.cuh>  // Array1D<T>..Array16D<T>: data, shape[], strides[] (elements), a(i, j), size()
 #include <cunumpy/atomic.cuh>      // cunumpy_atomic_add(double*|float*, v), _2d(data, n1, i, j, v), _3d(...)
 ```
 

{cunumpy-0.6.0 → cunumpy-0.6.2}/src/cunumpy/__init__.py

@@ -14,6 +14,7 @@ from cunumpy import (
     rng,
     xp,
 )
+from cunumpy._host import evaluate_on_host, host_call, setup_on_host
 from cunumpy._scipy_backend import scipy
 from cunumpy.xp import (
     as_device_array,
@@ -79,9 +80,11 @@ __all__ = [
     "cupy_available",
     "cupy_backend",
     "default_float_dtype",
+    "evaluate_on_host",
     "get_array_backend",
     "get_array_module",
     "get_backend",
+    "host_call",
     "is_cpu",
     "is_gpu",
     "kernels",
@@ -95,6 +98,7 @@ __all__ = [
     "same_backend",
     "scipy",
     "set_backend",
+    "setup_on_host",
     "synchronize",
     "to_cunumpy",
     "to_cupy",

{cunumpy-0.6.0 → cunumpy-0.6.2}/src/cunumpy/__init__.pyi

@@ -1,7 +1,7 @@
 # Stub file for Pylance/mypy: exposes all numpy symbols so that
 # `import cunumpy as xp` followed by `xp.<Tab>` shows numpy completions.
 # At runtime the real __init__.py dispatches to numpy or cupy via __getattr__.
-from collections.abc import Generator
+from collections.abc import Callable, Generator
 from contextlib import contextmanager
 from typing import Any
 
@@ -38,6 +38,9 @@ def set_backend(backend: str, *, strict: bool = ...) -> None: ...
 def require_version(minimum: str) -> None: ...
 def default_float_dtype() -> Any: ...
 def synchronize() -> None: ...
+def host_call(fun: Callable[..., Any], *args: Any, **kwargs: Any) -> Any: ...
+def evaluate_on_host(method: Callable[..., Any]) -> Callable[..., Any]: ...
+def setup_on_host(init: Callable[..., None]) -> Callable[..., None]: ...
 def as_device_array(
     value: Any, dtype: Any = ..., ndim: int | None = ..., *, name: str | None = ...
 ) -> Any: ...

{cunumpy-0.6.0 → cunumpy-0.6.2}/src/cunumpy/_algorithms.py

@@ -251,3 +251,49 @@ def sort_by_key(keys: Any, *arrays: Any) -> tuple[Any, ...]:
             )
     order = xpm.argsort(keys, kind="stable").astype(xpm.int64, copy=False)
     return (keys[order], order, *(array[order] for array in arrays))
+
+
+def compact_by_mask(mask: Any, *arrays: Any) -> int:
+    """Move the rows where `mask` is True to the front of every array, in place.
+
+    The usual step after particles left the domain or were absorbed: keep the
+    live ones at the front of the marker array (and of the arrays that go with
+    it) and continue with ``markers[:n]``. The order of the kept rows is
+    preserved, so the result is reproducible::
+
+        n = xp.algorithms.compact_by_mask(alive, markers, weights)
+        markers, weights = markers[:n], weights[:n]
+
+    Parameters
+    ----------
+    mask : array of bool, shape (n,)
+        True for the rows to keep.
+    *arrays : arrays
+        Arrays with ``n`` rows (any further axes), on the backend of `mask`.
+        Rows ``[:count]`` hold the kept rows afterwards; the rows after them
+        are unspecified, so ignore them (or overwrite them).
+
+    Returns
+    -------
+    int
+        The number of kept rows. Its value is needed on the host, so on CuPy
+        the call synchronizes once per call (counted by
+        :func:`~cunumpy.profiling.count_transfers` where it can be seen).
+    """
+    assert_same_backend(mask, *arrays)
+    xpm = get_array_module(mask)
+    mask = xpm.asarray(mask)
+    if mask.ndim != 1 or mask.dtype != np.bool_:
+        raise TypeError(
+            f"mask must be a 1D boolean array, got dtype {mask.dtype}, {mask.ndim}D",
+        )
+    for i, array in enumerate(arrays):
+        if array.ndim < 1 or array.shape[0] != mask.shape[0]:
+            raise ValueError(
+                f"array {i} has shape {array.shape}, expected {mask.shape[0]} rows",
+            )
+    rows = xpm.nonzero(mask)[0]
+    n_kept = int(rows.size)
+    for array in arrays:
+        array[:n_kept] = array[rows]  # the right side is a copy: no overlap problem
+    return n_kept

{cunumpy-0.6.0 → cunumpy-0.6.2}/src/cunumpy/_cuda_kernel.py

@@ -66,6 +66,9 @@ from typing import Any, NamedTuple
 
 import numpy as np
 
+from cunumpy._transfers import _ACTIVE as _COUNTERS
+from cunumpy._transfers import _record_sync
+
 __all__ = [
     "DEBUG_OPTIONS",
     "CudaArguments",
@@ -123,7 +126,7 @@ def cuda_include_dir() -> str:
 
     :class:`CudaKernel` adds it to the include path automatically, so kernels
     can ``#include "cunumpy/array_view.cuh"`` (strided ``Array1D<T>``
-    to ``Array4D<T>`` views passed by value) and
+    to ``Array16D<T>`` views passed by value) and
     ``#include "cunumpy/index.cuh"`` (thread-index and grid-stride macros such
     as ``CUNUMPY_THREAD_1D(i, n)``), ``#include "cunumpy/atomic.cuh"`` (atomic
     adds) and ``#include "cunumpy/reduce.cuh"`` (warp and block reductions).
@@ -188,7 +191,7 @@ class CudaParameter(NamedTuple):
         The struct type, for a struct passed by value.
     view_ndim : int | None
         The number of dimensions, for an array view (``Array1D<T>`` to
-        ``Array4D<T>`` or ``CArray1D<T>`` to ``CArray4D<T>``, see
+        ``Array16D<T>`` or ``CArray1D<T>`` to ``CArray16D<T>``, see
         :func:`cuda_include_dir`) passed by value.
     contiguous : bool
         Whether the array view is C-contiguous (``CArray2D<T>``): packed
@@ -265,11 +268,11 @@ _CTYPE_OF = {
 _QUALIFIERS = {"const", "volatile", "__restrict__", "__restrict", "restrict"}
 
 _COMPLEX = re.compile(r"(?:(?:thrust|cuda::std)::)?complex\s*<\s*(float|double)\s*>")
-# Array1D<T> to Array4D<T> and CArray1D<T> to CArray4D<T> (cunumpy/array_view.cuh),
+# Array1D<T> to Array16D<T> and CArray1D<T> to CArray16D<T> (cunumpy/array_view.cuh),
 # T a scalar type of _CTYPES
-_VIEW = re.compile(r"\b(C?)Array([1234])D\s*<((?:[^<>]|complex<[^<>]*>)+?)>")
+_VIEW = re.compile(r"\b(C?)Array([1-9]|1[0-6])D\s*<((?:[^<>]|complex<[^<>]*>)+?)>")
 _TOKEN = re.compile(
-    r"C?Array[1234]D<[^<>]*(?:<[^<>]*>[^<>]*)?>|complex<(?:float|double)>"
+    r"C?Array(?:[1-9]|1[0-6])D<[^<>]*(?:<[^<>]*>[^<>]*)?>|complex<(?:float|double)>"
     r"|[A-Za-z_]\w*|\*|\[\s*\]",
 )
 
@@ -905,8 +908,8 @@ def _pyccel_ctype(annotation: Any, scalars: Mapping[str, str], what: str) -> str
     ctype = scalars[scalar]
     if ndim == 0:
         return ctype
-    if ndim > 4:
-        raise ValueError(f"{what}: arrays have at most 4 dimensions, got {ndim}")
+    if ndim > 16:
+        raise ValueError(f"{what}: arrays have at most 16 dimensions, got {ndim}")
     return f"Array{ndim}D<{ctype}>"
 
 
@@ -1075,7 +1078,7 @@ class CudaStruct:
         ``(field name, C type)`` pairs, in order, e.g. ``("x", "double*")`` or
         ``("n", "int")``. Scalar fields, pointers to the scalar types of
         :func:`ctype_of` (or ``void*``), and array views ``Array1D<T>`` to
-        ``Array4D<T>`` of those scalar types (from ``cunumpy/array_view.cuh``,
+        ``Array16D<T>`` of those scalar types (from ``cunumpy/array_view.cuh``,
         packed as pointer, shape and strides in elements) are supported.
 
     Examples
@@ -1848,7 +1851,7 @@ class CudaKernel:
         The headers shipped with cunumpy (:func:`cuda_include_dir`) are always
         found at compile time (see :meth:`compile_options`):
         ``#include "cunumpy/array_view.cuh"`` gives the ``Array1D<T>`` to
-        ``Array4D<T>`` views, ``#include "cunumpy/index.cuh"`` the thread-index
+        ``Array16D<T>`` views, ``#include "cunumpy/index.cuh"`` the thread-index
         macros, ``#include "cunumpy/atomic.cuh"`` atomic adds,
         ``#include "cunumpy/reduce.cuh"`` warp and block reductions.
     source_dir : str | Path | None
@@ -2421,6 +2424,10 @@ class CudaKernel:
         if shared_mem < 0:
             raise ValueError(f"shared_mem must be non-negative, got {shared_mem}")
         values = self.prepare_args(*args)
+        # RawKernel accepts size-one NumPy arrays for structs passed by value,
+        # but not structured NumPy scalars (np.void). Keep their packed bytes
+        # and alignment intact, including array-view pointers and strides.
+        values = tuple(np.asarray(v) if isinstance(v, np.void) else v for v in values)
         if 0 in grid_shape:
             return
 
@@ -2528,6 +2535,8 @@ class CudaKernel:
             stream = cp.cuda.get_current_stream()
         if _is_capturing(stream):
             return
+        if _COUNTERS:
+            _record_sync(f"debug synchronization after kernel {self.expression!r}")
         try:
             stream.synchronize()
         except Exception as error:

{cunumpy-0.6.0 → cunumpy-0.6.2}/src/cunumpy/_dispatch.py

@@ -40,6 +40,7 @@ from cunumpy._kernel import (
     HostImplementations,
     PyccelKernel,
     get_device_kernel_implementation,
+    outputs_from_annotations,
 )
 from cunumpy._transfers import _ACTIVE as _COUNTERS
 from cunumpy._transfers import _record
@@ -219,6 +220,10 @@ class Kernel:
                 "host_options are for wrapping a plain callable; configure the "
                 "given PyccelKernel directly",
             )
+        if host_kernel._parameters is None:
+            # compiled kernels have no Python signature: name the parameters
+            # from the host function, so that outputs may be given by name
+            host_kernel._parameters = self.host_parameters
         self._host_kernel = host_kernel
         self._cuda_kernel = cuda_kernel
         self._name = name if name is not None else host_kernel.name
@@ -239,6 +244,7 @@ class Kernel:
         check_name_length: bool = True,
         missing_cuda: str = "raise",
         host_options: Mapping[str, Any] | None = None,
+        outputs: Sequence[int | str] | str | None = None,
         include_dirs: Sequence[str | Path] | None = None,
         dispatch: str = "backend",
         compile_host: Callable[[Any], Any] | None = None,
@@ -285,6 +291,14 @@ class Kernel:
             As for :meth:`KernelCatalog.from_package`.
         missing_cuda, host_options, dispatch
             Passed on to :class:`Kernel`.
+        outputs : Sequence[int | str] | "annotations" | None
+            The arguments the host kernel writes to (names or indices, see
+            :class:`~cunumpy.kernels.PyccelKernel`), so that only those arrays are
+            copied back to the device on the fallback path. ``"annotations"``
+            reads them from the annotations of the host function: every
+            parameter that is not ``Final`` or a scalar is an output (see
+            :func:`~cunumpy.kernels.outputs_from_annotations`). A value in
+            `host_options` takes precedence.
         include_dirs : Sequence[str | Path] | None
             Include directories of the CUDA kernel, in addition to the folder
             itself; by default the source root of the top-level package (the
@@ -334,6 +348,19 @@ class Kernel:
             test_args = f"{package}.{name}{test_args_suffix}"
         module = importlib.import_module(f"{package}.{name}{host_suffix}")
         python = getattr(module, name)
+        if outputs is not None and "outputs" not in (host_options or {}):
+            declared = (
+                outputs_from_annotations(python)
+                if isinstance(outputs, str) and outputs == "annotations"
+                else outputs
+            )
+            if isinstance(outputs, str) and outputs != "annotations":
+                raise ValueError(
+                    f"outputs must be a sequence of names/indices or 'annotations', "
+                    f"got {outputs!r}",
+                )
+            if declared is not None:
+                host_options = {**(host_options or {}), "outputs": declared}
         loaders: dict[str, Callable[[], Callable[..., Any]]] = {
             "python": lambda: python,
             "pyccel": (
@@ -669,6 +696,12 @@ class KernelCatalog(Mapping):
         host_options: (
             Mapping[str, Any] | Callable[[str], Mapping[str, Any]] | None
         ) = None,
+        outputs: (
+            Sequence[int | str]
+            | str
+            | Callable[[str], Sequence[int | str] | str | None]
+            | None
+        ) = None,
         include_dirs: Sequence[str | Path] | None = None,
         dispatch: str = "backend",
         compile_host: Callable[[Any], Any] | None = None,
@@ -713,6 +746,10 @@ class KernelCatalog(Mapping):
             Keyword arguments for the :class:`~cunumpy.kernels.PyccelKernel` wrapping each
             host kernel (see :class:`Kernel`): the same for all kernels, or a
             function of the kernel name, e.g. to declare per-kernel ``outputs``.
+        outputs : Sequence[int | str] | "annotations" | Callable | None
+            The arguments every host kernel writes to, or ``"annotations"`` to
+            read them from the annotations of each host function, or a function
+            of the kernel name returning either (see :meth:`Kernel.from_folder`).
         include_dirs : Sequence[str | Path] | None
             Include directories of the CUDA kernels, in addition to each
             kernel's own folder. By default the source root of the top-level
@@ -757,6 +794,7 @@ class KernelCatalog(Mapping):
                 host_options=(
                     host_options(name) if callable(host_options) else host_options
                 ),
+                outputs=outputs(name) if callable(outputs) else outputs,
                 include_dirs=include_dirs,
                 dispatch=dispatch,
                 compile_host=compile_host,