8439284519

Committed 26 Mar 2024 04:13PM UTC coverage: 81.745% (+0.1%) from 81.614%

Build # 8439284519

Build Type

Pull #1411

github

Committed by

web-flow

Commit Message

Merge cf239174a into 1e427c577

Pull Request Pull Request #1411: Remove/kernel_interface.spirv_kernel

Run Details

1395 of 1927 branches covered (72.39%)

Branch coverage included in aggregate %.

13 of 13 new or added lines in 4 files covered. (100.0%)

1 existing line in 1 file now uncovered.

5810 of 6887 relevant lines covered (84.36%)

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

IntelPython / numba-dpex / 8439284519

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