7253910063

Committed 18 Dec 2023 09:16PM UTC coverage: 79.575% (-0.09%) from 79.663%

Build # 7253910063

Build Type

Pull #1144

github

Committed by

web-flow

Commit Message

Merge 00ef0bfc2 into 6b76fd3de

Pull Request Pull Request #1144: Implement support for dpnp.arange()

Run Details

1288 of 1882 branches covered (0.0%)

Branch coverage included in aggregate %.

148 of 183 new or added lines in 3 files covered. (80.87%)

1 existing line in 1 file now uncovered.

5534 of 6691 relevant lines covered (82.71%)

0.83 hits per line

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

86.01

/numba_dpex/core/parfors/parfor_lowerer.py

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

import copy
from collections import namedtuple

from llvmlite import ir as llvmir
from numba.core import cgutils, ir, types
from numba.parfors.parfor import (
    find_potential_aliases_parfor,
    get_parfor_outputs,
)

from numba_dpex import config
from numba_dpex.core.parfors.reduction_helper import (
    ReductionHelper,
    ReductionKernelVariables,
)
from numba_dpex.core.utils.kernel_launcher import KernelLaunchIRBuilder
from numba_dpex.dpctl_iface import libsyclinterface_bindings as sycl
from numba_dpex.core.datamodel.models import (
    dpex_data_model_manager as kernel_dmm,
)

from ..exceptions import UnsupportedParforError
from ..types.dpnp_ndarray_type import DpnpNdArray
from .kernel_builder import ParforKernel, create_kernel_for_parfor
from .reduction_kernel_builder import (
    create_reduction_main_kernel_for_parfor,
    create_reduction_remainder_kernel_for_parfor,
)


# A global list of kernels to keep the objects alive indefinitely.
keep_alive_kernels = []


def _getvar(lowerer, x):
    """Returns the LLVM Value corresponding to a Numba IR variable.

    Depending on if Numba's sroa-like optimization is enabled or not, the
    LLVM value for an Numba IR variable is found in either the ``varmap``
    or the ``blk_local_varmap`` of the ``lowerer``. If the LLVM Value is not a
    pointer, e.g., in case of function args with sroa optimization enabled, then
    creates an alloca and stores the Value into the new alloca Value and returns
    it. The extra alloca is needed as all inputs to a kernel function need to
    be passed by reference and not value.

    Args:
        lowerer: The Numba Lower instance used to lower the function.
        x: Numba IR variable name used to lookup the corresponding
           LLVM Value.

    Raises:
        AssertionError: If the LLVM Value for ``x`` does not exist in either
            the ``varmap`` or the ``blk_local_varmap``.

    Returns: An LLVM Value object

    """
    var_val = None
    if x in lowerer._blk_local_varmap:
        var_val = lowerer._blk_local_varmap[x]
    elif x in lowerer.varmap:
        var_val = lowerer.varmap[x]

    if var_val:
        if isinstance(var_val.type, llvmir.PointerType):
            return lowerer.builder.load(var_val)
        else:
            return var_val
    else:
        raise AssertionError("No llvm Value found for kernel arg")


def _load_range(lowerer, value):
    if isinstance(value, ir.Var):
        return lowerer.loadvar(value.name)
    else:
        return lowerer.context.get_constant(types.uintp, value)


