9215040431

Committed 23 May 2024 09:21PM UTC coverage: 86.624% (+0.1%) from 86.5%

Build # 9215040431

Build Type

Pull #1464

github

Committed by

web-flow

Commit Message

Merge 4a5294826 into b9436c165

Pull Request Pull Request #1464: Fix/dpnp mp

Run Details

664 of 747 branches covered (88.89%)

Branch coverage included in aggregate %.

34 of 40 new or added lines in 2 files covered. (85.0%)

12 existing lines in 2 files now uncovered.

5456 of 6318 relevant lines covered (86.36%)

0.86 hits per line

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

88.68

/numba_dpex/numba_patches/patch_is_ufunc.py

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

import logging

import dpnp
import numpy as np

from numba_dpex.core.typing import dpnpdecl


def patch():
    patch_is_ufunc()
    patch_ufuncs()


def patch_is_ufunc():
    """Patches the numba.np.ufunc.array_exprs._is_ufunc function to make it
    possible to support dpnp universal functions (ufuncs).

    The extra condition is the check for the "is_dpnp_ufunc" attribute to
    identify a non-NumPy ufunc.
    """
    import numpy
    from numba.np.ufunc.dufunc import DUFunc

    def _is_ufunc(func):
        return isinstance(func, (numpy.ufunc, DUFunc)) or hasattr(
            func, "is_dpnp_ufunc"
        )

    from numba.np.ufunc import array_exprs

    array_exprs._is_ufunc = _is_ufunc


def patch_ufuncs():
    failed_dpnpop_types_lst = []

    op = getattr(dpnp, "erf")
    op.nin = 1
    op.nout = 1
    op.nargs = 2
    op.types = ["f->f", "d->d"]
    op.is_dpnp_ufunc = True

    for ufuncop in dpnpdecl.supported_ufuncs:
        if ufuncop == "erf":
            continue

        dpnpop = getattr(dpnp, ufuncop)
        npop = getattr(np, ufuncop)

        if not hasattr(dpnpop, "nin"):
            dpnpop.nin = npop.nin
        if not hasattr(dpnpop, "nout"):
            dpnpop.nout = npop.nout
        if not hasattr(dpnpop, "nargs"):
            dpnpop.nargs = dpnpop.nin + dpnpop.nout

        # Check if the dpnp operation has a `types` attribute and if an
        # AttributeError gets raised then "monkey patch" the attribute from
        # numpy. If the attribute lookup raised a ValueError, it indicates
        # that dpnp could not be resolve the supported types for the
        # operation. Dpnp will fail to resolve the `types` if no SYCL
        # devices are available on the system. For such a scenario, we log
        # dpnp operations for which the ValueError happened and print them
        # as a user-level warning. It is done this way so that the failure
        # to load the dpnpdecl registry due to the ValueError does not
        # impede a user from importing numba-dpex.
        try:
            dpnpop.types
        except ValueError:
            failed_dpnpop_types_lst.append(ufuncop)
        except AttributeError:
            dpnpop.types = npop.types

        dpnpop.is_dpnp_ufunc = True

    if len(failed_dpnpop_types_lst) > 0:
        try:
            getattr(dpnp, failed_dpnpop_types_lst[0]).types
        except ValueError:
            ops = " ".join(failed_dpnpop_types_lst)
            logging.exception(
                "The types attribute for the following dpnp ops could not be "
                f"determined: {ops}"
            )

        # if not hasattr(dpnpop, "nin"):
        #     print(f"nin not implemented: {ufuncop}")
        # if ufuncop in {
        #     "fmod",
        #     "mod",
        #     "fabs",
        #     "deg2rad",
        #     "rad2deg",
        #     "degrees",
        #     "radians",
        #     "fmax",
        #     "fmin"
        # }:
        #     dpnpop.nin = npop.nin
        # dpnpop.nout = npop.nout
        # dpnpop.nargs = dpnpop.nin + dpnpop.nout
        # dpnpop.types = npop.types
        # else:
        # print(hasattr(dpnpop, "types"))
    # print(hasattr(dpnp.add, "types"))

