Added tests to increase coverage of elementwise functions

Author: oleksandr-pavlyk

dpctl/tensor/_elementwise_common.py

@@ -49,9 +49,7 @@ def __init__(self, name, result_type_resolver_fn, unary_dp_impl_fn, docs):
 
     def __call__(self, x, order="K"):
         if not isinstance(x, dpt.usm_ndarray):
-            raise TypeError(
-                f"Expected :class:`dpctl.tensor.usm_ndarray`, got {type(x)}"
-            )
+            raise TypeError(f"Expected dpctl.tensor.usm_ndarray, got {type(x)}")
         if order not in ["C", "F", "K", "A"]:
             order = "K"
         buf_dt, res_dt = _find_buf_dtype(
@@ -85,8 +83,6 @@ def __call__(self, x, order="K"):
         if order == "K":
             r = _empty_like_orderK(buf, res_dt)
         else:
-            if order == "A":
-                order = "F" if buf.flags.f_contiguous else "C"
             r = dpt.empty_like(buf, dtype=res_dt, order=order)
 
         ht, _ = self.unary_fn_(buf, r, sycl_queue=exec_q, depends=[copy_ev])
@@ -142,6 +138,8 @@ def get(self):
 def _get_dtype(o, dev):
     if isinstance(o, dpt.usm_ndarray):
         return o.dtype
+    if hasattr(o, "__sycl_usm_array_interface__"):
+        return dpt.asarray(o).dtype
     if _is_buffer(o):
         host_dt = np.array(o).dtype
         dev_dt = _to_device_supported_dtype(host_dt, dev)
@@ -224,13 +222,12 @@ def _resolve_weak_types(o1_dtype, o2_dtype, dev):
                 return dpt.bool, o2_dtype
             if isinstance(o1_dtype, WeakIntegralType):
                 return dpt.int64, o2_dtype
-            if isinstance(o1_dtype, WeakInexactType):
-                if isinstance(o1_dtype.get(), complex):
-                    return (
-                        _to_device_supported_dtype(dpt.complex128, dev),
-                        o2_dtype,
-                    )
-                return _to_device_supported_dtype(dpt.float64, dev), o2_dtype
+            if isinstance(o1_dtype.get(), complex):
+                return (
+                    _to_device_supported_dtype(dpt.complex128, dev),
+                    o2_dtype,
+                )
+            return _to_device_supported_dtype(dpt.float64, dev), o2_dtype
         else:
             return o2_dtype, o2_dtype
     elif isinstance(
@@ -243,15 +240,12 @@ def _resolve_weak_types(o1_dtype, o2_dtype, dev):
                 return o1_dtype, dpt.bool
             if isinstance(o2_dtype, WeakIntegralType):
                 return o1_dtype, dpt.int64
-            if isinstance(o2_dtype, WeakInexactType):
-                if isinstance(o2_dtype.get(), complex):
-                    return o1_dtype, _to_device_supported_dtype(
-                        dpt.complex128, dev
-                    )
-                return (
-                    o1_dtype,
-                    _to_device_supported_dtype(dpt.float64, dev),
-                )
+            if isinstance(o2_dtype.get(), complex):
+                return o1_dtype, _to_device_supported_dtype(dpt.complex128, dev)
+            return (
+                o1_dtype,
+                _to_device_supported_dtype(dpt.float64, dev),
+            )
         else:
             return o1_dtype, o1_dtype
     else:
@@ -287,10 +281,14 @@ def __repr__(self):
         return f"<BinaryElementwiseFunc '{self.name_}'>"
 
     def __call__(self, o1, o2, order="K"):
+        if order not in ["K", "C", "F", "A"]:
+            order = "K"
         q1, o1_usm_type = _get_queue_usm_type(o1)
         q2, o2_usm_type = _get_queue_usm_type(o2)
         if q1 is None and q2 is None:
-            raise ValueError(
+            raise ExecutionPlacementError(
+                "Execution placement can not be unambiguously inferred "
+                "from input arguments. "
                 "One of the arguments must represent USM allocation and "
                 "expose `__sycl_usm_array_interface__` property"
             )
@@ -415,18 +413,6 @@ def __call__(self, o1, o2, order="K"):
                     src1, buf2, res_dt, res_usm_type, exec_q
                 )
             else:
-                if order == "A":
-                    order = (
-                        "F"
-                        if all(
-                            arr.flags.f_contiguous
-                            for arr in (
-                                src1,
-                                buf2,
-                            )
-                        )
-                        else "C"
-                    )
                 r = dpt.empty(
                     res_shape,
                     dtype=res_dt,
@@ -461,18 +447,6 @@ def __call__(self, o1, o2, order="K"):
                     buf1, src2, res_dt, res_usm_type, exec_q
                 )
             else:
-                if order == "A":
-                    order = (
-                        "F"
-                        if all(
-                            arr.flags.f_contiguous
-                            for arr in (
-                                buf1,
-                                src2,
-                            )
-                        )
-                        else "C"
-                    )
                 r = dpt.empty(
                     res_shape,
                     dtype=res_dt,
@@ -493,7 +467,7 @@ def __call__(self, o1, o2, order="K"):
             ht_.wait()
             return r
 
-        if order in "KA":
+        if order in ["K", "A"]:
             if src1.flags.f_contiguous and src2.flags.f_contiguous:
                 order = "F"
             else:

dpctl/tests/test_tensor_elementwise.py

@@ -1,10 +1,13 @@
+import ctypes
 import itertools
 
 import numpy as np
 import pytest
 
 import dpctl
 import dpctl.tensor as dpt
+import dpctl.tensor._type_utils as tu
+import dpctl.utils
 from dpctl.tests.helper import get_queue_or_skip, skip_if_dtype_not_supported
 
 _all_dtypes = [
@@ -26,6 +29,157 @@
 _usm_types = ["device", "shared", "host"]
 
 
+class MockDevice:
+    def __init__(self, fp16: bool, fp64: bool):
+        self.has_aspect_fp16 = fp16
+        self.has_aspect_fp64 = fp64
+
+
+def _map_to_device_dtype(dt, dev):
+    return tu._to_device_supported_dtype(dt, dev)
+
+
+@pytest.mark.parametrize("dtype", _all_dtypes)
+def test_type_utils_map_to_device_type(dtype):
+    for fp64 in [
+        True,
+        False,
+    ]:
+        for fp16 in [True, False]:
+            dev = MockDevice(fp16, fp64)
+            dt_in = dpt.dtype(dtype)
+            dt_out = _map_to_device_dtype(dt_in, dev)
+            assert isinstance(dt_out, dpt.dtype)
+
+
+def test_type_util_all_data_types():
+    for fp64 in [
+        True,
+        False,
+    ]:
+        for fp16 in [True, False]:
+            r = tu._all_data_types(fp16, fp64)
+            assert isinstance(r, list)
+            # 11: bool + 4 signed + 4 unsigned inegral + float32 + complex64
+            assert len(r) == 11 + int(fp16) + 2 * int(fp64)
+
+
+def test_type_util_can_cast():
+    for fp64 in [
+        True,
+        False,
+    ]:
+        for fp16 in [True, False]:
+            for from_ in _all_dtypes:
+                for to_ in _all_dtypes:
+                    r = tu._can_cast(
+                        dpt.dtype(from_), dpt.dtype(to_), fp16, fp64
+                    )
+                    assert isinstance(r, bool)
+
+
+def test_type_utils_empty_like_orderK():
+    try:
+        a = dpt.empty((10, 10), dtype=dpt.int32, order="F")
+    except dpctl.SyclDeviceCreationError:
+        pytest.skip("No SYCL devices available")
+    X = tu._empty_like_orderK(a, dpt.int32, a.usm_type, a.device)
+    assert X.flags["F"]
+
+
+def test_type_utils_empty_like_orderK_invalid_args():
+    with pytest.raises(TypeError):
+        tu._empty_like_orderK([1, 2, 3], dpt.int32, "device", None)
+    with pytest.raises(TypeError):
+        tu._empty_like_pair_orderK(
+            [1, 2, 3],
+            (
+                1,
+                2,
+                3,
+            ),
+            dpt.int32,
+            "device",
+            None,
+        )
+    try:
+        a = dpt.empty(10, dtype=dpt.int32)
+    except dpctl.SyclDeviceCreationError:
+        pytest.skip("No SYCL devices available")
+    with pytest.raises(TypeError):
+        tu._empty_like_pair_orderK(
+            a,
+            (
+                1,
+                2,
+                3,
+            ),
+            dpt.int32,
+            "device",
+            None,
+        )
+
+
+def test_type_utils_find_buf_dtype():
+    def _denier_fn(dt):
+        return False
+
+    for fp64 in [
+        True,
+        False,
+    ]:
+        for fp16 in [True, False]:
+            dev = MockDevice(fp16, fp64)
+            arg_dt = dpt.float64
+            r = tu._find_buf_dtype(arg_dt, _denier_fn, dev)
+            assert r == (
+                None,
+                None,
+            )
+
+
+def test_type_utils_find_buf_dtype2():
+    def _denier_fn(dt1, dt2):
+        return False
+
+    for fp64 in [
+        True,
+        False,
+    ]:
+        for fp16 in [True, False]:
+            dev = MockDevice(fp16, fp64)
+            arg1_dt = dpt.float64
+            arg2_dt = dpt.complex64
+            r = tu._find_buf_dtype2(arg1_dt, arg2_dt, _denier_fn, dev)
+            assert r == (
+                None,
+                None,
+                None,
+            )
+
+
+def test_unary_func_arg_validation():
+    with pytest.raises(TypeError):
+        dpt.abs([1, 2, 3])
+    try:
+        a = dpt.arange(8)
+    except dpctl.SyclDeviceCreationError:
+        pytest.skip("No SYCL devices available")
+    dpt.abs(a, order="invalid")
+
+
+def test_binary_func_arg_vaidation():
+    with pytest.raises(dpctl.utils.ExecutionPlacementError):
+        dpt.add([1, 2, 3], 1)
+    try:
+        a = dpt.arange(8)
+    except dpctl.SyclDeviceCreationError:
+        pytest.skip("No SYCL devices available")
+    with pytest.raises(ValueError):
+        dpt.add(a, Ellipsis)
+    dpt.add(a, a, order="invalid")
+
+
 @pytest.mark.parametrize("dtype", _all_dtypes)
 def test_abs_out_type(dtype):
     q = get_queue_or_skip()
@@ -111,15 +265,7 @@ def test_abs_complex(dtype):
 def _compare_dtypes(dt, ref_dt, sycl_queue=None):
     assert isinstance(sycl_queue, dpctl.SyclQueue)
     dev = sycl_queue.sycl_device
-    expected_dt = ref_dt
-    if not dev.has_aspect_fp64:
-        if expected_dt == dpt.float64:
-            expected_dt = dpt.float32
-        elif expected_dt == dpt.complex128:
-            expected_dt = dpt.complex64
-    if not dev.has_aspect_fp16:
-        if expected_dt == dpt.float16:
-            expected_dt = dpt.float32
+    expected_dt = _map_to_device_dtype(ref_dt, dev)
     return dt == expected_dt
 
 
@@ -224,22 +370,60 @@ def test_add_broadcasting():
     assert (dpt.asnumpy(r2) == np.arange(1, 6, dtype="i4")[np.newaxis, :]).all()
 
 
-def _map_to_device_dtype(dt, dev):
-    if np.issubdtype(dt, np.integer):
-        return dt
-    if np.issubdtype(dt, np.floating):
-        dtc = np.dtype(dt).char
-        if dtc == "d":
-            return dt if dev.has_aspect_fp64 else dpt.float32
-        elif dtc == "e":
-            return dt if dev.has_aspect_fp16 else dpt.float32
-        return dt
-    if np.issubdtype(dt, np.complexfloating):
-        dtc = np.dtype(dt).char
-        if dtc == "D":
-            return dt if dev.has_aspect_fp64 else dpt.complex64
-        return dt
-    return dt
+@pytest.mark.parametrize("arr_dt", _all_dtypes)
+def test_add_python_scalar(arr_dt):
+    q = get_queue_or_skip()
+    skip_if_dtype_not_supported(arr_dt, q)
+
+    X = dpt.zeros((10, 10), dtype=arr_dt, sycl_queue=q)
+    py_zeros = (
+        bool(0),
+        int(0),
+        float(0),
+        complex(0),
+        np.float32(0),
+        ctypes.c_int(0),
+    )
+    for sc in py_zeros:
+        R = dpt.add(X, sc)
+        assert isinstance(R, dpt.usm_ndarray)
+        R = dpt.add(sc, X)
+        assert isinstance(R, dpt.usm_ndarray)
+
+
+class MockArray:
+    def __init__(self, arr):
+        self.data_ = arr
+
+    @property
+    def __sycl_usm_array_interface__(self):
+        return self.data_.__sycl_usm_array_interface__
+
+
+def test_add_mock_array():
+    get_queue_or_skip()
+    a = dpt.arange(10)
+    b = dpt.ones(10)
+    c = MockArray(b)
+    r = dpt.add(a, c)
+    assert isinstance(r, dpt.usm_ndarray)
+
+
+def test_add_canary_mock_array():
+    get_queue_or_skip()
+    a = dpt.arange(10)
+
+    class Canary:
+        def __init__(self):
+            pass
+
+        @property
+        def __sycl_usm_array_interface__(self):
+            return None
+
+    c = Canary()
+    with pytest.raises(ValueError):
+        dpt.add(a, c)
 
 
 @pytest.mark.parametrize("dtype", _all_dtypes)