4964796786

Build Type

github

Committed by GitHub

Commit Message

Merge ad5a888c3 into 87206facf

Pull Request Pull Request #999: Enable dpnp parfor reduction

Run Details

2159 of 3743 branches covered (57.68%)

Branch coverage included in aggregate %.

517 of 572 new or added lines in 9 files covered. (90.38%)

35 existing lines in 1 file now uncovered.

7370 of 10665 relevant lines covered (69.1%)

0.69 hits per line

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

93.94

/numba_dpex/core/utils/reduction_kernel_builder.py

import copy
import warnings

from numba.core import types
from numba.core.errors import NumbaParallelSafetyWarning
from numba.core.ir_utils import (
    add_offset_to_labels,
    get_name_var_table,
    get_unused_var_name,
    legalize_names,
    mk_unique_var,
    remove_dels,
    rename_labels,
    replace_var_names,
)
from numba.core.typing import signature

from numba_dpex import config

from .kernel_builder import (
    ParforKernel,
    _compile_kernel_parfor,
    _print_body,
    _to_scalar_from_0d,
)
from .kernel_templates.partial_reduction_template import (
    RemainderReduceIntermediateKernelTemplate,
    TreeReduceIntermediateKernelTemplate,
)
from .reduction_helper import update_sentinel


def create_reduction_main_kernel_for_parfor(
    loop_ranges,
    parfor_node,
    typemap,
    flags,
    has_aliases,
    reductionKernelVar,
    parfor_reddict=None,
):
    """
    Creates a numba_dpex.kernel function for a parfor node.

    There are two parts to this function:

        1) Code to iterate across the iteration space as defined by
           the schedule.
        2) The parfor body that does the work for a single point in
           the iteration space.

    Part 1 is created as Python text for simplicity with a sentinel
    assignment to mark the point in the IR where the parfor body
    should be added. This Python text is 'exec'ed into existence and its
    IR retrieved with run_frontend. The IR is scanned for the sentinel
    assignment where that basic block is split and the IR for the parfor
    body inserted.
    """

    redarrs = reductionKernelVar.parfor_redvars_to_redarrs
    parfor_legalized_params = reductionKernelVar.parfor_legalized_params
    parfor_redvars = reductionKernelVar.parfor_redvars
    parfor_args = reductionKernelVar.parfor_params
    parfor_redarrs_legal_dict = reductionKernelVar.parfor_redarrs_legal_dict
    param_types = reductionKernelVar.param_types
    func_arg_types = reductionKernelVar.func_arg_types
    loop_body = copy.deepcopy(reductionKernelVar.loop_body)
    legal_loop_indices = reductionKernelVar.legal_loop_indices
    param_dict = reductionKernelVar.param_dict
    redvars_legal_dict = reductionKernelVar.redvars_legal_dict
    work_group_size = reductionKernelVar.work_group_size

    loc = parfor_node.init_block.loc

    for race in parfor_node.races:
        msg = (
            "Variable %s used in parallel loop may be written "
            "to simultaneously by multiple workers and may result "
            "in non-deterministic or unintended results." % race
        )
        warnings.warn(NumbaParallelSafetyWarning(msg, loc))

    loop_body_var_table = get_name_var_table(loop_body)
    sentinel_name = get_unused_var_name("__sentinel__", loop_body_var_table)

    # Determine the unique names of the scheduling and gufunc functions.
    kernel_name = "__numba_parfor_gufunc_%s" % (parfor_node.id)

    # swap s.2 (redvar) with partial_sum
    for i, name in enumerate(parfor_args):
        try:
            tmp = redarrs[name][0]
            nameNew = parfor_redarrs_legal_dict[tmp]
            parfor_legalized_params[i] = nameNew
            param_types[i] = _to_scalar_from_0d(typemap[tmp])
            func_arg_types[i] = _to_scalar_from_0d(typemap[tmp])

        except KeyError:
            pass

    kernel_template = TreeReduceIntermediateKernelTemplate(
        kernel_name=kernel_name,
        kernel_params=parfor_legalized_params,
        ivar_names=legal_loop_indices,
        sentinel_name=sentinel_name,
        loop_ranges=loop_ranges,
        param_dict=param_dict,
        parfor_dim=len(parfor_node.loop_nests),
        redvars=parfor_redvars,
        parfor_args=parfor_args,
        parfor_reddict=parfor_reddict,
        redvars_dict=redvars_legal_dict,
        typemap=typemap,
        work_group_size=work_group_size,
    )
    kernel_ir = kernel_template.kernel_ir

    for i, name in enumerate(parfor_args):
        try:
            tmp = redarrs[name][0]
            parfor_args[i] = tmp
        except KeyError:
            pass

    # rename all variables in kernel_ir afresh
    var_table = get_name_var_table(kernel_ir.blocks)
    new_var_dict = {}
    reserved_names = (
        [sentinel_name] + list(param_dict.values()) + legal_loop_indices
    )
    for name, _ in var_table.items():
        if not (name in reserved_names):
            new_var_dict[name] = mk_unique_var(name)

    replace_var_names(kernel_ir.blocks, new_var_dict)
    kernel_param_types = param_types
    gufunc_stub_last_label = max(kernel_ir.blocks.keys()) + 1
    # Add gufunc stub last label to each parfor.loop_body label to prevent
    # label conflicts.
    loop_body = add_offset_to_labels(loop_body, gufunc_stub_last_label)
    # new label for splitting sentinel block
    new_label = max(loop_body.keys()) + 1

    update_sentinel(kernel_ir, sentinel_name, loop_body, new_label)

    # FIXME: Why rename and remove dels causes the partial_sum array update
    # instructions to be removed.
    kernel_ir.blocks = rename_labels(kernel_ir.blocks)
    remove_dels(kernel_ir.blocks)

    old_alias = flags.noalias

    if not has_aliases:
        flags.noalias = True

    kernel_sig = signature(types.none, *kernel_param_types)
    exec_queue = typemap[parfor_args[0]].queue

    sycl_kernel = _compile_kernel_parfor(
        exec_queue,
        kernel_name,
        kernel_ir,
        kernel_param_types,
        debug=flags.debuginfo,
    )

    flags.noalias = old_alias

    return ParforKernel(
        name=kernel_name,
        kernel=sycl_kernel,
        signature=kernel_sig,
        kernel_args=parfor_args,
        kernel_arg_types=func_arg_types,
        queue=exec_queue,
    )


