numba-cuda 0.21.1__cp313-cp313-win_amd64.whl → 0.24.0__cp313-cp313-win_amd64.whl

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

@@ -592,6 +592,12 @@ def atomic_cas_2dim(res, old, ary, fill_val):
         old[gid] = cuda.atomic.cas(res, gid, fill_val, ary[gid])
 
 
+@unittest.skipIf(
+    not config.ENABLE_CUDASIM
+    and cuda.get_current_device().compute_capability >= (12, 0)
+    and cuda.cudadrv.runtime.get_version()[0] == 12,
+    reason="NVVM 12.9 Bugged on CC 10+",
+)
 class TestCudaAtomics(CUDATestCase):
     def setUp(self):
         super().setUp()

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

@@ -25,6 +25,11 @@ from numba.cuda.tests.support import (
     temp_directory,
     import_dynamic,
 )
+import numpy as np
+from pickle import PicklingError
+
+# Module-level global for testing that caching rejects global device arrays
+GLOBAL_DEVICE_ARRAY = None
 
 
 class BaseCacheTest(TestCase):
@@ -368,6 +373,48 @@ class CUDACachingTest(DispatcherCacheUsecasesTest):
             def f():
                 pass
 
+    def test_cannot_cache_captured_device_array(self):
+        # Test that kernels capturing device arrays from closures cannot
+        # be cached. The error can come from either NumbaPickler (for closure
+        # variables) or CUDACodeLibrary._reduce_states (for referenced objects).
+        host_data = np.array([1.0, 2.0, 3.0], dtype=np.float32)
+        captured_arr = cuda.to_device(host_data)
+
+        msg = "global device arrays"
+        with self.assertRaisesRegex(PicklingError, msg):
+
+            @cuda.jit(cache=True)
+            def cached_kernel(output):
+                i = cuda.grid(1)
+                if i < output.size:
+                    output[i] = captured_arr[i] * 2.0
+
+            output = cuda.device_array(3, dtype=np.float32)
+            cached_kernel[1, 3](output)
+
+    def test_cannot_cache_global_device_array(self):
+        # Test that kernels referencing module-level global device arrays
+        # cannot be cached.
+        global GLOBAL_DEVICE_ARRAY
+
+        host_data = np.array([1.0, 2.0, 3.0], dtype=np.float32)
+        GLOBAL_DEVICE_ARRAY = cuda.to_device(host_data)
+
+        try:
+            msg = "global device arrays"
+            with self.assertRaisesRegex(PicklingError, msg):
+
+                @cuda.jit(cache=True)
+                def cached_kernel_global(output):
+                    i = cuda.grid(1)
+                    if i < output.size:
+                        output[i] = GLOBAL_DEVICE_ARRAY[i] * 2.0
+
+                output = cuda.device_array(3, dtype=np.float32)
+                cached_kernel_global[1, 3](output)
+        finally:
+            GLOBAL_DEVICE_ARRAY = None
+
 
 @skip_on_cudasim("Simulator does not implement caching")
 class CUDACooperativeGroupTest(DispatcherCacheUsecasesTest):

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

@@ -13,6 +13,7 @@ from numba.cuda import (
     compile_all,
     LinkableCode,
 )
+from numba.cuda.cudadrv import nvrtc
 from numba.cuda.testing import skip_on_cudasim, unittest, CUDATestCase
 
 TEST_BIN_DIR = os.getenv("NUMBA_CUDA_TEST_BIN_DIR")
@@ -169,6 +170,16 @@ class TestCompile(unittest.TestCase):
         # ending in the filename of this module.
         self.assertRegex(ptx, '\\.file.*test_compiler.py"')
 
+    # We did test for the presence of debuginfo here, but in practice it made
+    # no sense - the C ABI wrapper generates a call instruction that has
+    # nothing to correlate with the DWARF, so it would confuse the debugger
+    # immediately anyway. With the resolution of Issue #588 (using separate
+    # translation of each IR module when debuginfo is enabled) the debuginfo
+    # isn't even produced for the ABI wrapper, because there was none present
+    # in that module anyway. So this test can only be expected to fail until we
+    # have a proper way of generating device functions with the C ABI without
+    # requiring the hack of generating a wrapper.
+    @unittest.expectedFailure
     def test_device_function_with_debug(self):
         # See Issue #6719 - this ensures that compilation with debug succeeds
         # with CUDA 11.2 / NVVM 7.0 onwards. Previously it failed because NVVM
