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

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

@@ -0,0 +1,271 @@
+import numpy as np
+from numba import cuda, int32, float32
+from numba.cuda.testing import skip_on_cudasim, unittest, CUDATestCase
+from numba.core.config import ENABLE_CUDASIM
+
+
+def useless_syncthreads(ary):
+    i = cuda.grid(1)
+    cuda.syncthreads()
+    ary[i] = i
+
+
+def useless_syncwarp(ary):
+    i = cuda.grid(1)
+    cuda.syncwarp()
+    ary[i] = i
+
+
+def useless_syncwarp_with_mask(ary):
+    i = cuda.grid(1)
+    cuda.syncwarp(0xFFFF)
+    ary[i] = i
+
+
+def coop_syncwarp(res):
+    sm = cuda.shared.array(32, int32)
+    i = cuda.grid(1)
+
+    sm[i] = i
+    cuda.syncwarp()
+
+    if i < 16:
+        sm[i] = sm[i] + sm[i + 16]
+        cuda.syncwarp(0xFFFF)
+
+    if i < 8:
+        sm[i] = sm[i] + sm[i + 8]
+        cuda.syncwarp(0xFF)
+
+    if i < 4:
+        sm[i] = sm[i] + sm[i + 4]
+        cuda.syncwarp(0xF)
+
+    if i < 2:
+        sm[i] = sm[i] + sm[i + 2]
+        cuda.syncwarp(0x3)
+
+    if i == 0:
+        res[0] = sm[0] + sm[1]
+
+
+def simple_smem(ary):
+    N = 100
+    sm = cuda.shared.array(N, int32)
+    i = cuda.grid(1)
+    if i == 0:
+        for j in range(N):
+            sm[j] = j
+    cuda.syncthreads()
+    ary[i] = sm[i]
+
+
+def coop_smem2d(ary):
+    i, j = cuda.grid(2)
+    sm = cuda.shared.array((10, 20), float32)
+    sm[i, j] = (i + 1) / (j + 1)
+    cuda.syncthreads()
+    ary[i, j] = sm[i, j]
+
+
+def dyn_shared_memory(ary):
+    i = cuda.grid(1)
+    sm = cuda.shared.array(0, float32)
+    sm[i] = i * 2
+    cuda.syncthreads()
+    ary[i] = sm[i]
+
+
+def use_threadfence(ary):
+    ary[0] += 123
+    cuda.threadfence()
+    ary[0] += 321
+
+
+def use_threadfence_block(ary):
+    ary[0] += 123
+    cuda.threadfence_block()
+    ary[0] += 321
+
+
+def use_threadfence_system(ary):
+    ary[0] += 123
+    cuda.threadfence_system()
+    ary[0] += 321
+
+
+def use_syncthreads_count(ary_in, ary_out):
+    i = cuda.grid(1)
+    ary_out[i] = cuda.syncthreads_count(ary_in[i])
+
+
+def use_syncthreads_and(ary_in, ary_out):
+    i = cuda.grid(1)
+    ary_out[i] = cuda.syncthreads_and(ary_in[i])
+
+
+def use_syncthreads_or(ary_in, ary_out):
+    i = cuda.grid(1)
+    ary_out[i] = cuda.syncthreads_or(ary_in[i])
+
+
+def _safe_cc_check(cc):
+    if ENABLE_CUDASIM:
+        return True
+    else:
+        return cuda.get_current_device().compute_capability >= cc
+
+
+class TestCudaSync(CUDATestCase):
+    def _test_useless(self, kernel):
+        compiled = cuda.jit("void(int32[::1])")(kernel)
+        nelem = 10
+        ary = np.empty(nelem, dtype=np.int32)
+        exp = np.arange(nelem, dtype=np.int32)
+        compiled[1, nelem](ary)
+        np.testing.assert_equal(ary, exp)
+
+    def test_useless_syncthreads(self):
+        self._test_useless(useless_syncthreads)
+
+    @skip_on_cudasim("syncwarp not implemented on cudasim")
+    def test_useless_syncwarp(self):
+        self._test_useless(useless_syncwarp)
+
+    @skip_on_cudasim("syncwarp not implemented on cudasim")
+    @unittest.skipUnless(_safe_cc_check((7, 0)),
+                         "Partial masks require CC 7.0 or greater")
+    def test_useless_syncwarp_with_mask(self):
+        self._test_useless(useless_syncwarp_with_mask)
+
+    @skip_on_cudasim("syncwarp not implemented on cudasim")
+    @unittest.skipUnless(_safe_cc_check((7, 0)),
+                         "Partial masks require CC 7.0 or greater")
+    def test_coop_syncwarp(self):
+        # coop_syncwarp computes the sum of all integers from 0 to 31 (496)
+        # using a single warp
+        expected = 496
+        nthreads = 32
+        nblocks = 1
+
+        compiled = cuda.jit("void(int32[::1])")(coop_syncwarp)
+        res = np.zeros(1, dtype=np.int32)
+        compiled[nblocks, nthreads](res)
+        np.testing.assert_equal(expected, res[0])
+
+    def test_simple_smem(self):
+        compiled = cuda.jit("void(int32[::1])")(simple_smem)
+        nelem = 100
+        ary = np.empty(nelem, dtype=np.int32)
+        compiled[1, nelem](ary)
+        self.assertTrue(np.all(ary == np.arange(nelem, dtype=np.int32)))
+
+    def test_coop_smem2d(self):
+        compiled = cuda.jit("void(float32[:,::1])")(coop_smem2d)
+        shape = 10, 20
+        ary = np.empty(shape, dtype=np.float32)
+        compiled[1, shape](ary)
+        exp = np.empty_like(ary)
+        for i in range(ary.shape[0]):
+            for j in range(ary.shape[1]):
+                exp[i, j] = (i + 1) / (j + 1)
+        self.assertTrue(np.allclose(ary, exp))
+
+    def test_dyn_shared_memory(self):
+        compiled = cuda.jit("void(float32[::1])")(dyn_shared_memory)
+        shape = 50
+        ary = np.empty(shape, dtype=np.float32)
+        compiled[1, shape, 0, ary.size * 4](ary)
+        self.assertTrue(np.all(ary == 2 * np.arange(ary.size, dtype=np.int32)))
+
+    def test_threadfence_codegen(self):
+        # Does not test runtime behavior, just the code generation.
+        sig = (int32[:],)
+        compiled = cuda.jit(sig)(use_threadfence)
+        ary = np.zeros(10, dtype=np.int32)
+        compiled[1, 1](ary)
+        self.assertEqual(123 + 321, ary[0])
+        if not ENABLE_CUDASIM:
+            self.assertIn("membar.gl;", compiled.inspect_asm(sig))
+
+    def test_threadfence_block_codegen(self):
+        # Does not test runtime behavior, just the code generation.
+        sig = (int32[:],)
+        compiled = cuda.jit(sig)(use_threadfence_block)
+        ary = np.zeros(10, dtype=np.int32)
+        compiled[1, 1](ary)
+        self.assertEqual(123 + 321, ary[0])
+        if not ENABLE_CUDASIM:
+            self.assertIn("membar.cta;", compiled.inspect_asm(sig))
+
+    def test_threadfence_system_codegen(self):
+        # Does not test runtime behavior, just the code generation.
+        sig = (int32[:],)
+        compiled = cuda.jit(sig)(use_threadfence_system)
+        ary = np.zeros(10, dtype=np.int32)
+        compiled[1, 1](ary)
+        self.assertEqual(123 + 321, ary[0])
+        if not ENABLE_CUDASIM:
+            self.assertIn("membar.sys;", compiled.inspect_asm(sig))
+
+    def _test_syncthreads_count(self, in_dtype):
+        compiled = cuda.jit(use_syncthreads_count)
+        ary_in = np.ones(72, dtype=in_dtype)
+        ary_out = np.zeros(72, dtype=np.int32)
+        ary_in[31] = 0
+        ary_in[42] = 0
+        compiled[1, 72](ary_in, ary_out)
+        self.assertTrue(np.all(ary_out == 70))
+
+    def test_syncthreads_count(self):
+        self._test_syncthreads_count(np.int32)
+
+    def test_syncthreads_count_upcast(self):
+        self._test_syncthreads_count(np.int16)
+
+    def test_syncthreads_count_downcast(self):
+        self._test_syncthreads_count(np.int64)
+
+    def _test_syncthreads_and(self, in_dtype):
+        compiled = cuda.jit(use_syncthreads_and)
+        nelem = 100
+        ary_in = np.ones(nelem, dtype=in_dtype)
+        ary_out = np.zeros(nelem, dtype=np.int32)
+        compiled[1, nelem](ary_in, ary_out)
+        self.assertTrue(np.all(ary_out == 1))
+        ary_in[31] = 0
+        compiled[1, nelem](ary_in, ary_out)
+        self.assertTrue(np.all(ary_out == 0))
+
+    def test_syncthreads_and(self):
+        self._test_syncthreads_and(np.int32)
+
+    def test_syncthreads_and_upcast(self):
+        self._test_syncthreads_and(np.int16)
+
+    def test_syncthreads_and_downcast(self):
+        self._test_syncthreads_and(np.int64)
+
+    def _test_syncthreads_or(self, in_dtype):
+        compiled = cuda.jit(use_syncthreads_or)
+        nelem = 100
+        ary_in = np.zeros(nelem, dtype=in_dtype)
+        ary_out = np.zeros(nelem, dtype=np.int32)
+        compiled[1, nelem](ary_in, ary_out)
+        self.assertTrue(np.all(ary_out == 0))
+        ary_in[31] = 1
+        compiled[1, nelem](ary_in, ary_out)
+        self.assertTrue(np.all(ary_out == 1))
+
+    def test_syncthreads_or(self):
+        self._test_syncthreads_or(np.int32)
+
+    def test_syncthreads_or_upcast(self):
+        self._test_syncthreads_or(np.int16)
+
+    def test_syncthreads_or_downcast(self):
+        self._test_syncthreads_or(np.int64)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,80 @@
+import numpy as np
+from numba import cuda
+from numba.cuda.kernels.transpose import transpose
+from numba.cuda.testing import unittest
+from numba.cuda.testing import skip_on_cudasim, CUDATestCase
+
+
+recordwith2darray = np.dtype([('i', np.int32),
+                              ('j', np.float32, (3, 2))])
+
+
+@skip_on_cudasim('Device Array API unsupported in the simulator')
+class TestTranspose(CUDATestCase):
+
+    def test_transpose(self):
+        variants = ((5, 6, np.float64),
+                    (128, 128, np.complex128),
+                    (1025, 512, np.float64))
+
+        for rows, cols, dtype in variants:
+            with self.subTest(rows=rows, cols=cols, dtype=dtype):
+                x = np.arange(rows * cols, dtype=dtype).reshape(cols, rows)
+                y = np.zeros(rows * cols, dtype=dtype).reshape(rows, cols)
+                dx = cuda.to_device(x)
+                dy = cuda.cudadrv.devicearray.from_array_like(y)
+                transpose(dx, dy)
+                dy.copy_to_host(y)
+                np.testing.assert_array_equal(x.transpose(), y)
+
+    small_variants = ((2, 3), (16, 16), (16, 17), (17, 16), (14, 15), (15, 14),
+                      (14, 14))
+
+    def test_transpose_record(self):
+        for rows, cols in self.small_variants:
+            with self.subTest(rows=rows, cols=cols):
+                arr = np.recarray((rows, cols), dtype=recordwith2darray)
+                for x in range(rows):
+                    for y in range(cols):
+                        arr[x, y].i = x ** 2 + y
+                        j = np.arange(3 * 2, dtype=np.float32)
+                        arr[x, y].j = j.reshape(3, 2) * x + y
+
+                transposed = arr.T
+                d_arr = cuda.to_device(arr)
+                d_transposed = cuda.device_array_like(transposed)
+                transpose(d_arr, d_transposed)
+                host_transposed = d_transposed.copy_to_host()
+                np.testing.assert_array_equal(transposed, host_transposed)
+
+    def test_transpose_bool(self):
+        for rows, cols in self.small_variants:
+            with self.subTest(rows=rows, cols=cols):
+                arr = np.random.randint(2, size=(rows, cols), dtype=np.bool_)
+                transposed = arr.T
+
+                d_arr = cuda.to_device(arr)
+                d_transposed = cuda.device_array_like(transposed)
+                transpose(d_arr, d_transposed)
+
+                host_transposed = d_transposed.copy_to_host()
+                np.testing.assert_array_equal(transposed, host_transposed)
+
+    def test_transpose_view(self):
+        # Because the strides of transposes of views differ to those in NumPy
+        # (see issue #4974), we test the shape and strides of a transpose.
+        a = np.arange(120, dtype=np.int64).reshape((10, 12))
+        a_view_t = a[::2, ::2].T
+
+        d_a = cuda.to_device(a)
+        d_a_view_t = d_a[::2, ::2].T
+
+        self.assertEqual(d_a_view_t.shape, (6, 5))
+        self.assertEqual(d_a_view_t.strides, (40, 8))
+
+        h_a_view_t = d_a_view_t.copy_to_host()
+        np.testing.assert_array_equal(a_view_t, h_a_view_t)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,277 @@
+import functools
+import numpy as np
+import unittest
+
+from numba import config, cuda, types
+from numba.tests.support import TestCase
+from numba.tests.test_ufuncs import BasicUFuncTest
+
+
+def _make_ufunc_usecase(ufunc):
+    ldict = {}
+    arg_str = ','.join(['a{0}'.format(i) for i in range(ufunc.nargs)])
+    func_str = f'def fn({arg_str}):\n    np.{ufunc.__name__}({arg_str})'
+    exec(func_str, globals(), ldict)
+    fn = ldict['fn']
+    fn.__name__ = '{0}_usecase'.format(ufunc.__name__)
+    return fn
+
+
+# This test would also be a CUDATestCase, but to avoid a confusing and
+# potentially dangerous inheritance diamond with setUp methods that modify
+# global state, we implement the necessary parts of CUDATestCase within this
+# class instead. These are:
+#
+# - Disable parallel testing with _numba_parallel_test_.
+# - Disabling CUDA performance warnings for the duration of tests.
+class TestUFuncs(BasicUFuncTest, TestCase):
+    _numba_parallel_test_ = False
+
+    def setUp(self):
+        BasicUFuncTest.setUp(self)
+
+        # The basic ufunc test does not set up complex inputs, so we'll add
+        # some here for testing with CUDA.
+        self.inputs.extend([
+            (np.complex64(-0.5 - 0.5j), types.complex64),
+            (np.complex64(0.0), types.complex64),
+            (np.complex64(0.5 + 0.5j), types.complex64),
+
+            (np.complex128(-0.5 - 0.5j), types.complex128),
+            (np.complex128(0.0), types.complex128),
+            (np.complex128(0.5 + 0.5j), types.complex128),
+
+            (np.array([-0.5 - 0.5j, 0.0, 0.5 + 0.5j], dtype='c8'),
+             types.Array(types.complex64, 1, 'C')),
+            (np.array([-0.5 - 0.5j, 0.0, 0.5 + 0.5j], dtype='c16'),
+             types.Array(types.complex128, 1, 'C')),
+        ])
+
+        # Test with multiple dimensions
+        self.inputs.extend([
+            # Basic 2D and 3D arrays
+            (np.linspace(0, 1).reshape((5, -1)),
+             types.Array(types.float64, 2, 'C')),
+            (np.linspace(0, 1).reshape((2, 5, -1)),
+             types.Array(types.float64, 3, 'C')),
+            # Complex data (i.e. interleaved)
+            (np.linspace(0, 1 + 1j).reshape(5, -1),
+             types.Array(types.complex128, 2, 'C')),
+            # F-ordered
+            (np.asfortranarray(np.linspace(0, 1).reshape((5, -1))),
+             types.Array(types.float64, 2, 'F')),
+        ])
+
+        # Add tests for other integer types
+        self.inputs.extend([
+            (np.uint8(0), types.uint8),
+            (np.uint8(1), types.uint8),
+            (np.int8(-1), types.int8),
+            (np.int8(0), types.int8),
+
+            (np.uint16(0), types.uint16),
+            (np.uint16(1), types.uint16),
+            (np.int16(-1), types.int16),
+            (np.int16(0), types.int16),
+
+            (np.ulonglong(0), types.ulonglong),
+            (np.ulonglong(1), types.ulonglong),
+            (np.longlong(-1), types.longlong),
+            (np.longlong(0), types.longlong),
+
+            (np.array([0,1], dtype=np.ulonglong),
+             types.Array(types.ulonglong, 1, 'C')),
+            (np.array([0,1], dtype=np.longlong),
+             types.Array(types.longlong, 1, 'C')),
+        ])
+
+        self._low_occupancy_warnings = config.CUDA_LOW_OCCUPANCY_WARNINGS
+        self._warn_on_implicit_copy = config.CUDA_WARN_ON_IMPLICIT_COPY
+
+        # Disable warnings about low gpu utilization in the test suite
+        config.CUDA_LOW_OCCUPANCY_WARNINGS = 0
+        # Disable warnings about host arrays in the test suite
+        config.CUDA_WARN_ON_IMPLICIT_COPY = 0
+
+    def tearDown(self):
+        # Restore original warning settings
+        config.CUDA_LOW_OCCUPANCY_WARNINGS = self._low_occupancy_warnings
+        config.CUDA_WARN_ON_IMPLICIT_COPY = self._warn_on_implicit_copy
+
+    def _make_ufunc_usecase(self, ufunc):
+        return _make_ufunc_usecase(ufunc)
+
+    @functools.lru_cache(maxsize=None)
+    def _compile(self, pyfunc, args):
+        # We return an already-configured kernel so that basic_ufunc_test can
+        # call it just like it does for a CPU function
+        return cuda.jit(args)(pyfunc)[1, 1]
+
+    def basic_int_ufunc_test(self, name=None):
+        skip_inputs = [
+            types.float32,
+            types.float64,
+            types.Array(types.float32, 1, 'C'),
+            types.Array(types.float32, 2, 'C'),
+            types.Array(types.float64, 1, 'C'),
+            types.Array(types.float64, 2, 'C'),
+            types.Array(types.float64, 3, 'C'),
+            types.Array(types.float64, 2, 'F'),
+            types.complex64,
+            types.complex128,
+            types.Array(types.complex64, 1, 'C'),
+            types.Array(types.complex64, 2, 'C'),
+            types.Array(types.complex128, 1, 'C'),
+            types.Array(types.complex128, 2, 'C'),
+        ]
+        self.basic_ufunc_test(name, skip_inputs=skip_inputs)
+
+    ############################################################################
+    # Trigonometric Functions
+
+    def test_sin_ufunc(self):
+        self.basic_ufunc_test(np.sin, kinds='cf')
+
+    def test_cos_ufunc(self):
+        self.basic_ufunc_test(np.cos, kinds='cf')
+
+    def test_tan_ufunc(self):
+        self.basic_ufunc_test(np.tan, kinds='cf')
+
+    def test_arcsin_ufunc(self):
+        self.basic_ufunc_test(np.arcsin, kinds='cf')
+
+    def test_arccos_ufunc(self):
+        self.basic_ufunc_test(np.arccos, kinds='cf')
+
+    def test_arctan_ufunc(self):
+        self.basic_ufunc_test(np.arctan, kinds='cf')
+
+    def test_arctan2_ufunc(self):
+        self.basic_ufunc_test(np.arctan2, kinds='f')
+
+    def test_hypot_ufunc(self):
+        self.basic_ufunc_test(np.hypot, kinds='f')
+
+    def test_sinh_ufunc(self):
+        self.basic_ufunc_test(np.sinh, kinds='cf')
+
+    def test_cosh_ufunc(self):
+        self.basic_ufunc_test(np.cosh, kinds='cf')
+
+    def test_tanh_ufunc(self):
+        self.basic_ufunc_test(np.tanh, kinds='cf')
+
+    def test_arcsinh_ufunc(self):
+        self.basic_ufunc_test(np.arcsinh, kinds='cf')
+
+    def test_arccosh_ufunc(self):
+        self.basic_ufunc_test(np.arccosh, kinds='cf')
+
+    def test_arctanh_ufunc(self):
+        # arctanh is only valid is only finite in the range ]-1, 1[
+        # This means that for any of the integer types it will produce
+        # conversion from infinity/-infinity to integer. That's undefined
+        # behavior in C, so the results may vary from implementation to
+        # implementation. This means that the result from the compiler
+        # used to compile NumPy may differ from the result generated by
+        # llvm. Skipping the integer types in this test avoids failed
+        # tests because of this.
+        to_skip = [types.Array(types.uint32, 1, 'C'), types.uint32,
+                   types.Array(types.int32, 1, 'C'), types.int32,
+                   types.Array(types.uint64, 1, 'C'), types.uint64,
+                   types.Array(types.int64, 1, 'C'), types.int64]
+
+        self.basic_ufunc_test(np.arctanh, skip_inputs=to_skip, kinds='cf')
+
+    def test_deg2rad_ufunc(self):
+        self.basic_ufunc_test(np.deg2rad, kinds='f')
+
+    def test_rad2deg_ufunc(self):
+        self.basic_ufunc_test(np.rad2deg, kinds='f')
+
+    def test_degrees_ufunc(self):
+        self.basic_ufunc_test(np.degrees, kinds='f')
+
+    def test_radians_ufunc(self):
+        self.basic_ufunc_test(np.radians, kinds='f')
+
+    ############################################################################
+    # Comparison functions
+    def test_greater_ufunc(self):
+        self.signed_unsigned_cmp_test(np.greater)
+
+    def test_greater_equal_ufunc(self):
+        self.signed_unsigned_cmp_test(np.greater_equal)
+
+    def test_less_ufunc(self):
+        self.signed_unsigned_cmp_test(np.less)
+
+    def test_less_equal_ufunc(self):
+        self.signed_unsigned_cmp_test(np.less_equal)
+
+    def test_not_equal_ufunc(self):
+        self.signed_unsigned_cmp_test(np.not_equal)
+
+    def test_equal_ufunc(self):
+        self.signed_unsigned_cmp_test(np.equal)
+
+    def test_logical_and_ufunc(self):
+        self.basic_ufunc_test(np.logical_and)
+
+    def test_logical_or_ufunc(self):
+        self.basic_ufunc_test(np.logical_or)
+
+    def test_logical_xor_ufunc(self):
+        self.basic_ufunc_test(np.logical_xor)
+
+    def test_logical_not_ufunc(self):
+        self.basic_ufunc_test(np.logical_not)
+
+    def test_maximum_ufunc(self):
+        self.basic_ufunc_test(np.maximum)
+
+    def test_minimum_ufunc(self):
+        self.basic_ufunc_test(np.minimum)
+
+    def test_fmax_ufunc(self):
+        self.basic_ufunc_test(np.fmax)
+
+    def test_fmin_ufunc(self):
+        self.basic_ufunc_test(np.fmin)
+
+    def test_bitwise_and_ufunc(self):
+        self.basic_int_ufunc_test(np.bitwise_and)
+
+    def test_bitwise_or_ufunc(self):
+        self.basic_int_ufunc_test(np.bitwise_or)
+
+    def test_bitwise_xor_ufunc(self):
+        self.basic_int_ufunc_test(np.bitwise_xor)
+
+    def test_invert_ufunc(self):
+        self.basic_int_ufunc_test(np.invert)
+
+    def test_bitwise_not_ufunc(self):
+        self.basic_int_ufunc_test(np.bitwise_not)
+
+    # Note: there is no entry for np.left_shift and np.right_shift
+    # because their implementations in NumPy have undefined behavior
+    # when the second argument is a negative. See the comment in
+    # numba/tests/test_ufuncs.py for more details.
+
+    ############################################################################
+    # Mathematical Functions
+
+    def test_log_ufunc(self):
+        self.basic_ufunc_test(np.log, kinds='cf')
+
+    def test_log2_ufunc(self):
+        self.basic_ufunc_test(np.log2, kinds='cf')
+
+    def test_log10_ufunc(self):
+        self.basic_ufunc_test(np.log10, kinds='cf')
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,47 @@
+from numba.cuda.testing import unittest, CUDATestCase
+from numba import cuda
+from numba.core import config
+
+
+class MyError(Exception):
+    pass
+
+
+regex_pattern = (
+    r'In function [\'"]test_exc[\'"], file [\:\.\/\\\-a-zA-Z_0-9]+, line \d+'
+)
+
+
+class TestUserExc(CUDATestCase):
+
+    def setUp(self):
+        super().setUp()
+        # LTO optimizes away the exception status due to an oversight
+        # in the way we generate it (it is not added to the used list).
+        # See https://github.com/numba/numba/issues/9526.
+        self.skip_if_lto("Exceptions not supported with LTO")
+
+    def test_user_exception(self):
+        @cuda.jit("void(int32)", debug=True)
+        def test_exc(x):
+            if x == 1:
+                raise MyError
+            elif x == 2:
+                raise MyError("foo")
+
+        test_exc[1, 1](0)    # no raise
+        with self.assertRaises(MyError) as cm:
+            test_exc[1, 1](1)
+        if not config.ENABLE_CUDASIM:
+            self.assertRegex(str(cm.exception), regex_pattern)
+        self.assertIn("tid=[0, 0, 0] ctaid=[0, 0, 0]", str(cm.exception))
+        with self.assertRaises(MyError) as cm:
+            test_exc[1, 1](2)
+        if not config.ENABLE_CUDASIM:
+            self.assertRegex(str(cm.exception), regex_pattern)
+            self.assertRegex(str(cm.exception), regex_pattern)
+        self.assertIn("tid=[0, 0, 0] ctaid=[0, 0, 0]: foo", str(cm.exception))
+
+
+if __name__ == '__main__':
+    unittest.main()