numba-cuda 0.8.1__py3-none-any.whl → 0.10.0__py3-none-any.whl

numba_cuda/numba/cuda/cudamath.py

@@ -136,5 +136,5 @@ class Math_isnan(ConcreteTemplate):
 class Math_modf(ConcreteTemplate):
     cases = [
         signature(types.UniTuple(types.float64, 2), types.float64),
-        signature(types.UniTuple(types.float32, 2), types.float32)
+        signature(types.UniTuple(types.float32, 2), types.float32),
     ]

numba_cuda/numba/cuda/debuginfo.py

@@ -1,5 +1,5 @@
 from llvmlite import ir
-from numba.core import types
+from numba.core import types, cgutils
 from numba.core.debuginfo import DIBuilder
 from numba.cuda.types import GridGroup
 
@@ -7,9 +7,14 @@ _BYTE_SIZE = 8
 
 
 class CUDADIBuilder(DIBuilder):
+    def __init__(self, module, filepath, cgctx, directives_only):
+        super().__init__(module, filepath, cgctx, directives_only)
+        # Cache for local variable metadata type and line deduplication
+        self._vartypelinemap = {}
 
     def _var_type(self, lltype, size, datamodel=None):
         is_bool = False
+        is_int_literal = False
         is_grid_group = False
 
         if isinstance(lltype, ir.IntType):
@@ -21,24 +26,111 @@ class CUDADIBuilder(DIBuilder):
                 name = str(datamodel.fe_type)
                 if isinstance(datamodel.fe_type, types.Boolean):
                     is_bool = True
+                    if isinstance(datamodel.fe_type, types.BooleanLiteral):
+                        name = "bool"
+                elif isinstance(datamodel.fe_type, types.Integer):
+                    if isinstance(datamodel.fe_type, types.IntegerLiteral):
+                        name = f"int{_BYTE_SIZE * size}"
+                        is_int_literal = True
                 elif isinstance(datamodel.fe_type, GridGroup):
                     is_grid_group = True
 
-        if is_bool or is_grid_group:
+        if is_bool or is_int_literal 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"
+            elif is_int_literal:
+                ditok = "DW_ATE_signed"
             # 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),
-            })
+            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)
+
+    def mark_variable(
+        self,
+        builder,
+        allocavalue,
+        name,
+        lltype,
+        size,
+        line,
+        datamodel=None,
+        argidx=None,
+    ):
+        if name.startswith("$") or "." in name:
+            # Do not emit llvm.dbg.declare on user variable alias
+            return
+        else:
+            int_type = (ir.IntType,)
+            real_type = ir.FloatType, ir.DoubleType
+            if isinstance(lltype, int_type + real_type):
+                # Start with scalar variable, swtiching llvm.dbg.declare
+                # to llvm.dbg.value
+                return
+            else:
+                return super().mark_variable(
+                    builder,
+                    allocavalue,
+                    name,
+                    lltype,
+                    size,
+                    line,
+                    datamodel,
+                    argidx,
+                )
+
+    def update_variable(
+        self,
+        builder,
+        value,
+        name,
+        lltype,
+        size,
+        line,
+        datamodel=None,
+        argidx=None,
+    ):
+        m = self.module
+        fnty = ir.FunctionType(ir.VoidType(), [ir.MetaDataType()] * 3)
+        decl = cgutils.get_or_insert_function(m, fnty, "llvm.dbg.value")
+
+        mdtype = self._var_type(lltype, size, datamodel)
+        index = name.find(".")
+        if index >= 0:
+            name = name[:index]
+        # Merge DILocalVariable nodes with same name and type but different
+        # lines. Use the cached [(name, type) -> line] info to deduplicate
+        # metadata. Use the lltype as part of key.
+        key = (name, lltype)
+        if key in self._vartypelinemap:
+            line = self._vartypelinemap[key]
+        else:
+            self._vartypelinemap[key] = line
+        arg_index = 0 if argidx is None else argidx
+        mdlocalvar = m.add_debug_info(
+            "DILocalVariable",
+            {
+                "name": name,
+                "arg": arg_index,
+                "scope": self.subprograms[-1],
+                "file": self.difile,
+                "line": line,
+                "type": mdtype,
+            },
+        )
+        mdexpr = m.add_debug_info("DIExpression", {})
+
+        return builder.call(decl, [value, mdlocalvar, mdexpr])

