4976268058

Build Type

github

Committed by GitHub

Commit Message

Merge 52aa2a335 into 87206facf

Pull Request Pull Request #1041: Remove/njit offload

Run Details

1561 of 3278 branches covered (47.62%)

Branch coverage included in aggregate %.

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

670 existing lines in 10 files now uncovered.

5276 of 8841 relevant lines covered (59.68%)

0.6 hits per line

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

6.25

/numba_dpex/core/passes/dufunc_inliner.py

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

from numba.core import ir
from numba.core.ir_utils import dead_code_elimination, simplify_CFG


def _run_inliner(
    func_ir,
    sig,
    template,
    arg_typs,
    expr,
    i,
    py_func,
    block,
    work_list,
    typemap,
    calltypes,
    typingctx,
    targetctx,
):
    from numba.core.inline_closurecall import (
        callee_ir_validator,
        inline_closure_call,
    )

    # pass is typed so use the callee globals
    inline_closure_call(
        func_ir,
        py_func.__globals__,
        block,
        i,
        py_func,
        typingctx=typingctx,
        targetctx=targetctx,
        arg_typs=arg_typs,
        typemap=typemap,
        calltypes=calltypes,
        work_list=work_list,
        replace_freevars=False,
        callee_validator=callee_ir_validator,
    )
    return True


def _inline(
    func_ir,
    work_list,
    block,
    i,
    expr,
    py_func,
    typemap,
    calltypes,
    typingctx,
    targetctx,
):
    # try and get a definition for the call, this isn't always possible as
    # it might be a eval(str)/part generated awaiting update etc. (parfors)
    to_inline = None
    try:
        to_inline = func_ir.get_definition(expr.func)
    except Exception:
        return False

    # do not handle closure inlining here, another pass deals with that.
    if getattr(to_inline, "op", False) == "make_function":
        return False

    # check this is a known and typed function
    try:
        func_ty = typemap[expr.func.name]
    except KeyError:
        return False
    if not hasattr(func_ty, "get_call_type"):
        return False

    sig = calltypes[expr]

    templates = getattr(func_ty, "templates", None)
    arg_typs = sig.args

    if templates is None:
        return False

    assert len(templates) == 1

    # at this point we know we maybe want to inline something and there's
    # definitely something that could be inlined.
    return _run_inliner(
        func_ir,
        sig,
        templates[0],
        arg_typs,
        expr,
        i,
        py_func,
        block,
        work_list,
        typemap,
        calltypes,
        typingctx,
        targetctx,
    )


def _is_dufunc_callsite(expr, block):
    if expr.op == "call":
        call_node = block.find_variable_assignment(expr.func.name).value
        # due to circular import we can not import DUFunc, TODO: Fix it
        if call_node.value.__class__.__name__ == "DUFunc":
            return call_node
    return None


def dufunc_inliner(func_ir, calltypes, typemap, typingctx, targetctx):
    _DEBUG = False
    modified = False

    if _DEBUG:
        print("GUFunc before inlining DUFunc".center(80, "-"))
        print(func_ir.dump())

    work_list = list(func_ir.blocks.items())
    # use a work list, look for call sites via `ir.Expr.op == call` and
    # then pass these to `self._do_work` to make decisions about inlining.
    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):
                    call_node = _is_dufunc_callsite(expr, block)
                    if call_node:
                        py_func = call_node.value._dispatcher.py_func
                        workfn = _inline(
                            func_ir,
                            work_list,
                            block,
                            i,
                            expr,
                            py_func,
                            typemap,
                            calltypes,
                            typingctx,
                            targetctx,
                        )
                        if workfn:
                            modified = True
                            break  # because block structure changed
                    else:
                        continue
    if _DEBUG:
        print("GUFunc after inlining DUFunc".center(80, "-"))
        print(func_ir.dump())
        print("".center(80, "-"))

    if modified:
        # clean up leftover load instructions. This step is needed or else
        # SpirvLowerer would complain
        dead_code_elimination(func_ir, typemap=typemap)
        # clean up unconditional branches that appear due to inlined
        # functions introducing blocks
        func_ir.blocks = simplify_CFG(func_ir.blocks)

    if _DEBUG:
        print("GUFunc after inlining DUFunc, DCE, SimplyCFG".center(80, "-"))
        print(func_ir.dump())
        print("".center(80, "-"))

    return True

