numba-cuda 0.6.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

numba_cuda/VERSION

@@ -1 +1 @@
-0.6.0
+0.8.0

numba_cuda/numba/cuda/compiler.py

@@ -427,6 +427,8 @@ def kernel_fixup(kernel, debug):
                         if tm_name == 'types':
                             types = tm_value
                             types.operands = types.operands[1:]
+                            if config.DUMP_LLVM:
+                                types._clear_string_cache()
 
     # Mark as a kernel for NVVM
 

numba_cuda/numba/cuda/cudadrv/nvvm.py

@@ -199,12 +199,52 @@ class NVVM(object):
 
 
 class CompilationUnit(object):
-    def __init__(self):
+    """
+    A CompilationUnit is a set of LLVM modules that are compiled to PTX or
+    LTO-IR with NVVM.
+
+    Compilation options are accepted as a dict mapping option names to values,
+    with the following considerations:
+
+    - Underscores (`_`) in option names are converted to dashes (`-`), to match
+      NVVM's option name format.
+    - Options that take a value will be emitted in the form "-<name>=<value>".
+    - Booleans passed as option values will be converted to integers.
+    - Options which take no value (such as `-gen-lto`) should have a value of
+      `None` and will be emitted in the form "-<name>".
+
+    For documentation on NVVM compilation options, see the CUDA Toolkit
+    Documentation:
+
+    https://docs.nvidia.com/cuda/libnvvm-api/index.html#_CPPv418nvvmCompileProgram11nvvmProgramiPPKc
+    """
+
+    def __init__(self, options):
         self.driver = NVVM()
         self._handle = nvvm_program()
         err = self.driver.nvvmCreateProgram(byref(self._handle))
         self.driver.check_error(err, 'Failed to create CU')
 
+        def stringify_option(k, v):
+            k = k.replace('_', '-')
+
+            if v is None:
+                return f'-{k}'.encode('utf-8')
+
+            if isinstance(v, bool):
+                v = int(v)
+
+            return f'-{k}={v}'.encode('utf-8')
+
+        options = [stringify_option(k, v) for k, v in options.items()]
+        option_ptrs = (c_char_p * len(options))(*[c_char_p(x) for x in options])
+
+        # We keep both the options and the pointers to them so that options are
+        # not destroyed before we've used their values
+        self.options = options
+        self.option_ptrs = option_ptrs
+        self.n_options = len(options)
+
     def __del__(self):
         driver = NVVM()
         err = driver.nvvmDestroyProgram(byref(self._handle))
@@ -230,60 +270,35 @@ class CompilationUnit(object):
                                                      len(buffer), None)
         self.driver.check_error(err, 'Failed to add module')
 
-    def compile(self, **options):
-        """Perform Compilation.
-
-        Compilation options are accepted as keyword arguments, with the
-        following considerations:
-
-        - Underscores (`_`) in option names are converted to dashes (`-`), to
-          match NVVM's option name format.
-        - Options that take a value will be emitted in the form
-          "-<name>=<value>".
-        - Booleans passed as option values will be converted to integers.
-        - Options which take no value (such as `-gen-lto`) should have a value
-          of `None` passed in and will be emitted in the form "-<name>".
-
-        For documentation on NVVM compilation options, see the CUDA Toolkit
-        Documentation:
-
-        https://docs.nvidia.com/cuda/libnvvm-api/index.html#_CPPv418nvvmCompileProgram11nvvmProgramiPPKc
+    def verify(self):
         """
