numba-cuda 0.11.0__py3-none-any.whl → 0.12.1__py3-none-any.whl

numba_cuda/VERSION

@@ -1 +1 @@
-0.11.0
+0.12.1

numba_cuda/numba/cuda/{cuda_bf16.py → _internal/cuda_bf16.py}

@@ -2,7 +2,7 @@
 # Generator Information:
 # Ast_canopy version: 0.3.0
 # Numbast version: 0.3.0
-# Generation command: /home/wangm/numbast/numbast/src/numbast/__main__.py --cfg-path configs/cuda_bf16.yml --output-dir numba_cuda/numba/cuda/
+# Generation command: /home/wangm/numbast/numbast/src/numbast/__main__.py --cfg-path configs/cuda_bf16.yml --output-dir numba_cuda/numba/cuda/_internal
 # Static binding generator parameters: {'cfg_path': 'configs/cuda_bf16.yml', 'output_dir': 'numba_cuda/numba/cuda/', 'entry_point': None, 'retain': None, 'types': None, 'datamodels': None, 'compute_capability': None, 'run_ruff_format': True}
 # Config file path (relative to the path of the generated binding): ../../../../configs/cuda_bf16.yml
 # Cudatoolkit version: (12, 8)

numba_cuda/numba/cuda/api.py

@@ -10,6 +10,7 @@ import numpy as np
 from .cudadrv import devicearray, devices, driver
 from numba.core import config
 from numba.cuda.api_util import prepare_shape_strides_dtype
+from numba.cuda.cudadrv.runtime import get_version
 
 # NDarray device helper
 
@@ -95,6 +96,18 @@ def is_float16_supported():
     return True
 
 
+def is_bfloat16_supported():
+    """Whether bfloat16 are supported.
+
+    bfloat16 are only supported on devices with compute capability >= 8.0 and cuda version >= 12.0
+    """
+    cuda_version = get_version()
+    return current_context().device.supports_bfloat16 and cuda_version >= (
+        12,
+        0,
+    )
+
+
 @require_context
 def to_device(obj, stream=0, copy=True, to=None):
     """to_device(obj, stream=0, copy=True, to=None)

numba_cuda/numba/cuda/bf16.py

@@ -0,0 +1,112 @@
+from numba.cuda._internal.cuda_bf16 import (
+    _type_class___nv_bfloat16,
+    nv_bfloat16 as bfloat16,
+    htrunc,
+    hceil,
+    hfloor,
+    hrint,
+    hsqrt,
+    hrsqrt,
+    hrcp,
+    hlog,
+    hlog2,
+    hlog10,
+    hcos,
+    hsin,
+    hexp,
+    hexp2,
+    hexp10,
+    htanh,
+    htanh_approx,
+)
+from numba.extending import overload
+
+import math
+
+
+def _make_unary(a, func):
+    if isinstance(a, _type_class___nv_bfloat16):
+        return lambda a: func(a)
+
+
+# Bind low++ bindings to math APIs
+@overload(math.trunc, target="cuda")
+def trunc_ol(a):
+    return _make_unary(a, htrunc)
+
+
+@overload(math.ceil, target="cuda")
+def ceil_ol(a):
+    return _make_unary(a, hceil)
+
+
+@overload(math.floor, target="cuda")
+def floor_ol(a):
+    return _make_unary(a, hfloor)
+
+
+@overload(math.sqrt, target="cuda")
+def sqrt_ol(a):
+    return _make_unary(a, hsqrt)
+
+
+@overload(math.log, target="cuda")
+def log_ol(a):
+    return _make_unary(a, hlog)
+
+
+@overload(math.log10, target="cuda")
+def log10_ol(a):
+    return _make_unary(a, hlog10)
+
+
+@overload(math.cos, target="cuda")
+def cos_ol(a):
+    return _make_unary(a, hcos)
+
+
+@overload(math.sin, target="cuda")
+def sin_ol(a):
+    return _make_unary(a, hsin)
+
+
+@overload(math.tanh, target="cuda")
+def tanh_ol(a):
+    return _make_unary(a, htanh)
+
+
+@overload(math.exp, target="cuda")
+def exp_ol(a):
+    return _make_unary(a, hexp)
+
+
+try:
+    from math import exp2
+
+    @overload(exp2, target="cuda")
+    def exp2_ol(a):
+        return _make_unary(a, hexp2)
+except ImportError:
+    pass
+
+
+__all__ = [
+    "bfloat16",
+    "htrunc",
+    "hceil",
+    "hfloor",
+    "hrint",
+    "hsqrt",
+    "hrsqrt",
+    "hrcp",
+    "hlog",
+    "hlog2",
+    "hlog10",
+    "hcos",
+    "hsin",
+    "htanh",
+    "htanh_approx",
+    "hexp",
+    "hexp2",
+    "hexp10",
+]

numba_cuda/numba/cuda/cg.py

@@ -23,6 +23,7 @@ def _this_grid(typingctx):
     sig = signature(grid_group)
 
     def codegen(context, builder, sig, args):
+        context.active_code_library.use_cooperative = True
         one = context.get_constant(types.int32, 1)
         mod = builder.module
         return builder.call(
@@ -45,6 +46,7 @@ def _grid_group_sync(typingctx, group):
     sig = signature(types.int32, group)
 
     def codegen(context, builder, sig, args):
+        context.active_code_library.use_cooperative = True
         flags = context.get_constant(types.int32, 0)
         mod = builder.module
         return builder.call(

numba_cuda/numba/cuda/codegen.py

@@ -70,6 +70,8 @@ class ExternalCodeLibrary(CodeLibrary):
         self._setup_functions = []
         self._teardown_functions = []
 
+        self.use_cooperative = False
+
     @property
     def modules(self):
         # There are no LLVM IR modules in an ExternalCodeLibrary
@@ -181,6 +183,8 @@ class CUDACodeLibrary(serialize.ReduceMixin, CodeLibrary):
         self._nvvm_options = nvvm_options
         self._entry_name = entry_name
 
+        self.use_cooperative = False
+
     @property
     def llvm_strs(self):
         if self._llvm_strs is None:
@@ -352,6 +356,7 @@ class CUDACodeLibrary(serialize.ReduceMixin, CodeLibrary):
         self._linking_files.update(library._linking_files)
         self._setup_functions.extend(library._setup_functions)
         self._teardown_functions.extend(library._teardown_functions)
+        self.use_cooperative |= library.use_cooperative
 
     def add_linking_file(self, path_or_obj):
         if isinstance(path_or_obj, LinkableCode):
@@ -442,6 +447,7 @@ class CUDACodeLibrary(serialize.ReduceMixin, CodeLibrary):
             nvvm_options=self._nvvm_options,
             needs_cudadevrt=self.needs_cudadevrt,
             nrt=nrt,
+            use_cooperative=self.use_cooperative,
         )
 
     @classmethod
@@ -458,6 +464,7 @@ class CUDACodeLibrary(serialize.ReduceMixin, CodeLibrary):
         nvvm_options,
         needs_cudadevrt,
         nrt,
+        use_cooperative,
     ):
         """
         Rebuild an instance.
