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

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

@@ -0,0 +1,121 @@
+"""
+Test cases adapted from numba/tests/test_enums.py
+"""
+
+import numpy as np
+
+from numba import int16, int32
+from numba import cuda, vectorize, njit
+from numba.cuda.testing import unittest, CUDATestCase, skip_on_cudasim
+from numba.tests.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)
+
+    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)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,79 @@
+from numba import cuda
+from numba.core.errors import TypingError
+from numba.cuda.testing import unittest, CUDATestCase, skip_on_cudasim
+
+
+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)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,174 @@
+import numpy as np
+
+from numba import cuda
+from numba.cuda.testing import unittest, xfail_unless_cudasim, CUDATestCase
+from numba.core import config
+
+
+class TestException(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).
+        self.skip_if_lto("Exceptions not supported with LTO")
+
+    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. / (np.arange(n) + 0.01)
+        got_y = 1. / (np.arange(n) + 0.01)
+        problematic[1, n](got_x, got_y)
+
+        expect_x = 1. / (np.arange(n) + 0.01)
+        expect_y = 1. / (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)
+        def kernel():
+            f()
+
+        with self.assertRaises(ValueError) as raises:
+            kernel[1, 1]()
+
+        self.assertIn(msg, str(raises.exception))
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,155 @@
+from numba.cuda.testing import skip_on_cudasim, unittest, CUDATestCase
+
+import numpy as np
+from numba import config, cuda, njit, types
+
+
+class Interval:
+    """
+    A half-open interval on the real number line.
+    """
+    def __init__(self, lo, hi):
+        self.lo = lo
+        self.hi = hi
+
+    def __repr__(self):
+        return 'Interval(%f, %f)' % (self.lo, self.hi)
+
+    @property
+    def width(self):
+        return self.hi - self.lo
+
+
+@njit
+def interval_width(interval):
+    return interval.width
+
+
+@njit
+def sum_intervals(i, j):
+    return Interval(i.lo + j.lo, i.hi + j.hi)
+
+
+if not config.ENABLE_CUDASIM:
+    from numba.core import cgutils
+    from numba.core.extending import (lower_builtin, make_attribute_wrapper,
+                                      models, register_model, type_callable,
+                                      typeof_impl)
+    from numba.core.typing.templates import AttributeTemplate
+    from numba.cuda.cudadecl import registry as cuda_registry
+    from numba.cuda.cudaimpl import lower_attr as cuda_lower_attr
+
+    class IntervalType(types.Type):
+        def __init__(self):
+            super().__init__(name='Interval')
+
+    interval_type = IntervalType()
+
+    @typeof_impl.register(Interval)
+    def typeof_interval(val, c):
+        return interval_type
+
+    @type_callable(Interval)
+    def type_interval(context):
+        def typer(lo, hi):
+            if isinstance(lo, types.Float) and isinstance(hi, types.Float):
+                return interval_type
+        return typer
+
+    @register_model(IntervalType)
+    class IntervalModel(models.StructModel):
+        def __init__(self, dmm, fe_type):
+            members = [
+                ('lo', types.float64),
+                ('hi', types.float64),
+            ]
+            models.StructModel.__init__(self, dmm, fe_type, members)
+
+    make_attribute_wrapper(IntervalType, 'lo', 'lo')
+    make_attribute_wrapper(IntervalType, 'hi', 'hi')
+
+    @lower_builtin(Interval, types.Float, types.Float)
+    def impl_interval(context, builder, sig, args):
+        typ = sig.return_type
+        lo, hi = args
+        interval = cgutils.create_struct_proxy(typ)(context, builder)
+        interval.lo = lo
+        interval.hi = hi
+        return interval._getvalue()
+
+    @cuda_registry.register_attr
+    class Interval_attrs(AttributeTemplate):
+        key = IntervalType
+
+        def resolve_width(self, mod):
+            return types.float64
+
+    @cuda_lower_attr(IntervalType, 'width')
+    def cuda_Interval_width(context, builder, sig, arg):
+        lo = builder.extract_value(arg, 0)
+        hi = builder.extract_value(arg, 1)
+        return builder.fsub(hi, lo)
+
+
+@skip_on_cudasim('Extensions not supported in the simulator')
+class TestExtending(CUDATestCase):
+    def test_attributes(self):
+        @cuda.jit
+        def f(r, x):
+            iv = Interval(x[0], x[1])
+            r[0] = iv.lo
+            r[1] = iv.hi
+
+        x = np.asarray((1.5, 2.5))
+        r = np.zeros_like(x)
+
+        f[1, 1](r, x)
+
+        np.testing.assert_equal(r, x)
+
+    def test_property(self):
+        @cuda.jit
+        def f(r, x):
+            iv = Interval(x[0], x[1])
+            r[0] = iv.width
+
+        x = np.asarray((1.5, 2.5))
+        r = np.zeros(1)
+
+        f[1, 1](r, x)
+
+        np.testing.assert_allclose(r[0], x[1] - x[0])
+
+    def test_extension_type_as_arg(self):
+        @cuda.jit
+        def f(r, x):
+            iv = Interval(x[0], x[1])
+            r[0] = interval_width(iv)
+
+        x = np.asarray((1.5, 2.5))
+        r = np.zeros(1)
+
+        f[1, 1](r, x)
+
+        np.testing.assert_allclose(r[0], x[1] - x[0])
+
+    def test_extension_type_as_retvalue(self):
+        @cuda.jit
+        def f(r, x):
+            iv1 = Interval(x[0], x[1])
+            iv2 = Interval(x[2], x[3])
+            iv_sum = sum_intervals(iv1, iv2)
+            r[0] = iv_sum.lo
+            r[1] = iv_sum.hi
+
+        x = np.asarray((1.5, 2.5, 3.0, 4.0))
+        r = np.zeros(2)
+
+        f[1, 1](r, x)
+
+        expected = np.asarray((x[0] + x[2], x[1] + x[3]))
+        np.testing.assert_allclose(r, expected)
+
+
+if __name__ == '__main__':
+    unittest.main()