numba-cuda 0.16.0__py3-none-any.whl → 0.17.0__py3-none-any.whl

numba_cuda/VERSION

@@ -1 +1 @@
-0.16.0
+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/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/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/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/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/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/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/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/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/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.dist-info → numba_cuda-0.17.0.dist-info}/METADATA

@@ -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.dist-info → numba_cuda-0.17.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 _numba_cuda_redirector.pth,sha256=cmfMMmV0JPh3yEpl4bGeM9AuXiVVMSo6Z_b7RaQL3XE,30
 _numba_cuda_redirector.py,sha256=n_r8MYbu5-vcXMnLJW147k8DnFXXvgb7nPIXnlXwTyQ,2659
-numba_cuda/VERSION,sha256=qgN0VLXoMgUhoysnij9K_wX8eQCatVA_XUobmjOzjEc,7
+numba_cuda/VERSION,sha256=AtOOmOiPSo3C6kDbt2kzhgEGb8lJILUogqFPIa2X9-4,7
 numba_cuda/__init__.py,sha256=atXeUvJKR3JHcAiCFbXCVOJQUHgB1TulmsqSL_9RT3Q,114
 numba_cuda/_version.py,sha256=nzrrJXi85d18m6SPdsPsetJNClDETkmF1MrEhGLYDBs,734
 numba_cuda/numba/cuda/__init__.py,sha256=xdN14yT_i5jlikiGJy7K3E1AvUTQQ4U-t4zOgYYAwBQ,3526
@@ -12,7 +12,7 @@ numba_cuda/numba/cuda/cg.py,sha256=n-sBj05ut6U_GgFIq-PTCjPad4nXWAc0GVg_J9xD_Pc,1
 numba_cuda/numba/cuda/codegen.py,sha256=NyHz0jlH7_vRapHqfA4P-RWpMTWsQNiW9dUbVO0N5w8,16855
 numba_cuda/numba/cuda/compiler.py,sha256=_RkTTc6oSZiZVlB8w-jleBGnqxTkmzaIo7VsE3h0-18,26016
 numba_cuda/numba/cuda/cpp_function_wrappers.cu,sha256=8lUPmU6FURxphzEqkPLZRPYBCEK_wmDtHq2voPkckfs,950
-numba_cuda/numba/cuda/cuda_paths.py,sha256=CRC-L5tiVjgN0oWsgnbg0mD9VuexDNMsDgIQ3FqLxNE,15784
+numba_cuda/numba/cuda/cuda_paths.py,sha256=2r2uTfoSb1Lg5RhxmJ0rt40_wZcBcmibo16uWKUlWLs,15792
 numba_cuda/numba/cuda/cudadecl.py,sha256=_TXMu8SIT2hIhsPI0n05wuShtzp8NcPX88NH5y7xauU,22909
 numba_cuda/numba/cuda/cudaimpl.py,sha256=q6CPqD8ZtJvY8JlpMEN--d6003_FIHoHLBqNP2McNyM,39274
 numba_cuda/numba/cuda/cudamath.py,sha256=wbGjlyGVwcUAoQjgXIaAaasLdVuDSKHkf6KyID5IYBw,3979
@@ -21,7 +21,7 @@ numba_cuda/numba/cuda/decorators.py,sha256=wCLjm2FUWjznmKV_QK1egO03msOrJEnZTR1du
 numba_cuda/numba/cuda/descriptor.py,sha256=t1rSVJSCAlVACC5_Un3FQ7iubdTTBe-euqz88cvs2tI,985
 numba_cuda/numba/cuda/device_init.py,sha256=Rtwd6hQMHMLMkj6MXtndbWYFJfkIaRe0MwOIJF2nzhU,3449
 numba_cuda/numba/cuda/deviceufunc.py,sha256=zj9BbLiZD-dPttHew4olw8ANgR2nXnXEE9qjCeGLrQI,30731
-numba_cuda/numba/cuda/dispatcher.py,sha256=AZqsyQdVg-3s1uFBxHnSnuOCpVY-pW70fX9LMAy7veQ,43372
+numba_cuda/numba/cuda/dispatcher.py,sha256=Lc09syEjVLEWbvl2FRP6BgO4FYlDBsp06K64_OAEtsg,43386
 numba_cuda/numba/cuda/errors.py,sha256=WRso1Q_jCoWP5yrDBMhihRhhVtVo1-7KdN8QVE9j46o,1712
 numba_cuda/numba/cuda/extending.py,sha256=VwuU5F0AQFlJsqaiwoWk-6Itihew1FsjVT_BVjhY8Us,2278
 numba_cuda/numba/cuda/flags.py,sha256=4p12gufxChLfF1fCK_B9HJRdB0Eg8k_UFU__cItqWps,743