@@ -547,7 +558,7 @@ class TestCompile(unittest.TestCase):
                 link_obj = LinkableCode.from_path(link)
                 if link_obj.kind == "cu":
                     # if link is a cu file, result contains a compiled object code
-                    from cuda.core.experimental import ObjectCode
+                    from numba.cuda._compat import ObjectCode
 
                     assert isinstance(code_list[1], ObjectCode)
                 else:
@@ -651,6 +662,16 @@ class TestCompileOnlyTests(unittest.TestCase):
             ),
         )
 
+    def test_compile_ptx_arch_specific(self):
+        ptx, resty = cuda.compile_ptx(lambda: None, tuple(), cc=(9, 0, "a"))
+        self.assertIn(".target sm_90a", ptx)
+
+        if nvrtc._get_nvrtc_version() >= (12, 9):
+            ptx, resty = cuda.compile_ptx(
+                lambda: None, tuple(), cc=(10, 0, "f")
+            )
+            self.assertIn(".target sm_100f", ptx)
+
 
 @skip_on_cudasim("Compilation unsupported in the simulator")
 class TestCompileWithLaunchBounds(unittest.TestCase):

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

@@ -3,12 +3,15 @@
 
 import math
 import itertools
+import sys
 
 import numpy as np
+import pytest
 
 from numba.cuda.testing import unittest, CUDATestCase
 from numba.cuda import types
 from numba import cuda
