numba-cuda 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

numba_cuda/VERSION

@@ -1 +1 @@
-0.5.0
+0.7.0

numba_cuda/numba/cuda/compiler.py

@@ -1,14 +1,17 @@
 from llvmlite import ir
 from numba.core.typing.templates import ConcreteTemplate
+from numba.core import ir as numba_ir
 from numba.core import (cgutils, types, typing, funcdesc, config, compiler,
                         sigutils, utils)
 from numba.core.compiler import (sanitize_compile_result_entries, CompilerBase,
                                  DefaultPassBuilder, Flags, Option,
                                  CompileResult)
 from numba.core.compiler_lock import global_compiler_lock
-from numba.core.compiler_machinery import (LoweringPass,
+from numba.core.compiler_machinery import (FunctionPass, LoweringPass,
                                            PassManager, register_pass)
+from numba.core.interpreter import Interpreter
 from numba.core.errors import NumbaInvalidConfigWarning
+from numba.core.untyped_passes import TranslateByteCode
 from numba.core.typed_passes import (IRLegalization, NativeLowering,
                                      AnnotateTypes)
 from warnings import warn
@@ -143,13 +146,74 @@ class CreateLibrary(LoweringPass):
         return True
 
 
+class CUDABytecodeInterpreter(Interpreter):
+    # Based on the superclass implementation, but names the resulting variable
+    # "$bool<N>" instead of "bool<N>" - see Numba PR #9888:
+    # https://github.com/numba/numba/pull/9888
+    #
+    # This can be removed once that PR is available in an upstream Numba
+    # release.
+    def _op_JUMP_IF(self, inst, pred, iftrue):
+        brs = {
+            True: inst.get_jump_target(),
+            False: inst.next,
+        }
+        truebr = brs[iftrue]
+        falsebr = brs[not iftrue]
+
+        name = "$bool%s" % (inst.offset)
+        gv_fn = numba_ir.Global("bool", bool, loc=self.loc)
+        self.store(value=gv_fn, name=name)
+
+        callres = numba_ir.Expr.call(self.get(name), (self.get(pred),), (),
+                                     loc=self.loc)
+
+        pname = "$%spred" % (inst.offset)
+        predicate = self.store(value=callres, name=pname)
+        bra = numba_ir.Branch(cond=predicate, truebr=truebr, falsebr=falsebr,
+                              loc=self.loc)
+        self.current_block.append(bra)
+
+
+@register_pass(mutates_CFG=True, analysis_only=False)
+class CUDATranslateBytecode(FunctionPass):
+    _name = "cuda_translate_bytecode"
+
+    def __init__(self):
+        FunctionPass.__init__(self)
+
+    def run_pass(self, state):
+        func_id = state['func_id']
+        bc = state['bc']
+        interp = CUDABytecodeInterpreter(func_id)
+        func_ir = interp.interpret(bc)
+        state['func_ir'] = func_ir
+        return True
+
+
 class CUDACompiler(CompilerBase):
     def define_pipelines(self):
         dpb = DefaultPassBuilder
         pm = PassManager('cuda')
 
         untyped_passes = dpb.define_untyped_pipeline(self.state)
-        pm.passes.extend(untyped_passes.passes)
+
+        # Rather than replicating the whole untyped passes definition in
+        # numba-cuda, it seems cleaner to take the pass list and replace the
+        # TranslateBytecode pass with our own.
+
+        def replace_translate_pass(implementation, description):
+            if implementation is TranslateByteCode:
+                return (CUDATranslateBytecode, description)
+            else:
+                return (implementation, description)
+
+        cuda_untyped_passes = [
+            replace_translate_pass(implementation, description)
+            for implementation, description in untyped_passes.passes
+        ]
+
+        pm.passes.extend(cuda_untyped_passes)
 
         typed_passes = dpb.define_typed_pipeline(self.state)
         pm.passes.extend(typed_passes.passes)
@@ -352,6 +416,20 @@ def kernel_fixup(kernel, debug):
     kernel.return_value = ir.ReturnValue(kernel, ir.VoidType())
     kernel.args = kernel.args[1:]
 
+    # If debug metadata is present, remove the return value from it
+
+    if kernel_metadata := getattr(kernel, 'metadata', None):
+        if dbg_metadata := kernel_metadata.get('dbg', None):
+            for name, value in dbg_metadata.operands:
+                if name == "type":
+                    type_metadata = value
+                    for tm_name, tm_value in type_metadata.operands:
+                        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
 
     nvvm.set_cuda_kernel(kernel)

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/debuginfo.py

@@ -0,0 +1,44 @@
+from llvmlite import ir
+from numba.core import types
+from numba.core.debuginfo import DIBuilder
+from numba.cuda.types import GridGroup
+
+_BYTE_SIZE = 8
+
+
+class CUDADIBuilder(DIBuilder):
+
+    def _var_type(self, lltype, size, datamodel=None):
+        is_bool = False
+        is_grid_group = False
+
+        if isinstance(lltype, ir.IntType):
+            if datamodel is None:
+                if size == 1:
+                    name = str(lltype)
+                    is_bool = True
+            else:
+                name = str(datamodel.fe_type)
+                if isinstance(datamodel.fe_type, types.Boolean):
+                    is_bool = True
+                elif isinstance(datamodel.fe_type, GridGroup):
+                    is_grid_group = True
+
+        if is_bool or is_grid_group:
+            m = self.module
+            bitsize = _BYTE_SIZE * size
+            # Boolean type workaround until upstream Numba is fixed
+            if is_bool:
+                ditok = "DW_ATE_boolean"
+            # GridGroup type should use numba.cuda implementation
+            elif is_grid_group:
+                ditok = "DW_ATE_unsigned"
+
+            return m.add_debug_info('DIBasicType', {
+                'name': name,
+                'size': bitsize,
+                'encoding': ir.DIToken(ditok),
+            })
+
+        # For other cases, use upstream Numba implementation
+        return super()._var_type(lltype, size, datamodel=datamodel)

numba_cuda/numba/cuda/dispatcher.py

@@ -4,8 +4,9 @@ import re
 import sys
 import ctypes
 import functools
+from collections import defaultdict
 
-from numba.core import config, serialize, sigutils, types, typing, utils
+from numba.core import config, ir, serialize, sigutils, types, typing, utils
 from numba.core.caching import Cache, CacheImpl
 from numba.core.compiler_lock import global_compiler_lock
 from numba.core.dispatcher import Dispatcher
@@ -42,6 +43,55 @@ cuda_fp16_math_funcs = ['hsin', 'hcos',
 reshape_funcs = ['nocopy_empty_reshape', 'numba_attempt_nocopy_reshape']
 
 
+def get_cres_link_objects(cres):
+    """Given a compile result, return a set of all linkable code objects that
+    are required for it to be fully linked."""
+
+    link_objects = set()
+
+    # List of calls into declared device functions
+    device_func_calls = [
+        (name, v) for name, v in cres.fndesc.typemap.items() if (
+            isinstance(v, cuda_types.CUDADispatcher)
+        )
+    ]
+
+    # List of tuples with SSA name of calls and corresponding signature
+    call_signatures = [
+        (call.func.name, sig)
+        for call, sig in cres.fndesc.calltypes.items() if (
+            isinstance(call, ir.Expr) and call.op == 'call'
+        )
+    ]
+
+    # Map SSA names to all invoked signatures
+    call_signature_d = defaultdict(list)
+    for name, sig in call_signatures:
+        call_signature_d[name].append(sig)
+
+    # Add the link objects from the current function's callees
+    for name, v in device_func_calls:
+        for sig in call_signature_d.get(name, []):
+            called_cres = v.dispatcher.overloads[sig.args]
+            called_link_objects = get_cres_link_objects(called_cres)
+            link_objects.update(called_link_objects)
+
+    # From this point onwards, we are only interested in ExternFunction
+    # declarations - these are the calls made directly in this function to
+    # them.
+    for name, v in cres.fndesc.typemap.items():
+        if not isinstance(v, Function):
+            continue
+
+        if not isinstance(v.typing_key, ExternFunction):
+            continue
+
+        for obj in v.typing_key.link:
+            link_objects.add(obj)
+
+    return link_objects
+
+
 class _Kernel(serialize.ReduceMixin):
     '''
     CUDA Kernel specialized for a given set of argument types. When called, this
@@ -159,15 +209,8 @@ class _Kernel(serialize.ReduceMixin):
 
         self.maybe_link_nrt(link, tgt_ctx, asm)
 
-        for k, v in cres.fndesc.typemap.items():
-            if not isinstance(v, Function):
-                continue
-
-            if not isinstance(v.typing_key, ExternFunction):
-                continue
-
-            for obj in v.typing_key.link:
-                lib.add_linking_file(obj)
+        for obj in get_cres_link_objects(cres):
+            lib.add_linking_file(obj)
 
         for filepath in link:
             lib.add_linking_file(filepath)
@@ -267,7 +310,11 @@ class _Kernel(serialize.ReduceMixin):
         """
         cufunc = self._codelibrary.get_cufunc()
 
-        if hasattr(self, "target_context") and self.target_context.enable_nrt:
+        if (
+            hasattr(self, "target_context")
+            and self.target_context.enable_nrt
+            and config.CUDA_NRT_STATS
+        ):
             rtsys.ensure_initialized()
             rtsys.set_memsys_to_module(cufunc.module)
             # We don't know which stream the kernel will be launched on, so

numba_cuda/numba/cuda/target.py

@@ -3,8 +3,7 @@ from functools import cached_property
 import llvmlite.binding as ll
 from llvmlite import ir
 
-from numba.core import (cgutils, config, debuginfo, itanium_mangler, types,
-                        typing, utils)
+from numba.core import cgutils, config, itanium_mangler, types, typing
 from numba.core.dispatcher import Dispatcher
 from numba.core.base import BaseContext
 from numba.core.callconv import BaseCallConv, MinimalCallConv
@@ -12,7 +11,8 @@ from numba.core.typing import cmathdecl
 from numba.core import datamodel
 
 from .cudadrv import nvvm
-from numba.cuda import codegen, nvvmutils, ufuncs
+from numba.cuda import codegen, ufuncs
+from numba.cuda.debuginfo import CUDADIBuilder
 from numba.cuda.models import cuda_data_manager
 
 # -----------------------------------------------------------------------------
@@ -80,7 +80,7 @@ class CUDATargetContext(BaseContext):
 
     @property
     def DIBuilder(self):
-        return debuginfo.DIBuilder
+        return CUDADIBuilder
 
     @property
     def enable_boundscheck(self):
@@ -150,136 +150,6 @@ class CUDATargetContext(BaseContext):
         return itanium_mangler.mangle(name, argtypes, abi_tags=abi_tags,
                                       uid=uid)
 
-    def prepare_cuda_kernel(self, codelib, fndesc, debug, lineinfo,
-                            nvvm_options, filename, linenum,
-                            max_registers=None, lto=False):
-        """
-        Adapt a code library ``codelib`` with the numba compiled CUDA kernel
-        with name ``fname`` and arguments ``argtypes`` for NVVM.
-        A new library is created with a wrapper function that can be used as
-        the kernel entry point for the given kernel.
-
-        Returns the new code library and the wrapper function.
-
-        Parameters:
-
-        codelib:       The CodeLibrary containing the device function to wrap
-                       in a kernel call.
-        fndesc:        The FunctionDescriptor of the source function.
-        debug:         Whether to compile with debug.
-        lineinfo:      Whether to emit line info.
-        nvvm_options:  Dict of NVVM options used when compiling the new library.
-        filename:      The source filename that the function is contained in.
-        linenum:       The source line that the function is on.
-        max_registers: The max_registers argument for the code library.
-        """
-        kernel_name = itanium_mangler.prepend_namespace(
-            fndesc.llvm_func_name, ns='cudapy',
-        )
-        library = self.codegen().create_library(f'{codelib.name}_kernel_',
-                                                entry_name=kernel_name,
-                                                nvvm_options=nvvm_options,
-                                                max_registers=max_registers,
-                                                lto=lto
-                                                )
-        library.add_linking_library(codelib)
-        wrapper = self.generate_kernel_wrapper(library, fndesc, kernel_name,
-                                               debug, lineinfo, filename,
-                                               linenum)
-        return library, wrapper
-
-    def generate_kernel_wrapper(self, library, fndesc, kernel_name, debug,
-                                lineinfo, filename, linenum):
-        """
-        Generate the kernel wrapper in the given ``library``.
-        The function being wrapped is described by ``fndesc``.
-        The wrapper function is returned.
-        """
-
-        argtypes = fndesc.argtypes
-        arginfo = self.get_arg_packer(argtypes)
-        argtys = list(arginfo.argument_types)
-        wrapfnty = ir.FunctionType(ir.VoidType(), argtys)
-        wrapper_module = self.create_module("cuda.kernel.wrapper")
-        fnty = ir.FunctionType(ir.IntType(32),
-                               [self.call_conv.get_return_type(types.pyobject)]
-                               + argtys)
-        func = ir.Function(wrapper_module, fnty, fndesc.llvm_func_name)
-
-        prefixed = itanium_mangler.prepend_namespace(func.name, ns='cudapy')
-        wrapfn = ir.Function(wrapper_module, wrapfnty, prefixed)
-        builder = ir.IRBuilder(wrapfn.append_basic_block(''))
-
-        if debug or lineinfo:
-            directives_only = lineinfo and not debug
-            debuginfo = self.DIBuilder(module=wrapper_module,
-                                       filepath=filename,
-                                       cgctx=self,
-                                       directives_only=directives_only)
-            debuginfo.mark_subprogram(
-                wrapfn, kernel_name, fndesc.args, argtypes, linenum,
-            )
-            debuginfo.mark_location(builder, linenum)
-
-        # Define error handling variable
-        def define_error_gv(postfix):
-            name = wrapfn.name + postfix
-            gv = cgutils.add_global_variable(wrapper_module, ir.IntType(32),
-                                             name)
-            gv.initializer = ir.Constant(gv.type.pointee, None)
-            return gv
-
-        gv_exc = define_error_gv("__errcode__")
-        gv_tid = []
-        gv_ctaid = []
-        for i in 'xyz':
-            gv_tid.append(define_error_gv("__tid%s__" % i))
-            gv_ctaid.append(define_error_gv("__ctaid%s__" % i))
-
-        callargs = arginfo.from_arguments(builder, wrapfn.args)
-        status, _ = self.call_conv.call_function(
-            builder, func, types.void, argtypes, callargs)
-
-        if debug:
-            # Check error status
-            with cgutils.if_likely(builder, status.is_ok):
-                builder.ret_void()
-
-            with builder.if_then(builder.not_(status.is_python_exc)):
-                # User exception raised
-                old = ir.Constant(gv_exc.type.pointee, None)
-
-                # Use atomic cmpxchg to prevent rewriting the error status
-                # Only the first error is recorded
-
-                xchg = builder.cmpxchg(gv_exc, old, status.code,
-                                       'monotonic', 'monotonic')
-                changed = builder.extract_value(xchg, 1)
-
-                # If the xchange is successful, save the thread ID.
-                sreg = nvvmutils.SRegBuilder(builder)
-                with builder.if_then(changed):
-                    for dim, ptr, in zip("xyz", gv_tid):
-                        val = sreg.tid(dim)
-                        builder.store(val, ptr)
-
-                    for dim, ptr, in zip("xyz", gv_ctaid):
-                        val = sreg.ctaid(dim)
-                        builder.store(val, ptr)
-
-        builder.ret_void()
-
-        nvvm.set_cuda_kernel(wrapfn)
-        library.add_ir_module(wrapper_module)
-        if debug or lineinfo:
-            debuginfo.finalize()
-        library.finalize()
-
-        if config.DUMP_LLVM:
-            utils.dump_llvm(fndesc, wrapper_module)
-
-        return library.get_function(wrapfn.name)
-
     def make_constant_array(self, builder, aryty, arr):
         """
         Unlike the parent version.  This returns a a pointer in the constant

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
@@ -72,6 +72,57 @@ class TestCudaDebugInfo(CUDATestCase):
         def f(x):
             x[0] = 0
 
+    def test_issue_9888(self):
+        # Compiler created symbol should not be emitted in DILocalVariable
+        # See Numba Issue #9888 https://github.com/numba/numba/pull/9888
+        sig = (types.boolean,)
+
+        @cuda.jit(sig, debug=True, opt=False)
+        def f(cond):
+            if cond:
+                x = 1  # noqa: F841
+            else:
+                x = 0  # noqa: F841
+
+        llvm_ir = f.inspect_llvm(sig)
+        # A varible name starting with "bool" in the debug metadata
+        pat = r'!DILocalVariable\(.*name:\s+\"bool'
+        match = re.compile(pat).search(llvm_ir)
+        self.assertIsNone(match, msg=llvm_ir)
+
+    def test_bool_type(self):
+        sig = (types.int32, types.int32)
+
+        @cuda.jit("void(int32, int32)", debug=True, opt=False)
+        def f(x, y):
+            z = x == y  # noqa: F841
+
+        llvm_ir = f.inspect_llvm(sig)
+
+        # extract the metadata node id from `type` field of DILocalVariable
+        pat = r'!DILocalVariable\(.*name:\s+"z".*type:\s+!(\d+)'
+        match = re.compile(pat).search(llvm_ir)
+        self.assertIsNotNone(match, msg=llvm_ir)
+        mdnode_id = match.group(1)
+
+        # verify the DIBasicType has correct encoding attribute DW_ATE_boolean
+        pat = rf'!{mdnode_id}\s+=\s+!DIBasicType\(.*DW_ATE_boolean'
+        match = re.compile(pat).search(llvm_ir)
+        self.assertIsNotNone(match, msg=llvm_ir)
+
+    def test_grid_group_type(self):
+        sig = (types.int32,)
+
+        @cuda.jit(sig, debug=True, opt=False)
+        def f(x):
+            grid = cuda.cg.this_grid()  # noqa: F841
+
+        llvm_ir = f.inspect_llvm(sig)
+
+        pat = r'!DIBasicType\(.*DW_ATE_unsigned, name: "GridGroup", size: 64'
+        match = re.compile(pat).search(llvm_ir)
+        self.assertIsNotNone(match, msg=llvm_ir)
+
     @unittest.skip("Wrappers no longer exist")
     def test_wrapper_has_debuginfo(self):
         sig = (types.int32[::1],)
@@ -217,6 +268,45 @@ 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):
+        sig = (types.int32, types.int32)
+
+        @cuda.jit("void(int32, int32)", debug=True, opt=False)
+        def f(x, y):
+            z = x + y  # noqa: F841
+
+        llvm_ir = f.inspect_llvm(sig)
+
+        # extract the metadata node id from `types` field of DISubroutineType
+        pat = r'!DISubroutineType\(types:\s+!(\d+)\)'
+        match = re.compile(pat).search(llvm_ir)
+        self.assertIsNotNone(match, msg=llvm_ir)
+        mdnode_id = match.group(1)
+
+        # extract the metadata node ids from the flexible node of types
+        pat = rf'!{mdnode_id}\s+=\s+!{{\s+!(\d+),\s+!(\d+)\s+}}'
+        match = re.compile(pat).search(llvm_ir)
+        self.assertIsNotNone(match, msg=llvm_ir)
+        mdnode_id1 = match.group(1)
+        mdnode_id2 = match.group(2)
+
+        # verify each of the two metadata nodes match expected type
+        pat = rf'!{mdnode_id1}\s+=\s+!DIBasicType\(.*DW_ATE_signed,\s+name:\s+"int32"'  # noqa: E501
+        match = re.compile(pat).search(llvm_ir)
+        self.assertIsNotNone(match, msg=llvm_ir)
+        pat = rf'!{mdnode_id2}\s+=\s+!DIBasicType\(.*DW_ATE_signed,\s+name:\s+"int32"'  # noqa: E501
+        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_device_func.py

@@ -205,6 +205,14 @@ int times2(int *out, int a)
 }
 """)
 
+times3_cu = cuda.CUSource("""
+extern "C" __device__
+int times3(int *out, int a)
+{
+  *out = a * 3;
+  return 0;
+}
+""")
 
 times4_cu = cuda.CUSource("""
 extern "C" __device__
@@ -351,6 +359,123 @@ class TestDeclareDevice(CUDATestCase):
         kernel[1, 1](x, 1)
         np.testing.assert_equal(x[0], 323845807)
 
+    def test_declared_in_called_function(self):
+        times2 = cuda.declare_device('times2', 'int32(int32)', link=times2_cu)
+
+        @cuda.jit
+        def device_func(x):
+            return times2(x)
+
+        @cuda.jit
+        def kernel(r, x):
+            i = cuda.grid(1)
+            if i < len(r):
+                r[i] = device_func(x[i])
+
+        x = np.arange(10, dtype=np.int32)
+        r = np.empty_like(x)
+
+        kernel[1, 32](r, x)
+
+        np.testing.assert_equal(r, x * 2)
+
+    def test_declared_in_called_function_twice(self):
+        times2 = cuda.declare_device('times2', 'int32(int32)', link=times2_cu)
+
+        @cuda.jit
+        def device_func_1(x):
+            return times2(x)
+
+        @cuda.jit
+        def device_func_2(x):
+            return device_func_1(x)
+
+        @cuda.jit
+        def kernel(r, x):
+            i = cuda.grid(1)
+            if i < len(r):
+                r[i] = device_func_2(x[i])
+
+        x = np.arange(10, dtype=np.int32)
+        r = np.empty_like(x)
+
+        kernel[1, 32](r, x)
+
+        np.testing.assert_equal(r, x * 2)
+
+    def test_declared_in_called_function_two_calls(self):
+        times2 = cuda.declare_device('times2', 'int32(int32)', link=times2_cu)
+
+        @cuda.jit
+        def device_func(x):
+            return times2(x)
+
+        @cuda.jit
+        def kernel(r, x):
+            i = cuda.grid(1)
+            if i < len(r):
+                r[i] = device_func(x[i]) + device_func(x[i] + i)
+
+        x = np.arange(10, dtype=np.int32)
+        r = np.empty_like(x)
+
+        kernel[1, 32](r, x)
+
+        np.testing.assert_equal(r, x * 6)
+
+    def test_call_declared_function_twice(self):
+        times2 = cuda.declare_device('times2', 'int32(int32)', link=times2_cu)
+
+        @cuda.jit
+        def kernel(r, x):
+            i = cuda.grid(1)
+            if i < len(r):
+                r[i] = times2(x[i]) + times2(x[i] + i)
+
+        x = np.arange(10, dtype=np.int32)
+        r = np.empty_like(x)
+
+        kernel[1, 32](r, x)
+
+        np.testing.assert_equal(r, x * 6)
+
+    def test_declared_in_called_function_and_parent(self):
+        times2 = cuda.declare_device('times2', 'int32(int32)', link=times2_cu)
+
+        @cuda.jit
+        def device_func(x):
+            return times2(x)
+
+        @cuda.jit
+        def kernel(r, x):
+            i = cuda.grid(1)
+            if i < len(r):
+                r[i] = device_func(x[i]) + times2(x[i])
+
+        x = np.arange(10, dtype=np.int32)
+        r = np.empty_like(x)
+
+        kernel[1, 32](r, x)
+
+        np.testing.assert_equal(r, x * 4)
+
+    def test_call_two_different_declared_functions(self):
+        times2 = cuda.declare_device('times2', 'int32(int32)', link=times2_cu)
+        times3 = cuda.declare_device('times3', 'int32(int32)', link=times3_cu)
+
+        @cuda.jit
+        def kernel(r, x):
+            i = cuda.grid(1)
+            if i < len(r):
+                r[i] = times2(x[i]) + times3(x[i])
+
+        x = np.arange(10, dtype=np.int32)
+        r = np.empty_like(x)
+
+        kernel[1, 32](r, x)
+
+        np.testing.assert_equal(r, x * 5)
+
 
 if __name__ == '__main__':
     unittest.main()

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

@@ -171,7 +171,10 @@ class TestNrtStatistics(CUDATestCase):
             arr = cuda_arange(5 * tmp[0]) # noqa: F841
             return None
 
-        with override_config('CUDA_ENABLE_NRT', True):
+        with (
+            override_config('CUDA_ENABLE_NRT', True),
+            override_config('CUDA_NRT_STATS', True)
+        ):
             # Switch on stats
             rtsys.memsys_enable_stats()
             # check the stats are on

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

@@ -18,7 +18,10 @@ class TestNrtRefCt(EnableNRTStatsMixin, CUDATestCase):
         super(TestNrtRefCt, self).tearDown()
 
     def run(self, result=None):
-        with override_config("CUDA_ENABLE_NRT", True):
+        with (
+            override_config("CUDA_ENABLE_NRT", True),
+            override_config('CUDA_NRT_STATS', True)
+        ):
             super(TestNrtRefCt, self).run(result)
 
     def test_no_return(self):

{numba_cuda-0.5.0.dist-info → numba_cuda-0.7.0.dist-info}/METADATA

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

{numba_cuda-0.5.0.dist-info → numba_cuda-0.7.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=oK1QZAE5pST4ZZEVcUW_HUZ06pwGW_6iFVjw97BEMMg,6
+numba_cuda/VERSION,sha256=ln2a-xATRmZxZvLnboGRC8GQSI19QdUMoAcunZLwDjI,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=FHiDD_9ovsleJrRYprmiVl5QOBm0TDQFgDwcbwDnURk,21386
+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
@@ -17,11 +17,12 @@ numba_cuda/numba/cuda/cuda_paths.py,sha256=C0gA72QLWUMfvXkFpw1WqqaFqfsQ7HM72hQVX
 numba_cuda/numba/cuda/cudadecl.py,sha256=6h_Je6cXmfr4VjBowkr-OOGlsXei-QqGlcjU4Yv-m-4,23438
 numba_cuda/numba/cuda/cudaimpl.py,sha256=0oHjDwBC4JmfpwS1Fsn1bm5YWVru5vZvvnO414P4TS0,38840
 numba_cuda/numba/cuda/cudamath.py,sha256=EFNtdzEytAZuwijdRoFGzVKCeal76UzzaNy7wUFQx8I,3978
+numba_cuda/numba/cuda/debuginfo.py,sha256=lMIs7UAOfkqUvD9sx-nNEY8qP9DhWF9X38xnW3yo_Qc,1433
 numba_cuda/numba/cuda/decorators.py,sha256=MqmbEXVVgIV1G_feYtccKBRTDL0VALWf0LjbrVfJo4s,8041
 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=weI2KSXt51XOpsUF1k5MGAlo_2cc8b3qF5ivVnit2M0,42833
+numba_cuda/numba/cuda/dispatcher.py,sha256=j2nAjlqNAIAoQVCQ4ZQD--hQDsnFLXedlvaXdCMNKEc,44354
 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
@@ -39,7 +40,7 @@ numba_cuda/numba/cuda/random.py,sha256=khX8iDdde_RTUPWhAqrxZacHRQAorFr7BokPuxRWz
 numba_cuda/numba/cuda/reshape_funcs.cu,sha256=H5UAa-VAvoxW9SQwJO88ZrDXC64nWALW3Ch4cHAAqO4,4325
 numba_cuda/numba/cuda/simulator_init.py,sha256=W_bPRtmPGOQVuiprbgt7ENnnnELv_LPCeLDIsfsvFZ8,460
 numba_cuda/numba/cuda/stubs.py,sha256=W3tozv4ganMnfbdFqyPjgQXYeX8GQhwx_xXgv8jk6iM,22270
-numba_cuda/numba/cuda/target.py,sha256=hBflzmxCGlmTugWT1sYhZj9f4HkQAMK2RQ9lO85pMW4,17052
+numba_cuda/numba/cuda/target.py,sha256=MWpdHs2K17Lus4e318FNbR533q24MhovGS6Q1ob9x_4,11354
 numba_cuda/numba/cuda/testing.py,sha256=tG1FBm_gqW4esDxCaecMvCRKvwYEg7Yu2Q60ARNnes0,6873
 numba_cuda/numba/cuda/types.py,sha256=WVfjcly_VUpG9FfKueiEPzZm2NV8Hg0XAFg3bNzPdVc,1314
 numba_cuda/numba/cuda/ufuncs.py,sha256=txw27IxG80W1Yo7e-XwL2AMcQo0fMnxMjBIMy-n5pCo,23317
@@ -59,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
@@ -110,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
@@ -145,8 +146,8 @@ 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=8Tm1iD2x1BRryB1QY6qp6tdjJCE6Tx9p0LzcYwiExIU,7922
-numba_cuda/numba/cuda/tests/cudapy/test_device_func.py,sha256=2EIJjaCGnHDAjpN2t5g2LNbqfhMxYTC51rT5baKA5mc,9988
+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
 numba_cuda/numba/cuda/tests/cudapy/test_errors.py,sha256=jwHbNb2Ro5pbGOPFetmUhI-vG4s36OKCqMJ-lgWxHMY,2620
@@ -238,14 +239,14 @@ numba_cuda/numba/cuda/tests/nocuda/test_library_lookup.py,sha256=7kJOPHEcrjy_kTA
 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=b3rtK018qslhUU5UsAAa3s-mjlnlfxAwTJmARTVD2j4,7650
-numba_cuda/numba/cuda/tests/nrt/test_nrt_refct.py,sha256=Wq46oICum9IXnbQ97vV8V7g-3U01PLQEQbaGSNdRuMg,3163
+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/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.5.0.dist-info/LICENSE,sha256=eHeYE-XjASmwbxfsP5AImgfzRwZurZGqH1f6OFwJ4io,1326
-numba_cuda-0.5.0.dist-info/METADATA,sha256=ZcZ1vxC3J23snRGKPsm6spYu7Y7n9TVLWXaS5jmqgKA,1836
-numba_cuda-0.5.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-numba_cuda-0.5.0.dist-info/top_level.txt,sha256=C50SsH-8tXDmt7I0Y3nlJYhS5s6pqWflCPdobe9vx2M,11
-numba_cuda-0.5.0.dist-info/RECORD,,
+numba_cuda-0.7.0.dist-info/LICENSE,sha256=eHeYE-XjASmwbxfsP5AImgfzRwZurZGqH1f6OFwJ4io,1326
+numba_cuda-0.7.0.dist-info/METADATA,sha256=tq7106PKB0M6Qf-HpEjH_BoUBndW2MA7XsFVAKmbbqc,1836
+numba_cuda-0.7.0.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+numba_cuda-0.7.0.dist-info/top_level.txt,sha256=C50SsH-8tXDmt7I0Y3nlJYhS5s6pqWflCPdobe9vx2M,11
+numba_cuda-0.7.0.dist-info/RECORD,,

{numba_cuda-0.5.0.dist-info → numba_cuda-0.7.0.dist-info}/WHEEL

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