@@ -52,8 +52,8 @@ numba_cuda/numba/cuda/vectorizers.py,sha256=nEfQxjSA4oCX8ZzvoqjDRygDfwzxFVDXtnjx
 numba_cuda/numba/cuda/_internal/cuda_bf16.py,sha256=QYck6s_D85HBEsc__SAl_UZxf7SptqAk31mLv_1gzuE,152212
 numba_cuda/numba/cuda/cudadrv/__init__.py,sha256=inat2K8K1OVrgDe64FK7CyRmyFyNKcNO4p2_L79yRZ0,201
 numba_cuda/numba/cuda/cudadrv/devicearray.py,sha256=xJFZwbfi7o9bzPDLxSPDTLdH6iFYi8W1AbOMmikbpgY,31225
-numba_cuda/numba/cuda/cudadrv/devices.py,sha256=k87EDIRhj1ncM9PxJCjZGPFfEks99vzmHlTc55GK5X0,8062
-numba_cuda/numba/cuda/cudadrv/driver.py,sha256=lrKFJc4yuTXJ7Zzf-J72SXzM6ZKNtKjr5qsQL6LUhHE,114913
+numba_cuda/numba/cuda/cudadrv/devices.py,sha256=UB0xFDe-yyaXwe-rlkNmh2RvulU6bACktDvP41yxo8c,7974
+numba_cuda/numba/cuda/cudadrv/driver.py,sha256=T_YKjr-uh-I0c7IaJJtvtPW64C_7e5G6ySDK3HdmxhQ,117173
 numba_cuda/numba/cuda/cudadrv/drvapi.py,sha256=OnjYWnmy8ZlSfYouhzyYIpW-AJ3x1YHj32YcBY2xet4,16790
 numba_cuda/numba/cuda/cudadrv/dummyarray.py,sha256=2jycZhniMy3ncoVWQG9D8dBehTEeocBZTW43gKHL5Tc,14291
 numba_cuda/numba/cuda/cudadrv/enums.py,sha256=raWKryxamWQZ5A8ivMpyYVhhwbSpaD9lu7l1_wl2W9M,23742
@@ -82,7 +82,7 @@ numba_cuda/numba/cuda/memory_management/memsys.cu,sha256=gMBM9_Hnv3EO3Gw_GKvII8y
 numba_cuda/numba/cuda/memory_management/memsys.cuh,sha256=hPGBQgKyOfYY25ntoBXlhYyeXzxJyz0ByeTszkaKJUM,504
 numba_cuda/numba/cuda/memory_management/nrt.cu,sha256=1hzbAKyqh9783UVdVT67ZxfvJyl_Ojt8e0AbHUC86ss,4818
 numba_cuda/numba/cuda/memory_management/nrt.cuh,sha256=p2GQ-l-EfCoO0sBTyKXhIY3hxGWbPhEJcR-mLLT_V3M,2173
-numba_cuda/numba/cuda/memory_management/nrt.py,sha256=LtIW_6nH7RZjquyM48UYAJvAck3LjkI3-qn8UIO0Kzk,9866
+numba_cuda/numba/cuda/memory_management/nrt.py,sha256=vrC5lo6tIfbWUjBTxBr_ZjdS_WAcR5h7ZZyMylomyS0,9872
 numba_cuda/numba/cuda/simulator/__init__.py,sha256=ONoWJ3SwE53di0p-lFRH7NOZea2jEUWyn9sDpkOVjCw,2040
 numba_cuda/numba/cuda/simulator/api.py,sha256=hFSFPIrg-aUd-MHg2GCSosFJiL8x2XRiQaqolfTGA3A,3551
 numba_cuda/numba/cuda/simulator/bf16.py,sha256=1ZWkY4Adv8dY46YyorGKGQj3KEBqeet6rsyM8jwfAb4,16
@@ -111,17 +111,17 @@ numba_cuda/numba/cuda/tests/__init__.py,sha256=T5bnw3yl7Xa5ZJPI6OUYBDBDOgcaGqMeS
 numba_cuda/numba/cuda/tests/support.py,sha256=IpWXM2pELCeoqdQIUsvy9Rsm460omp15HMMpJsxTt9U,263
 numba_cuda/numba/cuda/tests/cudadrv/__init__.py,sha256=GdfSq6pRVSOQwmgNi7ZFQ5l0yg4-2gNar_0Rz0buUpM,157
 numba_cuda/numba/cuda/tests/cudadrv/test_array_attr.py,sha256=np2UccpkNqLFLcbjJNHGkCJF6TZIyFljB6UXD7U71nM,5299
