8386463695

Committed 22 Mar 2024 06:33AM UTC coverage: 79.08% (-0.8%) from 79.874%

Build # 8386463695

Build Type

Pull #1400

github

Committed by

web-flow

Commit Message

Merge d7cca4aec into 611a59711

Pull Request Pull Request #1400: Feature/move experimental decorators to stable

Run Details

1504 of 2209 branches covered (68.09%)

Branch coverage included in aggregate %.

79 of 86 new or added lines in 3 files covered. (91.86%)

83 existing lines in 11 files now uncovered.

6332 of 7700 relevant lines covered (82.23%)

0.82 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

53.85

/numba_dpex/core/exceptions.py

# SPDX-FileCopyrightText: 2020 - 2024 Intel Corporation
#
# SPDX-License-Identifier: Apache-2.0

"""The module defines the custom error classes used in numba_dpex.
"""

from warnings import warn


class KernelHasReturnValueError(Exception):
    """Exception raised when a kernel function is defined with a return
    statement.


    @numba_dpex.kernel does not allow users to return any value. The
    restriction is inline with the general ABI for device functions in OpenCL,
    CUDA, and SYCL.

    Args:
        kernel_name: Name of the kernel function that caused the error.
        return_type: Numba type representing the return value specified for
        the kernel function.
    """

    def __init__(self, kernel_name, return_type, sig=None) -> None:
        self.return_type = return_type
        if sig:
            self.message = (
                f'Specialized kernel signature "{sig}" has a return value '
                f'of type "{return_type}". '
                "A kernel must have a void return type."
            )
        else:
            self.message = (
                f'Kernel "{kernel_name}" has a return value '
                f'of type "{return_type}". '
                "A kernel must have a void return type."
            )

        super().__init__(self.message)


class InvalidKernelLaunchArgsError(Exception):
    """Exception raised when a kernel is dispatched with insufficient or
    incorrect launch arguments.

    A global range value is needed to submit a kernel to an execution queue. The
    global range provides the number of work items that the SYCL runtime should
    create to execute the kernel. The exception is raised if a kernel is
    dispatched without specifying a valid global range.

    Args:
        kernel_name (str): The kernel function name.
    """

    def __init__(self, kernel_name):
        self.message = (
            "Invalid global and local range arguments specified for launching "
            f' the Kernel "{kernel_name}". Refer documentation for details.'
        )
        super().__init__(self.message)


class UnknownGlobalRangeError(Exception):
    """Exception raised when a kernel is launched without specifying a global
    range.

    Args:
        kernel_name (str): The kernel function name.
    """

    def __init__(self, kernel_name) -> None:
        self.message = (
            "No global range specified for launching the Kernel "
            f'"{kernel_name}". '
            "A valid global range tuple is needed to launch a kernel."
        )
        super().__init__(self.message)


class IllegalRangeValueError(Exception):
    """Exception raised when a range used to launch a kernel is not well-formed.

    A non-well-formed range value is either empty or is not a list of ints.

    Args:
        kernel_name (str): The kernel function name.
    """

    def __init__(self, kernel_name) -> None:
        self.message = (
            f"Specified range to launch Kernel {kernel_name} is not "
            "well-formed. A range should be specified as a list, tuple, "
            "or an int using the [] (__getitem__) method of the kernel."
        )
        super().__init__(self.message)


class UnsupportedNumberOfRangeDimsError(Exception):
    """Exception raised when a range is created for a device that has more
    number of dimensions than is supported by the device.

    Args:
        kernel_name (str): The kernel function name.
        ndims (int): Rank of the errant range.
        max_work_item_dims (int): Maximum number of range dimensions supported
        by the device.
    """

    def __init__(self, kernel_name, ndims, max_work_item_dims) -> None:
        self.message = (
            f"Specified range for kernel {kernel_name} has {ndims} dimensions, "
            f"the device supports only {max_work_item_dims} dimensional "
            "ranges."
        )
        super().__init__(self.message)


