Simplification of exec. queue derivation.

    - The removal of support for NumPy args in kernels helps
      simplify the logic for execution queue derivation.
    - The ComputeFollowsDataInferenceError was renamed to
      ExecutionQueueInferenceError, and the old
      ExecutionQueueInferenceError was removed.

Author: Diptorup Deb

numba_dpex/core/exceptions.py

@@ -182,7 +182,7 @@ def __init__(self, kernel_name, dim, work_groups, work_items) -> None:
         super().__init__(self.message)
 
 
-class ComputeFollowsDataInferenceError(Exception):
+class ExecutionQueueInferenceError(Exception):
     """Exception raised when an execution queue for a given array expression or
     a kernel function could not be deduced using the compute-follows-data
     programming model.
@@ -194,34 +194,20 @@ class ComputeFollowsDataInferenceError(Exception):
     which the array operands were allocated. Computation is required to occur
     on the same device where the arrays currently reside.
 
-    A ComputeFollowsDataInferenceError is raised when the execution queue using
+    A ExecutionQueueInferenceError is raised when the execution queue using
     compute-follows-data rules could not be deduced. It may happen when arrays
     that have a device attribute such as ``dpctl.tensor.usm_ndarray`` are mixed
     with host arrays such as ``numpy.ndarray``. The error may also be raised if
     the array operands are allocated on different devices.
 
     Args:
         kernel_name : Name of the kernel function for which the error occurred.
-        ndarray_argnum_list: The list of ``numpy.ndarray`` arguments identified
-        by the argument position that caused the error.
         usmarray_argnum_list: The list of ``dpctl.tensor.usm_ndarray`` arguments
         identified by the argument position that caused the error.
     """
 