-
-        def stringify_option(k, v):
-            k = k.replace('_', '-')
-
-            if v is None:
-                return f'-{k}'
-
-            if isinstance(v, bool):
-                v = int(v)
-
-            return f'-{k}={v}'
-
-        options = [stringify_option(k, v) for k, v in options.items()]
-
-        c_opts = (c_char_p * len(options))(*[c_char_p(x.encode('utf8'))
-                                             for x in options])
-        # verify
-        err = self.driver.nvvmVerifyProgram(self._handle, len(options), c_opts)
+        Run the NVVM verifier on all code added to the compilation unit.
+        """
+        err = self.driver.nvvmVerifyProgram(self._handle, self.n_options,
+                                            self.option_ptrs)
         self._try_error(err, 'Failed to verify\n')
 
-        # compile
-        err = self.driver.nvvmCompileProgram(self._handle, len(options), c_opts)
+    def compile(self):
+        """
+        Compile all modules added to the compilation unit and return the
+        resulting PTX or LTO-IR (depending on the options).
+        """
+        err = self.driver.nvvmCompileProgram(self._handle, self.n_options,
+                                             self.option_ptrs)
         self._try_error(err, 'Failed to compile\n')
 
-        # get result
-        reslen = c_size_t()
-        err = self.driver.nvvmGetCompiledResultSize(self._handle, byref(reslen))
+        # Get result
+        result_size = c_size_t()
+        err = self.driver.nvvmGetCompiledResultSize(self._handle,
+                                                    byref(result_size))
 
         self._try_error(err, 'Failed to get size of compiled result.')
 
-        output_buffer = (c_char * reslen.value)()
+        output_buffer = (c_char * result_size.value)()
         err = self.driver.nvvmGetCompiledResult(self._handle, output_buffer)
         self._try_error(err, 'Failed to get compiled result.')
 
-        # get log
+        # Get log
         self.log = self.get_log()
         if self.log:
             warnings.warn(self.log, category=NvvmWarning)
@@ -615,40 +630,44 @@ def llvm_replace(llvmir):
     for decl, fn in replacements:
         llvmir = llvmir.replace(decl, fn)
 
-    llvmir = llvm140_to_70_ir(llvmir)
+    llvmir = llvm150_to_70_ir(llvmir)
 
     return llvmir
 
 
-def compile_ir(llvmir, **opts):
+def compile_ir(llvmir, **options):
     if isinstance(llvmir, str):
         llvmir = [llvmir]
 
-    if opts.pop('fastmath', False):
-        opts.update({
+    if options.pop('fastmath', False):
+        options.update({
             'ftz': True,
             'fma': True,
             'prec_div': False,
             'prec_sqrt': False,
         })
 
-    cu = CompilationUnit()
-    libdevice = LibDevice()
+    cu = CompilationUnit(options)
 
     for mod in llvmir:
         mod = llvm_replace(mod)
         cu.add_module(mod.encode('utf8'))
+    cu.verify()
+
+    # We add libdevice following verification so that it is not subject to the
+    # verifier's requirements
+    libdevice = LibDevice()
     cu.lazy_add_module(libdevice.get())
 
-    return cu.compile(**opts)
+    return cu.compile()
 
 
 re_attributes_def = re.compile(r"^attributes #\d+ = \{ ([\w\s]+)\ }")
 
 
-def llvm140_to_70_ir(ir):
+def llvm150_to_70_ir(ir):
     """
-    Convert LLVM 14.0 IR for LLVM 7.0.
+    Convert LLVM 15.0 IR for LLVM 7.0.
     """
     buf = []
     for line in ir.splitlines():

numba_cuda/numba/cuda/dispatcher.py

@@ -968,6 +968,10 @@ class CUDADispatcher(Dispatcher, serialize.ReduceMixin):
 
         A (template, pysig, args, kws) tuple is returned.
         """
+        # Fold keyword arguments and resolve default values
+        pysig, args = self._compiler.fold_argument_types(args, kws)
+        kws = {}
+
         # Ensure an exactly-matching overload is available if we can
         # compile. We proceed with the typing even if we can't compile
         # because we may be able to force a cast on the caller side.

numba_cuda/numba/cuda/runtime/nrt.py

@@ -5,7 +5,8 @@ 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.driver import (Linker, driver, launch_kernel,
+                                       USE_NV_BINDING)
 from numba.cuda.cudadrv import devices
 from numba.cuda.api import get_current_device
 from numba.cuda.utils import _readenv
