Merge master into impl_common_type

Author: vlad-perevezentsev

dpnp/backend/extensions/blas/blas_py.cpp

@@ -62,8 +62,7 @@ PYBIND11_MODULE(_blas_impl, m)
     using event_vecT = std::vector<sycl::event>;
 
     {
-        dot_ns::init_dot_dispatch_vector<dot_impl_fn_ptr_t,
-                                         blas_ns::DotContigFactory>(
+        dot_ns::init_dot_dispatch_vector<blas_ns::DotContigFactory>(
             dot_dispatch_vector);
 
         auto dot_pyapi = [&](sycl::queue &exec_q, const arrayT &src1,
@@ -81,8 +80,7 @@ PYBIND11_MODULE(_blas_impl, m)
     }
 
     {
-        dot_ns::init_dot_dispatch_vector<dot_impl_fn_ptr_t,
-                                         blas_ns::DotcContigFactory>(
+        dot_ns::init_dot_dispatch_vector<blas_ns::DotcContigFactory>(
             dotc_dispatch_vector);
 
         auto dotc_pyapi = [&](sycl::queue &exec_q, const arrayT &src1,
@@ -101,8 +99,7 @@ PYBIND11_MODULE(_blas_impl, m)
     }
 
     {
-        dot_ns::init_dot_dispatch_vector<dot_impl_fn_ptr_t,
-                                         blas_ns::DotuContigFactory>(
+        dot_ns::init_dot_dispatch_vector<blas_ns::DotuContigFactory>(
             dotu_dispatch_vector);
 
         auto dotu_pyapi = [&](sycl::queue &exec_q, const arrayT &src1,

dpnp/backend/extensions/blas/dot_common.hpp

@@ -50,14 +50,13 @@ typedef sycl::event (*dot_impl_fn_ptr_t)(sycl::queue &,
 namespace dpctl_td_ns = dpctl::tensor::type_dispatch;
 namespace py = pybind11;
 
-template <typename dispatchT>
 std::pair<sycl::event, sycl::event>
     dot_func(sycl::queue &exec_q,
              const dpctl::tensor::usm_ndarray &vectorX,
              const dpctl::tensor::usm_ndarray &vectorY,
              const dpctl::tensor::usm_ndarray &result,
              const std::vector<sycl::event> &depends,
-             const dispatchT &dot_dispatch_vector)
+             const dot_impl_fn_ptr_t *dot_dispatch_vector)
 {
     const int vectorX_nd = vectorX.get_ndim();
     const int vectorY_nd = vectorY.get_ndim();
@@ -166,12 +165,10 @@ std::pair<sycl::event, sycl::event>
     return std::make_pair(args_ev, dot_ev);
 }
 
-template <typename dispatchT,
-          template <typename fnT, typename T>
-          typename factoryT>
-void init_dot_dispatch_vector(dispatchT dot_dispatch_vector[])
+template <template <typename fnT, typename T> typename factoryT>
+void init_dot_dispatch_vector(dot_impl_fn_ptr_t dot_dispatch_vector[])
 {
-    dpctl_td_ns::DispatchVectorBuilder<dispatchT, factoryT,
+    dpctl_td_ns::DispatchVectorBuilder<dot_impl_fn_ptr_t, factoryT,
                                        dpctl_td_ns::num_types>
         contig;
     contig.populate_dispatch_vector(dot_dispatch_vector);

dpnp/backend/extensions/window/common.hpp

@@ -67,12 +67,11 @@ sycl::event window_impl(sycl::queue &q,
     return window_ev;
 }
 
-template <typename dispatchT>
 std::pair<sycl::event, sycl::event>
     py_window(sycl::queue &exec_q,
               const dpctl::tensor::usm_ndarray &result,
               const std::vector<sycl::event> &depends,
-              const dispatchT &window_dispatch_vector)
+              const window_fn_ptr_t *window_dispatch_vector)
 {
     dpctl::tensor::validation::CheckWritable::throw_if_not_writable(result);
 

dpnp/tests/helper.py

@@ -346,6 +346,14 @@ def is_cuda_device(device=None):
     return dev.backend == dpctl.backend_type.cuda
 
 
+def is_gpu_device(device=None):
+    """
+    Return True if a test is running on GPU device, False otherwise.
+    """
+    dev = dpctl.select_default_device() if device is None else device
+    return dev.has_aspect_gpu
+
+
 def is_win_platform():
     """
     Return True if a test is running on Windows OS, False otherwise.

dpnp/tests/skipped_tests.tbl

@@ -10,10 +10,3 @@ tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.
 tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.asarray(x).astype(dpnp.int8)]
 
 tests/third_party/intel/test_zero_copy_test1.py::test_dpnp_interaction_with_dpctl_memory
-
-tests/test_umath.py::test_umaths[('divmod', 'ii')]
-tests/test_umath.py::test_umaths[('divmod', 'll')]
-tests/test_umath.py::test_umaths[('divmod', 'ff')]
-tests/test_umath.py::test_umaths[('divmod', 'dd')]
-tests/test_umath.py::test_umaths[('frexp', 'f')]
-tests/test_umath.py::test_umaths[('frexp', 'd')]

dpnp/tests/skipped_tests_cuda.tbl

@@ -4,8 +4,6 @@
 tests/test_arithmetic.py::TestArithmetic::test_modf_part1
 tests/test_arithmetic.py::TestArithmetic::test_modf_part2
 tests/test_sycl_queue.py::test_modf[cuda:gpu:0]
-tests/test_umath.py::test_umaths[('modf', 'f')]
-tests/test_umath.py::test_umaths[('modf', 'd')]
 tests/third_party/cupy/math_tests/test_arithmetic.py::TestArithmeticModf::test_modf
 
 # random

dpnp/tests/skipped_tests_gpu.tbl

@@ -17,12 +17,4 @@ tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: (dpnp
 tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.asarray([(i, i) for i in x], [("a", object), ("b", dpnp.int32)])]]
 tests/test_random.py::TestPermutationsTestShuffle::test_shuffle1[lambda x: dpnp.asarray(x).astype(dpnp.int8)]
 
-tests/test_umath.py::test_umaths[('divmod', 'ii')]
-tests/test_umath.py::test_umaths[('divmod', 'll')]
-tests/test_umath.py::test_umaths[('divmod', 'ff')]
-tests/test_umath.py::test_umaths[('divmod', 'dd')]
-tests/test_umath.py::test_umaths[('floor_divide', 'ff')]
-tests/test_umath.py::test_umaths[('frexp', 'f')]
-tests/test_umath.py::test_umaths[('frexp', 'd')]
-
 tests/third_party/intel/test_zero_copy_test1.py::test_dpnp_interaction_with_dpctl_memory

dpnp/tests/skipped_tests_gpu_no_fp64.tbl

@@ -13,6 +13,7 @@
 
 from .helper import (
     assert_dtype_allclose,
+    generate_random_numpy_array,
     get_abs_array,
     get_all_dtypes,
     get_complex_dtypes,
@@ -22,10 +23,6 @@
     has_support_aspect16,
     numpy_version,
 )
-from .test_umath import (
-    _get_numpy_arrays_2in_1out,
-    _get_output_data_type,
-)
 
 """
 The scope includes tests with only functions which are instances of
@@ -39,7 +36,9 @@ class TestAdd:
 
     @pytest.mark.parametrize("dtype", ALL_DTYPES)
     def test_add(self, dtype):
-        a, b, expected = _get_numpy_arrays_2in_1out("add", dtype, [-5, 5, 10])
+        a = generate_random_numpy_array(10, dtype)
+        b = generate_random_numpy_array(10, dtype)
+        expected = numpy.add(a, b)
 
         ia, ib = dpnp.array(a), dpnp.array(b)
         iout = dpnp.empty(expected.shape, dtype=dtype)
@@ -139,91 +138,63 @@ def test_invalid_out(self, xp, out):
         assert_raises(TypeError, xp.add, a, 2, out)
 
 
+@pytest.mark.parametrize("func", ["fmax", "fmin", "maximum", "minimum"])
 class TestBoundFuncs:
-    @pytest.fixture(
-        params=[
-            {"func_name": "fmax", "input_values": [-5, 5, 10]},
-            {"func_name": "fmin", "input_values": [-5, 5, 10]},
-            {"func_name": "maximum", "input_values": [-5, 5, 10]},
-            {"func_name": "minimum", "input_values": [-5, 5, 10]},
-        ],
-        ids=[
-            "fmax",
-            "fmin",
-            "maximum",
-            "minimum",
-        ],
-    )
-    def func_params(self, request):
-        return request.param
-
-    @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_bool=True, no_complex=True)
-    )
-    def test_out(self, func_params, dtype):
-        func_name = func_params["func_name"]
-        input_values = func_params["input_values"]
-        a, b, expected = _get_numpy_arrays_2in_1out(
-            func_name, dtype, input_values
-        )
+    @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
+    def test_out(self, func, dtype):
+        a = generate_random_numpy_array(10, dtype)
+        b = generate_random_numpy_array(10, dtype)
+        expected = getattr(numpy, func)(a, b)
 
         ia, ib = dpnp.array(a), dpnp.array(b)
         iout = dpnp.empty(expected.shape, dtype=dtype)
-        result = getattr(dpnp, func_name)(ia, ib, out=iout)
+        result = getattr(dpnp, func)(ia, ib, out=iout)
 
         assert result is iout
         assert_dtype_allclose(result, expected)
 
     @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_bool=True, no_complex=True)
+        "dtype", get_all_dtypes(no_none=True, no_bool=True)
     )
-    def test_out_overlap(self, func_params, dtype):
-        func_name = func_params["func_name"]
+    def test_out_overlap(self, func, dtype):
         size = 15
         a = numpy.arange(2 * size, dtype=dtype)
         ia = dpnp.array(a)
 
-        getattr(dpnp, func_name)(ia[size::], ia[::2], out=ia[:size:])
-        getattr(numpy, func_name)(a[size::], a[::2], out=a[:size:])
+        getattr(dpnp, func)(ia[size::], ia[::2], out=ia[:size:])
+        getattr(numpy, func)(a[size::], a[::2], out=a[:size:])
 
         assert_dtype_allclose(ia, a)
 
     @pytest.mark.parametrize("shape", [(0,), (15,), (2, 2)])
-    def test_invalid_shape(self, func_params, shape):
-        func_name = func_params["func_name"]
+    def test_invalid_shape(self, func, shape):
         a, b = dpnp.arange(10), dpnp.arange(10)
         out = dpnp.empty(shape)
 
         with pytest.raises(ValueError):
-            getattr(dpnp, func_name)(a, b, out=out)
+            getattr(dpnp, func)(a, b, out=out)
 
     @pytest.mark.parametrize("xp", [dpnp, numpy])
     @pytest.mark.parametrize(
         "out",
         [4, (), [], (3, 7), [2, 4]],
         ids=["scalar", "empty_tuple", "empty_list", "tuple", "list"],
     )
-    def test_invalid_out(self, func_params, xp, out):
-        func_name = func_params["func_name"]
+    def test_invalid_out(self, func, xp, out):
         a = xp.arange(10)
-        assert_raises(TypeError, getattr(xp, func_name), a, 2, out)
+        assert_raises(TypeError, getattr(xp, func), a, 2, out)
 
 
 class TestDivide:
     @pytest.mark.usefixtures("suppress_divide_invalid_numpy_warnings")
-    @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_none=True, no_bool=True)
-    )
+    @pytest.mark.parametrize("dtype", get_all_dtypes(no_none=True))
     def test_divide(self, dtype):
-        a, b, expected = _get_numpy_arrays_2in_1out(
-            "divide", dtype, [-5, 5, 10]
-        )
+        a = generate_random_numpy_array(10, dtype)
+        b = generate_random_numpy_array(10, dtype)
+        expected = numpy.divide(a, b)
 
         ia, ib = dpnp.array(a), dpnp.array(b)
-        if numpy.issubdtype(dtype, numpy.integer):
-            out_dtype = map_dtype_to_device(dpnp.float64, ia.sycl_device)
-        else:
-            out_dtype = _get_output_data_type(dtype)
+        out_dtype = map_dtype_to_device(expected.dtype, ia.sycl_device)
         iout = dpnp.empty(expected.shape, dtype=out_dtype)
         result = dpnp.divide(ia, ib, out=iout)
 
@@ -318,7 +289,9 @@ def do_inplace_op(self, base, other, func):
     @pytest.mark.usefixtures("suppress_divide_numpy_warnings")
     @pytest.mark.parametrize("dtype", ALL_DTYPES)
     def test_basic(self, func, dtype):
-        a, b, expected = _get_numpy_arrays_2in_1out(func, dtype, [-5, 5, 10])
+        a = generate_random_numpy_array(10, dtype)
+        b = generate_random_numpy_array(10, dtype)
+        expected = getattr(numpy, func)(a, b)
 
         ia, ib = dpnp.array(a), dpnp.array(b)
         iout = dpnp.empty(expected.shape, dtype=dtype)
@@ -398,9 +371,9 @@ def test_invalid_out(self, func, xp, out):
         assert_raises(TypeError, getattr(xp, func), a, 2, out)
 
 
+@pytest.mark.parametrize("func", ["fmax", "fmin"])
 class TestFmaxFmin:
     @pytest.mark.skipif(not has_support_aspect16(), reason="no fp16 support")
-    @pytest.mark.parametrize("func", ["fmax", "fmin"])
     def test_half(self, func):
         a = numpy.array([0, 1, 2, 4, 2], dtype=numpy.float16)
         b = numpy.array([-2, 5, 1, 4, 3], dtype=numpy.float16)
@@ -415,7 +388,6 @@ def test_half(self, func):
         expected = getattr(numpy, func)(b, c)
         assert_equal(result, expected)
 
-    @pytest.mark.parametrize("func", ["fmax", "fmin"])
     @pytest.mark.parametrize("dtype", get_float_dtypes())
     def test_float_nans(self, func, dtype):
         a = numpy.array([0, numpy.nan, numpy.nan], dtype=dtype)
@@ -426,7 +398,6 @@ def test_float_nans(self, func, dtype):
         expected = getattr(numpy, func)(a, b)
         assert_equal(result, expected)
 
-    @pytest.mark.parametrize("func", ["fmax", "fmin"])
     @pytest.mark.parametrize("dtype", get_complex_dtypes())
     @pytest.mark.parametrize(
         "nan_val",
@@ -446,7 +417,6 @@ def test_complex_nans(self, func, dtype, nan_val):
         expected = getattr(numpy, func)(a, b)
         assert_equal(result, expected)
 
-    @pytest.mark.parametrize("func", ["fmax", "fmin"])
     @pytest.mark.parametrize("dtype", get_float_dtypes(no_float16=False))
     def test_precision(self, func, dtype):
         dtmin = numpy.finfo(dtype).min
@@ -602,9 +572,9 @@ class TestMultiply:
 
     @pytest.mark.parametrize("dtype", ALL_DTYPES)
     def test_multiply(self, dtype):
-        a, b, expected = _get_numpy_arrays_2in_1out(
-            "multiply", dtype, [0, 10, 10]
-        )
+        a = generate_random_numpy_array(10, dtype)
+        b = generate_random_numpy_array(10, dtype)
+        expected = numpy.multiply(a, b)
 
         ia, ib = dpnp.array(a), dpnp.array(b)
         iout = dpnp.empty(expected.shape, dtype=dtype)
@@ -853,8 +823,9 @@ def test_basic(self, array, val, data_type, val_type):
 
     @pytest.mark.parametrize("dtype", ALL_DTYPES)
     def test_power(self, dtype):
-        numpy.random.seed(42)
-        a, b, expected = _get_numpy_arrays_2in_1out("power", dtype, [0, 10, 10])
+        a = generate_random_numpy_array(10, dtype, low=0)
+        b = generate_random_numpy_array(10, dtype, low=0)
+        expected = numpy.power(a, b)
 
         ia, ib = dpnp.array(a), dpnp.array(b)
         out_dtype = numpy.int8 if dtype == numpy.bool_ else dtype
@@ -1075,9 +1046,9 @@ class TestSubtract:
 
     @pytest.mark.parametrize("dtype", ALL_DTYPES)
     def test_add(self, dtype):
-        a, b, expected = _get_numpy_arrays_2in_1out(
-            "subtract", dtype, [-5, 5, 10]
-        )
+        a = generate_random_numpy_array(10, dtype)
+        b = generate_random_numpy_array(10, dtype)
+        expected = numpy.subtract(a, b)
 
         ia, ib = dpnp.array(a), dpnp.array(b)
         iout = dpnp.empty(expected.shape, dtype=dtype)