def create_reduction_remainder_kernel_for_parfor(
    parfor_node,
    typemap,
    flags,
    has_aliases,
    reductionKernelVar,
    parfor_reddict,
    reductionHelperList,
):
    """
    Creates a numba_dpex.kernel function for a parfor node.

    There are two parts to this function:

        1) Code to iterate across the iteration space as defined by
           the schedule.
        2) The parfor body that does the work for a single point in
           the iteration space.

    Part 1 is created as Python text for simplicity with a sentinel
    assignment to mark the point in the IR where the parfor body
    should be added. This Python text is 'exec'ed into existence and its
    IR retrieved with run_frontend. The IR is scanned for the sentinel
    assignment where that basic block is split and the IR for the parfor
    body inserted.
    """

    parfor_legalized_params = reductionKernelVar.parfor_legalized_params
    parfor_redvars = reductionKernelVar.parfor_redvars
    parfor_args = reductionKernelVar.parfor_params
    # parfor_redarrs_legal_dict = reductionKernelVar.parfor_redarrs_legal_dict
    param_types = reductionKernelVar.param_types
    func_arg_types = reductionKernelVar.func_arg_types
    loop_body = copy.deepcopy(reductionKernelVar.loop_body)
    legal_loop_indices = reductionKernelVar.legal_loop_indices
    param_dict = reductionKernelVar.param_dict
    redvars_legal_dict = reductionKernelVar.redvars_legal_dict

    loc = parfor_node.init_block.loc

    for race in parfor_node.races:
        msg = (
            "Variable %s used in parallel loop may be written "
            "to simultaneously by multiple workers and may result "
            "in non-deterministic or unintended results." % race
        )
        warnings.warn(NumbaParallelSafetyWarning(msg, loc))

    loop_body_var_table = get_name_var_table(loop_body)
    sentinel_name = get_unused_var_name("__sentinel__", loop_body_var_table)

    global_size_var_name = []
    global_size_mod_var_name = []
    partial_sum_var_name = []
    partial_sum_size_var_name = []
    final_sum_var_name = []

    for i, _ in enumerate(parfor_redvars):
        reductionHelper = reductionHelperList[i]
        name = reductionHelper.partial_sum_var.name
        partial_sum_var_name.append(name)

        name = reductionHelper.global_size_var.name
        global_size_var_name.append(name)

        name = reductionHelper.global_size_mod_var.name
        global_size_mod_var_name.append(name)

        name = reductionHelper.partial_sum_size_var.name
        partial_sum_size_var_name.append(name)

        name = reductionHelper.final_sum_var.name
        final_sum_var_name.append(name)

    kernel_name = "__numba_parfor_gufunc_%s_sum2" % (parfor_node.id)

    partial_sum_var_dict = legalize_names(partial_sum_var_name)
    global_size_var_dict = legalize_names(global_size_var_name)
    global_size_mod_var_dict = legalize_names(global_size_mod_var_name)
    partial_sum_size_var_dict = legalize_names(partial_sum_size_var_name)
    final_sum_var_dict = legalize_names(final_sum_var_name)

    partial_sum_var_legal_name = [
        partial_sum_var_dict[v] for v in partial_sum_var_dict
    ]

    global_size_var_legal_name = [
        global_size_var_dict[v] for v in global_size_var_dict
    ]
    global_size_mod_var_legal_name = [
        global_size_mod_var_dict[v] for v in global_size_mod_var_dict
    ]
    partial_sum_size_var_legal_name = [
        partial_sum_size_var_dict[v] for v in partial_sum_size_var_dict
    ]
    final_sum_var_legal_name = [
        final_sum_var_dict[v] for v in final_sum_var_dict
    ]

    kernel_template = RemainderReduceIntermediateKernelTemplate(
        kernel_name=kernel_name,
        kernel_params=parfor_legalized_params,
        sentinel_name=sentinel_name,
        legal_loop_indices=legal_loop_indices,
        redvars_dict=redvars_legal_dict,
        redvars=parfor_redvars,
        parfor_reddict=parfor_reddict,
        typemap=typemap,
        global_size_var_name=global_size_var_legal_name,
        global_size_mod_var_name=global_size_mod_var_legal_name,
        partial_sum_size_var_name=partial_sum_size_var_legal_name,
        partial_sum_var_name=partial_sum_var_legal_name,
        final_sum_var_name=final_sum_var_legal_name,
        reductionKernelVar=reductionKernelVar,
    )
    kernel_ir = kernel_template.kernel_ir

    var_table = get_name_var_table(kernel_ir.blocks)
    new_var_dict = {}
    reserved_names = (
        [sentinel_name] + list(param_dict.values()) + legal_loop_indices
    )
    for name, _ in var_table.items():
        if not (name in reserved_names):
            new_var_dict[name] = mk_unique_var(name)
    replace_var_names(kernel_ir.blocks, new_var_dict)

    for i, _ in enumerate(parfor_redvars):
        if reductionHelperList[i].global_size_var is not None:
            parfor_args.append(global_size_var_name[i])
            parfor_legalized_params.append(global_size_var_legal_name[i])
            param_types.append(
                _to_scalar_from_0d(typemap[global_size_var_name[i]])
            )
            func_arg_types.append(
                _to_scalar_from_0d(typemap[global_size_var_name[i]])
            )

        if reductionHelperList[i].global_size_mod_var is not None:
            parfor_args.append(global_size_mod_var_name[i])
            parfor_legalized_params.append(global_size_mod_var_legal_name[i])

            param_types.append(
                _to_scalar_from_0d(typemap[global_size_mod_var_name[i]])
            )
            func_arg_types.append(
                _to_scalar_from_0d(typemap[global_size_mod_var_name[i]])
            )

        if reductionHelperList[i].partial_sum_size_var is not None:
            parfor_args.append(partial_sum_size_var_name[i])
            parfor_legalized_params.append(partial_sum_size_var_legal_name[i])
            param_types.append(
                _to_scalar_from_0d(typemap[partial_sum_size_var_name[i]])
            )
            func_arg_types.append(
                _to_scalar_from_0d(typemap[partial_sum_size_var_name[i]])
            )
        if reductionHelperList[i].final_sum_var is not None:
            parfor_args.append(final_sum_var_name[i])
            parfor_legalized_params.append(final_sum_var_legal_name[i])
            param_types.append(
                _to_scalar_from_0d(typemap[final_sum_var_name[i]])
            )
            func_arg_types.append(
                _to_scalar_from_0d(typemap[final_sum_var_name[i]])
            )

    kernel_param_types = param_types

    gufunc_stub_last_label = max(kernel_ir.blocks.keys()) + 1

    # Add gufunc stub last label to each parfor.loop_body label to prevent
    # label conflicts.
    loop_body = add_offset_to_labels(loop_body, gufunc_stub_last_label)
    # new label for splitting sentinel block
    new_label = max(loop_body.keys()) + 1

    update_sentinel(kernel_ir, sentinel_name, loop_body, new_label)

    old_alias = flags.noalias
    if not has_aliases:
        flags.noalias = True

    kernel_sig = signature(types.none, *kernel_param_types)

    # FIXME: Enable check after CFD pass has been added
    # exec_queue = determine_kernel_launch_queue(
    #     args=parfor_args, argtypes=kernel_param_types, kernel_name=kernel_name
    # )
    exec_queue = typemap[parfor_args[0]].queue

    sycl_kernel = _compile_kernel_parfor(
        exec_queue,
        kernel_name,
        kernel_ir,
        kernel_param_types,
        debug=flags.debuginfo,
    )

    flags.noalias = old_alias

    return ParforKernel(
        name=kernel_name,
        kernel=sycl_kernel,
        signature=kernel_sig,
        kernel_args=parfor_args,
        kernel_arg_types=func_arg_types,
        queue=exec_queue,
    )