@@ -128,6 +129,18 @@ class _Runtime:
             cooperative=False
         )
 
+    def _ctypes_pointer(self, array):
+        """
+        Given an array, return a ctypes pointer to the data suitable for
+        passing to ``launch_kernel``.
+        """
+        ptr = array.device_ctypes_pointer
+
+        if USE_NV_BINDING:
+            ptr = ctypes.c_void_p(int(ptr))
+
+        return ptr
+
     def ensure_initialized(self, stream=None):
         """
         If memsys is not initialized, initialize memsys
@@ -174,12 +187,13 @@ class _Runtime:
         context
         """
         enabled_ar = cuda.managed_array(1, np.uint8)
+        enabled_ptr = self._ctypes_pointer(enabled_ar)
 
         self._single_thread_launch(
             self._memsys_module,
             stream,
             "NRT_MemSys_stats_enabled",
-            (enabled_ar.device_ctypes_pointer,)
+            (enabled_ptr,)
         )
 
         cuda.synchronize()
@@ -198,12 +212,13 @@ class _Runtime:
         ])
 
         stats_for_read = cuda.managed_array(1, dt)
+        stats_ptr = self._ctypes_pointer(stats_for_read)
 
         self._single_thread_launch(
             self._memsys_module,
             stream,
             "NRT_MemSys_read",
-            [stats_for_read.device_ctypes_pointer]
+            [stats_ptr]
         )
         cuda.synchronize()
 
@@ -231,11 +246,13 @@ class _Runtime:
         Get a single stat from the memsys
         """
         got = cuda.managed_array(1, np.uint64)
+        got_ptr = self._ctypes_pointer(got)
+
         self._single_thread_launch(
             self._memsys_module,
             stream,
             f"NRT_MemSys_read_{stat}",
-            [got.device_ctypes_pointer]
+            [got_ptr]
         )
 
         cuda.synchronize()
@@ -294,11 +311,13 @@ class _Runtime:
             raise RuntimeError(
                 "Please allocate NRT Memsys first before setting to module.")
 
+        memsys_ptr = self._ctypes_pointer(self._memsys)
+
         self._single_thread_launch(
             module,
             stream,
             "NRT_MemSys_set",
-            [self._memsys.device_ctypes_pointer,]
+            [memsys_ptr]
         )
 
     @_alloc_init_guard

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

@@ -261,7 +261,8 @@ class TestLinker(CUDATestCase):
 
 
 @unittest.skipIf(
-    not PYNVJITLINK_INSTALLED, reason="Pynvjitlink is not installed"
+    not PYNVJITLINK_INSTALLED or not TEST_BIN_DIR,
+    reason="pynvjitlink not enabled"
 )
 class TestLinkerUsage(CUDATestCase):
     """Test that whether pynvjitlink can be enabled by both environment variable

numba_cuda/numba/cuda/tests/cudapy/test_debuginfo.py

@@ -1,4 +1,4 @@
-from numba.tests.support import override_config
+from numba.tests.support import (override_config, captured_stdout)
 from numba.cuda.testing import skip_on_cudasim
 from numba import cuda
 from numba.core import types
@@ -268,7 +268,7 @@ class TestCudaDebugInfo(CUDATestCase):
         three_device_fns(kernel_debug=False, leaf_debug=True)
         three_device_fns(kernel_debug=False, leaf_debug=False)
 
-    def test_kernel_args_types(self):
+    def _test_kernel_args_types(self):
         sig = (types.int32, types.int32)
 
         @cuda.jit("void(int32, int32)", debug=True, opt=False)
@@ -298,6 +298,15 @@ class TestCudaDebugInfo(CUDATestCase):
         match = re.compile(pat).search(llvm_ir)
         self.assertIsNotNone(match, msg=llvm_ir)
 