class UnmatchedNumberOfRangeDimsError(Exception):
    """Exception raised when the global range and local range have different
    number of dimensions or rank.

    Args:
        kernel_name (str): The kernel function name.
        global_ndims (int): Rank of the global range.
        local_ndims (int): Rank of the local range.
    """

    def __init__(self, kernel_name, global_ndims, local_ndims) -> None:
        self.message = (
            f"Specified global_range for kernel {kernel_name} has "
            f"{global_ndims} dimensions, "
            f"while specified local_range with dimensions of {local_ndims} "
            "doesn't match with global_range."
        )
        super().__init__(self.message)


class UnsupportedWorkItemSizeError(Exception):
    """Exception raised when the number of work items requested for a
    specific dimension exceeds the number supported by the device.

    Args:
        kernel_name (str): The kernel function name.
        requested_work_items (int): Number of requested work items.
        supported_work_items (int): Supported number of work items.
    """

    def __init__(
        self, kernel_name, dim, requested_work_items, supported_work_items
    ) -> None:
        self.message = (
            f"Attempting to launch kernel {kernel_name} with "
            f"{requested_work_items} work items in dimension {dim} is not "
            f"supported. The device supports only {supported_work_items} "
            f"work items for dimension {dim}."
        )
        super().__init__(self.message)


class UnsupportedGroupWorkItemSizeError(Exception):
    """Exception raised when the value in a specific dimension of a global
    range is not evenly divisible by the value in the corresponding dimension
    in a local range.

    Args:
        kernel_name (str): The kernel function name.
        dim (int): Dimension where the mismatch was identified.
        work_groups (int): Number of requested work groups.
        work_items (int): Number of requested work items in the errant
        dimension of the local range.
    """

    def __init__(self, kernel_name, dim, work_groups, work_items) -> None:
        self.message = (
            f"Attempting to launch kernel {kernel_name} with "
            f"{work_groups} global work groups and {work_items} local work "
            f"items in dimension {dim} is not supported. The global work "
            "groups must be evenly divisible by the local work items."
        )
        super().__init__(self.message)


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.

    Compute-follows-data is a programming model that determines the execution
    device or queue of an array expression or kernel based on the arrays that
    are on the right hand side of the expression or are the arguments to the
    kernel function. The execution queue is deduced based on the device on
    which the array operands were allocated. Computation is required to occur
    on the same device where the arrays currently reside.

    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.
        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, *, 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 '
                "be deduced using compute follows data programming model. The "
                f"usm_ndarray arguments {usmarray_args} were not allocated "
                "on the same queue."
            )
        else:
            self.message = (
                f'Execution queue for kernel "{kernel_name}" could '
                "be deduced using compute follows data programming model. The "
                "kernel has no USMNdArray argument."
            )
        super().__init__(self.message)


class UnsupportedBackendError(Exception):
    """Exception raised when the target device is not supported by dpex.

    Presently only L0 and OpenCL devices are supported by numba_dpex. If the
    provided execution queue is for any other SYCL platform (e.g., Cuda) then
    it results in an UnsupportedBackendError.

    Args:
        kernel_name (str): Name of kernel where the error was raised.
        backend (str): name of the unsupported backend.
        supported_backends (List): The list of supported backends.
    """

    def __init__(self, kernel_name, backend, supported_backends) -> None:
        supported_backends_joined = ",".join(supported_backends)
        self.message = (
            f'Kernel "{kernel_name}" cannot be compiled for "{backend}". '
            f'Only "{supported_backends_joined}" backends are supported.'
        )
        super().__init__(self.message)


class UncompiledKernelError(Exception):
    """Exception raised when an attribute of a KernelInterface object is
    accessed before the object is compiled.

    Args:
        kernel_name (str): Name of kernel where the error was raised.
    """

    def __init__(self, kernel_name) -> None:
        self.message = (
            f'No LLVM module for kernel "{kernel_name}". '
            "Kernel might not be compiled yet."
        )
        super().__init__(self.message)