1	import copy	1✔
2	import warnings	1✔
3
4	from numba.core import types	1✔
5	from numba.core.errors import NumbaParallelSafetyWarning	1✔
6	from numba.core.ir_utils import (	1✔
7	add_offset_to_labels,
8	get_name_var_table,
9	get_unused_var_name,
10	legalize_names,
11	mk_unique_var,
12	remove_dels,
13	rename_labels,
14	replace_var_names,
15	)
16	from numba.core.typing import signature	1✔
17
18	from numba_dpex import config	1✔
19
20	from .kernel_builder import (	1✔
21	ParforKernel,
22	_compile_kernel_parfor,
23	_print_body,
24	_to_scalar_from_0d,
25	)
26	from .kernel_templates.partial_reduction_template import (	1✔
27	RemainderReduceIntermediateKernelTemplate,
28	TreeReduceIntermediateKernelTemplate,
29	)
30	from .reduction_helper import update_sentinel	1✔
31
32
33	def create_reduction_main_kernel_for_parfor(	1✔
34	loop_ranges,
35	parfor_node,
36	typemap,
37	flags,
38	has_aliases,
39	reductionKernelVar,
40	parfor_reddict=None,
41	):
42	"""
43	Creates a numba_dpex.kernel function for a parfor node.
44
45	There are two parts to this function:
46
47	1) Code to iterate across the iteration space as defined by
48	the schedule.
49	2) The parfor body that does the work for a single point in
50	the iteration space.
51
52	Part 1 is created as Python text for simplicity with a sentinel
53	assignment to mark the point in the IR where the parfor body
54	should be added. This Python text is 'exec'ed into existence and its
55	IR retrieved with run_frontend. The IR is scanned for the sentinel
56	assignment where that basic block is split and the IR for the parfor
57	body inserted.
58	"""
59
60	redarrs = reductionKernelVar.parfor_redvars_to_redarrs	1✔
61	parfor_legalized_params = reductionKernelVar.parfor_legalized_params	1✔
62	parfor_redvars = reductionKernelVar.parfor_redvars	1✔
63	parfor_args = reductionKernelVar.parfor_params	1✔
64	parfor_redarrs_legal_dict = reductionKernelVar.parfor_redarrs_legal_dict	1✔
65	param_types = reductionKernelVar.param_types	1✔
66	func_arg_types = reductionKernelVar.func_arg_types	1✔
67	loop_body = copy.deepcopy(reductionKernelVar.loop_body)	1✔
68	legal_loop_indices = reductionKernelVar.legal_loop_indices	1✔
69	param_dict = reductionKernelVar.param_dict	1✔
70	redvars_legal_dict = reductionKernelVar.redvars_legal_dict	1✔
71	work_group_size = reductionKernelVar.work_group_size	1✔
72
73	loc = parfor_node.init_block.loc	1✔
74
75	for race in parfor_node.races:	1!
NEW 76	msg = (	×
77	"Variable %s used in parallel loop may be written "
78	"to simultaneously by multiple workers and may result "
79	"in non-deterministic or unintended results." % race
80	)
NEW 81	warnings.warn(NumbaParallelSafetyWarning(msg, loc))	×
82
83	loop_body_var_table = get_name_var_table(loop_body)	1✔
84	sentinel_name = get_unused_var_name("__sentinel__", loop_body_var_table)	1✔
85
86	# Determine the unique names of the scheduling and gufunc functions.
87	kernel_name = "__numba_parfor_gufunc_%s" % (parfor_node.id)	1✔
88
89	# swap s.2 (redvar) with partial_sum
90	for i, name in enumerate(parfor_args):	1✔
91	try:	1✔
92	tmp = redarrs[name][0]	1✔
93	nameNew = parfor_redarrs_legal_dict[tmp]	1✔
94	parfor_legalized_params[i] = nameNew	1✔
95	param_types[i] = _to_scalar_from_0d(typemap[tmp])	1✔
96	func_arg_types[i] = _to_scalar_from_0d(typemap[tmp])	1✔
97
98	except KeyError:	1✔
99	pass	1✔
100
101	kernel_template = TreeReduceIntermediateKernelTemplate(	1✔
102	kernel_name=kernel_name,
103	kernel_params=parfor_legalized_params,
104	ivar_names=legal_loop_indices,
105	sentinel_name=sentinel_name,
106	loop_ranges=loop_ranges,
107	param_dict=param_dict,
108	parfor_dim=len(parfor_node.loop_nests),
109	redvars=parfor_redvars,
110	parfor_args=parfor_args,
111	parfor_reddict=parfor_reddict,
112	redvars_dict=redvars_legal_dict,
113	typemap=typemap,
114	work_group_size=work_group_size,
115	)
116	kernel_ir = kernel_template.kernel_ir	1✔
117
118	for i, name in enumerate(parfor_args):	1✔
119	try:	1✔
120	tmp = redarrs[name][0]	1✔
121	parfor_args[i] = tmp	1✔
122	except KeyError:	1✔
123	pass	1✔
124
125	# rename all variables in kernel_ir afresh
126	var_table = get_name_var_table(kernel_ir.blocks)	1✔
127	new_var_dict = {}	1✔
128	reserved_names = (	1✔
129	[sentinel_name] + list(param_dict.values()) + legal_loop_indices
130	)
131	for name, _ in var_table.items():	1✔
132	if not (name in reserved_names):	1✔
133	new_var_dict[name] = mk_unique_var(name)	1✔
134
135	replace_var_names(kernel_ir.blocks, new_var_dict)	1✔
136	kernel_param_types = param_types	1✔
137	gufunc_stub_last_label = max(kernel_ir.blocks.keys()) + 1	1✔
138	# Add gufunc stub last label to each parfor.loop_body label to prevent
139	# label conflicts.
140	loop_body = add_offset_to_labels(loop_body, gufunc_stub_last_label)	1✔
141	# new label for splitting sentinel block
142	new_label = max(loop_body.keys()) + 1	1✔
143
144	update_sentinel(kernel_ir, sentinel_name, loop_body, new_label)	1✔
145
146	# FIXME: Why rename and remove dels causes the partial_sum array update
147	# instructions to be removed.
148	kernel_ir.blocks = rename_labels(kernel_ir.blocks)	1✔
149	remove_dels(kernel_ir.blocks)	1✔
150
151	old_alias = flags.noalias	1✔
152
153	if not has_aliases:	1!
154	flags.noalias = True	1✔
155
156	kernel_sig = signature(types.none, *kernel_param_types)	1✔
157	exec_queue = typemap[parfor_args[0]].queue	1✔
158
159	sycl_kernel = _compile_kernel_parfor(	1✔
160	exec_queue,
161	kernel_name,
162	kernel_ir,
163	kernel_param_types,
164	debug=flags.debuginfo,
165	)
166
167	flags.noalias = old_alias	1✔
168
169	return ParforKernel(	1✔
170	name=kernel_name,
171	kernel=sycl_kernel,
172	signature=kernel_sig,
173	kernel_args=parfor_args,
174	kernel_arg_types=func_arg_types,
175	queue=exec_queue,
176	)
177
178
179	def create_reduction_remainder_kernel_for_parfor(	1✔
180	parfor_node,
181	typemap,
182	flags,
183	has_aliases,
184	reductionKernelVar,
185	parfor_reddict,
186	reductionHelperList,
187	):
188	"""
189	Creates a numba_dpex.kernel function for a parfor node.
190
191	There are two parts to this function:
192
193	1) Code to iterate across the iteration space as defined by
194	the schedule.
195	2) The parfor body that does the work for a single point in
196	the iteration space.
197
198	Part 1 is created as Python text for simplicity with a sentinel
199	assignment to mark the point in the IR where the parfor body
200	should be added. This Python text is 'exec'ed into existence and its
201	IR retrieved with run_frontend. The IR is scanned for the sentinel
202	assignment where that basic block is split and the IR for the parfor
203	body inserted.
204	"""
205
206	parfor_legalized_params = reductionKernelVar.parfor_legalized_params	1✔
207	parfor_redvars = reductionKernelVar.parfor_redvars	1✔
208	parfor_args = reductionKernelVar.parfor_params	1✔
209	# parfor_redarrs_legal_dict = reductionKernelVar.parfor_redarrs_legal_dict
210	param_types = reductionKernelVar.param_types	1✔
211	func_arg_types = reductionKernelVar.func_arg_types	1✔
212	loop_body = copy.deepcopy(reductionKernelVar.loop_body)	1✔
213	legal_loop_indices = reductionKernelVar.legal_loop_indices	1✔
214	param_dict = reductionKernelVar.param_dict	1✔
215	redvars_legal_dict = reductionKernelVar.redvars_legal_dict	1✔
216
217	loc = parfor_node.init_block.loc	1✔
218
219	for race in parfor_node.races:	1!
NEW 220	msg = (	×
221	"Variable %s used in parallel loop may be written "
222	"to simultaneously by multiple workers and may result "
223	"in non-deterministic or unintended results." % race
224	)
NEW 225	warnings.warn(NumbaParallelSafetyWarning(msg, loc))	×
226
227	loop_body_var_table = get_name_var_table(loop_body)	1✔
228	sentinel_name = get_unused_var_name("__sentinel__", loop_body_var_table)	1✔
229
230	global_size_var_name = []	1✔
231	global_size_mod_var_name = []	1✔
232	partial_sum_var_name = []	1✔
233	partial_sum_size_var_name = []	1✔
234	final_sum_var_name = []	1✔
235
236	for i, _ in enumerate(parfor_redvars):	1✔
237	reductionHelper = reductionHelperList[i]	1✔
238	name = reductionHelper.partial_sum_var.name	1✔
239	partial_sum_var_name.append(name)	1✔
240
241	name = reductionHelper.global_size_var.name	1✔
242	global_size_var_name.append(name)	1✔
243
244	name = reductionHelper.global_size_mod_var.name	1✔
245	global_size_mod_var_name.append(name)	1✔
246
247	name = reductionHelper.partial_sum_size_var.name	1✔
248	partial_sum_size_var_name.append(name)	1✔
249
250	name = reductionHelper.final_sum_var.name	1✔
251	final_sum_var_name.append(name)	1✔
252
253	kernel_name = "__numba_parfor_gufunc_%s_sum2" % (parfor_node.id)	1✔
254
255	partial_sum_var_dict = legalize_names(partial_sum_var_name)	1✔
256	global_size_var_dict = legalize_names(global_size_var_name)	1✔
257	global_size_mod_var_dict = legalize_names(global_size_mod_var_name)	1✔
258	partial_sum_size_var_dict = legalize_names(partial_sum_size_var_name)	1✔
259	final_sum_var_dict = legalize_names(final_sum_var_name)	1✔
260
261	partial_sum_var_legal_name = [	1✔
262	partial_sum_var_dict[v] for v in partial_sum_var_dict
263	]
264
265	global_size_var_legal_name = [	1✔
266	global_size_var_dict[v] for v in global_size_var_dict
267	]
268	global_size_mod_var_legal_name = [	1✔
269	global_size_mod_var_dict[v] for v in global_size_mod_var_dict
270	]
271	partial_sum_size_var_legal_name = [	1✔
272	partial_sum_size_var_dict[v] for v in partial_sum_size_var_dict
273	]
274	final_sum_var_legal_name = [	1✔
275	final_sum_var_dict[v] for v in final_sum_var_dict
276	]
277
278	kernel_template = RemainderReduceIntermediateKernelTemplate(	1✔
279	kernel_name=kernel_name,
280	kernel_params=parfor_legalized_params,
281	sentinel_name=sentinel_name,
282	legal_loop_indices=legal_loop_indices,
283	redvars_dict=redvars_legal_dict,
284	redvars=parfor_redvars,
285	parfor_reddict=parfor_reddict,
286	typemap=typemap,
287	global_size_var_name=global_size_var_legal_name,
288	global_size_mod_var_name=global_size_mod_var_legal_name,
289	partial_sum_size_var_name=partial_sum_size_var_legal_name,
290	partial_sum_var_name=partial_sum_var_legal_name,
291	final_sum_var_name=final_sum_var_legal_name,
292	reductionKernelVar=reductionKernelVar,
293	)
294	kernel_ir = kernel_template.kernel_ir	1✔
295
296	var_table = get_name_var_table(kernel_ir.blocks)	1✔
297	new_var_dict = {}	1✔
298	reserved_names = (	1✔
299	[sentinel_name] + list(param_dict.values()) + legal_loop_indices
300	)
301	for name, _ in var_table.items():	1✔
302	if not (name in reserved_names):	1✔
303	new_var_dict[name] = mk_unique_var(name)	1✔
304	replace_var_names(kernel_ir.blocks, new_var_dict)	1✔
305
306	for i, _ in enumerate(parfor_redvars):	1✔
307	if reductionHelperList[i].global_size_var is not None:	1!
308	parfor_args.append(global_size_var_name[i])	1✔
309	parfor_legalized_params.append(global_size_var_legal_name[i])	1✔
310	param_types.append(	1✔
311	_to_scalar_from_0d(typemap[global_size_var_name[i]])
312	)
313	func_arg_types.append(	1✔
314	_to_scalar_from_0d(typemap[global_size_var_name[i]])
315	)
316
317	if reductionHelperList[i].global_size_mod_var is not None:	1!
318	parfor_args.append(global_size_mod_var_name[i])	1✔
319	parfor_legalized_params.append(global_size_mod_var_legal_name[i])	1✔
320
321	param_types.append(	1✔
322	_to_scalar_from_0d(typemap[global_size_mod_var_name[i]])
323	)
324	func_arg_types.append(	1✔
325	_to_scalar_from_0d(typemap[global_size_mod_var_name[i]])
326	)
327
328	if reductionHelperList[i].partial_sum_size_var is not None:	1!
329	parfor_args.append(partial_sum_size_var_name[i])	1✔
330	parfor_legalized_params.append(partial_sum_size_var_legal_name[i])	1✔
331	param_types.append(	1✔
332	_to_scalar_from_0d(typemap[partial_sum_size_var_name[i]])
333	)
334	func_arg_types.append(	1✔
335	_to_scalar_from_0d(typemap[partial_sum_size_var_name[i]])
336	)
337	if reductionHelperList[i].final_sum_var is not None:	1!
338	parfor_args.append(final_sum_var_name[i])	1✔
339	parfor_legalized_params.append(final_sum_var_legal_name[i])	1✔
340	param_types.append(	1✔
341	_to_scalar_from_0d(typemap[final_sum_var_name[i]])
342	)
343	func_arg_types.append(	1✔
344	_to_scalar_from_0d(typemap[final_sum_var_name[i]])
345	)
346
347	kernel_param_types = param_types	1✔
348
349	gufunc_stub_last_label = max(kernel_ir.blocks.keys()) + 1	1✔
350
351	# Add gufunc stub last label to each parfor.loop_body label to prevent
352	# label conflicts.
353	loop_body = add_offset_to_labels(loop_body, gufunc_stub_last_label)	1✔
354	# new label for splitting sentinel block
355	new_label = max(loop_body.keys()) + 1	1✔
356
357	update_sentinel(kernel_ir, sentinel_name, loop_body, new_label)	1✔
358
359	old_alias = flags.noalias	1✔
360	if not has_aliases:	1!
361	flags.noalias = True	1✔
362
363	kernel_sig = signature(types.none, *kernel_param_types)	1✔
364
365	# FIXME: Enable check after CFD pass has been added
366	# exec_queue = determine_kernel_launch_queue(
367	# args=parfor_args, argtypes=kernel_param_types, kernel_name=kernel_name
368	# )
369	exec_queue = typemap[parfor_args[0]].queue	1✔
370
371	sycl_kernel = _compile_kernel_parfor(	1✔
372	exec_queue,
373	kernel_name,
374	kernel_ir,
375	kernel_param_types,
376	debug=flags.debuginfo,
377	)
378
379	flags.noalias = old_alias	1✔
380
381	return ParforKernel(	1✔
382	name=kernel_name,
383	kernel=sycl_kernel,
384	signature=kernel_sig,
385	kernel_args=parfor_args,
386	kernel_arg_types=func_arg_types,
387	queue=exec_queue,
388	)

IntelPython / numba-dpex / 4964796786

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