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

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

@@ -1,4 +1,4 @@
-from numba.tests.support import (override_config, captured_stdout)
+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
@@ -8,7 +8,7 @@ import re
 import unittest
 
 
-@skip_on_cudasim('Simulator does not produce debug dumps')
+@skip_on_cudasim("Simulator does not produce debug dumps")
 class TestCudaDebugInfo(CUDATestCase):
     """
     These tests only checks the compiled PTX for debuginfo section
@@ -49,7 +49,7 @@ class TestCudaDebugInfo(CUDATestCase):
         self._check(foo, sig=(types.int32[:],), expect=True)
 
     def test_environment_override(self):
-        with override_config('CUDA_DEBUGINFO_DEFAULT', 1):
+        with override_config("CUDA_DEBUGINFO_DEFAULT", 1):
             # Using default value
             @cuda.jit(opt=False)
             def foo(x):
@@ -86,7 +86,7 @@ class TestCudaDebugInfo(CUDATestCase):
 
         llvm_ir = f.inspect_llvm(sig)
         # A varible name starting with "bool" in the debug metadata
-        pat = r'!DILocalVariable\(.*name:\s+\"bool'
+        pat = r"!DILocalVariable\(.*name:\s+\"bool"
         match = re.compile(pat).search(llvm_ir)
         self.assertIsNone(match, msg=llvm_ir)
 
@@ -106,7 +106,7 @@ class TestCudaDebugInfo(CUDATestCase):
         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'
+        pat = rf"!{mdnode_id}\s+=\s+!DIBasicType\(.*DW_ATE_boolean"
         match = re.compile(pat).search(llvm_ir)
         self.assertIsNotNone(match, msg=llvm_ir)
 
@@ -133,14 +133,17 @@ class TestCudaDebugInfo(CUDATestCase):
 
         llvm_ir = f.inspect_llvm(sig)
 
-        defines = [line for line in llvm_ir.splitlines()
-                   if 'define void @"_ZN6cudapy' in line]
+        defines = [
+            line
+            for line in llvm_ir.splitlines()
+            if 'define void @"_ZN6cudapy' in line
+        ]
 
         # Make sure we only found one definition
         self.assertEqual(len(defines), 1)
 
         wrapper_define = defines[0]
-        self.assertIn('!dbg', wrapper_define)
+        self.assertIn("!dbg", wrapper_define)
 
     def test_debug_function_calls_internal_impl(self):
         # Calling a function in a module generated from an implementation
@@ -198,16 +201,16 @@ class TestCudaDebugInfo(CUDATestCase):
         debug_opts = itertools.product(*[(True, False)] * 3)
 
         for kernel_debug, f1_debug, f2_debug in debug_opts:
-            with self.subTest(kernel_debug=kernel_debug,
-                              f1_debug=f1_debug,
-                              f2_debug=f2_debug):
-                self._test_chained_device_function(kernel_debug,
-                                                   f1_debug,
-                                                   f2_debug)
-
-    def _test_chained_device_function_two_calls(self, kernel_debug, f1_debug,
-                                                f2_debug):
-
+            with self.subTest(
+                kernel_debug=kernel_debug, f1_debug=f1_debug, f2_debug=f2_debug
+            ):
+                self._test_chained_device_function(
+                    kernel_debug, f1_debug, f2_debug
+                )
+
+    def _test_chained_device_function_two_calls(
+        self, kernel_debug, f1_debug, f2_debug
+    ):
         @cuda.jit(device=True, debug=f2_debug, opt=False)
         def f2(x):
             return x + 1
@@ -232,12 +235,12 @@ class TestCudaDebugInfo(CUDATestCase):
         debug_opts = itertools.product(*[(True, False)] * 3)
 
         for kernel_debug, f1_debug, f2_debug in debug_opts:
-            with self.subTest(kernel_debug=kernel_debug,
-                              f1_debug=f1_debug,
-                              f2_debug=f2_debug):
-                self._test_chained_device_function_two_calls(kernel_debug,
-                                                             f1_debug,
-                                                             f2_debug)
+            with self.subTest(
+                kernel_debug=kernel_debug, f1_debug=f1_debug, f2_debug=f2_debug
+            ):
+                self._test_chained_device_function_two_calls(
+                    kernel_debug, f1_debug, f2_debug
+                )
 
     def test_chained_device_three_functions(self):
         # Like test_chained_device_function, but with enough functions (three)
@@ -278,13 +281,13 @@ class TestCudaDebugInfo(CUDATestCase):
         llvm_ir = f.inspect_llvm(sig)
 
         # extract the metadata node id from `types` field of DISubroutineType
-        pat = r'!DISubroutineType\(types:\s+!(\d+)\)'
+        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+}}'
+        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)
@@ -303,10 +306,56 @@ class TestCudaDebugInfo(CUDATestCase):
 
     def test_kernel_args_types_dump(self):
         # see issue#135
-        with override_config('DUMP_LLVM', 1):
+        with override_config("DUMP_LLVM", 1):
             with captured_stdout():
                 self._test_kernel_args_types()
 
+    def test_llvm_dbg_value(self):
+        sig = (types.int32, types.int32)
+
+        @cuda.jit("void(int32, int32)", debug=True, opt=False)
+        def f(x, y):
+            z = x  # noqa: F841
+            z = 100  # noqa: F841
+            z = y  # noqa: F841
+            z = True  # noqa: F841
+
+        llvm_ir = f.inspect_llvm(sig)
+        # Verify the call to llvm.dbg.declare is replaced by llvm.dbg.value
+        pat1 = r'call void @"llvm.dbg.declare"'
+        match = re.compile(pat1).search(llvm_ir)
+        self.assertIsNone(match, msg=llvm_ir)
+        pat2 = r'call void @"llvm.dbg.value"'
+        match = re.compile(pat2).search(llvm_ir)
+        self.assertIsNotNone(match, msg=llvm_ir)
+
+    def test_no_user_var_alias(self):
+        sig = (types.int32, types.int32)
+
+        @cuda.jit("void(int32, int32)", debug=True, opt=False)
+        def f(x, y):
+            z = x  # noqa: F841
+            z = y  # noqa: F841
+
+        llvm_ir = f.inspect_llvm(sig)
+        pat = r'!DILocalVariable.*name:\s+"z\$1".*'
+        match = re.compile(pat).search(llvm_ir)
+        self.assertIsNone(match, msg=llvm_ir)
+
+    def test_no_literal_type(self):
+        sig = (types.int32,)
+
+        @cuda.jit("void(int32)", debug=True, opt=False)
+        def f(x):
+            z = x  # noqa: F841
+            z = 100  # noqa: F841
+            z = True  # noqa: F841
+
+        llvm_ir = f.inspect_llvm(sig)
+        pat = r'!DIBasicType.*name:\s+"Literal.*'
+        match = re.compile(pat).search(llvm_ir)
+        self.assertIsNone(match, msg=llvm_ir)
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -3,8 +3,13 @@ import cffi
 
 import numpy as np
 
-from numba.cuda.testing import (skip_if_curand_kernel_missing, skip_on_cudasim,
-                                test_data_dir, unittest, CUDATestCase)
+from numba.cuda.testing import (
+    skip_if_curand_kernel_missing,
+    skip_on_cudasim,
+    test_data_dir,
+    unittest,
+    CUDATestCase,
+)
 from numba import cuda, jit, float32, int32, types
 from numba.core.errors import TypingError
 from numba.tests.support import skip_unless_cffi
@@ -12,9 +17,7 @@ from types import ModuleType
 
 
 class TestDeviceFunc(CUDATestCase):
-
     def test_use_add2f(self):
-
         @cuda.jit("float32(float32, float32)", device=True)
         def add2f(a, b):
             return a + b
@@ -33,7 +36,6 @@ class TestDeviceFunc(CUDATestCase):
         self.assertTrue(np.all(ary == exp), (ary, exp))
 
     def test_indirect_add2f(self):
-
         @cuda.jit("float32(float32, float32)", device=True)
         def add2f(a, b):
             return a + b
@@ -74,12 +76,12 @@ class TestDeviceFunc(CUDATestCase):
 
         self._check_cpu_dispatcher(add)
 
-    @skip_on_cudasim('not supported in cudasim')
+    @skip_on_cudasim("not supported in cudasim")
     def test_cpu_dispatcher_invalid(self):
         # Test invalid usage
         # Explicit signature disables compilation, which also disable
         # compiling on CUDA.
-        @jit('(i4, i4)')
+        @jit("(i4, i4)")
         def add(a, b):
             return a + b
 
@@ -95,7 +97,7 @@ class TestDeviceFunc(CUDATestCase):
         def add(a, b):
             return a + b
 
-        mymod = ModuleType(name='mymod')
+        mymod = ModuleType(name="mymod")
         mymod.add = add
         del add
 
@@ -109,7 +111,7 @@ class TestDeviceFunc(CUDATestCase):
         add_kernel[1, ary.size](ary)
         np.testing.assert_equal(expect, ary)
 
-    @skip_on_cudasim('not supported in cudasim')
+    @skip_on_cudasim("not supported in cudasim")
     def test_inspect_llvm(self):
         @cuda.jit(device=True)
         def foo(x, y):
@@ -120,13 +122,13 @@ class TestDeviceFunc(CUDATestCase):
 
         fname = cres.fndesc.mangled_name
         # Verify that the function name has "foo" in it as in the python name
-        self.assertIn('foo', fname)
+        self.assertIn("foo", fname)
 
         llvm = foo.inspect_llvm(args)
         # Check that the compiled function name is in the LLVM.
         self.assertIn(fname, llvm)
 
-    @skip_on_cudasim('not supported in cudasim')
+    @skip_on_cudasim("not supported in cudasim")
     def test_inspect_asm(self):
         @cuda.jit(device=True)
         def foo(x, y):
@@ -137,13 +139,13 @@ class TestDeviceFunc(CUDATestCase):
 
         fname = cres.fndesc.mangled_name
         # Verify that the function name has "foo" in it as in the python name
-        self.assertIn('foo', fname)
+        self.assertIn("foo", fname)
 
         ptx = foo.inspect_asm(args)
         # Check that the compiled function name is in the PTX
         self.assertIn(fname, ptx)
 
-    @skip_on_cudasim('not supported in cudasim')
+    @skip_on_cudasim("not supported in cudasim")
     def test_inspect_sass_disallowed(self):
         @cuda.jit(device=True)
         def foo(x, y):
@@ -152,10 +154,11 @@ class TestDeviceFunc(CUDATestCase):
         with self.assertRaises(RuntimeError) as raises:
             foo.inspect_sass((int32, int32))
 
-        self.assertIn('Cannot inspect SASS of a device function',
-                      str(raises.exception))
+        self.assertIn(
+            "Cannot inspect SASS of a device function", str(raises.exception)
+        )
 
-    @skip_on_cudasim('cudasim will allow calling any function')
+    @skip_on_cudasim("cudasim will allow calling any function")
     def test_device_func_as_kernel_disallowed(self):
         @cuda.jit(device=True)
         def f():
@@ -164,10 +167,12 @@ class TestDeviceFunc(CUDATestCase):
         with self.assertRaises(RuntimeError) as raises:
             f[1, 1]()
 
-        self.assertIn('Cannot compile a device function as a kernel',
-                      str(raises.exception))
+        self.assertIn(
+            "Cannot compile a device function as a kernel",
+            str(raises.exception),
+        )
 
-    @skip_on_cudasim('cudasim ignores casting by jit decorator signature')
+    @skip_on_cudasim("cudasim ignores casting by jit decorator signature")
     def test_device_casting(self):
         # Ensure that casts to the correct type are forced when calling a
         # device function with a signature. This test ensures that:
@@ -176,20 +181,23 @@ class TestDeviceFunc(CUDATestCase):
         #   shouldn't
         # - We insert a cast when calling rgba, as opposed to failing to type.
 
-        @cuda.jit('int32(int32, int32, int32, int32)', device=True)
+        @cuda.jit("int32(int32, int32, int32, int32)", device=True)
         def rgba(r, g, b, a):
-            return (((r & 0xFF) << 16) |
-                    ((g & 0xFF) << 8) |
-                    ((b & 0xFF) << 0) |
-                    ((a & 0xFF) << 24))
+            return (
+                ((r & 0xFF) << 16)
+                | ((g & 0xFF) << 8)
+                | ((b & 0xFF) << 0)
+                | ((a & 0xFF) << 24)
+            )
 
         @cuda.jit
         def rgba_caller(x, channels):
             x[0] = rgba(channels[0], channels[1], channels[2], channels[3])
 
         x = cuda.device_array(1, dtype=np.int32)
-        channels = cuda.to_device(np.asarray([1.0, 2.0, 3.0, 4.0],
-                                             dtype=np.float32))
+        channels = cuda.to_device(
+            np.asarray([1.0, 2.0, 3.0, 4.0], dtype=np.float32)
+        )
 
         rgba_caller[1, 1](x, channels)
 
@@ -259,32 +267,31 @@ int random_number(unsigned int *out, unsigned long long seed)
 }""")
 
 
