Move compute follows data utils

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)

dpnp/dpnp_utils/dpnp_algo_utils.pyx

@@ -36,13 +36,13 @@ This module contains different helpers and utilities
 """
 
 import dpctl
-import dpctl.utils as dpu
 import numpy
 
 import dpnp
 import dpnp.config as config
 import dpnp.dpnp_container as dpnp_container
 from dpnp.dpnp_array import dpnp_array
+from dpnp.tensor import get_coerced_usm_type, get_execution_queue
 
 cimport cpython
 cimport cython
@@ -153,7 +153,7 @@ def call_origin(function, *args, **kwargs):
         kwargx = convert_item(kwarg)
         kwargs_new[key] = kwargx
 
-    exec_q = dpu.get_execution_queue(alloc_queues)
+    exec_q = get_execution_queue(alloc_queues)
     if exec_q is None:
         exec_q = dpnp.get_normalized_queue_device(sycl_queue=sycl_queue)
     # print(f"DPNP call_origin(): backend called. \n\t function={function}, \n\t args_new={args_new}, \n\t kwargs_new={kwargs_new}, \n\t dpnp_inplace={dpnp_inplace}")
@@ -221,7 +221,7 @@ def _get_coerced_usm_type(objects):
     elif len(types_in_use) == 1:
         return types_in_use[0]
 
-    common_usm_type = dpu.get_coerced_usm_type(types_in_use)
+    common_usm_type = get_coerced_usm_type(types_in_use)
     if common_usm_type is None:
         raise ValueError("Input arrays must have coerced USM types")
     return common_usm_type
@@ -234,7 +234,7 @@ def _get_common_allocation_queue(objects):
     elif len(queues_in_use) == 1:
         return queues_in_use[0]
 
-    common_queue = dpu.get_execution_queue(queues_in_use)
+    common_queue = get_execution_queue(queues_in_use)
     if common_queue is None:
         raise ValueError("Input arrays must be allocated on the same SYCL queue")
     return common_queue
@@ -401,13 +401,13 @@ cdef tuple get_common_usm_allocation(dpnp_descriptor x1, dpnp_descriptor x2):
     array1_obj = x1.get_array()
     array2_obj = x2.get_array()
 
-    common_usm_type = dpctl.utils.get_coerced_usm_type((array1_obj.usm_type, array2_obj.usm_type))
+    common_usm_type = get_coerced_usm_type((array1_obj.usm_type, array2_obj.usm_type))
     if common_usm_type is None:
         raise ValueError(
             "could not recognize common USM type for inputs of USM types {} and {}"
             "".format(array1_obj.usm_type, array2_obj.usm_type))
 
-    common_sycl_queue = dpu.get_execution_queue((array1_obj.sycl_queue, array2_obj.sycl_queue))
+    common_sycl_queue = get_execution_queue((array1_obj.sycl_queue, array2_obj.sycl_queue))
     if common_sycl_queue is None:
         raise ValueError(
             "could not recognize common SYCL queue for inputs in SYCL queues {} and {}"

dpnp/dpnp_utils/dpnp_utils_einsum.py

@@ -31,13 +31,12 @@
 import operator
 import warnings
 
-import dpctl
 import numpy
-from dpctl.utils import ExecutionPlacementError
 
 import dpnp
 from dpnp.dpnp_array import dpnp_array
 from dpnp.dpnp_utils import get_usm_allocations, map_dtype_to_device
+from dpnp.tensor import ExecutionPlacementError
 
 _einsum_symbols = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 
@@ -1023,7 +1022,7 @@ def dpnp_einsum(
     res_usm_type, exec_q = get_usm_allocations(arrays)
     if out is not None:
         dpnp.check_supported_arrays_type(out)
-        if dpctl.utils.get_execution_queue((exec_q, out.sycl_queue)) is None:
+        if dpnp.tensor.get_execution_queue((exec_q, out.sycl_queue)) is None:
             raise ExecutionPlacementError(
                 "Input and output allocation queues are not compatible"
             )

dpnp/dpnp_utils/dpnp_utils_linearalgebra.py

@@ -28,7 +28,6 @@
 
 import dpctl.utils as dpu
 import numpy
-from dpctl.utils import ExecutionPlacementError
 
 import dpnp
 import dpnp.backend.extensions.blas._blas_impl as bi
@@ -694,8 +693,8 @@ def _validate_out_array(out, exec_q):
     """Validate out is supported array and has correct queue."""
     if out is not None:
         dpnp.check_supported_arrays_type(out)
-        if dpu.get_execution_queue((exec_q, out.sycl_queue)) is None:
-            raise ExecutionPlacementError(
+        if dpt.get_execution_queue((exec_q, out.sycl_queue)) is None:
+            raise dpt.ExecutionPlacementError(
                 "Input and output allocation queues are not compatible"
             )
 

dpnp/dpnp_utils/dpnp_utils_statistics.py

@@ -28,9 +28,6 @@
 
 import warnings
 
-import dpctl
-from dpctl.utils import ExecutionPlacementError
-
 import dpnp
 import dpnp.tensor as dpt
 from dpnp.dpnp_array import dpnp_array
@@ -67,9 +64,9 @@ def _calc_nanmedian(a, out=None):
         res = dpnp.empty_like(valid_counts, dtype=a.dtype)
     else:
         dpnp.check_supported_arrays_type(out)
-        exec_q = dpctl.utils.get_execution_queue((a.sycl_queue, out.sycl_queue))
+        exec_q = dpt.get_execution_queue((a.sycl_queue, out.sycl_queue))
         if exec_q is None:
-            raise ExecutionPlacementError(
+            raise dpt.ExecutionPlacementError(
                 "Input and output allocation queues are not compatible"
             )
         if out.shape != valid_counts.shape:

dpnp/exceptions/__init__.py

@@ -32,9 +32,9 @@
     SyclQueueCreationError,
 )
 from dpctl.memory import USMAllocationError
-from dpctl.utils import ExecutionPlacementError
 from numpy.exceptions import AxisError
 
+from dpnp.tensor import ExecutionPlacementError
 from dpnp.tensor._dlpack import DLPackCreationError
 
 __all__ = [