numba-cuda 0.16.0__tar.gz → 0.17.0__tar.gz

{numba_cuda-0.16.0 → numba_cuda-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numba-cuda
-Version: 0.16.0
+Version: 0.17.0
 Summary: CUDA target for Numba
 Author: Anaconda Inc., NVIDIA Corporation
 License: BSD 2-clause
@@ -75,7 +75,7 @@ If you want to manage all run-time dependencies yourself, also pass the `--no-de
 python -m numba.runtests numba.cuda.tests
 ```
 
-This should discover the`numba.cuda` module from the `numba_cuda` package. You
+This should discover the `numba.cuda` module from the `numba_cuda` package. You
 can check where `numba.cuda` files are being located by running
 
 ```

{numba_cuda-0.16.0 → numba_cuda-0.17.0}/README.md

@@ -33,7 +33,7 @@ If you want to manage all run-time dependencies yourself, also pass the `--no-de
 python -m numba.runtests numba.cuda.tests
 ```
 
-This should discover the`numba.cuda` module from the `numba_cuda` package. You
+This should discover the `numba.cuda` module from the `numba_cuda` package. You
 can check where `numba.cuda` files are being located by running
 
 ```

numba_cuda-0.17.0/numba_cuda/VERSION

@@ -0,0 +1 @@
+0.17.0

{numba_cuda-0.16.0 → numba_cuda-0.17.0}/numba_cuda/numba/cuda/cuda_paths.py

@@ -100,7 +100,7 @@ def _get_nvrtc_system_ctk():
 def _get_nvrtc_path_decision():
     options = _build_options(
         [
-            ("CUDA_HOME", lambda: get_cuda_home("nvrtc")),
+            ("CUDA_HOME", lambda: get_cuda_home(_cudalib_path())),
             ("Conda environment", get_conda_ctk),
             ("Conda environment (NVIDIA package)", get_nvidia_cudalib_ctk),
             ("NVIDIA NVCC Wheel", _get_nvrtc_wheel),

{numba_cuda-0.16.0 → numba_cuda-0.17.0}/numba_cuda/numba/cuda/cudadrv/devices.py

@@ -40,6 +40,8 @@ class _DeviceList(object):
         """
         Returns the context manager for device *devnum*.
         """
+        if not isinstance(devnum, (int, slice)) and USE_NV_BINDING:
+            devnum = int(devnum)
         return self.lst[devnum]
 
     def __str__(self):
@@ -159,12 +161,8 @@ class _Runtime(object):
                     # Get primary context for the active device
                     ctx = self.gpus[ac.devnum].get_primary_context()
                     # Is active context the primary context?
-                    if USE_NV_BINDING:
-                        ctx_handle = int(ctx.handle)
-                        ac_ctx_handle = int(ac.context_handle)
-                    else:
-                        ctx_handle = ctx.handle.value
-                        ac_ctx_handle = ac.context_handle.value
+                    ctx_handle = ctx.handle.value
+                    ac_ctx_handle = ac.context_handle.value
                     if ctx_handle != ac_ctx_handle:
                         msg = (
                             "Numba cannot operate on non-primary"

{numba_cuda-0.16.0 → numba_cuda-0.17.0}/numba_cuda/numba/cuda/cudadrv/driver.py

@@ -490,11 +490,11 @@ class Driver(object):
         with self.get_active_context() as ac:
             if ac.devnum is not None:
                 if USE_NV_BINDING:
-                    return driver.cuCtxPopCurrent()
+                    popped = drvapi.cu_context(int(driver.cuCtxPopCurrent()))
                 else:
                     popped = drvapi.cu_context()
                     driver.cuCtxPopCurrent(byref(popped))
-                    return popped
+                return popped
 
     def get_active_context(self):
         """Returns an instance of ``_ActiveContext``."""
@@ -538,6 +538,8 @@ class _ActiveContext(object):
                 hctx = driver.cuCtxGetCurrent()
                 if int(hctx) == 0:
                     hctx = None
+                else:
+                    hctx = drvapi.cu_context(int(hctx))
             else:
                 hctx = drvapi.cu_context(0)
                 driver.cuCtxGetCurrent(byref(hctx))
@@ -716,6 +718,7 @@ class Device(object):
         # create primary context
         if USE_NV_BINDING:
             hctx = driver.cuDevicePrimaryCtxRetain(self.id)
+            hctx = drvapi.cu_context(int(hctx))
         else:
             hctx = drvapi.cu_context()
             driver.cuDevicePrimaryCtxRetain(byref(hctx), self.id)
@@ -1254,6 +1257,7 @@ class _PendingDeallocs(object):
                 [dtor, handle, size] = self._cons.popleft()
                 _logger.info("dealloc: %s %s bytes", dtor.__name__, size)
                 dtor(handle)
+
             self._size = 0
 
     @contextlib.contextmanager
@@ -1430,7 +1434,10 @@ class Context(object):
         """
         Pushes this context on the current CPU Thread.
         """
-        driver.cuCtxPushCurrent(self.handle)
+        if USE_NV_BINDING:
+            driver.cuCtxPushCurrent(self.handle.value)
+        else:
+            driver.cuCtxPushCurrent(self.handle)
         self.prepare_for_use()
 
     def pop(self):
@@ -1439,10 +1446,7 @@ class Context(object):
         must be at the top of the context stack, otherwise an error will occur.
         """
         popped = driver.pop_active_context()
-        if USE_NV_BINDING:
-            assert int(popped) == int(self.handle)
-        else:
-            assert popped.value == self.handle.value
+        assert popped.value == self.handle.value
 
     def memalloc(self, bytesize):
         return self.memory_manager.memalloc(bytesize)
@@ -1535,21 +1539,25 @@ class Context(object):
 
     def get_default_stream(self):
         if USE_NV_BINDING:
-            handle = binding.CUstream(CU_STREAM_DEFAULT)
+            handle = drvapi.cu_stream(int(binding.CUstream(CU_STREAM_DEFAULT)))
         else:
             handle = drvapi.cu_stream(drvapi.CU_STREAM_DEFAULT)
         return Stream(weakref.proxy(self), handle, None)
 
     def get_legacy_default_stream(self):
         if USE_NV_BINDING:
-            handle = binding.CUstream(binding.CU_STREAM_LEGACY)
+            handle = drvapi.cu_stream(
+                int(binding.CUstream(binding.CU_STREAM_LEGACY))
+            )
         else:
             handle = drvapi.cu_stream(drvapi.CU_STREAM_LEGACY)
         return Stream(weakref.proxy(self), handle, None)
 
     def get_per_thread_default_stream(self):
         if USE_NV_BINDING:
-            handle = binding.CUstream(binding.CU_STREAM_PER_THREAD)
+            handle = drvapi.cu_stream(
+                int(binding.CUstream(binding.CU_STREAM_PER_THREAD))
+            )
         else:
             handle = drvapi.cu_stream(drvapi.CU_STREAM_PER_THREAD)
         return Stream(weakref.proxy(self), handle, None)
@@ -1561,7 +1569,7 @@ class Context(object):
             # default stream, which we define also as CU_STREAM_DEFAULT when
             # the NV binding is in use).
             flags = binding.CUstream_flags.CU_STREAM_DEFAULT.value
-            handle = driver.cuStreamCreate(flags)
+            handle = drvapi.cu_stream(int(driver.cuStreamCreate(flags)))
         else:
             handle = drvapi.cu_stream()
             driver.cuStreamCreate(byref(handle), 0)
@@ -1575,7 +1583,7 @@ class Context(object):
         if not isinstance(ptr, int):
             raise TypeError("ptr for external stream must be an int")
         if USE_NV_BINDING:
-            handle = binding.CUstream(ptr)
+            handle = drvapi.cu_stream(int(binding.CUstream(ptr)))
         else:
             handle = drvapi.cu_stream(ptr)
         return Stream(weakref.proxy(self), handle, None, external=True)
@@ -1585,7 +1593,7 @@ class Context(object):
         if not timing:
             flags |= enums.CU_EVENT_DISABLE_TIMING
         if USE_NV_BINDING:
-            handle = driver.cuEventCreate(flags)
+            handle = drvapi.cu_event(int(driver.cuEventCreate(flags)))
         else:
             handle = drvapi.cu_event()
             driver.cuEventCreate(byref(handle), flags)
@@ -1776,14 +1784,14 @@ def _pin_finalizer(memory_manager, ptr, alloc_key, mapped):
 
 def _event_finalizer(deallocs, handle):
     def core():
-        deallocs.add_item(driver.cuEventDestroy, handle)
+        deallocs.add_item(driver.cuEventDestroy, handle.value)
 
     return core
 
 
 def _stream_finalizer(deallocs, handle):
     def core():
-        deallocs.add_item(driver.cuStreamDestroy, handle)
+        deallocs.add_item(driver.cuStreamDestroy, handle.value)
 
     return core
 
@@ -2054,6 +2062,9 @@ class MemoryPointer(object):
     __cuda_memory__ = True
 
     def __init__(self, context, pointer, size, owner=None, finalizer=None):
+        if USE_NV_BINDING and isinstance(pointer, ctypes.c_void_p):
+            pointer = binding.CUdeviceptr(pointer.value)
+
         self.context = context
         self.device_pointer = pointer
         self.size = size
@@ -2086,9 +2097,11 @@ class MemoryPointer(object):
     def memset(self, byte, count=None, stream=0):
         count = self.size if count is None else count
         if stream:
-            driver.cuMemsetD8Async(
-                self.device_pointer, byte, count, stream.handle
-            )
+            if USE_NV_BINDING:
+                handle = stream.handle.value
+            else:
+                handle = stream.handle
+            driver.cuMemsetD8Async(self.device_pointer, byte, count, handle)
         else:
             driver.cuMemsetD8(self.device_pointer, byte, count)
 
@@ -2326,27 +2339,16 @@ class Stream(object):
             weakref.finalize(self, finalizer)
 
     def __int__(self):
-        if USE_NV_BINDING:
-            return int(self.handle)
-        else:
-            # The default stream's handle.value is 0, which gives `None`
-            return self.handle.value or drvapi.CU_STREAM_DEFAULT
+        # The default stream's handle.value is 0, which gives `None`
+        return self.handle.value or drvapi.CU_STREAM_DEFAULT
 
     def __repr__(self):
-        if USE_NV_BINDING:
-            default_streams = {
-                CU_STREAM_DEFAULT: "<Default CUDA stream on %s>",
-                binding.CU_STREAM_LEGACY: "<Legacy default CUDA stream on %s>",
-                binding.CU_STREAM_PER_THREAD: "<Per-thread default CUDA stream on %s>",
-            }
-            ptr = int(self.handle) or 0
-        else:
-            default_streams = {
-                drvapi.CU_STREAM_DEFAULT: "<Default CUDA stream on %s>",
-                drvapi.CU_STREAM_LEGACY: "<Legacy default CUDA stream on %s>",
-                drvapi.CU_STREAM_PER_THREAD: "<Per-thread default CUDA stream on %s>",
-            }
-            ptr = self.handle.value or drvapi.CU_STREAM_DEFAULT
+        default_streams = {
+            drvapi.CU_STREAM_DEFAULT: "<Default CUDA stream on %s>",
+            drvapi.CU_STREAM_LEGACY: "<Legacy default CUDA stream on %s>",
+            drvapi.CU_STREAM_PER_THREAD: "<Per-thread default CUDA stream on %s>",
+        }
+        ptr = self.handle.value or drvapi.CU_STREAM_DEFAULT
 
         if ptr in default_streams:
             return default_streams[ptr] % self.context
@@ -2360,7 +2362,11 @@ class Stream(object):
         Wait for all commands in this stream to execute. This will commit any
         pending memory transfers.
         """
-        driver.cuStreamSynchronize(self.handle)
+        if USE_NV_BINDING:
+            handle = self.handle.value
+        else:
+            handle = self.handle
+        driver.cuStreamSynchronize(handle)
 
     @contextlib.contextmanager
     def auto_synchronize(self):
@@ -2385,6 +2391,16 @@ class Stream(object):
         callback will block later work in the stream and may block other
         callbacks from being executed.
 
+        .. warning::
+            There is a potential for deadlock due to a lock ordering issue
+            between the GIL and the CUDA driver lock when using libraries
+            that call CUDA functions without releasing the GIL. This can
+            occur when the callback function, which holds the CUDA driver lock,
+            attempts to acquire the GIL while another thread that holds the GIL
+            is waiting for the CUDA driver lock. Consider using libraries that
+            properly release the GIL around CUDA operations or restructure
+            your code to avoid this situation.
+
         Note: The driver function underlying this method is marked for
         eventual deprecation and may be replaced in a future CUDA release.
 
@@ -2398,9 +2414,11 @@ class Stream(object):
             stream_callback = binding.CUstreamCallback(ptr)
             # The callback needs to receive a pointer to the data PyObject
             data = id(data)
+            handle = self.handle.value
         else:
             stream_callback = self._stream_callback
-        driver.cuStreamAddCallback(self.handle, stream_callback, data, 0)
+            handle = self.handle
+        driver.cuStreamAddCallback(handle, stream_callback, data, 0)
 
     @staticmethod
     @cu_stream_callback_pyobj
@@ -2417,6 +2435,16 @@ class Stream(object):
         """
         Return an awaitable that resolves once all preceding stream operations
         are complete. The result of the awaitable is the current stream.
+
+        .. warning::
+            There is a potential for deadlock due to a lock ordering issue
+            between the GIL and the CUDA driver lock when using libraries
+            that call CUDA functions without releasing the GIL. This can
+            occur when the callback function (internally used by this method),
+            which holds the CUDA driver lock, attempts to acquire the GIL
+            while another thread that holds the GIL is waiting for the CUDA driver lock.
+            Consider using libraries that properly release the GIL around
+            CUDA operations or restructure your code to avoid this situation.
         """
         loop = asyncio.get_running_loop()
         future = loop.create_future()
@@ -2468,27 +2496,35 @@ class Event(object):
         completed.
         """
         if USE_NV_BINDING:
-            hstream = stream.handle if stream else binding.CUstream(0)
+            hstream = stream.handle.value if stream else binding.CUstream(0)
+            handle = self.handle.value
         else:
             hstream = stream.handle if stream else 0
-        driver.cuEventRecord(self.handle, hstream)
+            handle = self.handle
+        driver.cuEventRecord(handle, hstream)
 
     def synchronize(self):
         """
         Synchronize the host thread for the completion of the event.
         """
-        driver.cuEventSynchronize(self.handle)
+        if USE_NV_BINDING:
+            handle = self.handle.value
+        else:
+            handle = self.handle
+        driver.cuEventSynchronize(handle)
 
     def wait(self, stream=0):
         """
         All future works submitted to stream will wait util the event completes.
         """
         if USE_NV_BINDING:
-            hstream = stream.handle if stream else binding.CUstream(0)
+            hstream = stream.handle.value if stream else binding.CUstream(0)
+            handle = self.handle.value
         else:
             hstream = stream.handle if stream else 0
+            handle = self.handle
         flags = 0
-        driver.cuStreamWaitEvent(hstream, self.handle, flags)
+        driver.cuStreamWaitEvent(hstream, handle, flags)
 
     def elapsed_time(self, evtend):
         return event_elapsed_time(self, evtend)
@@ -2499,7 +2535,9 @@ def event_elapsed_time(evtstart, evtend):
     Compute the elapsed time between two events in milliseconds.
     """
     if USE_NV_BINDING:
-        return driver.cuEventElapsedTime(evtstart.handle, evtend.handle)
+        return driver.cuEventElapsedTime(
+            evtstart.handle.value, evtend.handle.value
+        )
     else:
         msec = c_float()
         driver.cuEventElapsedTime(byref(msec), evtstart.handle, evtend.handle)
@@ -3477,7 +3515,11 @@ def host_to_device(dst, src, size, stream=0):
     if stream:
         assert isinstance(stream, Stream)
         fn = driver.cuMemcpyHtoDAsync
-        varargs.append(stream.handle)
+        if USE_NV_BINDING:
+            handle = stream.handle.value
+        else:
+            handle = stream.handle
+        varargs.append(handle)
     else:
         fn = driver.cuMemcpyHtoD
 
@@ -3495,7 +3537,11 @@ def device_to_host(dst, src, size, stream=0):
     if stream:
         assert isinstance(stream, Stream)
         fn = driver.cuMemcpyDtoHAsync
-        varargs.append(stream.handle)
+        if USE_NV_BINDING:
+            handle = stream.handle.value
+        else:
+            handle = stream.handle
+        varargs.append(handle)
     else:
         fn = driver.cuMemcpyDtoH
 
@@ -3513,7 +3559,11 @@ def device_to_device(dst, src, size, stream=0):
     if stream:
         assert isinstance(stream, Stream)
         fn = driver.cuMemcpyDtoDAsync
-        varargs.append(stream.handle)
+        if USE_NV_BINDING:
+            handle = stream.handle.value
+        else:
+            handle = stream.handle
+        varargs.append(handle)
     else:
         fn = driver.cuMemcpyDtoD
 
@@ -3534,7 +3584,11 @@ def device_memset(dst, val, size, stream=0):
     if stream:
         assert isinstance(stream, Stream)
         fn = driver.cuMemsetD8Async
-        varargs.append(stream.handle)
+        if USE_NV_BINDING:
+            handle = stream.handle.value
+        else:
+            handle = stream.handle
+        varargs.append(handle)
     else:
         fn = driver.cuMemsetD8
 

{numba_cuda-0.16.0 → numba_cuda-0.17.0}/numba_cuda/numba/cuda/dispatcher.py

@@ -458,11 +458,10 @@ class _Kernel(serialize.ReduceMixin):
             self._prepare_args(t, v, stream, retr, kernelargs)
 
         if driver.USE_NV_BINDING:
-            zero_stream = driver.binding.CUstream(0)
+            stream_handle = stream and stream.handle.value or 0
         else:
             zero_stream = None
-
-        stream_handle = stream and stream.handle or zero_stream
+            stream_handle = stream and stream.handle or zero_stream
 
         # Invoke kernel
         driver.launch_kernel(

{numba_cuda-0.16.0 → numba_cuda-0.17.0}/numba_cuda/numba/cuda/memory_management/nrt.py

@@ -143,7 +143,7 @@ class _Runtime:
             1,
             1,
             0,
-            stream.handle,
+            stream.handle.value,
             params,
             cooperative=False,
         )

{numba_cuda-0.16.0 → numba_cuda-0.17.0}/numba_cuda/numba/cuda/tests/cudadrv/test_context_stack.py

@@ -25,6 +25,19 @@ class TestContextStack(CUDATestCase):
         gpulist = list(cuda.gpus)
         self.assertGreater(len(gpulist), 0)
 
+    def test_gpus_cudevice_indexing(self):
+        """Test that CUdevice objects can be used to index into cuda.gpus"""
+        # When using the CUDA Python bindings, the device ids are CUdevice
+        # objects, otherwise they are integers. We test that the device id is
+        # usable as an index into cuda.gpus.
+        device_ids = [device.id for device in cuda.list_devices()]
+        for device_id in device_ids:
+            with cuda.gpus[device_id]:
+                # Check that the device is an integer if not using the CUDA
+                # Python bindings, otherwise it's a CUdevice object
+                assert isinstance(device_id, int) != driver.USE_NV_BINDING
+                self.assertEqual(cuda.gpus.current.id, device_id)
+
 
 class TestContextAPI(CUDATestCase):
     def tearDown(self):
@@ -82,7 +95,8 @@ class Test3rdPartyContext(CUDATestCase):
         the_driver = driver.driver
         if driver.USE_NV_BINDING:
             dev = driver.binding.CUdevice(0)
-            hctx = the_driver.cuDevicePrimaryCtxRetain(dev)
+            binding_hctx = the_driver.cuDevicePrimaryCtxRetain(dev)
+            hctx = driver.drvapi.cu_context(int(binding_hctx))
         else:
             dev = 0
             hctx = driver.drvapi.cu_context()
@@ -93,10 +107,7 @@ class Test3rdPartyContext(CUDATestCase):
             # Check that the context from numba matches the created primary
             # context.
             my_ctx = cuda.current_context()
-            if driver.USE_NV_BINDING:
-                self.assertEqual(int(my_ctx.handle), int(ctx.handle))
-            else:
-                self.assertEqual(my_ctx.handle.value, ctx.handle.value)
+            self.assertEqual(my_ctx.handle.value, ctx.handle.value)
 
             extra_work()
         finally:

{numba_cuda-0.16.0 → numba_cuda-0.17.0}/numba_cuda/numba/cuda/tests/cudadrv/test_cuda_driver.py

@@ -129,6 +129,10 @@ class TestCudaDriver(CUDATestCase):
 
             ptr = memory.device_ctypes_pointer
 
+            stream_handle = stream.handle
+            if _driver.USE_NV_BINDING:
+                stream_handle = stream_handle.value
+
             launch_kernel(
                 function.handle,  # Kernel
                 1,
@@ -138,7 +142,7 @@ class TestCudaDriver(CUDATestCase):
                 1,
                 1,  # bx, by, bz
                 0,  # dynamic shared mem
-                stream.handle,  # stream
+                stream_handle,  # stream
                 [ptr],
             )  # arguments
 

{numba_cuda-0.16.0 → numba_cuda-0.17.0}/numba_cuda/numba/cuda/tests/cudadrv/test_emm_plugins.py

@@ -84,7 +84,7 @@ if not config.ENABLE_CUDASIM:
             # the tests don't try to do too much with it (e.g. open / close
             # it).
             self.get_ipc_handle_called = True
-            return "Dummy IPC handle for alloc %s" % memory.device_pointer.value
+            return "Dummy IPC handle for alloc %s" % memory.device_pointer_value
 
         @property
         def interface_version(self):

{numba_cuda-0.16.0 → numba_cuda-0.17.0}/numba_cuda/numba/cuda/tests/cudapy/test_cuda_array_interface.py

@@ -2,7 +2,6 @@ import numpy as np
 
 from numba import vectorize, guvectorize
 from numba import cuda
-from numba.cuda.cudadrv import driver
 from numba.cuda.testing import unittest, ContextResettingTestCase, ForeignArray
 from numba.cuda.testing import skip_on_cudasim, skip_if_external_memmgr
 from numba.tests.support import linux_only, override_config
@@ -32,10 +31,7 @@ class TestCudaArrayInterface(ContextResettingTestCase):
         self.assertPointersEqual(wrapped, d_arr)
 
     def get_stream_value(self, stream):
-        if driver.USE_NV_BINDING:
-            return int(stream.handle)
-        else:
-            return stream.handle.value
+        return stream.handle.value
 
     @skip_if_external_memmgr("Ownership not relevant with external memmgr")
     def test_ownership(self):

{numba_cuda-0.16.0 → numba_cuda-0.17.0}/numba_cuda/numba/cuda/tests/cudapy/test_stream_api.py

@@ -4,7 +4,7 @@ from numba.cuda.testing import (
     unittest,
     CUDATestCase,
 )
-from numba import config, cuda
+from numba import cuda
 
 # Basic tests that stream APIs execute on the hardware and in the simulator.
 #
@@ -38,10 +38,7 @@ class TestStreamAPI(CUDATestCase):
         # We don't test synchronization on the stream because it's not a real
         # stream - we used a dummy pointer for testing the API, so we just
         # ensure that the stream handle matches the external stream pointer.
-        if config.CUDA_USE_NVIDIA_BINDING:
-            value = int(s.handle)
-        else:
-            value = s.handle.value
+        value = s.handle.value
         self.assertEqual(ptr, value)
 
     @skip_unless_cudasim("External streams are usable with hardware")

{numba_cuda-0.16.0 → numba_cuda-0.17.0}/numba_cuda.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numba-cuda
-Version: 0.16.0
+Version: 0.17.0
 Summary: CUDA target for Numba
 Author: Anaconda Inc., NVIDIA Corporation
 License: BSD 2-clause
@@ -75,7 +75,7 @@ If you want to manage all run-time dependencies yourself, also pass the `--no-de
 python -m numba.runtests numba.cuda.tests
 ```
 
-This should discover the`numba.cuda` module from the `numba_cuda` package. You
+This should discover the `numba.cuda` module from the `numba_cuda` package. You
 can check where `numba.cuda` files are being located by running
 
 ```

numba_cuda-0.16.0/numba_cuda/VERSION

@@ -1 +0,0 @@
-0.16.0