-    def __init__(
-        self, kernel_name, ndarray_argnum_list=None, *, usmarray_argnum_list
-    ) -> None:
-        if ndarray_argnum_list and usmarray_argnum_list:
-            ndarray_args = ",".join([str(i) for i in ndarray_argnum_list])
-            usmarray_args = ",".join([str(i) for i in usmarray_argnum_list])
-            self.message = (
-                f'Kernel "{kernel_name}" has arguments of both usm_ndarray and '
-                "non-usm_ndarray types. Mixing of arguments of different "
-                "array types is disallowed. "
-                f"Arguments {ndarray_args} are non-usm arrays, "
-                f"and arguments {usmarray_args} are usm arrays."
-            )
-        elif usmarray_argnum_list is not None:
+    def __init__(self, kernel_name, *, usmarray_argnum_list) -> None:
+        if usmarray_argnum_list is not None:
             usmarray_args = ",".join([str(i) for i in usmarray_argnum_list])
             self.message = (
                 f'Execution queue for kernel "{kernel_name}" could '
@@ -232,32 +218,6 @@ def __init__(
         super().__init__(self.message)
 
 
-class ExecutionQueueInferenceError(Exception):
-    """Exception raised when an execution queue could not be deduced for NumPy
-    ndarray kernel arguments.
-
-    Args:
-        kernel_name (str): Name of kernel where the error was raised.
-
-    .. deprecated:: 0.19
-    """
-
-    def __init__(self, kernel_name) -> None:
-        warn(
-            "The ExecutionQueueInferenceError class is deprecated, and will "
-            + "be removed once support for NumPy ndarrays as kernel arguments "
-            + "is removed.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        self.message = (
-            f'Kernel "{kernel_name}" was called with NumPy ndarray arguments '
-            "outside a dpctl.device_context. The execution queue to be used "
-            "could not be deduced."
-        )
-        super().__init__(self.message)
-
-
 class UnsupportedBackendError(Exception):
     """Exception raised when the target device is not supported by dpex.
 

numba_dpex/core/kernel_interface/utils.py

@@ -2,15 +2,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from warnings import warn
 
-import dpctl
-from numba.core.types import Array as NpArrayType
-
-from numba_dpex.core.exceptions import (
-    ComputeFollowsDataInferenceError,
-    ExecutionQueueInferenceError,
-)
+from numba_dpex.core.exceptions import ExecutionQueueInferenceError
 from numba_dpex.core.types import USMNdArray
 
 
@@ -50,131 +43,34 @@ def chk_compute_follows_data_compliance(usm_array_arglist):
 def determine_kernel_launch_queue(args, argtypes, kernel_name):
     """Determines the queue where the kernel is to be launched.
 
-    The execution queue is derived using the following algorithm. In future,
-    support for ``numpy.ndarray`` and ``dpctl.device_context`` is to be
-    removed and queue derivation will follows Python Array API's
-    "compute follows data" logic.
-
-    Check if there are array arguments.
-    True:
-        Check if all array arguments are of type numpy.ndarray
-        (numba.types.Array)
-            True:
-                Check if the kernel was invoked from within a
-                dpctl.device_context.
-                True:
-                    Provide a deprecation warning for device_context use and
-                    point to using dpctl.tensor.usm_ndarray or dpnp.ndarray
-
-                    return dpctl.get_current_queue
-                False:
-                    Raise ExecutionQueueInferenceError
-            False:
-                Check if all of the arrays are USMNdarray
-                    True:
-                        Check if execution queue could be inferred using
-                        compute follows data rules
-                        True:
-                            return the compute follows data inferred queue
-                        False:
-                            Raise ComputeFollowsDataInferenceError
-                    False:
-                        Raise ComputeFollowsDataInferenceError
-    False:
-        Check if the kernel was invoked from within a dpctl.device_context.
-        True:
-            Provide a deprecation warning for device_context use and
-            point to using dpctl.tensor.usm_ndarray of dpnp.ndarray
-
-            return dpctl.get_current_queue
-        False:
-            Raise ExecutionQueueInferenceError
+    The execution queue is derived following Python Array API's
+    "compute follows data" programming model.
 
     Args:
-        args : A list of arguments passed to the kernel stored in the
-        launcher.
         argtypes : The Numba inferred type for each argument.
+        kernel_name : The name of the kernel function
 
     Returns:
         A queue the common queue used to allocate the arrays. If no such
         queue exists, then raises an Exception.
 
     Raises:
-        ComputeFollowsDataInferenceError: If the queue could not be inferred
-            using compute follows data rules.
-        ExecutionQueueInferenceError: If the queue could not be inferred
-            using the dpctl queue manager.
+        ExecutionQueueInferenceError: If the queue could not be inferred.
     """
 
-    # FIXME: The args parameter is not needed once numpy support is removed
-
-    # Needed as USMNdArray derives from Array
-    array_argnums = [
-        i
-        for i, _ in enumerate(args)
-        if isinstance(argtypes[i], NpArrayType)
-        and not isinstance(argtypes[i], USMNdArray)
-    ]
     usmarray_argnums = [
         i for i, _ in enumerate(args) if isinstance(argtypes[i], USMNdArray)
     ]
 
-    # if usm and non-usm array arguments are getting mixed, then the
-    # execution queue cannot be inferred using compute follows data rules.
-    if array_argnums and usmarray_argnums:
-        raise ComputeFollowsDataInferenceError(
-            array_argnums, usmarray_argnum_list=usmarray_argnums
+    usm_array_args = [
+        argtype for i, argtype in enumerate(argtypes) if i in usmarray_argnums
+    ]
+
+    queue = chk_compute_follows_data_compliance(usm_array_args)
+
+    if not queue:
+        raise ExecutionQueueInferenceError(
+            kernel_name, usmarray_argnum_list=usmarray_argnums
         )
-    elif array_argnums and not usmarray_argnums:
-        if dpctl.is_in_device_context():
-            warn(
-                "Support for dpctl.device_context to specify the "
-                + "execution queue is deprecated. "
-                + "Use dpctl.tensor.usm_ndarray based array "
-                + "containers instead. ",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            warn(
-                "Support for NumPy ndarray objects as kernel arguments is "
-                + "deprecated. Use dpctl.tensor.usm_ndarray based array "
-                + "containers instead. ",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            return dpctl.get_current_queue()
-        else:
-            raise ExecutionQueueInferenceError(kernel_name)
-    elif usmarray_argnums and not array_argnums:
-        if dpctl.is_in_device_context():
-            warn(
-                "dpctl.device_context ignored as the kernel arguments "
-                + "are dpctl.tensor.usm_ndarray based array containers."
-            )
-        usm_array_args = [
-            argtype
-            for i, argtype in enumerate(argtypes)
-            if i in usmarray_argnums
-        ]
-
-        queue = chk_compute_follows_data_compliance(usm_array_args)
 
-        if not queue:
-            raise ComputeFollowsDataInferenceError(
-                kernel_name, usmarray_argnum_list=usmarray_argnums
-            )
-
-        return queue
-    else:
-        if dpctl.is_in_device_context():
-            warn(
-                "Support for dpctl.device_context to specify the "
-                + "execution queue is deprecated. "
-                + "Use dpctl.tensor.usm_ndarray based array "
-                + "containers instead. ",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            return dpctl.get_current_queue()
-        else:
-            raise ExecutionQueueInferenceError(kernel_name)
+    return queue

numba_dpex/core/passes/parfor_legalize_cfd_pass.py

@@ -12,7 +12,7 @@
     get_parfor_params,
 )
 
-from numba_dpex.core.exceptions import ComputeFollowsDataInferenceError
+from numba_dpex.core.exceptions import ExecutionQueueInferenceError
 from numba_dpex.core.parfors.parfor_lowerer import ParforLowerFactory
 from numba_dpex.core.types.dpnp_ndarray_type import DpnpNdArray
 
@@ -27,7 +27,7 @@ class ParforLegalizeCFDPassImpl:
     __array_ufunc__ method of DpnpNdArray class. The pass fixes the LHS type by
     properly applying compute follows data programming model. The pass first
     checks if the right-hand-side (RHS) DpnpNdArray arguments are on the same
-    device, else raising a ComputeFollowsDataInferenceError. Once the RHS has
+    device, else raising a ExecutionQueueInferenceError. Once the RHS has
     been validated, the LHS type is updated.
 
     The pass also updated the usm_type of the LHS based on a USM type
@@ -92,7 +92,7 @@ def _check_cfd_parfor_params(self, parfor, checklist):
                 )
         # Check compute follows data on the dpnp arrays in checklist
         if len(deviceTypes) > 1:
-            raise ComputeFollowsDataInferenceError(
+            raise ExecutionQueueInferenceError(
                 kernel_name=parfor.loc.short(),
                 usmarray_argnum_list=[],
             )

numba_dpex/tests/core/passes/test_parfor_legalize_cfd_pass.py

@@ -13,7 +13,7 @@
 import pytest
 
 from numba_dpex import dpjit
-from numba_dpex.core.exceptions import ComputeFollowsDataInferenceError
+from numba_dpex.core.exceptions import ExecutionQueueInferenceError
 from numba_dpex.tests._helper import skip_no_opencl_gpu
 
 shapes = [10, (2, 5)]
@@ -62,7 +62,7 @@ def test_parfor_legalize_cfd_pass_raise():
     a = dpnp.zeros(shape=10, device="cpu")
     b = dpnp.ones(shape=10, device="gpu")
 
-    with pytest.raises(ComputeFollowsDataInferenceError):
+    with pytest.raises(ExecutionQueueInferenceError):
         func1(a, b)
 
 
@@ -78,5 +78,5 @@ def vecadd_prange(a, b):
             c[idx] = a[idx] + b[idx]
         return c
 
-    with pytest.raises(ComputeFollowsDataInferenceError):
+    with pytest.raises(ExecutionQueueInferenceError):
         vecadd_prange(a, b)