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

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

@@ -0,0 +1,307 @@
+"""
+CUDA vector type tests. Note that this test file imports
+`cuda.vector_type` module to programmatically test all the
+vector types. However, `vector_type` module is internal
+and should not be imported by user, user should only import the
+corresponding vector type from `cuda` module in kernel to use them.
+"""
+
+import numpy as np
+
+from numba.core import config
+from numba.cuda.testing import CUDATestCase
+
+from numba import cuda
+
+if config.ENABLE_CUDASIM:
+    from numba.cuda.simulator.vector_types import vector_types
+else:
+    from numba.cuda.vector_types import vector_types
+
+
+def make_kernel(vtype):
+    """
+    Returns a jit compiled kernel that constructs a vector types of
+    the given type, using the exact number of primitive types to
+    construct the vector type.
+    """
+    vobj = vtype.user_facing_object
+    base_type = vtype.base_type
+
+    def kernel_1elem(res):
+        v = vobj(base_type(0))
+        res[0] = v.x
+
+    def kernel_2elem(res):
+        v = vobj(base_type(0), base_type(1))
+        res[0] = v.x
+        res[1] = v.y
+
+    def kernel_3elem(res):
+        v = vobj(base_type(0), base_type(1), base_type(2))
+        res[0] = v.x
+        res[1] = v.y
+        res[2] = v.z
+
+    def kernel_4elem(res):
+        v = vobj(
+            base_type(0),
+            base_type(1),
+            base_type(2),
+            base_type(3)
+        )
+        res[0] = v.x
+        res[1] = v.y
+        res[2] = v.z
+        res[3] = v.w
+
+    host_function = {
+        1: kernel_1elem,
+        2: kernel_2elem,
+        3: kernel_3elem,
+        4: kernel_4elem
+    }[vtype.num_elements]
+    return cuda.jit(host_function)
+
+
+def make_fancy_creation_kernel(vtype):
+    """
+    Returns a jit compiled kernel that constructs a vector type using the
+    "fancy" construction, that is, with arbitrary combinations of primitive
+    types and vector types, as long as the total element of the construction
+    is the same as the number of elements of the vector type.
+    """
+    base_type = vtype.base_type
+    v1 = getattr(cuda, f"{vtype.name[:-1]}1")
+    v2 = getattr(cuda, f"{vtype.name[:-1]}2")
+    v3 = getattr(cuda, f"{vtype.name[:-1]}3")
+    v4 = getattr(cuda, f"{vtype.name[:-1]}4")
+
+    def kernel(res):
+        one = base_type(1.0)
+        two = base_type(2.0)
+        three = base_type(3.0)
+        four = base_type(4.0)
+
+        j = 0   # index of the result array
+
+        # Construct a 1-component vector type, possible combination includes:
+        # 2C1 = 2 combinations.
+
+        f1_1 = v1(one)  # 1
+        f1_2 = v1(f1_1) # 1
+
+        res[0] = f1_1.x
+        res[1] = f1_2.x
+        j += 2
+
+        # Construct a 2-component vector type, possible combination includes:
+        # 1 + 2C1 * 2 = 5 combinations
+
+        f2_1 = v2(two, three)       # 2 3
+        f2_2 = v2(f1_1, three)      # 1 3
+        f2_3 = v2(two, f1_1)        # 2 1
+        f2_4 = v2(f1_1, f1_1)       # 1 1
+        f2_5 = v2(f2_1)             # 2 3
+
+        for v in (f2_1, f2_2, f2_3, f2_4, f2_5):
+            res[j] = v.x
+            res[j + 1] = v.y
+            j += 2
+
+        # Construct a 3-component vector type, possible combination includes:
+        # 1 + 2C1 * 2 + 2^3 = 13 combinations
+
+        f3_1 = v3(f2_1, one)            # 2 3 1
+        f3_2 = v3(f2_1, f1_1)           # 2 3 1
+        f3_3 = v3(one, f2_1)            # 1 2 3
+        f3_4 = v3(f1_1, f2_1)           # 1 2 3
+
+        f3_5 = v3(one, two, three)      # 1 2 3
+        f3_6 = v3(f1_1, two, three)     # 1 2 3
+        f3_7 = v3(one, f1_1, three)     # 1 1 3
+        f3_8 = v3(one, two, f1_1)       # 1 2 1
+        f3_9 = v3(f1_1, f1_1, three)    # 1 1 3
+        f3_10 = v3(one, f1_1, f1_1)     # 1 1 1
+        f3_11 = v3(f1_1, two, f1_1)     # 1 2 1
+        f3_12 = v3(f1_1, f1_1, f1_1)    # 1 1 1
+
+        f3_13 = v3(f3_1)                # 2 3 1
+
+        for v in (f3_1, f3_2, f3_3, f3_4, f3_5, f3_6, f3_7, f3_8, f3_9,
+                  f3_10, f3_11, f3_12, f3_13):
+            res[j] = v.x
+            res[j + 1] = v.y
+            res[j + 2] = v.z
+            j += 3
+
+        # Construct a 4-component vector type, possible combination includes:
+        # 1 + (2C1 * 2 + 1) + 3C1 * 2^2 + 2^4 = 34 combinations
+
+        f4_1 = v4(one, two, three, four)    # 1 2 3 4
+        f4_2 = v4(f1_1, two, three, four)   # 1 2 3 4
+        f4_3 = v4(one, f1_1, three, four)   # 1 1 3 4
+        f4_4 = v4(one, two, f1_1, four)     # 1 2 1 4
+        f4_5 = v4(one, two, three, f1_1)    # 1 2 3 1
+        f4_6 = v4(f1_1, f1_1, three, four)  # 1 1 3 4
+        f4_7 = v4(f1_1, two, f1_1, four)    # 1 2 1 4
+        f4_8 = v4(f1_1, two, three, f1_1)   # 1 2 3 1
+        f4_9 = v4(one, f1_1, f1_1, four)    # 1 1 1 4
+        f4_10 = v4(one, f1_1, three, f1_1)  # 1 1 3 1
+        f4_11 = v4(one, two, f1_1, f1_1)    # 1 2 1 1
+        f4_12 = v4(f1_1, f1_1, f1_1, four)  # 1 1 1 4
+        f4_13 = v4(f1_1, f1_1, three, f1_1) # 1 1 3 1
+        f4_14 = v4(f1_1, two, f1_1, f1_1)   # 1 2 1 1
+        f4_15 = v4(one, f1_1, f1_1, f1_1)   # 1 1 1 1
+        f4_16 = v4(f1_1, f1_1, f1_1, f1_1)  # 1 1 1 1
+
+        f4_17 = v4(f2_1, two, three)        # 2 3 2 3
+        f4_18 = v4(f2_1, f1_1, three)       # 2 3 1 3
+        f4_19 = v4(f2_1, two, f1_1)         # 2 3 2 1
+        f4_20 = v4(f2_1, f1_1, f1_1)        # 2 3 1 1
+        f4_21 = v4(one, f2_1, three)        # 1 2 3 3
+        f4_22 = v4(f1_1, f2_1, three)       # 1 2 3 3
+        f4_23 = v4(one, f2_1, f1_1)         # 1 2 3 1
+        f4_24 = v4(f1_1, f2_1, f1_1)        # 1 2 3 1
+        f4_25 = v4(one, four, f2_1)         # 1 4 2 3
+        f4_26 = v4(f1_1, four, f2_1)        # 1 4 2 3
+        f4_27 = v4(one, f1_1, f2_1)         # 1 1 2 3
+        f4_28 = v4(f1_1, f1_1, f2_1)        # 1 1 2 3
+
+        f4_29 = v4(f2_1, f2_1)              # 2 3 2 3
+        f4_30 = v4(f3_1, four)              # 2 3 1 4
+        f4_31 = v4(f3_1, f1_1)              # 2 3 1 1
+        f4_32 = v4(four, f3_1)              # 4 2 3 1
+        f4_33 = v4(f1_1, f3_1)              # 1 2 3 1
+
+        f4_34 = v4(f4_1)                    # 1 2 3 4
+
+        for v in (f4_1, f4_2, f4_3, f4_4, f4_5, f4_6, f4_7, f4_8, f4_9, f4_10,
+                  f4_11, f4_12, f4_13, f4_14, f4_15, f4_16, f4_17, f4_18, f4_19,
+                  f4_20, f4_21, f4_22, f4_23, f4_24, f4_25, f4_26, f4_27, f4_28,
+                  f4_29, f4_30, f4_31, f4_32, f4_33, f4_34):
+            res[j] = v.x
+            res[j + 1] = v.y
+            res[j + 2] = v.z
+            res[j + 3] = v.w
+            j += 4
+
+    return cuda.jit(kernel)
+
+
+class TestCudaVectorType(CUDATestCase):
+
+    def test_basic(self):
+        """Basic test that makes sure that vector type and aliases
+        are available within the cuda module from both device and
+        simulator mode. This is an important sanity check, since other
+        tests below tests the vector type objects programmatically.
+        """
+        @cuda.jit("void(float64[:])")
+        def kernel(arr):
+            v1 = cuda.float64x4(1.0, 3.0, 5.0, 7.0)
+            v2 = cuda.short2(10, 11)
+            arr[0] = v1.x
+            arr[1] = v1.y
+            arr[2] = v1.z
+            arr[3] = v1.w
+            arr[4] = v2.x
+            arr[5] = v2.y
+
+        res = np.zeros(6, dtype=np.float64)
+        kernel[1, 1](res)
+        self.assertTrue(np.allclose(res, [1.0, 3.0, 5.0, 7.0, 10, 11]))
+
+    def test_creation_readout(self):
+        for vty in vector_types.values():
+            with self.subTest(vty=vty):
+                arr = np.zeros((vty.num_elements,))
+                kernel = make_kernel(vty)
+                kernel[1, 1](arr)
+                np.testing.assert_almost_equal(
+                    arr, np.array(range(vty.num_elements))
+                )
+
+    def test_fancy_creation_readout(self):
+        for vty in vector_types.values():
+            with self.subTest(vty=vty):
+                kernel = make_fancy_creation_kernel(vty)
+
+                expected = np.array([
+                    # 1-component vectors
+                    1,
+                    1,
+                    # 2-component vectors
+                    2, 3,
+                    1, 3,
+                    2, 1,
+                    1, 1,
+                    2, 3,
+                    # 3-component vectors
+                    2, 3, 1,
+                    2, 3, 1,
+                    1, 2, 3,
+                    1, 2, 3,
+                    1, 2, 3,
+                    1, 2, 3,
+                    1, 1, 3,
+                    1, 2, 1,
+                    1, 1, 3,
+                    1, 1, 1,
+                    1, 2, 1,
+                    1, 1, 1,
+                    2, 3, 1,
+                    # 4-component vectors
+                    1, 2, 3, 4,
+                    1, 2, 3, 4,
+                    1, 1, 3, 4,
+                    1, 2, 1, 4,
+                    1, 2, 3, 1,
+                    1, 1, 3, 4,
+                    1, 2, 1, 4,
+                    1, 2, 3, 1,
+                    1, 1, 1, 4,
+                    1, 1, 3, 1,
+                    1, 2, 1, 1,
+                    1, 1, 1, 4,
+                    1, 1, 3, 1,
+                    1, 2, 1, 1,
+                    1, 1, 1, 1,
+                    1, 1, 1, 1,
+                    2, 3, 2, 3,
+                    2, 3, 1, 3,
+                    2, 3, 2, 1,
+                    2, 3, 1, 1,
+                    1, 2, 3, 3,
+                    1, 2, 3, 3,
+                    1, 2, 3, 1,
+                    1, 2, 3, 1,
+                    1, 4, 2, 3,
+                    1, 4, 2, 3,
+                    1, 1, 2, 3,
+                    1, 1, 2, 3,
+                    2, 3, 2, 3,
+                    2, 3, 1, 4,
+                    2, 3, 1, 1,
+                    4, 2, 3, 1,
+                    1, 2, 3, 1,
+                    1, 2, 3, 4
+                ])
+                arr = np.zeros(expected.shape)
+                kernel[1, 1](arr)
+                np.testing.assert_almost_equal(arr, expected)
+
+    def test_vector_type_alias(self):
+        """Tests that `cuda.<vector_type.alias>` are importable and
+        that is the same as `cuda.<vector_type.name>`.
+
+        `test_fancy_creation_readout` only test vector types imported
+        with its name. This test makes sure that construction with
+        objects imported with alias should work the same.
+        """
+        for vty in vector_types.values():
+            for alias in vty.user_facing_object.aliases:
+                with self.subTest(vty=vty.name, alias=alias):
+                    self.assertEqual(
+                        id(getattr(cuda, vty.name)), id(getattr(cuda, alias))
+                    )

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

@@ -0,0 +1,283 @@
+import numpy as np
+
+from collections import namedtuple
+from itertools import product
+from numba import vectorize
+from numba import cuda, int32, float32, float64
+from numba.cuda.cudadrv.driver import CudaAPIError, driver
+from numba.cuda.testing import skip_on_cudasim
+from numba.cuda.testing import CUDATestCase
+import unittest
+
+
+# Signatures to test with - these are all homogeneous in dtype, so the output
+# dtype should match the input dtype - the output should not have been cast
+# upwards, as reported in #8400: https://github.com/numba/numba/issues/8400
+signatures = [int32(int32, int32),
+              float32(float32, float32),
+              float64(float64, float64)]
+
+# The order here is chosen such that each subsequent dtype might have been
+# casted to a previously-used dtype. This is unlikely to be an issue for CUDA,
+# but there might be future circumstances in which it becomes relevant, perhaps
+# if it supported Dynamic UFuncs, and we want to ensure that an implementation
+# for a the given dtype is used rather than casting the input upwards.
+dtypes = (np.float64, np.float32, np.int32)
+
+# NumPy ndarray orders
+orders = ('C', 'F')
+
+# Input sizes corresponding to operations:
+# - Less than one warp,
+# - Less than one block,
+# - Greater than one block (i.e. many blocks)
+input_sizes = (8, 100, 2 ** 10 + 1)
+
+
+@skip_on_cudasim('ufunc API unsupported in the simulator')
+class TestCUDAVectorize(CUDATestCase):
+    # Presumably chosen as an odd number unlikely to coincide with the total
+    # thread count, and large enough to ensure a significant number of blocks
+    # are used.
+    N = 1000001
+
+    def test_scalar(self):
+
+        @vectorize(signatures, target='cuda')
+        def vector_add(a, b):
+            return a + b
+
+        a = 1.2
+        b = 2.3
+        c = vector_add(a, b)
+        self.assertEqual(c, a + b)
+
+    def test_1d(self):
+
+        @vectorize(signatures, target='cuda')
+        def vector_add(a, b):
+            return a + b
+
+        for ty in dtypes:
+            data = np.array(np.random.random(self.N), dtype=ty)
+            expected = np.add(data, data)
+            actual = vector_add(data, data)
+            np.testing.assert_allclose(expected, actual)
+            self.assertEqual(actual.dtype, ty)
+
+    def test_1d_async(self):
+
+        @vectorize(signatures, target='cuda')
+        def vector_add(a, b):
+            return a + b
+
+        stream = cuda.stream()
+
+        for ty in dtypes:
+            data = np.array(np.random.random(self.N), dtype=ty)
+            device_data = cuda.to_device(data, stream)
+
+            dresult = vector_add(device_data, device_data, stream=stream)
+            actual = dresult.copy_to_host()
+
+            expected = np.add(data, data)
+
+            np.testing.assert_allclose(expected, actual)
+            self.assertEqual(actual.dtype, ty)
+
+    def test_nd(self):
+
+        @vectorize(signatures, target='cuda')
+        def vector_add(a, b):
+            return a + b
+
+        for nd, dtype, order in product(range(1, 8), dtypes, orders):
+            shape = (4,) * nd
+            data = np.random.random(shape).astype(dtype)
+            data2 = np.array(data.T, order=order)
+
+            expected = data + data2
+            actual = vector_add(data, data2)
+            np.testing.assert_allclose(expected, actual)
+            self.assertEqual(actual.dtype, dtype)
+
+    def test_output_arg(self):
+        @vectorize(signatures, target='cuda')
+        def vector_add(a, b):
+            return a + b
+
+        A = np.arange(10, dtype=np.float32)
+        B = np.arange(10, dtype=np.float32)
+
+        expected = A + B
+        actual = np.empty_like(A)
+        vector_add(A, B, out=actual)
+
+        np.testing.assert_allclose(expected, actual)
+        self.assertEqual(expected.dtype, actual.dtype)
+
+    def test_reduce(self):
+        @vectorize(signatures, target='cuda')
+        def vector_add(a, b):
+            return a + b
+
+        dtype = np.int32
+
+        for n in input_sizes:
+            x = np.arange(n, dtype=dtype)
+            expected = np.add.reduce(x)
+            actual = vector_add.reduce(x)
+            np.testing.assert_allclose(expected, actual)
+            # np.add.reduce is special-cased to return an int64 for any int
+            # arguments, so we can't compare against its returned dtype when
+            # we're checking the general reduce machinery (which just happens
+            # to be using addition). Instead, compare against the input dtype.
+            self.assertEqual(dtype, actual.dtype)
+
+    def test_reduce_async(self):
+
+        @vectorize(signatures, target='cuda')
+        def vector_add(a, b):
+            return a + b
+
+        stream = cuda.stream()
+        dtype = np.int32
+
+        for n in input_sizes:
+            x = np.arange(n, dtype=dtype)
+            expected = np.add.reduce(x)
+            dx = cuda.to_device(x, stream)
+            actual = vector_add.reduce(dx, stream=stream)
+            np.testing.assert_allclose(expected, actual)
+            # Compare against the input dtype as in test_reduce().
+            self.assertEqual(dtype, actual.dtype)
+
+    def test_manual_transfer(self):
+        @vectorize(signatures, target='cuda')
+        def vector_add(a, b):
+            return a + b
+
+        n = 10
+        x = np.arange(n, dtype=np.int32)
+        dx = cuda.to_device(x)
+        expected = x + x
+        actual = vector_add(x, dx).copy_to_host()
+        np.testing.assert_equal(expected, actual)
+        self.assertEqual(expected.dtype, actual.dtype)
+
+    def test_ufunc_output_2d(self):
+        @vectorize(signatures, target='cuda')
+        def vector_add(a, b):
+            return a + b
+
+        n = 10
+        x = np.arange(n, dtype=np.int32).reshape(2, 5)
+        dx = cuda.to_device(x)
+        vector_add(dx, dx, out=dx)
+
+        expected = x + x
+        actual = dx.copy_to_host()
+        np.testing.assert_equal(expected, actual)
+        self.assertEqual(expected.dtype, actual.dtype)
+
+    def check_tuple_arg(self, a, b):
+        @vectorize(signatures, target='cuda')
+        def vector_add(a, b):
+            return a + b
+
+        r = vector_add(a, b)
+        np.testing.assert_equal(np.asarray(a) + np.asarray(b), r)
+
+    def test_tuple_arg(self):
+        a = (1.0, 2.0, 3.0)
+        b = (4.0, 5.0, 6.0)
+        self.check_tuple_arg(a, b)
+
+    def test_namedtuple_arg(self):
+        Point = namedtuple('Point', ('x', 'y', 'z'))
+        a = Point(x=1.0, y=2.0, z=3.0)
+        b = Point(x=4.0, y=5.0, z=6.0)
+        self.check_tuple_arg(a, b)
+
+    def test_tuple_of_array_arg(self):
+        arr = np.arange(10, dtype=np.int32)
+        a = (arr, arr + 1)
+        b = (arr + 2, arr + 2)
+        self.check_tuple_arg(a, b)
+
+    def test_tuple_of_namedtuple_arg(self):
+        Point = namedtuple('Point', ('x', 'y', 'z'))
+        a = (Point(x=1.0, y=2.0, z=3.0), Point(x=1.5, y=2.5, z=3.5))
+        b = (Point(x=4.0, y=5.0, z=6.0), Point(x=4.5, y=5.5, z=6.5))
+        self.check_tuple_arg(a, b)
+
+    def test_namedtuple_of_array_arg(self):
+        xs1 = np.arange(10, dtype=np.int32)
+        ys1 = xs1 + 2
+        xs2 = np.arange(10, dtype=np.int32) * 2
+        ys2 = xs2 + 1
+        Points = namedtuple('Points', ('xs', 'ys'))
+        a = Points(xs=xs1, ys=ys1)
+        b = Points(xs=xs2, ys=ys2)
+        self.check_tuple_arg(a, b)
+
+    def test_name_attribute(self):
+        @vectorize('f8(f8)', target='cuda')
+        def bar(x):
+            return x ** 2
+
+        self.assertEqual(bar.__name__, 'bar')
+
+    def test_no_transfer_for_device_data(self):
+        # Initialize test data on the device prior to banning host <-> device
+        # transfer
+
+        noise = np.random.randn(1, 3, 64, 64).astype(np.float32)
+        noise = cuda.to_device(noise)
+
+        # A mock of a CUDA function that always raises a CudaAPIError
+
+        def raising_transfer(*args, **kwargs):
+            raise CudaAPIError(999, 'Transfer not allowed')
+
+        # Use the mock for transfers between the host and device
+
+        old_HtoD = getattr(driver, 'cuMemcpyHtoD', None)
+        old_DtoH = getattr(driver, 'cuMemcpyDtoH', None)
+
+        setattr(driver, 'cuMemcpyHtoD', raising_transfer)
+        setattr(driver, 'cuMemcpyDtoH', raising_transfer)
+
+        # Ensure that the mock functions are working as expected
+
+        with self.assertRaisesRegex(CudaAPIError, "Transfer not allowed"):
+            noise.copy_to_host()
+
+        with self.assertRaisesRegex(CudaAPIError, "Transfer not allowed"):
+            cuda.to_device([1])
+
+        try:
+            # Check that defining and calling a ufunc with data on the device
+            # induces no transfers
+
+            @vectorize(['float32(float32)'], target='cuda')
+            def func(noise):
+                return noise + 1.0
+
+            func(noise)
+        finally:
+            # Replace our mocks with the original implementations. If there was
+            # no original implementation, simply remove ours.
+
+            if old_HtoD is not None:
+                setattr(driver, 'cuMemcpyHtoD', old_HtoD)
+            else:
+                del driver.cuMemcpyHtoD
+            if old_DtoH is not None:
+                setattr(driver, 'cuMemcpyDtoH', old_DtoH)
+            else:
+                del driver.cuMemcpyDtoH
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,20 @@
+import numpy as np
+from numba import vectorize
+from numba.cuda.testing import skip_on_cudasim, CUDATestCase
+import unittest
+
+
+@skip_on_cudasim('ufunc API unsupported in the simulator')
+class TestVectorizeComplex(CUDATestCase):
+    def test_vectorize_complex(self):
+        @vectorize(['complex128(complex128)'], target='cuda')
+        def vcomp(a):
+            return a * a + 1.
+
+        A = np.arange(5, dtype=np.complex128)
+        B = vcomp(A)
+        self.assertTrue(np.allclose(A * A + 1., B))
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,69 @@
+import numpy as np
+
+from numba import vectorize, cuda
+from numba.tests.npyufunc.test_vectorize_decor import BaseVectorizeDecor, \
+    BaseVectorizeNopythonArg, BaseVectorizeUnrecognizedArg
+from numba.cuda.testing import skip_on_cudasim, CUDATestCase
+import unittest
+
+
+@skip_on_cudasim('ufunc API unsupported in the simulator')
+class TestVectorizeDecor(CUDATestCase, BaseVectorizeDecor):
+    """
+    Runs the tests from BaseVectorizeDecor with the CUDA target.
+    """
+    target = 'cuda'
+
+
+@skip_on_cudasim('ufunc API unsupported in the simulator')
+class TestGPUVectorizeBroadcast(CUDATestCase):
+    def test_broadcast(self):
+        a = np.random.randn(100, 3, 1)
+        b = a.transpose(2, 1, 0)
+
+        def fn(a, b):
+            return a - b
+
+        @vectorize(['float64(float64,float64)'], target='cuda')
+        def fngpu(a, b):
+            return a - b
+
+        expect = fn(a, b)
+        got = fngpu(a, b)
+        np.testing.assert_almost_equal(expect, got)
+
+    def test_device_broadcast(self):
+        """
+        Same test as .test_broadcast() but with device array as inputs
+        """
+
+        a = np.random.randn(100, 3, 1)
+        b = a.transpose(2, 1, 0)
+
+        def fn(a, b):
+            return a - b
+
+        @vectorize(['float64(float64,float64)'], target='cuda')
+        def fngpu(a, b):
+            return a - b
+
+        expect = fn(a, b)
+        got = fngpu(cuda.to_device(a), cuda.to_device(b))
+        np.testing.assert_almost_equal(expect, got.copy_to_host())
+
+
+@skip_on_cudasim('ufunc API unsupported in the simulator')
+class TestVectorizeNopythonArg(BaseVectorizeNopythonArg, CUDATestCase):
+    def test_target_cuda_nopython(self):
+        warnings = ["nopython kwarg for cuda target is redundant"]
+        self._test_target_nopython('cuda', warnings)
+
+
+@skip_on_cudasim('ufunc API unsupported in the simulator')
+class TestVectorizeUnrecognizedArg(BaseVectorizeUnrecognizedArg, CUDATestCase):
+    def test_target_cuda_unrecognized_arg(self):
+        self._test_target_unrecognized_arg('cuda')
+
+
+if __name__ == '__main__':
+    unittest.main()