-@skip_on_cudasim('External functions unsupported in the simulator')
+@skip_on_cudasim("External functions unsupported in the simulator")
 class TestDeclareDevice(CUDATestCase):
-
     def check_api(self, decl):
-        self.assertEqual(decl.name, 'f1')
+        self.assertEqual(decl.name, "f1")
         self.assertEqual(decl.sig.args, (float32[:],))
         self.assertEqual(decl.sig.return_type, int32)
 
     def test_declare_device_signature(self):
-        f1 = cuda.declare_device('f1', int32(float32[:]))
+        f1 = cuda.declare_device("f1", int32(float32[:]))
         self.check_api(f1)
 
     def test_declare_device_string(self):
-        f1 = cuda.declare_device('f1', 'int32(float32[:])')
+        f1 = cuda.declare_device("f1", "int32(float32[:])")
         self.check_api(f1)
 
     def test_bad_declare_device_tuple(self):
-        with self.assertRaisesRegex(TypeError, 'Return type'):
-            cuda.declare_device('f1', (float32[:],))
+        with self.assertRaisesRegex(TypeError, "Return type"):
+            cuda.declare_device("f1", (float32[:],))
 
     def test_bad_declare_device_string(self):
-        with self.assertRaisesRegex(TypeError, 'Return type'):
-            cuda.declare_device('f1', '(float32[:],)')
+        with self.assertRaisesRegex(TypeError, "Return type"):
+            cuda.declare_device("f1", "(float32[:],)")
 
     def test_link_cu_source(self):