class ParforLowerImpl:
    """Provides a custom lowerer for parfor nodes that generates a SYCL kernel
    for a parfor and submits it to a queue.
    """

    def _loop_ranges(
        self,
        lowerer,
        loop_ranges,
    ):
        # Create a global range over which to submit the kernel based on the
        # loop_ranges of the parfor
        global_range = []

        # SYCL ranges can have at max 3 dimension. If the parfor is of a higher
        # dimension then the indexing for the higher dimensions is done inside
        # the kernel.
        global_range_rank = len(loop_ranges) if len(loop_ranges) < 3 else 3

        for i in range(global_range_rank):
            start, stop, step = loop_ranges[i]
            stop = _load_range(lowerer, stop)
            if step != 1:
                raise UnsupportedParforError(
                    "non-unit strides are not yet supported."
                )
            global_range.append(stop)
        # For now the local_range is always an empty list as numba_dpex always
        # submits kernels generated for parfor nodes as range kernels.
        # The provision is kept here if in future there is newer functionality
        # to submit these kernels as ndrange.
        local_range = []

        return global_range, local_range

    def _reduction_ranges(
        self,
        lowerer,
        reductionHelper=None,
    ):
        # Create a global range over which to submit the kernel based on the
        # loop_ranges of the parfor
        global_range = []

        stop = reductionHelper.global_size_var
        stop = _load_range(lowerer, stop)
        global_range.append(stop)

        local_range = []
        local_range.append(
            _load_range(lowerer, reductionHelper.work_group_size)
        )

        return global_range, local_range

    def _remainder_ranges(self, lowerer):
        # Create a global range over which to submit the kernel based on the
        # loop_ranges of the parfor
        global_range = []

        stop = _load_range(lowerer, 1)

        global_range.append(stop)

        local_range = []

        return global_range, local_range

    def _submit_parfor_kernel(
        self,
        lowerer,
        kernel_fn: ParforKernel,
        global_range,
        local_range,
    ):
        """
        Adds a call to submit a kernel function into the function body of the
        current Numba JIT compiled function.
        """
        # Ensure that the Python arguments are kept alive for the duration of
        # the kernel execution
        keep_alive_kernels.append(kernel_fn.kernel)
        kl_builder = KernelLaunchIRBuilder(
            lowerer.context, lowerer.builder, kernel_dmm
        )

        queue_ref = kl_builder.get_queue(exec_queue=kernel_fn.queue)

        kernel_args = []
        for arg in kernel_fn.kernel_args:
            kernel_args.append(_getvar(lowerer, arg))

        kernel_ref_addr = kernel_fn.kernel.addressof_ref()
        kernel_ref = lowerer.builder.inttoptr(
            lowerer.context.get_constant(types.uintp, kernel_ref_addr),
            cgutils.voidptr_t,
        )

        kl_builder.set_kernel(kernel_ref)
        kl_builder.set_queue(queue_ref)
        kl_builder.set_range(global_range, local_range)
        kl_builder.set_arguments(
            kernel_fn.kernel_arg_types, kernel_args=kernel_args
        )
        kl_builder.set_dependent_events([])
        event_ref = kl_builder.submit()

        sycl.dpctl_event_wait(lowerer.builder, event_ref)
        sycl.dpctl_event_delete(lowerer.builder, event_ref)
        sycl.dpctl_queue_delete(lowerer.builder, queue_ref)

    def _reduction_codegen(
        self,
        parfor,
        typemap,
        nredvars,
        parfor_redvars,
        parfor_reddict,
        lowerer,
        parfor_output_arrays,
        loop_ranges,
        flags,
        alias_map,
    ):
        """
        Reduction kernel generation and submission.
        """
        inputArrayName = None
        for para in parfor.params:
            if not isinstance(typemap[para], DpnpNdArray):
                continue
            inputArrayName = para
            break

        if inputArrayName is None:
            raise AssertionError

        inputArrayType = typemap[inputArrayName]

        reductionHelperList = []
        for i in range(nredvars):
            reductionHelper = ReductionHelper()
            reductionHelper._allocate_partial_reduction_arrays(
                parfor,
                lowerer,
                parfor_redvars[i],
                inputArrayType,
            )
            reductionHelperList.append(reductionHelper)

        reductionKernelVar = ReductionKernelVariables(
            lowerer=lowerer,
            parfor_node=parfor,
            typemap=typemap,
            parfor_outputs=parfor_output_arrays,
            reductionHelperList=reductionHelperList,
        )

        if len(parfor.loop_nests) > 1:
            raise UnsupportedParforError(
                "Reduction with nested loop is not yet supported."
            )

        parfor_kernel = create_reduction_main_kernel_for_parfor(
            loop_ranges,
            parfor,
            typemap,
            flags,
            bool(alias_map),
            reductionKernelVar,
            parfor_reddict,
        )

        global_range, local_range = self._reduction_ranges(
            lowerer, reductionHelperList[0]
        )

        self._submit_parfor_kernel(
            lowerer,
            parfor_kernel,
            global_range,
            local_range,
        )

        parfor_kernel = create_reduction_remainder_kernel_for_parfor(
            parfor,
            typemap,
            flags,
            bool(alias_map),
            reductionKernelVar,
            parfor_reddict,
            reductionHelperList,
        )

        global_range, local_range = self._remainder_ranges(lowerer)

        self._submit_parfor_kernel(
            lowerer,
            parfor_kernel,
            global_range,
            local_range,
        )

        reductionKernelVar.copy_final_sum_to_host(parfor_kernel)

    def _lower_parfor_as_kernel(self, lowerer, parfor):
        """Lowers a parfor node created by the dpjit compiler to a
        ``numba_dpex.kernel``.

        The general approach is as follows:

            - The code from the parfor's init block is lowered normally
              in the context of the current function.
            - The body of the parfor is transformed into a kernel function.
            - Dpctl runtime calls to submit the kernel are added.

        """
        # We copy the typemap here because for race condition variable we'll
        # update their type to array so they can be updated by the kernel.
        orig_typemap = lowerer.fndesc.typemap

        # replace original typemap with copy and restore the original at the
        # end.
        lowerer.fndesc.typemap = copy.copy(orig_typemap)

        if config.DEBUG_ARRAY_OPT:
            print("lowerer.fndesc", lowerer.fndesc, type(lowerer.fndesc))

        typemap = lowerer.fndesc.typemap
        varmap = lowerer.varmap

        loc = parfor.init_block.loc
        scope = parfor.init_block.scope

        # Lower the init block of the parfor.
        for instr in parfor.init_block.body:
            lowerer.lower_inst(instr)

        for racevar in parfor.races:
            if racevar not in varmap:
                rvtyp = typemap[racevar]
                rv = ir.Var(scope, racevar, loc)
                lowerer._alloca_var(rv.name, rvtyp)

        alias_map = {}
        arg_aliases = {}

        find_potential_aliases_parfor(
            parfor,
            parfor.params,
            typemap,
            lowerer.func_ir,
            alias_map,
            arg_aliases,
        )

        # run get_parfor_outputs() and get_parfor_reductions() before
        # kernel creation since Jumps are modified so CFG of loop_body
        # dict will become invalid
        if parfor.params is None:
            raise AssertionError

        parfor_output_arrays = get_parfor_outputs(parfor, parfor.params)

        # compile parfor body as a separate dpex kernel function
        flags = copy.copy(parfor.flags)
        flags.error_model = "numpy"

        # Can't get here unless
        # flags.set('auto_parallel', ParallelOptions(True)) # noqa: E800
        index_var_typ = typemap[parfor.loop_nests[0].index_variable.name]

        # index variables should have the same type, check rest of indices
        for loop_nest in parfor.loop_nests[1:]:
            if typemap[loop_nest.index_variable.name] != index_var_typ:
                raise AssertionError

        loop_ranges = [
            (loop_nest.start, loop_nest.stop, loop_nest.step)
            for loop_nest in parfor.loop_nests
        ]

        parfor_redvars, parfor_reddict = parfor.redvars, parfor.reddict

        nredvars = len(parfor_redvars)
        if nredvars > 0:
            self._reduction_codegen(
                parfor,
                typemap,
                nredvars,
                parfor_redvars,
                parfor_reddict,
                lowerer,
                parfor_output_arrays,
                loop_ranges,
                flags,
                alias_map,
            )
        else:
            try:
                parfor_kernel = create_kernel_for_parfor(
                    lowerer,
                    parfor,
                    typemap,
                    flags,
                    loop_ranges,
                    bool(alias_map),
                    parfor.races,
                    parfor_output_arrays,
                )
            except Exception:
                # FIXME: Make the exception more informative
                raise UnsupportedParforError

            global_range, local_range = self._loop_ranges(lowerer, loop_ranges)

            # Finally submit the kernel
            self._submit_parfor_kernel(
                lowerer,
                parfor_kernel,
                global_range,
                local_range,
            )

        # TODO: free the kernel at this point

        # Restore the original typemap of the function that was replaced
        # temporarily at the beginning of this function.
        lowerer.fndesc.typemap = orig_typemap


