4997420547

Build # 4997420547

Build Type

github

Committed by GitHub

Commit Message

Merge 09fbf4f96 into 5c186911f

Pull Request Pull Request #999: Enable dpnp parfor reduction

Run Details

1790 of 3458 branches covered (51.76%)

Branch coverage included in aggregate %.

586 of 627 new or added lines in 11 files covered. (93.46%)

32 existing lines in 1 file now uncovered.

5988 of 9437 relevant lines covered (63.45%)

0.63 hits per line

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

44.44

/numba_dpex/core/passes/passes.py

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

import warnings
from contextlib import contextmanager

import numpy as np
from numba.core import errors, funcdesc, ir, typing, utils
from numba.core.compiler_machinery import (
    AnalysisPass,
    FunctionPass,
    LoweringPass,
    register_pass,
)
from numba.core.ir_utils import remove_dels
from numba.core.typed_passes import NativeLowering
from numba.parfors.parfor import ParforPass as _numba_parfor_ParforPass
from numba.parfors.parfor import PreParforPass as _numba_parfor_PreParforPass
from numba.parfors.parfor import swap_functions_map

from numba_dpex import config

from .lowerer import DPEXLowerer
from .parfor import Parfor
from .parfor import ParforFusionPass as _parfor_ParforFusionPass
from .parfor import ParforPass as _parfor_ParforPass
from .parfor import ParforPreLoweringPass as _parfor_ParforPreLoweringPass


@register_pass(mutates_CFG=True, analysis_only=False)
class ConstantSizeStaticLocalMemoryPass(FunctionPass):
    _name = "dpex_constant_size_static_local_memory_pass"

    def __init__(self):
        FunctionPass.__init__(self)

    def run_pass(self, state):
        """
        Preprocessing for data-parallel computations.
        """
        # Ensure we have an IR and type information.
        assert state.func_ir
        func_ir = state.func_ir

        _DEBUG = False

        if _DEBUG:
            print(
                "Checks if size of OpenCL local address space alloca is a "
                + "compile-time constant.".center(80, "-")
            )
            print(func_ir.dump())

        work_list = list(func_ir.blocks.items())
        while work_list:
            label, block = work_list.pop()
            for i, instr in enumerate(block.body):
                if isinstance(instr, ir.Assign):
                    expr = instr.value
                    if isinstance(expr, ir.Expr):
                        if expr.op == "call":
                            find_var = block.find_variable_assignment(
                                expr.func.name
                            )
                            if find_var is not None:
                                call_node = find_var.value
                                if (
                                    isinstance(call_node, ir.Expr)
                                    and call_node.op == "getattr"
                                    and call_node.attr == "array"
                                ):
                                    # let's check if it is from numba_dpex.local
                                    attr_node = block.find_variable_assignment(
                                        call_node.value.name
                                    ).value
                                    if (
                                        isinstance(attr_node, ir.Expr)
                                        and attr_node.op == "getattr"
                                        and attr_node.attr == "local"
                                    ):
                                        arg = None
                                        # at first look in keyword arguments to
                                        # get the shape, which has to be
                                        # constant
                                        if expr.kws:
                                            for _arg in expr.kws:
                                                if _arg[0] == "shape":
                                                    arg = _arg[1]

                                        if not arg:
                                            arg = expr.args[0]

                                        error = False
                                        # arg can be one constant or a tuple of
                                        # constant items
                                        arg_type = func_ir.get_definition(
                                            arg.name
                                        )
                                        if isinstance(arg_type, ir.Expr):
                                            # we have a tuple
                                            for item in arg_type.items:
                                                if not isinstance(
                                                    func_ir.get_definition(
                                                        item.name
                                                    ),
                                                    ir.Const,
                                                ):
                                                    error = True
                                                    break

                                        else:
                                            if not isinstance(
                                                func_ir.get_definition(
                                                    arg.name
                                                ),
                                                ir.Const,
                                            ):
                                                error = True
                                                break

                                        if error:
                                            warnings.warn_explicit(
                                                "The size of the Local memory "
                                                + "has to be constant",
                                                errors.NumbaError,
                                                state.func_id.filename,
                                                state.func_id.firstlineno,
                                            )
                                            raise

        if config.DEBUG or config.DUMP_IR:
            name = state.func_ir.func_id.func_qualname
            print(("IR DUMP: %s" % name).center(80, "-"))
            state.func_ir.dump()

        return True


