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

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

@@ -0,0 +1,125 @@
+from numba import cuda
+from numba.core.errors import TypingError
+from numba.cuda.testing import CUDATestCase, skip_on_cudasim
+import numpy as np
+import unittest
+
+
+class TestSelfRecursion(CUDATestCase):
+
+    def setUp(self):
+        # Avoid importing this module at the top level, as it triggers
+        # compilation and can therefore fail
+        from numba.cuda.tests.cudapy import recursion_usecases
+        self.mod = recursion_usecases
+        super().setUp()
+
+    def check_fib(self, cfunc):
+        @cuda.jit
+        def kernel(r, x):
+            r[0] = cfunc(x[0])
+
+        x = np.asarray([10], dtype=np.int64)
+        r = np.zeros_like(x)
+        kernel[1, 1](r, x)
+
+        actual = r[0]
+        expected = 55
+        self.assertPreciseEqual(actual, expected)
+
+    def test_global_explicit_sig(self):
+        self.check_fib(self.mod.fib1)
+
+    def test_inner_explicit_sig(self):
+        self.check_fib(self.mod.fib2)
+
+    def test_global_implicit_sig(self):
+        self.check_fib(self.mod.fib3)
+
+    @skip_on_cudasim('Simulator does not compile')
+    def test_runaway(self):
+        with self.assertRaises(TypingError) as raises:
+            cfunc = self.mod.runaway_self
+
+            @cuda.jit('void()')
+            def kernel():
+                cfunc(1)
+
+        self.assertIn("cannot type infer runaway recursion",
+                      str(raises.exception))
+
+    @unittest.skip('Needs insert_unresolved_ref support in target')
+    def test_type_change(self):
+        pfunc = self.mod.type_change_self.py_func
+        cfunc = self.mod.type_change_self
+
+        @cuda.jit
+        def kernel(r, x, y):
+            r[0] = cfunc(x[0], y[0])
+
+        args = 13, 0.125
+        x = np.asarray([args[0]], dtype=np.int64)
+        y = np.asarray([args[1]], dtype=np.float64)
+        r = np.zeros_like(x)
+
+        kernel[1, 1](r, x, y)
+
+        expected = pfunc(*args)
+        actual = r[0]
+
+        self.assertPreciseEqual(actual, expected)
+
+    @unittest.expectedFailure
+    def test_raise(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
+        with self.assertRaises(ValueError) as raises:
+            self.mod.raise_self_kernel[1, 1](3)
+
+        self.assertEqual(str(raises.exception), "raise_self")
+
+    @unittest.skip('Needs insert_unresolved_ref support in target')
+    def test_optional_return(self):
+        pfunc = self.mod.make_optional_return_case()
+        cfunc = self.mod.make_optional_return_case(cuda.jit)
+
+        @cuda.jit
+        def kernel(r, x):
+            res = cfunc(x[0])
+            if res is None:
+                res = 999
+            r[0] = res
+
+        def cpu_kernel(x):
+            res = pfunc(x)
+            if res is None:
+                res = 999
+            return res
+
+        for arg in (0, 5, 10, 15):
+            expected = cpu_kernel(arg)
+            x = np.asarray([arg], dtype=np.int64)
+            r = np.zeros_like(x)
+            kernel[1, 1](r, x)
+            actual = r[0]
+
+            self.assertEqual(expected, actual)
+
+    @skip_on_cudasim('Recursion handled because simulator does not compile')
+    def test_growing_return_tuple(self):
+        cfunc = self.mod.make_growing_tuple_case(cuda.jit)
+
+        with self.assertRaises(TypingError) as raises:
+            @cuda.jit('void()')
+            def kernel():
+                cfunc(100)
+
+        self.assertIn(
+            "Return type of recursive function does not converge",
+            str(raises.exception),
+        )
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,76 @@
+import numpy as np
+from numba import cuda
+from numba.core.config import ENABLE_CUDASIM
+from numba.cuda.testing import CUDATestCase
+import unittest
+
+# Avoid recompilation of the sum_reduce function by keeping it at global scope
+sum_reduce = cuda.Reduce(lambda a, b: a + b)
+
+
+class TestReduction(CUDATestCase):
+    def _sum_reduce(self, n):
+        A = (np.arange(n, dtype=np.float64) + 1)
+        expect = A.sum()
+        got = sum_reduce(A)
+        self.assertEqual(expect, got)
+
+    def test_sum_reduce(self):
+        if ENABLE_CUDASIM:
+            # Minimal test set for the simulator (which only wraps
+            # functools.reduce)
+            test_sizes = [ 1, 16 ]
+        else:
+            # Tests around the points where blocksize changes, and around larger
+            # powers of two, sums of powers of two, and some "random" sizes
+            test_sizes = [ 1, 15, 16, 17, 127, 128, 129, 1023, 1024,
+                           1025, 1536, 1048576, 1049600, 1049728, 34567 ]
+        # Avoid recompilation by keeping sum_reduce here
+        for n in test_sizes:
+            self._sum_reduce(n)
+
+    def test_empty_array_host(self):
+        A = (np.arange(0, dtype=np.float64) + 1)
+        expect = A.sum()
+        got = sum_reduce(A)
+        self.assertEqual(expect, got)
+
+    def test_empty_array_device(self):
+        A = (np.arange(0, dtype=np.float64) + 1)
+        dA = cuda.to_device(A)
+        expect = A.sum()
+        got = sum_reduce(dA)
+        self.assertEqual(expect, got)
+
+    def test_prod_reduce(self):
+        prod_reduce = cuda.reduce(lambda a, b: a * b)
+        A = (np.arange(64, dtype=np.float64) + 1)
+        expect = A.prod()
+        got = prod_reduce(A, init=1)
+        np.testing.assert_allclose(expect, got)
+
+    def test_max_reduce(self):
+        max_reduce = cuda.Reduce(lambda a, b: max(a, b))
+        A = (np.arange(3717, dtype=np.float64) + 1)
+        expect = A.max()
+        got = max_reduce(A, init=0)
+        self.assertEqual(expect, got)
+
+    def test_non_identity_init(self):
+        init = 3
+        A = (np.arange(10, dtype=np.float64) + 1)
+        expect = A.sum() + init
+        got = sum_reduce(A, init=init)
+        self.assertEqual(expect, got)
+
+    def test_result_on_device(self):
+        A = (np.arange(10, dtype=np.float64) + 1)
+        got = cuda.to_device(np.zeros(1, dtype=np.float64))
+        expect = A.sum()
+        res = sum_reduce(A, res=got)
+        self.assertIsNone(res)
+        self.assertEqual(expect, got[0])
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,83 @@
+import numpy as np
+
+from numba import cuda
+from numba.cuda.args import wrap_arg
+from numba.cuda.testing import CUDATestCase
+import unittest
+
+
+class DefaultIn(object):
+    def prepare_args(self, ty, val, **kwargs):
+        return ty, wrap_arg(val, default=cuda.In)
+
+
+def nocopy(kernel):
+    kernel.extensions.append(DefaultIn())
+    return kernel
+
+
+def set_array_to_three(arr):
+    arr[0] = 3
+
+
+def set_record_to_three(rec):
+    rec[0]['b'] = 3
+
+
+recordtype = np.dtype(
+    [('b', np.int32)],
+    align=True
+)
+
+
+class TestRetrieveAutoconvertedArrays(CUDATestCase):
+    def setUp(self):
+        super().setUp()
+        self.set_array_to_three = cuda.jit(set_array_to_three)
+        self.set_array_to_three_nocopy = nocopy(cuda.jit(set_array_to_three))
+        self.set_record_to_three = cuda.jit(set_record_to_three)
+        self.set_record_to_three_nocopy = nocopy(cuda.jit(set_record_to_three))
+
+    def test_array_inout(self):
+        host_arr = np.zeros(1, dtype=np.int64)
+        self.set_array_to_three[1, 1](cuda.InOut(host_arr))
+        self.assertEqual(3, host_arr[0])
+
+    def test_array_in(self):
+        host_arr = np.zeros(1, dtype=np.int64)
+        self.set_array_to_three[1, 1](cuda.In(host_arr))
+        self.assertEqual(0, host_arr[0])
+
+    def test_array_in_from_config(self):
+        host_arr = np.zeros(1, dtype=np.int64)
+        self.set_array_to_three_nocopy[1, 1](host_arr)
+        self.assertEqual(0, host_arr[0])
+
+    def test_array_default(self):
+        host_arr = np.zeros(1, dtype=np.int64)
+        self.set_array_to_three[1, 1](host_arr)
+        self.assertEqual(3, host_arr[0])
+
+    def test_record_in(self):
+        host_rec = np.zeros(1, dtype=recordtype)
+        self.set_record_to_three[1, 1](cuda.In(host_rec))
+        self.assertEqual(0, host_rec[0]['b'])
+
+    def test_record_inout(self):
+        host_rec = np.zeros(1, dtype=recordtype)
+        self.set_record_to_three[1, 1](cuda.InOut(host_rec))
+        self.assertEqual(3, host_rec[0]['b'])
+
+    def test_record_default(self):
+        host_rec = np.zeros(1, dtype=recordtype)
+        self.set_record_to_three[1, 1](host_rec)
+        self.assertEqual(3, host_rec[0]['b'])
+
+    def test_record_in_from_config(self):
+        host_rec = np.zeros(1, dtype=recordtype)
+        self.set_record_to_three_nocopy[1, 1](host_rec)
+        self.assertEqual(0, host_rec[0]['b'])
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,85 @@
+import pickle
+import numpy as np
+from numba import cuda, vectorize
+from numba.core import types
+from numba.cuda.testing import skip_on_cudasim, CUDATestCase
+import unittest
+from numba.np import numpy_support
+
+
+@skip_on_cudasim('pickling not supported in CUDASIM')
+class TestPickle(CUDATestCase):
+
+    def check_call(self, callee):
+        arr = np.array([100])
+        expected = callee[1, 1](arr)
+
+        # serialize and rebuild
+        foo1 = pickle.loads(pickle.dumps(callee))
+        del callee
+        # call rebuild function
+        got1 = foo1[1, 1](arr)
+        np.testing.assert_equal(got1, expected)
+        del got1
+
+        # test serialization of previously serialized object
+        foo2 = pickle.loads(pickle.dumps(foo1))
+        del foo1
+        # call rebuild function
+        got2 = foo2[1, 1](arr)
+        np.testing.assert_equal(got2, expected)
+        del got2
+
+        # test propagation of thread, block config
+        foo3 = pickle.loads(pickle.dumps(foo2[5, 8]))
+        del foo2
+        self.assertEqual(foo3.griddim, (5, 1, 1))
+        self.assertEqual(foo3.blockdim, (8, 1, 1))
+
+    def test_pickling_jit_typing(self):
+        @cuda.jit(device=True)
+        def inner(a):
+            return a + 1
+
+        @cuda.jit('void(intp[:])')
+        def foo(arr):
+            arr[0] = inner(arr[0])
+
+        self.check_call(foo)
+
+    def test_pickling_jit(self):
+
+        @cuda.jit(device=True)
+        def inner(a):
+            return a + 1
+
+        @cuda.jit
+        def foo(arr):
+            arr[0] = inner(arr[0])
+
+        self.check_call(foo)
+
+    def test_pickling_vectorize(self):
+        @vectorize(['intp(intp)', 'float64(float64)'], target='cuda')
+        def cuda_vect(x):
+            return x * 2
+
+        # accommodate int representations in np.arange
+        npty = numpy_support.as_dtype(types.intp)
+        # get expected result
+        ary = np.arange(10, dtype=npty)
+        expected = cuda_vect(ary)
+        # first pickle
+        foo1 = pickle.loads(pickle.dumps(cuda_vect))
+        del cuda_vect
+        got1 = foo1(ary)
+        np.testing.assert_equal(expected, got1)
+        # second pickle
+        foo2 = pickle.loads(pickle.dumps(foo1))
+        del foo1
+        got2 = foo2(ary)
+        np.testing.assert_equal(expected, got2)
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,37 @@
+import numpy as np
+from numba import cuda
+from numba.cuda.testing import unittest, CUDATestCase
+
+
+def foo(inp, out):
+    for i in range(out.shape[0]):
+        out[i] = inp[i]
+
+
+def copy(inp, out):
+    i = cuda.grid(1)
+    cufoo(inp[i, :], out[i, :])
+
+
+class TestCudaSlicing(CUDATestCase):
+    def test_slice_as_arg(self):
+        global cufoo
+        cufoo = cuda.jit("void(int32[:], int32[:])", device=True)(foo)
+        cucopy = cuda.jit("void(int32[:,:], int32[:,:])")(copy)
+
+        inp = np.arange(100, dtype=np.int32).reshape(10, 10)
+        out = np.zeros_like(inp)
+
+        cucopy[1, 10](inp, out)
+
+    def test_assign_empty_slice(self):
+        # Issue #5017. Assigning to an empty slice should not result in a
+        # CudaAPIError.
+        N = 0
+        a = range(N)
+        arr = cuda.device_array(len(a))
+        arr[:] = cuda.to_device(a)
+
+
+if __name__ == '__main__':
+    unittest.main()