numba-cuda 0.0.1__py3-none-any.whl → 0.0.12__py3-none-any.whl

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

@@ -0,0 +1,94 @@
+import numpy as np
+
+from numba import cuda, vectorize, guvectorize
+from numba.np.numpy_support import from_dtype
+from numba.cuda.testing import CUDATestCase, skip_on_cudasim
+import unittest
+
+
+class TestCudaDateTime(CUDATestCase):
+    def test_basic_datetime_kernel(self):
+        @cuda.jit
+        def foo(start, end, delta):
+            for i in range(cuda.grid(1), delta.size, cuda.gridsize(1)):
+                delta[i] = end[i] - start[i]
+
+        arr1 = np.arange('2005-02', '2006-02', dtype='datetime64[D]')
+        arr2 = arr1 + np.random.randint(0, 10000, arr1.size)
+        delta = np.zeros_like(arr1, dtype='timedelta64[D]')
+
+        foo[1, 32](arr1, arr2, delta)
+
+        self.assertPreciseEqual(delta, arr2 - arr1)
+
+    def test_scalar_datetime_kernel(self):
+        @cuda.jit
+        def foo(dates, target, delta, matches, outdelta):
+            for i in range(cuda.grid(1), matches.size, cuda.gridsize(1)):
+                matches[i] = dates[i] == target
+                outdelta[i] = dates[i] - delta
+        arr1 = np.arange('2005-02', '2006-02', dtype='datetime64[D]')
+        target = arr1[5]           # datetime
+        delta = arr1[6] - arr1[5]  # timedelta
+        matches = np.zeros_like(arr1, dtype=np.bool_)
+        outdelta = np.zeros_like(arr1, dtype='datetime64[D]')
+
+        foo[1, 32](arr1, target, delta, matches, outdelta)
+        where = matches.nonzero()
+
+        self.assertEqual(list(where), [5])
+        self.assertPreciseEqual(outdelta, arr1 - delta)
+
+    @skip_on_cudasim('ufunc API unsupported in the simulator')
+    def test_ufunc(self):
+        datetime_t = from_dtype(np.dtype('datetime64[D]'))
+
+        @vectorize([(datetime_t, datetime_t)], target='cuda')
+        def timediff(start, end):
+            return end - start
+
+        arr1 = np.arange('2005-02', '2006-02', dtype='datetime64[D]')
+        arr2 = arr1 + np.random.randint(0, 10000, arr1.size)
+
+        delta = timediff(arr1, arr2)
+
+        self.assertPreciseEqual(delta, arr2 - arr1)
+
+    @skip_on_cudasim('ufunc API unsupported in the simulator')
+    def test_gufunc(self):
+        datetime_t = from_dtype(np.dtype('datetime64[D]'))
+        timedelta_t = from_dtype(np.dtype('timedelta64[D]'))
+
+        @guvectorize([(datetime_t, datetime_t, timedelta_t[:])], '(),()->()',
+                     target='cuda')
+        def timediff(start, end, out):
+            out[0] = end - start
+
+        arr1 = np.arange('2005-02', '2006-02', dtype='datetime64[D]')
+        arr2 = arr1 + np.random.randint(0, 10000, arr1.size)
+
+        delta = timediff(arr1, arr2)
+
+        self.assertPreciseEqual(delta, arr2 - arr1)
+
+    @skip_on_cudasim('no .copy_to_host() in the simulator')
+    def test_datetime_view_as_int64(self):
+        arr = np.arange('2005-02', '2006-02', dtype='datetime64[D]')
+        darr = cuda.to_device(arr)
+        viewed = darr.view(np.int64)
+        self.assertPreciseEqual(arr.view(np.int64), viewed.copy_to_host())
+        self.assertEqual(viewed.gpu_data, darr.gpu_data)
+
+    @skip_on_cudasim('no .copy_to_host() in the simulator')
+    def test_timedelta_view_as_int64(self):
+        arr = np.arange('2005-02', '2006-02', dtype='datetime64[D]')
+        arr = arr - (arr - 1)
+        self.assertEqual(arr.dtype, np.dtype('timedelta64[D]'))
+        darr = cuda.to_device(arr)
+        viewed = darr.view(np.int64)
+        self.assertPreciseEqual(arr.view(np.int64), viewed.copy_to_host())
+        self.assertEqual(viewed.gpu_data, darr.gpu_data)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,101 @@
+import numpy as np
+
+from numba.core.utils import PYVERSION
+from numba.cuda.testing import skip_on_cudasim, CUDATestCase
+from numba.tests.support import (override_config, captured_stderr,
+                                 captured_stdout)
+from numba import cuda, float64
+import unittest
+
+
+def simple_cuda(A, B):
+    i = cuda.grid(1)
+    B[i] = A[i] + 1.5
+
+
+@skip_on_cudasim('Simulator does not produce debug dumps')
+class TestDebugOutput(CUDATestCase):
+
+    def compile_simple_cuda(self):
+        with captured_stderr() as err:
+            with captured_stdout() as out:
+                cfunc = cuda.jit((float64[:], float64[:]))(simple_cuda)
+                # Call compiled function (to ensure PTX is generated)
+                # and sanity-check results.
+                A = np.linspace(0, 1, 10).astype(np.float64)
+                B = np.zeros_like(A)
+                cfunc[1, 10](A, B)
+                self.assertTrue(np.allclose(A + 1.5, B))
+        # stderr shouldn't be affected by debug output
+        self.assertFalse(err.getvalue())
+        return out.getvalue()
+
+    def assert_fails(self, *args, **kwargs):
+        self.assertRaises(AssertionError, *args, **kwargs)
+
+    def check_debug_output(self, out, enabled_dumps):
+        all_dumps = dict.fromkeys(['bytecode', 'cfg', 'ir', 'llvm',
+                                   'assembly'],
+                                  False)
+        for name in enabled_dumps:
+            assert name in all_dumps
+            all_dumps[name] = True
+        for name, enabled in sorted(all_dumps.items()):
+            check_meth = getattr(self, '_check_dump_%s' % name)
+            if enabled:
+                check_meth(out)
+            else:
+                self.assertRaises(AssertionError, check_meth, out)
+
+    def _check_dump_bytecode(self, out):
+        if PYVERSION in ((3, 11), (3, 12)):
+            # 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)
+
+    def _check_dump_cfg(self, out):
+        self.assertIn('CFG dominators', out)
+
+    def _check_dump_ir(self, out):
+        self.assertIn('--IR DUMP: simple_cuda--', out)
+        self.assertIn('const(float, 1.5)', out)
+
+    def _check_dump_llvm(self, out):
+        self.assertIn('--LLVM DUMP', out)
+        self.assertIn('!"kernel", i32 1', out)
+
+    def _check_dump_assembly(self, out):
+        self.assertIn('--ASSEMBLY simple_cuda', out)
+        self.assertIn('Generated by NVIDIA NVVM Compiler', out)
+
+    def test_dump_bytecode(self):
+        with override_config('DUMP_BYTECODE', True):
+            out = self.compile_simple_cuda()
+        self.check_debug_output(out, ['bytecode'])
+
+    def test_dump_ir(self):
+        with override_config('DUMP_IR', True):
+            out = self.compile_simple_cuda()
+        self.check_debug_output(out, ['ir'])
+
+    def test_dump_cfg(self):
+        with override_config('DUMP_CFG', True):
+            out = self.compile_simple_cuda()
+        self.check_debug_output(out, ['cfg'])
+
+    def test_dump_llvm(self):
+        with override_config('DUMP_LLVM', True):
+            out = self.compile_simple_cuda()
+        self.check_debug_output(out, ['llvm'])
+
+    def test_dump_assembly(self):
+        with override_config('DUMP_ASSEMBLY', True):
+            out = self.compile_simple_cuda()
+        self.check_debug_output(out, ['assembly'])
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,221 @@
+from numba.tests.support import override_config
+from numba.cuda.testing import skip_on_cudasim
+from numba import cuda
+from numba.core import types
+from numba.cuda.testing import CUDATestCase
+import itertools
+import re
+import unittest
+
+
+@skip_on_cudasim('Simulator does not produce debug dumps')
+class TestCudaDebugInfo(CUDATestCase):
+    """
+    These tests only checks the compiled PTX for debuginfo section
+    """
+
+    def setUp(self):
+        super().setUp()
+        # If we're using LTO then we can't check the PTX in these tests,
+        # because we produce LTO-IR, which is opaque to the user.
+        # Additionally, LTO optimizes away the exception status due to an
+        # oversight in the way we generate it (it is not added to the used
+        # list).
+        self.skip_if_lto("Exceptions not supported with LTO")
+
+    def _getasm(self, fn, sig):
+        fn.compile(sig)
+        return fn.inspect_asm(sig)
+
+    def _check(self, fn, sig, expect):
+        asm = self._getasm(fn, sig=sig)
+        re_section_dbginfo = re.compile(r"\.section\s+\.debug_info\s+{")
+        match = re_section_dbginfo.search(asm)
+        assertfn = self.assertIsNotNone if expect else self.assertIsNone
+        assertfn(match, msg=asm)
+
+    def test_no_debuginfo_in_asm(self):
+        @cuda.jit(debug=False)
+        def foo(x):
+            x[0] = 1
+
+        self._check(foo, sig=(types.int32[:],), expect=False)
+
+    def test_debuginfo_in_asm(self):
+        @cuda.jit(debug=True, opt=False)
+        def foo(x):
+            x[0] = 1
+
+        self._check(foo, sig=(types.int32[:],), expect=True)
+
+    def test_environment_override(self):
+        with override_config('CUDA_DEBUGINFO_DEFAULT', 1):
+            # Using default value
+            @cuda.jit(opt=False)
+            def foo(x):
+                x[0] = 1
+
+            self._check(foo, sig=(types.int32[:],), expect=True)
+
+            # User override default value
+            @cuda.jit(debug=False)
+            def bar(x):
+                x[0] = 1
+
+            self._check(bar, sig=(types.int32[:],), expect=False)
+
+    def test_issue_5835(self):
+        # Invalid debug metadata would segfault NVVM when any function was
+        # compiled with debug turned on and optimization off. This eager
+        # compilation should not crash anything.
+        @cuda.jit((types.int32[::1],), debug=True, opt=False)
+        def f(x):
+            x[0] = 0
+
+    def test_wrapper_has_debuginfo(self):
+        sig = (types.int32[::1],)
+
+        @cuda.jit(sig, debug=True, opt=0)
+        def f(x):
+            x[0] = 1
+
+        llvm_ir = f.inspect_llvm(sig)
+
+        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)
+
+    def test_debug_function_calls_internal_impl(self):
+        # Calling a function in a module generated from an implementation
+        # internal to Numba requires multiple modules to be compiled with NVVM -
+        # the internal implementation, and the caller. This example uses two
+        # modules because the `in (2, 3)` is implemented with:
+        #
+        # numba::cpython::listobj::in_seq::$3clocals$3e::seq_contains_impl$242(
+        #     UniTuple<long long, 2>,
+        #     int
+        # )
+        #
+        # This is condensed from this reproducer in Issue 5311:
+        # https://github.com/numba/numba/issues/5311#issuecomment-674206587
+
+        @cuda.jit((types.int32[:], types.int32[:]), debug=True, opt=False)
+        def f(inp, outp):
+            outp[0] = 1 if inp[0] in (2, 3) else 3
+
+    def test_debug_function_calls_device_function(self):
+        # Calling a device function requires compilation of multiple modules
+        # with NVVM - one for the caller and one for the callee. This checks
+        # that we don't cause an NVVM error in this case.
+
+        @cuda.jit(device=True, debug=True, opt=0)
+        def threadid():
+            return cuda.blockDim.x * cuda.blockIdx.x + cuda.threadIdx.x
+
+        @cuda.jit((types.int32[:],), debug=True, opt=0)
+        def kernel(arr):
+            i = cuda.grid(1)
+            if i < len(arr):
+                arr[i] = threadid()
+
+    def _test_chained_device_function(self, kernel_debug, f1_debug, f2_debug):
+        @cuda.jit(device=True, debug=f2_debug, opt=False)
+        def f2(x):
+            return x + 1
+
+        @cuda.jit(device=True, debug=f1_debug, opt=False)
+        def f1(x, y):
+            return x - f2(y)
+
+        @cuda.jit((types.int32, types.int32), debug=kernel_debug, opt=False)
+        def kernel(x, y):
+            f1(x, y)
+
+        kernel[1, 1](1, 2)
+
+    def test_chained_device_function(self):
+        # Calling a device function that calls another device function from a
+        # kernel with should succeed regardless of which jit decorators have
+        # debug=True. See Issue #7159.
+
+        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):
+
+        @cuda.jit(device=True, debug=f2_debug, opt=False)
+        def f2(x):
+            return x + 1
+
+        @cuda.jit(device=True, debug=f1_debug, opt=False)
+        def f1(x, y):
+            return x - f2(y)
+
+        @cuda.jit(debug=kernel_debug, opt=False)
+        def kernel(x, y):
+            f1(x, y)
+            f2(x)
+
+        kernel[1, 1](1, 2)
+
+    def test_chained_device_function_two_calls(self):
+        # Calling a device function that calls a leaf device function from a
+        # kernel, and calling the leaf device function from the kernel should
+        # succeed, regardless of which jit decorators have debug=True. See
+        # Issue #7159.
+
+        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)
+
+    def test_chained_device_three_functions(self):
+        # Like test_chained_device_function, but with enough functions (three)
+        # to ensure that the recursion visits all the way down the call tree
+        # when fixing linkage of functions for debug.
+        def three_device_fns(kernel_debug, leaf_debug):
+            @cuda.jit(device=True, debug=leaf_debug, opt=False)
+            def f3(x):
+                return x * x
+
+            @cuda.jit(device=True)
+            def f2(x):
+                return f3(x) + 1
+
+            @cuda.jit(device=True)
+            def f1(x, y):
+                return x - f2(y)
+
+            @cuda.jit(debug=kernel_debug, opt=False)
+            def kernel(x, y):
+                f1(x, y)
+
+            kernel[1, 1](1, 2)
+
+        # Check when debug on the kernel, on the leaf, and not on any function.
+        three_device_fns(kernel_debug=True, leaf_debug=True)
+        three_device_fns(kernel_debug=True, leaf_debug=False)
+        three_device_fns(kernel_debug=False, leaf_debug=True)
+        three_device_fns(kernel_debug=False, leaf_debug=False)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,222 @@
+import re
+import types
+
+import numpy as np
+
+from numba.cuda.testing import unittest, skip_on_cudasim, CUDATestCase
+from numba import cuda, jit, float32, int32
+from numba.core.errors import TypingError
+
+
+class TestDeviceFunc(CUDATestCase):
+
+    def test_use_add2f(self):
+
+        @cuda.jit("float32(float32, float32)", device=True)
+        def add2f(a, b):
+            return a + b
+
+        def use_add2f(ary):
+            i = cuda.grid(1)
+            ary[i] = add2f(ary[i], ary[i])
+
+        compiled = cuda.jit("void(float32[:])")(use_add2f)
+
+        nelem = 10
+        ary = np.arange(nelem, dtype=np.float32)
+        exp = ary + ary
+        compiled[1, nelem](ary)
+
+        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
+
+        @cuda.jit("float32(float32, float32)", device=True)
+        def indirect(a, b):
+            return add2f(a, b)
+
+        def indirect_add2f(ary):
+            i = cuda.grid(1)
+            ary[i] = indirect(ary[i], ary[i])
+
+        compiled = cuda.jit("void(float32[:])")(indirect_add2f)
+
+        nelem = 10
+        ary = np.arange(nelem, dtype=np.float32)
+        exp = ary + ary
+        compiled[1, nelem](ary)
+
+        self.assertTrue(np.all(ary == exp), (ary, exp))
+
+    def _check_cpu_dispatcher(self, add):
+        @cuda.jit
+        def add_kernel(ary):
+            i = cuda.grid(1)
+            ary[i] = add(ary[i], 1)
+
+        ary = np.arange(10)
+        expect = ary + 1
+        add_kernel[1, ary.size](ary)
+        np.testing.assert_equal(expect, ary)
+
+    def test_cpu_dispatcher(self):
+        # Test correct usage
+        @jit
+        def add(a, b):
+            return a + b
+
+        self._check_cpu_dispatcher(add)
+
+    @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)')
+        def add(a, b):
+            return a + b
+
+        # Check that the right error message is provided.
+        with self.assertRaises(TypingError) as raises:
+            self._check_cpu_dispatcher(add)
+        msg = "Untyped global name 'add':.*using cpu function on device"
+        expected = re.compile(msg)
+        self.assertTrue(expected.search(str(raises.exception)) is not None)
+
+    def test_cpu_dispatcher_other_module(self):
+        @jit
+        def add(a, b):
+            return a + b
+
+        mymod = types.ModuleType(name='mymod')
+        mymod.add = add
+        del add
+
+        @cuda.jit
+        def add_kernel(ary):
+            i = cuda.grid(1)
+            ary[i] = mymod.add(ary[i], 1)
+
+        ary = np.arange(10)
+        expect = ary + 1
+        add_kernel[1, ary.size](ary)
+        np.testing.assert_equal(expect, ary)
+
+    @skip_on_cudasim('not supported in cudasim')
+    def test_inspect_llvm(self):
+        @cuda.jit(device=True)
+        def foo(x, y):
+            return x + y
+
+        args = (int32, int32)
+        cres = foo.compile_device(args)
+
+        fname = cres.fndesc.mangled_name
+        # Verify that the function name has "foo" in it as in the python name
+        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')
+    def test_inspect_asm(self):
+        @cuda.jit(device=True)
+        def foo(x, y):
+            return x + y
+
+        args = (int32, int32)
+        cres = foo.compile_device(args)
+
+        fname = cres.fndesc.mangled_name
+        # Verify that the function name has "foo" in it as in the python name
+        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')
+    def test_inspect_sass_disallowed(self):
+        @cuda.jit(device=True)
+        def foo(x, y):
+            return x + y
+
+        with self.assertRaises(RuntimeError) as raises:
+            foo.inspect_sass((int32, int32))
+
+        self.assertIn('Cannot inspect SASS of a device function',
+                      str(raises.exception))
+
+    @skip_on_cudasim('cudasim will allow calling any function')
+    def test_device_func_as_kernel_disallowed(self):
+        @cuda.jit(device=True)
+        def f():
+            pass
+
+        with self.assertRaises(RuntimeError) as raises:
+            f[1, 1]()
+
+        self.assertIn('Cannot compile a device function as a kernel',
+                      str(raises.exception))
+
+    @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:
+        #
+        # - We don't compile a new specialization of rgba for float32 when we
+        #   shouldn't
+        # - We insert a cast when calling rgba, as opposed to failing to type.
+
+        @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))
+
+        @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))
+
+        rgba_caller[1, 1](x, channels)
+
+        self.assertEqual(0x04010203, x[0])
+
+    def _test_declare_device(self, decl):
+        self.assertEqual(decl.name, 'f1')
+        self.assertEqual(decl.sig.args, (float32[:],))
+        self.assertEqual(decl.sig.return_type, int32)
+
+    @skip_on_cudasim('cudasim does not check signatures')
+    def test_declare_device_signature(self):
+        f1 = cuda.declare_device('f1', int32(float32[:]))
+        self._test_declare_device(f1)
+
+    @skip_on_cudasim('cudasim does not check signatures')
+    def test_declare_device_string(self):
+        f1 = cuda.declare_device('f1', 'int32(float32[:])')
+        self._test_declare_device(f1)
+
+    @skip_on_cudasim('cudasim does not check signatures')
+    def test_bad_declare_device_tuple(self):
+        with self.assertRaisesRegex(TypeError, 'Return type'):
+            cuda.declare_device('f1', (float32[:],))
+
+    @skip_on_cudasim('cudasim does not check signatures')
+    def test_bad_declare_device_string(self):
+        with self.assertRaisesRegex(TypeError, 'Return type'):
+            cuda.declare_device('f1', '(float32[:],)')
+
+
+if __name__ == '__main__':
+    unittest.main()