@register_pass(mutates_CFG=True, analysis_only=False)
class PreParforPass(FunctionPass):
    _name = "dpex_pre_parfor_pass"

    def __init__(self):
        FunctionPass.__init__(self)

    def run_pass(self, state):
        """
        Preprocessing for data-parallel computations.
        """

        # Ensure we have an IR and type information.
        assert state.func_ir
        functions_map = swap_functions_map.copy()
        # FIXME: remove once reduction is implemented
        functions_map.pop(("dot", "numpy"), None)
        functions_map.pop(("sum", "numpy"), None)
        functions_map.pop(("prod", "numpy"), None)
        functions_map.pop(("argmax", "numpy"), None)
        functions_map.pop(("max", "numpy"), None)
        functions_map.pop(("argmin", "numpy"), None)
        functions_map.pop(("min", "numpy"), None)
        functions_map.pop(("mean", "numpy"), None)

        preparfor_pass = _numba_parfor_PreParforPass(
            state.func_ir,
            state.type_annotation.typemap,
            state.type_annotation.calltypes,
            state.typingctx,
            state.targetctx,
            state.flags.auto_parallel,
            state.parfor_diagnostics.replaced_fns,
            replace_functions_map=functions_map,
        )

        preparfor_pass.run()

        if config.DEBUG or config.DUMP_IR:
            name = state.func_ir.func_id.func_qualname
            print(("IR DUMP: %s" % name).center(80, "-"))
            state.func_ir.dump()

        return True


@register_pass(mutates_CFG=True, analysis_only=False)
class ParforPass(FunctionPass):
    _name = "dpex_parfor_pass"

    def __init__(self):
        FunctionPass.__init__(self)

    def run_pass(self, state):
        """
        Convert data-parallel computations into Parfor nodes
        """
        # Ensure we have an IR and type information.
        assert state.func_ir
        parfor_pass = _numba_parfor_ParforPass(
            state.func_ir,
            state.type_annotation.typemap,
            state.type_annotation.calltypes,
            state.return_type,
            state.typingctx,
            state.targetctx,
            state.flags.auto_parallel,
            state.flags,
            state.metadata,
            state.parfor_diagnostics,
        )

        parfor_pass.run()

        if config.DEBUG or config.DUMP_IR:
            name = state.func_ir.func_id.func_qualname
            print(("IR DUMP: %s" % name).center(80, "-"))
            state.func_ir.dump()

        return True


# this is here so it pickles and for no other reason
def _reload_parfors():
    """Reloader for cached parfors"""
    # Re-initialize the parallel backend when load from cache.
    from numba.np.ufunc.parallel import _launch_threads

    _launch_threads()


@register_pass(mutates_CFG=True, analysis_only=False)
class SplitParforPass(FunctionPass):
    _name = "dpex_parfor_pass"

    def __init__(self):
        FunctionPass.__init__(self)

    def run_pass(self, state):
        """
        Convert data-parallel computations into Parfor nodes
        """
        # Ensure we have an IR and type information.
        assert state.func_ir
        parfor_pass = _parfor_ParforPass(
            state.func_ir,
            state.typemap,
            state.calltypes,
            state.return_type,
            state.typingctx,
            state.targetctx,
            state.flags.auto_parallel,
            state.flags,
            state.metadata,
            state.parfor_diagnostics,
        )
        parfor_pass.run()

        # check the parfor pass worked and warn if it didn't
        has_parfor = False
        for blk in state.func_ir.blocks.values():
            for stmnt in blk.body:
                if isinstance(stmnt, Parfor):
                    has_parfor = True
                    break
            else:
                continue
            break

        if not has_parfor:
            # parfor calls the compiler chain again with a string
            if not (
                config.DISABLE_PERFORMANCE_WARNINGS
                or state.func_ir.loc.filename == "<string>"
            ):
                url = (
                    "https://numba.readthedocs.io/en/stable/user/"
                    "parallel.html#diagnostics"
                )
                msg = (
                    "\nThe keyword argument 'parallel=True' was specified "
                    "but no transformation for parallel execution was "
                    "possible.\n\nTo find out why, try turning on parallel "
                    "diagnostics, see %s for help." % url
                )
                warnings.warn(
                    errors.NumbaPerformanceWarning(msg, state.func_ir.loc)
                )

        # Add reload function to initialize the parallel backend.
        state.reload_init.append(_reload_parfors)
        return True