+from numba.cuda import config
 from numba.cuda.tests.cudapy.complex_usecases import (
     real_usecase,
     imag_usecase,
@@ -275,6 +278,10 @@ class TestCMath(BaseComplexTest):
     def test_log(self):
         self.check_unary_func(log_usecase)
 
+    @pytest.mark.xfail(
+        sys.version_info[:2] >= (3, 14),
+        reason="python 3.14 cmath.log behavior is different than previous versions",
+    )
     def test_log_base(self):
         values = list(itertools.product(self.more_values(), self.more_values()))
         value_types = [
@@ -333,6 +340,12 @@ class TestCMath(BaseComplexTest):
         self.check_unary_func(tanh_usecase, ulps=2, ignore_sign_on_zero=True)
 
 
+@unittest.skipIf(
+    not config.ENABLE_CUDASIM
+    and cuda.get_current_device().compute_capability >= (12, 0)
+    and cuda.cudadrv.runtime.get_version()[0] == 12,
+    reason="NVVM 12.9 Bugged on CC 10+",
+)
 class TestAtomicOnComplexComponents(CUDATestCase):
     # Based on the reproducer from Issue #8309. array.real and array.imag could
     # not be used because they required returning an array from a generated

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

@@ -48,7 +48,7 @@ def _in_list_var(list_var, var):
 
 
 def _find_assign(func_ir, var):
-    for label, block in func_ir.blocks.items():
+    for block in func_ir.blocks.values():
         for i, inst in enumerate(block.body):
             if isinstance(inst, ir.Assign) and inst.target.name != var:
                 all_var = inst.list_vars()

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

@@ -54,7 +54,7 @@ class TestDebugOutput(CUDATestCase):
                 self.assertRaises(AssertionError, check_meth, out)
 
     def _check_dump_bytecode(self, out):
-        if PYVERSION > (3, 10):
+        if PYVERSION in ((3, 11), (3, 12), (3, 13), (3, 14)):
             # binop with arg=0 is binary add, see CPython dis.py and opcode.py
             self.assertIn("BINARY_OP(arg=0", out)
         else:

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

@@ -6,6 +6,7 @@ from numba.cuda.tests.support import override_config, captured_stdout
 from numba.cuda.testing import skip_on_cudasim
 from numba import cuda
 from numba.cuda import types
+from numba.cuda.np import numpy_support
 from numba.cuda.testing import CUDATestCase
 from numba.cuda.core import config
 from textwrap import dedent
@@ -884,6 +885,99 @@ class TestCudaDebugInfo(CUDATestCase):
         """,
         )
 
+    # shared_arr -> composite -> elements[4] (data field at index 4) -> pointer without dwarfAddressSpace
+    # local_arr -> composite -> elements[4] (data field at index 4) -> pointer without dwarfAddressSpace
+    # Note: Shared memory pointers don't have dwarfAddressSpace because they are
+    # cast to generic address space via addrspacecast in cudaimpl.py
+    address_class_filechecks = r"""
+        CHECK-DAG: [[SHARED_VAR:![0-9]+]] = !DILocalVariable({{.*}}name: "shared_arr"{{.*}}type: [[SHARED_COMPOSITE:![0-9]+]]
+        CHECK-DAG: [[SHARED_COMPOSITE]] = {{.*}}!DICompositeType(elements: [[SHARED_ELEMENTS:![0-9]+]]
+        CHECK-DAG: [[SHARED_ELEMENTS]] = !{{{.*}}, {{.*}}, {{.*}}, {{.*}}, [[SHARED_DATA:![0-9]+]], {{.*}}, {{.*}}}
+        CHECK-DAG: [[SHARED_DATA]] = !DIDerivedType(baseType: [[SHARED_PTR:![0-9]+]], name: "data"
+        CHECK-DAG: [[SHARED_PTR]] = !DIDerivedType({{.*}}tag: DW_TAG_pointer_type
+        CHECK-NOT: [[SHARED_PTR]]{{.*}}dwarfAddressSpace
+
+        CHECK-DAG: [[LOCAL_VAR:![0-9]+]] = !DILocalVariable({{.*}}name: "local_arr"{{.*}}type: [[LOCAL_COMPOSITE:![0-9]+]]
+        CHECK-DAG: [[LOCAL_COMPOSITE]] = {{.*}}!DICompositeType(elements: [[LOCAL_ELEMENTS:![0-9]+]]
+        CHECK-DAG: [[LOCAL_ELEMENTS]] = !{{{.*}}, {{.*}}, {{.*}}, {{.*}}, [[LOCAL_DATA:![0-9]+]], {{.*}}, {{.*}}}
+        CHECK-DAG: [[LOCAL_DATA]] = !DIDerivedType(baseType: [[LOCAL_PTR:![0-9]+]], name: "data"
+        CHECK-DAG: [[LOCAL_PTR]] = !DIDerivedType(baseType: {{.*}}tag: DW_TAG_pointer_type
+        CHECK-NOT: [[LOCAL_PTR]]{{.*}}dwarfAddressSpace
+    """
+
+    def _test_shared_memory_address_class(self, dtype):
+        """Test that shared memory arrays have correct DWARF address class.
+
+        Shared memory pointers should NOT have dwarfAddressSpace attribute
+        because they are cast to generic address space via addrspacecast.
+        The runtime pointer type is generic, not shared, so cuda-gdb can
+        correctly dereference them. Local arrays also should not have this
+        attribute.
+        """
+        sig = (numpy_support.from_dtype(dtype),)
+
+        @cuda.jit(sig, debug=True, opt=False)
+        def kernel_with_shared(data):
+            shared_arr = cuda.shared.array(32, dtype=dtype)
+            local_arr = cuda.local.array(32, dtype=dtype)
+            idx = cuda.grid(1)
+            if idx < 32:
+                shared_arr[idx] = data + idx
+                local_arr[idx] = data * 2 + idx
+            cuda.syncthreads()
+            if idx == 0:
+                result = dtype(0)
+                for i in range(32):
+                    result += shared_arr[i] + local_arr[i]
+
+        llvm_ir = kernel_with_shared.inspect_llvm(sig)
+
+        self.assertFileCheckMatches(llvm_ir, self.address_class_filechecks)
+
+    def test_shared_memory_address_class_int32(self):
+        self._test_shared_memory_address_class(np.int32)
+
+    def test_shared_memory_address_class_complex64(self):
+        self._test_shared_memory_address_class(np.complex64)
+
+    def test_shared_memory_address_class_boolean(self):
+        self._test_shared_memory_address_class(np.bool)
+
+    def test_shared_memory_address_class_float16(self):
+        self._test_shared_memory_address_class(np.float16)
+
+    def test_shared_memory_address_class_record(self):
+        dtype = np.dtype(
+            [
+                ("a", np.int32),
+                ("b", np.float32),
+            ]
+        )
+        sig = (numpy_support.from_dtype(dtype),)
+
+        @cuda.jit(sig, debug=True, opt=False)
+        def kernel_with_shared(data):
+            shared_arr = cuda.shared.array(32, dtype=dtype)
+            local_arr = cuda.local.array(32, dtype=dtype)
+            result = cuda.local.array(1, dtype=dtype)
+            idx = cuda.grid(1)
+            if idx < 32:
+                shared_arr[idx].a = data.a + idx
+                local_arr[idx].a = data.a * 2 + idx
+                shared_arr[idx].b = data.b + idx
+                local_arr[idx].b = data.b * 2 + idx
+            cuda.syncthreads()
+            if idx == 0:
+                result[0].a = 0
+                result[0].b = 0.0
+                for i in range(32):
+                    result[0].a += shared_arr[i].a + local_arr[i].a
+                    result[0].b += shared_arr[i].b + local_arr[i].b
+
+        llvm_ir = kernel_with_shared.inspect_llvm(sig)
+
+        self.assertFileCheckMatches(llvm_ir, self.address_class_filechecks)
+
 
 if __name__ == "__main__":
     unittest.main()

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

@@ -0,0 +1,243 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+"""
+Tests for capturing device arrays (objects implementing __cuda_array_interface__)
+from global scope in CUDA kernels and device functions.
+
+This tests the capture of arrays that implement __cuda_array_interface__:
+- Numba device arrays (cuda.to_device)
+- ForeignArray (wrapper implementing __cuda_array_interface__)
+"""
+
+import numpy as np
+
+from numba import cuda
+from numba.cuda.testing import unittest, CUDATestCase, ForeignArray
+from numba.cuda.testing import skip_on_cudasim
+
+
+def make_numba_array(host_arr):
+    """Create a Numba device array from host array."""
+    return cuda.to_device(host_arr)
+
+
+def make_foreign_array(host_arr):
+    """Create a ForeignArray wrapping a Numba device array."""
+    return ForeignArray(cuda.to_device(host_arr))
+
+
+def get_host_data(arr):
+    """Copy array data back to host."""
+    if isinstance(arr, ForeignArray):
+        return arr._arr.copy_to_host()
+    return arr.copy_to_host()
+
+
+# Array factories to test: (name, factory)
+ARRAY_FACTORIES = [
+    ("numba_device", make_numba_array),
+    ("foreign", make_foreign_array),
+]
+
+
+@skip_on_cudasim("Global device array capture not supported in simulator")
+class TestDeviceArrayCapture(CUDATestCase):
+    """Test capturing device arrays from global scope."""
+
+    def test_basic_capture(self):
+        """Test basic global capture with different array types."""
+        for name, make_array in ARRAY_FACTORIES:
+            with self.subTest(array_type=name):
+                host_data = np.array(
+                    [1.0, 2.0, 3.0, 4.0, 5.0], dtype=np.float32
+                )
+                global_array = make_array(host_data)
+
+                @cuda.jit(device=True)
+                def read_global(idx):
+                    return global_array[idx]
+
+                @cuda.jit
+                def kernel(output):
+                    i = cuda.grid(1)
+                    if i < output.size:
+                        output[i] = read_global(i)
+
+                n = len(host_data)
+                output = cuda.device_array(n, dtype=np.float32)
+                kernel[1, n](output)
+
+                result = output.copy_to_host()
+                np.testing.assert_array_equal(result, host_data)
+
+    def test_computation(self):
+        """Test captured global arrays used in computations."""
+        for name, make_array in ARRAY_FACTORIES:
+            with self.subTest(array_type=name):
+                host_data = np.array(
+                    [1.0, 2.0, 3.0, 4.0, 5.0], dtype=np.float32
+                )
+                global_array = make_array(host_data)
+
+                @cuda.jit(device=True)
+                def double_global_value(idx):
+                    return global_array[idx] * 2.0
+
+                @cuda.jit
+                def kernel(output):
+                    i = cuda.grid(1)
+                    if i < output.size:
+                        output[i] = double_global_value(i)
+
+                n = len(host_data)
+                output = cuda.device_array(n, dtype=np.float32)
+                kernel[1, n](output)
+
+                result = output.copy_to_host()
+                expected = host_data * 2.0
+                np.testing.assert_array_equal(result, expected)
+
+    def test_mutability(self):
+        """Test that captured arrays can be written to (mutability)."""
+        for name, make_array in ARRAY_FACTORIES:
+            with self.subTest(array_type=name):
+                host_data = np.zeros(5, dtype=np.float32)
+                mutable_array = make_array(host_data)
+
+                @cuda.jit
+                def write_kernel():
+                    i = cuda.grid(1)
+                    if i < 5:
+                        mutable_array[i] = float(i + 1)
+
+                write_kernel[1, 5]()
+
+                result = get_host_data(mutable_array)
+                expected = np.array([1.0, 2.0, 3.0, 4.0, 5.0], dtype=np.float32)
+                np.testing.assert_array_equal(result, expected)
+
+    def test_multiple_arrays(self):
+        """Test capturing multiple arrays from globals."""
+        for name, make_array in ARRAY_FACTORIES:
+            with self.subTest(array_type=name):
+                host_a = np.array([1.0, 2.0, 3.0], dtype=np.float32)
+                host_b = np.array([10.0, 20.0, 30.0], dtype=np.float32)
+                arr_a = make_array(host_a)
+                arr_b = make_array(host_b)
+
+                @cuda.jit(device=True)
+                def add_globals(idx):
+                    return arr_a[idx] + arr_b[idx]
+
+                @cuda.jit
+                def kernel(output):
+                    i = cuda.grid(1)
+                    if i < output.size:
+                        output[i] = add_globals(i)
+
+                output = cuda.device_array(3, dtype=np.float32)
+                kernel[1, 3](output)
+
+                result = output.copy_to_host()
+                expected = np.array([11.0, 22.0, 33.0], dtype=np.float32)
+                np.testing.assert_array_equal(result, expected)
+
+    def test_multidimensional(self):
+        """Test capturing multidimensional arrays."""
+        for name, make_array in ARRAY_FACTORIES:
+            with self.subTest(array_type=name):
+                host_2d = np.array(
+                    [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], dtype=np.float32
+                )
+                arr_2d = make_array(host_2d)
+
+                @cuda.jit(device=True)
+                def read_2d(row, col):
+                    return arr_2d[row, col]
+
+                @cuda.jit
+                def kernel(output):
+                    i = cuda.grid(1)
+                    if i < 6:
+                        row = i // 2
+                        col = i % 2
+                        output[i] = read_2d(row, col)
+
+                output = cuda.device_array(6, dtype=np.float32)
+                kernel[1, 6](output)
+
+                result = output.copy_to_host()
+                expected = host_2d.flatten()
+                np.testing.assert_array_equal(result, expected)
+
+    def test_dtypes(self):
+        """Test capturing arrays with different dtypes."""
+        dtypes = [
+            (np.int32, [10, 20, 30, 40]),
+            (np.float64, [1.5, 2.5, 3.5, 4.5]),
+        ]
+
+        for name, make_array in ARRAY_FACTORIES:
+            for dtype, values in dtypes:
+                with self.subTest(array_type=name, dtype=dtype):
+                    host_data = np.array(values, dtype=dtype)
+                    global_arr = make_array(host_data)
+
+                    @cuda.jit(device=True)
+                    def read_arr(idx):
+                        return global_arr[idx]
+
+                    @cuda.jit
+                    def kernel(output):
+                        i = cuda.grid(1)
+                        if i < output.size:
+                            output[i] = read_arr(i)
+
+                    output = cuda.device_array(len(host_data), dtype=dtype)
+                    kernel[1, len(host_data)](output)
+                    np.testing.assert_array_equal(
+                        output.copy_to_host(), host_data
+                    )
+
+    def test_direct_kernel_access(self):
+        """Test direct kernel access (not via device function)."""
+        for name, make_array in ARRAY_FACTORIES:
+            with self.subTest(array_type=name):
+                host_data = np.array([7.0, 8.0, 9.0], dtype=np.float32)
+                global_direct = make_array(host_data)
+
+                @cuda.jit
+                def direct_access_kernel(output):
+                    i = cuda.grid(1)
+                    if i < output.size:
+                        output[i] = global_direct[i] + 1.0
+
+                output = cuda.device_array(3, dtype=np.float32)
+                direct_access_kernel[1, 3](output)
+
+                result = output.copy_to_host()
+                expected = np.array([8.0, 9.0, 10.0], dtype=np.float32)
+                np.testing.assert_array_equal(result, expected)
+
+    def test_zero_dimensional(self):
+        """Test capturing 0-D (scalar) device arrays."""
+        for name, make_array in ARRAY_FACTORIES:
+            with self.subTest(array_type=name):
+                host_0d = np.array(42.0, dtype=np.float32)
+                global_0d = make_array(host_0d)
+
+                @cuda.jit
+                def kernel_0d(output):
+                    output[()] = global_0d[()] * 2.0
+
+                output = cuda.device_array((), dtype=np.float32)
+                kernel_0d[1, 1](output)
+
+                result = output.copy_to_host()
+                expected = 84.0
+                self.assertEqual(result, expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -1,7 +1,7 @@
 # SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: BSD-2-Clause
 
-from numba.cuda.cudadrv.driver import CudaAPIError
+from numba.cuda._compat import CUDAError
 import numpy as np
 import threading
 
@@ -767,8 +767,8 @@ class TestLaunchBounds(CUDATestCase):
         f[1, 128]()
 
         # Test launch bound exceeded
-        msg = "Call to cuLaunchKernel results in CUDA_ERROR_INVALID_VALUE"
-        with self.assertRaisesRegex(CudaAPIError, msg):
+        msg = "CUDA_ERROR_INVALID_VALUE"
+        with self.assertRaisesRegex(CUDAError, msg):
             f[1, 256]()
 
         sig = f.signatures[0]

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

@@ -860,7 +860,7 @@ class TestIntrinsic(TestCase):
             "TestIntrinsic.test_docstring.<locals>.void_func",
             void_func.__qualname__,
         )
-        self.assertDictEqual({"a": int}, void_func.__annotations__)
+        self.assertDictEqual({"a": int}, inspect.get_annotations(void_func))
         self.assertEqual("void_func docstring", void_func.__doc__)
 
 

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

@@ -0,0 +1,35 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import numpy as np
+
+from numba import cuda
+from numba.cuda import HAS_NUMBA
+from numba.cuda.testing import unittest, CUDATestCase, skip_on_cudasim
+
+if HAS_NUMBA:
+    from numba.extending import overload
+
+
+@skip_on_cudasim("Simulator does not support the extension API")
+@unittest.skipUnless(HAS_NUMBA, "Tests interoperability with Numba")
+class TestNumbaInterop(CUDATestCase):
+    def test_overload_inline_always(self):
+        # From Issue #624
+        def get_42():
+            raise NotImplementedError()
+
+        @overload(get_42, target="cuda", inline="always")
+        def ol_blas_get_accumulator():
+            def impl():
+                return 42
+
+            return impl
+
+        @cuda.jit
+        def kernel(a):
+            a[0] = get_42()
+
+        a = np.empty(1, dtype=np.float32)
+        kernel[1, 1](a)
+        np.testing.assert_equal(a[0], 42)

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

@@ -117,6 +117,39 @@ print_bfloat16[1, 1]()
 cuda.synchronize()
 """
 
+print_int64_tuple_usecase = """\
+from numba import cuda
+
+@cuda.jit
+def print_tuple(tup):
+    print(tup)
+
+print_tuple[1, 1]((1, 2, 3, 4, 5))
+cuda.synchronize()
+"""
+
+print_nested_mixed_type_tuple_usecase = """\
+from numba import cuda
+
+@cuda.jit
+def print_tuple(tup):
+    print(tup)
+
+print_tuple[1, 1]((1, ((2, 4), 3.0), (4,), 5))
+cuda.synchronize()
+"""
+
+print_single_element_tuple_usecase = """\
+from numba import cuda
+
+@cuda.jit
+def print_tuple(tup):
+    print(tup)
+
+print_tuple[1, 1]((1,))
+cuda.synchronize()
+"""
+
 
 class TestPrint(CUDATestCase):
     # Note that in these tests we generally strip the output to avoid dealing
@@ -163,6 +196,24 @@ class TestPrint(CUDATestCase):
         expected = [str(i) for i in np.ndindex(2, 2, 2)]
         self.assertEqual(sorted(lines), expected)
 
+    def test_tuple(self):
+        output, _ = self.run_code(print_int64_tuple_usecase)
+        lines = [line.strip() for line in output.splitlines(True)]
+        expected = ["(1, 2, 3, 4, 5)"]
+        self.assertEqual(lines, expected)
+
+    def test_nested_mixed_type_tuple(self):
+        output, _ = self.run_code(print_nested_mixed_type_tuple_usecase)
+        (line,) = (line.strip() for line in output.splitlines(True))
+        expected = r"^\(1, \(\(2, 4\), 3\.0+\), \(4,\), 5\)$"
+        self.assertRegex(line, expected)
+
+    def test_single_element_tuple(self):
+        output, _ = self.run_code(print_single_element_tuple_usecase)
+        lines = [line.strip() for line in output.splitlines(True)]
+        expected = ["(1,)"]
+        self.assertEqual(lines, expected)
+
     @skip_on_cudasim("bfloat16 on host is not yet supported.")
     def test_bfloat16(self):
         output, _ = self.run_code(print_bfloat16_usecase)