diff --git a/dpnp/dpnp_algo/dpnp_arraycreation.py b/dpnp/dpnp_algo/dpnp_arraycreation.py index 66d8b9d9fbc8..df21ea5bbc44 100644 --- a/dpnp/dpnp_algo/dpnp_arraycreation.py +++ b/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( diff --git a/dpnp/dpnp_algo/dpnp_elementwise_common.py b/dpnp/dpnp_algo/dpnp_elementwise_common.py index 5902d389391f..4eb613db35a2 100644 --- a/dpnp/dpnp_algo/dpnp_elementwise_common.py +++ b/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" ) diff --git a/dpnp/dpnp_algo/dpnp_fill.py b/dpnp/dpnp_algo/dpnp_fill.py index 7afda62bb07f..03c47dea169c 100644 --- a/dpnp/dpnp_algo/dpnp_fill.py +++ b/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) diff --git a/dpnp/dpnp_container.py b/dpnp/dpnp_container.py index 14d9278579ba..374cc2c26f09 100644 --- a/dpnp/dpnp_container.py +++ b/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 ) diff --git a/dpnp/dpnp_iface.py b/dpnp/dpnp_iface.py index acca10a2211b..a9bf24bc56ea 100644 --- a/dpnp/dpnp_iface.py +++ b/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) diff --git a/dpnp/dpnp_iface_histograms.py b/dpnp/dpnp_iface_histograms.py index 8f3363e79fe0..944302d31205 100644 --- a/dpnp/dpnp_iface_histograms.py +++ b/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" ) diff --git a/dpnp/dpnp_iface_indexing.py b/dpnp/dpnp_iface_indexing.py index a24c8f56844a..26a0c826cf4a 100644 --- a/dpnp/dpnp_iface_indexing.py +++ b/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" ) diff --git a/dpnp/dpnp_iface_logic.py b/dpnp/dpnp_iface_logic.py index ce1d40774ca0..12014b4b5151 100644 --- a/dpnp/dpnp_iface_logic.py +++ b/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) diff --git a/dpnp/dpnp_iface_mathematical.py b/dpnp/dpnp_iface_mathematical.py index 22517d9cccca..e46bbe8f323d 100644 --- a/dpnp/dpnp_iface_mathematical.py +++ b/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 diff --git a/dpnp/dpnp_iface_statistics.py b/dpnp/dpnp_iface_statistics.py index 3d1f62ef716e..bf27fc98a4ce 100644 --- a/dpnp/dpnp_iface_statistics.py +++ b/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) diff --git a/dpnp/dpnp_utils/dpnp_algo_utils.pyx b/dpnp/dpnp_utils/dpnp_algo_utils.pyx index 938d9118545b..11737831f014 100644 --- a/dpnp/dpnp_utils/dpnp_algo_utils.pyx +++ b/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 {}" diff --git a/dpnp/dpnp_utils/dpnp_utils_einsum.py b/dpnp/dpnp_utils/dpnp_utils_einsum.py index 284268e2868b..81adaf4edc67 100644 --- a/dpnp/dpnp_utils/dpnp_utils_einsum.py +++ b/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" ) diff --git a/dpnp/dpnp_utils/dpnp_utils_linearalgebra.py b/dpnp/dpnp_utils/dpnp_utils_linearalgebra.py index 3ea0ec170bb3..316521b7b7fd 100644 --- a/dpnp/dpnp_utils/dpnp_utils_linearalgebra.py +++ b/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" ) diff --git a/dpnp/dpnp_utils/dpnp_utils_statistics.py b/dpnp/dpnp_utils/dpnp_utils_statistics.py index 6dd5d6433f82..3a773e29c9e1 100644 --- a/dpnp/dpnp_utils/dpnp_utils_statistics.py +++ b/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: diff --git a/dpnp/exceptions/__init__.py b/dpnp/exceptions/__init__.py index 7e5a55961d51..99587311cf0d 100644 --- a/dpnp/exceptions/__init__.py +++ b/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__ = [ diff --git a/dpnp/fft/dpnp_utils_fft.py b/dpnp/fft/dpnp_utils_fft.py index 074f0a66d7bc..7f232e23f426 100644 --- a/dpnp/fft/dpnp_utils_fft.py +++ b/dpnp/fft/dpnp_utils_fft.py @@ -41,14 +41,13 @@ from collections.abc import Sequence -import dpctl import dpctl.utils as dpu import numpy -from dpctl.utils import ExecutionPlacementError import dpnp import dpnp.backend.extensions.fft._fft_impl as fi import dpnp.tensor._tensor_impl as ti +from dpnp.tensor import ExecutionPlacementError, get_execution_queue from dpnp.tensor._numpy_helper import ( normalize_axis_index, normalize_axis_tuple, @@ -546,10 +545,7 @@ def _validate_out_keyword(a, out, s, axes, c2c, c2r, r2c): """Validate out keyword argument.""" if out is not None: dpnp.check_supported_arrays_type(out) - if ( - dpctl.utils.get_execution_queue((a.sycl_queue, out.sycl_queue)) - is None - ): + if get_execution_queue((a.sycl_queue, out.sycl_queue)) is None: raise ExecutionPlacementError( "Input and output allocation queues are not compatible" ) @@ -779,7 +775,7 @@ def dpnp_fillfreq(a, m, n, val): """Fill an array with the sample frequencies""" exec_q = a.sycl_queue - _manager = dpctl.utils.SequentialOrderManager[exec_q] + _manager = dpu.SequentialOrderManager[exec_q] # it's assumed there are no dependent events to populate the array ht_lin_ev, lin_ev = ti._linspace_step(0, 1, a[:m].get_array(), exec_q) diff --git a/dpnp/random/dpnp_random_state.py b/dpnp/random/dpnp_random_state.py index e49fe739aedd..e95434bcd410 100644 --- a/dpnp/random/dpnp_random_state.py +++ b/dpnp/random/dpnp_random_state.py @@ -36,7 +36,6 @@ """ -import dpctl.utils as dpu import numpy import dpnp @@ -46,6 +45,7 @@ use_origin_backend, ) from dpnp.random.dpnp_algo_random import MCG59, MT19937 +from dpnp.tensor import validate_usm_type class RandomState: @@ -269,7 +269,7 @@ def normal( f"scale={scale}, but must be non-negative." ) - dpu.validate_usm_type(usm_type, allow_none=False) + validate_usm_type(usm_type, allow_none=False) return self._random_state.normal( loc=loc, scale=scale, @@ -635,7 +635,7 @@ def uniform( dtype = self._validate_float_dtype( dtype, (dpnp.int32, dpnp.float32, dpnp.float64) ) - dpu.validate_usm_type(usm_type, allow_none=False) + validate_usm_type(usm_type, allow_none=False) return self._random_state.uniform( low=low, diff --git a/dpnp/tensor/__init__.py b/dpnp/tensor/__init__.py index 03980e194fd0..0118e04f7ab1 100644 --- a/dpnp/tensor/__init__.py +++ b/dpnp/tensor/__init__.py @@ -30,6 +30,12 @@ from ._accumulation import cumulative_logsumexp, cumulative_prod, cumulative_sum from ._array_api import __array_api_version__, __array_namespace_info__ from ._clip import clip +from ._compute_follows_data import ( + ExecutionPlacementError, + get_coerced_usm_type, + get_execution_queue, + validate_usm_type, +) from ._constants import e, inf, nan, newaxis, pi from ._copy_utils import ( asnumpy, @@ -411,4 +417,9 @@ "zeros_like", "__array_api_version__", "__array_namespace_info__", + # utilities + "ExecutionPlacementError", + "get_coerced_usm_type", + "get_execution_queue", + "validate_usm_type", ] diff --git a/dpnp/tensor/_accumulation.py b/dpnp/tensor/_accumulation.py index 305cf263514e..fa1326c3b18d 100644 --- a/dpnp/tensor/_accumulation.py +++ b/dpnp/tensor/_accumulation.py @@ -26,8 +26,7 @@ # THE POSSIBILITY OF SUCH DAMAGE. # ***************************************************************************** -import dpctl -from dpctl.utils import ExecutionPlacementError, SequentialOrderManager +from dpctl.utils import SequentialOrderManager import dpnp.tensor as dpt import dpnp.tensor._tensor_accumulation_impl as tai @@ -121,8 +120,8 @@ def _accumulate_common( raise ValueError( f"Output array of type {res_dt} is needed, " f"got {out.dtype}" ) - if dpctl.utils.get_execution_queue((q, out.sycl_queue)) is None: - raise ExecutionPlacementError( + if dpt.get_execution_queue((q, out.sycl_queue)) is None: + raise dpt.ExecutionPlacementError( "Input and output allocation queues are not compatible" ) # permute out array dims if necessary diff --git a/dpnp/tensor/_clip.py b/dpnp/tensor/_clip.py index 64020e88ce39..4ba2dcecb370 100644 --- a/dpnp/tensor/_clip.py +++ b/dpnp/tensor/_clip.py @@ -26,8 +26,7 @@ # THE POSSIBILITY OF SUCH DAMAGE. # ***************************************************************************** -import dpctl -from dpctl.utils import ExecutionPlacementError, SequentialOrderManager +from dpctl.utils import SequentialOrderManager import dpnp.tensor as dpt import dpnp.tensor._tensor_elementwise_impl as tei @@ -80,19 +79,19 @@ def _clip_none(x, val, out, order, _binary_fn): exec_q = q1 res_usm_type = x_usm_type else: - exec_q = dpctl.utils.get_execution_queue((q1, q2)) + exec_q = dpt.get_execution_queue((q1, q2)) if exec_q is None: - raise ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments." ) - res_usm_type = dpctl.utils.get_coerced_usm_type( + res_usm_type = dpt.get_coerced_usm_type( ( x_usm_type, val_usm_type, ) ) - dpctl.utils.validate_usm_type(res_usm_type, allow_none=False) + dpt.validate_usm_type(res_usm_type, allow_none=False) x_shape = x.shape val_shape = _get_shape(val) if not isinstance(val_shape, (tuple, list)): @@ -153,8 +152,8 @@ def _clip_none(x, val, out, order, _binary_fn): f"Output array of type {res_dt} is needed, got {out.dtype}" ) - if dpctl.utils.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" ) @@ -340,11 +339,8 @@ def clip(x, /, min=None, max=None, out=None, order="K"): f"got {out.dtype}" ) - if ( - dpctl.utils.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" ) @@ -388,46 +384,46 @@ def clip(x, /, min=None, max=None, out=None, order="K"): exec_q = q1 res_usm_type = x_usm_type elif q3 is None: - exec_q = dpctl.utils.get_execution_queue((q1, q2)) + exec_q = dpt.get_execution_queue((q1, q2)) if exec_q is None: - raise ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments." ) - res_usm_type = dpctl.utils.get_coerced_usm_type( + res_usm_type = dpt.get_coerced_usm_type( ( x_usm_type, min_usm_type, ) ) elif q2 is None: - exec_q = dpctl.utils.get_execution_queue((q1, q3)) + exec_q = dpt.get_execution_queue((q1, q3)) if exec_q is None: - raise ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments." ) - res_usm_type = dpctl.utils.get_coerced_usm_type( + res_usm_type = dpt.get_coerced_usm_type( ( x_usm_type, max_usm_type, ) ) else: - exec_q = dpctl.utils.get_execution_queue((q1, q2, q3)) + exec_q = dpt.get_execution_queue((q1, q2, q3)) if exec_q is None: - raise ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments." ) - res_usm_type = dpctl.utils.get_coerced_usm_type( + res_usm_type = dpt.get_coerced_usm_type( ( x_usm_type, min_usm_type, max_usm_type, ) ) - dpctl.utils.validate_usm_type(res_usm_type, allow_none=False) + dpt.validate_usm_type(res_usm_type, allow_none=False) x_shape = x.shape min_shape = _get_shape(min) max_shape = _get_shape(max) @@ -506,11 +502,8 @@ def clip(x, /, min=None, max=None, out=None, order="K"): f"got {out.dtype}" ) - if ( - dpctl.utils.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" ) diff --git a/dpnp/tensor/_compute_follows_data.pyx b/dpnp/tensor/_compute_follows_data.pyx new file mode 100644 index 000000000000..70e6bdfaeb79 --- /dev/null +++ b/dpnp/tensor/_compute_follows_data.pyx @@ -0,0 +1,191 @@ +# ***************************************************************************** +# Copyright (c) 2026, Intel Corporation +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are met: +# - Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# - Neither the name of the copyright holder nor the names of its contributors +# may be used to endorse or promote products derived from this software +# without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE +# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF +# THE POSSIBILITY OF SUCH DAMAGE. +# ***************************************************************************** + +# distutils: language = c++ +# cython: language_level=3 +# cython: linetrace=True + +"""Compute-follows-data utilities for execution queue and USM type management. + +This module provides utilities to determine execution placement and USM allocation +types when combining arrays under the compute-follows-data paradigm. +""" + + +import dpctl +from dpctl._sycl_queue cimport SyclQueue + +__all__ = [ + "get_execution_queue", "get_coerced_usm_type", "ExecutionPlacementError" +] + + +class ExecutionPlacementError(Exception): + """Exception raised when execution placement target can not + be unambiguously determined from input arrays. + + Make sure that input arrays are associated with the same + :class:`dpctl.SyclQueue`, + or migrate data to the same :class:`dpctl.SyclQueue` using + :meth:`dpctl.tensor.usm_ndarray.to_device` method. + """ + pass + + +cdef bint queue_equiv(SyclQueue q1, SyclQueue q2): + """Queues are equivalent if ``q1 == q2``, that is they are copies + of the same underlying SYCL object and hence are the same.""" + return q1.__eq__(q2) + + +def get_execution_queue(qs, /): + """ + Get execution queue from queues associated with input arrays. + + Args: + qs (List[:class:`dpctl.SyclQueue`], Tuple[:class:`dpctl.SyclQueue`]): + a list or a tuple of :class:`dpctl.SyclQueue` objects + corresponding to arrays that are being combined. + + Returns: + SyclQueue: + execution queue under compute follows data paradigm, + or ``None`` if queues are not equal. + """ + if not isinstance(qs, (list, tuple)): + raise TypeError( + "Expected a list or a tuple, got {}".format(type(qs)) + ) + if len(qs) == 0: + return None + elif len(qs) == 1: + return qs[0] if isinstance(qs[0], dpctl.SyclQueue) else None + for q1, q2 in zip(qs[:-1], qs[1:]): + if not isinstance(q1, dpctl.SyclQueue): + return None + elif not isinstance(q2, dpctl.SyclQueue): + return None + elif not queue_equiv( q1, q2): + return None + return qs[0] + + +def get_coerced_usm_type(usm_types, /): + """ + Get USM type of the output array for a function combining + arrays of given USM types using compute-follows-data execution + model. + + Args: + usm_types (List[str], Tuple[str]): + a list or a tuple of strings of ``.usm_types`` attributes + for input arrays + + Returns: + str + type of USM allocation for the output arrays (s). + ``None`` if any of the input strings are not recognized. + """ + if not isinstance(usm_types, (list, tuple)): + raise TypeError( + "Expected a list or a tuple, got {}".format(type(usm_types)) + ) + if len(usm_types) == 0: + return None + _k = ["device", "shared", "host"] + _m = {k: i for i, k in enumerate(_k)} + res = len(_k) + for t in usm_types: + if not isinstance(t, str): + return None + if t not in _m: + return None + res = min(res, _m[t]) + return _k[res] + + +def _validate_usm_type_allow_none(usm_type): + "Validates usm_type argument" + if usm_type is not None: + if isinstance(usm_type, str): + if usm_type not in ["device", "shared", "host"]: + raise ValueError( + f"Unrecognized value of usm_type={usm_type}, " + "expected 'device', 'shared', 'host', or None." + ) + else: + raise TypeError( + f"Expected usm_type to be a str or None, got {type(usm_type)}" + ) + + +def _validate_usm_type_disallow_none(usm_type): + "Validates usm_type argument" + if isinstance(usm_type, str): + if usm_type not in ["device", "shared", "host"]: + raise ValueError( + f"Unrecognized value of usm_type={usm_type}, " + "expected 'device', 'shared', or 'host'." + ) + else: + raise TypeError( + f"Expected usm_type to be a str, got {type(usm_type)}" + ) + + +def validate_usm_type(usm_type, /, *, allow_none=True): + """ validate_usm_type(usm_type, allow_none=True) + + Raises an exception if `usm_type` is invalid. + + Args: + usm_type: + Specification for USM allocation type. Valid specifications + are: + + * ``"device"`` + * ``"shared"`` + * ``"host"`` + + If ``allow_none`` keyword argument is set, a value of + ``None`` is also permitted. + allow_none (bool, optional): + Whether ``usm_type`` value of ``None`` is considered valid. + Default: `True`. + + Raises: + ValueError: + if ``usm_type`` is not a recognized string. + TypeError: + if ``usm_type`` is not a string, and ``usm_type`` is + not ``None`` provided ``allow_none`` is ``True``. + """ + if allow_none: + _validate_usm_type_allow_none(usm_type) + else: + _validate_usm_type_disallow_none(usm_type) diff --git a/dpnp/tensor/_copy_utils.py b/dpnp/tensor/_copy_utils.py index 9a16d4f59acd..ac1e9a9863a2 100644 --- a/dpnp/tensor/_copy_utils.py +++ b/dpnp/tensor/_copy_utils.py @@ -32,8 +32,8 @@ import dpctl import dpctl.memory as dpm -import dpctl.utils import numpy as np +from dpctl.utils import SequentialOrderManager import dpnp.tensor as dpt import dpnp.tensor._tensor_impl as ti @@ -124,7 +124,7 @@ def _copy_from_numpy_into(dst, np_ary): src_ary = src_ary.astype(np.float32) elif src_ary_dt_c == "D": src_ary = src_ary.astype(np.complex64) - _manager = dpctl.utils.SequentialOrderManager[copy_q] + _manager = SequentialOrderManager[copy_q] dep_ev = _manager.submitted_events # synchronizing call ti._copy_numpy_ndarray_into_usm_ndarray( @@ -142,14 +142,12 @@ def _extract_impl(ary, ary_mask, axis=0): f"Expecting type dpctl.tensor.usm_ndarray, got {type(ary)}" ) if isinstance(ary_mask, dpt.usm_ndarray): - dst_usm_type = dpctl.utils.get_coerced_usm_type( + dst_usm_type = dpt.get_coerced_usm_type( (ary.usm_type, ary_mask.usm_type) ) - exec_q = dpctl.utils.get_execution_queue( - (ary.sycl_queue, ary_mask.sycl_queue) - ) + exec_q = dpt.get_execution_queue((ary.sycl_queue, ary_mask.sycl_queue)) if exec_q is None: - raise dpctl.utils.ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "arrays have different associated queues. " "Use `y.to_device(x.device)` to migrate." ) @@ -175,7 +173,7 @@ def _extract_impl(ary, ary_mask, axis=0): cumsum_dt = dpt.int32 if mask_nelems < int32_t_max else dpt.int64 cumsum = dpt.empty(mask_nelems, dtype=cumsum_dt, device=ary_mask.device) exec_q = cumsum.sycl_queue - _manager = dpctl.utils.SequentialOrderManager[exec_q] + _manager = SequentialOrderManager[exec_q] dep_evs = _manager.submitted_events mask_count = ti.mask_positions( ary_mask, cumsum, sycl_queue=exec_q, depends=dep_evs @@ -230,8 +228,8 @@ def _get_indices_queue_usm_type(inds, queue, usm_type): raise TypeError( "at least one element of `inds` expected to be an array" ) - usm_type = dpctl.utils.get_coerced_usm_type(usm_types) - q = dpctl.utils.get_execution_queue(queues) + usm_type = dpt.get_coerced_usm_type(usm_types) + q = dpt.get_execution_queue(queues) return q, usm_type @@ -247,7 +245,7 @@ def _nonzero_impl(ary): cumsum = dpt.empty( mask_nelems, dtype=cumsum_dt, sycl_queue=exec_q, order="C" ) - _manager = dpctl.utils.SequentialOrderManager[exec_q] + _manager = SequentialOrderManager[exec_q] dep_evs = _manager.submitted_events mask_count = ti.mask_positions( ary, cumsum, sycl_queue=exec_q, depends=dep_evs @@ -318,20 +316,20 @@ def _place_impl(ary, ary_mask, vals, axis=0): f"Expecting type dpctl.tensor.usm_ndarray, got {type(ary)}" ) if isinstance(ary_mask, dpt.usm_ndarray): - exec_q = dpctl.utils.get_execution_queue( + exec_q = dpt.get_execution_queue( ( ary.sycl_queue, ary_mask.sycl_queue, ) ) - coerced_usm_type = dpctl.utils.get_coerced_usm_type( + coerced_usm_type = dpt.get_coerced_usm_type( ( ary.usm_type, ary_mask.usm_type, ) ) if exec_q is None: - raise dpctl.utils.ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "arrays have different associated queues. " "Use `y.to_device(x.device)` to migrate." ) @@ -355,15 +353,15 @@ def _place_impl(ary, ary_mask, vals, axis=0): sycl_queue=exec_q, ) else: - exec_q = dpctl.utils.get_execution_queue((exec_q, vals.sycl_queue)) - coerced_usm_type = dpctl.utils.get_coerced_usm_type( + exec_q = dpt.get_execution_queue((exec_q, vals.sycl_queue)) + coerced_usm_type = dpt.get_coerced_usm_type( ( coerced_usm_type, vals.usm_type, ) ) if exec_q is None: - raise dpctl.utils.ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "arrays have different associated queues. " "Use `Y.to_device(X.device)` to migrate." ) @@ -383,7 +381,7 @@ def _place_impl(ary, ary_mask, vals, axis=0): device=ary_mask.device, ) exec_q = cumsum.sycl_queue - _manager = dpctl.utils.SequentialOrderManager[exec_q] + _manager = SequentialOrderManager[exec_q] dep_ev = _manager.submitted_events mask_count = ti.mask_positions( ary_mask, cumsum, sycl_queue=exec_q, depends=dep_ev @@ -440,15 +438,15 @@ def _put_multi_index(ary, inds, p, vals, mode=0): sycl_queue=exec_q, ) else: - exec_q = dpctl.utils.get_execution_queue((exec_q, vals.sycl_queue)) - coerced_usm_type = dpctl.utils.get_coerced_usm_type( + exec_q = dpt.get_execution_queue((exec_q, vals.sycl_queue)) + coerced_usm_type = dpt.get_coerced_usm_type( ( coerced_usm_type, vals.usm_type, ) ) if exec_q is None: - raise dpctl.utils.ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Can not automatically determine where to allocate the " "result or performance execution. " "Use `usm_ndarray.to_device` method to migrate data to " @@ -470,7 +468,7 @@ def _put_multi_index(ary, inds, p, vals, mode=0): else: rhs = dpt.astype(vals, ary.dtype) rhs = dpt.broadcast_to(rhs, expected_vals_shape) - _manager = dpctl.utils.SequentialOrderManager[exec_q] + _manager = SequentialOrderManager[exec_q] dep_ev = _manager.submitted_events hev, put_ev = ti._put( dst=ary, @@ -504,7 +502,7 @@ def _take_multi_index(ary, inds, p, mode=0): inds, ary.sycl_queue, ary.usm_type ) if exec_q is None: - raise dpctl.utils.ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Can not automatically determine where to allocate the " "result or performance execution. " "Use `usm_ndarray.to_device` method to migrate data to " @@ -522,7 +520,7 @@ def _take_multi_index(ary, inds, p, mode=0): res = dpt.empty( res_shape, dtype=ary.dtype, usm_type=res_usm_type, sycl_queue=exec_q ) - _manager = dpctl.utils.SequentialOrderManager[exec_q] + _manager = SequentialOrderManager[exec_q] dep_ev = _manager.submitted_events hev, take_ev = ti._take( src=ary, @@ -630,7 +628,7 @@ def _copy_overlapping(dst, src): order="C", buffer_ctor_kwargs={"queue": q}, ) - _manager = dpctl.utils.SequentialOrderManager[q] + _manager = SequentialOrderManager[q] dep_evs = _manager.submitted_events hcp1, cp1 = ti._copy_usm_ndarray_into_usm_ndarray( src=src, dst=tmp, sycl_queue=q, depends=dep_evs @@ -655,7 +653,7 @@ def _copy_same_shape(dst, src): return copy_q = dst.sycl_queue - _manager = dpctl.utils.SequentialOrderManager[copy_q] + _manager = SequentialOrderManager[copy_q] dep_evs = _manager.submitted_events hev, cpy_ev = ti._copy_usm_ndarray_into_usm_ndarray( src=src, dst=dst, sycl_queue=copy_q, depends=dep_evs diff --git a/dpnp/tensor/_ctors.py b/dpnp/tensor/_ctors.py index c6e14db7398f..7e9a6202f12a 100644 --- a/dpnp/tensor/_ctors.py +++ b/dpnp/tensor/_ctors.py @@ -31,8 +31,8 @@ import dpctl import dpctl.memory as dpm -import dpctl.utils import numpy as np +from dpctl.utils import SequentialOrderManager import dpnp.tensor as dpt import dpnp.tensor._tensor_impl as ti @@ -164,8 +164,8 @@ def _asarray_from_seq( if usm_type is None: usm_types_in_seq = [] _usm_types_walker(seq_obj, usm_types_in_seq) - usm_type = dpctl.utils.get_coerced_usm_type(usm_types_in_seq) - dpctl.utils.validate_usm_type(usm_type) + usm_type = dpt.get_coerced_usm_type(usm_types_in_seq) + dpt.validate_usm_type(usm_type) if dtype is None: dtype = _map_to_device_dtype(seq_dt, alloc_q) else: @@ -186,7 +186,7 @@ def _asarray_from_seq( sycl_queue=alloc_q, order=order, ) - _manager = dpctl.utils.SequentialOrderManager[exec_q] + _manager = SequentialOrderManager[exec_q] _device_copy_walker(seq_obj, res, _manager) return res else: @@ -215,7 +215,7 @@ def _asarray_from_seq_single_device( exec_q = seq_dev alloc_q = seq_dev else: - exec_q = dpctl.utils.get_execution_queue( + exec_q = dpt.get_execution_queue( ( sycl_queue, seq_dev, @@ -249,9 +249,7 @@ def _asarray_from_usm_ndarray( if usm_type is None: usm_type = usm_ndary.usm_type if sycl_queue is not None: - exec_q = dpctl.utils.get_execution_queue( - [usm_ndary.sycl_queue, sycl_queue] - ) + exec_q = dpt.get_execution_queue([usm_ndary.sycl_queue, sycl_queue]) copy_q = normalize_queue_device(sycl_queue=sycl_queue, device=exec_q) else: copy_q = usm_ndary.sycl_queue @@ -300,9 +298,9 @@ def _asarray_from_usm_ndarray( order=order, buffer_ctor_kwargs={"queue": copy_q}, ) - eq = dpctl.utils.get_execution_queue([usm_ndary.sycl_queue, copy_q]) + eq = dpt.get_execution_queue([usm_ndary.sycl_queue, copy_q]) if eq is not None: - _manager = dpctl.utils.SequentialOrderManager[eq] + _manager = SequentialOrderManager[eq] dep_evs = _manager.submitted_events hev, cpy_ev = ti._copy_usm_ndarray_into_usm_ndarray( src=usm_ndary, dst=res, sycl_queue=eq, depends=dep_evs @@ -350,7 +348,7 @@ def _coerce_and_infer_dt(*args, dt, sycl_queue, err_msg, allow_bool=False): def _copy_through_host_walker(seq_o, usm_res): if isinstance(seq_o, dpt.usm_ndarray): if ( - dpctl.utils.get_execution_queue( + dpt.get_execution_queue( ( usm_res.sycl_queue, seq_o.sycl_queue, @@ -370,7 +368,7 @@ def _copy_through_host_walker(seq_o, usm_res): if hasattr(seq_o, "__sycl_usm_array_interface__"): usm_ar = _usm_ndarray_from_suai(seq_o) if ( - dpctl.utils.get_execution_queue( + dpt.get_execution_queue( ( usm_res.sycl_queue, usm_ar.sycl_queue, @@ -615,7 +613,7 @@ def arange( start = 0 if step is None: step = 1 - dpctl.utils.validate_usm_type(usm_type, allow_none=False) + dpt.validate_usm_type(usm_type, allow_none=False) sycl_queue = normalize_queue_device(sycl_queue=sycl_queue, device=device) is_bool = False if dtype: @@ -656,7 +654,7 @@ def arange( else: _step = sc_ty(1) _start = _first - _manager = dpctl.utils.SequentialOrderManager[sycl_queue] + _manager = SequentialOrderManager[sycl_queue] # populating newly allocated array, no task dependencies hev, lin_ev = ti._linspace_step(_start, _step, res, sycl_queue) _manager.add_event_pair(hev, lin_ev) @@ -752,7 +750,7 @@ def asarray( ) order = order[0].upper() # 4. Check that usm_type is None, or a valid value - dpctl.utils.validate_usm_type(usm_type, allow_none=True) + dpt.validate_usm_type(usm_type, allow_none=True) # 5. Normalize device/sycl_queue [keep it None if was None] if device is not None or sycl_queue is not None: sycl_queue = normalize_queue_device( @@ -846,7 +844,7 @@ def asarray( if len(devs) == 1: alloc_q = devs[0] else: - raise dpctl.utils.ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Please specify `device` or `sycl_queue` keyword " "argument to determine where to allocate the " "resulting array." @@ -929,7 +927,7 @@ def empty( "Unrecognized order keyword value, expecting 'F' or 'C'." ) order = order[0].upper() - dpctl.utils.validate_usm_type(usm_type, allow_none=False) + dpt.validate_usm_type(usm_type, allow_none=False) sycl_queue = normalize_queue_device(sycl_queue=sycl_queue, device=device) dtype = _get_dtype(dtype, sycl_queue) _ensure_native_dtype_device_support(dtype, sycl_queue.sycl_device) @@ -997,7 +995,7 @@ def empty_like( dtype = x.dtype if usm_type is None: usm_type = x.usm_type - dpctl.utils.validate_usm_type(usm_type, allow_none=False) + dpt.validate_usm_type(usm_type, allow_none=False) if device is None and sycl_queue is None: device = x.device sycl_queue = normalize_queue_device(sycl_queue=sycl_queue, device=device) @@ -1097,7 +1095,7 @@ def eye( usm_type=usm_type, sycl_queue=sycl_queue, ) - dpctl.utils.validate_usm_type(usm_type, allow_none=False) + dpt.validate_usm_type(usm_type, allow_none=False) sycl_queue = normalize_queue_device(sycl_queue=sycl_queue, device=device) dtype = _get_dtype(dtype, sycl_queue) _ensure_native_dtype_device_support(dtype, sycl_queue.sycl_device) @@ -1109,7 +1107,7 @@ def eye( buffer_ctor_kwargs={"queue": sycl_queue}, ) if n_rows != 0 and n_cols != 0: - _manager = dpctl.utils.SequentialOrderManager[sycl_queue] + _manager = SequentialOrderManager[sycl_queue] hev, eye_ev = ti._eye(k, dst=res, sycl_queue=sycl_queue) _manager.add_event_pair(hev, eye_ev) return res @@ -1178,7 +1176,7 @@ def full( "Unrecognized order keyword value, expecting 'F' or 'C'." ) order = order[0].upper() - dpctl.utils.validate_usm_type(usm_type, allow_none=True) + dpt.validate_usm_type(usm_type, allow_none=True) if isinstance(fill_value, (dpt.usm_ndarray, np.ndarray, tuple, list)): if ( @@ -1214,7 +1212,7 @@ def full( ) fill_value = _cast_fill_val(fill_value, dtype) - _manager = dpctl.utils.SequentialOrderManager[sycl_queue] + _manager = SequentialOrderManager[sycl_queue] # populating new allocation, no dependent events hev, full_ev = ti._full_usm_ndarray(fill_value, res, sycl_queue) _manager.add_event_pair(hev, full_ev) @@ -1288,7 +1286,7 @@ def full_like( dtype = x.dtype if usm_type is None: usm_type = x.usm_type - dpctl.utils.validate_usm_type(usm_type, allow_none=False) + dpt.validate_usm_type(usm_type, allow_none=False) if device is None and sycl_queue is None: device = x.device sycl_queue = normalize_queue_device(sycl_queue=sycl_queue, device=device) @@ -1307,7 +1305,7 @@ def full_like( ) X = dpt.broadcast_to(X, sh) res = _empty_like_orderK(x, dtype, usm_type, sycl_queue) - _manager = dpctl.utils.SequentialOrderManager[sycl_queue] + _manager = SequentialOrderManager[sycl_queue] # order copy after tasks populating X dep_evs = _manager.submitted_events hev, copy_ev = ti._copy_usm_ndarray_into_usm_ndarray( @@ -1321,7 +1319,7 @@ def full_like( dtype = _get_dtype(dtype, sycl_queue, ref_type=type(fill_value)) res = _empty_like_orderK(x, dtype, usm_type, sycl_queue) fill_value = _cast_fill_val(fill_value, dtype) - _manager = dpctl.utils.SequentialOrderManager[sycl_queue] + _manager = SequentialOrderManager[sycl_queue] # populating new allocation, no dependent events hev, full_ev = ti._full_usm_ndarray(fill_value, res, sycl_queue) _manager.add_event_pair(hev, full_ev) @@ -1405,7 +1403,7 @@ def linspace( interval. """ sycl_queue = normalize_queue_device(sycl_queue=sycl_queue, device=device) - dpctl.utils.validate_usm_type(usm_type, allow_none=False) + dpt.validate_usm_type(usm_type, allow_none=False) if endpoint not in [True, False]: raise TypeError("endpoint keyword argument must be of boolean type") @@ -1432,7 +1430,7 @@ def linspace( stop = float(stop) res = dpt.empty(num, dtype=dt, usm_type=usm_type, sycl_queue=sycl_queue) - _manager = dpctl.utils.SequentialOrderManager[sycl_queue] + _manager = SequentialOrderManager[sycl_queue] hev, la_ev = ti._linspace_affine( start, stop, dst=res, include_endpoint=endpoint, sycl_queue=sycl_queue ) @@ -1567,7 +1565,7 @@ def ones( "Unrecognized order keyword value, expecting 'F' or 'C'." ) order = order[0].upper() - dpctl.utils.validate_usm_type(usm_type, allow_none=False) + dpt.validate_usm_type(usm_type, allow_none=False) sycl_queue = normalize_queue_device(sycl_queue=sycl_queue, device=device) dtype = _get_dtype(dtype, sycl_queue) res = dpt.usm_ndarray( @@ -1577,7 +1575,7 @@ def ones( order=order, buffer_ctor_kwargs={"queue": sycl_queue}, ) - _manager = dpctl.utils.SequentialOrderManager[sycl_queue] + _manager = SequentialOrderManager[sycl_queue] # populating new allocation, no dependent events hev, full_ev = ti._full_usm_ndarray(1, res, sycl_queue) _manager.add_event_pair(hev, full_ev) @@ -1639,7 +1637,7 @@ def ones_like( dtype = x.dtype if usm_type is None: usm_type = x.usm_type - dpctl.utils.validate_usm_type(usm_type, allow_none=False) + dpt.validate_usm_type(usm_type, allow_none=False) if device is None and sycl_queue is None: device = x.device sycl_queue = normalize_queue_device(sycl_queue=sycl_queue, device=device) @@ -1648,7 +1646,7 @@ def ones_like( if order == "K": _ensure_native_dtype_device_support(dtype, sycl_queue.sycl_device) res = _empty_like_orderK(x, dtype, usm_type, sycl_queue) - _manager = dpctl.utils.SequentialOrderManager[sycl_queue] + _manager = SequentialOrderManager[sycl_queue] # populating new allocation, no dependent events hev, full_ev = ti._full_usm_ndarray(1, res, sycl_queue) _manager.add_event_pair(hev, full_ev) @@ -1711,7 +1709,7 @@ def tril(x, /, *, k=0): usm_type=x.usm_type, sycl_queue=q, ) - _manager = dpctl.utils.SequentialOrderManager[q] + _manager = SequentialOrderManager[q] dep_evs = _manager.submitted_events hev, cpy_ev = ti._copy_usm_ndarray_into_usm_ndarray( src=x, dst=res, sycl_queue=q, depends=dep_evs @@ -1733,7 +1731,7 @@ def tril(x, /, *, k=0): usm_type=x.usm_type, sycl_queue=q, ) - _manager = dpctl.utils.SequentialOrderManager[q] + _manager = SequentialOrderManager[q] dep_evs = _manager.submitted_events hev, tril_ev = ti._tril( src=x, dst=res, k=k, sycl_queue=q, depends=dep_evs @@ -1797,7 +1795,7 @@ def triu(x, /, *, k=0): usm_type=x.usm_type, sycl_queue=q, ) - _manager = dpctl.utils.SequentialOrderManager[q] + _manager = SequentialOrderManager[q] dep_evs = _manager.submitted_events hev, cpy_ev = ti._copy_usm_ndarray_into_usm_ndarray( src=x, dst=res, sycl_queue=q, depends=dep_evs @@ -1811,7 +1809,7 @@ def triu(x, /, *, k=0): usm_type=x.usm_type, sycl_queue=q, ) - _manager = dpctl.utils.SequentialOrderManager[q] + _manager = SequentialOrderManager[q] dep_evs = _manager.submitted_events hev, triu_ev = ti._triu( src=x, dst=res, k=k, sycl_queue=q, depends=dep_evs @@ -1871,7 +1869,7 @@ def zeros( "Unrecognized order keyword value, expecting 'F' or 'C'." ) order = order[0].upper() - dpctl.utils.validate_usm_type(usm_type, allow_none=False) + dpt.validate_usm_type(usm_type, allow_none=False) sycl_queue = normalize_queue_device(sycl_queue=sycl_queue, device=device) dtype = _get_dtype(dtype, sycl_queue) _ensure_native_dtype_device_support(dtype, sycl_queue.sycl_device) @@ -1882,7 +1880,7 @@ def zeros( order=order, buffer_ctor_kwargs={"queue": sycl_queue}, ) - _manager = dpctl.utils.SequentialOrderManager[sycl_queue] + _manager = SequentialOrderManager[sycl_queue] # populating new allocation, no dependent events hev, zeros_ev = ti._zeros_usm_ndarray(res, sycl_queue) _manager.add_event_pair(hev, zeros_ev) @@ -1947,7 +1945,7 @@ def zeros_like( dtype = x.dtype if usm_type is None: usm_type = x.usm_type - dpctl.utils.validate_usm_type(usm_type, allow_none=False) + dpt.validate_usm_type(usm_type, allow_none=False) if device is None and sycl_queue is None: device = x.device sycl_queue = normalize_queue_device(sycl_queue=sycl_queue, device=device) @@ -1956,7 +1954,7 @@ def zeros_like( if order == "K": _ensure_native_dtype_device_support(dtype, sycl_queue.sycl_device) res = _empty_like_orderK(x, dtype, usm_type, sycl_queue) - _manager = dpctl.utils.SequentialOrderManager[sycl_queue] + _manager = SequentialOrderManager[sycl_queue] # populating new allocation, no dependent events hev, full_ev = ti._full_usm_ndarray(0, res, sycl_queue) _manager.add_event_pair(hev, full_ev) diff --git a/dpnp/tensor/_device.py b/dpnp/tensor/_device.py index 8d763bc721e3..5f2725c74855 100644 --- a/dpnp/tensor/_device.py +++ b/dpnp/tensor/_device.py @@ -31,6 +31,8 @@ from dpctl._sycl_device_factory import _cached_default_device from dpctl._sycl_queue_manager import get_device_cached_queue +from ._compute_follows_data import get_execution_queue + __doc__ = "Implementation of array API mandated Device class" @@ -182,7 +184,7 @@ def normalize_queue_device(sycl_queue=None, device=None): if d is None: return q d = Device.create_device(d) - qq = dpctl.utils.get_execution_queue( + qq = get_execution_queue( ( q, d.sycl_queue, diff --git a/dpnp/tensor/_elementwise_common.py b/dpnp/tensor/_elementwise_common.py index d312d50a4a8f..e258df1b2e93 100644 --- a/dpnp/tensor/_elementwise_common.py +++ b/dpnp/tensor/_elementwise_common.py @@ -26,8 +26,7 @@ # THE POSSIBILITY OF SUCH DAMAGE. # ***************************************************************************** -import dpctl -from dpctl.utils import ExecutionPlacementError, SequentialOrderManager +from dpctl.utils import SequentialOrderManager import dpnp.tensor as dpt import dpnp.tensor._tensor_impl as ti @@ -232,11 +231,8 @@ def __call__(self, x, /, *, out=None, order="K"): # created, so the array overlap check isn't needed. out = dpt.empty_like(out) - if ( - dpctl.utils.get_execution_queue((x.sycl_queue, out.sycl_queue)) - is None - ): - raise ExecutionPlacementError( + if dpt.get_execution_queue((x.sycl_queue, out.sycl_queue)) is None: + raise dpt.ExecutionPlacementError( "Input and output allocation queues are not compatible" ) @@ -482,7 +478,7 @@ def __call__(self, o1, o2, /, *, out=None, 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 ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments. " "One of the arguments must represent USM allocation and " @@ -495,19 +491,19 @@ def __call__(self, o1, o2, /, *, out=None, order="K"): exec_q = q1 res_usm_type = o1_usm_type else: - exec_q = dpctl.utils.get_execution_queue((q1, q2)) + exec_q = dpt.get_execution_queue((q1, q2)) if exec_q is None: - raise ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments." ) - res_usm_type = dpctl.utils.get_coerced_usm_type( + res_usm_type = dpt.get_coerced_usm_type( ( o1_usm_type, o2_usm_type, ) ) - dpctl.utils.validate_usm_type(res_usm_type, allow_none=False) + dpt.validate_usm_type(res_usm_type, allow_none=False) o1_shape = _get_shape(o1) o2_shape = _get_shape(o2) if not all( @@ -583,11 +579,8 @@ def __call__(self, o1, o2, /, *, out=None, order="K"): f"got {out.dtype}" ) - if ( - dpctl.utils.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" ) @@ -876,19 +869,19 @@ def _inplace_op(self, o1, o2): exec_q = q1 res_usm_type = o1_usm_type else: - exec_q = dpctl.utils.get_execution_queue((q1, q2)) + exec_q = dpt.get_execution_queue((q1, q2)) if exec_q is None: - raise ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments." ) - res_usm_type = dpctl.utils.get_coerced_usm_type( + res_usm_type = dpt.get_coerced_usm_type( ( o1_usm_type, o2_usm_type, ) ) - dpctl.utils.validate_usm_type(res_usm_type, allow_none=False) + dpt.validate_usm_type(res_usm_type, allow_none=False) o1_shape = o1.shape o2_shape = _get_shape(o2) if not isinstance(o2_shape, (tuple, list)): diff --git a/dpnp/tensor/_indexing_functions.py b/dpnp/tensor/_indexing_functions.py index 8f097e59efc3..32162942d738 100644 --- a/dpnp/tensor/_indexing_functions.py +++ b/dpnp/tensor/_indexing_functions.py @@ -28,8 +28,7 @@ import operator -import dpctl -import dpctl.utils +from dpctl.utils import SequentialOrderManager import dpnp.tensor as dpt import dpnp.tensor._tensor_impl as ti @@ -91,14 +90,14 @@ def extract(condition, arr): raise TypeError( "Expecting dpctl.tensor.usm_ndarray type, " f"got {type(arr)}" ) - exec_q = dpctl.utils.get_execution_queue( + exec_q = dpt.get_execution_queue( ( condition.sycl_queue, arr.sycl_queue, ) ) if exec_q is None: - raise dpctl.utils.ExecutionPlacementError + raise dpt.ExecutionPlacementError if condition.shape != arr.shape: raise ValueError("Arrays are not of the same size") return _extract_impl(arr, condition) @@ -163,7 +162,7 @@ def place(arr, mask, vals): raise TypeError( "Expecting dpctl.tensor.usm_ndarray type, " f"got {type(vals)}" ) - exec_q = dpctl.utils.get_execution_queue( + exec_q = dpt.get_execution_queue( ( arr.sycl_queue, mask.sycl_queue, @@ -171,11 +170,11 @@ def place(arr, mask, vals): ) ) if exec_q is None: - raise dpctl.utils.ExecutionPlacementError + raise dpt.ExecutionPlacementError if arr.shape != mask.shape or vals.ndim != 1: raise ValueError("Array sizes are not as required") cumsum = dpt.empty(mask.size, dtype="i8", sycl_queue=exec_q) - _manager = dpctl.utils.SequentialOrderManager[exec_q] + _manager = SequentialOrderManager[exec_q] deps_ev = _manager.submitted_events nz_count = ti.mask_positions( mask, cumsum, sycl_queue=exec_q, depends=deps_ev @@ -297,10 +296,10 @@ def put_vec_duplicates(vec, ind, vals): indices.dtype ) ) - exec_q = dpctl.utils.get_execution_queue(queues_) + exec_q = dpt.get_execution_queue(queues_) if exec_q is None: - raise dpctl.utils.ExecutionPlacementError - vals_usm_type = dpctl.utils.get_coerced_usm_type(usm_types_) + raise dpt.ExecutionPlacementError + vals_usm_type = dpt.get_coerced_usm_type(usm_types_) mode = _get_indexing_mode(mode) @@ -340,7 +339,7 @@ def put_vec_duplicates(vec, ind, vals): rhs = dpt.astype(vals, x.dtype) rhs = dpt.broadcast_to(rhs, val_shape) - _manager = dpctl.utils.SequentialOrderManager[exec_q] + _manager = SequentialOrderManager[exec_q] deps_ev = _manager.submitted_events hev, put_ev = ti._put( x, (indices,), rhs, axis, mode, sycl_queue=exec_q, depends=deps_ev @@ -404,13 +403,13 @@ def put_along_axis(x, indices, vals, /, *, axis=-1, mode="wrap"): else: queues_ = [x.sycl_queue, indices.sycl_queue] usm_types_ = [x.usm_type, indices.usm_type] - exec_q = dpctl.utils.get_execution_queue(queues_) + exec_q = dpt.get_execution_queue(queues_) if exec_q is None: - raise dpctl.utils.ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments. " ) - out_usm_type = dpctl.utils.get_coerced_usm_type(usm_types_) + out_usm_type = dpt.get_coerced_usm_type(usm_types_) mode_i = _get_indexing_mode(mode) indexes_dt = ( dpt.uint64 @@ -482,12 +481,10 @@ def take(x, indices, /, *, axis=None, out=None, mode="wrap"): raise ValueError( "`indices` expected a 1D array, got `{}`".format(indices.ndim) ) - exec_q = dpctl.utils.get_execution_queue([x.sycl_queue, indices.sycl_queue]) + exec_q = dpt.get_execution_queue([x.sycl_queue, indices.sycl_queue]) if exec_q is None: - raise dpctl.utils.ExecutionPlacementError - res_usm_type = dpctl.utils.get_coerced_usm_type( - [x.usm_type, indices.usm_type] - ) + raise dpt.ExecutionPlacementError + res_usm_type = dpt.get_coerced_usm_type([x.usm_type, indices.usm_type]) mode = _get_indexing_mode(mode) @@ -532,8 +529,8 @@ def take(x, indices, /, *, axis=None, out=None, mode="wrap"): raise ValueError( f"Output array of type {dt} is needed, got {out.dtype}" ) - if dpctl.utils.get_execution_queue((exec_q, out.sycl_queue)) is None: - raise dpctl.utils.ExecutionPlacementError( + if dpt.get_execution_queue((exec_q, out.sycl_queue)) is None: + raise dpt.ExecutionPlacementError( "Input and output allocation queues are not compatible" ) if ti._array_overlap(x, out): @@ -543,7 +540,7 @@ def take(x, indices, /, *, axis=None, out=None, mode="wrap"): res_shape, dtype=dt, usm_type=res_usm_type, sycl_queue=exec_q ) - _manager = dpctl.utils.SequentialOrderManager[exec_q] + _manager = SequentialOrderManager[exec_q] deps_ev = _manager.submitted_events hev, take_ev = ti._take( x, (indices,), out, axis, mode, sycl_queue=exec_q, depends=deps_ev @@ -612,12 +609,10 @@ def take_along_axis(x, indices, /, *, axis=-1, mode="wrap"): "argument arrays must be equal" ) pp = normalize_axis_index(operator.index(axis), x_nd) - out_usm_type = dpctl.utils.get_coerced_usm_type( - (x.usm_type, indices.usm_type) - ) - exec_q = dpctl.utils.get_execution_queue((x.sycl_queue, indices.sycl_queue)) + out_usm_type = dpt.get_coerced_usm_type((x.usm_type, indices.usm_type)) + exec_q = dpt.get_execution_queue((x.sycl_queue, indices.sycl_queue)) if exec_q is None: - raise dpctl.utils.ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments. " ) diff --git a/dpnp/tensor/_linear_algebra_functions.py b/dpnp/tensor/_linear_algebra_functions.py index bec0522cd18f..ad64fd201eb0 100644 --- a/dpnp/tensor/_linear_algebra_functions.py +++ b/dpnp/tensor/_linear_algebra_functions.py @@ -28,8 +28,7 @@ import operator -import dpctl -from dpctl.utils import ExecutionPlacementError, SequentialOrderManager +from dpctl.utils import SequentialOrderManager import dpnp.tensor as dpt import dpnp.tensor._tensor_elementwise_impl as tei @@ -121,19 +120,19 @@ def tensordot(x1, x2, axes=2): raise TypeError(f"Expected dpctl.tensor.usm_ndarray, got {type(x2)}") q1, x1_usm_type = x1.sycl_queue, x1.usm_type q2, x2_usm_type = x2.sycl_queue, x2.usm_type - exec_q = dpctl.utils.get_execution_queue((q1, q2)) + exec_q = dpt.get_execution_queue((q1, q2)) if exec_q is None: - raise ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments." ) - res_usm_type = dpctl.utils.get_coerced_usm_type( + res_usm_type = dpt.get_coerced_usm_type( ( x1_usm_type, x2_usm_type, ) ) - dpctl.utils.validate_usm_type(res_usm_type, allow_none=False) + dpt.validate_usm_type(res_usm_type, allow_none=False) # handle axes and shapes validation x1_nd = x1.ndim x2_nd = x2.ndim @@ -357,19 +356,19 @@ def vecdot(x1, x2, axis=-1): raise TypeError(f"Expected dpctl.tensor.usm_ndarray, got {type(x2)}") q1, x1_usm_type = x1.sycl_queue, x1.usm_type q2, x2_usm_type = x2.sycl_queue, x2.usm_type - exec_q = dpctl.utils.get_execution_queue((q1, q2)) + exec_q = dpt.get_execution_queue((q1, q2)) if exec_q is None: - raise ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments." ) - res_usm_type = dpctl.utils.get_coerced_usm_type( + res_usm_type = dpt.get_coerced_usm_type( ( x1_usm_type, x2_usm_type, ) ) - dpctl.utils.validate_usm_type(res_usm_type, allow_none=False) + dpt.validate_usm_type(res_usm_type, allow_none=False) # axis and shape validation x1_nd = x1.ndim x2_nd = x2.ndim @@ -661,19 +660,19 @@ def matmul(x1, x2, out=None, dtype=None, order="K"): order = "K" q1, x1_usm_type = x1.sycl_queue, x1.usm_type q2, x2_usm_type = x2.sycl_queue, x2.usm_type - exec_q = dpctl.utils.get_execution_queue((q1, q2)) + exec_q = dpt.get_execution_queue((q1, q2)) if exec_q is None: - raise ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments." ) - res_usm_type = dpctl.utils.get_coerced_usm_type( + res_usm_type = dpt.get_coerced_usm_type( ( x1_usm_type, x2_usm_type, ) ) - dpctl.utils.validate_usm_type(res_usm_type, allow_none=False) + dpt.validate_usm_type(res_usm_type, allow_none=False) x1_nd = x1.ndim x2_nd = x2.ndim @@ -780,8 +779,8 @@ def matmul(x1, x2, out=None, dtype=None, order="K"): f"Output array of type {res_dt} is needed, got {out.dtype}" ) - if dpctl.utils.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" ) diff --git a/dpnp/tensor/_manipulation_functions.py b/dpnp/tensor/_manipulation_functions.py index 965bafda7948..7347f62de115 100644 --- a/dpnp/tensor/_manipulation_functions.py +++ b/dpnp/tensor/_manipulation_functions.py @@ -29,9 +29,8 @@ import itertools import operator -import dpctl -import dpctl.utils as dputils import numpy as np +from dpctl.utils import SequentialOrderManager import dpnp.tensor as dpt import dpnp.tensor._tensor_impl as ti @@ -57,11 +56,11 @@ def _arrays_validation(arrays, check_ndim=True): if not isinstance(X, dpt.usm_ndarray): raise TypeError(f"Expected usm_ndarray type, got {type(X)}.") - exec_q = dputils.get_execution_queue([X.sycl_queue for X in arrays]) + exec_q = dpt.get_execution_queue([X.sycl_queue for X in arrays]) if exec_q is None: raise ValueError("All the input arrays must have same sycl queue.") - res_usm_type = dputils.get_coerced_usm_type([X.usm_type for X in arrays]) + res_usm_type = dpt.get_coerced_usm_type([X.usm_type for X in arrays]) if res_usm_type is None: raise ValueError("All the input arrays must have usm_type.") @@ -176,7 +175,7 @@ def _concat_axis_None(arrays): ) fill_start = 0 - _manager = dputils.SequentialOrderManager[exec_q] + _manager = SequentialOrderManager[exec_q] deps = _manager.submitted_events for array in arrays: fill_end = fill_start + array.size @@ -335,7 +334,7 @@ def concat(arrays, /, *, axis=0): res_shape, dtype=res_dtype, usm_type=res_usm_type, sycl_queue=exec_q ) - _manager = dputils.SequentialOrderManager[exec_q] + _manager = SequentialOrderManager[exec_q] deps = _manager.submitted_events fill_start = 0 for i in range(n): @@ -584,21 +583,19 @@ def repeat(x, repeats, /, *, axis=None): "`repeats` array must be 0- or 1-dimensional, got " f"{repeats.ndim}" ) - exec_q = dpctl.utils.get_execution_queue( - (x.sycl_queue, repeats.sycl_queue) - ) + exec_q = dpt.get_execution_queue((x.sycl_queue, repeats.sycl_queue)) if exec_q is None: - raise dputils.ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments." ) - usm_type = dpctl.utils.get_coerced_usm_type( + usm_type = dpt.get_coerced_usm_type( ( x.usm_type, repeats.usm_type, ) ) - dpctl.utils.validate_usm_type(usm_type, allow_none=False) + dpt.validate_usm_type(usm_type, allow_none=False) if not dpt.can_cast(repeats.dtype, dpt.int64, casting="same_kind"): raise TypeError( f"'repeats' data type {repeats.dtype} cannot be cast to " @@ -651,7 +648,7 @@ def repeat(x, repeats, /, *, axis=None): f"got {type(repeats)}" ) - _manager = dputils.SequentialOrderManager[exec_q] + _manager = SequentialOrderManager[exec_q] dep_evs = _manager.submitted_events if scalar: res_axis_size = repeats * axis_size @@ -786,7 +783,7 @@ def roll(x, /, shift, *, axis=None): if not isinstance(x, dpt.usm_ndarray): raise TypeError(f"Expected usm_ndarray type, got {type(x)}.") exec_q = x.sycl_queue - _manager = dputils.SequentialOrderManager[exec_q] + _manager = SequentialOrderManager[exec_q] if axis is None: shift = operator.index(shift) res = dpt.empty( @@ -918,7 +915,7 @@ def stack(arrays, /, *, axis=0): res_shape, dtype=res_dtype, usm_type=res_usm_type, sycl_queue=exec_q ) - _manager = dputils.SequentialOrderManager[exec_q] + _manager = SequentialOrderManager[exec_q] dep_evs = _manager.submitted_events for i in range(n): c_shapes_copy = tuple( @@ -1088,7 +1085,7 @@ def tile(x, repetitions, /): broadcast_sh, ) # copy broadcast input into flat array - _manager = dputils.SequentialOrderManager[exec_q] + _manager = SequentialOrderManager[exec_q] dep_evs = _manager.submitted_events hev, cp_ev = ti._copy_usm_ndarray_for_reshape( src=x, dst=res, sycl_queue=exec_q, depends=dep_evs diff --git a/dpnp/tensor/_print.py b/dpnp/tensor/_print.py index c9325af9d312..51de51265907 100644 --- a/dpnp/tensor/_print.py +++ b/dpnp/tensor/_print.py @@ -31,8 +31,8 @@ import operator import dpctl -import dpctl.utils import numpy as np +from dpctl.utils import SequentialOrderManager import dpnp.tensor as dpt import dpnp.tensor._tensor_impl as ti @@ -286,7 +286,7 @@ def _nd_corners(arr_in, edge_items): else: blocks.append((np.s_[:],)) - _manager = dpctl.utils.SequentialOrderManager[exec_q] + _manager = SequentialOrderManager[exec_q] dep_evs = _manager.submitted_events hev_list = [] for slc in itertools.product(*blocks): diff --git a/dpnp/tensor/_reduction.py b/dpnp/tensor/_reduction.py index 82b75503e269..dfa77c63fe92 100644 --- a/dpnp/tensor/_reduction.py +++ b/dpnp/tensor/_reduction.py @@ -26,8 +26,7 @@ # THE POSSIBILITY OF SUCH DAMAGE. # ***************************************************************************** -import dpctl -from dpctl.utils import ExecutionPlacementError, SequentialOrderManager +from dpctl.utils import SequentialOrderManager import dpnp.tensor as dpt import dpnp.tensor._tensor_impl as ti @@ -88,8 +87,8 @@ def _comparison_over_axis(x, axis, keepdims, out, _reduction_fn): raise ValueError( f"Output array of type {res_dt} is needed, got {out.dtype}" ) - if dpctl.utils.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" ) if keepdims: @@ -204,8 +203,8 @@ def _reduction_over_axis( raise ValueError( f"Output array of type {res_dt} is needed, got {out.dtype}" ) - if dpctl.utils.get_execution_queue((q, out.sycl_queue)) is None: - raise ExecutionPlacementError( + if dpt.get_execution_queue((q, out.sycl_queue)) is None: + raise dpt.ExecutionPlacementError( "Input and output allocation queues are not compatible" ) if keepdims: @@ -351,8 +350,8 @@ def _search_over_axis(x, axis, keepdims, out, _reduction_fn): raise ValueError( f"Output array of type {res_dt} is needed, got {out.dtype}" ) - if dpctl.utils.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" ) if keepdims: diff --git a/dpnp/tensor/_reshape.py b/dpnp/tensor/_reshape.py index 6d817c5ccdf0..0187ae496003 100644 --- a/dpnp/tensor/_reshape.py +++ b/dpnp/tensor/_reshape.py @@ -28,8 +28,8 @@ import operator -import dpctl.utils import numpy as np +from dpctl.utils import SequentialOrderManager import dpnp.tensor as dpt @@ -179,7 +179,7 @@ def reshape(X, /, shape, *, order="C", copy=None): buffer=X.usm_type, buffer_ctor_kwargs={"queue": copy_q}, ) - _manager = dpctl.utils.SequentialOrderManager[copy_q] + _manager = SequentialOrderManager[copy_q] dep_evs = _manager.submitted_events if order == "C": hev, r_e = _copy_usm_ndarray_for_reshape( diff --git a/dpnp/tensor/_search_functions.py b/dpnp/tensor/_search_functions.py index 7e443351311a..339f2b2a4e3d 100644 --- a/dpnp/tensor/_search_functions.py +++ b/dpnp/tensor/_search_functions.py @@ -26,8 +26,7 @@ # THE POSSIBILITY OF SUCH DAMAGE. # ***************************************************************************** -import dpctl -from dpctl.utils import ExecutionPlacementError, SequentialOrderManager +from dpctl.utils import SequentialOrderManager import dpnp.tensor as dpt import dpnp.tensor._tensor_impl as ti @@ -174,46 +173,46 @@ def where(condition, x1, x2, /, *, order="K", out=None): exec_q = q1 out_usm_type = condition_usm_type elif q3 is None: - exec_q = dpctl.utils.get_execution_queue((q1, q2)) + exec_q = dpt.get_execution_queue((q1, q2)) if exec_q is None: - raise ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments." ) - out_usm_type = dpctl.utils.get_coerced_usm_type( + out_usm_type = dpt.get_coerced_usm_type( ( condition_usm_type, x1_usm_type, ) ) elif q2 is None: - exec_q = dpctl.utils.get_execution_queue((q1, q3)) + exec_q = dpt.get_execution_queue((q1, q3)) if exec_q is None: - raise ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments." ) - out_usm_type = dpctl.utils.get_coerced_usm_type( + out_usm_type = dpt.get_coerced_usm_type( ( condition_usm_type, x2_usm_type, ) ) else: - exec_q = dpctl.utils.get_execution_queue((q1, q2, q3)) + exec_q = dpt.get_execution_queue((q1, q2, q3)) if exec_q is None: - raise ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments." ) - out_usm_type = dpctl.utils.get_coerced_usm_type( + out_usm_type = dpt.get_coerced_usm_type( ( condition_usm_type, x1_usm_type, x2_usm_type, ) ) - dpctl.utils.validate_usm_type(out_usm_type, allow_none=False) + dpt.validate_usm_type(out_usm_type, allow_none=False) condition_shape = condition.shape x1_shape = _get_shape(x1) x2_shape = _get_shape(x2) @@ -280,8 +279,8 @@ def where(condition, x1, x2, /, *, order="K", out=None): f"got {out.dtype}" ) - if dpctl.utils.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" ) diff --git a/dpnp/tensor/_searchsorted.py b/dpnp/tensor/_searchsorted.py index 66a2df7ff375..0702e1711ef9 100644 --- a/dpnp/tensor/_searchsorted.py +++ b/dpnp/tensor/_searchsorted.py @@ -32,6 +32,11 @@ import dpctl import dpctl.utils as du +from ._compute_follows_data import ( + ExecutionPlacementError, + get_coerced_usm_type, + get_execution_queue, +) from ._copy_utils import _empty_like_orderK from ._ctors import empty from ._tensor_impl import _copy_usm_ndarray_into_usm_ndarray as ti_copy @@ -99,13 +104,13 @@ def searchsorted( ) if sorter is None: - q = du.get_execution_queue([x1.sycl_queue, x2.sycl_queue]) + q = get_execution_queue([x1.sycl_queue, x2.sycl_queue]) else: - q = du.get_execution_queue( + q = get_execution_queue( [x1.sycl_queue, x2.sycl_queue, sorter.sycl_queue] ) if q is None: - raise du.ExecutionPlacementError( + raise ExecutionPlacementError( "Execution placement can not be unambiguously " "inferred from input arguments." ) @@ -164,7 +169,7 @@ def searchsorted( _manager.add_event_pair(ht_ev, ev) x2 = x2_buf - dst_usm_type = du.get_coerced_usm_type([x1.usm_type, x2.usm_type]) + dst_usm_type = get_coerced_usm_type([x1.usm_type, x2.usm_type]) index_dt = ti_default_device_index_type(q) dst = _empty_like_orderK(x2, index_dt, usm_type=dst_usm_type) diff --git a/dpnp/tensor/_set_functions.py b/dpnp/tensor/_set_functions.py index e6131ddf7d2a..3b1a9b66d0da 100644 --- a/dpnp/tensor/_set_functions.py +++ b/dpnp/tensor/_set_functions.py @@ -683,7 +683,7 @@ def isin( q1, x_usm_type = _get_queue_usm_type(x) q2, test_usm_type = _get_queue_usm_type(test_elements) if q1 is None and q2 is None: - raise du.ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments. " "One of the arguments must represent USM allocation and " @@ -696,19 +696,19 @@ def isin( exec_q = q1 res_usm_type = x_usm_type else: - exec_q = du.get_execution_queue((q1, q2)) + exec_q = dpt.get_execution_queue((q1, q2)) if exec_q is None: - raise du.ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments." ) - res_usm_type = du.get_coerced_usm_type( + res_usm_type = dpt.get_coerced_usm_type( ( x_usm_type, test_usm_type, ) ) - du.validate_usm_type(res_usm_type, allow_none=False) + dpt.validate_usm_type(res_usm_type, allow_none=False) sycl_dev = exec_q.sycl_device if not isinstance(invert, bool): diff --git a/dpnp/tensor/_testing.py b/dpnp/tensor/_testing.py index ec1f0c47be60..33b1b30980a3 100644 --- a/dpnp/tensor/_testing.py +++ b/dpnp/tensor/_testing.py @@ -26,7 +26,6 @@ # THE POSSIBILITY OF SUCH DAMAGE. # ***************************************************************************** -import dpctl.utils as du import numpy as np import dpnp.tensor as dpt @@ -135,9 +134,9 @@ def allclose(a1, a2, atol=1e-8, rtol=1e-5, equal_nan=False): "Absolute and relative tolerances must be non-negative" ) equal_nan = bool(equal_nan) - exec_q = du.get_execution_queue(tuple(a.sycl_queue for a in (a1, a2))) + exec_q = dpt.get_execution_queue(tuple(a.sycl_queue for a in (a1, a2))) if exec_q is None: - raise du.ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments." ) diff --git a/dpnp/tensor/_utility_functions.py b/dpnp/tensor/_utility_functions.py index 644c2ce9911f..a02f7406d135 100644 --- a/dpnp/tensor/_utility_functions.py +++ b/dpnp/tensor/_utility_functions.py @@ -206,46 +206,46 @@ def _concat_diff_input(arr, axis, prepend, append): exec_q = q1 coerced_usm_type = x_usm_type elif q3 is None: - exec_q = du.get_execution_queue((q1, q2)) + exec_q = dpt.get_execution_queue((q1, q2)) if exec_q is None: - raise du.ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments." ) - coerced_usm_type = du.get_coerced_usm_type( + coerced_usm_type = dpt.get_coerced_usm_type( ( x_usm_type, prepend_usm_type, ) ) elif q2 is None: - exec_q = du.get_execution_queue((q1, q3)) + exec_q = dpt.get_execution_queue((q1, q3)) if exec_q is None: - raise du.ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments." ) - coerced_usm_type = du.get_coerced_usm_type( + coerced_usm_type = dpt.get_coerced_usm_type( ( x_usm_type, append_usm_type, ) ) else: - exec_q = du.get_execution_queue((q1, q2, q3)) + exec_q = dpt.get_execution_queue((q1, q2, q3)) if exec_q is None: - raise du.ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments." ) - coerced_usm_type = du.get_coerced_usm_type( + coerced_usm_type = dpt.get_coerced_usm_type( ( x_usm_type, prepend_usm_type, append_usm_type, ) ) - du.validate_usm_type(coerced_usm_type, allow_none=False) + dpt.validate_usm_type(coerced_usm_type, allow_none=False) arr_shape = arr.shape prepend_shape = _get_shape(prepend) append_shape = _get_shape(append) @@ -318,19 +318,19 @@ def _concat_diff_input(arr, axis, prepend, append): exec_q = q1 coerced_usm_type = x_usm_type else: - exec_q = du.get_execution_queue((q1, q2)) + exec_q = dpt.get_execution_queue((q1, q2)) if exec_q is None: - raise du.ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments." ) - coerced_usm_type = du.get_coerced_usm_type( + coerced_usm_type = dpt.get_coerced_usm_type( ( x_usm_type, prepend_usm_type, ) ) - du.validate_usm_type(coerced_usm_type, allow_none=False) + dpt.validate_usm_type(coerced_usm_type, allow_none=False) arr_shape = arr.shape prepend_shape = _get_shape(prepend) if not isinstance(prepend_shape, (tuple, list)): @@ -375,19 +375,19 @@ def _concat_diff_input(arr, axis, prepend, append): exec_q = q1 coerced_usm_type = x_usm_type else: - exec_q = du.get_execution_queue((q1, q2)) + exec_q = dpt.get_execution_queue((q1, q2)) if exec_q is None: - raise du.ExecutionPlacementError( + raise dpt.ExecutionPlacementError( "Execution placement can not be unambiguously inferred " "from input arguments." ) - coerced_usm_type = du.get_coerced_usm_type( + coerced_usm_type = dpt.get_coerced_usm_type( ( x_usm_type, append_usm_type, ) ) - du.validate_usm_type(coerced_usm_type, allow_none=False) + dpt.validate_usm_type(coerced_usm_type, allow_none=False) arr_shape = arr.shape append_shape = _get_shape(append) if not isinstance(append_shape, (tuple, list)): diff --git a/dpnp/tests/tensor/elementwise/test_add.py b/dpnp/tests/tensor/elementwise/test_add.py index 0320ec642a66..28a4efb21e94 100644 --- a/dpnp/tests/tensor/elementwise/test_add.py +++ b/dpnp/tests/tensor/elementwise/test_add.py @@ -32,7 +32,6 @@ import dpctl import numpy as np import pytest -from dpctl.utils import ExecutionPlacementError import dpnp.tensor as dpt from dpnp.tensor._type_utils import _can_cast @@ -101,9 +100,7 @@ def test_add_usm_type_matrix(op1_usm_type, op2_usm_type): r = dpt.add(ar1, ar2) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( - (op1_usm_type, op2_usm_type) - ) + expected_usm_type = dpt.get_coerced_usm_type((op1_usm_type, op2_usm_type)) assert r.usm_type == expected_usm_type @@ -299,7 +296,7 @@ def test_add_errors(): ar1 = dpt.ones(2, dtype="float32", sycl_queue=gpu_queue) ar2 = dpt.ones_like(ar1, sycl_queue=gpu_queue) y = dpt.empty_like(ar1, sycl_queue=cpu_queue) - with pytest.raises(ExecutionPlacementError) as excinfo: + with pytest.raises(dpt.ExecutionPlacementError) as excinfo: dpt.add(ar1, ar2, out=y) assert "Input and output allocation queues are not compatible" in str( excinfo.value @@ -316,7 +313,7 @@ def test_add_errors(): ar1 = np.ones(2, dtype="float32") ar2 = np.ones_like(ar1, dtype="int32") - with pytest.raises(ExecutionPlacementError) as excinfo: + with pytest.raises(dpt.ExecutionPlacementError) as excinfo: dpt.add(ar1, ar2) assert re.match( "Execution placement can not be unambiguously inferred.*", @@ -484,7 +481,7 @@ def test_add_inplace_errors(): ar1 = dpt.ones(2, dtype="float32", sycl_queue=gpu_queue) ar2 = dpt.ones_like(ar1, sycl_queue=cpu_queue) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.add(ar1, ar2, out=ar1) ar1 = dpt.ones(2, dtype="float32") @@ -522,7 +519,7 @@ def test_add_inplace_operator_errors(): x_q1 = dpt.ones(10, dtype="i4", sycl_queue=q1) x_q2 = dpt.ones(10, dtype="i4", sycl_queue=q2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.add._inplace_op(x_q1, x_q2) @@ -564,10 +561,10 @@ def test_add_cfd(): x1 = dpt.ones(10, sycl_queue=q1) x2 = dpt.ones(10, sycl_queue=q2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.add(x1, x2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.add(x1, x1, out=x2) diff --git a/dpnp/tests/tensor/elementwise/test_divide.py b/dpnp/tests/tensor/elementwise/test_divide.py index e39436394f7d..99de5a51214d 100644 --- a/dpnp/tests/tensor/elementwise/test_divide.py +++ b/dpnp/tests/tensor/elementwise/test_divide.py @@ -95,9 +95,7 @@ def test_divide_usm_type_matrix(op1_usm_type, op2_usm_type): r = dpt.divide(ar1, ar2) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( - (op1_usm_type, op2_usm_type) - ) + expected_usm_type = dpt.get_coerced_usm_type((op1_usm_type, op2_usm_type)) assert r.usm_type == expected_usm_type diff --git a/dpnp/tests/tensor/elementwise/test_equal.py b/dpnp/tests/tensor/elementwise/test_equal.py index 2791d600f7a3..f5e0cd520762 100644 --- a/dpnp/tests/tensor/elementwise/test_equal.py +++ b/dpnp/tests/tensor/elementwise/test_equal.py @@ -90,9 +90,7 @@ def test_equal_usm_type_matrix(op1_usm_type, op2_usm_type): r = dpt.equal(ar1, ar2) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( - (op1_usm_type, op2_usm_type) - ) + expected_usm_type = dpt.get_coerced_usm_type((op1_usm_type, op2_usm_type)) assert r.usm_type == expected_usm_type diff --git a/dpnp/tests/tensor/elementwise/test_floor_divide.py b/dpnp/tests/tensor/elementwise/test_floor_divide.py index 6a18575722b5..5762b09afdb3 100644 --- a/dpnp/tests/tensor/elementwise/test_floor_divide.py +++ b/dpnp/tests/tensor/elementwise/test_floor_divide.py @@ -92,9 +92,7 @@ def test_floor_divide_usm_type_matrix(op1_usm_type, op2_usm_type): r = dpt.floor_divide(ar1, ar2) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( - (op1_usm_type, op2_usm_type) - ) + expected_usm_type = dpt.get_coerced_usm_type((op1_usm_type, op2_usm_type)) assert r.usm_type == expected_usm_type diff --git a/dpnp/tests/tensor/elementwise/test_greater.py b/dpnp/tests/tensor/elementwise/test_greater.py index 7234bd03d86a..eb5f2b3929df 100644 --- a/dpnp/tests/tensor/elementwise/test_greater.py +++ b/dpnp/tests/tensor/elementwise/test_greater.py @@ -166,9 +166,7 @@ def test_greater_usm_type_matrix(op1_usm_type, op2_usm_type): r = dpt.greater(ar1, ar2) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( - (op1_usm_type, op2_usm_type) - ) + expected_usm_type = dpt.get_coerced_usm_type((op1_usm_type, op2_usm_type)) assert r.usm_type == expected_usm_type diff --git a/dpnp/tests/tensor/elementwise/test_greater_equal.py b/dpnp/tests/tensor/elementwise/test_greater_equal.py index 888dfbd342b7..f2e97bf62189 100644 --- a/dpnp/tests/tensor/elementwise/test_greater_equal.py +++ b/dpnp/tests/tensor/elementwise/test_greater_equal.py @@ -164,9 +164,7 @@ def test_greater_equal_usm_type_matrix(op1_usm_type, op2_usm_type): r = dpt.greater_equal(ar1, ar2) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( - (op1_usm_type, op2_usm_type) - ) + expected_usm_type = dpt.get_coerced_usm_type((op1_usm_type, op2_usm_type)) assert r.usm_type == expected_usm_type diff --git a/dpnp/tests/tensor/elementwise/test_hypot.py b/dpnp/tests/tensor/elementwise/test_hypot.py index 7cebaf3bf6ab..bc87736318ee 100644 --- a/dpnp/tests/tensor/elementwise/test_hypot.py +++ b/dpnp/tests/tensor/elementwise/test_hypot.py @@ -90,9 +90,7 @@ def test_hypot_usm_type_matrix(op1_usm_type, op2_usm_type): r = dpt.hypot(ar1, ar2) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( - (op1_usm_type, op2_usm_type) - ) + expected_usm_type = dpt.get_coerced_usm_type((op1_usm_type, op2_usm_type)) assert r.usm_type == expected_usm_type diff --git a/dpnp/tests/tensor/elementwise/test_less.py b/dpnp/tests/tensor/elementwise/test_less.py index 65fb9c2d9a84..0abf1e440643 100644 --- a/dpnp/tests/tensor/elementwise/test_less.py +++ b/dpnp/tests/tensor/elementwise/test_less.py @@ -166,9 +166,7 @@ def test_less_usm_type_matrix(op1_usm_type, op2_usm_type): r = dpt.less(ar1, ar2) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( - (op1_usm_type, op2_usm_type) - ) + expected_usm_type = dpt.get_coerced_usm_type((op1_usm_type, op2_usm_type)) assert r.usm_type == expected_usm_type diff --git a/dpnp/tests/tensor/elementwise/test_less_equal.py b/dpnp/tests/tensor/elementwise/test_less_equal.py index b3f9d3b42a69..1a5744475210 100644 --- a/dpnp/tests/tensor/elementwise/test_less_equal.py +++ b/dpnp/tests/tensor/elementwise/test_less_equal.py @@ -165,9 +165,7 @@ def test_less_equal_usm_type_matrix(op1_usm_type, op2_usm_type): r = dpt.less_equal(ar1, ar2) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( - (op1_usm_type, op2_usm_type) - ) + expected_usm_type = dpt.get_coerced_usm_type((op1_usm_type, op2_usm_type)) assert r.usm_type == expected_usm_type diff --git a/dpnp/tests/tensor/elementwise/test_logaddexp.py b/dpnp/tests/tensor/elementwise/test_logaddexp.py index a1502f4c3d11..fc16c1722d98 100644 --- a/dpnp/tests/tensor/elementwise/test_logaddexp.py +++ b/dpnp/tests/tensor/elementwise/test_logaddexp.py @@ -95,9 +95,7 @@ def test_logaddexp_usm_type_matrix(op1_usm_type, op2_usm_type): r = dpt.logaddexp(ar1, ar2) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( - (op1_usm_type, op2_usm_type) - ) + expected_usm_type = dpt.get_coerced_usm_type((op1_usm_type, op2_usm_type)) assert r.usm_type == expected_usm_type diff --git a/dpnp/tests/tensor/elementwise/test_logical_and.py b/dpnp/tests/tensor/elementwise/test_logical_and.py index 064c295812b1..09f5838265af 100644 --- a/dpnp/tests/tensor/elementwise/test_logical_and.py +++ b/dpnp/tests/tensor/elementwise/test_logical_and.py @@ -193,9 +193,7 @@ def test_logical_and_usm_type_matrix(op1_usm_type, op2_usm_type): r = dpt.logical_and(ar1, ar2) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( - (op1_usm_type, op2_usm_type) - ) + expected_usm_type = dpt.get_coerced_usm_type((op1_usm_type, op2_usm_type)) assert r.usm_type == expected_usm_type diff --git a/dpnp/tests/tensor/elementwise/test_logical_or.py b/dpnp/tests/tensor/elementwise/test_logical_or.py index 6987183e37a7..42c7e6f645b3 100644 --- a/dpnp/tests/tensor/elementwise/test_logical_or.py +++ b/dpnp/tests/tensor/elementwise/test_logical_or.py @@ -194,9 +194,7 @@ def test_logical_or_usm_type_matrix(op1_usm_type, op2_usm_type): r = dpt.logical_or(ar1, ar2) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( - (op1_usm_type, op2_usm_type) - ) + expected_usm_type = dpt.get_coerced_usm_type((op1_usm_type, op2_usm_type)) assert r.usm_type == expected_usm_type diff --git a/dpnp/tests/tensor/elementwise/test_logical_xor.py b/dpnp/tests/tensor/elementwise/test_logical_xor.py index 043c704bcf4b..da2b79974f12 100644 --- a/dpnp/tests/tensor/elementwise/test_logical_xor.py +++ b/dpnp/tests/tensor/elementwise/test_logical_xor.py @@ -195,9 +195,7 @@ def test_logical_xor_usm_type_matrix(op1_usm_type, op2_usm_type): r = dpt.logical_xor(ar1, ar2) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( - (op1_usm_type, op2_usm_type) - ) + expected_usm_type = dpt.get_coerced_usm_type((op1_usm_type, op2_usm_type)) assert r.usm_type == expected_usm_type diff --git a/dpnp/tests/tensor/elementwise/test_maximum_minimum.py b/dpnp/tests/tensor/elementwise/test_maximum_minimum.py index 7e0bce95baf9..2eb6d9de7582 100644 --- a/dpnp/tests/tensor/elementwise/test_maximum_minimum.py +++ b/dpnp/tests/tensor/elementwise/test_maximum_minimum.py @@ -208,16 +208,12 @@ def test_maximum_minimum_usm_type_matrix(op1_usm_type, op2_usm_type): r = dpt.maximum(ar1, ar2) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( - (op1_usm_type, op2_usm_type) - ) + expected_usm_type = dpt.get_coerced_usm_type((op1_usm_type, op2_usm_type)) assert r.usm_type == expected_usm_type r = dpt.minimum(ar1, ar2) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( - (op1_usm_type, op2_usm_type) - ) + expected_usm_type = dpt.get_coerced_usm_type((op1_usm_type, op2_usm_type)) assert r.usm_type == expected_usm_type diff --git a/dpnp/tests/tensor/elementwise/test_multiply.py b/dpnp/tests/tensor/elementwise/test_multiply.py index df0defc7cfc6..33dbef03f347 100644 --- a/dpnp/tests/tensor/elementwise/test_multiply.py +++ b/dpnp/tests/tensor/elementwise/test_multiply.py @@ -91,9 +91,7 @@ def test_multiply_usm_type_matrix(op1_usm_type, op2_usm_type): r = dpt.multiply(ar1, ar2) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( - (op1_usm_type, op2_usm_type) - ) + expected_usm_type = dpt.get_coerced_usm_type((op1_usm_type, op2_usm_type)) assert r.usm_type == expected_usm_type diff --git a/dpnp/tests/tensor/elementwise/test_not_equal.py b/dpnp/tests/tensor/elementwise/test_not_equal.py index 718105d2689b..3f0eb58cf8b7 100644 --- a/dpnp/tests/tensor/elementwise/test_not_equal.py +++ b/dpnp/tests/tensor/elementwise/test_not_equal.py @@ -90,9 +90,7 @@ def test_not_equal_usm_type_matrix(op1_usm_type, op2_usm_type): r = dpt.not_equal(ar1, ar2) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( - (op1_usm_type, op2_usm_type) - ) + expected_usm_type = dpt.get_coerced_usm_type((op1_usm_type, op2_usm_type)) assert r.usm_type == expected_usm_type diff --git a/dpnp/tests/tensor/elementwise/test_pow.py b/dpnp/tests/tensor/elementwise/test_pow.py index 17d54058c320..c68e6ad13b0a 100644 --- a/dpnp/tests/tensor/elementwise/test_pow.py +++ b/dpnp/tests/tensor/elementwise/test_pow.py @@ -91,9 +91,7 @@ def test_power_usm_type_matrix(op1_usm_type, op2_usm_type): r = dpt.pow(ar1, ar2) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( - (op1_usm_type, op2_usm_type) - ) + expected_usm_type = dpt.get_coerced_usm_type((op1_usm_type, op2_usm_type)) assert r.usm_type == expected_usm_type diff --git a/dpnp/tests/tensor/elementwise/test_remainder.py b/dpnp/tests/tensor/elementwise/test_remainder.py index 0770820599d1..b8d5ca1cf8ae 100644 --- a/dpnp/tests/tensor/elementwise/test_remainder.py +++ b/dpnp/tests/tensor/elementwise/test_remainder.py @@ -91,9 +91,7 @@ def test_remainder_usm_type_matrix(op1_usm_type, op2_usm_type): r = dpt.remainder(ar1, ar2) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( - (op1_usm_type, op2_usm_type) - ) + expected_usm_type = dpt.get_coerced_usm_type((op1_usm_type, op2_usm_type)) assert r.usm_type == expected_usm_type diff --git a/dpnp/tests/tensor/elementwise/test_subtract.py b/dpnp/tests/tensor/elementwise/test_subtract.py index 70c652c7e65a..70d05f926c23 100644 --- a/dpnp/tests/tensor/elementwise/test_subtract.py +++ b/dpnp/tests/tensor/elementwise/test_subtract.py @@ -107,9 +107,7 @@ def test_subtract_usm_type_matrix(op1_usm_type, op2_usm_type): r = dpt.subtract(ar1, ar2) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( - (op1_usm_type, op2_usm_type) - ) + expected_usm_type = dpt.get_coerced_usm_type((op1_usm_type, op2_usm_type)) assert r.usm_type == expected_usm_type diff --git a/dpnp/tests/tensor/elementwise/test_type_utils.py b/dpnp/tests/tensor/elementwise/test_type_utils.py index 45b1501796a3..42e096f4f42d 100644 --- a/dpnp/tests/tensor/elementwise/test_type_utils.py +++ b/dpnp/tests/tensor/elementwise/test_type_utils.py @@ -154,7 +154,7 @@ def test_unary_func_arg_validation(): def test_binary_func_arg_validation(): - with pytest.raises(dpctl.utils.ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.add([1, 2, 3], 1) try: a = dpt.arange(8) diff --git a/dpnp/tests/tensor/test_tensor_accumulation.py b/dpnp/tests/tensor/test_tensor_accumulation.py index 66e979e63a38..b7ea9147e100 100644 --- a/dpnp/tests/tensor/test_tensor_accumulation.py +++ b/dpnp/tests/tensor/test_tensor_accumulation.py @@ -29,7 +29,6 @@ from random import randrange import pytest -from dpctl.utils import ExecutionPlacementError import dpnp.tensor as dpt @@ -308,7 +307,7 @@ def test_accumulator_arg_validation(): # compute follows data out_wrong_queue = dpt.empty_like(x2, sycl_queue=q2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.cumulative_sum(x2, out=out_wrong_queue) diff --git a/dpnp/tests/tensor/test_tensor_asarray.py b/dpnp/tests/tensor/test_tensor_asarray.py index 33d6d00e3ba8..f5caacacdac6 100644 --- a/dpnp/tests/tensor/test_tensor_asarray.py +++ b/dpnp/tests/tensor/test_tensor_asarray.py @@ -404,7 +404,7 @@ def test_asarray_seq_of_arrays_on_different_queues(): assert res.sycl_queue == w.sycl_queue assert dpt.isdtype(res.dtype, "integral") - with pytest.raises(dpctl.utils.ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.asarray([m, [w, py_seq]]) diff --git a/dpnp/tests/tensor/test_tensor_clip.py b/dpnp/tests/tensor/test_tensor_clip.py index de4717f22023..759fc0ef11c7 100644 --- a/dpnp/tests/tensor/test_tensor_clip.py +++ b/dpnp/tests/tensor/test_tensor_clip.py @@ -29,7 +29,6 @@ import dpctl import numpy as np import pytest -from dpctl.utils import ExecutionPlacementError from numpy.testing import assert_raises_regex import dpnp.tensor as dpt @@ -392,7 +391,7 @@ def test_clip_usm_type_matrix(usm_type1, usm_type2, usm_type3): r = dpt.clip(ar1, ar2, ar3) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type( + expected_usm_type = dpt.get_coerced_usm_type( (usm_type1, usm_type2, usm_type3) ) assert r.usm_type == expected_usm_type @@ -409,7 +408,7 @@ def test_clip_usm_type_matrix_none_arg(usm_type1, usm_type2): r = dpt.clip(ar1, min=ar2, max=None) assert isinstance(r, dpt.usm_ndarray) - expected_usm_type = dpctl.utils.get_coerced_usm_type((usm_type1, usm_type2)) + expected_usm_type = dpt.get_coerced_usm_type((usm_type1, usm_type2)) assert r.usm_type == expected_usm_type @@ -457,7 +456,7 @@ def test_clip_errors(): ar3 = dpt.ones_like(ar1, sycl_queue=gpu_queue) ar4 = dpt.empty_like(ar1, sycl_queue=cpu_queue) assert_raises_regex( - ExecutionPlacementError, + dpt.ExecutionPlacementError, "Input and output allocation queues are not compatible", dpt.clip, ar1, @@ -467,7 +466,7 @@ def test_clip_errors(): ) assert_raises_regex( - ExecutionPlacementError, + dpt.ExecutionPlacementError, "Input and output allocation queues are not compatible", dpt.clip, ar1, @@ -477,7 +476,7 @@ def test_clip_errors(): ) assert_raises_regex( - ExecutionPlacementError, + dpt.ExecutionPlacementError, "Execution placement can not be unambiguously inferred from input " "arguments.", dpt.clip, @@ -488,7 +487,7 @@ def test_clip_errors(): ) assert_raises_regex( - ExecutionPlacementError, + dpt.ExecutionPlacementError, "Execution placement can not be unambiguously inferred from input " "arguments.", dpt.clip, @@ -499,7 +498,7 @@ def test_clip_errors(): ) assert_raises_regex( - ExecutionPlacementError, + dpt.ExecutionPlacementError, "Execution placement can not be unambiguously inferred from input " "arguments.", dpt.clip, @@ -510,7 +509,7 @@ def test_clip_errors(): ) assert_raises_regex( - ExecutionPlacementError, + dpt.ExecutionPlacementError, "Execution placement can not be unambiguously inferred from input " "arguments.", dpt.clip, @@ -750,19 +749,19 @@ def test_clip_compute_follows_data(): a_max = dpt.ones(10, dtype="i4", sycl_queue=q1) res = dpt.empty_like(x, sycl_queue=q2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.clip(x, a_min, a_max) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.clip(x, dpt.ones_like(x), a_max, out=res) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.clip(x, a_min) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.clip(x, None, a_max, out=res) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.clip(x, out=res) diff --git a/dpnp/tests/tensor/test_tensor_diff.py b/dpnp/tests/tensor/test_tensor_diff.py index 10153b5f5cc5..e5beea6845b1 100644 --- a/dpnp/tests/tensor/test_tensor_diff.py +++ b/dpnp/tests/tensor/test_tensor_diff.py @@ -29,7 +29,6 @@ from math import prod import pytest -from dpctl.utils import ExecutionPlacementError from numpy.testing import assert_raises_regex import dpnp.tensor as dpt @@ -305,19 +304,19 @@ def test_diff_compute_follows_data(): ar2 = dpt.ones(1, dtype="i4", sycl_queue=q2) ar3 = dpt.ones(1, dtype="i4", sycl_queue=q3) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.diff(ar1, prepend=ar2, append=ar3) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.diff(ar1, prepend=ar2, append=0) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.diff(ar1, prepend=0, append=ar2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.diff(ar1, prepend=ar2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.diff(ar1, append=ar2) diff --git a/dpnp/tests/tensor/test_tensor_isin.py b/dpnp/tests/tensor/test_tensor_isin.py index 0bb22ea242ad..08f1787f733f 100644 --- a/dpnp/tests/tensor/test_tensor_isin.py +++ b/dpnp/tests/tensor/test_tensor_isin.py @@ -30,7 +30,6 @@ import numpy as np import pytest -from dpctl.utils import ExecutionPlacementError import dpnp.tensor as dpt @@ -225,7 +224,7 @@ def test_isin_empty_inputs(): def test_isin_validation(): get_queue_or_skip() - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.isin(1, 1) not_bool = {} with pytest.raises(TypeError): @@ -278,5 +277,5 @@ def test_isin_compute_follows_data(): x = dpt.ones(10, sycl_queue=q1) test = dpt.ones_like(x, sycl_queue=q2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.isin(x, test) diff --git a/dpnp/tests/tensor/test_usm_ndarray_ctor.py b/dpnp/tests/tensor/test_usm_ndarray_ctor.py index cb185ff64a1f..70066860b19f 100644 --- a/dpnp/tests/tensor/test_usm_ndarray_ctor.py +++ b/dpnp/tests/tensor/test_usm_ndarray_ctor.py @@ -1442,14 +1442,14 @@ def test_full_compute_follows_data(): assert Y.dtype == X.dtype assert Y.usm_type == X.usm_type - assert dpctl.utils.get_execution_queue((Y.sycl_queue, X.sycl_queue)) + assert dpt.get_execution_queue((Y.sycl_queue, X.sycl_queue)) assert np.array_equal(dpt.asnumpy(Y), np.full(10, 3, dtype="i4")) Y = dpt.full(10, X[3], dtype="f4", sycl_queue=q2, usm_type="host") assert Y.dtype == dpt.dtype("f4") assert Y.usm_type == "host" - assert dpctl.utils.get_execution_queue((Y.sycl_queue, q2)) + assert dpt.get_execution_queue((Y.sycl_queue, q2)) assert np.array_equal(dpt.asnumpy(Y), np.full(10, 3, dtype="f4")) diff --git a/dpnp/tests/tensor/test_usm_ndarray_indexing.py b/dpnp/tests/tensor/test_usm_ndarray_indexing.py index 530d4ab2988c..b81e5456872b 100644 --- a/dpnp/tests/tensor/test_usm_ndarray_indexing.py +++ b/dpnp/tests/tensor/test_usm_ndarray_indexing.py @@ -29,7 +29,6 @@ import dpctl import numpy as np import pytest -from dpctl.utils import ExecutionPlacementError from numpy.testing import assert_array_equal import dpnp.tensor as dpt @@ -1154,17 +1153,17 @@ def test_advanced_indexing_compute_follows_data(): val0 = dpt.asarray(2, dtype=x.dtype, sycl_queue=q1) val1 = dpt.asarray(2, dtype=x.dtype, sycl_queue=q2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.take(x, ind1, axis=0) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): x[ind1] - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.put(x, ind1, val0, axis=0) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): x[ind1] = val0 - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.put(x, ind0, val1, axis=0) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): x[ind0] = val1 @@ -1500,7 +1499,7 @@ def test_extract_arg_validation(): with pytest.raises(TypeError): dpt.extract(cond, None) q1 = dpctl.SyclQueue() - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.extract(cond.to_device(q1), dpt.zeros_like(cond, dtype="u1")) with pytest.raises(ValueError): dpt.extract(dpt.ones((2, 3), dtype="?"), dpt.ones((3, 2), dtype="i1")) @@ -1518,7 +1517,7 @@ def test_place_arg_validation(): dpt.place(arr, cond, None) vals = dpt.ones_like(arr) q1 = dpctl.SyclQueue() - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.place(arr.to_device(q1), cond, vals) with pytest.raises(ValueError): dpt.place(dpt.reshape(arr, (2, 2, 2)), cond, vals) @@ -1699,7 +1698,7 @@ def test_take_along_axis_validation(): # check compute-follows-data q2 = dpctl.SyclQueue(x_dev, property="enable_profiling") ind2 = dpt.zeros(1, dtype=ind_dt, sycl_queue=q2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.take_along_axis(x, ind2) @@ -1764,7 +1763,7 @@ def test_put_along_axis_validation(): # check compute-follows-data q2 = dpctl.SyclQueue(x_dev, property="enable_profiling") ind2 = dpt.zeros(1, dtype=ind_dt, sycl_queue=q2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.put_along_axis(x, ind2, vals) @@ -1822,7 +1821,7 @@ def check__extract_impl_validation(fn): fn(x, list()) q2 = dpctl.SyclQueue(x.sycl_device, property="enable_profiling") ind2 = dpt.ones(10, dtype="?", sycl_queue=q2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): fn(x, ind2) with pytest.raises(ValueError): fn(x, ind, 1) @@ -1850,7 +1849,7 @@ def check__take_multi_index(fn): fn(x, (x,), 1) q2 = dpctl.SyclQueue(x.sycl_device, property="enable_profiling") ind2 = dpt.arange(10, dtype=ind_dt, sycl_queue=q2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): fn(x, (ind2,), 0) m = dpt.ones((10, 10)) ind_1 = dpt.arange(10, dtype="i8") @@ -1867,7 +1866,7 @@ def check__place_impl_validation(fn): fn(x, list(), list()) q2 = dpctl.SyclQueue(x.sycl_device, property="enable_profiling") mask2 = dpt.ones(10, dtype="?", sycl_queue=q2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): fn(x, mask2, 1) x2 = dpt.ones((5, 5)) mask2 = dpt.ones((5, 5), dtype="?") @@ -2037,7 +2036,7 @@ def test_take_out_errors(): dpt.take(x, ind, out=out_bad_dt) out_bad_q = dpt.empty(ind.shape, dtype=x.dtype, sycl_queue=q2) - with pytest.raises(dpctl.utils.ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.take(x, ind, out=out_bad_q) diff --git a/dpnp/tests/tensor/test_usm_ndarray_linalg.py b/dpnp/tests/tensor/test_usm_ndarray_linalg.py index 13b03ff66fd5..c28754ca080f 100644 --- a/dpnp/tests/tensor/test_usm_ndarray_linalg.py +++ b/dpnp/tests/tensor/test_usm_ndarray_linalg.py @@ -31,7 +31,6 @@ import dpctl import numpy as np import pytest -from dpctl.utils import ExecutionPlacementError import dpnp.tensor as dpt @@ -452,7 +451,7 @@ def test_matmul_out_errors(): with pytest.raises(ValueError): dpt.matmul(m1, m2, out=dpt.empty(sh, dtype="f4", sycl_queue=q1)) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.matmul(m1, m2, out=dpt.empty(sh, dtype=dt, sycl_queue=q2)) @@ -536,7 +535,7 @@ def test_matmul_compute_follows_data(): m1 = dpt.zeros(sh, dtype=dt, sycl_queue=q1) m2 = dpt.zeros(sh, dtype=dt, sycl_queue=q2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.matmul(m1, m2) @@ -751,7 +750,7 @@ def test_tensordot_validation(): t2 = dpt.empty((10, 10, 10)) q = dpctl.SyclQueue(t2.sycl_context, t2.sycl_device, property="in_order") - with pytest.raises(dpctl.utils.ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.tensordot(t1, t2.to_device(q)) invalid_axes = ( @@ -938,7 +937,7 @@ def test_vector_arg_validation(): q = dpctl.SyclQueue( v2.sycl_context, v2.sycl_device, property="enable_profiling" ) - with pytest.raises(dpctl.utils.ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.vecdot(v1, v2.to_device(q)) m1 = dpt.empty((10, 5)) diff --git a/dpnp/tests/tensor/test_usm_ndarray_manipulation.py b/dpnp/tests/tensor/test_usm_ndarray_manipulation.py index 45a53aa0532d..0375bb446370 100644 --- a/dpnp/tests/tensor/test_usm_ndarray_manipulation.py +++ b/dpnp/tests/tensor/test_usm_ndarray_manipulation.py @@ -31,7 +31,6 @@ import dpctl import numpy as np import pytest -from dpctl.utils import ExecutionPlacementError from numpy.testing import assert_, assert_array_equal, assert_raises_regex import dpnp.tensor as dpt @@ -1413,7 +1412,7 @@ def test_repeat_arg_validation(): # compute follows data q2 = dpctl.SyclQueue() reps = dpt.asarray(1, dtype="i8", sycl_queue=q2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.repeat(x, reps) # repeats array must not contain negative elements diff --git a/dpnp/tests/tensor/test_usm_ndarray_reductions.py b/dpnp/tests/tensor/test_usm_ndarray_reductions.py index 4d828fbdbd49..2c431efa936d 100644 --- a/dpnp/tests/tensor/test_usm_ndarray_reductions.py +++ b/dpnp/tests/tensor/test_usm_ndarray_reductions.py @@ -30,7 +30,6 @@ import numpy as np import pytest -from dpctl.utils import ExecutionPlacementError from numpy.testing import assert_allclose import dpnp.tensor as dpt @@ -56,7 +55,6 @@ "f8", ] - _all_dtypes = _no_complex_dtypes + [ "c8", "c16", @@ -650,11 +648,11 @@ def test_reduction_out_kwarg_arg_validation(): dpt.max(x, out=dict()) with pytest.raises(TypeError): dpt.argmax(x, out=dict()) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.sum(x, out=out_wrong_queue) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.max(x, out=out_wrong_queue) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.argmax(x, out=dpt.empty_like(out_wrong_queue, dtype=ind_dt)) with pytest.raises(ValueError): dpt.sum(x, out=out_wrong_dtype) diff --git a/dpnp/tests/tensor/test_usm_ndarray_search_functions.py b/dpnp/tests/tensor/test_usm_ndarray_search_functions.py index 30be5f0ee4f5..33942d93c3a7 100644 --- a/dpnp/tests/tensor/test_usm_ndarray_search_functions.py +++ b/dpnp/tests/tensor/test_usm_ndarray_search_functions.py @@ -31,7 +31,6 @@ import numpy as np import pytest -from dpctl.utils import ExecutionPlacementError from numpy.testing import assert_array_equal import dpnp.tensor as dpt @@ -383,11 +382,11 @@ def test_where_compute_follows_data(): x1 = dpt.empty((1,), dtype="i4", sycl_queue=q1) x2 = dpt.empty((1,), dtype="i4", sycl_queue=q2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.where(dpt.empty((1,), dtype="i4", sycl_queue=q1), x1, x2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.where(dpt.empty((1,), dtype="i4", sycl_queue=q3), x1, x2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.where(x1, x1, x2) @@ -533,7 +532,7 @@ def test_where_out_arg_validation(): with pytest.raises(TypeError): dpt.where(condition, x1, x2, out=dict()) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.where(condition, x1, x2, out=out_wrong_queue) with pytest.raises(ValueError): dpt.where(condition, x1, x2, out=out_wrong_dtype) diff --git a/dpnp/tests/tensor/test_usm_ndarray_searchsorted.py b/dpnp/tests/tensor/test_usm_ndarray_searchsorted.py index d97e224b61cc..aef782f06f08 100644 --- a/dpnp/tests/tensor/test_usm_ndarray_searchsorted.py +++ b/dpnp/tests/tensor/test_usm_ndarray_searchsorted.py @@ -27,7 +27,6 @@ # ***************************************************************************** import dpctl -import dpctl.utils as dpu import numpy as np import pytest @@ -334,10 +333,10 @@ def test_searchsorted_validation2(): q2 = dpctl.SyclQueue(d, property="in_order") x2 = dpt.ones(5, dtype=x1.dtype, sycl_queue=q2) - with pytest.raises(dpu.ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.searchsorted(x1, x2) - with pytest.raises(dpu.ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpt.searchsorted(x1, x2, sorter=sorter) sorter = dpt.ones(x1.shape, dtype=dpt.bool) diff --git a/dpnp/tests/test_fft.py b/dpnp/tests/test_fft.py index c39303f32c1a..31215d725f82 100644 --- a/dpnp/tests/test_fft.py +++ b/dpnp/tests/test_fft.py @@ -1,7 +1,6 @@ import dpctl import numpy import pytest -from dpctl.utils import ExecutionPlacementError from numpy.testing import assert_raises import dpnp @@ -277,7 +276,7 @@ def test_validate_out(self): # Inconsistent sycl_queue a = dpnp.ones((10,), dtype=dpnp.complex64, sycl_queue=dpctl.SyclQueue()) out = dpnp.empty((10,), sycl_queue=dpctl.SyclQueue()) - assert_raises(ExecutionPlacementError, dpnp.fft.fft, a, out=out) + assert_raises(dpt.ExecutionPlacementError, dpnp.fft.fft, a, out=out) # Invalid shape a = dpnp.ones((10,), dtype=dpnp.complex64) diff --git a/dpnp/tests/test_fill.py b/dpnp/tests/test_fill.py index 3102de395d93..6d6f7049d9e3 100644 --- a/dpnp/tests/test_fill.py +++ b/dpnp/tests/test_fill.py @@ -1,9 +1,9 @@ import dpctl import pytest -from dpctl.utils import ExecutionPlacementError from numpy.testing import assert_array_equal import dpnp +from dpnp.tensor import ExecutionPlacementError @pytest.mark.parametrize( diff --git a/dpnp/tests/test_indexing.py b/dpnp/tests/test_indexing.py index 3bdd5449d223..78eec020649b 100644 --- a/dpnp/tests/test_indexing.py +++ b/dpnp/tests/test_indexing.py @@ -3,7 +3,6 @@ import dpctl import numpy import pytest -from dpctl.utils import ExecutionPlacementError from numpy.testing import ( assert_, assert_array_equal, @@ -1380,7 +1379,7 @@ def test_compress_invalid_out_errors(self): with pytest.raises(ValueError): dpnp.compress(condition, a, out=out_bad_shape) out_bad_queue = dpnp.empty(1, dtype="i4", sycl_queue=q2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpnp.compress(condition, a, out=out_bad_queue) out_bad_dt = dpnp.empty(1, dtype="i8", sycl_queue=q1) with pytest.raises(TypeError): @@ -1496,7 +1495,7 @@ def test_choose_invalid_out_errors(self): with pytest.raises(ValueError): dpnp.choose(inds, [chcs], out=out_bad_shape) out_bad_queue = dpnp.empty(chcs.shape, dtype=chcs.dtype, sycl_queue=q2) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpnp.choose(inds, [chcs], out=out_bad_queue) out_bad_dt = dpnp.empty(chcs.shape, dtype="i8", sycl_queue=q1) with pytest.raises(TypeError): diff --git a/dpnp/tests/test_linalg.py b/dpnp/tests/test_linalg.py index d32237c04aad..524fd4869b0c 100644 --- a/dpnp/tests/test_linalg.py +++ b/dpnp/tests/test_linalg.py @@ -3,7 +3,6 @@ import dpctl import numpy import pytest -from dpctl.utils import ExecutionPlacementError from numpy.testing import ( assert_allclose, assert_array_equal, @@ -607,7 +606,9 @@ def test_einsum_error1(self): a = dpnp.ones((5, 5)) out = dpnp.empty((5,), sycl_queue=dpctl.SyclQueue()) # inconsistent sycl_queue - assert_raises(ExecutionPlacementError, dpnp.einsum, "ii->i", a, out=out) + assert_raises( + dpt.ExecutionPlacementError, dpnp.einsum, "ii->i", a, out=out + ) # unknown value for optimize keyword assert_raises(TypeError, dpnp.einsum, "ii->i", a, optimize="blah") @@ -2777,7 +2778,7 @@ def test_matrix_rank_errors(self): a_dp_q = dpnp.array(a_dp, sycl_queue=a_queue) tol_dp_q = dpnp.array([0.5], dtype="float32", sycl_queue=tol_queue) assert_raises( - ExecutionPlacementError, + dpt.ExecutionPlacementError, dpnp.linalg.matrix_rank, a_dp_q, tol_dp_q, diff --git a/dpnp/tests/test_logic.py b/dpnp/tests/test_logic.py index cae51e6777ef..1ff9a780d88d 100644 --- a/dpnp/tests/test_logic.py +++ b/dpnp/tests/test_logic.py @@ -1,7 +1,6 @@ import dpctl import numpy import pytest -from dpctl.utils import ExecutionPlacementError from numpy.testing import ( assert_allclose, assert_array_equal, @@ -10,6 +9,7 @@ ) import dpnp +from dpnp.tensor import ExecutionPlacementError from .helper import ( generate_random_numpy_array, diff --git a/dpnp/tests/test_mathematical.py b/dpnp/tests/test_mathematical.py index ae273ffa8c03..c9a506fa6238 100644 --- a/dpnp/tests/test_mathematical.py +++ b/dpnp/tests/test_mathematical.py @@ -1,7 +1,6 @@ import dpctl import numpy import pytest -from dpctl.utils import ExecutionPlacementError from numpy.testing import ( assert_allclose, assert_array_equal, @@ -710,12 +709,14 @@ def test_errors(self): # another `to_begin` sycl queue to_begin = dpnp.array([-20, -15], sycl_queue=dpctl.SyclQueue()) assert_raises( - ExecutionPlacementError, dpnp.ediff1d, ia, to_begin=to_begin + dpt.ExecutionPlacementError, dpnp.ediff1d, ia, to_begin=to_begin ) # another `to_end` sycl queue to_end = dpnp.array([15, 20], sycl_queue=dpctl.SyclQueue()) - assert_raises(ExecutionPlacementError, dpnp.ediff1d, ia, to_end=to_end) + assert_raises( + dpt.ExecutionPlacementError, dpnp.ediff1d, ia, to_end=to_end + ) class TestGradient: @@ -2131,13 +2132,13 @@ def test_unary_two_outs_cfd_error(self, func): out1 = dpnp.empty((), sycl_queue=dpctl.SyclQueue()) out2 = dpnp.empty((), sycl_queue=dpctl.SyclQueue()) with pytest.raises( - ExecutionPlacementError, + dpt.ExecutionPlacementError, match="Input and output allocation queues are not compatible", ): _ = fn(*args, out1) with pytest.raises( - ExecutionPlacementError, + dpt.ExecutionPlacementError, match="Input and output allocation queues are not compatible", ): _ = fn(*args, out=(None, out2)) diff --git a/dpnp/tests/test_nanfunctions.py b/dpnp/tests/test_nanfunctions.py index 3c5ea5b61989..49f47ebec043 100644 --- a/dpnp/tests/test_nanfunctions.py +++ b/dpnp/tests/test_nanfunctions.py @@ -1,7 +1,6 @@ import dpctl import numpy import pytest -from dpctl.utils import ExecutionPlacementError from numpy.testing import ( assert_allclose, assert_almost_equal, @@ -496,7 +495,7 @@ def test_error(self): # out has a different queue exec_q = dpctl.SyclQueue() res = dpnp.empty(2, dtype=a.dtype, sycl_queue=exec_q) - with pytest.raises(ExecutionPlacementError): + with pytest.raises(dpt.ExecutionPlacementError): dpnp.nanmedian(a, axis=1, out=res) diff --git a/dpnp/tests/test_product.py b/dpnp/tests/test_product.py index cd71b07352da..abbaa307ee03 100644 --- a/dpnp/tests/test_product.py +++ b/dpnp/tests/test_product.py @@ -1,11 +1,11 @@ import dpctl import numpy import pytest -from dpctl.utils import ExecutionPlacementError from numpy.testing import assert_allclose, assert_array_equal, assert_raises import dpnp from dpnp.dpnp_utils import map_dtype_to_device +from dpnp.tensor import ExecutionPlacementError from dpnp.tensor._numpy_helper import AxisError from .helper import ( diff --git a/dpnp/tests/test_sycl_queue.py b/dpnp/tests/test_sycl_queue.py index f1678bd28da3..361b10444192 100644 --- a/dpnp/tests/test_sycl_queue.py +++ b/dpnp/tests/test_sycl_queue.py @@ -4,7 +4,6 @@ import dpctl import numpy import pytest -from dpctl.utils import ExecutionPlacementError from numpy.testing import assert_array_equal, assert_raises import dpnp @@ -50,7 +49,7 @@ def assert_sycl_queue_equal(result, expected): assert result.sycl_device == expected.sycl_device assert result.is_in_order == expected.is_in_order assert result.has_enable_profiling == expected.has_enable_profiling - exec_queue = dpctl.utils.get_execution_queue([result, expected]) + exec_queue = dpt.get_execution_queue([result, expected]) assert exec_queue is not None @@ -657,7 +656,7 @@ def test_2in_broadcasting(func, data1, data2, device): def test_2in_1out_diff_queue_but_equal_context(func, device): x1 = dpnp.arange(10) x2 = dpnp.arange(10, sycl_queue=dpctl.SyclQueue(device))[::-1] - with assert_raises((ValueError, ExecutionPlacementError)): + with assert_raises((ValueError, dpt.ExecutionPlacementError)): getattr(dpnp, func)(x1, x2) diff --git a/dpnp/tests/test_usm_type.py b/dpnp/tests/test_usm_type.py index a0cfe6d24979..78ef41f9ea18 100644 --- a/dpnp/tests/test_usm_type.py +++ b/dpnp/tests/test_usm_type.py @@ -2,7 +2,6 @@ import tempfile from math import prod -import dpctl.utils as du import numpy import pytest @@ -29,7 +28,7 @@ def test_add(usm_type_x, usm_type_y): assert x.usm_type == usm_type_x assert y.usm_type == usm_type_y - assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_y]) + assert z.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_y]) @pytest.mark.parametrize("usm_type_x", list_of_usm_types) @@ -46,7 +45,7 @@ def test_multiply(usm_type_x, usm_type_y): assert x.usm_type == usm_type_x assert y.usm_type == usm_type_y - assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_y]) + assert z.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_y]) @pytest.mark.parametrize("usm_type_x", list_of_usm_types) @@ -63,7 +62,7 @@ def test_subtract(usm_type_x, usm_type_y): assert x.usm_type == usm_type_x assert y.usm_type == usm_type_y - assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_y]) + assert z.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_y]) @pytest.mark.parametrize("usm_type_x", list_of_usm_types) @@ -80,7 +79,7 @@ def test_divide(usm_type_x, usm_type_y): assert x.usm_type == usm_type_x assert y.usm_type == usm_type_y - assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_y]) + assert z.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_y]) @pytest.mark.parametrize("usm_type_x", list_of_usm_types) @@ -100,7 +99,7 @@ def test_remainder(usm_type_x, usm_type_y): assert x.usm_type == usm_type_x assert y.usm_type == usm_type_y - assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_y]) + assert z.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_y]) @pytest.mark.parametrize("usm_type_x", list_of_usm_types) @@ -121,7 +120,7 @@ def test_floor_divide(usm_type_x, usm_type_y): assert x.usm_type == usm_type_x assert y.usm_type == usm_type_y - assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_y]) + assert z.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_y]) @pytest.mark.parametrize("usm_type_x", list_of_usm_types) @@ -136,7 +135,7 @@ def test_power(usm_type_x, usm_type_y): assert x.usm_type == usm_type_x assert y.usm_type == usm_type_y - assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_y]) + assert z.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_y]) @pytest.mark.parametrize( @@ -320,7 +319,7 @@ def test_linspace_arrays(usm_type_start, usm_type_stop): start = dpnp.array([0, 0], usm_type=usm_type_start) stop = dpnp.array([2, 4], usm_type=usm_type_stop) res = dpnp.linspace(start, stop, 4) - assert res.usm_type == du.get_coerced_usm_type( + assert res.usm_type == dpt.get_coerced_usm_type( [usm_type_start, usm_type_stop] ) @@ -376,7 +375,7 @@ def test_logic_op_2in(op, usm_type_x, usm_type_y): assert x.usm_type == zx.usm_type == usm_type_x assert y.usm_type == zy.usm_type == usm_type_y - assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_y]) + assert z.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_y]) @pytest.mark.parametrize("op", ["bitwise_count", "bitwise_not"]) @@ -404,7 +403,7 @@ def test_bitwise_op_2in(op, usm_type_x, usm_type_y): assert x.usm_type == zx.usm_type == usm_type_x assert y.usm_type == zy.usm_type == usm_type_y - assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_y]) + assert z.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_y]) class TestMatmul: @@ -445,7 +444,7 @@ def test_basic(self, usm_type_x, usm_type_y, dtype, shape1, shape2): assert x.usm_type == usm_type_x assert y.usm_type == usm_type_y - assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_y]) + assert z.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_y]) @pytest.mark.parametrize("usm_type", list_of_usm_types) def test_syrk(self, usm_type): @@ -474,7 +473,7 @@ def test_matvec(usm_type_x, usm_type_y, shape1, shape2): assert x.usm_type == usm_type_x assert y.usm_type == usm_type_y - assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_y]) + assert z.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_y]) @pytest.mark.parametrize("usm_type_x", list_of_usm_types) @@ -496,7 +495,7 @@ def test_vecdot(usm_type_x, usm_type_y, shape1, shape2): assert x.usm_type == usm_type_x assert y.usm_type == usm_type_y - assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_y]) + assert z.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_y]) @pytest.mark.parametrize("usm_type_x", list_of_usm_types) @@ -518,7 +517,7 @@ def test_vecmat(usm_type_x, usm_type_y, shape1, shape2): assert x.usm_type == usm_type_x assert y.usm_type == usm_type_y - assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_y]) + assert z.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_y]) @pytest.mark.parametrize("usm_type_x", list_of_usm_types) @@ -744,7 +743,7 @@ def test_2in_1out(func, data1, data2, usm_type_x, usm_type_y): assert x.usm_type == usm_type_x assert y.usm_type == usm_type_y - assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_y]) + assert z.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_y]) @pytest.mark.parametrize( @@ -765,7 +764,7 @@ def test_2in_2out(func, data1, data2, usm_type_x, usm_type_y): assert ( z1.usm_type == z2.usm_type - == du.get_coerced_usm_type([usm_type_x, usm_type_y]) + == dpt.get_coerced_usm_type([usm_type_x, usm_type_y]) ) @@ -811,7 +810,7 @@ def test_piecewise(usm_type_x, usm_type_y, usm_type_z): assert x.usm_type == usm_type_x assert y.usm_type == usm_type_y assert z.usm_type == usm_type_z - assert result.usm_type == du.get_coerced_usm_type( + assert result.usm_type == dpt.get_coerced_usm_type( [usm_type_x, usm_type_y, usm_type_z] ) @@ -836,7 +835,7 @@ def test_concat_stack(func, data1, data2, usm_type_x, usm_type_y): assert x.usm_type == usm_type_x assert y.usm_type == usm_type_y - assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_y]) + assert z.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_y]) @pytest.mark.parametrize("usm_type_x", list_of_usm_types) @@ -848,7 +847,7 @@ def test_extract(usm_type_x, usm_type_y): assert x.usm_type == usm_type_x assert y.usm_type == usm_type_y - assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_y]) + assert z.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_y]) @pytest.mark.parametrize( @@ -896,7 +895,9 @@ def test_obj_ndarray(self, usm_type, usm_type_other): assert x.usm_type == usm_type assert y.usm_type == usm_type_other - assert z.usm_type == du.get_coerced_usm_type([usm_type, usm_type_other]) + assert z.usm_type == dpt.get_coerced_usm_type( + [usm_type, usm_type_other] + ) @pytest.mark.parametrize("usm_type", list_of_usm_types) @@ -941,7 +942,9 @@ def test_values_ndarray(self, obj, usm_type, usm_type_other): assert x.usm_type == usm_type assert y.usm_type == usm_type_other - assert z.usm_type == du.get_coerced_usm_type([usm_type, usm_type_other]) + assert z.usm_type == dpt.get_coerced_usm_type( + [usm_type, usm_type_other] + ) @pytest.mark.parametrize("values", [-2, [-1, -2]], ids=["scalar", "list"]) @pytest.mark.parametrize("usm_type_other", list_of_usm_types) @@ -952,7 +955,9 @@ def test_obj_ndarray(self, values, usm_type, usm_type_other): assert x.usm_type == usm_type assert y.usm_type == usm_type_other - assert z.usm_type == du.get_coerced_usm_type([usm_type, usm_type_other]) + assert z.usm_type == dpt.get_coerced_usm_type( + [usm_type, usm_type_other] + ) @pytest.mark.parametrize("usm_type_y", list_of_usm_types) @pytest.mark.parametrize("usm_type_z", list_of_usm_types) @@ -965,7 +970,7 @@ def test_obj_values_ndarray(self, usm_type, usm_type_y, usm_type_z): assert x.usm_type == usm_type assert y.usm_type == usm_type_y assert z.usm_type == usm_type_z - assert res.usm_type == du.get_coerced_usm_type( + assert res.usm_type == dpt.get_coerced_usm_type( [usm_type, usm_type_y, usm_type_z] ) @@ -980,7 +985,7 @@ def test_take(func, usm_type_x, usm_type_ind): assert x.usm_type == usm_type_x assert ind.usm_type == usm_type_ind - assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_ind]) + assert z.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_ind]) @pytest.mark.parametrize( @@ -1004,7 +1009,7 @@ def test_take_along_axis(data, ind, axis, usm_type_x, usm_type_ind): assert x.usm_type == usm_type_x assert ind.usm_type == usm_type_ind - assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_ind]) + assert z.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_ind]) @pytest.mark.parametrize("usm_type", list_of_usm_types + [None]) @@ -1156,8 +1161,8 @@ def test_histogram(usm_type_v, usm_type_w): hist, edges = dpnp.histogram(v, weights=w) assert v.usm_type == usm_type_v assert w.usm_type == usm_type_w - assert hist.usm_type == du.get_coerced_usm_type([usm_type_v, usm_type_w]) - assert edges.usm_type == du.get_coerced_usm_type([usm_type_v, usm_type_w]) + assert hist.usm_type == dpt.get_coerced_usm_type([usm_type_v, usm_type_w]) + assert edges.usm_type == dpt.get_coerced_usm_type([usm_type_v, usm_type_w]) @pytest.mark.parametrize("usm_type_x", list_of_usm_types) @@ -1172,13 +1177,13 @@ def test_histogram2d(usm_type_x, usm_type_y, usm_type_w): assert x.usm_type == usm_type_x assert y.usm_type == usm_type_y assert w.usm_type == usm_type_w - assert hist.usm_type == du.get_coerced_usm_type( + assert hist.usm_type == dpt.get_coerced_usm_type( [usm_type_x, usm_type_y, usm_type_w] ) - assert edges_x.usm_type == du.get_coerced_usm_type( + assert edges_x.usm_type == dpt.get_coerced_usm_type( [usm_type_x, usm_type_y, usm_type_w] ) - assert edges_y.usm_type == du.get_coerced_usm_type( + assert edges_y.usm_type == dpt.get_coerced_usm_type( [usm_type_x, usm_type_y, usm_type_w] ) @@ -1192,7 +1197,7 @@ def test_bincount(usm_type_v, usm_type_w): hist = dpnp.bincount(v, weights=w) assert v.usm_type == usm_type_v assert w.usm_type == usm_type_w - assert hist.usm_type == du.get_coerced_usm_type([usm_type_v, usm_type_w]) + assert hist.usm_type == dpt.get_coerced_usm_type([usm_type_v, usm_type_w]) @pytest.mark.parametrize("usm_type_v", list_of_usm_types) @@ -1204,9 +1209,9 @@ def test_histogramdd(usm_type_v, usm_type_w): hist, edges = dpnp.histogramdd(v, weights=w) assert v.usm_type == usm_type_v assert w.usm_type == usm_type_w - assert hist.usm_type == du.get_coerced_usm_type([usm_type_v, usm_type_w]) + assert hist.usm_type == dpt.get_coerced_usm_type([usm_type_v, usm_type_w]) for e in edges: - assert e.usm_type == du.get_coerced_usm_type([usm_type_v, usm_type_w]) + assert e.usm_type == dpt.get_coerced_usm_type([usm_type_v, usm_type_w]) @pytest.mark.parametrize( @@ -1247,7 +1252,7 @@ def test_histogram_bin_edges(usm_type_v, usm_type_w): edges = dpnp.histogram_bin_edges(v, weights=w) assert v.usm_type == usm_type_v assert w.usm_type == usm_type_w - assert edges.usm_type == du.get_coerced_usm_type([usm_type_v, usm_type_w]) + assert edges.usm_type == dpt.get_coerced_usm_type([usm_type_v, usm_type_w]) @pytest.mark.parametrize("usm_type_x", list_of_usm_types) @@ -1256,7 +1261,7 @@ def test_select(usm_type_x, usm_type_y): condlist = [dpnp.array([True, False], usm_type=usm_type_x)] choicelist = [dpnp.array([1, 2], usm_type=usm_type_y)] res = dpnp.select(condlist, choicelist) - assert res.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_y]) + assert res.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_y]) @pytest.mark.parametrize("axis", [None, 0, -1]) @@ -1300,7 +1305,7 @@ def test_ediff1d(usm_type_x, usm_type_args, to_end, to_begin): res = dpnp.ediff1d(x, to_end=to_end, to_begin=to_begin) - assert res.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_args]) + assert res.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_args]) @pytest.mark.parametrize("usm_type", list_of_usm_types) @@ -1337,7 +1342,7 @@ def test_choose(usm_type_x, usm_type_ind): assert chc.usm_type == usm_type_x assert ind.usm_type == usm_type_ind - assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_ind]) + assert z.usm_type == dpt.get_coerced_usm_type([usm_type_x, usm_type_ind]) @pytest.mark.parametrize( @@ -1371,7 +1376,7 @@ def test_basic(self, usm_type_x, usm_type_xp, usm_type_fp): assert x.usm_type == usm_type_x assert xp.usm_type == usm_type_xp assert fp.usm_type == usm_type_fp - assert result.usm_type == du.get_coerced_usm_type( + assert result.usm_type == dpt.get_coerced_usm_type( [usm_type_x, usm_type_xp, usm_type_fp] ) @@ -1390,7 +1395,7 @@ def test_left_right(self, usm_type_x, usm_type_left, usm_type_right): assert left.usm_type == usm_type_left assert right.usm_type == usm_type_right - assert result.usm_type == du.get_coerced_usm_type( + assert result.usm_type == dpt.get_coerced_usm_type( [ x.usm_type, xp.usm_type, @@ -1523,7 +1528,7 @@ def test_lstsq(self, m, n, nrhs, usm_type, usm_type_other): assert a.usm_type == usm_type assert b.usm_type == usm_type_other for param in result: - assert param.usm_type == du.get_coerced_usm_type( + assert param.usm_type == dpt.get_coerced_usm_type( [usm_type, usm_type_other] ) @@ -1558,7 +1563,7 @@ def test_lu_solve(self, a_data, b_data, usm_type, usm_type_rhs): assert lu.usm_type == usm_type assert b.usm_type == usm_type_rhs - assert result.usm_type == du.get_coerced_usm_type( + assert result.usm_type == dpt.get_coerced_usm_type( [usm_type, usm_type_rhs] ) @@ -1718,7 +1723,7 @@ def test_solve(self, matrix, rhs, usm_type, usm_type_rhs): assert x.usm_type == usm_type assert y.usm_type == usm_type_rhs - assert z.usm_type == du.get_coerced_usm_type([usm_type, usm_type_rhs]) + assert z.usm_type == dpt.get_coerced_usm_type([usm_type, usm_type_rhs]) @pytest.mark.parametrize("full_matrices_param", [True, False]) @pytest.mark.parametrize("compute_uv_param", [True, False]) @@ -1784,6 +1789,6 @@ def test_tensorsolve(self, usm_type, usm_type_other): assert a.usm_type == usm_type assert b.usm_type == usm_type_other - assert result.usm_type == du.get_coerced_usm_type( + assert result.usm_type == dpt.get_coerced_usm_type( [usm_type, usm_type_other] )