-numba_cuda/numba/cuda/tests/cudadrv/test_context_stack.py,sha256=6LHHkKv_oib4WqYoA-Ilwuf-duz7ac6Mk4R3bFLAQEQ,4935
+numba_cuda/numba/cuda/tests/cudadrv/test_context_stack.py,sha256=8hRDvMyl1ZQaGzPuX0PJV4UXGjFO13vh3PB0jzx_QNM,5623
 numba_cuda/numba/cuda/tests/cudadrv/test_cuda_array_slicing.py,sha256=QhBQr3ZzrBMT-r132RR99UCKwrR-RwZk98RxVv5os0w,13933
 numba_cuda/numba/cuda/tests/cudadrv/test_cuda_auto_context.py,sha256=xprxASXl0g6QrOujoj07YDw3lIwu0SQbk1lGQPJHlRc,564
 numba_cuda/numba/cuda/tests/cudadrv/test_cuda_devicerecord.py,sha256=JkMbKFa3CBSMSQaSWzOqJU7DE5YlwJLux6OLAmvnSJo,5654
-numba_cuda/numba/cuda/tests/cudadrv/test_cuda_driver.py,sha256=Q8hfUK8xhmt1bUYpzVy5Knm_14QAWdt3zxZkXJ6RT-0,7409
+numba_cuda/numba/cuda/tests/cudadrv/test_cuda_driver.py,sha256=CIir5l1l8EAIn3sQZwdeDWWuQ7Ksu39NQzpYb93uHBM,7543
 numba_cuda/numba/cuda/tests/cudadrv/test_cuda_libraries.py,sha256=KWGON5OSb5Vp74QFDIiupK6ytMwwwDfbYqpENAB4lGE,801
 numba_cuda/numba/cuda/tests/cudadrv/test_cuda_memory.py,sha256=_ysNhgEnvr18miDhzFWbFoQdrPRl6wHPjXAH4sGTOPo,6377
 numba_cuda/numba/cuda/tests/cudadrv/test_cuda_ndarray.py,sha256=MzKXO2RLCHA_0XU29JfjaLrmKTwwu7PA3cspTfQgCPM,21699
 numba_cuda/numba/cuda/tests/cudadrv/test_deallocations.py,sha256=VKYRuIOPdEWkI-6E6-pRCNC1U4-Qxi0d-jX_q_7x1dI,8420
 numba_cuda/numba/cuda/tests/cudadrv/test_detect.py,sha256=DUYZeNlDgL1mQN1xHDYzTRfc-zetuikcULyULcRaC1A,2657
-numba_cuda/numba/cuda/tests/cudadrv/test_emm_plugins.py,sha256=xom2V_KImeDX5AN9XKcWln_MFhIvPrwJDxJWvE6Nspw,7070
+numba_cuda/numba/cuda/tests/cudadrv/test_emm_plugins.py,sha256=76p-pr8qPHIhf8RjmPgzOVHSpIdy6x8wzfWCH1VX-T4,7070
 numba_cuda/numba/cuda/tests/cudadrv/test_events.py,sha256=TenHde9Dieie1TmwXOoDtFYWS9ZBVUHaNTVaJ0bHgw4,1075
 numba_cuda/numba/cuda/tests/cudadrv/test_host_alloc.py,sha256=ciy4dAK6-qrf1f8X_xJVsrIEF_a2iLc16m2kJc6nj78,2169
 numba_cuda/numba/cuda/tests/cudadrv/test_init.py,sha256=mRcGOJWTUpZ533EWq4Tbp3D_aHFFcVS6c_iZqhId7I0,4494
@@ -167,7 +167,7 @@ numba_cuda/numba/cuda/tests/cudapy/test_complex_kernel.py,sha256=KIuXQ0ihgQQXM-e
 numba_cuda/numba/cuda/tests/cudapy/test_const_string.py,sha256=li1UsV5vc2M01cJ7k6_526VPtuAOAKr8e7kb1CDUXi4,4323
 numba_cuda/numba/cuda/tests/cudapy/test_constmem.py,sha256=ZWmyKvFokRMjqyXjVpZVOnR6LR694GWcbUn2jVEQV14,5170
 numba_cuda/numba/cuda/tests/cudapy/test_cooperative_groups.py,sha256=3OkjhcjPp_P3Pnc1zbteGpAGpoN07cG8Xtdnunx5yWA,5973