+    def test_kernel_args_types(self):
+        self._test_kernel_args_types()
+
+    def test_kernel_args_types_dump(self):
+        # see issue#135
+        with override_config('DUMP_LLVM', 1):
+            with captured_stdout():
+                self._test_kernel_args_types()
+
 
 if __name__ == '__main__':
     unittest.main()

numba_cuda/numba/cuda/tests/cudapy/test_overload.py

@@ -56,6 +56,10 @@ def target_overloaded_calls_target_overloaded():
     pass
 
 
+def default_values_and_kwargs():
+    pass
+
+
 # To recognise which functions are resolved for a call, we identify each with a
 # prime number. Each function called multiplies a value by its prime (starting
 # with the value 1), and we can check that the result is as expected based on
@@ -185,6 +189,13 @@ def ol_generic_calls_target_overloaded_cuda(x):
     return impl
 
 
+@overload(default_values_and_kwargs)
+def ol_default_values_and_kwargs(out, x, y=5, z=6):
+    def impl(out, x, y=5, z=6):
+        out[0], out[1] = x + y, z
+    return impl
+
+
 @skip_on_cudasim('Overloading not supported in cudasim')
 class TestOverload(CUDATestCase):
     def check_overload(self, kernel, expected):
@@ -330,6 +341,18 @@ class TestOverload(CUDATestCase):
         def cuda_target_attr_use(res, dummy):
             res[0] = dummy.cuda_only
 
+    def test_default_values_and_kwargs(self):
+        """
+        Test default values and kwargs.
+        """
+        @cuda.jit()
+        def kernel(a, b, out):
+            default_values_and_kwargs(out, a, z=b)
+
+        out = np.empty(2, dtype=np.int64)
+        kernel[1,1](1, 2, out)
+        self.assertEqual(tuple(out), (6, 2))
+
 
 if __name__ == '__main__':
     unittest.main()

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

@@ -5,7 +5,6 @@ import numpy as np
 import unittest
 from numba.cuda.testing import CUDATestCase
 
-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
@@ -24,7 +23,7 @@ class TestNrtBasic(CUDATestCase):
 
         @cuda.jit
         def g():
-            x = cuda_empty(10, np.int64)
+            x = np.empty(10, np.int64)
             f(x)
 
         g[1,1]()
@@ -37,7 +36,7 @@ class TestNrtBasic(CUDATestCase):
 
         @cuda.jit
         def g():
-            x = cuda_empty(10, np.int64)
+            x = np.empty(10, np.int64)
             f(x)
 
         g[1,1]()
@@ -66,7 +65,7 @@ class TestNrtBasic(CUDATestCase):
 
         @cuda.jit
         def g(out_ary):
-            x = cuda_empty(10, np.int64)
+            x = np.empty(10, np.int64)
             x[5] = 1
             y = f(x)
             out_ary[0] = y[0]
