Merge branch 'master' into add-helper-function

Author: antonwolfy

dpnp/tests/helper.py

@@ -412,6 +412,14 @@ def has_support_aspect64(device=None):
     return dev.has_aspect_fp64
 
 
+def is_arl_or_mtl(device=None):
+    """
+    Return True if a test is running on Arrow Lake or Meteor Lake GPU device,
+    False otherwise.
+    """
+    return _get_dev_mask(device) == 0x7D00
+
+
 def is_cpu_device(device=None):
     """
     Return True if a test is running on CPU device, False otherwise.

dpnp/tests/test_linalg.py

@@ -23,7 +23,8 @@
     get_float_complex_dtypes,
     get_integer_float_dtypes,
     has_support_aspect64,
-    is_cpu_device,
+    is_arl_or_mtl,
+    is_win_platform,
     numpy_version,
 )
 from .third_party.cupy import testing
@@ -109,6 +110,8 @@ def test_usm_ndarray_linalg_batch(func, gen_kwargs, func_kwargs):
             )
             for _ in range(2)
         ]
+    elif func == "cholesky" and is_win_platform() and is_arl_or_mtl():
+        pytest.skip("SAT-8206")
     else:
         dpt_args = [
             dpt.asarray(generate_random_numpy_array(shape, **gen_kwargs))
@@ -158,6 +161,8 @@ class TestCholesky:
     def test_cholesky(self, array, dtype):
         a = numpy.array(array, dtype=dtype)
         ia = dpnp.array(a)
+        if ia.ndim > 2 and is_win_platform() and is_arl_or_mtl():
+            pytest.skip("SAT-8206")
         result = dpnp.linalg.cholesky(ia)
         expected = numpy.linalg.cholesky(a)
         assert_dtype_allclose(result, expected)
@@ -177,6 +182,8 @@ def test_cholesky(self, array, dtype):
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True))
     def test_cholesky_upper(self, array, dtype):
         ia = dpnp.array(array, dtype=dtype)
+        if ia.ndim > 2 and is_win_platform() and is_arl_or_mtl():
+            pytest.skip("SAT-8206")
         result = dpnp.linalg.cholesky(ia, upper=True)
 
         if ia.ndim > 2:
@@ -219,6 +226,8 @@ def test_cholesky_upper(self, array, dtype):
     def test_cholesky_upper_numpy(self, array, dtype):
         a = numpy.array(array, dtype=dtype)
         ia = dpnp.array(a)
+        if ia.ndim > 2 and is_win_platform() and is_arl_or_mtl():
+            pytest.skip("SAT-8206")
         result = dpnp.linalg.cholesky(ia, upper=True)
         expected = numpy.linalg.cholesky(a, upper=True)
         assert_dtype_allclose(result, expected)

dpnp/tests/test_strides.py

@@ -182,6 +182,7 @@ def test_erf(dtype):
     assert_dtype_allclose(result, expected)
 
 
+@pytest.mark.filterwarnings("ignore::RuntimeWarning")
 @pytest.mark.parametrize("dtype", get_float_complex_dtypes())
 @pytest.mark.parametrize("stride", [2, -1, -3])
 def test_reciprocal(dtype, stride):

dpnp/tests/test_sycl_queue.py

@@ -12,7 +12,12 @@
 from dpnp.dpnp_array import dpnp_array
 from dpnp.dpnp_utils import get_usm_allocations
 
-from .helper import generate_random_numpy_array, get_all_dtypes, is_win_platform
+from .helper import (
+    generate_random_numpy_array,
+    get_all_dtypes,
+    is_arl_or_mtl,
+    is_win_platform,
+)
 
 list_of_backend_str = ["cuda", "host", "level_zero", "opencl"]
 
@@ -1488,6 +1493,8 @@ def test_cholesky(self, data, is_empty, device):
         else:
             dtype = dpnp.default_float_type(device)
             x = dpnp.array(data, dtype=dtype, device=device)
+            if x.ndim > 2 and is_win_platform() and is_arl_or_mtl():
+                pytest.skip("SAT-8206")
 
         result = dpnp.linalg.cholesky(x)
         assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue)

dpnp/tests/test_umath.py

@@ -445,7 +445,7 @@ def test_large_values(self, dtype):
 
 
 class TestReciprocal:
-    @pytest.mark.usefixtures("suppress_divide_numpy_warnings")
+    @pytest.mark.filterwarnings("ignore::RuntimeWarning")
     @pytest.mark.parametrize("dtype", get_float_complex_dtypes())
     def test_reciprocal(self, dtype):
         a = generate_random_numpy_array(10, dtype)

dpnp/tests/test_usm_type.py

@@ -10,7 +10,7 @@
 import dpnp
 from dpnp.dpnp_utils import get_usm_allocations
 
-from .helper import generate_random_numpy_array, is_win_platform
+from .helper import generate_random_numpy_array, is_arl_or_mtl, is_win_platform
 
 list_of_usm_types = ["device", "shared", "host"]
 
@@ -1341,6 +1341,8 @@ def test_cholesky(self, data, is_empty, usm_type):
             x = dpnp.empty(data, dtype=dtype, usm_type=usm_type)
         else:
             x = dpnp.array(data, dtype=dtype, usm_type=usm_type)
+            if x.ndim > 2 and is_win_platform() and is_arl_or_mtl():
+                pytest.skip("SAT-8206")
 
         result = dpnp.linalg.cholesky(x)
         assert x.usm_type == result.usm_type

dpnp/tests/third_party/cupy/linalg_tests/test_decomposition.py

@@ -6,7 +6,9 @@
 import dpnp as cupy
 from dpnp.tests.helper import (
     has_support_aspect64,
+    is_arl_or_mtl,
     is_cpu_device,
+    is_win_platform,
 )
 from dpnp.tests.third_party.cupy import testing
 from dpnp.tests.third_party.cupy.testing import _condition
@@ -82,6 +84,9 @@ def test_decomposition(self, dtype):
         # np.linalg.cholesky only uses a lower triangle of an array
         self.check_L(numpy.array([[1, 2], [1, 9]], dtype))
 
+    @pytest.mark.skipif(
+        is_win_platform() and is_arl_or_mtl(), reason="SAT-8206"
+    )
     @testing.for_dtypes(
         [
             numpy.int32,

dpnp/tests/third_party/cupy/math_tests/test_arithmetic.py

@@ -134,6 +134,7 @@ def test_raises_with_numpy_input(self):
 )
 class TestArithmeticUnary:
 
+    @pytest.mark.filterwarnings("ignore::RuntimeWarning")
     @testing.numpy_cupy_allclose(atol=1e-5, type_check=has_support_aspect64())
     def test_unary(self, xp):
         arg1 = self.arg1

dpnp/tests/third_party/cupy/math_tests/test_misc.py

@@ -250,6 +250,7 @@ def test_nan_to_num_for_old_numpy(self):
     def test_nan_to_num_negative_for_old_numpy(self):
         self.check_unary_negative("nan_to_num", no_bool=True)
 
+    @pytest.mark.filterwarnings("ignore::RuntimeWarning")
     def test_nan_to_num_inf(self):
         self.check_unary_inf("nan_to_num")
 
@@ -260,6 +261,7 @@ def test_nan_to_num_nan(self):
     def test_nan_to_num_scalar_nan(self, xp):
         return xp.nan_to_num(xp.array(xp.nan))
 
+    @pytest.mark.filterwarnings("ignore::RuntimeWarning")
     def test_nan_to_num_inf_nan(self):
         self.check_unary_inf_nan("nan_to_num")