-numba_cuda/numba/cuda/tests/cudapy/test_cuda_array_interface.py,sha256=k6pkt63aipYZd2ekYOuXw_GnyGWImcKwIHOkh5PEsr4,15713
+numba_cuda/numba/cuda/tests/cudapy/test_cuda_array_interface.py,sha256=GEIKRMBQX2L72nAmoET_LJjkFHwnHM6gvwsZmWaGkuc,15585
 numba_cuda/numba/cuda/tests/cudapy/test_cuda_jit_no_types.py,sha256=8prL2FTiaajW-UHSL9al-nBniygOfpdAOT_Dkej4PWI,2138
 numba_cuda/numba/cuda/tests/cudapy/test_datetime.py,sha256=MnOeDWMz-rL3-07FsswM06Laxmm0KjTmTwhrP3rmchQ,3526
 numba_cuda/numba/cuda/tests/cudapy/test_debug.py,sha256=1P369s02AvGu7fSIEe_YxSgh3c6S72Aw1gRgmepDbQY,3383
@@ -221,7 +221,7 @@ numba_cuda/numba/cuda/tests/cudapy/test_serialize.py,sha256=k0YBvZYE9CfSIPvQm5M9
 numba_cuda/numba/cuda/tests/cudapy/test_slicing.py,sha256=9QRqT29X9CUivLGQy9tFb3CWcflCOWX1zL_qpK8ixQE,903
 numba_cuda/numba/cuda/tests/cudapy/test_sm.py,sha256=xIsD9kfvZwy0S5zvV0VHTTrwPv_SnlJ1aPnziWnC4nM,14537
 numba_cuda/numba/cuda/tests/cudapy/test_sm_creation.py,sha256=9W04zGf8V-RgA4703ey4JUMNNjijTc_us62UZ37_KuM,7133
-numba_cuda/numba/cuda/tests/cudapy/test_stream_api.py,sha256=E0tQM4sC2qDGC-lAg_MY5zjtsZlP63h0LAVGE6rfdM0,1855
+numba_cuda/numba/cuda/tests/cudapy/test_stream_api.py,sha256=zyWmwlsKvIswD7lHvFl12KvvPTo7NQFZHC1_b_En-vs,1752
 numba_cuda/numba/cuda/tests/cudapy/test_sync.py,sha256=mKBGmFoqA1AkK1EYVcwxcdTXtwSegVKLpyB01XnebbU,7815
 numba_cuda/numba/cuda/tests/cudapy/test_transpose.py,sha256=qHxBXLUUyJSy69BGshzus06lBKoppZ3N-5hLqLrg8NE,3149
 numba_cuda/numba/cuda/tests/cudapy/test_ufuncs.py,sha256=V-gZsXP_OT9ldhVqREakU-qsLB2nMK_4nUzBCV8HZpY,10289
@@ -276,8 +276,8 @@ numba_cuda/numba/cuda/tests/test_binary_generation/generate_raw_ltoir.py,sha256=
 numba_cuda/numba/cuda/tests/test_binary_generation/nrt_extern.cu,sha256=T9ubst3fFUK7EXyXXMi73wAban3VFFQ986cY5OcKfvI,157
 numba_cuda/numba/cuda/tests/test_binary_generation/test_device_functions.cu,sha256=IB5t-dVhrKVoue3AbUx3yVMxPG0hBF_yZbzb4642sf0,538
 numba_cuda/numba/cuda/tests/test_binary_generation/undefined_extern.cu,sha256=q3oxZziT8KDodeNcEBiWULH6vMrHCWucmJmtrg8C0d0,128
-numba_cuda-0.16.0.dist-info/licenses/LICENSE,sha256=eHeYE-XjASmwbxfsP5AImgfzRwZurZGqH1f6OFwJ4io,1326
-numba_cuda-0.16.0.dist-info/METADATA,sha256=ok7G81fK2G3yfJwH2mEj4Hd2MvXU9ClAysIg2prYrsY,3195
-numba_cuda-0.16.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-numba_cuda-0.16.0.dist-info/top_level.txt,sha256=C50SsH-8tXDmt7I0Y3nlJYhS5s6pqWflCPdobe9vx2M,11
-numba_cuda-0.16.0.dist-info/RECORD,,
+numba_cuda-0.17.0.dist-info/licenses/LICENSE,sha256=eHeYE-XjASmwbxfsP5AImgfzRwZurZGqH1f6OFwJ4io,1326
+numba_cuda-0.17.0.dist-info/METADATA,sha256=NnZAJFI68kEFW7PuhL0bIU3HxgQ1N1_70a0bi-2SuZg,3196
+numba_cuda-0.17.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+numba_cuda-0.17.0.dist-info/top_level.txt,sha256=C50SsH-8tXDmt7I0Y3nlJYhS5s6pqWflCPdobe9vx2M,11
+numba_cuda-0.17.0.dist-info/RECORD,,