Move compute follows data utils (#2840)

This PR proposes to move the file `_compute_follows_data.pyx` from
`dpctl.utils` to `dpnp.tensor` as part of the migration of
`dpctl.tensor` to `dpnp.tensor`

### Changes
>- **Moved file**: `dpctl/utils/_compute_follows_data.pyx` →
`dpnp/tensor/_compute_follows_data.pyx`
>- **Exports** (now available from `dpnp.tensor`):
>>- `ExecutionPlacementError` - exception for execution placement errors
>>- `get_execution_queue()` - determine execution queue from input
arrays
>>- `get_coerced_usm_type()` - determine output USM type for
compute-follows-data
>>- `validate_usm_type()` - validate USM type specifications

Author: vlad-perevezentsev

dpnp/dpnp_algo/dpnp_arraycreation.py

@@ -29,7 +29,6 @@
 import math
 import operator
 
-import dpctl.utils as dpu
 import numpy
 
 import dpnp
@@ -340,7 +339,7 @@ class dpnp_nd_grid:
     def __init__(
         self, sparse=False, device=None, usm_type="device", sycl_queue=None
     ):
-        dpu.validate_usm_type(usm_type, allow_none=True)
+        dpt.validate_usm_type(usm_type, allow_none=True)
         self.sparse = sparse
         self.usm_type = "device" if usm_type is None else usm_type
         self.sycl_queue_normalized = dpnp.get_normalized_queue_device(

dpnp/dpnp_algo/dpnp_elementwise_common.py

@@ -451,7 +451,7 @@ def __call__(
                     f"Expected output shape is {x.shape}, got {res.shape}"
                 )
 
-            if dpu.get_execution_queue((exec_q, res.sycl_queue)) is None:
+            if dpt.get_execution_queue((exec_q, res.sycl_queue)) is None:
                 raise dpnp.exceptions.ExecutionPlacementError(
                     "Input and output allocation queues are not compatible"
                 )
@@ -1062,7 +1062,7 @@ def __call__(
                     f"Expected output shape is {res_shape}, got {res.shape}"
                 )
 
-            if dpu.get_execution_queue((exec_q, res.sycl_queue)) is None:
+            if dpt.get_execution_queue((exec_q, res.sycl_queue)) is None:
                 raise dpnp.exceptions.ExecutionPlacementError(
                     "Input and output allocation queues are not compatible"
                 )

dpnp/dpnp_algo/dpnp_fill.py

@@ -49,8 +49,8 @@ def dpnp_fill(arr, val):
         val = dpnp.get_usm_ndarray(val)
         if val.shape != ():
             raise ValueError("`val` must be a scalar or 0D-array")
-        if dpu.get_execution_queue((exec_q, val.sycl_queue)) is None:
-            raise dpu.ExecutionPlacementError(
+        if dpt.get_execution_queue((exec_q, val.sycl_queue)) is None:
+            raise dpt.ExecutionPlacementError(
                 "Input arrays have incompatible queues."
             )
         a_val = dpt.astype(val, arr.dtype)

dpnp/dpnp_container.py

@@ -35,8 +35,6 @@
 
 """
 
-import dpctl.utils as dpu
-
 import dpnp
 import dpnp.tensor as dpt
 from dpnp.dpnp_array import dpnp_array
@@ -67,7 +65,7 @@ def arange(
     sycl_queue=None,
 ):
     """Validate input parameters before passing them into `dpctl.tensor` module"""
-    dpu.validate_usm_type(usm_type, allow_none=False)
+    dpt.validate_usm_type(usm_type, allow_none=False)
     sycl_queue_normalized = dpnp.get_normalized_queue_device(
         sycl_queue=sycl_queue, device=device
     )
@@ -93,7 +91,7 @@ def asarray(
     sycl_queue=None,
 ):
     """Converts `x1` to `dpnp_array`."""
-    dpu.validate_usm_type(usm_type, allow_none=True)
+    dpt.validate_usm_type(usm_type, allow_none=True)
 
     if order is None:
         order = "K"
@@ -154,7 +152,7 @@ def empty(
     sycl_queue=None,
 ):
     """Validate input parameters before passing them into `dpctl.tensor` module"""
-    dpu.validate_usm_type(usm_type, allow_none=False)
+    dpt.validate_usm_type(usm_type, allow_none=False)
     sycl_queue_normalized = dpnp.get_normalized_queue_device(
         sycl_queue=sycl_queue, device=device
     )
@@ -185,7 +183,7 @@ def eye(
     sycl_queue=None,
 ):
     """Validate input parameters before passing them into `dpctl.tensor` module"""
-    dpu.validate_usm_type(usm_type, allow_none=False)
+    dpt.validate_usm_type(usm_type, allow_none=False)
     sycl_queue_normalized = dpnp.get_normalized_queue_device(
         sycl_queue=sycl_queue, device=device
     )
@@ -216,7 +214,7 @@ def full(
     sycl_queue=None,
 ):
     """Validate input parameters before passing them into `dpctl.tensor` module"""
-    dpu.validate_usm_type(usm_type, allow_none=True)
+    dpt.validate_usm_type(usm_type, allow_none=True)
 
     sycl_queue_normalized = dpnp.get_normalized_queue_device(
         fill_value, sycl_queue=sycl_queue, device=device
@@ -249,7 +247,7 @@ def ones(
     sycl_queue=None,
 ):
     """Validate input parameters before passing them into `dpctl.tensor` module"""
-    dpu.validate_usm_type(usm_type, allow_none=False)
+    dpt.validate_usm_type(usm_type, allow_none=False)
     sycl_queue_normalized = dpnp.get_normalized_queue_device(
         sycl_queue=sycl_queue, device=device
     )
@@ -289,7 +287,7 @@ def zeros(
     sycl_queue=None,
 ):
     """Validate input parameters before passing them into `dpctl.tensor` module"""
-    dpu.validate_usm_type(usm_type, allow_none=False)
+    dpt.validate_usm_type(usm_type, allow_none=False)
     sycl_queue_normalized = dpnp.get_normalized_queue_device(
         sycl_queue=sycl_queue, device=device
     )

dpnp/dpnp_iface.py

@@ -407,7 +407,7 @@ def get_dpnp_descriptor(
     if queue is not None and copy_when_nondefault_queue:
         default_queue = dpctl.SyclQueue()
         queue_is_default = (
-            dpctl.utils.get_execution_queue([queue, default_queue]) is not None
+            dpt.get_execution_queue([queue, default_queue]) is not None
         )
         if not queue_is_default:
             ext_obj = dpnp.array(ext_obj, sycl_queue=default_queue)

dpnp/dpnp_iface_histograms.py

@@ -53,6 +53,7 @@
     result_type_for_device,
     to_supported_dtypes,
 )
+from dpnp.tensor import get_coerced_usm_type, get_execution_queue
 
 # pylint: disable=no-name-in-module
 from .dpnp_utils import get_usm_allocations
@@ -87,10 +88,10 @@ def _ravel_check_a_and_weights(a, weights):
     if weights is not None:
         # check that `weights` array has supported type
         dpnp.check_supported_arrays_type(weights)
-        usm_type = dpu.get_coerced_usm_type([usm_type, weights.usm_type])
+        usm_type = get_coerced_usm_type([usm_type, weights.usm_type])
 
         # check that arrays have the same allocation queue
-        if dpu.get_execution_queue([a.sycl_queue, weights.sycl_queue]) is None:
+        if get_execution_queue([a.sycl_queue, weights.sycl_queue]) is None:
             raise ValueError(
                 "a and weights must be allocated on the same SYCL queue"
             )
@@ -173,7 +174,7 @@ def _get_bin_edges(a, bins, range, usm_type):
 
     elif numpy.ndim(bins) == 1:
         if dpnp.is_supported_array_type(bins):
-            if dpu.get_execution_queue([a.sycl_queue, bins.sycl_queue]) is None:
+            if get_execution_queue([a.sycl_queue, bins.sycl_queue]) is None:
                 raise ValueError(
                     "a and bins must be allocated on the same SYCL queue"
                 )

dpnp/dpnp_iface_indexing.py

@@ -130,8 +130,8 @@ def _choose_run(inds, chcs, q, usm_type, out=None, mode=0):
                 f"got {out.dtype}"
             )
 
-        if dpu.get_execution_queue((q, out.sycl_queue)) is None:
-            raise dpu.ExecutionPlacementError(
+        if dpt.get_execution_queue((q, out.sycl_queue)) is None:
+            raise dpt.ExecutionPlacementError(
                 "Input and output allocation queues are not compatible"
             )
 
@@ -292,8 +292,8 @@ def _take_index(x, inds, axis, q, usm_type, out=None, mode=0):
                 f"Output array of type {x.dtype} is needed, " f"got {out.dtype}"
             )
 
-        if dpu.get_execution_queue((q, out.sycl_queue)) is None:
-            raise dpu.ExecutionPlacementError(
+        if dpt.get_execution_queue((q, out.sycl_queue)) is None:
+            raise dpt.ExecutionPlacementError(
                 "Input and output allocation queues are not compatible"
             )
 

dpnp/dpnp_iface_logic.py

@@ -1261,12 +1261,12 @@ def isin(
         usm_element = dpnp.get_usm_ndarray(element)
     else:
         if (
-            dpu.get_execution_queue(
+            dpt.get_execution_queue(
                 (element.sycl_queue, test_elements.sycl_queue)
             )
             is None
         ):
-            raise dpu.ExecutionPlacementError(
+            raise dpt.ExecutionPlacementError(
                 "Input arrays have incompatible allocation queues"
             )
         usm_element = dpnp.get_usm_ndarray(element)

dpnp/dpnp_iface_mathematical.py

@@ -270,10 +270,10 @@ def _process_ediff1d_args(arg, arg_name, ary_dtype, ary_sycl_queue, usm_type):
     if not dpnp.is_supported_array_type(arg):
         arg = dpnp.asarray(arg, usm_type=usm_type, sycl_queue=ary_sycl_queue)
     else:
-        usm_type = dpu.get_coerced_usm_type([usm_type, arg.usm_type])
+        usm_type = dpt.get_coerced_usm_type([usm_type, arg.usm_type])
         # check that arrays have the same allocation queue
-        if dpu.get_execution_queue([ary_sycl_queue, arg.sycl_queue]) is None:
-            raise dpu.ExecutionPlacementError(
+        if dpt.get_execution_queue([ary_sycl_queue, arg.sycl_queue]) is None:
+            raise dpt.ExecutionPlacementError(
                 f"ary and {arg_name} must be allocated on the same SYCL queue"
             )
 
@@ -304,7 +304,7 @@ def _validate_interp_param(param, name, exec_q, usm_type, dtype=None):
                 f"a {name} value must be 0-dimensional, "
                 f"but got {param.ndim}-dim"
             )
-        if dpu.get_execution_queue([exec_q, param.sycl_queue]) is None:
+        if dpt.get_execution_queue([exec_q, param.sycl_queue]) is None:
             raise ValueError(
                 f"input arrays and {name} must be allocated "
                 "on the same SYCL queue"
@@ -2721,7 +2721,7 @@ def gradient(f, *varargs, axis=None, edge_order=1):
         if dpnp.isscalar(ax_dx):
             usm_type = f.usm_type
         else:
-            usm_type = dpu.get_coerced_usm_type([f.usm_type, ax_dx.usm_type])
+            usm_type = dpt.get_coerced_usm_type([f.usm_type, ax_dx.usm_type])
         out = dpnp.empty_like(f, dtype=otype, usm_type=usm_type)
 
         # spacing for the current axis

dpnp/dpnp_iface_statistics.py

@@ -670,7 +670,7 @@ def _run_native_sliding_dot_product1d(a, v, l_pad, r_pad, rdtype):
     a_casted = dpnp.asarray(a, dtype=supported_dtype, order="C")
     v_casted = dpnp.asarray(v, dtype=supported_dtype, order="C")
 
-    usm_type = dpu.get_coerced_usm_type([a_casted.usm_type, v_casted.usm_type])
+    usm_type = dpt.get_coerced_usm_type([a_casted.usm_type, v_casted.usm_type])
     out_size = l_pad + r_pad + a_casted.size - v_casted.size + 1
     # out type is the same as input type
     out = dpnp.empty_like(a_casted, shape=out_size, usm_type=usm_type)