numba-cuda 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

numba_cuda/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.0

numba_cuda/numba/cuda/cudadrv/devicearray.py

@@ -570,10 +570,13 @@ class DeviceNDArray(DeviceNDArrayBase):
         '''
         return self._dummy.is_c_contig
 
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None, copy=None):
         """
         :return: an `numpy.ndarray`, so copies to the host.
         """
+        if copy is False:
+            msg = "`copy=False` is not supported. A copy is always created."
+            raise ValueError(msg)
         if dtype:
             return self.copy_to_host().__array__(dtype)
         else:

numba_cuda/numba/cuda/cudadrv/driver.py

@@ -18,7 +18,6 @@ import functools
 import warnings
 import logging
 import threading
-import traceback
 import asyncio
 import pathlib
 import subprocess
@@ -40,6 +39,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
 from numba.cuda.cudadrv import enums, drvapi, nvrtc
 
 try:
@@ -66,25 +66,6 @@ _py_decref.argtypes = [ctypes.py_object]
 _py_incref.argtypes = [ctypes.py_object]
 
 
-def _readenv(name, ctor, default):
-    value = os.environ.get(name)
-    if value is None:
-        return default() if callable(default) else default
-    try:
-        if ctor is bool:
-            return value.lower() in {'1', "true"}
-        return ctor(value)
-    except Exception:
-        warnings.warn(
-            f"Environment variable '{name}' is defined but its associated "
-            f"value '{value}' could not be parsed.\n"
-            "The parse failed with exception:\n"
-            f"{traceback.format_exc()}",
-            RuntimeWarning
-        )
-        return default
-
-
 _MVC_ERROR_MESSAGE = (
     "Minor version compatibility requires ptxcompiler and cubinlinker packages "
     "to be available"

numba_cuda/numba/cuda/cudadrv/nvrtc.py

@@ -266,7 +266,11 @@ def compile(src, name, cc, ltoir=False):
     cudadrv_path = os.path.dirname(os.path.abspath(__file__))
     numba_cuda_path = os.path.dirname(cudadrv_path)
     numba_include = f'-I{numba_cuda_path}'
-    options = [arch, *cuda_include, numba_include, '-rdc', 'true']
+
+    nrt_path = os.path.join(numba_cuda_path, "runtime")
+    nrt_include = f'-I{nrt_path}'
+
+    options = [arch, *cuda_include, numba_include, nrt_include, '-rdc', 'true']
 
     if ltoir:
         options.append("-dlto")

numba_cuda/numba/cuda/dispatcher.py

@@ -21,6 +21,7 @@ from numba.cuda.descriptor import cuda_target
 from numba.cuda.errors import (missing_launch_config_msg,
                                normalize_kernel_dimensions)
 from numba.cuda import types as cuda_types
+from numba.cuda.runtime.nrt import rtsys
 
 from numba import cuda
 from numba import _dispatcher
@@ -253,7 +254,14 @@ class _Kernel(serialize.ReduceMixin):
         """
         Force binding to current CUDA context
         """
-        self._codelibrary.get_cufunc()
+        cufunc = self._codelibrary.get_cufunc()
+
+        if hasattr(self, "target_context") and self.target_context.enable_nrt:
+            rtsys.ensure_initialized()
+            rtsys.set_memsys_to_module(cufunc.module)
+            # We don't know which stream the kernel will be launched on, so
+            # we force synchronize here.
+            cuda.synchronize()
 
     @property
     def regs_per_thread(self):

numba_cuda/numba/cuda/runtime/__init__.py

@@ -0,0 +1 @@
+from numba.cuda.runtime.nrt import rtsys # noqa: F401

numba_cuda/numba/cuda/runtime/memsys.cu

@@ -0,0 +1,94 @@
+#include "memsys.cuh"
+
+__device__ size_t memsys_size = sizeof(NRT_MemSys);
+
+namespace detail
+{
+  void __device__ check_memsys()
+  {
+    if (TheMSys == nullptr)
+    {
+      assert(false && "TheMSys pointer is null. Please use NRT_MemSys_set to set pointer first.");
+    }
+  }
+}
+
+extern "C" __global__ void NRT_MemSys_set(NRT_MemSys *memsys_ptr)
+{
+  TheMSys = memsys_ptr;
+}
+
+extern "C" __global__ void NRT_MemSys_read(uint64_t *managed_memsys)
+{
+  detail::check_memsys();
+  managed_memsys[0] = TheMSys->stats.alloc;
+  managed_memsys[1] = TheMSys->stats.free;
+  managed_memsys[2] = TheMSys->stats.mi_alloc;
+  managed_memsys[3] = TheMSys->stats.mi_free;
+}
+
+extern "C" __global__ void NRT_MemSys_read_alloc(uint64_t *managed_result)
+{
+  detail::check_memsys();
+  managed_result[0] = TheMSys->stats.alloc;
+}
+
+extern "C" __global__ void NRT_MemSys_read_free(uint64_t *managed_result)
+{
+  detail::check_memsys();
+  managed_result[0] = TheMSys->stats.free;
+}
+
+extern "C" __global__ void NRT_MemSys_read_mi_alloc(uint64_t *managed_result)
+{
+  detail::check_memsys();
+  managed_result[0] = TheMSys->stats.mi_alloc;
+}
+
+extern "C" __global__ void NRT_MemSys_read_mi_free(uint64_t *managed_result)
+{
+  detail::check_memsys();
+  managed_result[0] = TheMSys->stats.mi_free;
+}
+
+extern "C" __global__ void NRT_MemSys_init(void)
+{
+  detail::check_memsys();
+  TheMSys->stats.enabled = false;
+  TheMSys->stats.alloc = 0;
+  TheMSys->stats.free = 0;
+  TheMSys->stats.mi_alloc = 0;
+  TheMSys->stats.mi_free = 0;
+}
+
+extern "C" __global__ void NRT_MemSys_enable_stats(void)
+{
+  detail::check_memsys();
+  TheMSys->stats.enabled = true;
+}
+
+extern "C" __global__ void NRT_MemSys_disable_stats(void)
+{
+  detail::check_memsys();
+  TheMSys->stats.enabled = false;
+}
+
+extern "C" __global__ void NRT_MemSys_stats_enabled(uint8_t *enabled)
+{
+  detail::check_memsys();
+  *enabled = static_cast<uint8_t>(TheMSys->stats.enabled);
+}
+
+extern "C" __global__ void NRT_MemSys_print(void)
+{
+  if (TheMSys != nullptr)
+  {
+    printf("TheMSys->stats.enabled %d\n", TheMSys->stats.enabled);
+    printf("TheMSys->stats.alloc %lu\n", TheMSys->stats.alloc.load());
+    printf("TheMSys->stats.free %lu\n", TheMSys->stats.free.load());
+    printf("TheMSys->stats.mi_alloc %lu\n", TheMSys->stats.mi_alloc.load());
+    printf("TheMSys->stats.mi_free %lu\n", TheMSys->stats.mi_free.load());
+  } else {
+    printf("TheMsys is null.\n");
+  }
+}

numba_cuda/numba/cuda/runtime/memsys.cuh

@@ -0,0 +1,17 @@
+#include <cuda/atomic>
+
+// Globally needed variables
+struct NRT_MemSys {
+    struct {
+      bool enabled;
+      cuda::atomic<size_t, cuda::thread_scope_device> alloc;
+      cuda::atomic<size_t, cuda::thread_scope_device> free;
+      cuda::atomic<size_t, cuda::thread_scope_device> mi_alloc;
+      cuda::atomic<size_t, cuda::thread_scope_device> mi_free;
+    } stats;
+  };
+
+/* The Memory System object */
+__device__ NRT_MemSys* TheMSys;
+
+extern "C" __global__ void NRT_MemSys_set(NRT_MemSys *memsys_ptr);

numba_cuda/numba/cuda/runtime/nrt.cu

@@ -3,6 +3,8 @@
 
 #include <cuda/atomic>
 
+#include "memsys.cuh"
+
 typedef void (*NRT_dtor_function)(void* ptr, size_t size, void* info);
 typedef void (*NRT_dealloc_func)(void* ptr, void* dealloc_info);
 
@@ -18,29 +20,21 @@ struct MemInfo {
 };
 }
 
-// Globally needed variables
-struct NRT_MemSys {
-  struct {
-    bool enabled;
-    cuda::atomic<size_t, cuda::thread_scope_device> alloc;
-    cuda::atomic<size_t, cuda::thread_scope_device> free;
-    cuda::atomic<size_t, cuda::thread_scope_device> mi_alloc;
-    cuda::atomic<size_t, cuda::thread_scope_device> mi_free;
-  } stats;
-};
+extern "C" __global__ void NRT_MemSys_set(NRT_MemSys *memsys_ptr)
+{
+  TheMSys = memsys_ptr;
+}
 
 static __device__ void *nrt_allocate_meminfo_and_data_align(size_t size, unsigned align, NRT_MemInfo **mi);
 static __device__ void *nrt_allocate_meminfo_and_data(size_t size, NRT_MemInfo **mi_out);
 extern "C" __device__ void* NRT_Allocate_External(size_t size);
 
-/* The Memory System object */
-__device__ NRT_MemSys* TheMSys;
-
 extern "C" __device__ void* NRT_Allocate(size_t size)
 {
   void* ptr = NULL;
   ptr       = malloc(size);
-//  if (TheMSys->stats.enabled) { TheMSys->stats.alloc++; }
+  if (TheMSys && TheMSys->stats.enabled) { 
+    TheMSys->stats.alloc.fetch_add(1, cuda::memory_order_relaxed); }
   return ptr;
 }
 
@@ -49,14 +43,14 @@ extern "C" __device__ void NRT_MemInfo_init(NRT_MemInfo* mi,
                                             size_t size,
                                             NRT_dtor_function dtor,
                                             void* dtor_info)
-//                                            NRT_MemSys* TheMSys)
 {
   mi->refct     = 1; /* starts with 1 refct */
   mi->dtor      = dtor;
   mi->dtor_info = dtor_info;
   mi->data      = data;
   mi->size      = size;
-//  if (TheMSys->stats.enabled) { TheMSys->stats.mi_alloc++; }
+ if (TheMSys && TheMSys->stats.enabled) { 
+  TheMSys->stats.mi_alloc.fetch_add(1, cuda::memory_order_relaxed); }
 }
 
 extern "C"
@@ -71,7 +65,8 @@ __device__ NRT_MemInfo* NRT_MemInfo_new(
 extern "C" __device__ void NRT_Free(void* ptr)
 {
   free(ptr);
-  //if (TheMSys->stats.enabled) { TheMSys->stats.free++; }
+  if (TheMSys && TheMSys->stats.enabled) {
+    TheMSys->stats.free.fetch_add(1, cuda::memory_order_relaxed); }
 }
 
 extern "C" __device__ void NRT_dealloc(NRT_MemInfo* mi)
@@ -82,8 +77,10 @@ extern "C" __device__ void NRT_dealloc(NRT_MemInfo* mi)
 extern "C" __device__ void NRT_MemInfo_destroy(NRT_MemInfo* mi)
 {
   NRT_dealloc(mi);
-  //if (TheMSys->stats.enabled) { TheMSys->stats.mi_free++; }
+  if (TheMSys && TheMSys->stats.enabled) { 
+    TheMSys->stats.mi_free.fetch_add(1, cuda::memory_order_relaxed); }
 }
+
 extern "C" __device__ void NRT_MemInfo_call_dtor(NRT_MemInfo* mi)
 {
   if (mi->dtor) /* We have a destructor */
@@ -158,10 +155,10 @@ extern "C" __device__ void* NRT_Allocate_External(size_t size) {
     ptr = malloc(size);
     //NRT_Debug(nrt_debug_print("NRT_Allocate_External bytes=%zu ptr=%p\n", size, ptr));
 
-    //if (TheMSys.stats.enabled)
-    //{
-    //    TheMSys.stats.alloc++;
-    //}
+    if (TheMSys && TheMSys->stats.enabled)
+    {
+       TheMSys->stats.alloc.fetch_add(1, cuda::memory_order_relaxed);
+    }
     return ptr;
 }
 

numba_cuda/numba/cuda/runtime/nrt.py

@@ -0,0 +1,318 @@
+import ctypes
+import os
+from functools import wraps
+import numpy as np
+
+from numba import cuda, config
+from numba.core.runtime.nrt import _nrt_mstats
+from numba.cuda.cudadrv.driver import Linker, driver, launch_kernel
+from numba.cuda.cudadrv import devices
+from numba.cuda.api import get_current_device
+from numba.cuda.utils import _readenv
+
+
+# Check environment variable or config for NRT statistics enablement
+NRT_STATS = (
+    _readenv("NUMBA_CUDA_NRT_STATS", bool, False) or
+    getattr(config, "NUMBA_CUDA_NRT_STATS", False)
+)
+if not hasattr(config, "NUMBA_CUDA_NRT_STATS"):
+    config.CUDA_NRT_STATS = NRT_STATS
+
+
+# Check environment variable or config for NRT enablement
+ENABLE_NRT = (
+    _readenv("NUMBA_CUDA_ENABLE_NRT", bool, False) or
+    getattr(config, "NUMBA_CUDA_ENABLE_NRT", False)
+)
+if not hasattr(config, "NUMBA_CUDA_ENABLE_NRT"):
+    config.CUDA_ENABLE_NRT = ENABLE_NRT
+
+
+# Protect method to ensure NRT memory allocation and initialization
+def _alloc_init_guard(method):
+    """
+    Ensure NRT memory allocation and initialization before running the method
+    """
+    @wraps(method)
+    def wrapper(self, *args, **kwargs):
+        self.ensure_allocated()
+        self.ensure_initialized()
+        return method(self, *args, **kwargs)
+    return wrapper
+
+
+class _Runtime:
+    """Singleton class for Numba CUDA runtime"""
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super(_Runtime, cls).__new__(cls, *args, **kwargs)
+        return cls._instance
+
+    def __init__(self):
+        """Initialize memsys module and variable"""
+        self._memsys_module = None
+        self._memsys = None
+        self._initialized = False
+
+    def _compile_memsys_module(self):
+        """
+        Compile memsys.cu and create a module from it in the current context
+        """
+        # Define the path for memsys.cu
+        memsys_mod = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)),
+            "memsys.cu"
+        )
+        cc = get_current_device().compute_capability
+
+        # Create a new linker instance and add the cu file
+        linker = Linker.new(cc=cc)
+        linker.add_cu_file(memsys_mod)
+
+        # Complete the linker and create a module from it
+        cubin = linker.complete()
+        ctx = devices.get_context()
+        module = ctx.create_module_image(cubin)
+
+        # Set the memsys module
+        self._memsys_module = module
+
+    def ensure_allocated(self, stream=None):
+        """
+        If memsys is not allocated, allocate it; otherwise, perform a no-op
+        """
+        if self._memsys is not None:
+            return
+
+        # Allocate the memsys
+        self.allocate(stream)
+
+    def allocate(self, stream=None):
+        """
+        Allocate memsys on global memory
+        """
+        from numba.cuda import device_array
+
+        # Check if memsys module is defined
+        if self._memsys_module is None:
+            # Compile the memsys module if not defined
+            self._compile_memsys_module()
+
+        # Allocate space for NRT_MemSys
+        ptr, nbytes = self._memsys_module.get_global_symbol("memsys_size")
+        memsys_size = ctypes.c_uint64()
+        driver.cuMemcpyDtoH(ctypes.addressof(memsys_size),
+                            ptr.device_ctypes_pointer, nbytes)
+        self._memsys = device_array(
+            (memsys_size.value,), dtype="i1", stream=stream)
+        self.set_memsys_to_module(self._memsys_module, stream=stream)
+
+    def _single_thread_launch(self, module, stream, name, params=()):
+        """
+        Launch the specified kernel with only 1 thread
+        """
+        if stream is None:
+            stream = cuda.default_stream()
+
+        func = module.get_function(name)
+        launch_kernel(
+            func.handle,
+            1, 1, 1,
+            1, 1, 1,
+            0,
+            stream.handle,
+            params,
+            cooperative=False
+        )
+
+    def ensure_initialized(self, stream=None):
+        """
+        If memsys is not initialized, initialize memsys
+        """
+        if self._initialized:
+            return
+
+        # Initialize the memsys
+        self.initialize(stream)
+
+    def initialize(self, stream=None):
+        """
+        Launch memsys initialization kernel
+        """
+        self.ensure_allocated()
+
+        self._single_thread_launch(
+            self._memsys_module, stream, "NRT_MemSys_init")
+        self._initialized = True
+
+        if config.CUDA_NRT_STATS:
+            self.memsys_enable_stats()
+
+    @_alloc_init_guard
+    def memsys_enable_stats(self, stream=None):
+        """
+        Enable memsys statistics
+        """
+        self._single_thread_launch(
+            self._memsys_module, stream, "NRT_MemSys_enable_stats")
+
+    @_alloc_init_guard
+    def memsys_disable_stats(self, stream=None):
+        """
+        Disable memsys statistics
+        """
+        self._single_thread_launch(
+            self._memsys_module, stream, "NRT_MemSys_disable_stats")
+
+    @_alloc_init_guard
+    def memsys_stats_enabled(self, stream=None):
+        """
+        Return a boolean indicating whether memsys is enabled. Synchronizes
+        context
+        """
+        enabled_ar = cuda.managed_array(1, np.uint8)
+
+        self._single_thread_launch(
+            self._memsys_module,
+            stream,
+            "NRT_MemSys_stats_enabled",
+            (enabled_ar.device_ctypes_pointer,)
+        )
+
+        cuda.synchronize()
+        return bool(enabled_ar[0])
+
+    @_alloc_init_guard
+    def _copy_memsys_to_host(self, stream):
+        """
+        Copy all statistics of memsys to the host
+        """
+        dt = np.dtype([
+            ('alloc', np.uint64),
+            ('free', np.uint64),
+            ('mi_alloc', np.uint64),
+            ('mi_free', np.uint64)
+        ])
+
+        stats_for_read = cuda.managed_array(1, dt)
+
+        self._single_thread_launch(
+            self._memsys_module,
+            stream,
+            "NRT_MemSys_read",
+            [stats_for_read.device_ctypes_pointer]
+        )
+        cuda.synchronize()
+
+        return stats_for_read[0]
+
+    @_alloc_init_guard
+    def get_allocation_stats(self, stream=None):
+        """
+        Get the allocation statistics
+        """
+        enabled = self.memsys_stats_enabled(stream)
+        if not enabled:
+            raise RuntimeError("NRT stats are disabled.")
+        memsys = self._copy_memsys_to_host(stream)
+        return _nrt_mstats(
+            alloc=memsys["alloc"],
+            free=memsys["free"],
+            mi_alloc=memsys["mi_alloc"],
+            mi_free=memsys["mi_free"]
+        )
+
+    @_alloc_init_guard
+    def _get_single_stat(self, stat, stream=None):
+        """
+        Get a single stat from the memsys
+        """
+        got = cuda.managed_array(1, np.uint64)
+        self._single_thread_launch(
+            self._memsys_module,
+            stream,
+            f"NRT_MemSys_read_{stat}",
+            [got.device_ctypes_pointer]
+        )
+
+        cuda.synchronize()
+        return got[0]
+
+    @_alloc_init_guard
+    def memsys_get_stats_alloc(self, stream=None):
+        """
+        Get the allocation statistic
+        """
+        enabled = self.memsys_stats_enabled(stream)
+        if not enabled:
+            raise RuntimeError("NRT stats are disabled.")
+
+        return self._get_single_stat("alloc")
+
+    @_alloc_init_guard
+    def memsys_get_stats_free(self, stream=None):
+        """
+        Get the free statistic
+        """
+        enabled = self.memsys_stats_enabled(stream)
+        if not enabled:
+            raise RuntimeError("NRT stats are disabled.")
+
+        return self._get_single_stat("free")
+
+    @_alloc_init_guard
+    def memsys_get_stats_mi_alloc(self, stream=None):
+        """
+        Get the mi alloc statistic
+        """
+        enabled = self.memsys_stats_enabled(stream)
+        if not enabled:
+            raise RuntimeError("NRT stats are disabled.")
+
+        return self._get_single_stat("mi_alloc")
+
+    @_alloc_init_guard
+    def memsys_get_stats_mi_free(self, stream=None):
+        """
+        Get the mi free statistic
+        """
+        enabled = self.memsys_stats_enabled(stream)
+        if not enabled:
+            raise RuntimeError("NRT stats are disabled.")
+
+        return self._get_single_stat("mi_free")
+
+    def set_memsys_to_module(self, module, stream=None):
+        """
+        Set the memsys module. The module must contain `NRT_MemSys_set` kernel,
+        and declare a pointer to NRT_MemSys structure.
+        """
+        if self._memsys is None:
+            raise RuntimeError(
+                "Please allocate NRT Memsys first before setting to module.")
+
+        self._single_thread_launch(
+            module,
+            stream,
+            "NRT_MemSys_set",
+            [self._memsys.device_ctypes_pointer,]
+        )
+
+    @_alloc_init_guard
+    def print_memsys(self, stream=None):
+        """
+        Print the current statistics of memsys, for debugging purposes
+        """
+        cuda.synchronize()
+        self._single_thread_launch(
+            self._memsys_module,
+            stream,
+            "NRT_MemSys_print"
+        )
+
+
+# Create an instance of the runtime
+rtsys = _Runtime()

numba_cuda/numba/cuda/tests/__init__.py

@@ -49,6 +49,7 @@ def load_tests(loader, tests, pattern):
         if gpus and gpus[0].compute_capability >= (2, 0):
             suite.addTests(load_testsuite(loader, join(this_dir, 'cudadrv')))
             suite.addTests(load_testsuite(loader, join(this_dir, 'cudapy')))
+            suite.addTests(load_testsuite(loader, join(this_dir, 'nrt')))
             suite.addTests(load_testsuite(loader, join(this_dir,
                                                        'doc_examples')))
         else:

numba_cuda/numba/cuda/tests/cudadrv/test_cuda_ndarray.py

@@ -4,6 +4,7 @@ from numba.cuda.cudadrv import devicearray
 from numba import cuda
 from numba.cuda.testing import unittest, CUDATestCase
 from numba.cuda.testing import skip_on_cudasim
+from numba.tests.support import IS_NUMPY_2
 
 
 class TestCudaNDArray(CUDATestCase):
@@ -456,6 +457,36 @@ class TestCudaNDArray(CUDATestCase):
         dev_array_from_host.copy_to_device(dev_array)
 
 
+class TestArrayMethod(CUDATestCase):
+    """Tests of the __array__() method via np.array"""
+
+    def test_np_array(self):
+        dev_array = cuda.to_device(np.asarray([1.0, 2.0, 3.0]))
+        host_array = np.array(dev_array)
+        np.testing.assert_equal(dev_array.copy_to_host(), host_array)
+
+    def test_np_array_dtype(self):
+        dtype = np.int32
+        dev_array = cuda.to_device(np.asarray([1.0, 2.0, 3.0]))
+        host_array = np.array(dev_array, dtype=dtype)
+        np.testing.assert_equal(
+            host_array,
+            dev_array.copy_to_host().astype(dtype)
+        )
+
+    @unittest.skipUnless(IS_NUMPY_2, "NumPy 1.x does not pass copy kwarg")
+    def test_np_array_copy_false(self):
+        dev_array = cuda.to_device(np.asarray([1.0, 2.0, 3.0]))
+        with self.assertRaisesRegex(ValueError, "`copy=False` is not"):
+            np.array(dev_array, copy=False)
+
+    @unittest.skipUnless(IS_NUMPY_2, "NumPy 1.x does not pass copy kwarg")
+    def test_np_array_copy_true(self):
+        dev_array = cuda.to_device(np.asarray([1.0, 2.0, 3.0]))
+        host_array = np.array(dev_array)
+        np.testing.assert_equal(dev_array.copy_to_host(), host_array)
+
+
 class TestRecarray(CUDATestCase):
     def test_recarray(self):
         # From issue #4111

numba_cuda/numba/cuda/tests/nrt/mock_numpy.py

@@ -1,8 +1,12 @@
+import math
+
+import numpy as np
 
 from numba.core import errors, types
 from numba.core.extending import overload
 from numba.np.arrayobj import (_check_const_str_dtype, is_nonelike,
-                               ty_parse_dtype, ty_parse_shape, numpy_empty_nd)
+                               ty_parse_dtype, ty_parse_shape, numpy_empty_nd,
+                               numpy_empty_like_nd)
 
 
 # Typical tests for allocation use array construction (e.g. np.zeros, np.empty,
@@ -20,6 +24,18 @@ def cuda_empty(shape, dtype):
     pass
 
 
+def cuda_empty_like(arr):
+    pass
+
+
+def cuda_arange(start):
+    pass
+
+
+def cuda_ones(shape):
+    pass
+
+
 @overload(cuda_empty)
 def ol_cuda_empty(shape, dtype):
     _check_const_str_dtype("empty", dtype)
@@ -40,3 +56,91 @@ def ol_cuda_empty(shape, dtype):
     else:
         msg = f"Cannot parse input types to function np.empty({shape}, {dtype})"
         raise errors.TypingError(msg)
+
+
+@overload(cuda_empty_like)
+def ol_cuda_empty_like(arr):
+
+    if isinstance(arr, types.Array):
+        nb_dtype = arr.dtype
+    else:
+        nb_dtype = arr
+
+    if isinstance(arr, types.Array):
+        layout = arr.layout if arr.layout != 'A' else 'C'
+        retty = arr.copy(dtype=nb_dtype, layout=layout, readonly=False)
+    else:
+        retty = types.Array(nb_dtype, 0, 'C')
+
+    def impl(arr):
+        dtype = None
+        return numpy_empty_like_nd(arr, dtype, retty)
+    return impl
+
+
+def _arange_dtype(*args):
+    bounds = [a for a in args if not isinstance(a, types.NoneType)]
+
+    if any(isinstance(a, types.Complex) for a in bounds):
+        dtype = types.complex128
+    elif any(isinstance(a, types.Float) for a in bounds):
+        dtype = types.float64
+    else:
+        # `np.arange(10).dtype` is always `np.dtype(int)`, aka `np.int_`, which
+        # in all released versions of numpy corresponds to the C `long` type.
+        # Windows 64 is broken by default here because Numba (as of 0.47) does
+        # not differentiate between Python and NumPy integers, so a `typeof(1)`
+        # on w64 is `int64`, i.e. `intp`. This means an arange(<some int>) will
+        # be typed as arange(int64) and the following will yield int64 opposed
+        # to int32. Example: without a load of analysis to work out of the args
+        # were wrapped in NumPy int*() calls it's not possible to detect the
+        # difference between `np.arange(10)` and `np.arange(np.int64(10)`.
+        NPY_TY = getattr(types, "int%s" % (8 * np.dtype(int).itemsize))
+
+        # unliteral these types such that `max` works.
+        unliteral_bounds = [types.unliteral(x) for x in bounds]
+        dtype = max(unliteral_bounds + [NPY_TY,])
+
+    return dtype
+
+
+@overload(cuda_arange)
+def ol_cuda_arange(start):
+    """Simplified arange with just 1 argument."""
+    if (not isinstance(start, types.Number)):
+        return
+
+    start_value = getattr(start, "literal_value", None)
+
+    def impl(start):
+        # Allow for improved performance if given literal arguments.
+        lit_start = start_value if start_value is not None else start
+
+        _step = 1
+        _start, _stop = 0, lit_start
+
+        nitems_c = (_stop - _start) / _step
+        nitems_r = int(math.ceil(nitems_c.real))
+
+        # Binary operator needed for compiler branch pruning.
+        nitems = max(nitems_r, 0)
+
+        arr = cuda_empty(nitems, np.int64)
+        val = _start
+        for i in range(nitems):
+            arr[i] = val + (i * _step)
+        return arr
+
+    return impl
+
+
+@overload(cuda_ones)
+def ol_cuda_ones(shape):
+
+    def impl(shape):
+        arr = cuda_empty(shape, np.float64)
+        arr_flat = arr.flat
+        for idx in range(len(arr_flat)):
+            arr_flat[idx] = 1
+        return arr
+    return impl

numba_cuda/numba/cuda/tests/nrt/test_nrt.py

@@ -1,47 +1,22 @@
 import re
-import gc
+import os
+
 import numpy as np
 import unittest
-from unittest.mock import patch
-from numba.core.runtime import rtsys
-from numba.tests.support import EnableNRTStatsMixin
 from numba.cuda.testing import CUDATestCase
 
-from .mock_numpy import cuda_empty
+from numba.cuda.tests.nrt.mock_numpy import cuda_empty, cuda_ones, cuda_arange
+from numba.tests.support import run_in_subprocess, override_config
 
 from numba import cuda
-
-
-class TestNrtRefCt(EnableNRTStatsMixin, CUDATestCase):
-
-    def setUp(self):
-        # Clean up any NRT-backed objects hanging in a dead reference cycle
-        gc.collect()
-        super(TestNrtRefCt, self).setUp()
-
-    @unittest.expectedFailure
-    def test_no_return(self):
-        """
-        Test issue #1291
-        """
-        n = 10
-
-        @cuda.jit
-        def kernel():
-            for i in range(n):
-                temp = cuda_empty(2, np.float64) # noqa: F841
-            return None
-
-        init_stats = rtsys.get_allocation_stats()
-
-        with patch('numba.config.CUDA_ENABLE_NRT', True, create=True):
-            kernel[1,1]()
-        cur_stats = rtsys.get_allocation_stats()
-        self.assertEqual(cur_stats.alloc - init_stats.alloc, n)
-        self.assertEqual(cur_stats.free - init_stats.free, n)
+from numba.cuda.runtime.nrt import rtsys
 
 
 class TestNrtBasic(CUDATestCase):
+    def run(self, result=None):
+        with override_config("CUDA_ENABLE_NRT", True):
+            super(TestNrtBasic, self).run(result)
+
     def test_nrt_launches(self):
         @cuda.jit
         def f(x):
@@ -52,8 +27,7 @@ class TestNrtBasic(CUDATestCase):
             x = cuda_empty(10, np.int64)
             f(x)
 
-        with patch('numba.config.CUDA_ENABLE_NRT', True, create=True):
-            g[1,1]()
+        g[1,1]()
         cuda.synchronize()
 
     def test_nrt_ptx_contains_refcount(self):
@@ -66,8 +40,7 @@ class TestNrtBasic(CUDATestCase):
             x = cuda_empty(10, np.int64)
             f(x)
 
-        with patch('numba.config.CUDA_ENABLE_NRT', True, create=True):
-            g[1,1]()
+        g[1,1]()
 
         ptx = next(iter(g.inspect_asm().values()))
 
@@ -100,11 +73,160 @@ class TestNrtBasic(CUDATestCase):
 
         out_ary = np.zeros(1, dtype=np.int64)
 
-        with patch('numba.config.CUDA_ENABLE_NRT', True, create=True):
-            g[1,1](out_ary)
+        g[1,1](out_ary)
 
         self.assertEqual(out_ary[0], 1)
 
 
+class TestNrtStatistics(CUDATestCase):
+
+    def setUp(self):
+        self._stream = cuda.default_stream()
+        # Store the current stats state
+        self.__stats_state = rtsys.memsys_stats_enabled(self._stream)
+
+    def tearDown(self):
+        # Set stats state back to whatever it was before the test ran
+        if self.__stats_state:
+            rtsys.memsys_enable_stats(self._stream)
+        else:
+            rtsys.memsys_disable_stats(self._stream)
+
+    def test_stats_env_var_explicit_on(self):
+        # Checks that explicitly turning the stats on via the env var works.
+        src = """if 1:
+        from numba import cuda
+        from numba.cuda.runtime import rtsys
+        from numba.cuda.tests.nrt.mock_numpy import cuda_arange
+
+        @cuda.jit
+        def foo():
+            x = cuda_arange(10)[0]
+
+        # initialize the NRT before use
+        rtsys.initialize()
+        assert rtsys.memsys_stats_enabled(), "Stats not enabled"
+        orig_stats = rtsys.get_allocation_stats()
+        foo[1, 1]()
+        new_stats = rtsys.get_allocation_stats()
+        total_alloc = new_stats.alloc - orig_stats.alloc
+        total_free = new_stats.free - orig_stats.free
+        total_mi_alloc = new_stats.mi_alloc - orig_stats.mi_alloc
+        total_mi_free = new_stats.mi_free - orig_stats.mi_free
+
+        expected = 1
+        assert total_alloc == expected, \\
+            f"total_alloc != expected, {total_alloc} != {expected}"
+        assert total_free == expected, \\
+            f"total_free != expected, {total_free} != {expected}"
+        assert total_mi_alloc == expected, \\
+            f"total_mi_alloc != expected, {total_mi_alloc} != {expected}"
+        assert total_mi_free == expected, \\
+            f"total_mi_free != expected, {total_mi_free} != {expected}"
+        """
+
+        # Check env var explicitly being set works
+        env = os.environ.copy()
+        env['NUMBA_CUDA_NRT_STATS'] = "1"
+        env['NUMBA_CUDA_ENABLE_NRT'] = "1"
+        run_in_subprocess(src, env=env)
+
+    def check_env_var_off(self, env):
+
+        src = """if 1:
+        from numba import cuda
+        import numpy as np
+        from numba.cuda.runtime import rtsys
+
+        @cuda.jit
+        def foo():
+            arr = np.arange(10)[0]
+
+        assert rtsys.memsys_stats_enabled() == False
+        try:
+            rtsys.get_allocation_stats()
+        except RuntimeError as e:
+            assert "NRT stats are disabled." in str(e)
+        """
+        run_in_subprocess(src, env=env)
+
+    def test_stats_env_var_explicit_off(self):
+        # Checks that explicitly turning the stats off via the env var works.
+        env = os.environ.copy()
+        env['NUMBA_CUDA_NRT_STATS'] = "0"
+        self.check_env_var_off(env)
+
+    def test_stats_env_var_default_off(self):
+        # Checks that the env var not being set is the same as "off", i.e.
+        # default for Numba is off.
+        env = os.environ.copy()
+        env.pop('NUMBA_CUDA_NRT_STATS', None)
+        self.check_env_var_off(env)
+
+    def test_stats_status_toggle(self):
+
+        @cuda.jit
+        def foo():
+            tmp = cuda_ones(3)
+            arr = cuda_arange(5 * tmp[0]) # noqa: F841
+            return None
+
+        with override_config('CUDA_ENABLE_NRT', True):
+            # Switch on stats
+            rtsys.memsys_enable_stats()
+            # check the stats are on
+            self.assertTrue(rtsys.memsys_stats_enabled())
+
+            for i in range(2):
+                # capture the stats state
+                stats_1 = rtsys.get_allocation_stats()
+                # Switch off stats
+                rtsys.memsys_disable_stats()
+                # check the stats are off
+                self.assertFalse(rtsys.memsys_stats_enabled())
+                # run something that would move the counters were they enabled
+                foo[1, 1]()
+                # Switch on stats
+                rtsys.memsys_enable_stats()
+                # check the stats are on
+                self.assertTrue(rtsys.memsys_stats_enabled())
+                # capture the stats state (should not have changed)
+                stats_2 = rtsys.get_allocation_stats()
+                # run something that will move the counters
+                foo[1, 1]()
+                # capture the stats state (should have changed)
+                stats_3 = rtsys.get_allocation_stats()
+                # check stats_1 == stats_2
+                self.assertEqual(stats_1, stats_2)
+                # check stats_2 < stats_3
+                self.assertLess(stats_2, stats_3)
+
+    def test_rtsys_stats_query_raises_exception_when_disabled(self):
+        # Checks that the standard rtsys.get_allocation_stats() query raises
+        # when stats counters are turned off.
+
+        rtsys.memsys_disable_stats()
+        self.assertFalse(rtsys.memsys_stats_enabled())
+
+        with self.assertRaises(RuntimeError) as raises:
+            rtsys.get_allocation_stats()
+
+        self.assertIn("NRT stats are disabled.", str(raises.exception))
+
+    def test_nrt_explicit_stats_query_raises_exception_when_disabled(self):
+        # Checks the various memsys_get_stats functions raise if queried when
+        # the stats counters are disabled.
+        method_variations = ('alloc', 'free', 'mi_alloc', 'mi_free')
+        for meth in method_variations:
+            stats_func = getattr(rtsys, f'memsys_get_stats_{meth}')
+            with self.subTest(stats_func=stats_func):
+                # Turn stats off
+                rtsys.memsys_disable_stats()
+                self.assertFalse(rtsys.memsys_stats_enabled())
+                with self.assertRaises(RuntimeError) as raises:
+                    stats_func()
+                self.assertIn("NRT stats are disabled.", str(raises.exception))
+
+
 if __name__ == '__main__':
     unittest.main()

numba_cuda/numba/cuda/tests/nrt/test_nrt_refct.py

@@ -0,0 +1,114 @@
+import numpy as np
+import unittest
+from numba.tests.support import override_config
+from numba.cuda.runtime import rtsys
+from numba.cuda.tests.support import EnableNRTStatsMixin
+from numba.cuda.testing import CUDATestCase
+from numba.cuda.tests.nrt.mock_numpy import cuda_empty, cuda_empty_like
+
+from numba import cuda
+
+
+class TestNrtRefCt(EnableNRTStatsMixin, CUDATestCase):
+
+    def setUp(self):
+        super(TestNrtRefCt, self).setUp()
+
+    def tearDown(self):
+        super(TestNrtRefCt, self).tearDown()
+
+    def run(self, result=None):
+        with override_config("CUDA_ENABLE_NRT", True):
+            super(TestNrtRefCt, self).run(result)
+
+    def test_no_return(self):
+        """
+        Test issue #1291
+        """
+
+        n = 10
+
+        @cuda.jit
+        def kernel():
+            for i in range(n):
+                temp = cuda_empty(2, np.float64) # noqa: F841
+            return None
+
+        init_stats = rtsys.get_allocation_stats()
+        kernel[1, 1]()
+        cur_stats = rtsys.get_allocation_stats()
+        self.assertEqual(cur_stats.alloc - init_stats.alloc, n)
+        self.assertEqual(cur_stats.free - init_stats.free, n)
+
+    def test_escaping_var_init_in_loop(self):
+        """
+        Test issue #1297
+        """
+
+        @cuda.jit
+        def g(n):
+
+            x = cuda_empty((n, 2), np.float64)
+
+            for i in range(n):
+                y = x[i]
+
+            for i in range(n):
+                y = x[i] # noqa: F841
+
+            return None
+
+        init_stats = rtsys.get_allocation_stats()
+        g[1, 1](10)
+        cur_stats = rtsys.get_allocation_stats()
+        self.assertEqual(cur_stats.alloc - init_stats.alloc, 1)
+        self.assertEqual(cur_stats.free - init_stats.free, 1)
+
+    def test_invalid_computation_of_lifetime(self):
+        """
+        Test issue #1573
+        """
+        @cuda.jit
+        def if_with_allocation_and_initialization(arr1, test1):
+            tmp_arr = cuda_empty_like(arr1)
+
+            for i in range(tmp_arr.shape[0]):
+                pass
+
+            if test1:
+                cuda_empty_like(arr1)
+
+        arr = np.random.random((5, 5))  # the values are not consumed
+
+        init_stats = rtsys.get_allocation_stats()
+        if_with_allocation_and_initialization[1, 1](arr, False)
+        cur_stats = rtsys.get_allocation_stats()
+        self.assertEqual(cur_stats.alloc - init_stats.alloc,
+                         cur_stats.free - init_stats.free)
+
+    def test_del_at_beginning_of_loop(self):
+        """
+        Test issue #1734
+        """
+        @cuda.jit
+        def f(arr):
+            res = 0
+
+            for i in (0, 1):
+                # `del t` is issued here before defining t.  It must be
+                # correctly handled by the lowering phase.
+                t = arr[i]
+                if t[i] > 1:
+                    res += t[i]
+
+        arr = np.ones((2, 2))
+
+        init_stats = rtsys.get_allocation_stats()
+        f[1, 1](arr)
+        cur_stats = rtsys.get_allocation_stats()
+        self.assertEqual(cur_stats.alloc - init_stats.alloc,
+                         cur_stats.free - init_stats.free)
+
+
+if __name__ == '__main__':
+    unittest.main()

numba_cuda/numba/cuda/tests/support.py

@@ -0,0 +1,11 @@
+from numba.cuda.runtime.nrt import rtsys
+
+
+class EnableNRTStatsMixin(object):
+    """Mixin to enable the NRT statistics counters."""
+
+    def setUp(self):
+        rtsys.memsys_enable_stats()
+
+    def tearDown(self):
+        rtsys.memsys_disable_stats()

numba_cuda/numba/cuda/utils.py

@@ -0,0 +1,22 @@
+import os
+import warnings
+import traceback
+
+
+def _readenv(name, ctor, default):
+    value = os.environ.get(name)
+    if value is None:
+        return default() if callable(default) else default
+    try:
+        if ctor is bool:
+            return value.lower() in {'1', "true"}
+        return ctor(value)
+    except Exception:
+        warnings.warn(
+            f"Environment variable '{name}' is defined but its associated "
+            f"value '{value}' could not be parsed.\n"
+            "The parse failed with exception:\n"
+            f"{traceback.format_exc()}",
+            RuntimeWarning
+        )
+        return default

{numba_cuda-0.3.0.dist-info → numba_cuda-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: numba-cuda
-Version: 0.3.0
+Version: 0.4.0
 Summary: CUDA target for Numba
 Author: Anaconda Inc., NVIDIA Corporation
 License: BSD 2-clause

{numba_cuda-0.3.0.dist-info → numba_cuda-0.4.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 _numba_cuda_redirector.pth,sha256=cmfMMmV0JPh3yEpl4bGeM9AuXiVVMSo6Z_b7RaQL3XE,30
 _numba_cuda_redirector.py,sha256=QKJmYICSQvjvph0Zw9OW015MsuKxIF28GPFjR35AXLM,2681
-numba_cuda/VERSION,sha256=2RXMldbKj0euKXcT7UbU5cXZnd0p_Dxh4mO98wXytbA,6
+numba_cuda/VERSION,sha256=QLjrQACpE6d5EJBTXykdPTaYdBYqie88nj1OiHobnnk,6
 numba_cuda/__init__.py,sha256=atXeUvJKR3JHcAiCFbXCVOJQUHgB1TulmsqSL_9RT3Q,114
 numba_cuda/_version.py,sha256=jbdUsbR7sVllw0KxQNB0-FMd929CGg3kH2fhHdrlkuc,719
 numba_cuda/numba/cuda/__init__.py,sha256=idyVHOObC9lTYnp62v7rVprSacRM4d5F6vhXfG5ElTI,621
@@ -21,7 +21,7 @@ numba_cuda/numba/cuda/decorators.py,sha256=qSpir16-jPYSe2YuRZ6g9INeobmsMNg6ab9IZ
 numba_cuda/numba/cuda/descriptor.py,sha256=rNMaurJkjNjIBmHPozDoLC35DMURE0fn_LtnXRmaG_w,985
 numba_cuda/numba/cuda/device_init.py,sha256=lP79tCsQ0Np9xcbjv_lXcH4JOiVZvV8nwg3INdETxsc,3586
 numba_cuda/numba/cuda/deviceufunc.py,sha256=yxAH71dpgJWK8okmCJm0FUV6z2AqdThCYOTZspT7z0M,30775
-numba_cuda/numba/cuda/dispatcher.py,sha256=Q8WN7jTAX3xy_D2sEgSeFHAivqavI2PRlfDjR7ysing,42073
+numba_cuda/numba/cuda/dispatcher.py,sha256=cJH7Jm-U26PyU-M2Igevar_Q_c_k9R-A99InnRGPzX0,42444
 numba_cuda/numba/cuda/errors.py,sha256=XwWHzCllx0DXU6BQdoRH0m3pznGxnTFOBTVYXMmCfqg,1724
 numba_cuda/numba/cuda/extending.py,sha256=URsyBYls2te-mgE0yvDY6akvawYCA0blBFfD7Lf9DO4,142
 numba_cuda/numba/cuda/initialize.py,sha256=TQGHGLQoq4ch4J6CLDcJdGsZzXM-g2kDgdyO1u-Rbhg,546
@@ -43,12 +43,13 @@ numba_cuda/numba/cuda/target.py,sha256=hBflzmxCGlmTugWT1sYhZj9f4HkQAMK2RQ9lO85pM
 numba_cuda/numba/cuda/testing.py,sha256=E0wP2vfno1yWsl0v1zg31kpbU8FrKxTF-5y9Iv4WjA4,6412
 numba_cuda/numba/cuda/types.py,sha256=WVfjcly_VUpG9FfKueiEPzZm2NV8Hg0XAFg3bNzPdVc,1314
 numba_cuda/numba/cuda/ufuncs.py,sha256=txw27IxG80W1Yo7e-XwL2AMcQo0fMnxMjBIMy-n5pCo,23317
+numba_cuda/numba/cuda/utils.py,sha256=JId22EI3KkQosW6Dafdaw43qU0xXXO_4JOENLap8klU,630
 numba_cuda/numba/cuda/vector_types.py,sha256=s18dY0IUpT-RcaBvQsa_zEbYuuL2IT0Vh6afCeccwmQ,6750
 numba_cuda/numba/cuda/vectorizers.py,sha256=u_0EzaD5tqVH8uOz4Gmqn3FgPC1rckwDAQuROm0BXm8,8915
 numba_cuda/numba/cuda/cudadrv/__init__.py,sha256=0TL4MZcJXUoo9qA7uu0vLv7eHrXRerVmyfi7O149ITw,199
-numba_cuda/numba/cuda/cudadrv/devicearray.py,sha256=06kM7iFcx1TYiFhs1o9r1kyoA3k5yS7mFAdZDf6nrxA,31215
+numba_cuda/numba/cuda/cudadrv/devicearray.py,sha256=jsfr4LL12HWJzU3HUgzXpkk38Z-pyFyzLuGArg2G-nU,31363
 numba_cuda/numba/cuda/cudadrv/devices.py,sha256=6SneNmoq83gue0txFWWx4A65vViAa8xA06FzkApoqAk,7992
-numba_cuda/numba/cuda/cudadrv/driver.py,sha256=FONYaUzgexmPUIMsSq0zr_FgD9eLbWT8m1APEVrLJRo,114887
+numba_cuda/numba/cuda/cudadrv/driver.py,sha256=1F-Ugsf1bdZgK-So_q_TkJckdoczlzhBrCEJn8KYxG0,114321
 numba_cuda/numba/cuda/cudadrv/drvapi.py,sha256=52ms3X6hfPaQB8E1jb6g7QKqRvHzBMlDQ-V2DM1rXxQ,17178
 numba_cuda/numba/cuda/cudadrv/dummyarray.py,sha256=nXRngdr-k3h_BNGQuJUxmp89yGNWxqEDJedpwDPEZ44,14209
 numba_cuda/numba/cuda/cudadrv/enums.py,sha256=Wy5dzukTk4TnWCowg_PLceET_v2xEyiWLu9TyH8pXr8,23742
@@ -57,14 +58,18 @@ numba_cuda/numba/cuda/cudadrv/libs.py,sha256=Gk9zQ1CKcsZsWl-_9QneXeP9VH5q5R1I3Cx
 numba_cuda/numba/cuda/cudadrv/linkable_code.py,sha256=Q_YTv0apBo9t8pkMlKrthPPSVeLd376ZTmVDF5NtVVo,1328
 numba_cuda/numba/cuda/cudadrv/mappings.py,sha256=-dTPHvAkDjdH6vS5OjgrB71AFuqKO6CRgf7hpOk2wiw,802
 numba_cuda/numba/cuda/cudadrv/ndarray.py,sha256=HtULWWFyDlgqvrH5459yyPTvU4UbUo2DSdtcNfvbH00,473
-numba_cuda/numba/cuda/cudadrv/nvrtc.py,sha256=RR096Ic2_Zu96C-GGh8x8WTOyxnmDkwtcwag8a_npkQ,10898
+numba_cuda/numba/cuda/cudadrv/nvrtc.py,sha256=XM9_Vllv7HzH5wZIR2lwFictyX68XDtNbyLkXlL6NTI,11003
 numba_cuda/numba/cuda/cudadrv/nvvm.py,sha256=v2hJJTAQeRmoG59-hnhgMEp5BSVA73QHtEoy636VKao,24107
 numba_cuda/numba/cuda/cudadrv/rtapi.py,sha256=WdeUoWzsYNYodx8kMRLVIjnNs0QzwpCihd2Q0AaqItE,226
 numba_cuda/numba/cuda/cudadrv/runtime.py,sha256=Tj9ACrzQqNmDSO6xfpzw12EsQknSywQ-ZGuWMbDdHnQ,4255
 numba_cuda/numba/cuda/kernels/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 numba_cuda/numba/cuda/kernels/reduction.py,sha256=fQnaWtoNB2yp143MNbE1DujqFIYy0KV_2moQVvbaROU,9362
 numba_cuda/numba/cuda/kernels/transpose.py,sha256=5FSu-nbTfhintxwfU-bjT2px2otQF5QkKH-JPDDWq_k,2061
-numba_cuda/numba/cuda/runtime/nrt.cu,sha256=i8Xcf-x84n3uNPzs_xak4c_sLHOH91ast2aE6DKKf9Q,5497
+numba_cuda/numba/cuda/runtime/__init__.py,sha256=rDi_pA5HnwpuwT8wwy0hparfO7HWgfjLVj9htbk_tCg,54
+numba_cuda/numba/cuda/runtime/memsys.cu,sha256=5nTXrstrUBVLeLvnDUReyhRGvVILK--VdM1u3oUCa2o,2386
+numba_cuda/numba/cuda/runtime/memsys.cuh,sha256=4oDvs7LvcMmdkN58b8e0nBqPka_sdagoULSKRut74DY,503
+numba_cuda/numba/cuda/runtime/nrt.cu,sha256=WB7jQxT1bLdkY6Tm7-_ytVLjJxK4iU0OFifbPIpLwvw,5403
+numba_cuda/numba/cuda/runtime/nrt.py,sha256=pmacryGZn25IHjdRMwT2vZipdtu0xsjpPDic_hlRxkA,9195
 numba_cuda/numba/cuda/simulator/__init__.py,sha256=crW0VQ_8e7DMRSHKoAIziZ37ea5mpbh_49tR9M3d5YY,1610
 numba_cuda/numba/cuda/simulator/api.py,sha256=K_fX-w9X4grGx2IAp0XlBW9rth5l7wibMwinQvkE7Jc,3237
 numba_cuda/numba/cuda/simulator/compiler.py,sha256=eXnvmzSKzIZZzBz6ZFJ-vMNyRAgqbCiB-AO5IJXuUyM,232
@@ -82,7 +87,8 @@ numba_cuda/numba/cuda/simulator/cudadrv/error.py,sha256=ACSQ7ZvhuCHnvV4GmvRuKWZ5
 numba_cuda/numba/cuda/simulator/cudadrv/libs.py,sha256=ry5rerpZrnAy70LU_YBa1KNaqKBGLHE9cMxljdSzaik,101
 numba_cuda/numba/cuda/simulator/cudadrv/nvvm.py,sha256=vIFQi4ewYXyzUYssfw78QLfoZmoVgloFCLTk55Gg1tw,474
 numba_cuda/numba/cuda/simulator/cudadrv/runtime.py,sha256=K63p7puZJZD3BQ6ZT0qoII_Z3xJiUckp2dhozFjrnEs,358
-numba_cuda/numba/cuda/tests/__init__.py,sha256=5Kh5-TtG6wclbWd_wDRIvtQG4O4McmqMpyNihl2nORM,2347
+numba_cuda/numba/cuda/tests/__init__.py,sha256=4U2RJuURN6SazAUSEtVofVEtahN3dDfUYNyDCmu64zo,2421
+numba_cuda/numba/cuda/tests/support.py,sha256=1og4VLrK2x2LF5m5ARrrHVe-JhYx9Gv9ODKt6-8r6Aw,253
 numba_cuda/numba/cuda/tests/cudadrv/__init__.py,sha256=43EXdiXXRBd6yIcVGMrU9F_EJCD9Uw3mzOP3SB53AEE,260
 numba_cuda/numba/cuda/tests/cudadrv/test_array_attr.py,sha256=cjHQ0J6F8APrLm23ZCFr0S7dtQmLqwq9vxMoI5lyn68,5300
 numba_cuda/numba/cuda/tests/cudadrv/test_context_stack.py,sha256=lSEuEM7x-x95m_lS_wSIBKnBxOhzn-AJ3WjYw8bW0y4,4492
@@ -92,7 +98,7 @@ numba_cuda/numba/cuda/tests/cudadrv/test_cuda_devicerecord.py,sha256=rikIJQ266l_
 numba_cuda/numba/cuda/tests/cudadrv/test_cuda_driver.py,sha256=y--0AZFVpp2nmbeI1jbgZsWbBP-iVEmG8WKgR9XrxKE,7663
 numba_cuda/numba/cuda/tests/cudadrv/test_cuda_libraries.py,sha256=sqNbo8pk4Zl5ptuGXrXFndia4IyttbuGnqjVTOtGuuw,801
 numba_cuda/numba/cuda/tests/cudadrv/test_cuda_memory.py,sha256=MDJMIWm1jCsBOcuwdshzqwaE__uqX0562uSjxFhud3M,6627
-numba_cuda/numba/cuda/tests/cudadrv/test_cuda_ndarray.py,sha256=67dmVO6v5gzp89pgb4wpxqDrWAx1UjX4vhdDQH4mebQ,20403
+numba_cuda/numba/cuda/tests/cudadrv/test_cuda_ndarray.py,sha256=eWczfXXIHS0p9eNhVagzXa4XWPwmrCb_yIBuDtjgq8c,21628
 numba_cuda/numba/cuda/tests/cudadrv/test_deallocations.py,sha256=BR1ccEj_TCVToHoHS8KwwCfKLMUl6KGb92Cx6nX-XPg,8404
 numba_cuda/numba/cuda/tests/cudadrv/test_detect.py,sha256=lCt2E8gxnd8O-fRobDEwgX4jBZ15W7cImQcZc8_u2Sg,2774
 numba_cuda/numba/cuda/tests/cudadrv/test_emm_plugins.py,sha256=ah82yaWFvBfUTTSfbkZBKLsUf2tTSSJNvlSxrk1RI1E,7094
@@ -231,14 +237,15 @@ numba_cuda/numba/cuda/tests/nocuda/test_import.py,sha256=teiL8rpFGQOh41kyBSSNHHF
 numba_cuda/numba/cuda/tests/nocuda/test_library_lookup.py,sha256=7kJOPHEcrjy_kTA9Ym-iT_B972bgFRu3UkRtwIgWtuI,7948
 numba_cuda/numba/cuda/tests/nocuda/test_nvvm.py,sha256=n0_-xFaw6QqiZbhe55oy7lnEeOwqTvA55p5EUFiTpNw,2006
 numba_cuda/numba/cuda/tests/nrt/__init__.py,sha256=43EXdiXXRBd6yIcVGMrU9F_EJCD9Uw3mzOP3SB53AEE,260
-numba_cuda/numba/cuda/tests/nrt/mock_numpy.py,sha256=Qtn52GoKZ_ydre3oqkLWVdImC37tuPClUy4uHSutaJo,1568
-numba_cuda/numba/cuda/tests/nrt/test_nrt.py,sha256=Ox6ei2DldvSSS-CndTXRxLnsvWdteOQNgn6GvKHB244,2789
+numba_cuda/numba/cuda/tests/nrt/mock_numpy.py,sha256=Cx2DGhm2bJheShP2Ja1w9YLlRTeAMM7u1UYHsPnTzA8,4552
+numba_cuda/numba/cuda/tests/nrt/test_nrt.py,sha256=b3rtK018qslhUU5UsAAa3s-mjlnlfxAwTJmARTVD2j4,7650
+numba_cuda/numba/cuda/tests/nrt/test_nrt_refct.py,sha256=Wq46oICum9IXnbQ97vV8V7g-3U01PLQEQbaGSNdRuMg,3163
 numba_cuda/numba/cuda/tests/test_binary_generation/Makefile,sha256=P2WzCc5d64JGq6pJwHEwmKVmJOJxPBtsMTbnuzqYkik,2679
 numba_cuda/numba/cuda/tests/test_binary_generation/generate_raw_ltoir.py,sha256=V0raLZLGSiWbE_K-JluI0CnmNkXbhlMVj-TH7P1OV8E,5014
 numba_cuda/numba/cuda/tests/test_binary_generation/test_device_functions.cu,sha256=cUf-t6ZM9MK_x7X_aKwsrKW1LdR97XcpR-qnYr5faOE,453
 numba_cuda/numba/cuda/tests/test_binary_generation/undefined_extern.cu,sha256=q3oxZziT8KDodeNcEBiWULH6vMrHCWucmJmtrg8C0d0,128
-numba_cuda-0.3.0.dist-info/LICENSE,sha256=eHeYE-XjASmwbxfsP5AImgfzRwZurZGqH1f6OFwJ4io,1326
-numba_cuda-0.3.0.dist-info/METADATA,sha256=rbDC27qfmpgf9Qw5_p5YiSRyqc9hd_W2rAsA-geDRKk,1496
-numba_cuda-0.3.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-numba_cuda-0.3.0.dist-info/top_level.txt,sha256=C50SsH-8tXDmt7I0Y3nlJYhS5s6pqWflCPdobe9vx2M,11
-numba_cuda-0.3.0.dist-info/RECORD,,
+numba_cuda-0.4.0.dist-info/LICENSE,sha256=eHeYE-XjASmwbxfsP5AImgfzRwZurZGqH1f6OFwJ4io,1326
+numba_cuda-0.4.0.dist-info/METADATA,sha256=BWlfqEMCG0dlSXORk9sKzY7nT_YdQzk9eQ7fBX4rvlY,1496
+numba_cuda-0.4.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+numba_cuda-0.4.0.dist-info/top_level.txt,sha256=C50SsH-8tXDmt7I0Y3nlJYhS5s6pqWflCPdobe9vx2M,11
+numba_cuda-0.4.0.dist-info/RECORD,,

{numba_cuda-0.3.0.dist-info → numba_cuda-0.4.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any