numba-cuda 0.0.15__tar.gz → 0.0.17__tar.gz

{numba_cuda-0.0.15 → numba_cuda-0.0.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: numba-cuda
-Version: 0.0.15
+Version: 0.0.17
 Summary: CUDA target for Numba
 Author: Anaconda Inc., NVIDIA Corporation
 License: BSD 2-clause
@@ -49,21 +49,3 @@ which will show a path like:
 ```
 <path to numba-cuda repo>/numba_cuda/numba/cuda/__init__.py
 ```
-
-## Branching strategy
-
-Presently the `main` branch is being used to target the exact behavior of the
-built-in CUDA target. New feature development and bug fixes should be applied to
-`develop`. Once the `main` branch is widely tested and confirmed to work well as
-a drop-in replacement for the built-in `numba.cuda`, the `develop` branch will
-be merged in and new feature development will proceed on `main`.
-
-### Current PR targets
-
-- PRs related to replacing the built-in CUDA target's features should target
-  `main`.
-- PRs adding new features and bug fixes should target `develop`.
-
-### Future PR targets
-
-- In future, all PRs should target the `main` branch.

{numba_cuda-0.0.15 → numba_cuda-0.0.17}/README.md

@@ -34,21 +34,3 @@ which will show a path like:
 ```
 <path to numba-cuda repo>/numba_cuda/numba/cuda/__init__.py
 ```
-
-## Branching strategy
-
-Presently the `main` branch is being used to target the exact behavior of the
-built-in CUDA target. New feature development and bug fixes should be applied to
-`develop`. Once the `main` branch is widely tested and confirmed to work well as
-a drop-in replacement for the built-in `numba.cuda`, the `develop` branch will
-be merged in and new feature development will proceed on `main`.
-
-### Current PR targets
-
-- PRs related to replacing the built-in CUDA target's features should target
-  `main`.
-- PRs adding new features and bug fixes should target `develop`.
-
-### Future PR targets
-
-- In future, all PRs should target the `main` branch.

numba_cuda-0.0.17/numba_cuda/VERSION

@@ -0,0 +1 @@
+0.0.17

{numba_cuda-0.0.15 → numba_cuda-0.0.17}/numba_cuda/numba/cuda/compiler.py

@@ -253,8 +253,8 @@ def cabi_wrap_function(context, lib, fndesc, wrapper_function_name,
 
 
 @global_compiler_lock
-def compile(pyfunc, sig, debug=False, lineinfo=False, device=True,
-            fastmath=False, cc=None, opt=True, abi="c", abi_info=None,
+def compile(pyfunc, sig, debug=None, lineinfo=False, device=True,
+            fastmath=False, cc=None, opt=None, abi="c", abi_info=None,
             output='ptx'):
     """Compile a Python function to PTX or LTO-IR for a given set of argument
     types.
@@ -283,7 +283,7 @@ def compile(pyfunc, sig, debug=False, lineinfo=False, device=True,
     :param cc: Compute capability to compile for, as a tuple
                ``(MAJOR, MINOR)``. Defaults to ``(5, 0)``.
     :type cc: tuple
-    :param opt: Enable optimizations. Defaults to ``True``.
+    :param opt: Whether to enable optimizations in the compiled code.
     :type opt: bool
     :param abi: The ABI for a compiled function - either ``"numba"`` or
                 ``"c"``. Note that the Numba ABI is not considered stable.
@@ -307,8 +307,11 @@ def compile(pyfunc, sig, debug=False, lineinfo=False, device=True,
     if output not in ("ptx", "ltoir"):
         raise NotImplementedError(f'Unsupported output type: {output}')
 
+    debug = config.CUDA_DEBUGINFO_DEFAULT if debug is None else debug
+    opt = (config.OPT != 0) if opt is None else opt
+
     if debug and opt:
-        msg = ("debug=True with opt=True (the default) "
+        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))
@@ -359,8 +362,8 @@ def compile(pyfunc, sig, debug=False, lineinfo=False, device=True,
     return code, resty
 
 
-def compile_for_current_device(pyfunc, sig, debug=False, lineinfo=False,
-                               device=True, fastmath=False, opt=True,
+def compile_for_current_device(pyfunc, sig, debug=None, lineinfo=False,
+                               device=True, fastmath=False, opt=None,
                                abi="c", abi_info=None, output='ptx'):
     """Compile a Python function to PTX or LTO-IR for a given signature for the
     current device's compute capabilility. This calls :func:`compile` with an
@@ -371,8 +374,8 @@ def compile_for_current_device(pyfunc, sig, debug=False, lineinfo=False,
                    abi_info=abi_info, output=output)
 
 
-def compile_ptx(pyfunc, sig, debug=False, lineinfo=False, device=False,
-                fastmath=False, cc=None, opt=True, abi="numba", abi_info=None):
+def compile_ptx(pyfunc, sig, debug=None, lineinfo=False, device=False,
+                fastmath=False, cc=None, opt=None, abi="numba", abi_info=None):
     """Compile a Python function to PTX for a given signature. See
     :func:`compile`. The defaults for this function are to compile a kernel
     with the Numba ABI, rather than :func:`compile`'s default of compiling a
@@ -382,8 +385,8 @@ def compile_ptx(pyfunc, sig, debug=False, lineinfo=False, device=False,
                    abi_info=abi_info, output='ptx')
 
 
-def compile_ptx_for_current_device(pyfunc, sig, debug=False, lineinfo=False,
-                                   device=False, fastmath=False, opt=True,
+def compile_ptx_for_current_device(pyfunc, sig, debug=None, lineinfo=False,
+                                   device=False, fastmath=False, opt=None,
                                    abi="numba", abi_info=None):
     """Compile a Python function to PTX for a given signature for the current
     device's compute capabilility. See :func:`compile_ptx`."""

{numba_cuda-0.0.15 → numba_cuda-0.0.17}/numba_cuda/numba/cuda/decorators.py

@@ -12,7 +12,7 @@ _msg_deprecated_signature_arg = ("Deprecated keyword argument `{0}`. "
 
 
 def jit(func_or_sig=None, device=False, inline=False, link=[], debug=None,
-        opt=True, lineinfo=False, cache=False, **kws):
+        opt=None, lineinfo=False, cache=False, **kws):
     """
     JIT compile a Python function for CUDA GPUs.
 
@@ -42,9 +42,9 @@ def jit(func_or_sig=None, device=False, inline=False, link=[], debug=None,
        this number of registers per thread. The limit may not be respected if
        the ABI requires a greater number of registers than that requested.
        Useful for increasing occupancy.
-    :param opt: Whether to compile from LLVM IR to PTX with optimization
-                enabled. When ``True``, ``-opt=3`` is passed to NVVM. When
-                ``False``, ``-opt=0`` is passed to NVVM. Defaults to ``True``.
+    :param opt: Whether to compile with optimization enabled. If unspecified,
+       the OPT configuration variable is decided by ``NUMBA_OPT```; all
+       non-zero values will enable optimization.
     :type opt: bool
     :param lineinfo: If True, generate a line mapping between source code and
        assembly code. This enables inspection of the source code in NVIDIA
@@ -71,11 +71,12 @@ def jit(func_or_sig=None, device=False, inline=False, link=[], debug=None,
         raise DeprecationError(msg)
 
     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', [])
 
     if debug and opt:
-        msg = ("debug=True with opt=True (the default) "
+        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))

{numba_cuda-0.0.15 → numba_cuda-0.0.17}/numba_cuda/numba/cuda/printimpl.py

@@ -4,6 +4,7 @@ from numba.core import types, cgutils
 from numba.core.errors import NumbaWarning
 from numba.core.imputils import Registry
 from numba.cuda import nvvmutils
+from numba.cuda.types import Dim3
 from warnings import warn
 
 registry = Registry()
@@ -53,6 +54,26 @@ def const_print_impl(ty, context, builder, sigval):
     return rawfmt, [val]
 
 
+@print_item.register(Dim3)
+def dim3_print_impl(ty, context, builder, val):
+    rawfmt = "(%d, %d, %d)"
+    x = builder.extract_value(val, 0)
+    y = builder.extract_value(val, 1)
+    z = builder.extract_value(val, 2)
+    return rawfmt, [x, y, z]
+
+
+@print_item.register(types.Boolean)
+def bool_print_impl(ty, context, builder, val):
+    true_string = context.insert_string_const_addrspace(builder, "True")
+    false_string = context.insert_string_const_addrspace(builder, "False")
+    res_ptr = cgutils.alloca_once_value(builder, false_string)
+    with builder.if_then(val):
+        builder.store(true_string, res_ptr)
+    rawfmt = "%s"
+    return rawfmt, [builder.load(res_ptr)]
+
+
 @lower(print, types.VarArg(types.Any))
 def print_varargs(context, builder, sig, args):
     """This function is a generic 'print' wrapper for arbitrary types.

{numba_cuda-0.0.15 → numba_cuda-0.0.17}/numba_cuda/numba/cuda/simulator/api.py

@@ -9,6 +9,7 @@ from contextlib import contextmanager
 from .cudadrv.devices import require_context, reset, gpus  # noqa: F401
 from .kernel import FakeCUDAKernel
 from numba.core.sigutils import is_signature
+from numba.core import config
 from warnings import warn
 from ..args import In, Out, InOut  # noqa: F401
 
@@ -80,9 +81,9 @@ class Event(object):
 event = Event
 
 
-def jit(func_or_sig=None, device=False, debug=False, argtypes=None,
+def jit(func_or_sig=None, device=False, debug=None, argtypes=None,
         inline=False, restype=None, fastmath=False, link=None,
-        boundscheck=None, opt=True, cache=None
+        boundscheck=None, opt=None, cache=None
         ):
     # Here for API compatibility
     if boundscheck:
@@ -91,6 +92,8 @@ def jit(func_or_sig=None, device=False, debug=False, argtypes=None,
     if link is not None:
         raise NotImplementedError('Cannot link PTX in the simulator')
 
+    debug = config.CUDA_DEBUGINFO_DEFAULT if debug is None else debug
+
     # Check for first argument specifying types - in that case the
     # decorator is not being passed a function
     if (func_or_sig is None or is_signature(func_or_sig)

{numba_cuda-0.0.15 → numba_cuda-0.0.17}/numba_cuda/numba/cuda/tests/cudapy/test_compiler.py

@@ -101,7 +101,7 @@ class TestCompile(unittest.TestCase):
         def f():
             pass
 
-        ptx, resty = compile_ptx(f, (), device=True, debug=True)
+        ptx, resty = compile_ptx(f, (), device=True, debug=True, opt=False)
         self.check_debug_info(ptx)
 
     def test_kernel_with_debug(self):
@@ -109,7 +109,7 @@ class TestCompile(unittest.TestCase):
         def f():
             pass
 
-        ptx, resty = compile_ptx(f, (), debug=True)
+        ptx, resty = compile_ptx(f, (), debug=True, opt=False)
         self.check_debug_info(ptx)
 
     def check_line_info(self, ptx):

{numba_cuda-0.0.15 → numba_cuda-0.0.17}/numba_cuda/numba/cuda/tests/cudapy/test_cuda_jit_no_types.py

@@ -81,7 +81,7 @@ class TestCudaJitNoTypes(CUDATestCase):
         # Ensure that the jit decorator accepts the debug kwarg when the
         # simulator is in use - see Issue #6615.
         with override_config('ENABLE_CUDASIM', 1):
-            @cuda.jit(debug=True)
+            @cuda.jit(debug=True, opt=False)
             def f(x):
                 pass
 

{numba_cuda-0.0.15 → numba_cuda-0.0.17}/numba_cuda/numba/cuda/tests/cudapy/test_exception.py

@@ -160,7 +160,7 @@ class TestException(CUDATestCase):
         def f():
             raise ValueError(msg)
 
-        @cuda.jit(debug=True)
+        @cuda.jit(debug=True, opt=False)
         def kernel():
             f()
 

{numba_cuda-0.0.15 → numba_cuda-0.0.17}/numba_cuda/numba/cuda/tests/cudapy/test_fastmath.py

@@ -198,8 +198,8 @@ class TestFastMathOption(CUDATestCase):
             r[0] = x / y
 
         sig = (float32[::1], float32, float32)
-        fastver = cuda.jit(sig, fastmath=True, debug=True)(f10)
-        precver = cuda.jit(sig, debug=True)(f10)
+        fastver = cuda.jit(sig, fastmath=True, debug=True, opt=False)(f10)
+        precver = cuda.jit(sig, debug=True, opt=False)(f10)
         nelem = 10
         ary = np.empty(nelem, dtype=np.float32)
         with self.assertRaises(ZeroDivisionError):

{numba_cuda-0.0.15 → numba_cuda-0.0.17}/numba_cuda/numba/cuda/tests/cudapy/test_print.py

@@ -1,4 +1,5 @@
 from numba.cuda.testing import CUDATestCase, skip_on_cudasim
+import numpy as np
 import subprocess
 import sys
 import unittest
@@ -31,6 +32,21 @@ cuda.synchronize()
 """
 
 
+printbool_usecase = """\
+from numba import cuda
+
+@cuda.jit
+def printbool(x):
+    print(True)
+    print(False)
+    print(x == 0)
+
+printbool[1, 1](0)
+printbool[1, 1](1)
+cuda.synchronize()
+"""
+
+
 printstring_usecase = """\
 from numba import cuda
 
@@ -43,6 +59,19 @@ printstring[1, 3]()
 cuda.synchronize()
 """
 
+
+printdim3_usecase = """\
+from numba import cuda
+
+@cuda.jit
+def printdim3():
+    print(cuda.threadIdx)
+
+printdim3[1, (2, 2, 2)]()
+cuda.synchronize()
+"""
+
+
 printempty_usecase = """\
 from numba import cuda
 
@@ -95,6 +124,11 @@ class TestPrint(CUDATestCase):
         expected_cases = ["0 23 34.750000 321", "0 23 34.75 321"]
         self.assertIn(output.strip(), expected_cases)
 
+    def test_bool(self):
+        output, _ = self.run_code(printbool_usecase)
+        expected = "True\nFalse\nTrue\nTrue\nFalse\nFalse"
+        self.assertEqual(output.strip(), expected)
+
     def test_printempty(self):
         output, _ = self.run_code(printempty_usecase)
         self.assertEqual(output.strip(), "")
@@ -105,6 +139,12 @@ class TestPrint(CUDATestCase):
         expected = ['%d hop! 999' % i for i in range(3)]
         self.assertEqual(sorted(lines), expected)
 
+    def test_dim3(self):
+        output, _ = self.run_code(printdim3_usecase)
+        lines = [line.strip() for line in output.splitlines(True)]
+        expected = [str(i) for i in np.ndindex(2, 2, 2)]
+        self.assertEqual(sorted(lines), expected)
+
     @skip_on_cudasim('cudasim can print unlimited output')
     def test_too_many_args(self):
         # Tests that we emit the format string and warn when there are more

{numba_cuda-0.0.15 → numba_cuda-0.0.17}/numba_cuda/numba/cuda/tests/cudapy/test_userexc.py

@@ -22,7 +22,7 @@ class TestUserExc(CUDATestCase):
         self.skip_if_lto("Exceptions not supported with LTO")
 
     def test_user_exception(self):
-        @cuda.jit("void(int32)", debug=True)
+        @cuda.jit("void(int32)", debug=True, opt=False)
         def test_exc(x):
             if x == 1:
                 raise MyError

{numba_cuda-0.0.15 → numba_cuda-0.0.17}/numba_cuda/numba/cuda/tests/cudapy/test_warning.py

@@ -3,6 +3,7 @@ from numba import cuda
 from numba.cuda.testing import unittest, CUDATestCase, skip_on_cudasim
 from numba.tests.support import linux_only, override_config
 from numba.core.errors import NumbaPerformanceWarning
+from numba.core import config
 import warnings
 
 
@@ -134,6 +135,43 @@ class TestWarnings(CUDATestCase):
 
         self.assertEqual(len(w), 0)
 
+    def test_no_warn_on_debug_and_opt_with_config(self):
+        with override_config('CUDA_DEBUGINFO_DEFAULT', 1):
+            with override_config('OPT', config._OptLevel(0)):
+                with warnings.catch_warnings(record=True) as w:
+                    cuda.jit()
+
+            self.assertEqual(len(w), 0)
+
+            with warnings.catch_warnings(record=True) as w:
+                cuda.jit(opt=False)
+
+            self.assertEqual(len(w), 0)
+
+        with override_config('OPT', config._OptLevel(0)):
+            with warnings.catch_warnings(record=True) as w:
+                cuda.jit(debug=True)
+
+            self.assertEqual(len(w), 0)
+
+    def test_warn_on_debug_and_opt_with_config(self):
+        with override_config('CUDA_DEBUGINFO_DEFAULT', 1):
+            for opt in (1, 2, 3, 'max'):
+                with override_config('OPT', config._OptLevel(opt)):
+                    with warnings.catch_warnings(record=True) as w:
+                        cuda.jit()
+
+                self.assertEqual(len(w), 1)
+                self.assertIn('not supported by CUDA', str(w[0].message))
+
+        for opt in (1, 2, 3, 'max'):
+            with override_config('OPT', config._OptLevel(opt)):
+                with warnings.catch_warnings(record=True) as w:
+                    cuda.jit(debug=True)
+
+                self.assertEqual(len(w), 1)
+                self.assertIn('not supported by CUDA', str(w[0].message))
+
 
 if __name__ == '__main__':
     unittest.main()

{numba_cuda-0.0.15 → numba_cuda-0.0.17}/numba_cuda.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: numba-cuda
-Version: 0.0.15
+Version: 0.0.17
 Summary: CUDA target for Numba
 Author: Anaconda Inc., NVIDIA Corporation
 License: BSD 2-clause
@@ -49,21 +49,3 @@ which will show a path like:
 ```
 <path to numba-cuda repo>/numba_cuda/numba/cuda/__init__.py
 ```
-
-## Branching strategy
-
-Presently the `main` branch is being used to target the exact behavior of the
-built-in CUDA target. New feature development and bug fixes should be applied to
-`develop`. Once the `main` branch is widely tested and confirmed to work well as
-a drop-in replacement for the built-in `numba.cuda`, the `develop` branch will
-be merged in and new feature development will proceed on `main`.
-
-### Current PR targets
-
-- PRs related to replacing the built-in CUDA target's features should target
-  `main`.
-- PRs adding new features and bug fixes should target `develop`.
-
-### Future PR targets
-
-- In future, all PRs should target the `main` branch.

numba_cuda-0.0.15/numba_cuda/VERSION

@@ -1 +0,0 @@
-0.0.15