class UnreachableError(Exception):
    """Internal compiler error when an unreachable branch is taken somewhere in
    the compiler code.
    """

    def __init__(self) -> None:
        import sys
        import traceback

        _, _, tb = sys.exc_info()
        if tb:
            traceback.print_tb(tb)  # Fixed format
            tb_info = traceback.extract_tb(tb)
            filename, line, func, text = tb_info[-1]
            self.message = (
                f"Attempt to execute a unreachable code section on line {line} "
                f"in statement {text} in function {func} in the module "
                f"{filename}."
            )
        else:
            self.message = "Unreachable code executed."
        super().__init__(self.message)


class UnsupportedKernelArgumentError(Exception):
    """Exception raised when the type of a kernel argument is not supported by
    the compiler.

    Args:
        type (str): The type of the unsupported argument.
        value (object): The Python object passed as a kernel argument.
        kernel_name (str): Name of kernel where the error was raised.
    """

    def __init__(self, type, value, kernel_name="") -> None:
        self.message = (
            f"Argument {value} passed to kernel {kernel_name} is of an "
            f"unsupported type ({type})."
        )
        super().__init__(self.message)


class SUAIProtocolError(Exception):
    """Exception raised when an array-like object passed to a kernel is
    neither a NumPy array nor does it implement the __sycl_usm_array_interface__
    attribute.

    Args:
        kernel_name (str): Name of kernel where the error was raised.
        arg: Array-like object
    """

    def __init__(self, kernel_name, arg) -> None:
        self.message = (
            f'Array-like argument {arg} passed to kernel "{kernel_name}" '
            "is neither a NumPy array nor implement the "
            "__sycl_usm_array_interface__."
        )
        super().__init__(self.message)


class UnsupportedCompilationModeError(Exception):
    def __init__(self) -> None:
        self.message = (
            'The dpex compiler does not support the "force_pyobject" setting.'
        )
        super().__init__(self.message)


class InvalidKernelSpecializationError(Exception):
    """Exception raised when a the specialization argument types are not
    supported by the dpex kernel decorator.

    The exception is raised whenever an unsupported kernel argument is
    provided in the specialization signature passed to a dpex kernel decorator
    instance. For example, dpex kernels require arrays to be of USMNdArray type
    and no other Array type, such as NumPy ndarray, are supported. If the
    signature has an non USMNdArray Array type the exception is raised.

    Args:
        kernel_name (str): Name of kernel where the error was raised.
        invalid_sig: Unsupported signature.
        unsupported_argnum_list : The list of argument numbers that are
        unsupported.
    """

    def __init__(
        self, kernel_name, invalid_sig, unsupported_argnum_list
    ) -> None:
        unsupported = ",".join([str(i) for i in unsupported_argnum_list])
        self.message = (
            f"Kernel {kernel_name} cannot be specialized for "
            f'"{invalid_sig}". Arguments {unsupported} are not supported.'
        )

        super().__init__(self.message)


class MissingSpecializationError(Exception):
    """Exception raised when a specialized JitKernel was called with arguments
     that do not match any of the specialized versions of the JitKernel.

    Args:
        kernel_name (str): Name of kernel where the error was raised.
        sig: Unsupported argument types used to call a specialized JitKernel.
    """

    def __init__(self, kernel_name, argtypes) -> None:
        self.message = (
            f"No specialized version of the kernel {kernel_name} "
            f"exists for argument types: {argtypes}."
        )

        super().__init__(self.message)


class UnsupportedParforError(Exception):
    """Exception raised when a parfor node could not be lowered by Numba-dpex"""

    def __init__(self, extra_msg=None) -> None:
        self.message = "Expression cannot be offloaded"
        if extra_msg:
            self.message += " due to " + extra_msg
        super().__init__(self.message)