-        times2 = cuda.declare_device('times2', 'int32(int32)', link=times2_cu)
+        times2 = cuda.declare_device("times2", "int32(int32)", link=times2_cu)
 
         @cuda.jit
         def kernel(r, x):
@@ -301,7 +308,7 @@ class TestDeclareDevice(CUDATestCase):
 
     def _test_link_multiple_sources(self, link_type):
         link = link_type([times2_cu, times4_cu])
-        times4 = cuda.declare_device('times4', 'int32(int32)', link=link)
+        times4 = cuda.declare_device("times4", "int32(int32)", link=link)
 
         @cuda.jit
         def kernel(r, x):
@@ -360,7 +367,7 @@ class TestDeclareDevice(CUDATestCase):
         np.testing.assert_equal(x[0], 323845807)
 
     def test_declared_in_called_function(self):
-        times2 = cuda.declare_device('times2', 'int32(int32)', link=times2_cu)
+        times2 = cuda.declare_device("times2", "int32(int32)", link=times2_cu)
 
         @cuda.jit
         def device_func(x):
@@ -380,7 +387,7 @@ class TestDeclareDevice(CUDATestCase):
         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)
+        times2 = cuda.declare_device("times2", "int32(int32)", link=times2_cu)
 
         @cuda.jit
         def device_func_1(x):
@@ -404,7 +411,7 @@ class TestDeclareDevice(CUDATestCase):
         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)
+        times2 = cuda.declare_device("times2", "int32(int32)", link=times2_cu)
 
         @cuda.jit
         def device_func(x):
@@ -424,7 +431,7 @@ class TestDeclareDevice(CUDATestCase):
         np.testing.assert_equal(r, x * 6)
 
     def test_call_declared_function_twice(self):
-        times2 = cuda.declare_device('times2', 'int32(int32)', link=times2_cu)
+        times2 = cuda.declare_device("times2", "int32(int32)", link=times2_cu)
 
         @cuda.jit
         def kernel(r, x):
@@ -440,7 +447,7 @@ class TestDeclareDevice(CUDATestCase):
         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)
+        times2 = cuda.declare_device("times2", "int32(int32)", link=times2_cu)
 
         @cuda.jit
         def device_func(x):
@@ -460,8 +467,8 @@ class TestDeclareDevice(CUDATestCase):
         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)
+        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):
@@ -477,5 +484,5 @@ class TestDeclareDevice(CUDATestCase):
         np.testing.assert_equal(r, x * 5)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()