6736333254

Committed 02 Nov 2023 05:46PM UTC coverage: 78.272% (-0.007%) from 78.279%

Build # 6736333254

Build Type

Pull #1194

github

Committed by

web-flow

Commit Message

Merge c13471006 into ac05c1a87

Pull Request Pull Request #1194: Numba-mlir integration

Run Details

1078 of 1627 branches covered (0.0%)

Branch coverage included in aggregate %.

58 of 62 new or added lines in 3 files covered. (93.55%)

5 existing lines in 2 files now uncovered.

4711 of 5769 relevant lines covered (81.66%)

0.82 hits per line

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

90.28

/numba_dpex/core/pipelines/dpjit_compiler.py

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

from functools import lru_cache

from numba.core.compiler import CompilerBase, DefaultPassBuilder
from numba.core.compiler_machinery import PassManager
from numba.core.typed_passes import (
    AnnotateTypes,
    InlineOverloads,
    IRLegalization,
    NativeParforLowering,
    NopythonRewrites,
    NoPythonSupportedFeatureValidation,
    NopythonTypeInference,
    ParforFusionPass,
    ParforPass,
    ParforPreLoweringPass,
    PreLowerStripPhis,
    PreParforPass,
)

from numba_dpex.core.exceptions import UnsupportedCompilationModeError
from numba_dpex.core.passes import (
    DumpParforDiagnostics,
    NoPythonBackend,
    ParforLegalizeCFDPass,
)
from numba_dpex.parfor_diagnostics import ExtendedParforDiagnostics


@lru_cache
def get_compiler(use_mlir):
    class _DpjitPassBuilder(object):
        """
        A pass builder for dpex's DpjitCompiler that adds supports for
        offloading dpnp array expressions and dpnp library calls to a SYCL device.

        The pass builder does not implement pipelines for objectmode or interpreted
        execution.
        """

        @staticmethod
        def define_typed_pipeline(state, name="dpex_dpjit_typed"):
            """Returns the typed part of the nopython pipeline"""
            pm = PassManager(name)
            # typing
            pm.add_pass(NopythonTypeInference, "nopython frontend")
            # Annotate only once legalized
            pm.add_pass(AnnotateTypes, "annotate types")
            # strip phis
            pm.add_pass(PreLowerStripPhis, "remove phis nodes")

            # optimization
            pm.add_pass(InlineOverloads, "inline overloaded functions")
            pm.add_pass(PreParforPass, "Preprocessing for parfors")
            if not state.flags.no_rewrites:
                pm.add_pass(NopythonRewrites, "nopython rewrites")
            pm.add_pass(ParforPass, "convert to parfors")
            pm.add_pass(
                ParforLegalizeCFDPass,
                "Legalize parfors for compute follows data",
            )
            pm.add_pass(ParforFusionPass, "fuse parfors")
            pm.add_pass(ParforPreLoweringPass, "parfor prelowering")

            pm.finalize()
            return pm

        @staticmethod
        def define_nopython_lowering_pipeline(
            state, name="dpex_dpjit_lowering"
        ):
            """Returns an nopython mode pipeline based PassManager"""
            pm = PassManager(name)

            flags = state.flags
            if use_mlir or hasattr(flags, "use_mlir") and flags.use_mlir:
                from numba_mlir.mlir.passes import MlirReplaceParfors

                pm.add_pass(
                    MlirReplaceParfors,
                    "Lower parfor using MLIR pipeline",
                )

            # legalize
            pm.add_pass(
                NoPythonSupportedFeatureValidation,
                "ensure features that are in use are in a valid form",
            )
            pm.add_pass(IRLegalization, "ensure IR is legal prior to lowering")

            # lower
            pm.add_pass(
                NativeParforLowering, "lowerer with support for parfor nodes"
            )
            pm.add_pass(NoPythonBackend, "nopython mode backend")
            pm.add_pass(DumpParforDiagnostics, "dump parfor diagnostics")

            pm.finalize()
            return pm

        @staticmethod
        def define_nopython_pipeline(state, name="dpex_dpjit_nopython"):
            """Returns an nopython mode pipeline based PassManager"""
            # compose pipeline from untyped, typed and lowering parts
            dpb = _DpjitPassBuilder
            pm = PassManager(name)
            untyped_passes = DefaultPassBuilder.define_untyped_pipeline(state)
            pm.passes.extend(untyped_passes.passes)

            typed_passes = dpb.define_typed_pipeline(state)
            pm.passes.extend(typed_passes.passes)

            lowering_passes = dpb.define_nopython_lowering_pipeline(state)
            pm.passes.extend(lowering_passes.passes)

            pm.finalize()
            return pm

    class DpjitCompiler(CompilerBase):
        """Dpex's compiler pipeline to offload parfor nodes into SYCL kernels."""

        def define_pipelines(self):
            pms = []
            self.state.parfor_diagnostics = ExtendedParforDiagnostics()
            self.state.metadata[
                "parfor_diagnostics"
            ] = self.state.parfor_diagnostics
            if not self.state.flags.force_pyobject:
                pms.append(
                    _DpjitPassBuilder.define_nopython_pipeline(self.state)
                )
            if (
                self.state.status.can_fallback
                or self.state.flags.force_pyobject
            ):
                raise UnsupportedCompilationModeError()
            return pms

    return DpjitCompiler

