6475422111

Committed 10 Oct 2023 10:19PM UTC coverage: 77.515% (+0.2%) from 77.269%

Build # 6475422111

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1161 from IntelPython/fix/coverity_issues_0.21.3

Remove dead code to silence coverity errors.

Run Details

1102 of 1658 branches covered (0.0%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

4755 of 5898 relevant lines covered (80.62%)

0.81 hits per line

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

37.59

/numba_dpex/core/passes/passes.py

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

import warnings

from numba.core import errors, ir, typing
from numba.core.compiler_machinery import (
    AnalysisPass,
    FunctionPass,
    register_pass,
)
from numba.core.ir_utils import remove_dels
from numba.core.typed_passes import NativeLowering

from numba_dpex import config


@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

        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 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
7	from numba.core import errors, ir, typing	1✔
8	from numba.core.compiler_machinery import (	1✔
9	AnalysisPass,
10	FunctionPass,
11	register_pass,
12	)
13	from numba.core.ir_utils import remove_dels	1✔
14	from numba.core.typed_passes import NativeLowering	1✔
15
16	from numba_dpex import config	1✔
17
18
19	@register_pass(mutates_CFG=True, analysis_only=False)	1✔
20	class ConstantSizeStaticLocalMemoryPass(FunctionPass):	1✔
21	_name = "dpex_constant_size_static_local_memory_pass"	1✔
22
23	def __init__(self):	1✔
24	FunctionPass.__init__(self)	1✔
25
26	def run_pass(self, state):	1✔
27	"""
28	Preprocessing for data-parallel computations.
29	"""
30	# Ensure we have an IR and type information.
31	assert state.func_ir	×
32	func_ir = state.func_ir	×
33
34	work_list = list(func_ir.blocks.items())	×
UNCOV 35	while work_list:	×
36	label, block = work_list.pop()	×
37	for i, instr in enumerate(block.body):	×
38	if isinstance(instr, ir.Assign):	×
39	expr = instr.value	×
40	if isinstance(expr, ir.Expr):	×
41	if expr.op == "call":	×
42	find_var = block.find_variable_assignment(	×
43	expr.func.name
44	)
45	if find_var is not None:	×
46	call_node = find_var.value	×
47	if (	×
48	isinstance(call_node, ir.Expr)
49	and call_node.op == "getattr"
50	and call_node.attr == "array"
51	):
52	# let's check if it is from numba_dpex.local
53	attr_node = block.find_variable_assignment(	×
54	call_node.value.name
55	).value
56	if (	×
57	isinstance(attr_node, ir.Expr)
58	and attr_node.op == "getattr"
59	and attr_node.attr == "local"
60	):
61	arg = None	×
62	# at first look in keyword arguments to
63	# get the shape, which has to be
64	# constant
65	if expr.kws:	×
66	for _arg in expr.kws:	×
67	if _arg[0] == "shape":	×
68	arg = _arg[1]	×
69
70	if not arg:	×
71	arg = expr.args[0]	×
72
73	error = False	×
74	# arg can be one constant or a tuple of
75	# constant items
76	arg_type = func_ir.get_definition(	×
77	arg.name
78	)
79	if isinstance(arg_type, ir.Expr):	×
80	# we have a tuple
81	for item in arg_type.items:	×
82	if not isinstance(	×
83	func_ir.get_definition(
84	item.name
85	),
86	ir.Const,
87	):
88	error = True	×
89	break	×
90
91	else:
92	if not isinstance(	×
93	func_ir.get_definition(
94	arg.name
95	),
96	ir.Const,
97	):
98	error = True	×
99	break	×
100
101	if error:	×
102	warnings.warn_explicit(	×
103	"The size of the Local memory "
104	+ "has to be constant",
105	errors.NumbaError,
106	state.func_id.filename,
107	state.func_id.firstlineno,
108	)
109	raise	×
110
111	if config.DEBUG or config.DUMP_IR:	×
112	name = state.func_ir.func_id.func_qualname	×
113	print(("IR DUMP: %s" % name).center(80, "-"))	×
114	state.func_ir.dump()	×
115
116	return True	×
117
118
119	@register_pass(mutates_CFG=True, analysis_only=False)	1✔
120	class NoPythonBackend(FunctionPass):	1✔
121	_name = "dpex_nopython_backend"	1✔
122
123	def __init__(self):	1✔
124	FunctionPass.__init__(self)	1✔
125
126	def run_pass(self, state):	1✔
127	"""
128	Back-end: Generate LLVM IR from Numba IR, compile to machine code
129	"""
130
131	lowered = state["cr"]	1✔
132	signature = typing.signature(state.return_type, *state.args)	1✔
133
134	from numba.core.compiler import compile_result	1✔
135
136	state.cr = compile_result(	1✔
137	typing_context=state.typingctx,
138	target_context=state.targetctx,
139	entry_point=lowered.cfunc,
140	typing_error=state.status.fail_reason,
141	type_annotation=state.type_annotation,
142	library=state.library,
143	call_helper=lowered.call_helper,
144	signature=signature,
145	objectmode=False,
146	lifted=state.lifted,
147	fndesc=lowered.fndesc,
148	environment=lowered.env,
149	metadata=state.metadata,
150	reload_init=state.reload_init,
151	)
152
153	remove_dels(state.func_ir.blocks)	1✔
154
155	return True	1✔
156
157
158	@register_pass(mutates_CFG=False, analysis_only=True)	1✔
159	class DumpParforDiagnostics(AnalysisPass):	1✔
160	_name = "dpex_dump_parfor_diagnostics"	1✔
161
162	def __init__(self):	1✔
163	AnalysisPass.__init__(self)	1✔
164
165	def run_pass(self, state):	1✔
166	# if state.flags.auto_parallel.enabled, add a condition flag for kernels
167	if config.OFFLOAD_DIAGNOSTICS:	1!
168	if state.parfor_diagnostics is not None:	×
169	state.parfor_diagnostics.dump(config.PARALLEL_DIAGNOSTICS)	×
170	else:
171	raise RuntimeError("Diagnostics failed.")	×
172	return True	1✔
173
174
175	@register_pass(mutates_CFG=False, analysis_only=True)	1✔
176	class QualNameDisambiguationLowering(NativeLowering):	1✔
177	"""Qualified name disambiguation lowering pass
178
179	If there are multiple @func decorated functions exist inside
180	another @func decorated block, the numba compiler machinery
181	creates same qualified names for different compiled function.
182	Therefore, we utilize `unique_name` to resolve the ambiguity.
183
184	Args:
185	NativeLowering (CompilerPass): Superclass from which this
186	class has been inherited.
187
188	Returns:
189	bool: True if `run_pass()` of the superclass is successful.
190	"""
191
192	_name = "qual-name-disambiguation-lowering"	1✔
193
194	def run_pass(self, state):	1✔
195	qual_name = state.func_id.func_qualname	1✔
196	state.func_id.func_qualname = state.func_id.unique_name	1✔
197	ret = NativeLowering.run_pass(self, state)	1✔
198	state.func_id.func_qualname = qual_name	1✔
199	return ret	1✔

IntelPython / numba-dpex / 6475422111

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