1	# SPDX-FileCopyrightText: 2020 - 2023 Intel Corporation
2	#
3	# SPDX-License-Identifier: Apache-2.0
4
5	from numba.core import ir	1✔
6	from numba.core.ir_utils import dead_code_elimination, simplify_CFG	1✔
7
8
9	def _run_inliner(	1✔
10	func_ir,
11	sig,
12	template,
13	arg_typs,
14	expr,
15	i,
16	py_func,
17	block,
18	work_list,
19	typemap,
20	calltypes,
21	typingctx,
22	targetctx,
23	):
UNCOV 24	from numba.core.inline_closurecall import (	×
25	callee_ir_validator,
26	inline_closure_call,
27	)
28
29	# pass is typed so use the callee globals
UNCOV 30	inline_closure_call(	×
31	func_ir,
32	py_func.__globals__,
33	block,
34	i,
35	py_func,
36	typingctx=typingctx,
37	targetctx=targetctx,
38	arg_typs=arg_typs,
39	typemap=typemap,
40	calltypes=calltypes,
41	work_list=work_list,
42	replace_freevars=False,
43	callee_validator=callee_ir_validator,
44	)
UNCOV 45	return True	×
46
47
48	def _inline(	1✔
49	func_ir,
50	work_list,
51	block,
52	i,
53	expr,
54	py_func,
55	typemap,
56	calltypes,
57	typingctx,
58	targetctx,
59	):
60	# try and get a definition for the call, this isn't always possible as
61	# it might be a eval(str)/part generated awaiting update etc. (parfors)
UNCOV 62	to_inline = None	×
UNCOV 63	try:	×
UNCOV 64	to_inline = func_ir.get_definition(expr.func)	×
65	except Exception:	×
66	return False	×
67
68	# do not handle closure inlining here, another pass deals with that.
UNCOV 69	if getattr(to_inline, "op", False) == "make_function":	×
70	return False	×
71
72	# check this is a known and typed function
UNCOV 73	try:	×
UNCOV 74	func_ty = typemap[expr.func.name]	×
75	except KeyError:	×
76	return False	×
UNCOV 77	if not hasattr(func_ty, "get_call_type"):	×
78	return False	×
79
UNCOV 80	sig = calltypes[expr]	×
81
UNCOV 82	templates = getattr(func_ty, "templates", None)	×
UNCOV 83	arg_typs = sig.args	×
84
UNCOV 85	if templates is None:	×
86	return False	×
87
UNCOV 88	assert len(templates) == 1	×
89
90	# at this point we know we maybe want to inline something and there's
91	# definitely something that could be inlined.
UNCOV 92	return _run_inliner(	×
93	func_ir,
94	sig,
95	templates[0],
96	arg_typs,
97	expr,
98	i,
99	py_func,
100	block,
101	work_list,
102	typemap,
103	calltypes,
104	typingctx,
105	targetctx,
106	)
107
108
109	def _is_dufunc_callsite(expr, block):	1✔
UNCOV 110	if expr.op == "call":	×
UNCOV 111	call_node = block.find_variable_assignment(expr.func.name).value	×
112	# due to circular import we can not import DUFunc, TODO: Fix it
UNCOV 113	if call_node.value.__class__.__name__ == "DUFunc":	×
UNCOV 114	return call_node	×
UNCOV 115	return None	×
116
117
118	def dufunc_inliner(func_ir, calltypes, typemap, typingctx, targetctx):	1✔
UNCOV 119	_DEBUG = False	×
UNCOV 120	modified = False	×
121
UNCOV 122	if _DEBUG:	×
123	print("GUFunc before inlining DUFunc".center(80, "-"))	×
124	print(func_ir.dump())	×
125
UNCOV 126	work_list = list(func_ir.blocks.items())	×
127	# use a work list, look for call sites via `ir.Expr.op == call` and
128	# then pass these to `self._do_work` to make decisions about inlining.
UNCOV 129	while work_list:	×
UNCOV 130	label, block = work_list.pop()	×
UNCOV 131	for i, instr in enumerate(block.body):	×
UNCOV 132	if isinstance(instr, ir.Assign):	×
UNCOV 133	expr = instr.value	×
UNCOV 134	if isinstance(expr, ir.Expr):	×
UNCOV 135	call_node = _is_dufunc_callsite(expr, block)	×
UNCOV 136	if call_node:	×
UNCOV 137	py_func = call_node.value._dispatcher.py_func	×
UNCOV 138	workfn = _inline(	×
139	func_ir,
140	work_list,
141	block,
142	i,
143	expr,
144	py_func,
145	typemap,
146	calltypes,
147	typingctx,
148	targetctx,
149	)
UNCOV 150	if workfn:	×
UNCOV 151	modified = True	×
UNCOV 152	break # because block structure changed	×
153	else:
154	continue	×
UNCOV 155	if _DEBUG:	×
156	print("GUFunc after inlining DUFunc".center(80, "-"))	×
157	print(func_ir.dump())	×
158	print("".center(80, "-"))	×
159
UNCOV 160	if modified:	×
161	# clean up leftover load instructions. This step is needed or else
162	# SpirvLowerer would complain
UNCOV 163	dead_code_elimination(func_ir, typemap=typemap)	×
164	# clean up unconditional branches that appear due to inlined
165	# functions introducing blocks
UNCOV 166	func_ir.blocks = simplify_CFG(func_ir.blocks)	×
167
UNCOV 168	if _DEBUG:	×
169	print("GUFunc after inlining DUFunc, DCE, SimplyCFG".center(80, "-"))	×
170	print(func_ir.dump())	×
171	print("".center(80, "-"))	×
172
UNCOV 173	return True	×

IntelPython / numba-dpex / 4976268058

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