@@ -97,11 +96,11 @@ class TestNrtStatistics(CUDATestCase):
         src = """if 1:
         from numba import cuda
         from numba.cuda.runtime import rtsys
-        from numba.cuda.tests.nrt.mock_numpy import cuda_arange
+        import numpy as np
 
         @cuda.jit
         def foo():
-            x = cuda_arange(10)[0]
+            x = np.arange(10)[0]
 
         # initialize the NRT before use
         rtsys.initialize()
@@ -167,8 +166,8 @@ class TestNrtStatistics(CUDATestCase):
 
         @cuda.jit
         def foo():
-            tmp = cuda_ones(3)
-            arr = cuda_arange(5 * tmp[0]) # noqa: F841
+            tmp = np.ones(3)
+            arr = np.arange(5 * tmp[0]) # noqa: F841
             return None
 
         with (
@@ -230,6 +229,38 @@ class TestNrtStatistics(CUDATestCase):
                     stats_func()
                 self.assertIn("NRT stats are disabled.", str(raises.exception))
 
+    def test_read_one_stat(self):
+        @cuda.jit
+        def foo():
+            tmp = np.ones(3)
+            arr = np.arange(5 * tmp[0]) # noqa: F841
+            return None
+
+        with (
+            override_config('CUDA_ENABLE_NRT', True),
+            override_config('CUDA_NRT_STATS', True)
+        ):
+
+            # Switch on stats
+            rtsys.memsys_enable_stats()
+
+            # Launch the kernel a couple of times to increase stats
+            foo[1, 1]()
+            foo[1, 1]()
+
+            # Get stats struct and individual stats
+            stats = rtsys.get_allocation_stats()
+            stats_alloc = rtsys.memsys_get_stats_alloc()
+            stats_mi_alloc = rtsys.memsys_get_stats_mi_alloc()
+            stats_free = rtsys.memsys_get_stats_free()
+            stats_mi_free = rtsys.memsys_get_stats_mi_free()
+
+            # Check individual stats match stats struct
+            self.assertEqual(stats.alloc, stats_alloc)
+            self.assertEqual(stats.mi_alloc, stats_mi_alloc)
+            self.assertEqual(stats.free, stats_free)
+            self.assertEqual(stats.mi_free, stats_mi_free)
+
 
 if __name__ == '__main__':
     unittest.main()

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

@@ -4,7 +4,6 @@ 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
 
@@ -34,7 +33,7 @@ class TestNrtRefCt(EnableNRTStatsMixin, CUDATestCase):
         @cuda.jit
         def kernel():
             for i in range(n):
-                temp = cuda_empty(2, np.float64) # noqa: F841
+                temp = np.empty(2) # noqa: F841
             return None
 
         init_stats = rtsys.get_allocation_stats()
@@ -51,7 +50,7 @@ class TestNrtRefCt(EnableNRTStatsMixin, CUDATestCase):
         @cuda.jit
         def g(n):
 
-            x = cuda_empty((n, 2), np.float64)
+            x = np.empty((n, 2))
 
             for i in range(n):
                 y = x[i]
@@ -73,13 +72,13 @@ class TestNrtRefCt(EnableNRTStatsMixin, CUDATestCase):
         """
         @cuda.jit
         def if_with_allocation_and_initialization(arr1, test1):
-            tmp_arr = cuda_empty_like(arr1)
+            tmp_arr = np.empty_like(arr1)
 
             for i in range(tmp_arr.shape[0]):
                 pass
 
             if test1:
-                cuda_empty_like(arr1)
+                np.empty_like(arr1)
 
         arr = np.random.random((5, 5))  # the values are not consumed
 

