numba-cuda 0.22.0__cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

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

@@ -0,0 +1,152 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+"""
+Test cases adapted from numba/tests/test_enums.py
+"""
+
+import numpy as np
+
+from numba.cuda import int16, int32
+from numba.cuda import vectorize, HAS_NUMBA
+
+if HAS_NUMBA:
+    from numba import njit
+from numba import cuda
+from numba.cuda import types
+from numba.cuda.testing import (
+    unittest,
+    CUDATestCase,
+    skip_on_cudasim,
+    skip_on_standalone_numba_cuda,
+)
+from numba.cuda.tests.cudapy.enum_usecases import (
+    Color,
+    Shape,
+    Planet,
+    RequestError,
+    IntEnumWithNegatives,
+)
+
+
+class EnumTest(CUDATestCase):
+    pairs = [
+        (Color.red, Color.red),
+        (Color.red, Color.green),
+        (Planet.EARTH, Planet.EARTH),
+        (Planet.VENUS, Planet.MARS),
+        (Shape.circle, IntEnumWithNegatives.two),  # IntEnum, same value
+    ]
+
+    def test_compare(self):
+        def f(a, b, out):
+            out[0] = a == b
+            out[1] = a != b
+            out[2] = a is b
+            out[3] = a is not b
+
+        cuda_f = cuda.jit(f)
+        for a, b in self.pairs:
+            got = np.zeros((4,), dtype=np.bool_)
+            expected = got.copy()
+            cuda_f[1, 1](a, b, got)
+            f(a, b, expected)
+            self.assertPreciseEqual(expected, got)
+
+    def test_getattr_getitem(self):
+        def f(out):
+            # Lookup of an enum member on its class
+            out[0] = Color.red == Color.green
+            out[1] = Color["red"] == Color["green"]
+
+        cuda_f = cuda.jit(f)
+        got = np.zeros((2,), dtype=np.bool_)
+        expected = got.copy()
+        cuda_f[1, 1](got)
+        f(expected)
+        self.assertPreciseEqual(expected, got)
+
+    @skip_on_standalone_numba_cuda
+    def test_return_from_device_func(self):
+        @njit
+        def inner(pred):
+            return Color.red if pred else Color.green
+
+        def f(pred, out):
+            out[0] = inner(pred) == Color.red
+            out[1] = inner(not pred) == Color.green
+
+        cuda_f = cuda.jit(f)
+        got = np.zeros((2,), dtype=np.bool_)
+        expected = got.copy()
+        f(True, expected)
+        cuda_f[1, 1](True, got)
+        self.assertPreciseEqual(expected, got)
+
+    def test_int_coerce(self):
+        def f(x, out):
+            # Implicit coercion of intenums to ints
+            if x > RequestError.internal_error:
+                out[0] = x - RequestError.not_found
+            else:
+                out[0] = x + Shape.circle
+
+        cuda_f = cuda.jit(f)
+        for x in [300, 450, 550]:
+            got = np.zeros((1,), dtype=np.int32)
+            expected = got.copy()
+            cuda_f[1, 1](x, got)
+            f(x, expected)
+            self.assertPreciseEqual(expected, got)
+
+    def test_int_cast(self):
+        def f(x, out):
+            # Explicit coercion of intenums to ints
+            if x > int16(RequestError.internal_error):
+                out[0] = x - int32(RequestError.not_found)
+            else:
+                out[0] = x + int16(Shape.circle)
+
+        cuda_f = cuda.jit(f)
+        for x in [300, 450, 550]:
+            got = np.zeros((1,), dtype=np.int32)
+            expected = got.copy()
+            cuda_f[1, 1](x, got)
+            f(x, expected)
+            self.assertEqual(expected, got)
+
+    @skip_on_cudasim("ufuncs are unsupported on simulator.")
+    def test_vectorize(self):
+        def f(x):
+            if x != RequestError.not_found:
+                return RequestError["internal_error"]
+            else:
+                return RequestError.dummy
+
+        cuda_func = vectorize("int64(int64)", target="cuda")(f)
+        arr = np.array([2, 404, 500, 404], dtype=np.int64)
+        expected = np.array([f(x) for x in arr], dtype=np.int64)
+        got = cuda_func(arr)
+        self.assertPreciseEqual(expected, got)
+
+    @skip_on_cudasim("No typing context in CUDA simulator")
+    def test_int_enum_no_conversion(self):
+        # Ported from Numba PR #10047: "Fix IntEnumMember.can_convert_to() when
+        # no conversions found", https://github.com/numba/numba/pull/10047.
+
+        # The original test is intended to ensures that
+        # IntEnumMember.can_convert_to() handles the case when the typing
+        # context's can_convert() method returns None to signal no possible
+        # conversion. In Numba-CUDA, we had to patch the CUDA target context to
+        # work around this issue, because we cannot guarantee that the
+        # IntEnumMember method can be patched before instances are created.
+        ctx = cuda.descriptor.cuda_target.typing_context
+
+        int_enum_type = types.IntEnumMember(Shape, types.int64)
+        # Conversion of an int enum member to a 1D array would be invalid
+        invalid_toty = types.int64[::1]
+        self.assertIsNone(ctx.can_convert(int_enum_type, invalid_toty))
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,111 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+from numba import cuda
+from numba.cuda.core.errors import TypingError
+from numba.cuda.testing import unittest, CUDATestCase, skip_on_cudasim
+from numba.cuda.cudadrv import driver
+
+
+def noop(x):
+    pass
+
+
+class TestJitErrors(CUDATestCase):
+    """
+    Test compile-time errors with @jit.
+    """
+
+    def test_too_many_dims(self):
+        kernfunc = cuda.jit(noop)
+
+        with self.assertRaises(ValueError) as raises:
+            kernfunc[(1, 2, 3, 4), (5, 6)]
+        self.assertIn(
+            "griddim must be a sequence of 1, 2 or 3 integers, "
+            "got [1, 2, 3, 4]",
+            str(raises.exception),
+        )
+
+        with self.assertRaises(ValueError) as raises:
+            kernfunc[
+                (
+                    1,
+                    2,
+                ),
+                (3, 4, 5, 6),
+            ]
+        self.assertIn(
+            "blockdim must be a sequence of 1, 2 or 3 integers, "
+            "got [3, 4, 5, 6]",
+            str(raises.exception),
+        )
+
+    def test_non_integral_dims(self):
+        kernfunc = cuda.jit(noop)
+
+        with self.assertRaises(TypeError) as raises:
+            kernfunc[2.0, 3]
+        self.assertIn(
+            "griddim must be a sequence of integers, got [2.0]",
+            str(raises.exception),
+        )
+
+        with self.assertRaises(TypeError) as raises:
+            kernfunc[2, 3.0]
+        self.assertIn(
+            "blockdim must be a sequence of integers, got [3.0]",
+            str(raises.exception),
+        )
+
+    def _test_unconfigured(self, kernfunc):
+        with self.assertRaises(ValueError) as raises:
+            kernfunc(0)
+        self.assertIn(
+            "launch configuration was not specified", str(raises.exception)
+        )
+
+    def test_unconfigured_typed_cudakernel(self):
+        kernfunc = cuda.jit("void(int32)")(noop)
+        self._test_unconfigured(kernfunc)
+
+    def test_unconfigured_untyped_cudakernel(self):
+        kernfunc = cuda.jit(noop)
+        self._test_unconfigured(kernfunc)
+
+    @skip_on_cudasim("TypingError does not occur on simulator")
+    def test_typing_error(self):
+        # see #5860, this is present to catch changes to error reporting
+        # accidentally breaking the CUDA target
+
+        @cuda.jit(device=True)
+        def dev_func(x):
+            # floor is deliberately not imported for the purpose of this test.
+            return floor(x)  # noqa: F821
+
+        @cuda.jit
+        def kernel_func():
+            dev_func(1.5)
+
+        with self.assertRaises(TypingError) as raises:
+            kernel_func[1, 1]()
+        excstr = str(raises.exception)
+        self.assertIn("resolving callee type: type(CUDADispatcher", excstr)
+        self.assertIn("NameError: name 'floor' is not defined", excstr)
+
+    @skip_on_cudasim("Simulator does not use nvjitlink")
+    @unittest.skipIf(
+        driver._have_nvjitlink(), "nvJitLink available; LTO should not error"
+    )
+    def test_lto_without_nvjitlink_error(self):
+        with self.assertRaisesRegex(RuntimeError, "LTO requires nvjitlink"):
+
+            @cuda.jit(lto=True)
+            def f():
+                pass
+
+            f[1, 1]()
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,170 @@
+# 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.testing import unittest, xfail_unless_cudasim, CUDATestCase
+from numba.cuda.core import config
+
+
+class TestException(CUDATestCase):
+    def test_exception(self):
+        def foo(ary):
+            x = cuda.threadIdx.x
+            if x == 2:
+                # NOTE: indexing with a out-of-bounds constant can fail at
+                # compile-time instead (because the getitem is rewritten as a
+                # static_getitem)
+                ary.shape[-x]
+
+        unsafe_foo = cuda.jit(foo)
+        safe_foo = cuda.jit(debug=True, opt=False)(foo)
+
+        if not config.ENABLE_CUDASIM:
+            # Simulator throws exceptions regardless of debug
+            # setting
+            unsafe_foo[1, 3](np.array([0, 1]))
+
+        with self.assertRaises(IndexError) as cm:
+            safe_foo[1, 3](np.array([0, 1]))
+        self.assertIn("tuple index out of range", str(cm.exception))
+
+    def test_user_raise(self):
+        @cuda.jit(debug=True, opt=False)
+        def foo(do_raise):
+            if do_raise:
+                raise ValueError
+
+        foo[1, 1](False)
+        with self.assertRaises(ValueError):
+            foo[1, 1](True)
+
+    def case_raise_causing_warp_diverge(self, with_debug_mode):
+        """Testing issue #2655.
+
+        Exception raising code can cause the compiler to miss location
+        of unifying branch target and resulting in unexpected warp
+        divergence.
+        """
+        with_opt_mode = not with_debug_mode
+
+        @cuda.jit(debug=with_debug_mode, opt=with_opt_mode)
+        def problematic(x, y):
+            tid = cuda.threadIdx.x
+            ntid = cuda.blockDim.x
+
+            if tid > 12:
+                for i in range(ntid):
+                    y[i] += x[i] // y[i]
+
+            cuda.syncthreads()
+            if tid < 17:
+                for i in range(ntid):
+                    x[i] += x[i] // y[i]
+
+        @cuda.jit
+        def oracle(x, y):
+            tid = cuda.threadIdx.x
+            ntid = cuda.blockDim.x
+
+            if tid > 12:
+                for i in range(ntid):
+                    if y[i] != 0:
+                        y[i] += x[i] // y[i]
+
+            cuda.syncthreads()
+            if tid < 17:
+                for i in range(ntid):
+                    if y[i] != 0:
+                        x[i] += x[i] // y[i]
+
+        n = 32
+        got_x = 1.0 / (np.arange(n) + 0.01)
+        got_y = 1.0 / (np.arange(n) + 0.01)
+        problematic[1, n](got_x, got_y)
+
+        expect_x = 1.0 / (np.arange(n) + 0.01)
+        expect_y = 1.0 / (np.arange(n) + 0.01)
+        oracle[1, n](expect_x, expect_y)
+
+        np.testing.assert_almost_equal(expect_x, got_x)
+        np.testing.assert_almost_equal(expect_y, got_y)
+
+    def test_raise_causing_warp_diverge(self):
+        """Test case for issue #2655."""
+        self.case_raise_causing_warp_diverge(with_debug_mode=False)
+
+    # The following two cases relate to Issue #7806: Division by zero stops the
+    # kernel. https://github.com/numba/numba/issues/7806.
+
+    def test_no_zero_division_error(self):
+        # When debug is False:
+        # - Division by zero raises no exception
+        # - Execution proceeds after a divide by zero
+        @cuda.jit
+        def f(r, x, y):
+            r[0] = y[0] / x[0]
+            r[1] = y[0]
+
+        r = np.zeros(2)
+        x = np.zeros(1)
+        y = np.ones(1)
+
+        f[1, 1](r, x, y)
+
+        self.assertTrue(np.isinf(r[0]), "Expected inf from div by zero")
+        self.assertEqual(r[1], y[0], "Expected execution to continue")
+
+    def test_zero_division_error_in_debug(self):
+        # When debug is True:
+        # - Zero by division raises an exception
+        # - Execution halts at the point of division by zero
+        @cuda.jit(debug=True, opt=False)
+        def f(r, x, y):
+            r[0] = y[0] / x[0]
+            r[1] = y[0]
+
+        r = np.zeros(2)
+        x = np.zeros(1)
+        y = np.ones(1)
+
+        # Simulator and device behaviour differs slightly in the exception
+        # raised - in debug mode, the CUDA target uses the Python error model,
+        # which gives a ZeroDivision error. The simulator uses NumPy with the
+        # error mode for division by zero set to raise, which results in a
+        # FloatingPointError instead.
+        if config.ENABLE_CUDASIM:
+            exc = FloatingPointError
+        else:
+            exc = ZeroDivisionError
+
+        with self.assertRaises(exc):
+            f[1, 1](r, x, y)
+
+        self.assertEqual(r[0], 0, "Expected result to be left unset")
+        self.assertEqual(r[1], 0, "Expected execution to stop")
+
+    @xfail_unless_cudasim
+    def test_raise_in_device_function(self):
+        # This is an expected failure because reporting of exceptions raised in
+        # device functions does not work correctly - see Issue #8036:
+        # https://github.com/numba/numba/issues/8036
+        msg = "Device Function Error"
+
+        @cuda.jit(device=True)
+        def f():
+            raise ValueError(msg)
+
+        @cuda.jit(debug=True, opt=False)
+        def kernel():
+            f()
+
+        with self.assertRaises(ValueError) as raises:
+            kernel[1, 1]()
+
+        self.assertIn(msg, str(raises.exception))
+
+
+if __name__ == "__main__":
+    unittest.main()