1	# SPDX-FileCopyrightText: 2020 - 2024 Intel Corporation
2	#
3	# SPDX-License-Identifier: Apache-2.0
4
5	import logging	1✔
6
7	import dpnp	1✔
8	import numpy as np	1✔
9
10	from numba_dpex.core.typing import dpnpdecl	1✔
11
12
13	def patch():	1✔
14	patch_is_ufunc()	1✔
15	patch_ufuncs()	1✔
16
17
18	def patch_is_ufunc():	1✔
19	"""Patches the numba.np.ufunc.array_exprs._is_ufunc function to make it
20	possible to support dpnp universal functions (ufuncs).
21
22	The extra condition is the check for the "is_dpnp_ufunc" attribute to
23	identify a non-NumPy ufunc.
24	"""
25	import numpy	1✔
26	from numba.np.ufunc.dufunc import DUFunc	1✔
27
28	def _is_ufunc(func):	1✔
29	return isinstance(func, (numpy.ufunc, DUFunc)) or hasattr(	1✔
30	func, "is_dpnp_ufunc"
31	)
32
33	from numba.np.ufunc import array_exprs	1✔
34
35	array_exprs._is_ufunc = _is_ufunc	1✔
36
37
38	def patch_ufuncs():	1✔
39	failed_dpnpop_types_lst = []	1✔
40
41	op = getattr(dpnp, "erf")	1✔
42	op.nin = 1	1✔
43	op.nout = 1	1✔
44	op.nargs = 2	1✔
45	op.types = ["f->f", "d->d"]	1✔
46	op.is_dpnp_ufunc = True	1✔
47
48	for ufuncop in dpnpdecl.supported_ufuncs:	1✔
49	if ufuncop == "erf":	1✔
50	continue	1✔
51
52	dpnpop = getattr(dpnp, ufuncop)	1✔
53	npop = getattr(np, ufuncop)	1✔
54
55	if not hasattr(dpnpop, "nin"):	1✔
56	dpnpop.nin = npop.nin	1✔
57	if not hasattr(dpnpop, "nout"):	1✔
58	dpnpop.nout = npop.nout	1✔
59	if not hasattr(dpnpop, "nargs"):	1✔
60	dpnpop.nargs = dpnpop.nin + dpnpop.nout	1✔
61
62	# Check if the dpnp operation has a `types` attribute and if an
63	# AttributeError gets raised then "monkey patch" the attribute from
64	# numpy. If the attribute lookup raised a ValueError, it indicates
65	# that dpnp could not be resolve the supported types for the
66	# operation. Dpnp will fail to resolve the `types` if no SYCL
67	# devices are available on the system. For such a scenario, we log
68	# dpnp operations for which the ValueError happened and print them
69	# as a user-level warning. It is done this way so that the failure
70	# to load the dpnpdecl registry due to the ValueError does not
71	# impede a user from importing numba-dpex.
72	try:	1✔
73	dpnpop.types	1✔
74	except ValueError:	1✔
NEW UNCOV 75	failed_dpnpop_types_lst.append(ufuncop)	×
76	except AttributeError:	1✔
77	dpnpop.types = npop.types	1✔
78
79	dpnpop.is_dpnp_ufunc = True	1✔
80
81	if len(failed_dpnpop_types_lst) > 0:	1✔
NEW UNCOV 82	try:	×
NEW UNCOV 83	getattr(dpnp, failed_dpnpop_types_lst[0]).types	×
NEW UNCOV 84	except ValueError:	×
NEW UNCOV 85	ops = " ".join(failed_dpnpop_types_lst)	×
NEW UNCOV 86	logging.exception(	×
87	"The types attribute for the following dpnp ops could not be "
88	f"determined: {ops}"
89	)
90
91	# if not hasattr(dpnpop, "nin"):
92	# print(f"nin not implemented: {ufuncop}")
93	# if ufuncop in {
94	# "fmod",
95	# "mod",
96	# "fabs",
97	# "deg2rad",
98	# "rad2deg",
99	# "degrees",
100	# "radians",
101	# "fmax",
102	# "fmin"
103	# }:
104	# dpnpop.nin = npop.nin
105	# dpnpop.nout = npop.nout
106	# dpnpop.nargs = dpnpop.nin + dpnpop.nout
107	# dpnpop.types = npop.types
108	# else:
109	# print(hasattr(dpnpop, "types"))
110	# print(hasattr(dpnp.add, "types"))

IntelPython / numba-dpex / 9215040431

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