@@ -472,6 +479,7 @@ class CUDACodeLibrary(serialize.ReduceMixin, CodeLibrary):
         instance._max_registers = max_registers
         instance._nvvm_options = nvvm_options
         instance.needs_cudadevrt = needs_cudadevrt
+        instance.use_cooperative = use_cooperative
 
         instance._finalized = True
         if nrt:

numba_cuda/numba/cuda/compiler.py

@@ -797,7 +797,7 @@ def compile_ptx_for_current_device(
     )
 
 
-def declare_device_function(name, restype, argtypes, link):
+def declare_device_function(name, restype, argtypes, link, use_cooperative):
     from .descriptor import cuda_target
 
     typingctx = cuda_target.typing_context
@@ -816,6 +816,7 @@ def declare_device_function(name, restype, argtypes, link):
     lib = ExternalCodeLibrary(f"{name}_externals", targetctx.codegen())
     for file in link:
         lib.add_linking_file(file)
+    lib.use_cooperative = use_cooperative
 
     # ExternalFunctionDescriptor provides a lowering implementation for calling
     # external functions

numba_cuda/numba/cuda/cudadecl.py

@@ -423,7 +423,11 @@ _genfp16_binary_operator(operator.itruediv)
 def _resolve_wrapped_unary(fname):
     link = tuple()
     decl = declare_device_function(
-        f"__numba_wrapper_{fname}", types.float16, (types.float16,), link
+        f"__numba_wrapper_{fname}",
+        types.float16,
+        (types.float16,),
+        link,
+        use_cooperative=False,
     )
     return types.Function(decl)
 
@@ -438,6 +442,7 @@ def _resolve_wrapped_binary(fname):
             types.float16,
         ),
         link,
+        use_cooperative=False,
     )
     return types.Function(decl)
 

numba_cuda/numba/cuda/cudadrv/driver.py

@@ -714,6 +714,10 @@ class Device(object):
     def supports_float16(self):
         return self.compute_capability >= (5, 3)
 
+    @property
+    def supports_bfloat16(self):
+        return self.compute_capability >= (8, 0)
+
 
 def met_requirement_for_device(device):
     if device.compute_capability < MIN_REQUIRED_CC:

numba_cuda/numba/cuda/cudadrv/nvrtc.py

@@ -6,13 +6,21 @@ from numba.cuda.cudadrv.error import (
     NvrtcCompilationError,
     NvrtcSupportError,
 )
+from numba import config
 from numba.cuda.cuda_paths import get_cuda_paths
+from numba.cuda.utils import _readenv
 
 import functools
 import os
 import threading
 import warnings
 
+NVRTC_EXTRA_SEARCH_PATHS = _readenv(
+    "NUMBA_CUDA_NVRTC_EXTRA_SEARCH_PATHS", str, ""
+) or getattr(config, "NUMBA_CUDA_NVRTC_EXTRA_SEARCH_PATHS", "")
+if not hasattr(config, "NUMBA_CUDA_NVRTC_EXTRA_SEARCH_PATHS"):
+    config.CUDA_NVRTC_EXTRA_SEARCH_PATHS = NVRTC_EXTRA_SEARCH_PATHS
+
 # Opaque handle for compilation unit
 nvrtc_program = c_void_p
 
@@ -383,10 +391,24 @@ def compile(src, name, cc, ltoir=False):
     else:
         numba_include = f"-I{os.path.join(numba_cuda_path, 'include', '12')}"
 
+    if config.CUDA_NVRTC_EXTRA_SEARCH_PATHS:
+        extra_search_paths = config.CUDA_NVRTC_EXTRA_SEARCH_PATHS.split(":")
+        extra_includes = [f"-I{p}" for p in extra_search_paths]
+    else:
+        extra_includes = []
+
     nrt_path = os.path.join(numba_cuda_path, "runtime")
     nrt_include = f"-I{nrt_path}"
 
-    options = [arch, numba_include, *cuda_include, nrt_include, "-rdc", "true"]
+    options = [
+        arch,
+        numba_include,
+        *cuda_include,
+        nrt_include,
+        *extra_includes,
+        "-rdc",
+        "true",
+    ]
 
     if ltoir:
         options.append("-dlto")

numba_cuda/numba/cuda/debuginfo.py

@@ -59,6 +59,33 @@ class CUDADIBuilder(DIBuilder):
         # For other cases, use upstream Numba implementation
         return super()._var_type(lltype, size, datamodel=datamodel)
 