1	# SPDX-FileCopyrightText: 2020 - 2022 Intel Corporation
2	#
3	# SPDX-License-Identifier: Apache-2.0
4
5	from functools import lru_cache	1✔
6
7	from numba.core.compiler import CompilerBase, DefaultPassBuilder	1✔
8	from numba.core.compiler_machinery import PassManager	1✔
9	from numba.core.typed_passes import (	1✔
10	AnnotateTypes,
11	InlineOverloads,
12	IRLegalization,
13	NativeParforLowering,
14	NopythonRewrites,
15	NoPythonSupportedFeatureValidation,
16	NopythonTypeInference,
17	ParforFusionPass,
18	ParforPass,
19	ParforPreLoweringPass,
20	PreLowerStripPhis,
21	PreParforPass,
22	)
23
24	from numba_dpex.core.exceptions import UnsupportedCompilationModeError	1✔
25	from numba_dpex.core.passes import (	1✔
26	DumpParforDiagnostics,
27	NoPythonBackend,
28	ParforLegalizeCFDPass,
29	)
30	from numba_dpex.parfor_diagnostics import ExtendedParforDiagnostics	1✔
31
32
33	@lru_cache	1✔
34	def get_compiler(use_mlir):	1✔
35	class _DpjitPassBuilder(object):	1✔
36	"""
37	A pass builder for dpex's DpjitCompiler that adds supports for
38	offloading dpnp array expressions and dpnp library calls to a SYCL device.
39
40	The pass builder does not implement pipelines for objectmode or interpreted
41	execution.
42	"""
43
44	@staticmethod	1✔
45	def define_typed_pipeline(state, name="dpex_dpjit_typed"):	1✔
46	"""Returns the typed part of the nopython pipeline"""
47	pm = PassManager(name)	1✔
48	# typing
49	pm.add_pass(NopythonTypeInference, "nopython frontend")	1✔
50	# Annotate only once legalized
51	pm.add_pass(AnnotateTypes, "annotate types")	1✔
52	# strip phis
53	pm.add_pass(PreLowerStripPhis, "remove phis nodes")	1✔
54
55	# optimization
56	pm.add_pass(InlineOverloads, "inline overloaded functions")	1✔
57	pm.add_pass(PreParforPass, "Preprocessing for parfors")	1✔
58	if not state.flags.no_rewrites:	1!
59	pm.add_pass(NopythonRewrites, "nopython rewrites")	1✔
60	pm.add_pass(ParforPass, "convert to parfors")	1✔
61	pm.add_pass(	1✔
62	ParforLegalizeCFDPass,
63	"Legalize parfors for compute follows data",
64	)
65	pm.add_pass(ParforFusionPass, "fuse parfors")	1✔
66	pm.add_pass(ParforPreLoweringPass, "parfor prelowering")	1✔
67
68	pm.finalize()	1✔
69	return pm	1✔
70
71	@staticmethod	1✔
72	def define_nopython_lowering_pipeline(	1✔
73	state, name="dpex_dpjit_lowering"
74	):
75	"""Returns an nopython mode pipeline based PassManager"""
76	pm = PassManager(name)	1✔
77
78	flags = state.flags	1✔
79	if use_mlir or hasattr(flags, "use_mlir") and flags.use_mlir:	1!
NEW 80	from numba_mlir.mlir.passes import MlirReplaceParfors	×
81
NEW 82	pm.add_pass(	×
83	MlirReplaceParfors,
84	"Lower parfor using MLIR pipeline",
85	)
86
87	# legalize
88	pm.add_pass(	1✔
89	NoPythonSupportedFeatureValidation,
90	"ensure features that are in use are in a valid form",
91	)
92	pm.add_pass(IRLegalization, "ensure IR is legal prior to lowering")	1✔
93
94	# lower
95	pm.add_pass(	1✔
96	NativeParforLowering, "lowerer with support for parfor nodes"
97	)
98	pm.add_pass(NoPythonBackend, "nopython mode backend")	1✔
99	pm.add_pass(DumpParforDiagnostics, "dump parfor diagnostics")	1✔
100
101	pm.finalize()	1✔
102	return pm	1✔
103
104	@staticmethod	1✔
105	def define_nopython_pipeline(state, name="dpex_dpjit_nopython"):	1✔
106	"""Returns an nopython mode pipeline based PassManager"""
107	# compose pipeline from untyped, typed and lowering parts
108	dpb = _DpjitPassBuilder	1✔
109	pm = PassManager(name)	1✔
110	untyped_passes = DefaultPassBuilder.define_untyped_pipeline(state)	1✔
111	pm.passes.extend(untyped_passes.passes)	1✔
112
113	typed_passes = dpb.define_typed_pipeline(state)	1✔
114	pm.passes.extend(typed_passes.passes)	1✔
115
116	lowering_passes = dpb.define_nopython_lowering_pipeline(state)	1✔
117	pm.passes.extend(lowering_passes.passes)	1✔
118
119	pm.finalize()	1✔
120	return pm	1✔
121
122	class DpjitCompiler(CompilerBase):	1✔
123	"""Dpex's compiler pipeline to offload parfor nodes into SYCL kernels."""
124
125	def define_pipelines(self):	1✔
126	pms = []	1✔
127	self.state.parfor_diagnostics = ExtendedParforDiagnostics()	1✔
128	self.state.metadata[	1✔
129	"parfor_diagnostics"
130	] = self.state.parfor_diagnostics
131	if not self.state.flags.force_pyobject:	1!
132	pms.append(	1✔
133	_DpjitPassBuilder.define_nopython_pipeline(self.state)
134	)
135	if (	1!
136	self.state.status.can_fallback
137	or self.state.flags.force_pyobject
138	):
NEW 139	raise UnsupportedCompilationModeError()	×
140	return pms	1✔
141
142	return DpjitCompiler	1✔

IntelPython / numba-dpex / 6736333254

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