class ParforLowerFactory:
    """A pseudo-factory class that maps a device filter string to a lowering
    function.

    Each Parfor instruction can have an optional "lowerer" attribute. The
    lowerer attribute determines how the parfor instruction should be lowered
    to LLVM IR. In addition, the lower attribute decides which parfor
    instructions can be fused together.

    The factory class maintains a dictionary mapping every device
    type (filter string) encountered so far to a lowerer function for that
    device type. At this point numba-dpex does not generate device-specific code
    and the lowerer used is same for all device types. However, as a different
    ParforLowerImpl instance is returned for every parfor instruction that has
    a distinct compute-follows-data inferred device it prevents illegal
    parfor fusion.
    """

    device_to_lowerer_map = {}

    @classmethod
    def get_lowerer(cls, device):
        try:
            lowerer = ParforLowerFactory.device_to_lowerer_map[device]
        except KeyError:
            lowerer = ParforLowerImpl()._lower_parfor_as_kernel
            ParforLowerFactory.device_to_lowerer_map[device] = lowerer

        return lowerer

1	# SPDX-FileCopyrightText: 2020 - 2022 Intel Corporation
2	#
3	# SPDX-License-Identifier: Apache-2.0
4
5	import copy	1✔
6	from collections import namedtuple	1✔
7
8	from llvmlite import ir as llvmir	1✔
9	from numba.core import cgutils, ir, types	1✔
10	from numba.parfors.parfor import (	1✔
11	find_potential_aliases_parfor,
12	get_parfor_outputs,
13	)
14
15	from numba_dpex import config	1✔
16	from numba_dpex.core.parfors.reduction_helper import (	1✔
17	ReductionHelper,
18	ReductionKernelVariables,
19	)
20	from numba_dpex.core.utils.kernel_launcher import KernelLaunchIRBuilder	1✔
21	from numba_dpex.dpctl_iface import libsyclinterface_bindings as sycl	1✔
22	from numba_dpex.core.datamodel.models import (	1✔
23	dpex_data_model_manager as kernel_dmm,
24	)
25
26	from ..exceptions import UnsupportedParforError	1✔
27	from ..types.dpnp_ndarray_type import DpnpNdArray	1✔
28	from .kernel_builder import ParforKernel, create_kernel_for_parfor	1✔
29	from .reduction_kernel_builder import (	1✔
30	create_reduction_main_kernel_for_parfor,
31	create_reduction_remainder_kernel_for_parfor,
32	)
33
34
35	# A global list of kernels to keep the objects alive indefinitely.
36	keep_alive_kernels = []	1✔
37
38
39	def _getvar(lowerer, x):	1✔
40	"""Returns the LLVM Value corresponding to a Numba IR variable.
41
42	Depending on if Numba's sroa-like optimization is enabled or not, the
43	LLVM value for an Numba IR variable is found in either the ``varmap``
44	or the ``blk_local_varmap`` of the ``lowerer``. If the LLVM Value is not a
45	pointer, e.g., in case of function args with sroa optimization enabled, then
46	creates an alloca and stores the Value into the new alloca Value and returns
47	it. The extra alloca is needed as all inputs to a kernel function need to
48	be passed by reference and not value.
49
50	Args:
51	lowerer: The Numba Lower instance used to lower the function.
52	x: Numba IR variable name used to lookup the corresponding
53	LLVM Value.
54
55	Raises:
56	AssertionError: If the LLVM Value for ``x`` does not exist in either
57	the ``varmap`` or the ``blk_local_varmap``.
58
59	Returns: An LLVM Value object
60
61	"""
62	var_val = None	1✔
63	if x in lowerer._blk_local_varmap:	1✔
64	var_val = lowerer._blk_local_varmap[x]	1✔
65	elif x in lowerer.varmap:	1!
66	var_val = lowerer.varmap[x]	1✔
67
68	if var_val:	1!
69	if isinstance(var_val.type, llvmir.PointerType):	1✔
70	return lowerer.builder.load(var_val)	1✔
71	else:
72	return var_val	1✔
73	else:
74	raise AssertionError("No llvm Value found for kernel arg")	×
75
76
77	def _load_range(lowerer, value):	1✔
78	if isinstance(value, ir.Var):	1✔
79	return lowerer.loadvar(value.name)	1✔
80	else:
81	return lowerer.context.get_constant(types.uintp, value)	1✔
82
83
84	class ParforLowerImpl:	1✔
85	"""Provides a custom lowerer for parfor nodes that generates a SYCL kernel
86	for a parfor and submits it to a queue.
87	"""
88
89	def _loop_ranges(	1✔
90	self,
91	lowerer,
92	loop_ranges,
93	):
94	# Create a global range over which to submit the kernel based on the
95	# loop_ranges of the parfor
96	global_range = []	1✔
97
98	# SYCL ranges can have at max 3 dimension. If the parfor is of a higher
99	# dimension then the indexing for the higher dimensions is done inside
100	# the kernel.
101	global_range_rank = len(loop_ranges) if len(loop_ranges) < 3 else 3	1✔
102
103	for i in range(global_range_rank):	1✔
104	start, stop, step = loop_ranges[i]	1✔
105	stop = _load_range(lowerer, stop)	1✔
106	if step != 1:	1!
107	raise UnsupportedParforError(	×
108	"non-unit strides are not yet supported."
109	)
110	global_range.append(stop)	1✔
111	# For now the local_range is always an empty list as numba_dpex always
112	# submits kernels generated for parfor nodes as range kernels.
113	# The provision is kept here if in future there is newer functionality
114	# to submit these kernels as ndrange.
115	local_range = []	1✔
116
117	return global_range, local_range	1✔
118
119	def _reduction_ranges(	1✔
120	self,
121	lowerer,
122	reductionHelper=None,
123	):
124	# Create a global range over which to submit the kernel based on the
125	# loop_ranges of the parfor
126	global_range = []	1✔
127
128	stop = reductionHelper.global_size_var	1✔
129	stop = _load_range(lowerer, stop)	1✔
130	global_range.append(stop)	1✔
131
132	local_range = []	1✔
133	local_range.append(	1✔
134	_load_range(lowerer, reductionHelper.work_group_size)
135	)
136
137	return global_range, local_range	1✔
138
139	def _remainder_ranges(self, lowerer):	1✔
140	# Create a global range over which to submit the kernel based on the
141	# loop_ranges of the parfor
142	global_range = []	1✔
143
144	stop = _load_range(lowerer, 1)	1✔
145
146	global_range.append(stop)	1✔
147
148	local_range = []	1✔
149
150	return global_range, local_range	1✔
151
152	def _submit_parfor_kernel(	1✔
153	self,
154	lowerer,
155	kernel_fn: ParforKernel,
156	global_range,
157	local_range,
158	):
159	"""
160	Adds a call to submit a kernel function into the function body of the
161	current Numba JIT compiled function.
162	"""
163	# Ensure that the Python arguments are kept alive for the duration of
164	# the kernel execution
165	keep_alive_kernels.append(kernel_fn.kernel)	1✔
166	kl_builder = KernelLaunchIRBuilder(	1✔
167	lowerer.context, lowerer.builder, kernel_dmm
168	)
169
170	queue_ref = kl_builder.get_queue(exec_queue=kernel_fn.queue)	1✔
171
172	kernel_args = []	1✔
173	for arg in kernel_fn.kernel_args:	1✔
174	kernel_args.append(_getvar(lowerer, arg))	1✔
175
176	kernel_ref_addr = kernel_fn.kernel.addressof_ref()	1✔
177	kernel_ref = lowerer.builder.inttoptr(	1✔
178	lowerer.context.get_constant(types.uintp, kernel_ref_addr),
179	cgutils.voidptr_t,
180	)
181
182	kl_builder.set_kernel(kernel_ref)	1✔
183	kl_builder.set_queue(queue_ref)	1✔
184	kl_builder.set_range(global_range, local_range)	1✔
185	kl_builder.set_arguments(	1✔
186	kernel_fn.kernel_arg_types, kernel_args=kernel_args
187	)
188	kl_builder.set_dependent_events([])	1✔
189	event_ref = kl_builder.submit()	1✔
190
191	sycl.dpctl_event_wait(lowerer.builder, event_ref)	1✔
192	sycl.dpctl_event_delete(lowerer.builder, event_ref)	1✔
193	sycl.dpctl_queue_delete(lowerer.builder, queue_ref)	1✔
194
195	def _reduction_codegen(	1✔
196	self,
197	parfor,
198	typemap,
199	nredvars,
200	parfor_redvars,
201	parfor_reddict,
202	lowerer,
203	parfor_output_arrays,
204	loop_ranges,
205	flags,
206	alias_map,
207	):
208	"""
209	Reduction kernel generation and submission.
210	"""
211	inputArrayName = None	1✔
212	for para in parfor.params:	1!
213	if not isinstance(typemap[para], DpnpNdArray):	1!
UNCOV 214	continue	×
215	inputArrayName = para	1✔
216	break	1✔
217
218	if inputArrayName is None:	1!
219	raise AssertionError	×
220
221	inputArrayType = typemap[inputArrayName]	1✔
222
223	reductionHelperList = []	1✔
224	for i in range(nredvars):	1✔
225	reductionHelper = ReductionHelper()	1✔
226	reductionHelper._allocate_partial_reduction_arrays(	1✔
227	parfor,
228	lowerer,
229	parfor_redvars[i],
230	inputArrayType,
231	)
232	reductionHelperList.append(reductionHelper)	1✔
233
234	reductionKernelVar = ReductionKernelVariables(	1✔
235	lowerer=lowerer,
236	parfor_node=parfor,
237	typemap=typemap,
238	parfor_outputs=parfor_output_arrays,
239	reductionHelperList=reductionHelperList,
240	)
241
242	if len(parfor.loop_nests) > 1:	1!
243	raise UnsupportedParforError(	×
244	"Reduction with nested loop is not yet supported."
245	)
246
247	parfor_kernel = create_reduction_main_kernel_for_parfor(	1✔
248	loop_ranges,
249	parfor,
250	typemap,
251	flags,
252	bool(alias_map),
253	reductionKernelVar,
254	parfor_reddict,
255	)
256
257	global_range, local_range = self._reduction_ranges(	1✔
258	lowerer, reductionHelperList[0]
259	)
260
261	self._submit_parfor_kernel(	1✔
262	lowerer,
263	parfor_kernel,
264	global_range,
265	local_range,
266	)
267
268	parfor_kernel = create_reduction_remainder_kernel_for_parfor(	1✔
269	parfor,
270	typemap,
271	flags,
272	bool(alias_map),
273	reductionKernelVar,
274	parfor_reddict,
275	reductionHelperList,
276	)
277
278	global_range, local_range = self._remainder_ranges(lowerer)	1✔
279
280	self._submit_parfor_kernel(	1✔
281	lowerer,
282	parfor_kernel,
283	global_range,
284	local_range,
285	)
286
287	reductionKernelVar.copy_final_sum_to_host(parfor_kernel)	1✔
288
289	def _lower_parfor_as_kernel(self, lowerer, parfor):	1✔
290	"""Lowers a parfor node created by the dpjit compiler to a
291	``numba_dpex.kernel``.
292
293	The general approach is as follows:
294
295	- The code from the parfor's init block is lowered normally
296	in the context of the current function.
297	- The body of the parfor is transformed into a kernel function.
298	- Dpctl runtime calls to submit the kernel are added.
299
300	"""
301	# We copy the typemap here because for race condition variable we'll
302	# update their type to array so they can be updated by the kernel.
303	orig_typemap = lowerer.fndesc.typemap	1✔
304
305	# replace original typemap with copy and restore the original at the
306	# end.
307	lowerer.fndesc.typemap = copy.copy(orig_typemap)	1✔
308
309	if config.DEBUG_ARRAY_OPT:	1!
310	print("lowerer.fndesc", lowerer.fndesc, type(lowerer.fndesc))	×
311
312	typemap = lowerer.fndesc.typemap	1✔
313	varmap = lowerer.varmap	1✔
314
315	loc = parfor.init_block.loc	1✔
316	scope = parfor.init_block.scope	1✔
317
318	# Lower the init block of the parfor.
319	for instr in parfor.init_block.body:	1✔
320	lowerer.lower_inst(instr)	1✔
321
322	for racevar in parfor.races:	1!
323	if racevar not in varmap:	×
324	rvtyp = typemap[racevar]	×
325	rv = ir.Var(scope, racevar, loc)	×
326	lowerer._alloca_var(rv.name, rvtyp)	×
327
328	alias_map = {}	1✔
329	arg_aliases = {}	1✔
330
331	find_potential_aliases_parfor(	1✔
332	parfor,
333	parfor.params,
334	typemap,
335	lowerer.func_ir,
336	alias_map,
337	arg_aliases,
338	)
339
340	# run get_parfor_outputs() and get_parfor_reductions() before
341	# kernel creation since Jumps are modified so CFG of loop_body
342	# dict will become invalid
343	if parfor.params is None:	1!
344	raise AssertionError	×
345
346	parfor_output_arrays = get_parfor_outputs(parfor, parfor.params)	1✔
347
348	# compile parfor body as a separate dpex kernel function
349	flags = copy.copy(parfor.flags)	1✔
350	flags.error_model = "numpy"	1✔
351
352	# Can't get here unless
353	# flags.set('auto_parallel', ParallelOptions(True)) # noqa: E800
354	index_var_typ = typemap[parfor.loop_nests[0].index_variable.name]	1✔
355
356	# index variables should have the same type, check rest of indices
357	for loop_nest in parfor.loop_nests[1:]:	1✔
358	if typemap[loop_nest.index_variable.name] != index_var_typ:	1!
359	raise AssertionError	×
360
361	loop_ranges = [	1✔
362	(loop_nest.start, loop_nest.stop, loop_nest.step)
363	for loop_nest in parfor.loop_nests
364	]
365
366	parfor_redvars, parfor_reddict = parfor.redvars, parfor.reddict	1✔
367
368	nredvars = len(parfor_redvars)	1✔
369	if nredvars > 0:	1✔
370	self._reduction_codegen(	1✔
371	parfor,
372	typemap,
373	nredvars,
374	parfor_redvars,
375	parfor_reddict,
376	lowerer,
377	parfor_output_arrays,
378	loop_ranges,
379	flags,
380	alias_map,
381	)
382	else:
383	try:	1✔
384	parfor_kernel = create_kernel_for_parfor(	1✔
385	lowerer,
386	parfor,
387	typemap,
388	flags,
389	loop_ranges,
390	bool(alias_map),
391	parfor.races,
392	parfor_output_arrays,
393	)
394	except Exception:	×
395	# FIXME: Make the exception more informative
396	raise UnsupportedParforError	×
397
398	global_range, local_range = self._loop_ranges(lowerer, loop_ranges)	1✔
399
400	# Finally submit the kernel
401	self._submit_parfor_kernel(	1✔
402	lowerer,
403	parfor_kernel,
404	global_range,
405	local_range,
406	)
407
408	# TODO: free the kernel at this point
409
410	# Restore the original typemap of the function that was replaced
411	# temporarily at the beginning of this function.
412	lowerer.fndesc.typemap = orig_typemap	1✔
413
414
415	class ParforLowerFactory:	1✔
416	"""A pseudo-factory class that maps a device filter string to a lowering
417	function.
418
419	Each Parfor instruction can have an optional "lowerer" attribute. The
420	lowerer attribute determines how the parfor instruction should be lowered
421	to LLVM IR. In addition, the lower attribute decides which parfor
422	instructions can be fused together.
423
424	The factory class maintains a dictionary mapping every device
425	type (filter string) encountered so far to a lowerer function for that
426	device type. At this point numba-dpex does not generate device-specific code
427	and the lowerer used is same for all device types. However, as a different
428	ParforLowerImpl instance is returned for every parfor instruction that has
429	a distinct compute-follows-data inferred device it prevents illegal
430	parfor fusion.
431	"""
432
433	device_to_lowerer_map = {}	1✔
434
435	@classmethod	1✔
436	def get_lowerer(cls, device):	1✔
437	try:	1✔
438	lowerer = ParforLowerFactory.device_to_lowerer_map[device]	1✔
439	except KeyError:	1✔
440	lowerer = ParforLowerImpl()._lower_parfor_as_kernel	1✔
441	ParforLowerFactory.device_to_lowerer_map[device] = lowerer	1✔
442
443	return lowerer	1✔

IntelPython / numba-dpex / 7253910063

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