@register_pass(mutates_CFG=True, analysis_only=False)
class ParforFusionPass(FunctionPass):
    _name = "parfor_fusion_pass"

    def __init__(self):
        FunctionPass.__init__(self)

    def run_pass(self, state):
        """
        Do fusion of parfor nodes.
        """
        # Ensure we have an IR and type information.
        assert state.func_ir
        parfor_pass = _parfor_ParforFusionPass(
            state.func_ir,
            state.typemap,
            state.calltypes,
            state.return_type,
            state.typingctx,
            state.targetctx,
            state.flags.auto_parallel,
            state.flags,
            state.metadata,
            state.parfor_diagnostics,
        )
        parfor_pass.run()

        return True


@register_pass(mutates_CFG=True, analysis_only=False)
class ParforPreLoweringPass(FunctionPass):
    _name = "parfor_prelowering_pass"

    def __init__(self):
        FunctionPass.__init__(self)

    def run_pass(self, state):
        """
        Prepare parfors for lowering.
        """
        # Ensure we have an IR and type information.
        assert state.func_ir
        parfor_pass = _parfor_ParforPreLoweringPass(
            state.func_ir,
            state.typemap,
            state.calltypes,
            state.return_type,
            state.typingctx,
            state.targetctx,
            state.flags.auto_parallel,
            state.flags,
            state.metadata,
            state.parfor_diagnostics,
        )
        parfor_pass.run()

        return True


@contextmanager
def fallback_context(state, msg):
    """
    Wraps code that would signal a fallback to object mode
    """
    try:
        yield
    except Exception as e:
        if not state.status.can_fallback:
            raise
        else:
            if utils.PYVERSION >= (3,):
                # Clear all references attached to the traceback
                e = e.with_traceback(None)
            # this emits a warning containing the error message body in the
            # case of fallback from npm to objmode
            loop_lift = "" if state.flags.enable_looplift else "OUT"
            msg_rewrite = (
                "\nCompilation is falling back to object mode "
                "WITH%s looplifting enabled because %s" % (loop_lift, msg)
            )
            warnings.warn_explicit(
                "%s due to: %s" % (msg_rewrite, e),
                errors.NumbaWarning,
                state.func_id.filename,
                state.func_id.firstlineno,
            )
            raise


@register_pass(mutates_CFG=True, analysis_only=False)
class DpexLowering(LoweringPass):
    _name = "dpex_lowering"

    def __init__(self):
        LoweringPass.__init__(self)

    def run_pass(self, state):
        if state.library is None:
            codegen = state.targetctx.codegen()
            state.library = codegen.create_library(state.func_id.func_qualname)
            # Enable object caching upfront, so that the library can
            # be later serialized.
            state.library.enable_object_caching()

        targetctx = state.targetctx

        library = state.library
        interp = state.func_ir
        typemap = state.typemap
        restype = state.return_type
        calltypes = state.calltypes
        flags = state.flags
        metadata = state.metadata

        msg = "Function %s failed at nopython " "mode lowering" % (
            state.func_id.func_name,
        )
        with fallback_context(state, msg):
            kwargs = {}

            # for support numba 0.54 and <=0.55.0dev0=*_469
            if hasattr(flags, "get_mangle_string"):
                kwargs["abi_tags"] = flags.get_mangle_string()
            # Lowering
            fndesc = (
                funcdesc.PythonFunctionDescriptor.from_specialized_function(
                    interp,
                    typemap,
                    restype,
                    calltypes,
                    mangler=targetctx.mangler,
                    inline=flags.forceinline,
                    noalias=flags.noalias,
                    **kwargs,
                )
            )

            with targetctx.push_code_library(library):
                lower = DPEXLowerer(
                    targetctx, library, fndesc, interp, metadata=metadata
                )
                lower.lower()
                if not flags.no_cpython_wrapper:
                    lower.create_cpython_wrapper(flags.release_gil)

                env = lower.env
                call_helper = lower.call_helper
                del lower

            from numba.core.compiler import _LowerResult  # TODO: move this

            if flags.no_compile:
                state["cr"] = _LowerResult(
                    fndesc, call_helper, cfunc=None, env=env
                )
            else:
                # Prepare for execution
                cfunc = targetctx.get_executable(library, fndesc, env)
                # Insert native function for use by other jitted-functions.
                # We also register its library to allow for inlining.
                targetctx.insert_user_function(cfunc, fndesc, [library])
                state["cr"] = _LowerResult(
                    fndesc, call_helper, cfunc=cfunc, env=env
                )

        return True


@register_pass(mutates_CFG=True, analysis_only=False)
class NoPythonBackend(FunctionPass):
    _name = "dpex_nopython_backend"

    def __init__(self):
        FunctionPass.__init__(self)

    def run_pass(self, state):
        """
        Back-end: Generate LLVM IR from Numba IR, compile to machine code
        """

        lowered = state["cr"]
        signature = typing.signature(state.return_type, *state.args)

        from numba.core.compiler import compile_result

        state.cr = compile_result(
            typing_context=state.typingctx,
            target_context=state.targetctx,
            entry_point=lowered.cfunc,
            typing_error=state.status.fail_reason,
            type_annotation=state.type_annotation,
            library=state.library,
            call_helper=lowered.call_helper,
            signature=signature,
            objectmode=False,
            lifted=state.lifted,
            fndesc=lowered.fndesc,
            environment=lowered.env,
            metadata=state.metadata,
            reload_init=state.reload_init,
        )

        remove_dels(state.func_ir.blocks)

        return True


@register_pass(mutates_CFG=False, analysis_only=True)
class DumpParforDiagnostics(AnalysisPass):
    _name = "dpex_dump_parfor_diagnostics"

    def __init__(self):
        AnalysisPass.__init__(self)

    def run_pass(self, state):
        # if state.flags.auto_parallel.enabled, add a condition flag for kernels
        if config.OFFLOAD_DIAGNOSTICS:
            if state.parfor_diagnostics is not None:
                state.parfor_diagnostics.dump(config.PARALLEL_DIAGNOSTICS)
            else:
                raise RuntimeError("Diagnostics failed.")
        return True


@register_pass(mutates_CFG=False, analysis_only=True)
class QualNameDisambiguationLowering(NativeLowering):
    """Qualified name disambiguation lowering pass

    If there are multiple @func decorated functions exist inside
    another @func decorated block, the numba compiler machinery
    creates same qualified names for different compiled function.
    Therefore, we utilize `unique_name` to resolve the ambiguity.

    Args:
        NativeLowering (CompilerPass): Superclass from which this
        class has been inherited.

    Returns:
        bool: True if `run_pass()` of the superclass is successful.
    """

    _name = "qual-name-disambiguation-lowering"

    def run_pass(self, state):
        qual_name = state.func_id.func_qualname
        state.func_id.func_qualname = state.func_id.unique_name
        ret = NativeLowering.run_pass(self, state)
        state.func_id.func_qualname = qual_name
        return ret

1	# SPDX-FileCopyrightText: 2020 - 2023 Intel Corporation
2	#
3	# SPDX-License-Identifier: Apache-2.0
4
5	import warnings	1✔
6	from contextlib import contextmanager	1✔
7
8	import numpy as np	1✔
9	from numba.core import errors, funcdesc, ir, typing, utils	1✔
10	from numba.core.compiler_machinery import (	1✔
11	AnalysisPass,
12	FunctionPass,
13	LoweringPass,
14	register_pass,
15	)
16	from numba.core.ir_utils import remove_dels	1✔
17	from numba.core.typed_passes import NativeLowering	1✔
18	from numba.parfors.parfor import ParforPass as _numba_parfor_ParforPass	1✔
19	from numba.parfors.parfor import PreParforPass as _numba_parfor_PreParforPass	1✔
20	from numba.parfors.parfor import swap_functions_map	1✔
21
22	from numba_dpex import config	1✔
23
24	from .lowerer import DPEXLowerer	1✔
25	from .parfor import Parfor	1✔
26	from .parfor import ParforFusionPass as _parfor_ParforFusionPass	1✔
27	from .parfor import ParforPass as _parfor_ParforPass	1✔
28	from .parfor import ParforPreLoweringPass as _parfor_ParforPreLoweringPass	1✔
29
30
31	@register_pass(mutates_CFG=True, analysis_only=False)	1✔
32	class ConstantSizeStaticLocalMemoryPass(FunctionPass):	1✔
33	_name = "dpex_constant_size_static_local_memory_pass"	1✔
34
35	def __init__(self):	1✔
36	FunctionPass.__init__(self)	1✔
37
38	def run_pass(self, state):	1✔
39	"""
40	Preprocessing for data-parallel computations.
41	"""
42	# Ensure we have an IR and type information.
UNCOV 43	assert state.func_ir	×
UNCOV 44	func_ir = state.func_ir	×
45
UNCOV 46	_DEBUG = False	×
47
UNCOV 48	if _DEBUG:	×
49	print(	×
50	"Checks if size of OpenCL local address space alloca is a "
51	+ "compile-time constant.".center(80, "-")
52	)
53	print(func_ir.dump())	×
54
UNCOV 55	work_list = list(func_ir.blocks.items())	×
UNCOV 56	while work_list:	×
UNCOV 57	label, block = work_list.pop()	×
UNCOV 58	for i, instr in enumerate(block.body):	×
UNCOV 59	if isinstance(instr, ir.Assign):	×
UNCOV 60	expr = instr.value	×
UNCOV 61	if isinstance(expr, ir.Expr):	×
UNCOV 62	if expr.op == "call":	×
UNCOV 63	find_var = block.find_variable_assignment(	×
64	expr.func.name
65	)
UNCOV 66	if find_var is not None:	×
UNCOV 67	call_node = find_var.value	×
UNCOV 68	if (	×
69	isinstance(call_node, ir.Expr)
70	and call_node.op == "getattr"
71	and call_node.attr == "array"
72	):
73	# let's check if it is from numba_dpex.local
UNCOV 74	attr_node = block.find_variable_assignment(	×
75	call_node.value.name
76	).value
UNCOV 77	if (	×
78	isinstance(attr_node, ir.Expr)
79	and attr_node.op == "getattr"
80	and attr_node.attr == "local"
81	):
UNCOV 82	arg = None	×
83	# at first look in keyword arguments to
84	# get the shape, which has to be
85	# constant
UNCOV 86	if expr.kws:	×
UNCOV 87	for _arg in expr.kws:	×
UNCOV 88	if _arg[0] == "shape":	×
UNCOV 89	arg = _arg[1]	×
90
UNCOV 91	if not arg:	×
UNCOV 92	arg = expr.args[0]	×
93
UNCOV 94	error = False	×
95	# arg can be one constant or a tuple of
96	# constant items
UNCOV 97	arg_type = func_ir.get_definition(	×
98	arg.name
99	)
UNCOV 100	if isinstance(arg_type, ir.Expr):	×
101	# we have a tuple
102	for item in arg_type.items:	×
103	if not isinstance(	×
104	func_ir.get_definition(
105	item.name
106	),
107	ir.Const,
108	):
109	error = True	×
110	break	×
111
112	else:
UNCOV 113	if not isinstance(	×
114	func_ir.get_definition(
115	arg.name
116	),
117	ir.Const,
118	):
119	error = True	×
120	break	×
121
UNCOV 122	if error:	×
123	warnings.warn_explicit(	×
124	"The size of the Local memory "
125	+ "has to be constant",
126	errors.NumbaError,
127	state.func_id.filename,
128	state.func_id.firstlineno,
129	)
130	raise	×
131
UNCOV 132	if config.DEBUG or config.DUMP_IR:	×
133	name = state.func_ir.func_id.func_qualname	×
134	print(("IR DUMP: %s" % name).center(80, "-"))	×
135	state.func_ir.dump()	×
136
UNCOV 137	return True	×
138
139
140	@register_pass(mutates_CFG=True, analysis_only=False)	1✔
141	class PreParforPass(FunctionPass):	1✔
142	_name = "dpex_pre_parfor_pass"	1✔
143
144	def __init__(self):	1✔
145	FunctionPass.__init__(self)	1✔
146
147	def run_pass(self, state):	1✔
148	"""
149	Preprocessing for data-parallel computations.
150	"""
151
152	# Ensure we have an IR and type information.
153	assert state.func_ir	×
154	functions_map = swap_functions_map.copy()	×
155	# FIXME: remove once reduction is implemented
156	functions_map.pop(("dot", "numpy"), None)	×
157	functions_map.pop(("sum", "numpy"), None)	×
158	functions_map.pop(("prod", "numpy"), None)	×
159	functions_map.pop(("argmax", "numpy"), None)	×
160	functions_map.pop(("max", "numpy"), None)	×
161	functions_map.pop(("argmin", "numpy"), None)	×
162	functions_map.pop(("min", "numpy"), None)	×
163	functions_map.pop(("mean", "numpy"), None)	×
164
165	preparfor_pass = _numba_parfor_PreParforPass(	×
166	state.func_ir,
167	state.type_annotation.typemap,
168	state.type_annotation.calltypes,
169	state.typingctx,
170	state.targetctx,
171	state.flags.auto_parallel,
172	state.parfor_diagnostics.replaced_fns,
173	replace_functions_map=functions_map,
174	)
175
176	preparfor_pass.run()	×
177
178	if config.DEBUG or config.DUMP_IR:	×
179	name = state.func_ir.func_id.func_qualname	×
180	print(("IR DUMP: %s" % name).center(80, "-"))	×
181	state.func_ir.dump()	×
182
183	return True	×
184
185
186	@register_pass(mutates_CFG=True, analysis_only=False)	1✔
187	class ParforPass(FunctionPass):	1✔
188	_name = "dpex_parfor_pass"	1✔
189
190	def __init__(self):	1✔
191	FunctionPass.__init__(self)	1✔
192
193	def run_pass(self, state):	1✔
194	"""
195	Convert data-parallel computations into Parfor nodes
196	"""
197	# Ensure we have an IR and type information.
198	assert state.func_ir	×
199	parfor_pass = _numba_parfor_ParforPass(	×
200	state.func_ir,
201	state.type_annotation.typemap,
202	state.type_annotation.calltypes,
203	state.return_type,
204	state.typingctx,
205	state.targetctx,
206	state.flags.auto_parallel,
207	state.flags,
208	state.metadata,
209	state.parfor_diagnostics,
210	)
211
212	parfor_pass.run()	×
213
214	if config.DEBUG or config.DUMP_IR:	×
215	name = state.func_ir.func_id.func_qualname	×
216	print(("IR DUMP: %s" % name).center(80, "-"))	×
217	state.func_ir.dump()	×
218
219	return True	×
220
221
222	# this is here so it pickles and for no other reason
223	def _reload_parfors():	1✔
224	"""Reloader for cached parfors"""
225	# Re-initialize the parallel backend when load from cache.
226	from numba.np.ufunc.parallel import _launch_threads	×
227
228	_launch_threads()	×
229
230
231	@register_pass(mutates_CFG=True, analysis_only=False)	1✔
232	class SplitParforPass(FunctionPass):	1✔
233	_name = "dpex_parfor_pass"	1✔
234
235	def __init__(self):	1✔
236	FunctionPass.__init__(self)	1✔
237
238	def run_pass(self, state):	1✔
239	"""
240	Convert data-parallel computations into Parfor nodes
241	"""
242	# Ensure we have an IR and type information.
243	assert state.func_ir	1✔
244	parfor_pass = _parfor_ParforPass(	1✔
245	state.func_ir,
246	state.typemap,
247	state.calltypes,
248	state.return_type,
249	state.typingctx,
250	state.targetctx,
251	state.flags.auto_parallel,
252	state.flags,
253	state.metadata,
254	state.parfor_diagnostics,
255	)
256	parfor_pass.run()	1✔
257
258	# check the parfor pass worked and warn if it didn't
259	has_parfor = False	1✔
260	for blk in state.func_ir.blocks.values():	1✔
261	for stmnt in blk.body:	1✔
262	if isinstance(stmnt, Parfor):	1✔
263	has_parfor = True	1✔
264	break	1✔
265	else:
266	continue	1✔
267	break	1✔
268
269	if not has_parfor:	1✔
270	# parfor calls the compiler chain again with a string
271	if not (	1!
272	config.DISABLE_PERFORMANCE_WARNINGS
273	or state.func_ir.loc.filename == "<string>"
274	):
275	url = (	×
276	"https://numba.readthedocs.io/en/stable/user/"
277	"parallel.html#diagnostics"
278	)
279	msg = (	×
280	"\nThe keyword argument 'parallel=True' was specified "
281	"but no transformation for parallel execution was "
282	"possible.\n\nTo find out why, try turning on parallel "
283	"diagnostics, see %s for help." % url
284	)
285	warnings.warn(	×
286	errors.NumbaPerformanceWarning(msg, state.func_ir.loc)
287	)
288
289	# Add reload function to initialize the parallel backend.
290	state.reload_init.append(_reload_parfors)	1✔
291	return True	1✔
292
293
294	@register_pass(mutates_CFG=True, analysis_only=False)	1✔
295	class ParforFusionPass(FunctionPass):	1✔
296	_name = "parfor_fusion_pass"	1✔
297
298	def __init__(self):	1✔
299	FunctionPass.__init__(self)	1✔
300
301	def run_pass(self, state):	1✔
302	"""
303	Do fusion of parfor nodes.
304	"""
305	# Ensure we have an IR and type information.
306	assert state.func_ir	1✔
307	parfor_pass = _parfor_ParforFusionPass(	1✔
308	state.func_ir,
309	state.typemap,
310	state.calltypes,
311	state.return_type,
312	state.typingctx,
313	state.targetctx,
314	state.flags.auto_parallel,
315	state.flags,
316	state.metadata,
317	state.parfor_diagnostics,
318	)
319	parfor_pass.run()	1✔
320
321	return True	1✔
322
323
324	@register_pass(mutates_CFG=True, analysis_only=False)	1✔
325	class ParforPreLoweringPass(FunctionPass):	1✔
326	_name = "parfor_prelowering_pass"	1✔
327
328	def __init__(self):	1✔
329	FunctionPass.__init__(self)	1✔
330
331	def run_pass(self, state):	1✔
332	"""
333	Prepare parfors for lowering.
334	"""
335	# Ensure we have an IR and type information.
336	assert state.func_ir	1✔
337	parfor_pass = _parfor_ParforPreLoweringPass(	1✔
338	state.func_ir,
339	state.typemap,
340	state.calltypes,
341	state.return_type,
342	state.typingctx,
343	state.targetctx,
344	state.flags.auto_parallel,
345	state.flags,
346	state.metadata,
347	state.parfor_diagnostics,
348	)
349	parfor_pass.run()	1✔
350
351	return True	1✔
352
353
354	@contextmanager	1✔
355	def fallback_context(state, msg):	1✔
356	"""
357	Wraps code that would signal a fallback to object mode
358	"""
359	try:	×
360	yield	×
361	except Exception as e:	×
362	if not state.status.can_fallback:	×
363	raise	×
364	else:
365	if utils.PYVERSION >= (3,):	×
366	# Clear all references attached to the traceback
367	e = e.with_traceback(None)	×
368	# this emits a warning containing the error message body in the
369	# case of fallback from npm to objmode
370	loop_lift = "" if state.flags.enable_looplift else "OUT"	×
371	msg_rewrite = (	×
372	"\nCompilation is falling back to object mode "
373	"WITH%s looplifting enabled because %s" % (loop_lift, msg)
374	)
375	warnings.warn_explicit(	×
376	"%s due to: %s" % (msg_rewrite, e),
377	errors.NumbaWarning,
378	state.func_id.filename,
379	state.func_id.firstlineno,
380	)
381	raise	×
382
383
384	@register_pass(mutates_CFG=True, analysis_only=False)	1✔
385	class DpexLowering(LoweringPass):	1✔
386	_name = "dpex_lowering"	1✔
387
388	def __init__(self):	1✔
389	LoweringPass.__init__(self)	1✔
390
391	def run_pass(self, state):	1✔
392	if state.library is None:	×
393	codegen = state.targetctx.codegen()	×
394	state.library = codegen.create_library(state.func_id.func_qualname)	×
395	# Enable object caching upfront, so that the library can
396	# be later serialized.
397	state.library.enable_object_caching()	×
398
399	targetctx = state.targetctx	×
400
401	library = state.library	×
402	interp = state.func_ir	×
403	typemap = state.typemap	×
404	restype = state.return_type	×
405	calltypes = state.calltypes	×
406	flags = state.flags	×
407	metadata = state.metadata	×
408
409	msg = "Function %s failed at nopython " "mode lowering" % (	×
410	state.func_id.func_name,
411	)
412	with fallback_context(state, msg):	×
413	kwargs = {}	×
414
415	# for support numba 0.54 and <=0.55.0dev0=*_469
416	if hasattr(flags, "get_mangle_string"):	×
417	kwargs["abi_tags"] = flags.get_mangle_string()	×
418	# Lowering
419	fndesc = (	×
420	funcdesc.PythonFunctionDescriptor.from_specialized_function(
421	interp,
422	typemap,
423	restype,
424	calltypes,
425	mangler=targetctx.mangler,
426	inline=flags.forceinline,
427	noalias=flags.noalias,
428	**kwargs,
429	)
430	)
431
432	with targetctx.push_code_library(library):	×
433	lower = DPEXLowerer(	×
434	targetctx, library, fndesc, interp, metadata=metadata
435	)
436	lower.lower()	×
437	if not flags.no_cpython_wrapper:	×
438	lower.create_cpython_wrapper(flags.release_gil)	×
439
440	env = lower.env	×
441	call_helper = lower.call_helper	×
442	del lower	×
443
444	from numba.core.compiler import _LowerResult # TODO: move this	×
445
446	if flags.no_compile:	×
447	state["cr"] = _LowerResult(	×
448	fndesc, call_helper, cfunc=None, env=env
449	)
450	else:
451	# Prepare for execution
452	cfunc = targetctx.get_executable(library, fndesc, env)	×
453	# Insert native function for use by other jitted-functions.
454	# We also register its library to allow for inlining.
455	targetctx.insert_user_function(cfunc, fndesc, [library])	×
456	state["cr"] = _LowerResult(	×
457	fndesc, call_helper, cfunc=cfunc, env=env
458	)
459
460	return True	×
461
462
463	@register_pass(mutates_CFG=True, analysis_only=False)	1✔
464	class NoPythonBackend(FunctionPass):	1✔
465	_name = "dpex_nopython_backend"	1✔
466
467	def __init__(self):	1✔
468	FunctionPass.__init__(self)	1✔
469
470	def run_pass(self, state):	1✔
471	"""
472	Back-end: Generate LLVM IR from Numba IR, compile to machine code
473	"""
474
475	lowered = state["cr"]	1✔
476	signature = typing.signature(state.return_type, *state.args)	1✔
477
478	from numba.core.compiler import compile_result	1✔
479
480	state.cr = compile_result(	1✔
481	typing_context=state.typingctx,
482	target_context=state.targetctx,
483	entry_point=lowered.cfunc,
484	typing_error=state.status.fail_reason,
485	type_annotation=state.type_annotation,
486	library=state.library,
487	call_helper=lowered.call_helper,
488	signature=signature,
489	objectmode=False,
490	lifted=state.lifted,
491	fndesc=lowered.fndesc,
492	environment=lowered.env,
493	metadata=state.metadata,
494	reload_init=state.reload_init,
495	)
496
497	remove_dels(state.func_ir.blocks)	1✔
498
499	return True	1✔
500
501
502	@register_pass(mutates_CFG=False, analysis_only=True)	1✔
503	class DumpParforDiagnostics(AnalysisPass):	1✔
504	_name = "dpex_dump_parfor_diagnostics"	1✔
505
506	def __init__(self):	1✔
507	AnalysisPass.__init__(self)	1✔
508
509	def run_pass(self, state):	1✔
510	# if state.flags.auto_parallel.enabled, add a condition flag for kernels
511	if config.OFFLOAD_DIAGNOSTICS:	1!
512	if state.parfor_diagnostics is not None:	×
513	state.parfor_diagnostics.dump(config.PARALLEL_DIAGNOSTICS)	×
514	else:
515	raise RuntimeError("Diagnostics failed.")	×
516	return True	1✔
517
518
519	@register_pass(mutates_CFG=False, analysis_only=True)	1✔
520	class QualNameDisambiguationLowering(NativeLowering):	1✔
521	"""Qualified name disambiguation lowering pass
522
523	If there are multiple @func decorated functions exist inside
524	another @func decorated block, the numba compiler machinery
525	creates same qualified names for different compiled function.
526	Therefore, we utilize `unique_name` to resolve the ambiguity.
527
528	Args:
529	NativeLowering (CompilerPass): Superclass from which this
530	class has been inherited.
531
532	Returns:
533	bool: True if `run_pass()` of the superclass is successful.
534	"""
535
536	_name = "qual-name-disambiguation-lowering"	1✔
537
538	def run_pass(self, state):	1✔
539	qual_name = state.func_id.func_qualname	1✔
540	state.func_id.func_qualname = state.func_id.unique_name	1✔
541	ret = NativeLowering.run_pass(self, state)	1✔
542	state.func_id.func_qualname = qual_name	1✔
543	return ret	1✔

IntelPython / numba-dpex / 4997420547

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