class IllegalIntEnumLiteralValueError(Exception):
    """Exception raised when an IntEnumLiteral is attempted to be created from
    a non FlagEnum attribute.
    """

    def __init__(self) -> None:
        self.message = (
            "An IntEnumLiteral can only be initialized from a FlagEnum member"
        )
        super().__init__(self.message)


class InternalError(Exception):
    """
    Exception raise when something in the internal compiler machinery failed.
    """

    def __init__(self, extra_msg=None) -> None:
        if extra_msg is None:
            self.message = "An internal compiler error happened and the "
            "compilation failed."
        else:
            self.message = extra_msg
        super().__init__(self.message)

1	# SPDX-FileCopyrightText: 2020 - 2024 Intel Corporation
2	#
3	# SPDX-License-Identifier: Apache-2.0
4
5	"""The module defines the custom error classes used in numba_dpex.	1✔
6	"""
7
8	from warnings import warn	1✔
9
10
11	class KernelHasReturnValueError(Exception):	1✔
12	"""Exception raised when a kernel function is defined with a return
13	statement.
14
15
16	@numba_dpex.kernel does not allow users to return any value. The
17	restriction is inline with the general ABI for device functions in OpenCL,
18	CUDA, and SYCL.
19
20	Args:
21	kernel_name: Name of the kernel function that caused the error.
22	return_type: Numba type representing the return value specified for
23	the kernel function.
24	"""
25
26	def __init__(self, kernel_name, return_type, sig=None) -> None:	1✔
27	self.return_type = return_type	1✔
28	if sig:	1!
29	self.message = (	×
30	f'Specialized kernel signature "{sig}" has a return value '
31	f'of type "{return_type}". '
32	"A kernel must have a void return type."
33	)
34	else:
35	self.message = (	1✔
36	f'Kernel "{kernel_name}" has a return value '
37	f'of type "{return_type}". '
38	"A kernel must have a void return type."
39	)
40
41	super().__init__(self.message)	1✔
42
43
44	class InvalidKernelLaunchArgsError(Exception):	1✔
45	"""Exception raised when a kernel is dispatched with insufficient or
46	incorrect launch arguments.
47
48	A global range value is needed to submit a kernel to an execution queue. The
49	global range provides the number of work items that the SYCL runtime should
50	create to execute the kernel. The exception is raised if a kernel is
51	dispatched without specifying a valid global range.
52
53	Args:
54	kernel_name (str): The kernel function name.
55	"""
56
57	def __init__(self, kernel_name):	1✔
58	self.message = (	×
59	"Invalid global and local range arguments specified for launching "
60	f' the Kernel "{kernel_name}". Refer documentation for details.'
61	)
62	super().__init__(self.message)	×
63
64
65	class UnknownGlobalRangeError(Exception):	1✔
66	"""Exception raised when a kernel is launched without specifying a global
67	range.
68
69	Args:
70	kernel_name (str): The kernel function name.
71	"""
72
73	def __init__(self, kernel_name) -> None:	1✔
74	self.message = (	×
75	"No global range specified for launching the Kernel "
76	f'"{kernel_name}". '
77	"A valid global range tuple is needed to launch a kernel."
78	)
79	super().__init__(self.message)	×
80
81
82	class IllegalRangeValueError(Exception):	1✔
83	"""Exception raised when a range used to launch a kernel is not well-formed.
84
85	A non-well-formed range value is either empty or is not a list of ints.
86
87	Args:
88	kernel_name (str): The kernel function name.
89	"""
90
91	def __init__(self, kernel_name) -> None:	1✔
92	self.message = (	×
93	f"Specified range to launch Kernel {kernel_name} is not "
94	"well-formed. A range should be specified as a list, tuple, "
95	"or an int using the [] (__getitem__) method of the kernel."
96	)
97	super().__init__(self.message)	×
98
99
100	class UnsupportedNumberOfRangeDimsError(Exception):	1✔
101	"""Exception raised when a range is created for a device that has more
102	number of dimensions than is supported by the device.
103
104	Args:
105	kernel_name (str): The kernel function name.
106	ndims (int): Rank of the errant range.
107	max_work_item_dims (int): Maximum number of range dimensions supported
108	by the device.
109	"""
110
111	def __init__(self, kernel_name, ndims, max_work_item_dims) -> None:	1✔
112	self.message = (	×
113	f"Specified range for kernel {kernel_name} has {ndims} dimensions, "
114	f"the device supports only {max_work_item_dims} dimensional "
115	"ranges."
116	)
117	super().__init__(self.message)	×
118
119
120	class UnmatchedNumberOfRangeDimsError(Exception):	1✔
121	"""Exception raised when the global range and local range have different
122	number of dimensions or rank.
123
124	Args:
125	kernel_name (str): The kernel function name.
126	global_ndims (int): Rank of the global range.
127	local_ndims (int): Rank of the local range.
128	"""
129
130	def __init__(self, kernel_name, global_ndims, local_ndims) -> None:	1✔
131	self.message = (	×
132	f"Specified global_range for kernel {kernel_name} has "
133	f"{global_ndims} dimensions, "
134	f"while specified local_range with dimensions of {local_ndims} "
135	"doesn't match with global_range."
136	)
137	super().__init__(self.message)	×
138
139
140	class UnsupportedWorkItemSizeError(Exception):	1✔
141	"""Exception raised when the number of work items requested for a
142	specific dimension exceeds the number supported by the device.
143
144	Args:
145	kernel_name (str): The kernel function name.
146	requested_work_items (int): Number of requested work items.
147	supported_work_items (int): Supported number of work items.
148	"""
149
150	def __init__(	1✔
151	self, kernel_name, dim, requested_work_items, supported_work_items
152	) -> None:
153	self.message = (	×
154	f"Attempting to launch kernel {kernel_name} with "
155	f"{requested_work_items} work items in dimension {dim} is not "
156	f"supported. The device supports only {supported_work_items} "
157	f"work items for dimension {dim}."
158	)
159	super().__init__(self.message)	×
160
161
162	class UnsupportedGroupWorkItemSizeError(Exception):	1✔
163	"""Exception raised when the value in a specific dimension of a global
164	range is not evenly divisible by the value in the corresponding dimension
165	in a local range.
166
167	Args:
168	kernel_name (str): The kernel function name.
169	dim (int): Dimension where the mismatch was identified.
170	work_groups (int): Number of requested work groups.
171	work_items (int): Number of requested work items in the errant
172	dimension of the local range.
173	"""
174
175	def __init__(self, kernel_name, dim, work_groups, work_items) -> None:	1✔
176	self.message = (	×
177	f"Attempting to launch kernel {kernel_name} with "
178	f"{work_groups} global work groups and {work_items} local work "
179	f"items in dimension {dim} is not supported. The global work "
180	"groups must be evenly divisible by the local work items."
181	)
182	super().__init__(self.message)	×
183
184
185	class ExecutionQueueInferenceError(Exception):	1✔
186	"""Exception raised when an execution queue for a given array expression or
187	a kernel function could not be deduced using the compute-follows-data
188	programming model.
189
190	Compute-follows-data is a programming model that determines the execution
191	device or queue of an array expression or kernel based on the arrays that
192	are on the right hand side of the expression or are the arguments to the
193	kernel function. The execution queue is deduced based on the device on
194	which the array operands were allocated. Computation is required to occur
195	on the same device where the arrays currently reside.
196
197	A ExecutionQueueInferenceError is raised when the execution queue using
198	compute-follows-data rules could not be deduced. It may happen when arrays
199	that have a device attribute such as ``dpctl.tensor.usm_ndarray`` are mixed
200	with host arrays such as ``numpy.ndarray``. The error may also be raised if
201	the array operands are allocated on different devices.
202
203	Args:
204	kernel_name : Name of the kernel function for which the error occurred.
205	usmarray_argnum_list: The list of ``dpctl.tensor.usm_ndarray`` arguments
206	identified by the argument position that caused the error.
207	"""
208
209	def __init__(self, kernel_name, *, usmarray_argnum_list) -> None:	1✔
210	if usmarray_argnum_list is not None:	1✔
211	usmarray_args = ",".join([str(i) for i in usmarray_argnum_list])	1✔
212	self.message = (	1✔
213	f'Execution queue for kernel "{kernel_name}" could '
214	"be deduced using compute follows data programming model. The "
215	f"usm_ndarray arguments {usmarray_args} were not allocated "
216	"on the same queue."
217	)
218	else:
219	self.message = (	1✔
220	f'Execution queue for kernel "{kernel_name}" could '
221	"be deduced using compute follows data programming model. The "
222	"kernel has no USMNdArray argument."
223	)
224	super().__init__(self.message)	1✔
225
226
227	class UnsupportedBackendError(Exception):	1✔
228	"""Exception raised when the target device is not supported by dpex.
229
230	Presently only L0 and OpenCL devices are supported by numba_dpex. If the
231	provided execution queue is for any other SYCL platform (e.g., Cuda) then
232	it results in an UnsupportedBackendError.
233
234	Args:
235	kernel_name (str): Name of kernel where the error was raised.
236	backend (str): name of the unsupported backend.
237	supported_backends (List): The list of supported backends.
238	"""
239
240	def __init__(self, kernel_name, backend, supported_backends) -> None:	1✔
241	supported_backends_joined = ",".join(supported_backends)	×
242	self.message = (	×
243	f'Kernel "{kernel_name}" cannot be compiled for "{backend}". '
244	f'Only "{supported_backends_joined}" backends are supported.'
245	)
246	super().__init__(self.message)	×
247
248
249	class UncompiledKernelError(Exception):	1✔
250	"""Exception raised when an attribute of a KernelInterface object is
251	accessed before the object is compiled.
252
253	Args:
254	kernel_name (str): Name of kernel where the error was raised.
255	"""
256
257	def __init__(self, kernel_name) -> None:	1✔
258	self.message = (	×
259	f'No LLVM module for kernel "{kernel_name}". '
260	"Kernel might not be compiled yet."
261	)
262	super().__init__(self.message)	×
263
264
265	class UnreachableError(Exception):	1✔
266	"""Internal compiler error when an unreachable branch is taken somewhere in
267	the compiler code.
268	"""
269
270	def __init__(self) -> None:	1✔
271	import sys	×
272	import traceback	×
273
274	_, _, tb = sys.exc_info()	×
275	if tb:	×
276	traceback.print_tb(tb) # Fixed format	×
277	tb_info = traceback.extract_tb(tb)	×
278	filename, line, func, text = tb_info[-1]	×
279	self.message = (	×
280	f"Attempt to execute a unreachable code section on line {line} "
281	f"in statement {text} in function {func} in the module "
282	f"{filename}."
283	)
284	else:
285	self.message = "Unreachable code executed."	×
286	super().__init__(self.message)	×
287
288
289	class UnsupportedKernelArgumentError(Exception):	1✔
290	"""Exception raised when the type of a kernel argument is not supported by
291	the compiler.
292
293	Args:
294	type (str): The type of the unsupported argument.
295	value (object): The Python object passed as a kernel argument.
296	kernel_name (str): Name of kernel where the error was raised.
297	"""
298
299	def __init__(self, type, value, kernel_name="") -> None:	1✔
UNCOV 300	self.message = (	×
301	f"Argument {value} passed to kernel {kernel_name} is of an "
302	f"unsupported type ({type})."
303	)
UNCOV 304	super().__init__(self.message)	×
305
306
307	class SUAIProtocolError(Exception):	1✔
308	"""Exception raised when an array-like object passed to a kernel is
309	neither a NumPy array nor does it implement the __sycl_usm_array_interface__
310	attribute.
311
312	Args:
313	kernel_name (str): Name of kernel where the error was raised.
314	arg: Array-like object
315	"""
316
317	def __init__(self, kernel_name, arg) -> None:	1✔
318	self.message = (	×
319	f'Array-like argument {arg} passed to kernel "{kernel_name}" '
320	"is neither a NumPy array nor implement the "
321	"__sycl_usm_array_interface__."
322	)
323	super().__init__(self.message)	×
324
325
326	class UnsupportedCompilationModeError(Exception):	1✔
327	def __init__(self) -> None:	1✔
328	self.message = (	×
329	'The dpex compiler does not support the "force_pyobject" setting.'
330	)
331	super().__init__(self.message)	×
332
333
334	class InvalidKernelSpecializationError(Exception):	1✔
335	"""Exception raised when a the specialization argument types are not
336	supported by the dpex kernel decorator.
337
338	The exception is raised whenever an unsupported kernel argument is
339	provided in the specialization signature passed to a dpex kernel decorator
340	instance. For example, dpex kernels require arrays to be of USMNdArray type
341	and no other Array type, such as NumPy ndarray, are supported. If the
342	signature has an non USMNdArray Array type the exception is raised.
343
344	Args:
345	kernel_name (str): Name of kernel where the error was raised.
346	invalid_sig: Unsupported signature.
347	unsupported_argnum_list : The list of argument numbers that are
348	unsupported.
349	"""
350
351	def __init__(	1✔
352	self, kernel_name, invalid_sig, unsupported_argnum_list
353	) -> None:
354	unsupported = ",".join([str(i) for i in unsupported_argnum_list])	1✔
355	self.message = (	1✔
356	f"Kernel {kernel_name} cannot be specialized for "
357	f'"{invalid_sig}". Arguments {unsupported} are not supported.'
358	)
359
360	super().__init__(self.message)	1✔
361
362
363	class MissingSpecializationError(Exception):	1✔
364	"""Exception raised when a specialized JitKernel was called with arguments
365	that do not match any of the specialized versions of the JitKernel.
366
367	Args:
368	kernel_name (str): Name of kernel where the error was raised.
369	sig: Unsupported argument types used to call a specialized JitKernel.
370	"""
371
372	def __init__(self, kernel_name, argtypes) -> None:	1✔
373	self.message = (	×
374	f"No specialized version of the kernel {kernel_name} "
375	f"exists for argument types: {argtypes}."
376	)
377
378	super().__init__(self.message)	×
379
380
381	class UnsupportedParforError(Exception):	1✔
382	"""Exception raised when a parfor node could not be lowered by Numba-dpex"""
383
384	def __init__(self, extra_msg=None) -> None:	1✔
385	self.message = "Expression cannot be offloaded"	×
386	if extra_msg:	×
387	self.message += " due to " + extra_msg	×
388	super().__init__(self.message)	×
389
390
391	class IllegalIntEnumLiteralValueError(Exception):	1✔
392	"""Exception raised when an IntEnumLiteral is attempted to be created from
393	a non FlagEnum attribute.
394	"""
395
396	def __init__(self) -> None:	1✔
397	self.message = (	1✔
398	"An IntEnumLiteral can only be initialized from a FlagEnum member"
399	)
400	super().__init__(self.message)	1✔
401
402
403	class InternalError(Exception):	1✔
404	"""
405	Exception raise when something in the internal compiler machinery failed.
406	"""
407
408	def __init__(self, extra_msg=None) -> None:	1✔
409	if extra_msg is None:	×
410	self.message = "An internal compiler error happened and the "	×
411	"compilation failed."	×
412	else:
413	self.message = extra_msg	×
414	super().__init__(self.message)	×

IntelPython / numba-dpex / 8386463695

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous