Port existing kernel tests to experimental.

Author: Diptorup Deb

numba_dpex/tests/experimental/test_complex_array.py

@@ -0,0 +1,73 @@
+# SPDX-FileCopyrightText: 2020 - 2024 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import dpnp
+import numpy
+import pytest
+
+import numba_dpex.experimental as dpex
+from numba_dpex.tests._helper import get_all_dtypes
+
+N = 1024
+
+
+@dpex.kernel
+def kernel_scalar(item, a, b, c):
+    i = item.get_id(0)
+    b[i] = a[i] * c
+
+
+@dpex.kernel
+def kernel_array(item, a, b, c):
+    i = item.get_id(0)
+    b[i] = a[i] * c[i]
+
+
+list_of_dtypes = get_all_dtypes(
+    no_bool=True, no_int=True, no_float=True, no_none=True
+)
+
+list_of_usm_types = ["shared", "device", "host"]
+
+
+@pytest.fixture(params=list_of_dtypes)
+def input_arrays(request):
+    a = dpnp.ones(N, dtype=request.param)
+    c = dpnp.zeros(N, dtype=request.param)
+    b = dpnp.empty_like(a)
+    return a, b, c
+
+
+def test_numeric_kernel_arg_complex_scalar(input_arrays):
+    """Tests passing complex type scalar and dpnp arrays to a kernel function.
+
+    Args:
+        input_arrays (dpnp.ndarray): Array arguments to be passed to a kernel.
+    """
+    a, b, _ = input_arrays
+    s = a.dtype.type(2 + 1j)
+
+    dpex.call_kernel(kernel_scalar, dpex.Range(N), a, b, s)
+
+    nb = dpnp.asnumpy(b)
+    nexpected = numpy.full_like(nb, fill_value=2 + 1j)
+
+    assert numpy.allclose(nb, nexpected)
+
+
+def test_numeric_kernel_arg_complex_array(input_arrays):
+    """Tests passing complex type dpnp arrays to a kernel function.
+
+    Args:
+        input_arrays (dpnp.ndarray): Array arguments to be passed to a kernel.
+    """
+
+    a, b, c = input_arrays
+
+    dpex.call_kernel(kernel_array, dpex.Range(N), a, b, c)
+
+    nb = dpnp.asnumpy(b)
+    nexpected = numpy.full_like(nb, fill_value=0 + 0j)
+
+    assert numpy.allclose(nb, nexpected)

numba_dpex/tests/experimental/test_dpnp_ndarray_args.py