{numba_cuda-0.6.0.dist-info → numba_cuda-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: numba-cuda
-Version: 0.6.0
+Version: 0.8.0
 Summary: CUDA target for Numba
 Author: Anaconda Inc., NVIDIA Corporation
 License: BSD 2-clause
@@ -12,6 +12,7 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numba>=0.59.1
+Dynamic: license-file
 
 <div align="center"><img src="docs/source/_static/numba-green-icon-rgb.svg" width="200"/></div>
 

{numba_cuda-0.6.0.dist-info → numba_cuda-0.8.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=l6XW5UCmEg0Jw53bZn4Ojiusf8wv_vgTuC4I_WA2W84,6
+numba_cuda/VERSION,sha256=pmeA2iMQO-rxJDK0GFCJZrMaKjp4f5RopbbNqoZnwe8,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
@@ -9,7 +9,7 @@ numba_cuda/numba/cuda/api_util.py,sha256=aQfUV2-4RM_oGVvckMjbMr5e3effOQNX04v1T0O
 numba_cuda/numba/cuda/args.py,sha256=HloHkw_PQal2DT-I70Xf_XbnGObS1jiUgcRrQ85Gq28,1978
 numba_cuda/numba/cuda/cg.py,sha256=9V1uZqyGOJX1aFd9c6GAPbLSqq83lE8LoP-vxxrKENY,1490
 numba_cuda/numba/cuda/codegen.py,sha256=ghdYBKZ3Mzk2UlLE64HkrAjb60PN9fibSNkWFRQuj4M,13184
-numba_cuda/numba/cuda/compiler.py,sha256=aWP_aunOOw8RZsTKf-S3YdH5MDkY6kLN5Xr5B2XgOfk,24214
+numba_cuda/numba/cuda/compiler.py,sha256=zwTPJ7JkW3dj8rkAuYFh3jBSpT4qNow97YcXluhPatI,24323
 numba_cuda/numba/cuda/cpp_function_wrappers.cu,sha256=iv84_F6Q9kFjV_kclrQz1msh6Dud8mI3qNkswTid7Qc,953
 numba_cuda/numba/cuda/cuda_fp16.h,sha256=1IC0mdNdkvKbvAe0-f4uYVS7WFrVqOyI1nRUbBiqr6A,126844
 numba_cuda/numba/cuda/cuda_fp16.hpp,sha256=vJ7NUr2X2tKhAP7ojydAiCoOjVO6n4QGoXD6m9Srrlw,89130
@@ -22,7 +22,7 @@ numba_cuda/numba/cuda/decorators.py,sha256=MqmbEXVVgIV1G_feYtccKBRTDL0VALWf0Ljbr
 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=j2nAjlqNAIAoQVCQ4ZQD--hQDsnFLXedlvaXdCMNKEc,44354
+numba_cuda/numba/cuda/dispatcher.py,sha256=HxAlWeMHcipagMdGsfKOhggffUJBl2JB12h_MmWbPZ4,44500
 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
@@ -60,7 +60,7 @@ numba_cuda/numba/cuda/cudadrv/linkable_code.py,sha256=bWBvnndrzWu24SXm7cilCwNFXS
 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=XM9_Vllv7HzH5wZIR2lwFictyX68XDtNbyLkXlL6NTI,11003
-numba_cuda/numba/cuda/cudadrv/nvvm.py,sha256=cAoQmZ0bO8i3wPTQq5D0UeMtfnXdGebqYpU4W0kUIEY,24237
+numba_cuda/numba/cuda/cudadrv/nvvm.py,sha256=AgrWDNnGfIjvnTsQcEix60EnhFSI8Nbg7oOf5VWk87g,25038
 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
@@ -70,7 +70,7 @@ numba_cuda/numba/cuda/runtime/__init__.py,sha256=rDi_pA5HnwpuwT8wwy0hparfO7HWgfj
 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/runtime/nrt.py,sha256=j_LK8kNa3mla-Bkhoupmy4fgbM8ws0wqhiek0tbf3FQ,9683
 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
@@ -111,7 +111,7 @@ numba_cuda/numba/cuda/tests/cudadrv/test_is_fp16.py,sha256=0KPe4E9wOZsSV_0QI0Lmj
 numba_cuda/numba/cuda/tests/cudadrv/test_linker.py,sha256=_l2_EQEko2Jet5ooj4XMT0L4BjOuqLjbONGj1_MVI50,10161
 numba_cuda/numba/cuda/tests/cudadrv/test_managed_alloc.py,sha256=kYXYMkx_3GPAITKp4reLeM8KSzKkpxiC8nxnBvXpaTA,4979
 numba_cuda/numba/cuda/tests/cudadrv/test_mvc.py,sha256=984jATSa01SRoSrVqxPeO6ujJ7w2jsnZa39ABInFLVI,1529
-numba_cuda/numba/cuda/tests/cudadrv/test_nvjitlink.py,sha256=oZywLDuX-l1LJvIIU4QCsE7UCwtIKbBP7u6GxVDpD_g,11316
+numba_cuda/numba/cuda/tests/cudadrv/test_nvjitlink.py,sha256=EPS4-U2tnqFCG-QF-9j2POMKaYiWogHIbpknMwdYGD8,11335
 numba_cuda/numba/cuda/tests/cudadrv/test_nvvm_driver.py,sha256=DF7KV5uh-yMztks0f47NhpalV64dvsNy-f8HY6GhAhE,7373
 numba_cuda/numba/cuda/tests/cudadrv/test_pinned.py,sha256=u_TthSS2N-2J4eBIuF4PGg33AjD-wxly7MKpz0vRAKc,944
 numba_cuda/numba/cuda/tests/cudadrv/test_profiler.py,sha256=MQWZx1j3lbEpWmIpQ1bV9szrGOV3VHN0QrEnJRjAhW4,508
@@ -146,7 +146,7 @@ numba_cuda/numba/cuda/tests/cudapy/test_cuda_array_interface.py,sha256=73FCQbNaA
 numba_cuda/numba/cuda/tests/cudapy/test_cuda_jit_no_types.py,sha256=y7cNQZOZJo5Sv16ql3E5QaRksw-U3RkXss9YDcNeiTk,2137
 numba_cuda/numba/cuda/tests/cudapy/test_datetime.py,sha256=2in1Cq8y9zAFoka7H72wF1D0awEd3n7bv56sUPgoNAQ,3508
 numba_cuda/numba/cuda/tests/cudapy/test_debug.py,sha256=3MYNiMe75rgBF1T0vsJ7r-nkW5jPvov_tDms9KXo2UU,3449
-numba_cuda/numba/cuda/tests/cudapy/test_debuginfo.py,sha256=jI43jMbPS9Rbr3YI2mZBrDwH9MGjmyVlczv7QxxPoAs,10993
+numba_cuda/numba/cuda/tests/cudapy/test_debuginfo.py,sha256=SbeIIASsv5eZapp6i9KZlztN3-OPFiXg6YmtbYIh0eY,11288
 numba_cuda/numba/cuda/tests/cudapy/test_device_func.py,sha256=eDVymTQXTzW0WeAgTMDKYtOi1YAM310IUxGp3Y1ICjs,13162
 numba_cuda/numba/cuda/tests/cudapy/test_dispatcher.py,sha256=oX-l_L4H8rME1IolwhAyordSGJ152nnuqGAFdWjfgas,26587
 numba_cuda/numba/cuda/tests/cudapy/test_enums.py,sha256=0GWiwvZ1FTzSl1FfMxttkWaWrowASfXrSDT8XAR4ZHw,3560
@@ -182,7 +182,7 @@ numba_cuda/numba/cuda/tests/cudapy/test_multithreads.py,sha256=MfCbyJZu1XsCJOCSw
 numba_cuda/numba/cuda/tests/cudapy/test_nondet.py,sha256=mYMX0R1tmBLRe5ZAwiDVFFuSyMuPav5guuqL3WHWGPY,1378
 numba_cuda/numba/cuda/tests/cudapy/test_operator.py,sha256=0nJej4D898_JU-jhlif44fR2yu42keK4GoCLP810l3U,13295
 numba_cuda/numba/cuda/tests/cudapy/test_optimization.py,sha256=IRTI-b7hwMaJxtxFRzoTjpzzeqWGzNyCJPT6C4GugX4,2925
-numba_cuda/numba/cuda/tests/cudapy/test_overload.py,sha256=u4yUDVFcV9E3NWMlNjM81e3IW4KaIkcDtXig8JYevsw,8538
+numba_cuda/numba/cuda/tests/cudapy/test_overload.py,sha256=27olU7CNkKD0vf4BgBHhEhWPbGm1Y83wfSsQtZMJvXg,9087
 numba_cuda/numba/cuda/tests/cudapy/test_powi.py,sha256=TI82rYRnkSnwv9VN6PMpBnr9JqMJ_F3HhH4cKY6O8tw,3276
 numba_cuda/numba/cuda/tests/cudapy/test_print.py,sha256=r2xmMNx80_ANi3uFB3CQt3AHAXG_JdhStY1S796hlK0,4466
 numba_cuda/numba/cuda/tests/cudapy/test_py2_div_issue.py,sha256=R88Vfgg3mSAZ0Jy6WT6dJNmkFTsxnVnEmO7XqpqyxuU,986
@@ -238,15 +238,14 @@ 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=Cx2DGhm2bJheShP2Ja1w9YLlRTeAMM7u1UYHsPnTzA8,4552
-numba_cuda/numba/cuda/tests/nrt/test_nrt.py,sha256=wByXeagVoxsAu_pmfuYQ7vmeJt82h4VXwCBsDYQfsps,7727
-numba_cuda/numba/cuda/tests/nrt/test_nrt_refct.py,sha256=SnVvTis8YyaqsElRaGQ-34dnWgGavvc2Ovm2xZ_PD3Q,3240
+numba_cuda/numba/cuda/tests/nrt/test_nrt.py,sha256=KYDhlWJRqtIonAEy0-bUvLwPTEVMCDbfFoAXrPWtvqA,8721
+numba_cuda/numba/cuda/tests/nrt/test_nrt_refct.py,sha256=Xbxf07LNiiXzCA0rrmCSe_B-3Oi_8LwjNVVR3Lbc0Hc,3136
 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.6.0.dist-info/LICENSE,sha256=eHeYE-XjASmwbxfsP5AImgfzRwZurZGqH1f6OFwJ4io,1326
-numba_cuda-0.6.0.dist-info/METADATA,sha256=iNU56EXHsnAcAcwgNXglPh6H47Quz31_-6r9RevpJ_Q,1836
-numba_cuda-0.6.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-numba_cuda-0.6.0.dist-info/top_level.txt,sha256=C50SsH-8tXDmt7I0Y3nlJYhS5s6pqWflCPdobe9vx2M,11
-numba_cuda-0.6.0.dist-info/RECORD,,
+numba_cuda-0.8.0.dist-info/licenses/LICENSE,sha256=eHeYE-XjASmwbxfsP5AImgfzRwZurZGqH1f6OFwJ4io,1326
+numba_cuda-0.8.0.dist-info/METADATA,sha256=-DMmEoMsrK2h_Xk6hZEovTXhUURYzw9W4KDrl13ehRM,1858
+numba_cuda-0.8.0.dist-info/WHEEL,sha256=tTnHoFhvKQHCh4jz3yCn0WPTYIy7wXx3CJtJ7SJGV7c,91
+numba_cuda-0.8.0.dist-info/top_level.txt,sha256=C50SsH-8tXDmt7I0Y3nlJYhS5s6pqWflCPdobe9vx2M,11
+numba_cuda-0.8.0.dist-info/RECORD,,

{numba_cuda-0.6.0.dist-info → numba_cuda-0.8.0.dist-info}/WHEEL

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

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

@@ -1,146 +0,0 @@
-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,
-                               numpy_empty_like_nd)
-
-
-# Typical tests for allocation use array construction (e.g. np.zeros, np.empty,
-# etc.) to induce allocations. These don't work in the CUDA target because they
-# need keyword arguments, which are presently not supported properly in the
-# CUDA target.
-#
-# To work around this, we can define our own function, that works like
-# the desired one, except that it uses only positional arguments.
-#
-# Once the CUDA target supports keyword arguments, this workaround will no
-# longer be necessary and the tests in this module should be switched to use
-# the relevant NumPy functions instead.
-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)
-    if (dtype is float or
-        (isinstance(dtype, types.Function) and dtype.typing_key is float) or
-            is_nonelike(dtype)): #default
-        nb_dtype = types.double
-    else:
-        nb_dtype = ty_parse_dtype(dtype)
-
-    ndim = ty_parse_shape(shape)
-    if nb_dtype is not None and ndim is not None:
-        retty = types.Array(dtype=nb_dtype, ndim=ndim, layout='C')
-
-        def impl(shape, dtype):
-            return numpy_empty_nd(shape, dtype, retty)
-        return impl
-    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