+    def _di_subroutine_type(self, line, function, argmap):
+        # The function call conv needs encoding.
+        llfunc = function
+        md = []
+
+        # Create metadata type for return value
+        if len(llfunc.args) > 0:
+            lltype = llfunc.args[0].type
+            size = self.cgctx.get_abi_sizeof(lltype)
+            mdtype = self._var_type(lltype, size, datamodel=None)
+            md.append(mdtype)
+
+        # Create metadata type for arguments
+        for idx, (name, nbtype) in enumerate(argmap.items()):
+            datamodel = self.cgctx.data_model_manager[nbtype]
+            lltype = self.cgctx.get_value_type(nbtype)
+            size = self.cgctx.get_abi_sizeof(lltype)
+            mdtype = self._var_type(lltype, size, datamodel=datamodel)
+            md.append(mdtype)
+
+        return self.module.add_debug_info(
+            "DISubroutineType",
+            {
+                "types": self.module.add_metadata(md),
+            },
+        )
+
     def mark_variable(
         self,
         builder,

numba_cuda/numba/cuda/decorators.py

@@ -229,7 +229,7 @@ def jit(
                 return disp
 
 
-def declare_device(name, sig, link=None):
+def declare_device(name, sig, link=None, use_cooperative=False):
     """
     Declare the signature of a foreign function. Returns a descriptor that can
     be used to call the function from a Python kernel.
@@ -238,6 +238,7 @@ def declare_device(name, sig, link=None):
     :type name: str
     :param sig: The Numba signature of the function.
     :param link: External code to link when calling the function.
+    :param use_cooperative: External code requires cooperative launch.
     """
     if link is None:
         link = tuple()
@@ -250,6 +251,8 @@ def declare_device(name, sig, link=None):
         msg = "Return type must be provided for device declarations"
         raise TypeError(msg)
 
-    template = declare_device_function(name, restype, argtypes, link)
+    template = declare_device_function(
+        name, restype, argtypes, link, use_cooperative
+    )
 
     return template.key

numba_cuda/numba/cuda/dispatcher.py

@@ -151,8 +151,8 @@ class _Kernel(serialize.ReduceMixin):
 
         asm = lib.get_asm_str()
 
-        # A kernel needs cooperative launch if grid_sync is being used.
-        self.cooperative = "cudaCGGetIntrinsicHandle" in asm
+        # The code library contains functions that require cooperative launch.
+        self.cooperative = lib.use_cooperative
         # We need to link against cudadevrt if grid sync is being used.
         if self.cooperative:
             lib.needs_cudadevrt = True

numba_cuda/numba/cuda/target.py

@@ -290,7 +290,16 @@ class CUDATargetContext(BaseContext):
 
 
 class CUDACallConv(MinimalCallConv):
-    pass
+    def decorate_function(self, fn, args, fe_argtypes, noalias=False):
+        """
+        Set names and attributes of function arguments.
+        """
+        assert not noalias
+        arginfo = self._get_arg_packer(fe_argtypes)
+        # Do not prefix "arg." on argument name, so that nvvm compiler
+        # can track debug info of argument more accurately
+        arginfo.assign_names(self.get_arguments(fn), args)
+        fn.args[0].name = ".ret"
 
 
 class CUDACABICallConv(BaseCallConv):

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

@@ -203,18 +203,6 @@ def simple_usecase_kernel(r, x):
 simple_usecase_caller = CUDAUseCase(simple_usecase_kernel)
 
 
-# Usecase with cooperative groups
-
-
-@cuda.jit(cache=True)
-def cg_usecase_kernel(r, x):
-    grid = cuda.cg.this_grid()
-    grid.sync()
-
-
-cg_usecase = CUDAUseCase(cg_usecase_kernel)
-
-
 class _TestModule(CUDATestCase):
     """
     Tests for functionality of this module's functions.

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

@@ -0,0 +1,33 @@
+from numba import cuda
+from numba.cuda.testing import CUDATestCase
+import sys
+
+from numba.cuda.tests.cudapy.cache_usecases import CUDAUseCase
+
+
+# Usecase with cooperative groups
+
+
+@cuda.jit(cache=True)
+def cg_usecase_kernel(r, x):
+    grid = cuda.cg.this_grid()
+    grid.sync()
+
+
+cg_usecase = CUDAUseCase(cg_usecase_kernel)
+
+
+class _TestModule(CUDATestCase):
+    """
+    Tests for functionality of this module's functions.
+    Note this does not define any "test_*" method, instead check_module()
+    should be called by hand.
+    """
+
+    def check_module(self, mod):
+        mod.cg_usecase(0)
+
+
+def self_test():
+    mod = sys.modules[__name__]
+    _TestModule().check_module(mod)

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

@@ -0,0 +1,55 @@
+from numba import cuda, float32
+from numba.cuda.bf16 import bfloat16
+from numba.cuda.testing import CUDATestCase
+
+import math
+
+
+class TestBfloat16HighLevelBindings(CUDATestCase):
+    def skip_unsupported(self):
+        if not cuda.is_bfloat16_supported():
+            self.skipTest(
+                "bfloat16 requires compute capability 8.0+ and CUDA version>= 12.0"
+            )
+
+    def test_use_type_in_kernel(self):
+        self.skip_unsupported()
+
+        @cuda.jit
+        def kernel():
+            bfloat16(3.14)
+
+        kernel[1, 1]()
+
+    def test_math_bindings(self):
+        self.skip_unsupported()
+        functions = [
+            math.trunc,
+            math.ceil,
+            math.floor,
+            math.sqrt,
+            math.log,
+            math.log10,
+            math.cos,
+            math.sin,
+            math.tanh,
+            math.exp,
+            math.exp2,
+        ]
+
+        for f in functions:
+            with self.subTest(func=f):
+
+                @cuda.jit
+                def kernel(arr):
+                    x = bfloat16(3.14)
+                    y = f(x)
+                    arr[0] = float32(y)
+
+                arr = cuda.device_array((1,), dtype="float32")
+                kernel[1, 1](arr)
+
+                if f in (math.exp, math.exp2):
+                    self.assertAlmostEqual(arr[0], f(3.14), delta=1e-1)
+                else:
+                    self.assertAlmostEqual(arr[0], f(3.14), delta=1e-2)

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

@@ -5,7 +5,7 @@ import numpy as np
 from numba import int16, int32, int64, uint16, uint32, uint64, float32, float64
 from numba.types import float16
 
-from numba.cuda.cuda_bf16 import (
+from numba.cuda._internal.cuda_bf16 import (
     nv_bfloat16,
     htrunc,
     hceil,
@@ -22,21 +22,23 @@ from numba.cuda.cuda_bf16 import (
     hexp,
     hexp2,
     hexp10,
+    htanh,
+    htanh_approx,
 )
 
-from numba.cuda.cudadrv.runtime import get_version
-
-cuda_version = get_version()
-
 dtypes = [int16, int32, int64, uint16, uint32, uint64, float32]
 
 
-@unittest.skipIf(
-    (cuda.get_current_device().compute_capability < (8, 0)),
-    "bfloat16 requires compute capability 8.0+",
-)
 class Bfloat16Test(CUDATestCase):
+    def skip_unsupported(self):
+        if not cuda.is_bfloat16_supported():
+            self.skipTest(
+                "bfloat16 requires compute capability 8.0+ and CUDA version>= 12.0"
+            )
+
     def test_ctor(self):
+        self.skip_unsupported()
+
         @cuda.jit
         def simple_kernel():
             a = nv_bfloat16(float64(1.0))  # noqa: F841
@@ -47,18 +49,13 @@ class Bfloat16Test(CUDATestCase):
             f = nv_bfloat16(uint16(6))  # noqa: F841
             g = nv_bfloat16(uint32(7))  # noqa: F841
             h = nv_bfloat16(uint64(8))  # noqa: F841
+            i = nv_bfloat16(float16(9))  # noqa: F841
 
         simple_kernel[1, 1]()
 
-        if cuda_version >= (12, 0):
-
-            @cuda.jit
-            def simple_kernel_fp16():
-                i = nv_bfloat16(float16(9))  # noqa: F841
-
-            simple_kernel_fp16[1, 1]()
-
     def test_casts(self):
+        self.skip_unsupported()
+
         @cuda.jit
         def simple_kernel(b, c, d, e, f, g, h):
             a = nv_bfloat16(3.14)
@@ -90,6 +87,7 @@ class Bfloat16Test(CUDATestCase):
         assert h[0] == 3
 
     def test_ctor_cast_loop(self):
+        self.skip_unsupported()
         for dtype in dtypes:
             with self.subTest(dtype=dtype):
 
@@ -106,6 +104,8 @@ class Bfloat16Test(CUDATestCase):
                     assert a[0] == 3
 
     def test_arithmetic(self):
+        self.skip_unsupported()
+
         @cuda.jit
         def simple_kernel(arith, logic):
             # Binary Arithmetic Operators
@@ -175,6 +175,8 @@ class Bfloat16Test(CUDATestCase):
         )
 
     def test_math_func(self):
+        self.skip_unsupported()
+
         @cuda.jit
         def simple_kernel(a):
             x = nv_bfloat16(3.14)
@@ -191,16 +193,18 @@ class Bfloat16Test(CUDATestCase):
             a[9] = float32(hlog10(x))
             a[10] = float32(hcos(x))
             a[11] = float32(hsin(x))
-            a[12] = float32(hexp(x))
-            a[13] = float32(hexp2(x))
-            a[14] = float32(hexp10(x))
+            a[12] = float32(htanh(x))
+            a[13] = float32(htanh_approx(x))
+            a[14] = float32(hexp(x))
+            a[15] = float32(hexp2(x))
+            a[16] = float32(hexp10(x))
 
-        a = np.zeros(15, dtype=np.float32)
+        a = np.zeros(17, dtype=np.float32)
         simple_kernel[1, 1](a)
 
         x = 3.14
         np.testing.assert_allclose(
-            a[:12],
+            a[:14],
             [
                 np.trunc(x),
                 np.ceil(x),
@@ -214,15 +218,19 @@ class Bfloat16Test(CUDATestCase):
                 np.log10(x),
                 np.cos(x),
                 np.sin(x),
+                np.tanh(x),
+                np.tanh(x),
             ],
             atol=1e-2,
         )
 
         np.testing.assert_allclose(
-            a[12:], [np.exp(x), np.exp2(x), np.power(10, x)], atol=1e2
+            a[14:], [np.exp(x), np.exp2(x), np.power(10, x)], atol=1e2
         )
 
     def test_check_bfloat16_type(self):
+        self.skip_unsupported()
+
         @cuda.jit
         def kernel(arr):
             x = nv_bfloat16(3.14)
@@ -237,6 +245,8 @@ class Bfloat16Test(CUDATestCase):
         np.testing.assert_allclose(arr, [3.14], atol=1e-2)
 
     def test_use_within_device_func(self):
+        self.skip_unsupported()
+
         @cuda.jit(device=True)
         def add_bf16(a, b):
             return a + b
@@ -252,6 +262,22 @@ class Bfloat16Test(CUDATestCase):
 
         np.testing.assert_allclose(arr, [8], atol=1e-2)
 
+    def test_use_binding_inside_dfunc(self):
+        @cuda.jit(device=True)
+        def f(arr):
+            pi = nv_bfloat16(3.14)
+            three = htrunc(pi)
+            arr[0] = float32(three)
+
+        @cuda.jit
+        def kernel(arr):
+            f(arr)
+
+        arr = np.zeros(1, np.float32)
+        kernel[1, 1](arr)
+
+        np.testing.assert_allclose(arr, [3], atol=1e-2)
+
 
 if __name__ == "__main__":
     unittest.main()

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

@@ -1,8 +1,6 @@
 import multiprocessing
 import os
 import shutil
-import subprocess
-import sys
 import unittest
 import warnings
 
@@ -163,55 +161,6 @@ class CUDACachingTest(SerialMixin, DispatcherCacheUsecasesTest):
         f = mod.renamed_function2
         self.assertPreciseEqual(f(2), 8)
 
-    @skip_unless_cc_60
-    @skip_if_cudadevrt_missing
-    @skip_if_mvc_enabled("CG not supported with MVC")
-    def test_cache_cg(self):
-        # Functions using cooperative groups should be cacheable. See Issue
-        # #8888: https://github.com/numba/numba/issues/8888
-        self.check_pycache(0)
-        mod = self.import_module()
-        self.check_pycache(0)
-
-        mod.cg_usecase(0)
-        self.check_pycache(2)  # 1 index, 1 data
-
-        # Check the code runs ok from another process
-        self.run_in_separate_process()
-
-    @skip_unless_cc_60
-    @skip_if_cudadevrt_missing
-    @skip_if_mvc_enabled("CG not supported with MVC")
-    def test_cache_cg_clean_run(self):
-        # See Issue #9432: https://github.com/numba/numba/issues/9432
-        # If a cached function using CG sync was the first thing to compile,
-        # the compile would fail.
-        self.check_pycache(0)
-
-        # This logic is modelled on run_in_separate_process(), but executes the
-        # CG usecase directly in the subprocess.
-        code = """if 1:
-            import sys
-
-            sys.path.insert(0, %(tempdir)r)
-            mod = __import__(%(modname)r)
-            mod.cg_usecase(0)
-            """ % dict(tempdir=self.tempdir, modname=self.modname)
-
-        popen = subprocess.Popen(
-            [sys.executable, "-c", code],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-        )
-        out, err = popen.communicate(timeout=60)
-        if popen.returncode != 0:
-            raise AssertionError(
-                "process failed with code %s: \n"
-                "stdout follows\n%s\n"
-                "stderr follows\n%s\n"
-                % (popen.returncode, out.decode(), err.decode()),
-            )
-
     def _test_pycache_fallback(self):
         """
         With a disabled __pycache__, test there is a working fallback
@@ -275,6 +224,40 @@ class CUDACachingTest(SerialMixin, DispatcherCacheUsecasesTest):
                 pass
 
 
+@skip_on_cudasim("Simulator does not implement caching")
+class CUDACooperativeGroupTest(SerialMixin, DispatcherCacheUsecasesTest):
+    # See Issue #9432: https://github.com/numba/numba/issues/9432
+    # If a cached function using CG sync was the first thing to compile,
+    # the compile would fail.
+    here = os.path.dirname(__file__)
+    usecases_file = os.path.join(here, "cg_cache_usecases.py")
+    modname = "cuda_cooperative_caching_test_fodder"
+
+    def setUp(self):
+        DispatcherCacheUsecasesTest.setUp(self)
+        CUDATestCase.setUp(self)
+
+    def tearDown(self):
+        CUDATestCase.tearDown(self)
+        DispatcherCacheUsecasesTest.tearDown(self)
+
+    @skip_unless_cc_60
+    @skip_if_cudadevrt_missing
+    @skip_if_mvc_enabled("CG not supported with MVC")
+    def test_cache_cg(self):
+        # Functions using cooperative groups should be cacheable. See Issue
+        # #8888: https://github.com/numba/numba/issues/8888
+        self.check_pycache(0)
+        mod = self.import_module()
+        self.check_pycache(0)
+
+        mod.cg_usecase(0)
+        self.check_pycache(2)  # 1 index, 1 data
+
+        # Check the code runs ok from another process
+        self.run_in_separate_process()
+
+
 @skip_on_cudasim("Simulator does not implement caching")
 class CUDAAndCPUCachingTest(SerialMixin, DispatcherCacheUsecasesTest):
     here = os.path.dirname(__file__)

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

@@ -1,8 +1,13 @@
 from __future__ import print_function
 
+import os
+
+import cffi
+
 import numpy as np
 
 from numba import config, cuda, int32
+from numba.types import CPointer
 from numba.cuda.testing import (
     unittest,
     CUDATestCase,
@@ -11,6 +16,9 @@ from numba.cuda.testing import (
     skip_if_cudadevrt_missing,
     skip_if_mvc_enabled,
 )
+from numba.core.typing import signature
+
+ffi = cffi.FFI()
 
 
 @cuda.jit
@@ -149,6 +157,32 @@ class TestCudaCooperativeGroups(CUDATestCase):
         self.assertEqual(blocks1d, blocks2d)
         self.assertEqual(blocks1d, blocks3d)
 
+    @skip_unless_cc_60
+    def test_external_cooperative_func(self):
+        cudapy_test_path = os.path.dirname(__file__)
+        tests_path = os.path.dirname(cudapy_test_path)
+        data_path = os.path.join(tests_path, "data")
+        src = os.path.join(data_path, "cta_barrier.cu")
+
+        sig = signature(
+            CPointer(int32),
+        )
+        cta_barrier = cuda.declare_device(
+            "cta_barrier", sig=sig, link=[src], use_cooperative=True
+        )
+
+        @cuda.jit
+        def kernel():
+            cta_barrier()
+
+        block_size = 32
+        grid_size = 1024
+
+        kernel[grid_size, block_size]()
+
+        overload = kernel.overloads[()]
+        self.assertTrue(overload.cooperative)
+
 
 if __name__ == "__main__":
     unittest.main()

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

@@ -310,6 +310,23 @@ class TestCudaDebugInfo(CUDATestCase):
             with captured_stdout():
                 self._test_kernel_args_types()
 
+    def test_kernel_args_names(self):
+        sig = (types.int32,)
+
+        @cuda.jit("void(int32)", debug=True, opt=False)
+        def f(x):
+            z = x  # noqa: F841
+
+        llvm_ir = f.inspect_llvm(sig)
+
+        # Verify argument name is not prefixed with "arg."
+        pat = r"define void @.*\(i32 %\"x\"\)"
+        match = re.compile(pat).search(llvm_ir)
+        self.assertIsNotNone(match, msg=llvm_ir)
+        pat = r"define void @.*\(i32 %\"arg\.x\"\)"
+        match = re.compile(pat).search(llvm_ir)
+        self.assertIsNone(match, msg=llvm_ir)
+
     def test_llvm_dbg_value(self):
         sig = (types.int32, types.int32)
 

numba_cuda/numba/cuda/tests/data/cta_barrier.cu

@@ -0,0 +1,23 @@
+#include <cooperative_groups.h>
+#include <cuda/barrier>
+
+namespace cg = cooperative_groups;
+
+__device__ void _wait_on_tile(cuda::barrier<cuda::thread_scope_block> &tile)
+{
+    auto token = tile.arrive();
+    tile.wait(std::move(token));
+}
+
+extern "C"
+__device__ int cta_barrier(int *ret) {
+    auto cta = cg::this_thread_block();
+    cg::thread_block_tile<32> tile = cg::tiled_partition<32>(cta);
+    __shared__ cuda::barrier<cuda::thread_scope_block> barrier;
+    if (threadIdx.x == 0) {
+        init(&barrier, blockDim.x);
+    }
+
+    _wait_on_tile(barrier);
+    return 0;
+}

numba_cuda/numba/cuda/tests/data/include/add.cuh

@@ -0,0 +1,3 @@
+// Templated addition function: myadd
+template <typename T>
+__device__ T myadd(T a, T b) { return a + b; }

numba_cuda/numba/cuda/tests/doc_examples/ffi/include/mul.cuh

@@ -0,0 +1,3 @@
+// Templated multiplication function: mymul
+template <typename T>
+__device__ T mymul(T a, T b) { return a * b; }

numba_cuda/numba/cuda/tests/doc_examples/ffi/saxpy.cu

@@ -0,0 +1,9 @@
+#include <add.cuh> // In numba/cuda/tests/data/include
+#include <mul.cuh> // In numba/cuda/tests/doc_examples/ffi/include
+
+extern "C"
+__device__ int saxpy(float *ret, float a, float x, float y)
+{
+    *ret = myadd(mymul(a, x), y);
+    return 0;
+}

numba_cuda/numba/cuda/tests/doc_examples/test_ffi.py

@@ -3,7 +3,7 @@
 
 import unittest
 from numba.cuda.testing import CUDATestCase, skip_on_cudasim
-from numba.tests.support import skip_unless_cffi
+from numba.tests.support import skip_unless_cffi, override_config
 
 
 @skip_unless_cffi
@@ -85,6 +85,53 @@ class TestFFI(CUDATestCase):
         actual = r[()]
         np.testing.assert_allclose(expected, actual)
 
+    def test_ex_extra_includes(self):
+        import numpy as np
+        from numba import cuda, config
+        import os
+
+        basedir = os.path.dirname(os.path.abspath(__file__))
+        mul_dir = os.path.join(basedir, "ffi", "include")
+        saxpy_cu = os.path.join(basedir, "ffi", "saxpy.cu")
+
+        testdir = os.path.dirname(basedir)
+        add_dir = os.path.join(testdir, "data", "include")
+
+        includedir = ":".join([mul_dir, add_dir])
+        with override_config("CUDA_NVRTC_EXTRA_SEARCH_PATHS", includedir):
+            # magictoken.ex_extra_search_paths.begin
+            from numba import config
+
+            includedir = ":".join([mul_dir, add_dir])
+            config.CUDA_NVRTC_EXTRA_SEARCH_PATHS = includedir
+            # magictoken.ex_extra_search_paths.end
+
+            # magictoken.ex_extra_search_paths_kernel.begin
+            sig = "float32(float32, float32, float32)"
+            saxpy = cuda.declare_device("saxpy", sig=sig, link=saxpy_cu)
+
+            @cuda.jit
+            def vector_saxpy(a, x, y, res):
+                i = cuda.grid(1)
+                if i < len(res):
+                    res[i] = saxpy(a, x[i], y[i])
+
+            # magictoken.ex_extra_search_paths_kernel.end
+
+            size = 10_000
+            a = 3.0
+            X = np.ones((size,), dtype="float32")
+            Y = np.ones((size,), dtype="float32")
+            R = np.zeros((size,), dtype="float32")
+
+            block_size = 32
+            num_blocks = (size // block_size) + 1
+
+            vector_saxpy[num_blocks, block_size](a, X, Y, R)
+
+            expected = a * X + Y
+            np.testing.assert_equal(R, expected)
+
 
 if __name__ == "__main__":
     unittest.main()

{numba_cuda-0.11.0.dist-info → numba_cuda-0.12.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numba-cuda
-Version: 0.11.0
+Version: 0.12.1
 Summary: CUDA target for Numba
 Author: Anaconda Inc., NVIDIA Corporation
 License: BSD 2-clause

{numba_cuda-0.11.0.dist-info → numba_cuda-0.12.1.dist-info}/RECORD

@@ -1,27 +1,27 @@
 _numba_cuda_redirector.pth,sha256=cmfMMmV0JPh3yEpl4bGeM9AuXiVVMSo6Z_b7RaQL3XE,30
 _numba_cuda_redirector.py,sha256=n_r8MYbu5-vcXMnLJW147k8DnFXXvgb7nPIXnlXwTyQ,2659
-numba_cuda/VERSION,sha256=eV1rx5V00q7AOtnP7EBLuVCDyd0hDmUh4NQZl3LSjUQ,7
+numba_cuda/VERSION,sha256=9u5pvxxLJ6JCJmzLWutKqMgwY0W56-T_czW4yUBFK4E,7
 numba_cuda/__init__.py,sha256=atXeUvJKR3JHcAiCFbXCVOJQUHgB1TulmsqSL_9RT3Q,114
 numba_cuda/_version.py,sha256=nzrrJXi85d18m6SPdsPsetJNClDETkmF1MrEhGLYDBs,734
 numba_cuda/numba/cuda/__init__.py,sha256=3siqMXEKqa9ezQ8RxPC3KMdebUjgJt-EKxxV4CX9818,607
-numba_cuda/numba/cuda/api.py,sha256=XnyTZiAPdLhpFDKefpN59mK-RsM2uMVipQjHRNI0Z5s,17271
+numba_cuda/numba/cuda/api.py,sha256=mkbZBcBfm819kCywQbH8jAvUex2m4pYTcFD-LE-tXsQ,17638
 numba_cuda/numba/cuda/api_util.py,sha256=jK8oUD3zf_D5IX7vbjc3uY_5kmOxwgEqO2m_lDHdWfM,861
 numba_cuda/numba/cuda/args.py,sha256=UlTHTJpwPeCtnW0Bb-Wetm5UO9TPR-PCgIt5ys8b8tQ,1894
-numba_cuda/numba/cuda/cg.py,sha256=azz1sIT_jXQfJEZfDjBeqboJc6Pu_NtrZxfE7D1eQLQ,1484
-numba_cuda/numba/cuda/codegen.py,sha256=N6zwdKah4Pb79TKPFVqTbJWX10MGu_7E2YR6K77OQwE,16451
-numba_cuda/numba/cuda/compiler.py,sha256=jOwiebq5K4eCn745MPNtaXMkLyyTBef65fpZ5sqKbEM,25548
+numba_cuda/numba/cuda/bf16.py,sha256=PXuitxHhPMjnti3g9IOSoL90ofGgVRcDfqFg7AqCXpU,1778
+numba_cuda/numba/cuda/cg.py,sha256=n-sBj05ut6U_GgFIq-PTCjPad4nXWAc0GVg_J9xD_Pc,1602
+numba_cuda/numba/cuda/codegen.py,sha256=vZtLahHSLYzRpQ3GSbmMm5qYp4FS5mAlzGgSgJbaoz0,16709
+numba_cuda/numba/cuda/compiler.py,sha256=aZwEVP8KXCIyccSw4vJyG6Qaai9oXsFuBAo_Ghwwai4,25607
 numba_cuda/numba/cuda/cpp_function_wrappers.cu,sha256=8lUPmU6FURxphzEqkPLZRPYBCEK_wmDtHq2voPkckfs,950
-numba_cuda/numba/cuda/cuda_bf16.py,sha256=RfnWMV2_zSAW9FLN4JqfW6GfmWR8ZVO16e9Bw3jZnto,152203
 numba_cuda/numba/cuda/cuda_paths.py,sha256=kMIJ_1yV2qtcKEM5rCgSDJ3Gz7bgxbfAWh54E5cDndg,15872
-numba_cuda/numba/cuda/cudadecl.py,sha256=0JTTkA0yZljsa0EFlebmsAibvkf5OhHaeOCsfaUwjU0,22822
+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
-numba_cuda/numba/cuda/debuginfo.py,sha256=tWlRAC1-AsSQp0pG9kXQY9tlVdZPA-nDUJsrvru4eaM,4504
-numba_cuda/numba/cuda/decorators.py,sha256=T2nFq5nCPmeyJb-RyuVUUaV4qHYTeYm3Zj-o8cMewMc,9483
+numba_cuda/numba/cuda/debuginfo.py,sha256=5tCw_IEeZfoD6CtFpA_yUGdrq25Q9mFjfxxrudH_VFg,5476
+numba_cuda/numba/cuda/decorators.py,sha256=bR8yOAIC68lhm8mSMU-DUt1qFrEogbmSAtzAI4MoToc,9608
 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=1QzWn5IO_v27-NZlSjDbCIT_M5vtPuBadlwjliY2y0E,43169
+numba_cuda/numba/cuda/dispatcher.py,sha256=cLXD2pnsU7k-bN5clfjuWqifFCr7LfECKtK7YeeHwis,43162
 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/initialize.py,sha256=0SnpjccQEYiWITIyfAJx833H1yhYFFDY42EpnwYyMn8,487
@@ -41,17 +41,18 @@ numba_cuda/numba/cuda/random.py,sha256=V30KaFdkuDyjxoP14awz-KkY3lRIXqIZuuH27UotI
 numba_cuda/numba/cuda/reshape_funcs.cu,sha256=frw1uoeMSYlkPC38LiKE8Tz2P70X2e4UZGyLKkaPzho,4326
 numba_cuda/numba/cuda/simulator_init.py,sha256=Hvzty6NJp1SeKspyb-b887xpeNLMMI0x9aPmV--X77E,450
 numba_cuda/numba/cuda/stubs.py,sha256=JMs4Xg8IHlAq5L6SBYWcYNzXfJGM6v0lZCQaOb5x9CQ,23014
-numba_cuda/numba/cuda/target.py,sha256=mSMnS-bSsC8_4KqkAsa1Byi2mO8jPJdKW3m31qxsxUE,12520
+numba_cuda/numba/cuda/target.py,sha256=ymYBdkt7iNK_PJCfyqupKpcSj7j-UQzkWIq3KjoLBD8,12963
 numba_cuda/numba/cuda/testing.py,sha256=OR37AuDdzg7vLG4G_4s2uRAkNTScZc-BzHmTMJYuxhQ,6827
 numba_cuda/numba/cuda/types.py,sha256=hC1MUvgUwy-SLgbzFzXwssJzPR8BxQwqUcjwGJFzVac,1317
 numba_cuda/numba/cuda/ufuncs.py,sha256=AJifQgapyv62fdJeMm939R1I5TvIRmaA8dJ83Jy8DCw,23559
 numba_cuda/numba/cuda/utils.py,sha256=VRphC0PLr8Klq3D1FMONu4aRdVO23HOCBg4bxnsqmfc,785
 numba_cuda/numba/cuda/vector_types.py,sha256=FlzOKufhvBnZ-VC-liA7y9is8BV-uj0fD-En_vP6zl0,6783
 numba_cuda/numba/cuda/vectorizers.py,sha256=nEfQxjSA4oCX8ZzvoqjDRygDfwzxFVDXtnjx-K1aPqA,8387
+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=6tF2TYnmjMbKk2fho1ONoD_QsRD9QVTT2kHP7x1u1J0,31556
 numba_cuda/numba/cuda/cudadrv/devices.py,sha256=k87EDIRhj1ncM9PxJCjZGPFfEks99vzmHlTc55GK5X0,8062
-numba_cuda/numba/cuda/cudadrv/driver.py,sha256=dcrti-XDhjdfTiF5HrrGCYtIZkknN_6UugxSA2f-JoE,118994
+numba_cuda/numba/cuda/cudadrv/driver.py,sha256=63NDga5RLrk6JEiHW1aJDubqCbbHA5uumK3mSYy7SEY,119091
 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
@@ -60,7 +61,7 @@ numba_cuda/numba/cuda/cudadrv/libs.py,sha256=qjknQxYXd2ucwDLQqzhWC_srNg6FnwvcVHI
 numba_cuda/numba/cuda/cudadrv/linkable_code.py,sha256=IZ13laEG_altDQyi9HkdMcwW-YYEIn2erqz6AnYsqHg,2808
 numba_cuda/numba/cuda/cudadrv/mappings.py,sha256=9uEs1KepeVGRbEpVhLjtxSsvZpZsbrHnPywmx--y88A,804
 numba_cuda/numba/cuda/cudadrv/ndarray.py,sha256=HtULWWFyDlgqvrH5459yyPTvU4UbUo2DSdtcNfvbH00,473
-numba_cuda/numba/cuda/cudadrv/nvrtc.py,sha256=6xtAR1af5BsBkDMJcQsTIUFFO02wwpfLClNIsh5L33Y,14324
+numba_cuda/numba/cuda/cudadrv/nvrtc.py,sha256=pDc5YsxOMdMbLnUKm1st2FVmFPRU-Mhlpd9mau9KZ-0,14976
 numba_cuda/numba/cuda/cudadrv/nvvm.py,sha256=7tTy6-VEbMBpDUmuSMnUwqPFfBndTh3aPq_n7nxhEA0,26344
 numba_cuda/numba/cuda/cudadrv/rtapi.py,sha256=J6PRGGK07XSLRzgCw5xs8VU5xVoqavvhojk1mxiQsi4,226
 numba_cuda/numba/cuda/cudadrv/runtime.py,sha256=CFumwg4iblWap_E7l7GM_hMYz1PsbH81-N0tZwFFooA,4372
@@ -132,8 +133,9 @@ numba_cuda/numba/cuda/tests/cudadrv/test_runtime.py,sha256=4CcxftJN4S3whgnngOgrZ
 numba_cuda/numba/cuda/tests/cudadrv/test_select_device.py,sha256=saAWvGuAYJ4ToT9qQjvB254EeBfduVqy7VQVRqeVo0Y,987
 numba_cuda/numba/cuda/tests/cudadrv/test_streams.py,sha256=rrQEA8iawR6UyKnK2MdI5X9GnuCWPUNpoMOEVXEd_u0,4196
 numba_cuda/numba/cuda/tests/cudapy/__init__.py,sha256=43EXdiXXRBd6yIcVGMrU9F_EJCD9Uw3mzOP3SB53AEE,260
-numba_cuda/numba/cuda/tests/cudapy/cache_usecases.py,sha256=FnvjeqTZ-YBmroHctPrHgMHxnJ-HiT9KI79aHTej5G8,5840
+numba_cuda/numba/cuda/tests/cudapy/cache_usecases.py,sha256=3mYDpLS1FUBt7rerACFGR7HxsCJtHSLh_AYqxFEqRd0,5658
 numba_cuda/numba/cuda/tests/cudapy/cache_with_cpu_usecases.py,sha256=9CbjosLNPN5IzrD-15sD_4B0BMmjo02Y7faZiS82cyk,1143
+numba_cuda/numba/cuda/tests/cudapy/cg_cache_usecases.py,sha256=w9c0OXN6Mxb0Un0GxF-ndcq39dn5nMC8xaGzESZB40I,682
 numba_cuda/numba/cuda/tests/cudapy/extensions_usecases.py,sha256=2i_xq4B1t1tctr6ZrWA29ZHkmQlD_vCSewhr-AT9tMc,1651
 numba_cuda/numba/cuda/tests/cudapy/jitlink.ptx,sha256=PKVafUhDH1SKRWXkt4N3v8SDMh4RyDFiJM-CMksa5uc,519
 numba_cuda/numba/cuda/tests/cudapy/recursion_usecases.py,sha256=wrWx8AeRhBHM74iYPKKrZqiyWrYCtQU3J-g3Zv7JmoY,1782
@@ -143,10 +145,11 @@ numba_cuda/numba/cuda/tests/cudapy/test_array_alignment.py,sha256=JDKbbRieNE0C3w
 numba_cuda/numba/cuda/tests/cudapy/test_array_args.py,sha256=iiFrt5Yn7gfheAGOYG2VBeWeuW3JlBhRLXNfSz4cHAA,4982
 numba_cuda/numba/cuda/tests/cudapy/test_array_methods.py,sha256=SWa1MvpwG07yBkrFIUeM9pm3BIwUbhttMNBdUW-CpSM,969
 numba_cuda/numba/cuda/tests/cudapy/test_atomics.py,sha256=agsfUN3WOoh6ICAECtuMuxZNcKq5ivK30Ew3h_m76m0,57689
-numba_cuda/numba/cuda/tests/cudapy/test_bfloat16_bindings.py,sha256=NYLa_e60NYc63X7japCAsjUS84lXn92k4_S_E6-sEX4,6779
+numba_cuda/numba/cuda/tests/cudapy/test_bfloat16.py,sha256=DdP7WlHev8R5DdY6DEEgOF45ljh8LwKeqmkvGLjNC7E,1444
+numba_cuda/numba/cuda/tests/cudapy/test_bfloat16_bindings.py,sha256=wNP0NNtqVgaekY9fXp_H4LpPNLX-rDu9gp-_-e965Lg,7420
 numba_cuda/numba/cuda/tests/cudapy/test_blackscholes.py,sha256=0_wr6MSeHh0QVzPeH8SB7j0Nv_RrPAK01hNoQ_dGT5I,4417
 numba_cuda/numba/cuda/tests/cudapy/test_boolean.py,sha256=j4mIOv4rJTLjJzpKk1O9UFLT41_iOQRtwsmteXdKZ-M,547
-numba_cuda/numba/cuda/tests/cudapy/test_caching.py,sha256=qbNisdxvoErKlDkD5dw7IkdJhfcQUpIdfHX11UzGBOo,18990
+numba_cuda/numba/cuda/tests/cudapy/test_caching.py,sha256=obUSTJSP2Lh-YNElq8PZpVnRJOeq-uqV_VyLHtsXwAw,18427
 numba_cuda/numba/cuda/tests/cudapy/test_casting.py,sha256=3LaN3ZsSuOZXAZXCV85wYyhh0ih7JqABnjGTa7Y2YBE,8748
 numba_cuda/numba/cuda/tests/cudapy/test_cffi.py,sha256=tC7ZCA4dkzehS33iz2l35rX6OxE3BTQd9ivV4r74YXs,926
 numba_cuda/numba/cuda/tests/cudapy/test_compiler.py,sha256=OkCavTZAAcdffdUBYGEmlP_BN7zAH-rWlhr-LqSUUs8,10997
@@ -154,12 +157,12 @@ numba_cuda/numba/cuda/tests/cudapy/test_complex.py,sha256=hmAcyZim46yueXZDqDSJYq
 numba_cuda/numba/cuda/tests/cudapy/test_complex_kernel.py,sha256=KIuXQ0ihgQQXM-eH7s3xAxhKe35YL1qDTHCVTWA4ut8,497
 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=x2sOmq6ACN6r00LpPVjwOclOL_OsagJqP5l_9NsAl2U,4984
+numba_cuda/numba/cuda/tests/cudapy/test_cooperative_groups.py,sha256=kkrK5Mo9E8nNH3PYfQAEel0hY7CXZNsn88BAo7heX9g,5818
 numba_cuda/numba/cuda/tests/cudapy/test_cuda_array_interface.py,sha256=RXCNHAZM35sbUf3Gi-x2E8-a6BmhFb2rhQkBOeiS_fo,15757
 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
-numba_cuda/numba/cuda/tests/cudapy/test_debuginfo.py,sha256=796d8Oa1ZV2mZ9LTcwR3g6_j5sjSBk7kZEHYMOXPBfU,12606
+numba_cuda/numba/cuda/tests/cudapy/test_debuginfo.py,sha256=AE8D4U4dAv4nYP9oatDwROW6knpJ0-iggP4BaHymo6g,13170
 numba_cuda/numba/cuda/tests/cudapy/test_device_func.py,sha256=LNGBZfqFGUtVVQeC6FcHo8T3DbG-j6AjeBwJmwp9HH4,13157
 numba_cuda/numba/cuda/tests/cudapy/test_dispatcher.py,sha256=Oc6CdI1j9Ad_wklHdIYSMytrzUpzK6oXD0BGe45sTwg,26636
 numba_cuda/numba/cuda/tests/cudapy/test_enums.py,sha256=Yxac6S5P6C8GN0kMwieL3dQb1uogOVZQEx969B0AMpM,4533
@@ -226,15 +229,17 @@ numba_cuda/numba/cuda/tests/cudasim/__init__.py,sha256=GdfSq6pRVSOQwmgNi7ZFQ5l0y
 numba_cuda/numba/cuda/tests/cudasim/support.py,sha256=JjRrfrrLKS0V5p6GX6ibs6QTuFb1NanKfBQSgbLeiHs,114
 numba_cuda/numba/cuda/tests/cudasim/test_cudasim_issues.py,sha256=-GJCl2c063Ig6EUB8w5L_0GcmXzTLatGe_ddEzdnbgc,3177
 numba_cuda/numba/cuda/tests/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+numba_cuda/numba/cuda/tests/data/cta_barrier.cu,sha256=jJ3lzhbGr6WOHb56_fPaFg8j851ZwCpz8V4du-eyWbA,576
 numba_cuda/numba/cuda/tests/data/cuda_include.cu,sha256=1wj5Of86-kP0hxK5Gr6AhapuyTiiWWJAoFbCuCpyKfA,294
 numba_cuda/numba/cuda/tests/data/error.cu,sha256=5m65RDHgh39d0bIW6Dvj0xh9ffhKH1iILeCCR4p2ReI,138
 numba_cuda/numba/cuda/tests/data/jitlink.cu,sha256=A41S_002h_s4hEghJusT368JXX6H3bSMp3mC_6DX9Us,539
 numba_cuda/numba/cuda/tests/data/jitlink.ptx,sha256=KJZkTuc1u5xUAC7j5BrmrHkgRWr_ncZwN3ayVKa69dw,894
 numba_cuda/numba/cuda/tests/data/warn.cu,sha256=6L-qsXJIxAr_n3hVMAz_EZ5j0skcJAfgzuJfDEISG_I,172
+numba_cuda/numba/cuda/tests/data/include/add.cuh,sha256=yv61Ilqge_kjj-_BPO5YWAx3sqJD73gEh66gxYwE8wc,107
 numba_cuda/numba/cuda/tests/doc_examples/__init__.py,sha256=GdfSq6pRVSOQwmgNi7ZFQ5l0yg4-2gNar_0Rz0buUpM,157
 numba_cuda/numba/cuda/tests/doc_examples/test_cg.py,sha256=VLWd5_v744Z5QKa4i3JVDLUwA1sxJFQzV5cRG6EkyOI,2888
 numba_cuda/numba/cuda/tests/doc_examples/test_cpu_gpu_compat.py,sha256=I4hWDF4DzTTtt3-XmQsP5RzPAO_pWUGsKjVO0hhPOCM,2251
-numba_cuda/numba/cuda/tests/doc_examples/test_ffi.py,sha256=FUMfeKhSwCjrmHsawmSzwkIoHjqmKYQFhI1efN0SpvE,2743
+numba_cuda/numba/cuda/tests/doc_examples/test_ffi.py,sha256=AtjAzFgZWm1nwOokQyO7D8NVMYGd1QDD3EaUT_RQruQ,4403
 numba_cuda/numba/cuda/tests/doc_examples/test_laplace.py,sha256=4C_drWYNZq_qGIt-N0fJ9r8DZBaJdO_5h7mxRZ6RcO8,5133
 numba_cuda/numba/cuda/tests/doc_examples/test_matmul.py,sha256=cLIN3ejI-3cbW0xxgWjm7EsSlmluGB8stDKOqZN8EUo,6138
 numba_cuda/numba/cuda/tests/doc_examples/test_montecarlo.py,sha256=IoS2pbEby3YxLKpnS6_IGlHaPgvOEL8lJtKOf2eaGLM,3493
@@ -245,6 +250,8 @@ numba_cuda/numba/cuda/tests/doc_examples/test_ufunc.py,sha256=UXwXjL9ybg0OuYOFKn
 numba_cuda/numba/cuda/tests/doc_examples/test_vecadd.py,sha256=CvExzNABd2Qk5EJqDq1TjxMNz4zw_QIjynzh1O52HU0,2032
 numba_cuda/numba/cuda/tests/doc_examples/ffi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 numba_cuda/numba/cuda/tests/doc_examples/ffi/functions.cu,sha256=mRZEyCfZbq4ACTN3sj1236XmTpj1d0IxZ4QTMbI3g_E,877
+numba_cuda/numba/cuda/tests/doc_examples/ffi/saxpy.cu,sha256=xJ6D3RkxlU75Txp1_xsJKBuspDnqvr7-1L8Pb_BdMcU,246
+numba_cuda/numba/cuda/tests/doc_examples/ffi/include/mul.cuh,sha256=LfYU4QwoAlAXKysg_pV9k0DSHW8oVg21DTmGK8BuZO8,113
 numba_cuda/numba/cuda/tests/nocuda/__init__.py,sha256=43EXdiXXRBd6yIcVGMrU9F_EJCD9Uw3mzOP3SB53AEE,260
 numba_cuda/numba/cuda/tests/nocuda/test_dummyarray.py,sha256=4WbuBaowiv4_3hE8lRuxgAQwnR2r3WGVNWx85M3fRUI,13399
 numba_cuda/numba/cuda/tests/nocuda/test_function_resolution.py,sha256=bnv8HbWQR0f9x8z9XdBykDCu89KaFWP0LU4OohSwHv4,1496
@@ -259,8 +266,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.11.0.dist-info/licenses/LICENSE,sha256=eHeYE-XjASmwbxfsP5AImgfzRwZurZGqH1f6OFwJ4io,1326
-numba_cuda-0.11.0.dist-info/METADATA,sha256=5fGOJBTyB10OIPwAfyn2W7vYjFM5SuRNJWPacBD_rgA,1859
-numba_cuda-0.11.0.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-numba_cuda-0.11.0.dist-info/top_level.txt,sha256=C50SsH-8tXDmt7I0Y3nlJYhS5s6pqWflCPdobe9vx2M,11
-numba_cuda-0.11.0.dist-info/RECORD,,
+numba_cuda-0.12.1.dist-info/licenses/LICENSE,sha256=eHeYE-XjASmwbxfsP5AImgfzRwZurZGqH1f6OFwJ4io,1326
+numba_cuda-0.12.1.dist-info/METADATA,sha256=H6JW6cSrhykHqICS50fIbGkrZ6SRgh_cTC3hTC2-XvQ,1859
+numba_cuda-0.12.1.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+numba_cuda-0.12.1.dist-info/top_level.txt,sha256=C50SsH-8tXDmt7I0Y3nlJYhS5s6pqWflCPdobe9vx2M,11
+numba_cuda-0.12.1.dist-info/RECORD,,

{numba_cuda-0.11.0.dist-info → numba_cuda-0.12.1.dist-info}/WHEEL

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