@@ -0,0 +1,96 @@
+# SPDX-FileCopyrightText: 2020 - 2024 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import dpnp
+
+import numba_dpex.experimental as ndpx
+from numba_dpex import float32
+from numba_dpex import kernel_api as kapi
+
+COEFFICIENTS = dpnp.asarray(
+    [
+        [
+            -0.008086340206185568,
+            0.242590206185567,
+            -0.6172680412371134,
+            0,
+        ],
+        [
+            0.015431701030927836,
+            -1.168492268041237,
+            27.60438144329897,
+            -188.1443298969072,
+        ],
+        [
+            -0.0036404639175257733,
+            0.5480025773195877,
+            -23.890463917525775,
+            326.8041237113402,
+        ],
+        [
+            -0.010869845360824743,
+            1.4155283505154639,
+            -58.59149484536083,
+            789.4845360824743,
+        ],
+        [
+            -0.0028801546391752576,
+            0.21707474226804124,
+            1.3311855670103092,
+            -209.22680412371133,
+        ],
+        [
+            0.042390463917525774,
+            -7.9316365979381445,
+            490.25386597938143,
+            -9987.680412371134,
+        ],
+        [
+            -0.061681701030927835,
+            13.923518041237113,
+            -1039.6069587628865,
+            25709.072164948455,
+        ],
+        [
+            0.029336340206185568,
+            -7.920811855670103,
+            707.9394329896908,
+            -20892.164948453606,
+        ],
+    ],
+    dtype=dpnp.float32,
+)
+
+
+@ndpx.kernel()
+def _kernel(nditem: kapi.NdItem, coefficients):
+    c = kapi.PrivateArray(4, dtype=float32)
+    gr: kapi.Group = nditem.get_group()
+    gr_id = gr.get_group_id(0)
+
+    c[0] = coefficients[gr_id][0]
+    c[1] = coefficients[gr_id][1]
+    c[2] = coefficients[gr_id][2]
+    c[3] = coefficients[gr_id][3]
+
+
+def test_setting_private_from_dpnp_ndarray():
+    N_SEGMENTS = 8
+    LOCAL_SIZE = 128
+    # Number of points in the batch. Each work item processes one batch
+    N_POINTS_PER_WORK_ITEM = 4
+    # Number of points processed by a work group
+    N_POINTS_PER_WORK_GROUP = N_POINTS_PER_WORK_ITEM * LOCAL_SIZE
+    # Total number of points
+    N_POINTS = N_POINTS_PER_WORK_GROUP * N_SEGMENTS
+    global_range = ndpx.Range(N_POINTS // N_POINTS_PER_WORK_ITEM)
+    local_range = ndpx.Range(LOCAL_SIZE)
+    try:
+        ndpx.call_kernel(
+            _kernel, ndpx.NdRange(global_range, local_range), COEFFICIENTS
+        )
+    except Exception as e:
+        assert (
+            False
+        ), f"'_kernel' raised an exception {e} when passing a dpnp.ndarray arg"

numba_dpex/tests/experimental/test_func.py

@@ -0,0 +1,28 @@
+# SPDX-FileCopyrightText: 2020 - 2024 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import dpnp
+import numpy
+
+import numba_dpex.experimental as dpex
+
+
+@dpex.device_func
+def g(a):
+    return a + dpnp.float32(1)
+
+
+@dpex.kernel
+def f(item, a, b):
+    i = item.get_id(0)
+    b[i] = g(a[i])
+
+
+def test_func_call_from_kernel():
+    a = dpnp.ones(1024)
+    b = dpnp.ones(1024)
+
+    dpex.call_kernel(f, dpex.Range(1024), a, b)
+    nb = dpnp.asnumpy(b)
+    assert numpy.all(nb == 2)

numba_dpex/tests/experimental/test_func_qualname_disambiguation.py

@@ -0,0 +1,95 @@
+# SPDX-FileCopyrightText: 2023 - 2024 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import dpnp
+import numpy as np
+
+import numba_dpex.experimental as ndpx
+
+
+def make_write_values_kernel(n_rows):
+    """Uppermost kernel to set 1s in a certain way. The uppermost kernel
+    function invokes two levels of inner functions to set 1s in an empty matrix
+    in a certain way.
+
+    Args:
+        n_rows (int): Number of rows to iterate.
+
+    Returns:
+        numba_dpex.core.kernel_interface.dispatcher.JitKernel:
+            A KernelDispatcher object that encapsulates a @kernel decorated
+            numba_dpex compiled kernel object.
+    """
+    write_values = make_write_values_kernel_func()
+
+    @ndpx.kernel
+    def write_values_kernel(array_in):
+        for row_idx in range(n_rows):
+            is_even = (row_idx % 2) == 0
+            write_values(array_in, row_idx, is_even)
+
+    return write_values_kernel
+
+
+def make_write_values_kernel_func():
+    """An upper function to set 1 or 3 ones. A function to set
+    one or three 1s. If the row index is even it will set three 1s,
+    otherwise one 1. It uses the inner function to do this.
+
+    Returns:
+        numba_dpex.core.kernel_interface.func.DpexFunctionTemplate:
+            A DpexFunctionTemplate that encapsulates a @func decorated
+            numba_dpex compiled function object.
+    """
+    write_when_odd = make_write_values_kernel_func_inner(1)
+    write_when_even = make_write_values_kernel_func_inner(3)
+
+    @ndpx.device_func
+    def write_values(array_in, row_idx, is_even):
+        if is_even:
+            write_when_even(array_in, row_idx)
+        else:
+            write_when_odd(array_in, row_idx)
+
+    return write_values
+
+
+def make_write_values_kernel_func_inner(n_cols):
+    """Inner function to set 1s. An inner function to set 1s in
+    n_cols number of columns.
+
+    Args:
+        n_cols (int): Number of columns to be set to 1.
+
+    Returns:
+        numba_dpex.core.kernel_interface.func.DpexFunctionTemplate:
+            A DpexFunctionTemplate that encapsulates a @func decorated
+            numba_dpex compiled function object.
+    """
+
+    @ndpx.device_func
+    def write_values_inner(array_in, row_idx):
+        for idx in range(n_cols):
+            array_in[row_idx, idx] = 1
+
+    return write_values_inner
+
+
+def test_qualname_basic():
+    """A basic test function to test
+    qualified name disambiguation.
+    """
+    ans = np.zeros((10, 10), dtype=np.int64)
+    for i in range(ans.shape[0]):
+        if i % 2 == 0:
+            ans[i, 0:3] = 1
+        else:
+            ans[i, 0] = 1
+
+    a = dpnp.zeros((10, 10), dtype=dpnp.int64)
+
+    kernel = make_write_values_kernel(10)
+    ndpx.call_kernel(kernel, ndpx.NdRange((1,), (1,)), a)
+
+    assert np.array_equal(dpnp.asnumpy(a), ans)

numba_dpex/tests/experimental/test_invalid_kernel_args.py

@@ -0,0 +1,29 @@
+# SPDX-FileCopyrightText: 2020 - 2024 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import numpy
+import pytest
+
+import numba_dpex.experimental as dpex
+from numba_dpex import kernel_api as kapi
+
+N = 1024
+
+
+@dpex.kernel
+def vecadd_kernel(item: kapi.Item, a, b, c):
+    i = item.get_id(0)
+    c[i] = a[i] + b[i]
+
+
+def test_passing_numpy_arrays_as_kernel_args():
+    """
+    Negative test to verify that NumPy arrays cannot be passed to a kernel.
+    """
+    a = numpy.ones(N)
+    b = numpy.ones(N)
+    c = numpy.zeros(N)
+
+    with pytest.raises(Exception):
+        dpex.call_kernel(vecadd_kernel, dpex.Range(N), a, b, c)

numba_dpex/tests/experimental/test_math_functions.py

@@ -0,0 +1,53 @@
+# SPDX-FileCopyrightText: 2020 - 2024 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import math
+
+import dpnp
+import numpy
+import pytest
+
+import numba_dpex.experimental as dpex
+from numba_dpex.tests._helper import get_all_dtypes
+
+list_of_unary_ops = ["fabs", "exp", "log", "sqrt", "sin", "cos", "tan"]
+
+
+@pytest.fixture(params=list_of_unary_ops)
+def unary_op(request):
+    return request.param
+
+
+list_of_dtypes = get_all_dtypes(
+    no_bool=True, no_int=True, no_float16=True, no_none=True, no_complex=True
+)
+
+
+@pytest.fixture(params=list_of_dtypes)
+def input_arrays(request):
+    # The size of input and out arrays to be used
+    N = 2048
+    a = dpnp.arange(N, dtype=request.param)
+    b = dpnp.arange(N, dtype=request.param)
+    return a, b
+
+
+def test_binary_ops(unary_op, input_arrays):
+    a, b = input_arrays
+    uop = getattr(math, unary_op)
+    dpnp_uop = getattr(dpnp, unary_op)
+
+    @dpex.kernel
+    def f(item, a, b):
+        i = item.get_id(0)
+        b[i] = uop(a[i])
+
+    dpex.call_kernel(f, dpex.Range(a.size), a, b)
+
+    expected = dpnp_uop(a)
+
+    np_expected = dpnp.asnumpy(expected)
+    np_actual = dpnp.asnumpy(b)
+
+    assert numpy.allclose(np_expected, np_actual)