numba-cuda 0.14.0__tar.gz → 0.15.1__tar.gz

{numba_cuda-0.14.0 → numba_cuda-0.15.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numba-cuda
-Version: 0.14.0
+Version: 0.15.1
 Summary: CUDA target for Numba
 Author: Anaconda Inc., NVIDIA Corporation
 License: BSD 2-clause
@@ -13,11 +13,13 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numba>=0.59.1
 Provides-Extra: cu11
+Requires-Dist: cuda-bindings==11.8.*; extra == "cu11"
 Requires-Dist: cuda-python==11.8.*; extra == "cu11"
 Requires-Dist: nvidia-cuda-nvcc-cu11; extra == "cu11"
 Requires-Dist: nvidia-cuda-runtime-cu11; extra == "cu11"
 Requires-Dist: nvidia-cuda-nvrtc-cu11; extra == "cu11"
 Provides-Extra: cu12
+Requires-Dist: cuda-bindings==12.9.*; extra == "cu12"
 Requires-Dist: cuda-python==12.9.*; extra == "cu12"
 Requires-Dist: nvidia-cuda-nvcc-cu12; extra == "cu12"
 Requires-Dist: nvidia-cuda-runtime-cu12; extra == "cu12"

numba_cuda-0.15.1/numba_cuda/VERSION

@@ -0,0 +1 @@
+0.15.1

numba_cuda-0.15.1/numba_cuda/numba/cuda/__init__.py

@@ -0,0 +1,68 @@
+import importlib
+from numba import runtests
+from numba.core import config
+from .utils import _readenv
+
+# Enable pynvjitlink if the environment variables NUMBA_CUDA_ENABLE_PYNVJITLINK
+# or CUDA_ENABLE_PYNVJITLINK are set, or if the pynvjitlink module is found. If
+# explicitly disabled, do not use pynvjitlink, even if present in the env.
+_pynvjitlink_enabled_in_env = _readenv(
+    "NUMBA_CUDA_ENABLE_PYNVJITLINK", bool, None
+)
+_pynvjitlink_enabled_in_cfg = getattr(config, "CUDA_ENABLE_PYNVJITLINK", None)
+
+if _pynvjitlink_enabled_in_env is not None:
+    ENABLE_PYNVJITLINK = _pynvjitlink_enabled_in_env
+elif _pynvjitlink_enabled_in_cfg is not None:
+    ENABLE_PYNVJITLINK = _pynvjitlink_enabled_in_cfg
+else:
+    ENABLE_PYNVJITLINK = importlib.util.find_spec("pynvjitlink") is not None
+
+if not hasattr(config, "CUDA_ENABLE_PYNVJITLINK"):
+    config.CUDA_ENABLE_PYNVJITLINK = ENABLE_PYNVJITLINK
+
+# Upstream numba sets CUDA_USE_NVIDIA_BINDING to 0 by default, so it always
+# exists. Override, but not if explicitly set to 0 in the envioronment.
+_nvidia_binding_enabled_in_env = _readenv(
+    "NUMBA_CUDA_USE_NVIDIA_BINDING", bool, None
+)
+if _nvidia_binding_enabled_in_env is False:
+    USE_NV_BINDING = False
+else:
+    USE_NV_BINDING = True
+    config.CUDA_USE_NVIDIA_BINDING = USE_NV_BINDING
+if config.CUDA_USE_NVIDIA_BINDING:
+    if not importlib.util.find_spec("cuda.bindings"):
+        raise ImportError(
+            "CUDA bindings not found. Please pip install the "
+            "cuda-bindings package. Alternatively, install "
+            "numba-cuda[cuXY], where XY is the required CUDA "
+            "version, to install the binding automatically. "
+            "If no CUDA bindings are desired, set the env var "
+            "NUMBA_CUDA_USE_NVIDIA_BINDING=0 to enable ctypes "
+            "bindings."
+        )
+
+if config.ENABLE_CUDASIM:
+    from .simulator_init import *
+else:
+    from .device_init import *
+    from .device_init import _auto_device
+
+from numba.cuda.compiler import (
+    compile,
+    compile_for_current_device,
+    compile_ptx,
+    compile_ptx_for_current_device,
+)
+
+# This is the out-of-tree NVIDIA-maintained target. This is reported in Numba
+# sysinfo (`numba -s`):
+implementation = "NVIDIA"
+
+
+def test(*args, **kwargs):
+    if not is_available():
+        raise cuda_error()
+
+    return runtests.main("numba.cuda.tests", *args, **kwargs)

{numba_cuda-0.14.0 → numba_cuda-0.15.1}/numba_cuda/numba/cuda/cudadrv/devicearray.py

@@ -121,16 +121,10 @@ class DeviceNDArrayBase(_devicearray.DeviceArray):
 
     @property
     def __cuda_array_interface__(self):
-        if _driver.USE_NV_BINDING:
-            if self.device_ctypes_pointer is not None:
-                ptr = int(self.device_ctypes_pointer)
-            else:
-                ptr = 0
+        if self.device_ctypes_pointer.value is not None:
+            ptr = self.device_ctypes_pointer.value
         else:
-            if self.device_ctypes_pointer.value is not None:
-                ptr = self.device_ctypes_pointer.value
-            else:
-                ptr = 0
+            ptr = 0
 
         return {
             "shape": tuple(self.shape),
@@ -204,10 +198,7 @@ class DeviceNDArrayBase(_devicearray.DeviceArray):
     def device_ctypes_pointer(self):
         """Returns the ctypes pointer to the GPU data buffer"""
         if self.gpu_data is None:
-            if _driver.USE_NV_BINDING:
-                return _driver.binding.CUdeviceptr(0)
-            else:
-                return c_void_p(0)
+            return c_void_p(0)
         else:
             return self.gpu_data.device_ctypes_pointer
 

{numba_cuda-0.14.0 → numba_cuda-0.15.1}/numba_cuda/numba/cuda/cudadrv/driver.py

@@ -49,7 +49,7 @@ from .drvapi import API_PROTOTYPES
 from .drvapi import cu_occupancy_b2d_size, cu_stream_callback_pyobj, cu_uuid
 from .mappings import FILE_EXTENSION_MAP
 from .linkable_code import LinkableCode, LTOIR, Fatbin, Object
-from numba.cuda.utils import _readenv, cached_file_read
+from numba.cuda.utils import cached_file_read
 from numba.cuda.cudadrv import enums, drvapi, nvrtc
 
 try:
@@ -57,15 +57,6 @@ try:
 except ImportError:
     NvJitLinker, NvJitLinkError = None, None
 
-USE_NV_BINDING = config.CUDA_USE_NVIDIA_BINDING
-
-if USE_NV_BINDING:
-    from cuda import cuda as binding
-
-    # There is no definition of the default stream in the Nvidia bindings (nor
-    # is there at the C/C++ level), so we define it here so we don't need to
-    # use a magic number 0 in places where we want the default stream.
-    CU_STREAM_DEFAULT = 0
 
 MIN_REQUIRED_CC = (3, 5)
 SUPPORTS_IPC = sys.platform.startswith("linux")
@@ -82,23 +73,15 @@ _MVC_ERROR_MESSAGE = (
     "to be available"
 )
 
-# Enable pynvjitlink if the environment variables NUMBA_CUDA_ENABLE_PYNVJITLINK
-# or CUDA_ENABLE_PYNVJITLINK are set, or if the pynvjitlink module is found. If
-# explicitly disabled, do not use pynvjitlink, even if present in the env.
-_pynvjitlink_enabled_in_env = _readenv(
-    "NUMBA_CUDA_ENABLE_PYNVJITLINK", bool, None
-)
-_pynvjitlink_enabled_in_cfg = getattr(config, "CUDA_ENABLE_PYNVJITLINK", None)
+USE_NV_BINDING = config.CUDA_USE_NVIDIA_BINDING
 
-if _pynvjitlink_enabled_in_env is not None:
-    ENABLE_PYNVJITLINK = _pynvjitlink_enabled_in_env
-elif _pynvjitlink_enabled_in_cfg is not None:
-    ENABLE_PYNVJITLINK = _pynvjitlink_enabled_in_cfg
-else:
-    ENABLE_PYNVJITLINK = importlib.util.find_spec("pynvjitlink") is not None
+if USE_NV_BINDING:
+    from cuda.bindings import driver as binding
 
-if not hasattr(config, "CUDA_ENABLE_PYNVJITLINK"):
-    config.CUDA_ENABLE_PYNVJITLINK = ENABLE_PYNVJITLINK
+    # There is no definition of the default stream in the Nvidia bindings (nor
+    # is there at the C/C++ level), so we define it here so we don't need to
+    # use a magic number 0 in places where we want the default stream.
+    CU_STREAM_DEFAULT = 0
 
 
 def make_logger():
@@ -2107,6 +2090,8 @@ class MemoryPointer(object):
 
     @property
     def device_ctypes_pointer(self):
+        if USE_NV_BINDING:
+            return drvapi.cu_device_ptr(int(self.device_pointer))
         return self.device_pointer
 
     @property
@@ -3192,7 +3177,6 @@ class CudaPythonLinker(Linker):
 
         raw_keys = list(options.keys())
         raw_values = list(options.values())
-
         self.handle = driver.cuLinkCreate(len(raw_keys), raw_keys, raw_values)
 
         weakref.finalize(self, driver.cuLinkDestroy, self.handle)
@@ -3449,8 +3433,8 @@ def device_extents(devmem):
     """
     devptr = device_ctypes_pointer(devmem)
     if USE_NV_BINDING:
-        s, n = driver.cuMemGetAddressRange(devptr)
-        return s, binding.CUdeviceptr(int(s) + n)
+        s, n = driver.cuMemGetAddressRange(devptr.value)
+        return int(s), int(binding.CUdeviceptr(int(s) + n))
     else:
         s = drvapi.cu_device_ptr()
         n = c_size_t()
@@ -3467,10 +3451,7 @@ def device_memory_size(devmem):
     sz = getattr(devmem, "_cuda_memsize_", None)
     if sz is None:
         s, e = device_extents(devmem)
-        if USE_NV_BINDING:
-            sz = int(e) - int(s)
-        else:
-            sz = e - s
+        sz = e - s
         devmem._cuda_memsize_ = sz
     assert sz >= 0, "{} length array".format(sz)
     return sz
@@ -3536,10 +3517,7 @@ def host_memory_size(obj):
 
 def device_pointer(obj):
     "Get the device pointer as an integer"
-    if USE_NV_BINDING:
-        return obj.device_ctypes_pointer
-    else:
-        return device_ctypes_pointer(obj).value
+    return device_ctypes_pointer(obj).value
 
 
 def device_ctypes_pointer(obj):

{numba_cuda-0.14.0 → numba_cuda-0.15.1}/numba_cuda/numba/cuda/cudadrv/mappings.py

@@ -2,9 +2,9 @@ from numba import config
 from . import enums
 
 if config.CUDA_USE_NVIDIA_BINDING:
-    from cuda import cuda
+    from cuda.bindings import driver
 
-    jitty = cuda.CUjitInputType
+    jitty = driver.CUjitInputType
     FILE_EXTENSION_MAP = {
         "o": jitty.CU_JIT_INPUT_OBJECT,
         "ptx": jitty.CU_JIT_INPUT_PTX,

{numba_cuda-0.14.0 → numba_cuda-0.15.1}/numba_cuda/numba/cuda/dispatcher.py

@@ -588,8 +588,6 @@ class _Kernel(serialize.ReduceMixin):
         elif isinstance(ty, types.Record):
             devrec = wrap_arg(val).to_device(retr, stream)
             ptr = devrec.device_ctypes_pointer
-            if driver.USE_NV_BINDING:
-                ptr = ctypes.c_void_p(int(ptr))
             kernelargs.append(ptr)
 
         elif isinstance(ty, types.BaseTuple):
@@ -1009,7 +1007,7 @@ class CUDADispatcher(Dispatcher, serialize.ReduceMixin):
         A (template, pysig, args, kws) tuple is returned.
         """
         # Fold keyword arguments and resolve default values
-        pysig, args = self._compiler.fold_argument_types(args, kws)
+        pysig, args = self.fold_argument_types(args, kws)
         kws = {}
 
         # Ensure an exactly-matching overload is available if we can

{numba_cuda-0.14.0 → numba_cuda-0.15.1}/numba_cuda/numba/cuda/memory_management/nrt.py

@@ -113,10 +113,13 @@ class _Runtime:
             self._compile_memsys_module()
 
         # Allocate space for NRT_MemSys
-        ptr, nbytes = self._memsys_module.get_global_symbol("memsys_size")
         memsys_size = ctypes.c_uint64()
+        ptr, nbytes = self._memsys_module.get_global_symbol("memsys_size")
+        device_memsys_size = ptr.device_ctypes_pointer
+        if USE_NV_BINDING:
+            device_memsys_size = device_memsys_size.value
         driver.cuMemcpyDtoH(
-            ctypes.addressof(memsys_size), ptr.device_ctypes_pointer, nbytes
+            ctypes.addressof(memsys_size), device_memsys_size, nbytes
         )
         self._memsys = device_array(
             (memsys_size.value,), dtype="i1", stream=stream
@@ -145,18 +148,6 @@ class _Runtime:
             cooperative=False,
         )
 
-    def _ctypes_pointer(self, array):
-        """
-        Given an array, return a ctypes pointer to the data suitable for
-        passing to ``launch_kernel``.
-        """
-        ptr = array.device_ctypes_pointer
-
-        if USE_NV_BINDING:
-            ptr = ctypes.c_void_p(int(ptr))
-
-        return ptr
-
     def ensure_initialized(self, stream=None):
         """
         If memsys is not initialized, initialize memsys
@@ -206,7 +197,7 @@ class _Runtime:
         context
         """
         enabled_ar = cuda.managed_array(1, np.uint8)
-        enabled_ptr = self._ctypes_pointer(enabled_ar)
+        enabled_ptr = enabled_ar.device_ctypes_pointer
 
         self._single_thread_launch(
             self._memsys_module,
@@ -233,7 +224,7 @@ class _Runtime:
         )
 
         stats_for_read = cuda.managed_array(1, dt)
-        stats_ptr = self._ctypes_pointer(stats_for_read)
+        stats_ptr = stats_for_read.device_ctypes_pointer
 
         self._single_thread_launch(
             self._memsys_module, stream, "NRT_MemSys_read", [stats_ptr]
@@ -264,7 +255,7 @@ class _Runtime:
         Get a single stat from the memsys
         """
         got = cuda.managed_array(1, np.uint64)
-        got_ptr = self._ctypes_pointer(got)
+        got_ptr = got.device_ctypes_pointer
 
         self._single_thread_launch(
             self._memsys_module, stream, f"NRT_MemSys_read_{stat}", [got_ptr]
@@ -327,7 +318,7 @@ class _Runtime:
                 "Please allocate NRT Memsys first before setting to module."
             )
 
-        memsys_ptr = self._ctypes_pointer(self._memsys)
+        memsys_ptr = self._memsys.device_ctypes_pointer
 
         self._single_thread_launch(
             module, stream, "NRT_MemSys_set", [memsys_ptr]

{numba_cuda-0.14.0 → numba_cuda-0.15.1}/numba_cuda/numba/cuda/tests/cudadrv/test_cuda_driver.py

@@ -1,4 +1,4 @@
-from ctypes import byref, c_int, c_void_p, sizeof
+from ctypes import byref, c_int, sizeof
 
 from numba.cuda.cudadrv.driver import (
     host_to_device,
@@ -94,7 +94,6 @@ class TestCudaDriver(CUDATestCase):
         stream = 0
 
         if _driver.USE_NV_BINDING:
-            ptr = c_void_p(int(ptr))
             stream = _driver.binding.CUstream(stream)
 
         launch_kernel(
@@ -129,8 +128,6 @@ class TestCudaDriver(CUDATestCase):
             host_to_device(memory, array, sizeof(array), stream=stream)
 
             ptr = memory.device_ctypes_pointer
-            if _driver.USE_NV_BINDING:
-                ptr = c_void_p(int(ptr))
 
             launch_kernel(
                 function.handle,  # Kernel

{numba_cuda-0.14.0 → numba_cuda-0.15.1}/numba_cuda/numba/cuda/tests/cudadrv/test_cuda_memory.py

@@ -20,10 +20,7 @@ class TestCudaMemory(ContextResettingTestCase):
     def _template(self, obj):
         self.assertTrue(driver.is_device_memory(obj))
         driver.require_device_memory(obj)
-        if driver.USE_NV_BINDING:
-            expected_class = driver.binding.CUdeviceptr
-        else:
-            expected_class = drvapi.cu_device_ptr
+        expected_class = drvapi.cu_device_ptr
         self.assertTrue(isinstance(obj.device_ctypes_pointer, expected_class))
 
     def test_device_memory(self):

{numba_cuda-0.14.0 → numba_cuda-0.15.1}/numba_cuda/numba/cuda/tests/cudadrv/test_linker.py

@@ -104,8 +104,6 @@ def simple_lmem(A, B, dty):
 
 @skip_on_cudasim("Linking unsupported in the simulator")
 class TestLinker(CUDATestCase):
-    _NUMBA_NVIDIA_BINDING_0_ENV = {"NUMBA_CUDA_USE_NVIDIA_BINDING": "0"}
-
     @require_context
     def test_linker_basic(self):
         """Simply go through the constructor and destructor"""

{numba_cuda-0.14.0 → numba_cuda-0.15.1}/numba_cuda/numba/cuda/tests/cudadrv/test_module_callbacks.py

@@ -15,7 +15,7 @@ if not config.ENABLE_CUDASIM:
     from cuda.bindings.driver import cuModuleGetGlobal, cuMemcpyHtoD
 
     if config.CUDA_USE_NVIDIA_BINDING:
-        from cuda.cuda import CUmodule as cu_module_type
+        from cuda.bindings.driver import CUmodule as cu_module_type
     else:
         from numba.cuda.cudadrv.drvapi import cu_module as cu_module_type
 

{numba_cuda-0.14.0 → numba_cuda-0.15.1}/numba_cuda/numba/cuda/tests/cudadrv/test_nvjitlink.py

@@ -57,8 +57,6 @@ if TEST_BIN_DIR:
 )
 @skip_on_cudasim("Linking unsupported in the simulator")
 class TestLinker(CUDATestCase):
-    _NUMBA_NVIDIA_BINDING_0_ENV = {"NUMBA_CUDA_USE_NVIDIA_BINDING": "0"}
-
     def test_nvjitlink_create(self):
         patched_linker = PyNvJitLinker(cc=(7, 5))
         assert "-arch=sm_75" in patched_linker.options

{numba_cuda-0.14.0 → numba_cuda-0.15.1}/numba_cuda/numba/cuda/tests/cudapy/test_cuda_array_interface.py

@@ -12,10 +12,9 @@ from unittest.mock import call, patch
 @skip_on_cudasim("CUDA Array Interface is not supported in the simulator")
 class TestCudaArrayInterface(ContextResettingTestCase):
     def assertPointersEqual(self, a, b):
-        if driver.USE_NV_BINDING:
-            self.assertEqual(
-                int(a.device_ctypes_pointer), int(b.device_ctypes_pointer)
-            )
+        self.assertEqual(
+            a.device_ctypes_pointer.value, b.device_ctypes_pointer.value
+        )
 
     def test_as_cuda_array(self):
         h_arr = np.arange(10)

{numba_cuda-0.14.0 → numba_cuda-0.15.1}/numba_cuda.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numba-cuda
-Version: 0.14.0
+Version: 0.15.1
 Summary: CUDA target for Numba
 Author: Anaconda Inc., NVIDIA Corporation
 License: BSD 2-clause
@@ -13,11 +13,13 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numba>=0.59.1
 Provides-Extra: cu11
+Requires-Dist: cuda-bindings==11.8.*; extra == "cu11"
 Requires-Dist: cuda-python==11.8.*; extra == "cu11"
 Requires-Dist: nvidia-cuda-nvcc-cu11; extra == "cu11"
 Requires-Dist: nvidia-cuda-runtime-cu11; extra == "cu11"
 Requires-Dist: nvidia-cuda-nvrtc-cu11; extra == "cu11"
 Provides-Extra: cu12
+Requires-Dist: cuda-bindings==12.9.*; extra == "cu12"
 Requires-Dist: cuda-python==12.9.*; extra == "cu12"
 Requires-Dist: nvidia-cuda-nvcc-cu12; extra == "cu12"
 Requires-Dist: nvidia-cuda-runtime-cu12; extra == "cu12"

{numba_cuda-0.14.0 → numba_cuda-0.15.1}/numba_cuda.egg-info/requires.txt

@@ -1,12 +1,14 @@
 numba>=0.59.1
 
 [cu11]
+cuda-bindings==11.8.*
 cuda-python==11.8.*
 nvidia-cuda-nvcc-cu11
 nvidia-cuda-runtime-cu11
 nvidia-cuda-nvrtc-cu11
 
 [cu12]
+cuda-bindings==12.9.*
 cuda-python==12.9.*
 nvidia-cuda-nvcc-cu12
 nvidia-cuda-runtime-cu12

{numba_cuda-0.14.0 → numba_cuda-0.15.1}/pyproject.toml

@@ -22,12 +22,14 @@ dependencies = ["numba>=0.59.1"]
 
 [project.optional-dependencies]
 cu11 = [
+    "cuda-bindings==11.8.*",
     "cuda-python==11.8.*",  # supports all CTK 11.x
     "nvidia-cuda-nvcc-cu11",  # for libNVVM
     "nvidia-cuda-runtime-cu11",
     "nvidia-cuda-nvrtc-cu11",
 ]
 cu12 = [
+    "cuda-bindings==12.9.*",
     "cuda-python==12.9.*",  # supports all CTK 12.x
     "nvidia-cuda-nvcc-cu12",  # for libNVVM
     "nvidia-cuda-runtime-cu12",
@@ -110,7 +112,7 @@ exclude = [
 # Slightly long line in the standard version file
 "numba_cuda/_version.py" = ["E501"]
 # "Unused" imports / potentially undefined names in init files
-"numba_cuda/numba/cuda/__init__.py" = ["F401", "F403", "F405"]
+"numba_cuda/numba/cuda/__init__.py" = ["F401", "F403", "F405", "E402"]
 "numba_cuda/numba/cuda/simulator/__init__.py" = ["F401", "F403"]
 "numba_cuda/numba/cuda/simulator/cudadrv/__init__.py" = ["F401"]
 # Ignore star imports", " unused imports", " and "may be defined by star imports"

numba_cuda-0.14.0/numba_cuda/VERSION

@@ -1 +0,0 @@
-0.14.0

numba_cuda-0.14.0/numba_cuda/numba/cuda/__init__.py

@@ -1,26 +0,0 @@
-from numba import runtests
-from numba.core import config
-
-if config.ENABLE_CUDASIM:
-    from .simulator_init import *
-else:
-    from .device_init import *
-    from .device_init import _auto_device
-
-from numba.cuda.compiler import (
-    compile,
-    compile_for_current_device,
-    compile_ptx,
-    compile_ptx_for_current_device,
-)
-
-# This is the out-of-tree NVIDIA-maintained target. This is reported in Numba
-# sysinfo (`numba -s`):
-implementation = "NVIDIA"
-
-
-def test(*args, **kwargs):
-    if not is_available():
-        raise cuda_error()
-
-    return runtests.main("numba.cuda.tests", *args, **kwargs)