numba_cuda/numba/cuda/decorators.py

@@ -6,13 +6,24 @@ from numba.cuda.dispatcher import CUDADispatcher
 from numba.cuda.simulator.kernel import FakeCUDAKernel
 
 
-_msg_deprecated_signature_arg = ("Deprecated keyword argument `{0}`. "
-                                 "Signatures should be passed as the first "
-                                 "positional argument.")
-
-
-def jit(func_or_sig=None, device=False, inline=False, link=[], debug=None,
-        opt=None, lineinfo=False, cache=False, **kws):
+_msg_deprecated_signature_arg = (
+    "Deprecated keyword argument `{0}`. "
+    "Signatures should be passed as the first "
+    "positional argument."
+)
+
+
+def jit(
+    func_or_sig=None,
+    device=False,
+    inline="never",
+    link=[],
+    debug=None,
+    opt=None,
+    lineinfo=False,
+    cache=False,
+    **kws,
+):
     """
     JIT compile a Python function for CUDA GPUs.
 
@@ -55,39 +66,52 @@ def jit(func_or_sig=None, device=False, inline=False, link=[], debug=None,
     """
 
     if link and config.ENABLE_CUDASIM:
-        raise NotImplementedError('Cannot link PTX in the simulator')
+        raise NotImplementedError("Cannot link PTX in the simulator")
 
-    if kws.get('boundscheck'):
+    if kws.get("boundscheck"):
         raise NotImplementedError("bounds checking is not supported for CUDA")
 
-    if kws.get('argtypes') is not None:
-        msg = _msg_deprecated_signature_arg.format('argtypes')
+    if kws.get("argtypes") is not None:
+        msg = _msg_deprecated_signature_arg.format("argtypes")
         raise DeprecationError(msg)
-    if kws.get('restype') is not None:
-        msg = _msg_deprecated_signature_arg.format('restype')
+    if kws.get("restype") is not None:
+        msg = _msg_deprecated_signature_arg.format("restype")
         raise DeprecationError(msg)
-    if kws.get('bind') is not None:
-        msg = _msg_deprecated_signature_arg.format('bind')
+    if kws.get("bind") is not None:
+        msg = _msg_deprecated_signature_arg.format("bind")
         raise DeprecationError(msg)
 
+    if isinstance(inline, bool):
+        DeprecationWarning(
+            "Passing bool to inline argument is deprecated, please refer to "
+            "Numba's documentation on inlining: "
+            "https://numba.readthedocs.io/en/stable/developer/inlining.html"
+        )
+
+        inline = "always" if inline else "never"
+
     debug = config.CUDA_DEBUGINFO_DEFAULT if debug is None else debug
     opt = (config.OPT != 0) if opt is None else opt
-    fastmath = kws.get('fastmath', False)
-    extensions = kws.get('extensions', [])
+    fastmath = kws.get("fastmath", False)
+    extensions = kws.get("extensions", [])
 
     if debug and opt:
-        msg = ("debug=True with opt=True "
-               "is not supported by CUDA. This may result in a crash"
-               " - set debug=False or opt=False.")
+        msg = (
+            "debug=True with opt=True "
+            "is not supported by CUDA. This may result in a crash"
+            " - set debug=False or opt=False."
+        )
         warn(NumbaInvalidConfigWarning(msg))
 
     if debug and lineinfo:
-        msg = ("debug and lineinfo are mutually exclusive. Use debug to get "
-               "full debug info (this disables some optimizations), or "
-               "lineinfo for line info only with code generation unaffected.")
+        msg = (
+            "debug and lineinfo are mutually exclusive. Use debug to get "
+            "full debug info (this disables some optimizations), or "
+            "lineinfo for line info only with code generation unaffected."
+        )
         warn(NumbaInvalidConfigWarning(msg))
 
-    if device and kws.get('link'):
+    if device and kws.get("link"):
         raise ValueError("link keyword invalid for device function")
 
     if sigutils.is_signature(func_or_sig):
@@ -101,19 +125,22 @@ def jit(func_or_sig=None, device=False, inline=False, link=[], debug=None,
 
     if signatures is not None:
         if config.ENABLE_CUDASIM:
+
             def jitwrapper(func):
                 return FakeCUDAKernel(func, device=device, fastmath=fastmath)
+
             return jitwrapper
 
         def _jit(func):
             targetoptions = kws.copy()
-            targetoptions['debug'] = debug
-            targetoptions['lineinfo'] = lineinfo
-            targetoptions['link'] = link
-            targetoptions['opt'] = opt
-            targetoptions['fastmath'] = fastmath
-            targetoptions['device'] = device
-            targetoptions['extensions'] = extensions
+            targetoptions["debug"] = debug
+            targetoptions["lineinfo"] = lineinfo
+            targetoptions["link"] = link
+            targetoptions["opt"] = opt
+            targetoptions["fastmath"] = fastmath
+            targetoptions["device"] = device
+            targetoptions["inline"] = inline
+            targetoptions["extensions"] = extensions
 
             disp = CUDADispatcher(func, targetoptions=targetoptions)
 
@@ -128,6 +155,7 @@ def jit(func_or_sig=None, device=False, inline=False, link=[], debug=None,
 
                 if device:
                     from numba.core import typeinfer
+
                     with typeinfer.register_dispatcher(disp):
                         disp.compile_device(argtypes, restype)
                 else:
@@ -142,29 +170,43 @@ def jit(func_or_sig=None, device=False, inline=False, link=[], debug=None,
     else:
         if func_or_sig is None:
             if config.ENABLE_CUDASIM:
+
                 def autojitwrapper(func):
-                    return FakeCUDAKernel(func, device=device,
-                                          fastmath=fastmath)
+                    return FakeCUDAKernel(
+                        func, device=device, fastmath=fastmath
+                    )
             else:
+
                 def autojitwrapper(func):
-                    return jit(func, device=device, debug=debug, opt=opt,
-                               lineinfo=lineinfo, link=link, cache=cache, **kws)
+                    return jit(
+                        func,
+                        device=device,
+                        inline=inline,
+                        debug=debug,
+                        opt=opt,
+                        lineinfo=lineinfo,
+                        link=link,
+                        cache=cache,
+                        **kws,
+                    )
 
             return autojitwrapper
         # func_or_sig is a function
         else:
             if config.ENABLE_CUDASIM:
-                return FakeCUDAKernel(func_or_sig, device=device,
-                                      fastmath=fastmath)
+                return FakeCUDAKernel(
+                    func_or_sig, device=device, fastmath=fastmath
+                )
             else:
                 targetoptions = kws.copy()
-                targetoptions['debug'] = debug
-                targetoptions['lineinfo'] = lineinfo
-                targetoptions['opt'] = opt
-                targetoptions['link'] = link
-                targetoptions['fastmath'] = fastmath
-                targetoptions['device'] = device
-                targetoptions['extensions'] = extensions
+                targetoptions["debug"] = debug
+                targetoptions["lineinfo"] = lineinfo
+                targetoptions["opt"] = opt
+                targetoptions["link"] = link
+                targetoptions["fastmath"] = fastmath
+                targetoptions["device"] = device
+                targetoptions["inline"] = inline
+                targetoptions["extensions"] = extensions
                 disp = CUDADispatcher(func_or_sig, targetoptions=targetoptions)
 
                 if cache:
@@ -191,7 +233,7 @@ def declare_device(name, sig, link=None):
 
     argtypes, restype = sigutils.normalize_signature(sig)
     if restype is None:
-        msg = 'Return type must be provided for device declarations'
+        msg = "Return type must be provided for device declarations"
         raise TypeError(msg)
 
     return declare_device_function(name, restype, argtypes, link)

numba_cuda/numba/cuda/descriptor.py

@@ -30,4 +30,4 @@ class CUDATarget(TargetDescriptor):
         return self._targetctx
 
 
-cuda_target = CUDATarget('cuda')
+cuda_target = CUDATarget("cuda")

numba_cuda/numba/cuda/device_init.py

@@ -1,21 +1,61 @@
 # Re export
 import sys
 from numba.cuda import cg
-from .stubs import (threadIdx, blockIdx, blockDim, gridDim, laneid, warpsize,
-                    syncwarp, shared, local, const, atomic,
-                    shfl_sync_intrinsic, vote_sync_intrinsic, match_any_sync,
-                    match_all_sync, threadfence_block, threadfence_system,
-                    threadfence, selp, popc, brev, clz, ffs, fma, cbrt,
-                    activemask, lanemask_lt, nanosleep, fp16,
-                    _vector_type_stubs)
-from .intrinsics import (grid, gridsize, syncthreads, syncthreads_and,
-                         syncthreads_count, syncthreads_or)
+from .stubs import (
+    threadIdx,
+    blockIdx,
+    blockDim,
+    gridDim,
+    laneid,
+    warpsize,
+    syncwarp,
+    shared,
+    local,
+    const,
+    atomic,
+    vote_sync_intrinsic,
+    match_any_sync,
+    match_all_sync,
+    threadfence_block,
+    threadfence_system,
+    threadfence,
+    selp,
+    popc,
+    brev,
+    clz,
+    ffs,
+    fma,
+    cbrt,
+    activemask,
+    lanemask_lt,
+    nanosleep,
+    fp16,
+    _vector_type_stubs,
+)
+from .intrinsics import (
+    grid,
+    gridsize,
+    syncthreads,
+    syncthreads_and,
+    syncthreads_count,
+    syncthreads_or,
+    shfl_sync,
+    shfl_up_sync,
+    shfl_down_sync,
+    shfl_xor_sync,
+)
 from .cudadrv.error import CudaSupportError
-from numba.cuda.cudadrv.driver import (BaseCUDAMemoryManager,
-                                       HostOnlyCUDAMemoryManager,
-                                       GetIpcHandleMixin, MemoryPointer,
-                                       MappedMemory, PinnedMemory, MemoryInfo,
-                                       IpcHandle, set_memory_manager)
+from numba.cuda.cudadrv.driver import (
+    BaseCUDAMemoryManager,
+    HostOnlyCUDAMemoryManager,
+    GetIpcHandleMixin,
+    MemoryPointer,
+    MappedMemory,
+    PinnedMemory,
+    MemoryInfo,
+    IpcHandle,
+    set_memory_manager,
+)
 from numba.cuda.cudadrv.runtime import runtime
 from .cudadrv import nvvm
 from numba.cuda import initialize
@@ -26,13 +66,23 @@ from .api import *
 from .api import _auto_device
 from .args import In, Out, InOut
 
-from .intrinsic_wrapper import (all_sync, any_sync, eq_sync, ballot_sync,
-                                shfl_sync, shfl_up_sync, shfl_down_sync,
-                                shfl_xor_sync)
+from .intrinsic_wrapper import (
+    all_sync,
+    any_sync,
+    eq_sync,
+    ballot_sync,
+)
 
 from .kernels import reduction
 from numba.cuda.cudadrv.linkable_code import (
-    Archive, CUSource, Cubin, Fatbin, LinkableCode, LTOIR, Object, PTXSource
+    Archive,
+    CUSource,
+    Cubin,
+    Fatbin,
+    LinkableCode,
+    LTOIR,
+    Object,
+    PTXSource,
 )
 
 reduce = Reduce = reduction.Reduce