numba-cuda 0.22.0__cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

numba_cuda/numba/cuda/simulator/cudadrv/devicearray.py

@@ -0,0 +1,462 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+"""
+The Device Array API is not implemented in the simulator. This module provides
+stubs to allow tests to import correctly.
+"""
+
+from contextlib import contextmanager
+from numba.cuda.np.numpy_support import numpy_version
+from numba.cuda.np import numpy_support
+from numba.cuda import types
+
+import numpy as np
+
+
+DeviceRecord = None
+from_record_like = None
+
+
+errmsg_contiguous_buffer = (
+    "Array contains non-contiguous buffer and cannot "
+    "be transferred as a single memory region. Please "
+    "ensure contiguous buffer with numpy "
+    ".ascontiguousarray()"
+)
+
+
+class FakeShape(tuple):
+    """
+    The FakeShape class is used to provide a shape which does not allow negative
+    indexing, similar to the shape in CUDA Python. (Numpy shape arrays allow
+    negative indexing)
+    """
+
+    def __getitem__(self, k):
+        if isinstance(k, int) and k < 0:
+            raise IndexError("tuple index out of range")
+        return super(FakeShape, self).__getitem__(k)
+
+
+class FakeWithinKernelCUDAArray(object):
+    """
+    Created to emulate the behavior of arrays within kernels, where either
+    array.item or array['item'] is valid (that is, give all structured
+    arrays `numpy.recarray`-like semantics). This behaviour does not follow
+    the semantics of Python and NumPy with non-jitted code, and will be
+    deprecated and removed.
+    """
+
+    def __init__(self, item):
+        assert isinstance(item, FakeCUDAArray)
+        self.__dict__["_item"] = item
+
+    def __wrap_if_fake(self, item):
+        if isinstance(item, FakeCUDAArray):
+            return FakeWithinKernelCUDAArray(item)
+        else:
+            return item
+
+    def __getattr__(self, attrname):
+        if (value := getattr(self._item, attrname, None)) is not None:
+            return self.__wrap_if_fake(value)
+        else:
+            return self.__wrap_if_fake(self._item.__getitem__(attrname))
+
+    def __setattr__(self, nm, val):
+        self._item.__setitem__(nm, val)
+
+    def __getitem__(self, idx):
+        return self.__wrap_if_fake(self._item.__getitem__(idx))
+
+    def __setitem__(self, idx, val):
+        self._item.__setitem__(idx, val)
+
+    def __len__(self):
+        return len(self._item)
+
+    def __array_ufunc__(self, ufunc, method, *args, **kwargs):
+        # ufuncs can only be called directly on instances of numpy.ndarray (not
+        # things that implement its interfaces, like the FakeCUDAArray or
+        # FakeWithinKernelCUDAArray). For other objects, __array_ufunc__ is
+        # called when they are arguments to ufuncs, to provide an opportunity
+        # to somehow implement the ufunc. Since the FakeWithinKernelCUDAArray
+        # is just a thin wrapper over an ndarray, we can implement all ufuncs
+        # by passing the underlying ndarrays to a call to the intended ufunc.
+        call = getattr(ufunc, method)
+
+        def convert_fakes(obj):
+            if isinstance(obj, FakeWithinKernelCUDAArray):
+                obj = obj._item._ary
+
+            return obj
+
+        out = kwargs.get("out")
+        if out:
+            kwargs["out"] = tuple(convert_fakes(o) for o in out)
+        args = tuple(convert_fakes(a) for a in args)
+        return call(*args, **kwargs)
+
+
+class FakeCUDAArray(object):
+    """
+    Implements the interface of a DeviceArray/DeviceRecord, but mostly just
+    wraps a NumPy array.
+    """
+
+    __cuda_ndarray__ = True  # There must be gpu_data attribute
+
+    def __init__(self, ary, stream=0):
+        self._ary = ary
+        self.stream = stream
+
+    @property
+    def _numba_type_(self):
+        """
+        Magic attribute expected by Numba to get the numba type that
+        represents this object.
+        """
+        broadcast = 0 in self.strides
+        if self.is_c_contiguous() and not broadcast:
+            layout = "C"
+        elif self.is_f_contiguous() and not broadcast:
+            layout = "F"
+        else:
+            layout = "A"
+
+        dtype = numpy_support.from_dtype(self._ary.dtype)
+        return types.Array(dtype, self._ary.ndim, layout)
+
+    @property
+    def alloc_size(self):
+        return self._ary.nbytes
+
+    @property
+    def nbytes(self):
+        # return nbytes -- FakeCUDAArray is a wrapper around NumPy
+        return self._ary.nbytes
+
+    def __getattr__(self, attrname):
+        try:
+            attr = getattr(self._ary, attrname)
+            return attr
+        except AttributeError as e:
+            msg = "Wrapped array has no attribute '%s'" % attrname
+            raise AttributeError(msg) from e
+
+    def bind(self, stream=0):
+        return FakeCUDAArray(self._ary, stream)
+
+    @property
+    def T(self):
+        return self.transpose()
+
+    def transpose(self, axes=None):
+        return FakeCUDAArray(np.transpose(self._ary, axes=axes))
+
+    def __getitem__(self, idx):
+        ret = self._ary.__getitem__(idx)
+        if type(ret) not in [np.ndarray, np.void]:
+            return ret
+        else:
+            return FakeCUDAArray(ret, stream=self.stream)
+
+    def __setitem__(self, idx, val):
+        return self._ary.__setitem__(idx, val)
+
+    def copy_to_host(self, ary=None, stream=0):
+        if ary is None:
+            ary = np.empty_like(self._ary)
+        else:
+            check_array_compatibility(self, ary)
+        np.copyto(ary, self._ary)
+        return ary
+
+    def copy_to_device(self, ary, stream=0):
+        """
+        Copy from the provided array into this array.
+
+        This may be less forgiving than the CUDA Python implementation, which
+        will copy data up to the length of the smallest of the two arrays,
+        whereas this expects the size of the arrays to be equal.
+        """
+        sentry_contiguous(self)
+        self_core, ary_core = array_core(self), array_core(ary)
+        if isinstance(ary, FakeCUDAArray):
+            sentry_contiguous(ary)
+            check_array_compatibility(self_core, ary_core)
+        else:
+            ary_core = np.array(
+                ary_core,
+                order="C" if self_core.flags["C_CONTIGUOUS"] else "F",
+                subok=True,
+                copy=False if numpy_version < (2, 0) else None,
+            )
+            check_array_compatibility(self_core, ary_core)
+        np.copyto(self_core._ary, ary_core)
+
+    @property
+    def shape(self):
+        return FakeShape(self._ary.shape)
+
+    def ravel(self, *args, **kwargs):
+        return FakeCUDAArray(self._ary.ravel(*args, **kwargs))
+
+    def reshape(self, *args, **kwargs):
+        return FakeCUDAArray(self._ary.reshape(*args, **kwargs))
+
+    def view(self, *args, **kwargs):
+        return FakeCUDAArray(self._ary.view(*args, **kwargs))
+
+    def is_c_contiguous(self):
+        return self._ary.flags.c_contiguous
+
+    def is_f_contiguous(self):
+        return self._ary.flags.f_contiguous
+
+    def __str__(self):
+        return str(self._ary)
+
+    def __repr__(self):
+        return repr(self._ary)
+
+    def __len__(self):
+        return len(self._ary)
+
+    # TODO: Add inplace, bitwise, unary magic methods
+    #  (or maybe inherit this class from numpy)?
+    def __eq__(self, other):
+        return FakeCUDAArray(self._ary == other)
+
+    def __ne__(self, other):
+        return FakeCUDAArray(self._ary != other)
+
+    def __lt__(self, other):
+        return FakeCUDAArray(self._ary < other)
+
+    def __le__(self, other):
+        return FakeCUDAArray(self._ary <= other)
+
+    def __gt__(self, other):
+        return FakeCUDAArray(self._ary > other)
+
+    def __ge__(self, other):
+        return FakeCUDAArray(self._ary >= other)
+
+    def __add__(self, other):
+        return FakeCUDAArray(self._ary + other)
+
+    def __sub__(self, other):
+        return FakeCUDAArray(self._ary - other)
+
+    def __mul__(self, other):
+        return FakeCUDAArray(self._ary * other)
+
+    def __floordiv__(self, other):
+        return FakeCUDAArray(self._ary // other)
+
+    def __truediv__(self, other):
+        return FakeCUDAArray(self._ary / other)
+
+    def __mod__(self, other):
+        return FakeCUDAArray(self._ary % other)
+
+    def __pow__(self, other):
+        return FakeCUDAArray(self._ary**other)
+
+    def split(self, section, stream=0):
+        return [
+            FakeCUDAArray(a)
+            for a in np.split(self._ary, range(section, len(self), section))
+        ]
+
+
+def array_core(ary):
+    """
+    Extract the repeated core of a broadcast array.
+
+    Broadcast arrays are by definition non-contiguous due to repeated
+    dimensions, i.e., dimensions with stride 0. In order to ascertain memory
+    contiguity and copy the underlying data from such arrays, we must create
+    a view without the repeated dimensions.
+
+    """
+    if not ary.strides or not ary.size:
+        return ary
+    core_index = []
+    for stride in ary.strides:
+        core_index.append(0 if stride == 0 else slice(None))
+    return ary[tuple(core_index)]
+
+
+def is_contiguous(ary):
+    """
+    Returns True iff `ary` is C-style contiguous while ignoring
+    broadcasted and 1-sized dimensions.
+    As opposed to array_core(), it does not call require_context(),
+    which can be quite expensive.
+    """
+    size = ary.dtype.itemsize
+    for shape, stride in zip(reversed(ary.shape), reversed(ary.strides)):
+        if shape > 1 and stride != 0:
+            if size != stride:
+                return False
+            size *= shape
+    return True
+
+
+def sentry_contiguous(ary):
+    core = array_core(ary)
+    if not core.flags["C_CONTIGUOUS"] and not core.flags["F_CONTIGUOUS"]:
+        raise ValueError(errmsg_contiguous_buffer)
+
+
+def check_array_compatibility(ary1, ary2):
+    ary1sq, ary2sq = ary1.squeeze(), ary2.squeeze()
+    if ary1.dtype != ary2.dtype:
+        raise TypeError(
+            "incompatible dtype: %s vs. %s" % (ary1.dtype, ary2.dtype)
+        )
+    if ary1sq.shape != ary2sq.shape:
+        raise ValueError(
+            "incompatible shape: %s vs. %s" % (ary1.shape, ary2.shape)
+        )
+    if ary1sq.strides != ary2sq.strides:
+        raise ValueError(
+            "incompatible strides: %s vs. %s" % (ary1.strides, ary2.strides)
+        )
+
+
+def to_device(ary, stream=0, copy=True, to=None):
+    ary = np.array(
+        ary, copy=False if numpy_version < (2, 0) else None, subok=True
+    )
+    sentry_contiguous(ary)
+    if to is None:
+        buffer_dtype = np.int64 if ary.dtype.char in "Mm" else ary.dtype
+        return FakeCUDAArray(
+            np.ndarray(
+                buffer=np.copy(array_core(ary)).view(buffer_dtype),
+                dtype=ary.dtype,
+                shape=ary.shape,
+                strides=ary.strides,
+            ).view(type=type(ary)),
+        )
+    else:
+        to.copy_to_device(ary, stream=stream)
+
+
+@contextmanager
+def pinned(arg):
+    yield
+
+
+def mapped_array(*args, **kwargs):
+    for unused_arg in ("portable", "wc"):
+        if unused_arg in kwargs:
+            kwargs.pop(unused_arg)
+    return device_array(*args, **kwargs)
+
+
+def pinned_array(shape, dtype=np.float64, strides=None, order="C"):
+    return np.ndarray(shape=shape, strides=strides, dtype=dtype, order=order)
+
+
+def managed_array(shape, dtype=np.float64, strides=None, order="C"):
+    return np.ndarray(shape=shape, strides=strides, dtype=dtype, order=order)
+
+
+def device_array(*args, **kwargs):
+    stream = kwargs.pop("stream") if "stream" in kwargs else 0
+    return FakeCUDAArray(np.ndarray(*args, **kwargs), stream=stream)
+
+
+def _contiguous_strides_like_array(ary):
+    """
+    Given an array, compute strides for a new contiguous array of the same
+    shape.
+    """
+    # Don't recompute strides if the default strides will be sufficient to
+    # create a contiguous array.
+    if ary.flags["C_CONTIGUOUS"] or ary.flags["F_CONTIGUOUS"] or ary.ndim <= 1:
+        return None
+
+    # Otherwise, we need to compute new strides using an algorithm adapted from
+    # NumPy v1.17.4's PyArray_NewLikeArrayWithShape in
+    # core/src/multiarray/ctors.c. We permute the strides in ascending order
+    # then compute the stride for the dimensions with the same permutation.
+
+    # Stride permutation. E.g. a stride array (4, -2, 12) becomes
+    # [(1, -2), (0, 4), (2, 12)]
+    strideperm = [x for x in enumerate(ary.strides)]
+    strideperm.sort(key=lambda x: x[1])
+
+    # Compute new strides using permutation
+    strides = [0] * len(ary.strides)
+    stride = ary.dtype.itemsize
+    for i_perm, _ in strideperm:
+        strides[i_perm] = stride
+        stride *= ary.shape[i_perm]
+    return tuple(strides)
+
+
+def _order_like_array(ary):
+    if ary.flags["F_CONTIGUOUS"] and not ary.flags["C_CONTIGUOUS"]:
+        return "F"
+    else:
+        return "C"
+
+
+def device_array_like(ary, stream=0):
+    strides = _contiguous_strides_like_array(ary)
+    order = _order_like_array(ary)
+    return device_array(
+        shape=ary.shape, dtype=ary.dtype, strides=strides, order=order
+    )
+
+
+def pinned_array_like(ary):
+    strides = _contiguous_strides_like_array(ary)
+    order = _order_like_array(ary)
+    return pinned_array(
+        shape=ary.shape, dtype=ary.dtype, strides=strides, order=order
+    )
+
+
+def auto_device(ary, stream=0, copy=True):
+    if isinstance(ary, FakeCUDAArray):
+        return ary, False
+
+    if not isinstance(ary, np.void):
+        ary = np.array(
+            ary, copy=False if numpy_version < (2, 0) else None, subok=True
+        )
+    return to_device(ary, stream, copy), True
+
+
+def is_cuda_ndarray(obj):
+    "Check if an object is a CUDA ndarray"
+    return getattr(obj, "__cuda_ndarray__", False)
+
+
+def verify_cuda_ndarray_interface(obj):
+    "Verify the CUDA ndarray interface for an obj"
+    require_cuda_ndarray(obj)
+
+    def requires_attr(attr, typ):
+        if not hasattr(obj, attr):
+            raise AttributeError(attr)
+        if not isinstance(getattr(obj, attr), typ):
+            raise AttributeError("%s must be of type %s" % (attr, typ))
+
+    requires_attr("shape", tuple)
+    requires_attr("strides", tuple)
+    requires_attr("dtype", np.dtype)
+    requires_attr("size", int)
+
+
+def require_cuda_ndarray(obj):
+    "Raises ValueError is is_cuda_ndarray(obj) evaluates False"
+    if not is_cuda_ndarray(obj):
+        raise ValueError("require an cuda ndarray object")

numba_cuda/numba/cuda/simulator/cudadrv/devices.py

@@ -0,0 +1,122 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import numpy as np
+from collections import namedtuple
+
+_MemoryInfo = namedtuple("_MemoryInfo", "free,total")
+
+_SIMULATOR_CC = (5, 2)
+
+
+class FakeCUDADevice:
+    def __init__(self):
+        self.uuid = "GPU-00000000-0000-0000-0000-000000000000"
+
+    @property
+    def compute_capability(self):
+        return _SIMULATOR_CC
+
+
+class FakeCUDAContext:
+    """
+    This stub implements functionality only for simulating a single GPU
+    at the moment.
+    """
+
+    def __init__(self, device_id):
+        self._device_id = device_id
+        self._device = FakeCUDADevice()
+
+    def __enter__(self):
+        pass
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    def __str__(self):
+        return "<Managed Device {self.id}>".format(self=self)
+
+    @property
+    def id(self):
+        return self._device_id
+
+    @property
+    def device(self):
+        return self._device
+
+    @property
+    def compute_capability(self):
+        return _SIMULATOR_CC
+
+    def reset(self):
+        pass
+
+    def get_memory_info(self):
+        """
+        Cross-platform free / total host memory is hard without external
+        dependencies, e.g. `psutil` - so return infinite memory to maintain API
+        type compatibility
+        """
+        return _MemoryInfo(float("inf"), float("inf"))
+
+    def memalloc(self, sz):
+        """
+        Allocates memory on the simulated device
+        At present, there is no division between simulated
+        host memory and simulated device memory.
+        """
+        return np.ndarray(sz, dtype="u1")
+
+    def memhostalloc(self, sz, mapped=False, portable=False, wc=False):
+        """Allocates memory on the host"""
+        return self.memalloc(sz)
+
+
+class FakeDeviceList:
+    """
+    This stub implements a device list containing a single GPU. It also
+    keeps track of the GPU status, i.e. whether the context is closed or not,
+    which may have been set by the user calling reset()
+    """
+
+    def __init__(self):
+        self.lst = (FakeCUDAContext(0),)
+        self.closed = False
+
+    def __getitem__(self, devnum):
+        self.closed = False
+        return self.lst[devnum]
+
+    def __str__(self):
+        return ", ".join([str(d) for d in self.lst])
+
+    def __iter__(self):
+        return iter(self.lst)
+
+    def __len__(self):
+        return len(self.lst)
+
+    @property
+    def current(self):
+        if self.closed:
+            return None
+        return self.lst[0]
+
+
+gpus = FakeDeviceList()
+
+
+def reset():
+    gpus[0].closed = True
+
+
+def get_context(devnum=0):
+    return FakeCUDAContext(devnum)
+
+
+def require_context(func):
+    """
+    In the simulator, a context is always "available", so this is a no-op.
+    """
+    return func

numba_cuda/numba/cuda/simulator/cudadrv/driver.py

@@ -0,0 +1,66 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+"""
+Most of the driver API is unsupported in the simulator, but some stubs are
+provided to allow tests to import correctly.
+"""
+
+
+def device_memset(dst, val, size, stream=0):
+    dst.view("u1")[:size].fill(bytes([val])[0])
+
+
+def host_to_device(dst, src, size, stream=0):
+    dst.view("u1")[:size] = src.view("u1")[:size]
+
+
+def device_to_host(dst, src, size, stream=0):
+    host_to_device(dst, src, size)
+
+
+def device_memory_size(obj):
+    return obj.itemsize * obj.size
+
+
+def device_to_device(dst, src, size, stream=0):
+    host_to_device(dst, src, size)
+
+
+class FakeDriver(object):
+    def get_device_count(self):
+        return 1
+
+
+driver = FakeDriver()
+
+
+class _Linker:
+    @classmethod
+    def new(cls, max_registers=0, lineinfo=False, cc=None):
+        return _Linker()
+
+    @property
+    def lto(self):
+        return False
+
+
+class LinkerError(RuntimeError):
+    pass
+
+
+class NvrtcError(RuntimeError):
+    pass
+
+
+class CudaAPIError(RuntimeError):
+    pass
+
+
+def launch_kernel(*args, **kwargs):
+    msg = "Launching kernels directly is not supported in the simulator"
+    raise RuntimeError(msg)
+
+
+def _have_nvjitlink():
+    return False

numba_cuda/numba/cuda/simulator/cudadrv/drvapi.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+"""
+drvapi is not implemented in the simulator, but this module exists to allow
+tests to import correctly.
+"""

numba_cuda/numba/cuda/simulator/cudadrv/dummyarray.py

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+# Dummy arrays are not implemented in the simulator. This file allows the dummy
+# array tests to be imported, but they are skipped on the simulator.
+
+Array = None

numba_cuda/numba/cuda/simulator/cudadrv/error.py

@@ -0,0 +1,10 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+
+class CudaSupportError(RuntimeError):
+    pass
+
+
+class NvrtcError(Exception):
+    pass

numba_cuda/numba/cuda/simulator/cudadrv/libs.py

@@ -0,0 +1,10 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+
+def check_static_lib(lib):
+    raise FileNotFoundError("Linking libraries not supported by cudasim")
+
+
+def get_cuda_include_dir():
+    raise FileNotFoundError("CUDA includes not supported by cudasim")