numba-cuda 0.0.19__tar.gz → 0.0.20__tar.gz

{numba_cuda-0.0.19 → numba_cuda-0.0.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: numba-cuda
-Version: 0.0.19
+Version: 0.0.20
 Summary: CUDA target for Numba
 Author: Anaconda Inc., NVIDIA Corporation
 License: BSD 2-clause
@@ -13,17 +13,21 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numba>=0.59.1
 
+<div align="center"><img src="docs/source/_static/numba-green-icon-rgb.svg" width="200"/></div>
+
 # Numba CUDA Target
 
-An out-of-tree CUDA target for Numba.
+The CUDA target for Numba. Please visit the [official
+documentation](https://nvidia.github.io/numba-cuda) to get started!
+
 
-This contains an entire copy of Numba's CUDA target (the `numba.cuda` module),
-and a mechanism to ensure the code from this module (`numba_cuda.numba.cuda`) is
-used as the `numba.cuda` module instead of the code from the `numba` package.
+To report issues or file feature requests, please use the [issue
+tracker](https://github.com/NVIDIA/numba-cuda/issues).
 
-This is presently in an early state and is published for testing and feedback.
+To raise questions or initiate discussions, please use the [Numba Discourse
+forum](https://numba.discourse.group).
 
-## Building / testing
+## Building from source
 
 Install as an editable install:
 
@@ -31,7 +35,7 @@ Install as an editable install:
 pip install -e .
 ```
 
-Running tests:
+## Running tests
 
 ```
 python -m numba.runtests numba.cuda.tests

numba_cuda-0.0.20/README.md

@@ -0,0 +1,40 @@
+<div align="center"><img src="docs/source/_static/numba-green-icon-rgb.svg" width="200"/></div>
+
+# Numba CUDA Target
+
+The CUDA target for Numba. Please visit the [official
+documentation](https://nvidia.github.io/numba-cuda) to get started!
+
+
+To report issues or file feature requests, please use the [issue
+tracker](https://github.com/NVIDIA/numba-cuda/issues).
+
+To raise questions or initiate discussions, please use the [Numba Discourse
+forum](https://numba.discourse.group).
+
+## Building from source
+
+Install as an editable install:
+
+```
+pip install -e .
+```
+
+## Running tests
+
+```
+python -m numba.runtests numba.cuda.tests
+```
+
+This should discover the`numba.cuda` module from the `numba_cuda` package. You
+can check where `numba.cuda` files are being located by running
+
+```
+python -c "from numba import cuda; print(cuda.__file__)"
+```
+
+which will show a path like:
+
+```
+<path to numba-cuda repo>/numba_cuda/numba/cuda/__init__.py
+```

numba_cuda-0.0.20/numba_cuda/VERSION

@@ -0,0 +1 @@
+0.0.20

{numba_cuda-0.0.19 → numba_cuda-0.0.20}/numba_cuda/numba/cuda/compiler.py

@@ -1,6 +1,7 @@
 from llvmlite import ir
 from numba.core.typing.templates import ConcreteTemplate
-from numba.core import types, typing, funcdesc, config, compiler, sigutils
+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)
@@ -11,7 +12,10 @@ from numba.core.errors import NumbaInvalidConfigWarning
 from numba.core.typed_passes import (IRLegalization, NativeLowering,
                                      AnnotateTypes)
 from warnings import warn
+from numba.cuda import nvvmutils
 from numba.cuda.api import get_current_device
+from numba.cuda.cudadrv import nvvm
+from numba.cuda.descriptor import cuda_target
 from numba.cuda.target import CUDACABICallConv
 
 
@@ -24,6 +28,15 @@ def _nvvm_options_type(x):
         return x
 
 
+def _optional_int_type(x):
+    if x is None:
+        return None
+
+    else:
+        assert isinstance(x, int)
+        return x
+
+
 class CUDAFlags(Flags):
     nvvm_options = Option(
         type=_nvvm_options_type,
@@ -35,6 +48,16 @@ class CUDAFlags(Flags):
         default=None,
         doc="Compute Capability",
     )
+    max_registers = Option(
+        type=_optional_int_type,
+        default=None,
+        doc="Max registers"
+    )
+    lto = Option(
+        type=bool,
+        default=False,
+        doc="Enable Link-time Optimization"
+    )
 
 
 # The CUDACompileResult (CCR) has a specially-defined entry point equal to its
@@ -109,7 +132,11 @@ class CreateLibrary(LoweringPass):
         codegen = state.targetctx.codegen()
         name = state.func_id.func_qualname
         nvvm_options = state.flags.nvvm_options
-        state.library = codegen.create_library(name, nvvm_options=nvvm_options)
+        max_registers = state.flags.max_registers
+        lto = state.flags.lto
+        state.library = codegen.create_library(name, nvvm_options=nvvm_options,
+                                               max_registers=max_registers,
+                                               lto=lto)
         # Enable object caching upfront so that the library can be serialized.
         state.library.enable_object_caching()
 
@@ -152,7 +179,7 @@ class CUDACompiler(CompilerBase):
 @global_compiler_lock
 def compile_cuda(pyfunc, return_type, args, debug=False, lineinfo=False,
                  inline=False, fastmath=False, nvvm_options=None,
-                 cc=None):
+                 cc=None, max_registers=None, lto=False):
     if cc is None:
         raise ValueError('Compute Capability must be supplied')
 
@@ -189,6 +216,8 @@ def compile_cuda(pyfunc, return_type, args, debug=False, lineinfo=False,
     if nvvm_options:
         flags.nvvm_options = nvvm_options
     flags.compute_capability = cc
+    flags.max_registers = max_registers
+    flags.lto = lto
 
     # Run compilation pipeline
     from numba.core.target_extension import target_override
@@ -247,11 +276,155 @@ def cabi_wrap_function(context, lib, fndesc, wrapper_function_name,
         builder, func, restype, argtypes, callargs)
     builder.ret(return_value)
 
+    if config.DUMP_LLVM:
+        utils.dump_llvm(fndesc, wrapper_module)
+
     library.add_ir_module(wrapper_module)
     library.finalize()
     return library
 
 
+def kernel_fixup(kernel, debug):
+    if debug:
+        exc_helper = add_exception_store_helper(kernel)
+
+    # Pass 1 - replace:
+    #
+    #    ret <value>
+    #
+    # with:
+    #
+    #    exc_helper(<value>)
+    #    ret void
+
+    for block in kernel.blocks:
+        for i, inst in enumerate(block.instructions):
+            if isinstance(inst, ir.Ret):
+                old_ret = block.instructions.pop()
+                block.terminator = None
+
+                # The original return's metadata will be set on the new
+                # instructions in order to preserve debug info
+                metadata = old_ret.metadata
+
+                builder = ir.IRBuilder(block)
+                if debug:
+                    status_code = old_ret.operands[0]
+                    exc_helper_call = builder.call(exc_helper, (status_code,))
+                    exc_helper_call.metadata = metadata
+
+                new_ret = builder.ret_void()
+                new_ret.metadata = old_ret.metadata
+
+                # Need to break out so we don't carry on modifying what we are
+                # iterating over. There can only be one return in a block
+                # anyway.
+                break
+
+    # Pass 2: remove stores of null pointer to return value argument pointer
+
+    return_value = kernel.args[0]
+
+    for block in kernel.blocks:
+        remove_list = []
+
+        # Find all stores first
+        for inst in block.instructions:
+            if (isinstance(inst, ir.StoreInstr)
+                    and inst.operands[1] == return_value):
+                remove_list.append(inst)
+
+        # Remove all stores
+        for to_remove in remove_list:
+            block.instructions.remove(to_remove)
+
+    # Replace non-void return type with void return type and remove return
+    # value
+
+    if isinstance(kernel.type, ir.PointerType):
+        new_type = ir.PointerType(ir.FunctionType(ir.VoidType(),
+                                                  kernel.type.pointee.args[1:]))
+    else:
+        new_type = ir.FunctionType(ir.VoidType(), kernel.type.args[1:])
+
+    kernel.type = new_type
+    kernel.return_value = ir.ReturnValue(kernel, ir.VoidType())
+    kernel.args = kernel.args[1:]
+
+    # Mark as a kernel for NVVM
+
+    nvvm.set_cuda_kernel(kernel)
+
+    if config.DUMP_LLVM:
+        print(f"LLVM DUMP: Post kernel fixup {kernel.name}".center(80, '-'))
+        print(kernel.module)
+        print('=' * 80)
+
+
+def add_exception_store_helper(kernel):
+
+    # Create global variables for exception state
+
+    def define_error_gv(postfix):
+        name = kernel.name + postfix
+        gv = cgutils.add_global_variable(kernel.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))
+
+    # Create exception store helper function
+
+    helper_name = kernel.name + "__exc_helper__"
+    helper_type = ir.FunctionType(ir.VoidType(), (ir.IntType(32),))
+    helper_func = ir.Function(kernel.module, helper_type, helper_name)
+
+    block = helper_func.append_basic_block(name="entry")
+    builder = ir.IRBuilder(block)
+
+    # Implement status check / exception store logic
+
+    status_code = helper_func.args[0]
+    call_conv = cuda_target.target_context.call_conv
+    status = call_conv._get_return_status(builder, status_code)
+
+    # 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()
+
+    return helper_func
+
+
 @global_compiler_lock
 def compile(pyfunc, sig, debug=None, lineinfo=False, device=True,
             fastmath=False, cc=None, opt=None, abi="c", abi_info=None,
@@ -347,13 +520,10 @@ def compile(pyfunc, sig, debug=None, lineinfo=False, device=True,
             lib = cabi_wrap_function(tgt, lib, cres.fndesc, wrapper_name,
                                      nvvm_options)
     else:
-        code = pyfunc.__code__
-        filename = code.co_filename
-        linenum = code.co_firstlineno
-
-        lib, kernel = tgt.prepare_cuda_kernel(cres.library, cres.fndesc, debug,
-                                              lineinfo, nvvm_options, filename,
-                                              linenum)
+        lib = cres.library
+        kernel = lib.get_function(cres.fndesc.llvm_func_name)
+        lib._entry_name = cres.fndesc.llvm_func_name
+        kernel_fixup(kernel, debug)
 
     if lto:
         code = lib.get_ltoir(cc=cc)

{numba_cuda-0.0.19 → numba_cuda-0.0.20}/numba_cuda/numba/cuda/cuda_paths.py

@@ -310,7 +310,9 @@ def get_conda_include_dir():
         # though usually it shouldn't.
         include_dir = os.path.join(sys.prefix, 'include')
 
-    if os.path.exists(include_dir):
+    if (os.path.exists(include_dir) and os.path.isdir(include_dir)
+            and os.path.exists(os.path.join(include_dir,
+                                            'cuda_device_runtime_api.h'))):
         return include_dir
     return
 

{numba_cuda-0.0.19 → numba_cuda-0.0.20}/numba_cuda/numba/cuda/cudadrv/enums.py

@@ -55,7 +55,7 @@ CUDA_ERROR_INVALID_HANDLE = 400
 CUDA_ERROR_ILLEGAL_STATE = 401
 CUDA_ERROR_NOT_FOUND = 500
 CUDA_ERROR_NOT_READY = 600
-CUDA_ERROR_LAUNCH_FAILED = 700
+CUDA_ERROR_ILLEGAL_ADDRESS = 700
 CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES = 701
 CUDA_ERROR_LAUNCH_TIMEOUT = 702
 CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING = 703

{numba_cuda-0.0.19 → numba_cuda-0.0.20}/numba_cuda/numba/cuda/dispatcher.py

@@ -14,7 +14,7 @@ from numba.core.typing.typeof import Purpose, typeof
 
 from numba.cuda.api import get_current_device
 from numba.cuda.args import wrap_arg
-from numba.cuda.compiler import compile_cuda, CUDACompiler
+from numba.cuda.compiler import compile_cuda, CUDACompiler, kernel_fixup
 from numba.cuda.cudadrv import driver
 from numba.cuda.cudadrv.devices import get_context
 from numba.cuda.descriptor import cuda_target
@@ -102,15 +102,14 @@ class _Kernel(serialize.ReduceMixin):
                             inline=inline,
                             fastmath=fastmath,
                             nvvm_options=nvvm_options,
-                            cc=cc)
+                            cc=cc,
+                            max_registers=max_registers,
+                            lto=lto)
         tgt_ctx = cres.target_context
-        code = self.py_func.__code__
-        filename = code.co_filename
-        linenum = code.co_firstlineno
-        lib, kernel = tgt_ctx.prepare_cuda_kernel(cres.library, cres.fndesc,
-                                                  debug, lineinfo, nvvm_options,
-                                                  filename, linenum,
-                                                  max_registers, lto)
+        lib = cres.library
+        kernel = lib.get_function(cres.fndesc.llvm_func_name)
+        lib._entry_name = cres.fndesc.llvm_func_name
+        kernel_fixup(kernel, self.debug)
 
         if not link:
             link = []

{numba_cuda-0.0.19 → numba_cuda-0.0.20}/numba_cuda/numba/cuda/tests/cudapy/test_debug.py

@@ -48,13 +48,11 @@ class TestDebugOutput(CUDATestCase):
                 self.assertRaises(AssertionError, check_meth, out)
 
     def _check_dump_bytecode(self, out):
-        if PYVERSION in ((3, 11), (3, 12)):
+        if PYVERSION > (3, 10):
             # binop with arg=0 is binary add, see CPython dis.py and opcode.py
             self.assertIn('BINARY_OP(arg=0', out)
-        elif PYVERSION in ((3, 9), (3, 10)):
-            self.assertIn('BINARY_ADD', out)
         else:
-            raise NotImplementedError(PYVERSION)
+            self.assertIn('BINARY_ADD', out)
 
     def _check_dump_cfg(self, out):
         self.assertIn('CFG dominators', out)

{numba_cuda-0.0.19 → numba_cuda-0.0.20}/numba_cuda/numba/cuda/tests/cudapy/test_debuginfo.py

@@ -72,6 +72,7 @@ class TestCudaDebugInfo(CUDATestCase):
         def f(x):
             x[0] = 0
 
+    @unittest.skip("Wrappers no longer exist")
     def test_wrapper_has_debuginfo(self):
         sig = (types.int32[::1],)
 

{numba_cuda-0.0.19 → numba_cuda-0.0.20}/numba_cuda/numba/cuda/tests/cudapy/test_inspect.py

@@ -33,10 +33,7 @@ class TestInspect(CUDATestCase):
         self.assertIn("foo", llvm)
 
         # Kernel in LLVM
-        self.assertIn('cuda.kernel.wrapper', llvm)
-
-        # Wrapped device function body in LLVM
-        self.assertIn("define linkonce_odr i32", llvm)
+        self.assertIn("define void @", llvm)
 
         asm = foo.inspect_asm(sig)
 
@@ -72,12 +69,8 @@ class TestInspect(CUDATestCase):
         self.assertIn("foo", llvmirs[float64, float64])
 
         # Kernels in LLVM
-        self.assertIn('cuda.kernel.wrapper', llvmirs[intp, intp])
-        self.assertIn('cuda.kernel.wrapper', llvmirs[float64, float64])
-
-        # Wrapped device function bodies in LLVM
-        self.assertIn("define linkonce_odr i32", llvmirs[intp, intp])
-        self.assertIn("define linkonce_odr i32", llvmirs[float64, float64])
+        self.assertIn("define void @", llvmirs[intp, intp])
+        self.assertIn("define void @", llvmirs[float64, float64])
 
         asmdict = foo.inspect_asm()
 

{numba_cuda-0.0.19 → numba_cuda-0.0.20}/numba_cuda/numba/cuda/tests/cudapy/test_lineinfo.py

@@ -170,10 +170,9 @@ class TestCudaLineInfo(CUDATestCase):
                 subprograms += 1
 
         # One DISubprogram for each of:
-        # - The kernel wrapper
         # - The caller
         # - The callee
-        expected_subprograms = 3
+        expected_subprograms = 2
 
         self.assertEqual(subprograms, expected_subprograms,
                          f'"Expected {expected_subprograms} DISubprograms; '

{numba_cuda-0.0.19 → numba_cuda-0.0.20}/numba_cuda/numba/cuda/tests/cudapy/test_optimization.py

@@ -14,8 +14,11 @@ def device_func(x, y, z):
 
 
 # Fragments of code that are removed from kernel_func's PTX when optimization
-# is on
-removed_by_opt = ( '__local_depot0', 'call.uni', 'st.param.b64')
+# is on. Previously this list was longer when kernel wrappers were used - if
+# the test function were more complex it may be possible to isolate additional
+# fragments of PTX we could check for the absence / presence of, but removal of
+# the use of local memory is a good indicator that optimization was applied.
+removed_by_opt = ( '__local_depot0',)
 
 
 @skip_on_cudasim('Simulator does not optimize code')

{numba_cuda-0.0.19 → numba_cuda-0.0.20}/numba_cuda/numba/cuda/tests/cudapy/test_stream_api.py

@@ -1,6 +1,6 @@
 from numba.cuda.testing import (skip_on_cudasim, skip_unless_cudasim, unittest,
                                 CUDATestCase)
-from numba import cuda
+from numba import config, cuda
 
 # Basic tests that stream APIs execute on the hardware and in the simulator.
 #
@@ -34,7 +34,11 @@ class TestStreamAPI(CUDATestCase):
         # We don't test synchronization on the stream because it's not a real
         # stream - we used a dummy pointer for testing the API, so we just
         # ensure that the stream handle matches the external stream pointer.
-        self.assertEqual(ptr, s.handle.value)
+        if config.CUDA_USE_NVIDIA_BINDING:
+            value = int(s.handle)
+        else:
+            value = s.handle.value
+        self.assertEqual(ptr, value)
 
     @skip_unless_cudasim("External streams are usable with hardware")
     def test_external_stream_simulator_unavailable(self):

{numba_cuda-0.0.19 → numba_cuda-0.0.20}/numba_cuda.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: numba-cuda
-Version: 0.0.19
+Version: 0.0.20
 Summary: CUDA target for Numba
 Author: Anaconda Inc., NVIDIA Corporation
 License: BSD 2-clause
@@ -13,17 +13,21 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numba>=0.59.1
 
+<div align="center"><img src="docs/source/_static/numba-green-icon-rgb.svg" width="200"/></div>
+
 # Numba CUDA Target
 
-An out-of-tree CUDA target for Numba.
+The CUDA target for Numba. Please visit the [official
+documentation](https://nvidia.github.io/numba-cuda) to get started!
+
 
-This contains an entire copy of Numba's CUDA target (the `numba.cuda` module),
-and a mechanism to ensure the code from this module (`numba_cuda.numba.cuda`) is
-used as the `numba.cuda` module instead of the code from the `numba` package.
+To report issues or file feature requests, please use the [issue
+tracker](https://github.com/NVIDIA/numba-cuda/issues).
 
-This is presently in an early state and is published for testing and feedback.
+To raise questions or initiate discussions, please use the [Numba Discourse
+forum](https://numba.discourse.group).
 
-## Building / testing
+## Building from source
 
 Install as an editable install:
 
@@ -31,7 +35,7 @@ Install as an editable install:
 pip install -e .
 ```
 
-Running tests:
+## Running tests
 
 ```
 python -m numba.runtests numba.cuda.tests

numba_cuda-0.0.19/README.md

@@ -1,36 +0,0 @@
-# Numba CUDA Target
-
-An out-of-tree CUDA target for Numba.
-
-This contains an entire copy of Numba's CUDA target (the `numba.cuda` module),
-and a mechanism to ensure the code from this module (`numba_cuda.numba.cuda`) is
-used as the `numba.cuda` module instead of the code from the `numba` package.
-
-This is presently in an early state and is published for testing and feedback.
-
-## Building / testing
-
-Install as an editable install:
-
-```
-pip install -e .
-```
-
-Running tests:
-
-```
-python -m numba.runtests numba.cuda.tests
-```
-
-This should discover the`numba.cuda` module from the `numba_cuda` package. You
-can check where `numba.cuda` files are being located by running
-
-```
-python -c "from numba import cuda; print(cuda.__file__)"
-```
-
-which will show a path like:
-
-```
-<path to numba-cuda repo>/numba_cuda/numba/cuda/__init__.py
-```

numba_cuda-0.0.19/numba_cuda/VERSION

@@ -1 +0,0 @@
-0.0.19