6793858704

Committed 08 Nov 2023 04:42AM UTC coverage: 78.535% (-0.06%) from 78.594%

Build # 6793858704

Build Type

Pull #1144

github

Committed by

web-flow

Commit Message

Merge b9a745ef6 into fe619d074

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

Run Details

1190 of 1793 branches covered (0.0%)

Branch coverage included in aggregate %.

154 of 190 new or added lines in 3 files covered. (81.05%)

8 existing lines in 1 file now uncovered.

5191 of 6332 relevant lines covered (81.98%)

0.82 hits per line

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

91.3

/numba_dpex/core/runtime/context.py

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

import functools

import numba.core.unsafe.nrt
from llvmlite import ir as llvmir
from numba.core import cgutils, types


class DpexRTContext(object):
    """
    An object providing access to DPEXRT API in the lowering pass.
    """

    def __init__(self, context):
        self._context = context

    def _check_null_result(func):
        @functools.wraps(func)
        def wrap(self, builder, *args, **kwargs):
            memptr = func(self, builder, *args, **kwargs)
            msg = "In {0:s}.wrap(). USM allocation failed at {1:s}(). Check the usm_type and queue.".format(
                self.__class__.__name__, func.__name__
            )
            cgutils.guard_memory_error(self._context, builder, memptr, msg=msg)
            return memptr

        return wrap

    @_check_null_result
    def meminfo_alloc(self, builder, size, usm_type, queue_ref):
        """
        Wrapper to call :func:`~context.DpexRTContext.meminfo_alloc_unchecked`
        with null checking of the returned value.
        """

        return self.meminfo_alloc_unchecked(builder, size, usm_type, queue_ref)

    @_check_null_result
    def meminfo_fill(
        self,
        builder,
        meminfo,
        itemsize,
        dest_is_float,
        value_is_float,
        value,
        queue_ref,
    ):
        """
        Wrapper to call :func:`~context.DpexRTContext.meminfo_fill_unchecked`
        with null checking of the returned value.
        """
        return self.meminfo_fill_unchecked(
            builder,
            meminfo,
            itemsize,
            dest_is_float,
            value_is_float,
            value,
            queue_ref,
        )

    def meminfo_alloc_unchecked(self, builder, size, usm_type, queue_ref):
        """Allocate a new MemInfo with a data payload of `size` bytes.

        The result of the call is checked and if it is NULL, i.e. allocation
        failed, then a MemoryError is raised. If the allocation succeeded then
        a pointer to the MemInfo is returned.

        Args:
            builder (`llvmlite.ir.builder.IRBuilder`): LLVM IR builder.
            size (`llvmlite.ir.values.Argument`): LLVM uint64 value specifying
                the size in bytes for the data payload, i.e. i64 %"arg.allocsize"
            usm_type (`llvmlite.ir.values.Argument`): An LLVM Argument object
                specifying the type of the usm allocator. The constant value
                should match the values in
                ``dpctl's`` ``libsyclinterface::DPCTLSyclUSMType`` enum,
                i.e. i64 %"arg.usm_type".
            queue_ref (`llvmlite.ir.values.Argument`): An LLVM argument value storing
                the pointer to the address of the queue object, the object can be
                `dpctl.SyclQueue()`, i.e. i8* %"arg.queue".

        Returns:
            ret (`llvmlite.ir.instructions.CallInstr`): A pointer to the `MemInfo`
                is returned from the `DPEXRT_MemInfo_alloc` C function call.
        """

        mod = builder.module
        u64 = llvmir.IntType(64)
        fnty = llvmir.FunctionType(
            cgutils.voidptr_t, [cgutils.intp_t, u64, cgutils.voidptr_t]
        )
        fn = cgutils.get_or_insert_function(mod, fnty, "DPEXRT_MemInfo_alloc")
        fn.return_value.add_attribute("noalias")

        ret = builder.call(fn, [size, usm_type, queue_ref])

        return ret

    def meminfo_fill_unchecked(
        self,
        builder,
        meminfo,
        itemsize,
        dest_is_float,
        value_is_float,
        value,
        queue_ref,
    ):
        """Fills an allocated `MemInfo` with the value specified.

        The result of the call is checked and if it is `NULL`, i.e. the fill
        operation failed, then a `MemoryError` is raised. If the fill operation
        is succeeded then a pointer to the `MemInfo` is returned.

        Args:
            builder (`llvmlite.ir.builder.IRBuilder`): LLVM IR builder.
            meminfo (`llvmlite.ir.instructions.LoadInstr`): LLVM uint64 value
                specifying the size in bytes for the data payload.
            itemsize (`llvmlite.ir.values.Constant`): An LLVM Constant value
                specifying the size of the each data item allocated by the
                usm allocator.
            dest_is_float (`llvmlite.ir.values.Constant`): An LLVM Constant
                value specifying if the destination array type is floating
                point.
            value_is_float (`llvmlite.ir.values.Constant`): An LLVM Constant
                value specifying if the input value is a floating point.
            value (`llvmlite.ir.values.Constant`): An LLVM Constant value
                specifying if the input value that will be used to fill
                the array.
            queue_ref (`llvmlite.ir.instructions.ExtractValue`): An LLVM ExtractValue
                instruction object to extract the pointer to the queue from the
                DpctlSyclQueue type, i.e. %".74" = extractvalue {i8*, i8*} %".73", 1.

        Returns:
            ret (`llvmlite.ir.instructions.CallInstr`): A pointer to the `MemInfo`
                is returned from the `DPEXRT_MemInfo_fill` C function call.
        """

        mod = builder.module
        u64 = llvmir.IntType(64)
        b = llvmir.IntType(1)
        fnty = llvmir.FunctionType(
            cgutils.voidptr_t,
            [cgutils.voidptr_t, u64, b, b, u64, cgutils.voidptr_t],
        )
        fn = cgutils.get_or_insert_function(mod, fnty, "DPEXRT_MemInfo_fill")
        fn.return_value.add_attribute("noalias")

        ret = builder.call(
            fn,
            [
                meminfo,
                itemsize,
                dest_is_float,
                value_is_float,
                value,
                queue_ref,
            ],
        )

        return ret

    def arraystruct_from_python(self, pyapi, obj, ptr):
        """Generates a call to DPEXRT_sycl_usm_ndarray_from_python C function
        defined in the _DPREXRT_python Python extension.

        """
        fnty = llvmir.FunctionType(
            llvmir.IntType(32), [pyapi.pyobj, pyapi.voidptr]
        )
        fn = pyapi._get_function(fnty, "DPEXRT_sycl_usm_ndarray_from_python")
        fn.args[0].add_attribute("nocapture")
        fn.args[1].add_attribute("nocapture")

        self.error = pyapi.builder.call(fn, (obj, ptr))

        return self.error

    def queuestruct_from_python(self, pyapi, obj, ptr):
        """Calls the c function DPEXRT_sycl_queue_from_python"""
        fnty = llvmir.FunctionType(
            llvmir.IntType(32), [pyapi.voidptr, pyapi.pyobj, pyapi.voidptr]
        )
        nrt_api = self._context.nrt.get_nrt_api(pyapi.builder)

        fn = pyapi._get_function(fnty, "DPEXRT_sycl_queue_from_python")
        fn.args[0].add_attribute("nocapture")
        fn.args[1].add_attribute("nocapture")
        fn.args[2].add_attribute("nocapture")

        self.error = pyapi.builder.call(fn, (nrt_api, obj, ptr))
        return self.error

    def queuestruct_to_python(self, pyapi, val):
        """Calls the c function DPEXRT_sycl_queue_to_python"""

        fnty = llvmir.FunctionType(pyapi.pyobj, [pyapi.voidptr, pyapi.voidptr])
        nrt_api = self._context.nrt.get_nrt_api(pyapi.builder)

        fn = pyapi._get_function(fnty, "DPEXRT_sycl_queue_to_python")
        fn.args[0].add_attribute("nocapture")
        fn.args[1].add_attribute("nocapture")

        qptr = cgutils.alloca_once_value(pyapi.builder, val)
        ptr = pyapi.builder.bitcast(qptr, pyapi.voidptr)

        self.error = pyapi.builder.call(fn, [nrt_api, ptr])

        return self.error

    def eventstruct_from_python(self, pyapi, obj, ptr):
        """Calls the c function DPEXRT_sycl_event_from_python"""
        fnty = llvmir.FunctionType(
            llvmir.IntType(32), [pyapi.voidptr, pyapi.pyobj, pyapi.voidptr]
        )
        nrt_api = self._context.nrt.get_nrt_api(pyapi.builder)

        fn = pyapi._get_function(fnty, "DPEXRT_sycl_event_from_python")
        fn.args[0].add_attribute("nocapture")
        fn.args[1].add_attribute("nocapture")
        fn.args[2].add_attribute("nocapture")

        self.error = pyapi.builder.call(fn, (nrt_api, obj, ptr))
        return self.error

    def eventstruct_to_python(self, pyapi, val):
        """Calls the c function DPEXRT_sycl_event_to_python"""

        fnty = llvmir.FunctionType(pyapi.pyobj, [pyapi.voidptr, pyapi.voidptr])
        nrt_api = self._context.nrt.get_nrt_api(pyapi.builder)

        fn = pyapi._get_function(fnty, "DPEXRT_sycl_event_to_python")
        fn.args[0].add_attribute("nocapture")
        fn.args[1].add_attribute("nocapture")

        qptr = cgutils.alloca_once_value(pyapi.builder, val)
        ptr = pyapi.builder.bitcast(qptr, pyapi.voidptr)

        self.error = pyapi.builder.call(fn, [nrt_api, ptr])

        return self.error

    def usm_ndarray_to_python_acqref(self, pyapi, aryty, ary, dtypeptr):
        """Boxes a DpnpNdArray native object into a Python dpnp.ndarray.

        Args:
            pyapi (_type_): _description_
            aryty (_type_): _description_
            ary (_type_): _description_
            dtypeptr (_type_): _description_

        Returns:
            _type_: _description_
        """
        argtys = [
            pyapi.voidptr,
            pyapi.pyobj,
            llvmir.IntType(32),
            llvmir.IntType(32),
            pyapi.pyobj,
        ]
        fnty = llvmir.FunctionType(pyapi.pyobj, argtys)
        fn = pyapi._get_function(
            fnty, "DPEXRT_sycl_usm_ndarray_to_python_acqref"
        )
        fn.args[0].add_attribute("nocapture")

        aryptr = cgutils.alloca_once_value(pyapi.builder, ary)
        ptr = pyapi.builder.bitcast(aryptr, pyapi.voidptr)

        # Embed the Python type of the array (maybe subclass) in the LLVM IR.
        serialized = pyapi.serialize_object(aryty.box_type)
        serial_aryty_pytype = pyapi.unserialize(serialized)

        ndim = pyapi.context.get_constant(types.int32, aryty.ndim)
        writable = pyapi.context.get_constant(types.int32, int(aryty.mutable))

        args = [ptr, serial_aryty_pytype, ndim, writable, dtypeptr]
        return pyapi.builder.call(fn, args)

    def get_queue_from_filter_string(self, builder, device):
        """Calls DPEXRTQueue_CreateFromFilterString to create a new sycl::queue
        from a given filter string.

        Args:
            device (llvmlite.ir.values.FormattedConstant): An LLVM ArrayType
                storing a const string for a DPC++ filter selector string.

        Returns: A DPCTLSyclQueueRef pointer.
        """
        mod = builder.module
        fnty = llvmir.FunctionType(
            cgutils.voidptr_t,
            [cgutils.voidptr_t],
        )
        fn = cgutils.get_or_insert_function(
            mod, fnty, "DPEXRTQueue_CreateFromFilterString"
        )
        fn.return_value.add_attribute("noalias")

        ret = builder.call(fn, [device])

        return ret

    def submit_range(
        self,
        builder,
        kref,
        qref,
        args,
        argtys,
        nargs,
        range,
        nrange,
        depevents,
        ndepevents,
    ):
        """Calls DPEXRTQueue_CreateFromFilterString to create a new sycl::queue
        from a given filter string.

        Returns: A DPCTLSyclQueueRef pointer.
        """
        mod = builder.module
        fnty = llvmir.FunctionType(
            llvmir.types.VoidType(),
            [
                cgutils.voidptr_t,
                cgutils.voidptr_t,
                cgutils.voidptr_t.as_pointer(),
                cgutils.int32_t.as_pointer(),
                llvmir.IntType(64),
                llvmir.IntType(64).as_pointer(),
                llvmir.IntType(64),
                cgutils.voidptr_t,
                llvmir.IntType(64),
            ],
        )
        fn = cgutils.get_or_insert_function(
            mod, fnty, "DpexrtQueue_SubmitRange"
        )

        ret = builder.call(
            fn,
            [
                kref,
                qref,
                args,
                argtys,
                nargs,
                range,
                nrange,
                depevents,
                ndepevents,
            ],
        )

        return ret

    def submit_ndrange(
        self,
        builder,
        kref,
        qref,
        args,
        argtys,
        nargs,
        grange,
        lrange,
        ndims,
        depevents,
        ndepevents,
    ):
        """Calls DPEXRTQueue_CreateFromFilterString to create a new sycl::queue
        from a given filter string.

        Returns: A LLVM IR call inst.
        """

        mod = builder.module
        fnty = llvmir.FunctionType(
            llvmir.types.VoidType(),
            [
                cgutils.voidptr_t,
                cgutils.voidptr_t,
                cgutils.voidptr_t.as_pointer(),
                cgutils.int32_t.as_pointer(),
                llvmir.IntType(64),
                llvmir.IntType(64).as_pointer(),
                llvmir.IntType(64).as_pointer(),
                llvmir.IntType(64),
                cgutils.voidptr_t,
                llvmir.IntType(64),
            ],
        )
        fn = cgutils.get_or_insert_function(
            mod, fnty, "DpexrtQueue_SubmitNDRange"
        )

        ret = builder.call(
            fn,
            [
                kref,
                qref,
                args,
                argtys,
                nargs,
                grange,
                lrange,
                ndims,
                depevents,
                ndepevents,
            ],
        )

        return ret

1	# SPDX-FileCopyrightText: 2020 - 2023 Intel Corporation
2	#
3	# SPDX-License-Identifier: Apache-2.0
4
5	import functools	1✔
6
7	import numba.core.unsafe.nrt	1✔
8	from llvmlite import ir as llvmir	1✔
9	from numba.core import cgutils, types	1✔
10
11
12	class DpexRTContext(object):	1✔
13	"""
14	An object providing access to DPEXRT API in the lowering pass.
15	"""
16
17	def __init__(self, context):	1✔
18	self._context = context	1✔
19
20	def _check_null_result(func):	1✔
21	@functools.wraps(func)	1✔
22	def wrap(self, builder, args, *kwargs):	1✔
23	memptr = func(self, builder, args, *kwargs)	1✔
24	msg = "In {0:s}.wrap(). USM allocation failed at {1:s}(). Check the usm_type and queue.".format(	1✔
25	self.__class__.__name__, func.__name__
26	)
27	cgutils.guard_memory_error(self._context, builder, memptr, msg=msg)	1✔
28	return memptr	1✔
29
30	return wrap	1✔
31
32	@_check_null_result	1✔
33	def meminfo_alloc(self, builder, size, usm_type, queue_ref):	1✔
34	"""
35	Wrapper to call :func:`~context.DpexRTContext.meminfo_alloc_unchecked`
36	with null checking of the returned value.
37	"""
38
39	return self.meminfo_alloc_unchecked(builder, size, usm_type, queue_ref)	1✔
40
41	@_check_null_result	1✔
42	def meminfo_fill(	1✔
43	self,
44	builder,
45	meminfo,
46	itemsize,
47	dest_is_float,
48	value_is_float,
49	value,
50	queue_ref,
51	):
52	"""
53	Wrapper to call :func:`~context.DpexRTContext.meminfo_fill_unchecked`
54	with null checking of the returned value.
55	"""
56	return self.meminfo_fill_unchecked(	1✔
57	builder,
58	meminfo,
59	itemsize,
60	dest_is_float,
61	value_is_float,
62	value,
63	queue_ref,
64	)
65
66	def meminfo_alloc_unchecked(self, builder, size, usm_type, queue_ref):	1✔
67	"""Allocate a new MemInfo with a data payload of `size` bytes.
68
69	The result of the call is checked and if it is NULL, i.e. allocation
70	failed, then a MemoryError is raised. If the allocation succeeded then
71	a pointer to the MemInfo is returned.
72
73	Args:
74	builder (`llvmlite.ir.builder.IRBuilder`): LLVM IR builder.
75	size (`llvmlite.ir.values.Argument`): LLVM uint64 value specifying
76	the size in bytes for the data payload, i.e. i64 %"arg.allocsize"
77	usm_type (`llvmlite.ir.values.Argument`): An LLVM Argument object
78	specifying the type of the usm allocator. The constant value
79	should match the values in
80	``dpctl's`` ``libsyclinterface::DPCTLSyclUSMType`` enum,
81	i.e. i64 %"arg.usm_type".
82	queue_ref (`llvmlite.ir.values.Argument`): An LLVM argument value storing
83	the pointer to the address of the queue object, the object can be
84	`dpctl.SyclQueue()`, i.e. i8* %"arg.queue".
85
86	Returns:
87	ret (`llvmlite.ir.instructions.CallInstr`): A pointer to the `MemInfo`
88	is returned from the `DPEXRT_MemInfo_alloc` C function call.
89	"""
90
91	mod = builder.module	1✔
92	u64 = llvmir.IntType(64)	1✔
93	fnty = llvmir.FunctionType(	1✔
94	cgutils.voidptr_t, [cgutils.intp_t, u64, cgutils.voidptr_t]
95	)
96	fn = cgutils.get_or_insert_function(mod, fnty, "DPEXRT_MemInfo_alloc")	1✔
97	fn.return_value.add_attribute("noalias")	1✔
98
99	ret = builder.call(fn, [size, usm_type, queue_ref])	1✔
100
101	return ret	1✔
102
103	def meminfo_fill_unchecked(	1✔
104	self,
105	builder,
106	meminfo,
107	itemsize,
108	dest_is_float,
109	value_is_float,
110	value,
111	queue_ref,
112	):
113	"""Fills an allocated `MemInfo` with the value specified.
114
115	The result of the call is checked and if it is `NULL`, i.e. the fill
116	operation failed, then a `MemoryError` is raised. If the fill operation
117	is succeeded then a pointer to the `MemInfo` is returned.
118
119	Args:
120	builder (`llvmlite.ir.builder.IRBuilder`): LLVM IR builder.
121	meminfo (`llvmlite.ir.instructions.LoadInstr`): LLVM uint64 value
122	specifying the size in bytes for the data payload.
123	itemsize (`llvmlite.ir.values.Constant`): An LLVM Constant value
124	specifying the size of the each data item allocated by the
125	usm allocator.
126	dest_is_float (`llvmlite.ir.values.Constant`): An LLVM Constant
127	value specifying if the destination array type is floating
128	point.
129	value_is_float (`llvmlite.ir.values.Constant`): An LLVM Constant
130	value specifying if the input value is a floating point.
131	value (`llvmlite.ir.values.Constant`): An LLVM Constant value
132	specifying if the input value that will be used to fill
133	the array.
134	queue_ref (`llvmlite.ir.instructions.ExtractValue`): An LLVM ExtractValue
135	instruction object to extract the pointer to the queue from the
136	DpctlSyclQueue type, i.e. %".74" = extractvalue {i8, i8} %".73", 1.
137
138	Returns:
139	ret (`llvmlite.ir.instructions.CallInstr`): A pointer to the `MemInfo`
140	is returned from the `DPEXRT_MemInfo_fill` C function call.
141	"""
142
143	mod = builder.module	1✔
144	u64 = llvmir.IntType(64)	1✔
145	b = llvmir.IntType(1)	1✔
146	fnty = llvmir.FunctionType(	1✔
147	cgutils.voidptr_t,
148	[cgutils.voidptr_t, u64, b, b, u64, cgutils.voidptr_t],
149	)
150	fn = cgutils.get_or_insert_function(mod, fnty, "DPEXRT_MemInfo_fill")	1✔
151	fn.return_value.add_attribute("noalias")	1✔
152
153	ret = builder.call(	1✔
154	fn,
155	[
156	meminfo,
157	itemsize,
158	dest_is_float,
159	value_is_float,
160	value,
161	queue_ref,
162	],
163	)
164
165	return ret	1✔
166
167	def arraystruct_from_python(self, pyapi, obj, ptr):	1✔
168	"""Generates a call to DPEXRT_sycl_usm_ndarray_from_python C function
169	defined in the _DPREXRT_python Python extension.
170
171	"""
172	fnty = llvmir.FunctionType(	1✔
173	llvmir.IntType(32), [pyapi.pyobj, pyapi.voidptr]
174	)
175	fn = pyapi._get_function(fnty, "DPEXRT_sycl_usm_ndarray_from_python")	1✔
176	fn.args[0].add_attribute("nocapture")	1✔
177	fn.args[1].add_attribute("nocapture")	1✔
178
179	self.error = pyapi.builder.call(fn, (obj, ptr))	1✔
180
181	return self.error	1✔
182
183	def queuestruct_from_python(self, pyapi, obj, ptr):	1✔
184	"""Calls the c function DPEXRT_sycl_queue_from_python"""
185	fnty = llvmir.FunctionType(	1✔
186	llvmir.IntType(32), [pyapi.voidptr, pyapi.pyobj, pyapi.voidptr]
187	)
188	nrt_api = self._context.nrt.get_nrt_api(pyapi.builder)	1✔
189
190	fn = pyapi._get_function(fnty, "DPEXRT_sycl_queue_from_python")	1✔
191	fn.args[0].add_attribute("nocapture")	1✔
192	fn.args[1].add_attribute("nocapture")	1✔
193	fn.args[2].add_attribute("nocapture")	1✔
194
195	self.error = pyapi.builder.call(fn, (nrt_api, obj, ptr))	1✔
196	return self.error	1✔
197
198	def queuestruct_to_python(self, pyapi, val):	1✔
199	"""Calls the c function DPEXRT_sycl_queue_to_python"""
200
201	fnty = llvmir.FunctionType(pyapi.pyobj, [pyapi.voidptr, pyapi.voidptr])	1✔
202	nrt_api = self._context.nrt.get_nrt_api(pyapi.builder)	1✔
203
204	fn = pyapi._get_function(fnty, "DPEXRT_sycl_queue_to_python")	1✔
205	fn.args[0].add_attribute("nocapture")	1✔
206	fn.args[1].add_attribute("nocapture")	1✔
207
208	qptr = cgutils.alloca_once_value(pyapi.builder, val)	1✔
209	ptr = pyapi.builder.bitcast(qptr, pyapi.voidptr)	1✔
210
211	self.error = pyapi.builder.call(fn, [nrt_api, ptr])	1✔
212
213	return self.error	1✔
214
215	def eventstruct_from_python(self, pyapi, obj, ptr):	1✔
216	"""Calls the c function DPEXRT_sycl_event_from_python"""
217	fnty = llvmir.FunctionType(	1✔
218	llvmir.IntType(32), [pyapi.voidptr, pyapi.pyobj, pyapi.voidptr]
219	)
220	nrt_api = self._context.nrt.get_nrt_api(pyapi.builder)	1✔
221
222	fn = pyapi._get_function(fnty, "DPEXRT_sycl_event_from_python")	1✔
223	fn.args[0].add_attribute("nocapture")	1✔
224	fn.args[1].add_attribute("nocapture")	1✔
225	fn.args[2].add_attribute("nocapture")	1✔
226
227	self.error = pyapi.builder.call(fn, (nrt_api, obj, ptr))	1✔
228	return self.error	1✔
229
230	def eventstruct_to_python(self, pyapi, val):	1✔
231	"""Calls the c function DPEXRT_sycl_event_to_python"""
232
233	fnty = llvmir.FunctionType(pyapi.pyobj, [pyapi.voidptr, pyapi.voidptr])	1✔
234	nrt_api = self._context.nrt.get_nrt_api(pyapi.builder)	1✔
235
236	fn = pyapi._get_function(fnty, "DPEXRT_sycl_event_to_python")	1✔
237	fn.args[0].add_attribute("nocapture")	1✔
238	fn.args[1].add_attribute("nocapture")	1✔
239
240	qptr = cgutils.alloca_once_value(pyapi.builder, val)	1✔
241	ptr = pyapi.builder.bitcast(qptr, pyapi.voidptr)	1✔
242
243	self.error = pyapi.builder.call(fn, [nrt_api, ptr])	1✔
244
245	return self.error	1✔
246
247	def usm_ndarray_to_python_acqref(self, pyapi, aryty, ary, dtypeptr):	1✔
248	"""Boxes a DpnpNdArray native object into a Python dpnp.ndarray.
249
250	Args:
251	pyapi (_type_): _description_
252	aryty (_type_): _description_
253	ary (_type_): _description_
254	dtypeptr (_type_): _description_
255
256	Returns:
257	_type_: _description_
258	"""
259	argtys = [	1✔
260	pyapi.voidptr,
261	pyapi.pyobj,
262	llvmir.IntType(32),
263	llvmir.IntType(32),
264	pyapi.pyobj,
265	]
266	fnty = llvmir.FunctionType(pyapi.pyobj, argtys)	1✔
267	fn = pyapi._get_function(	1✔
268	fnty, "DPEXRT_sycl_usm_ndarray_to_python_acqref"
269	)
270	fn.args[0].add_attribute("nocapture")	1✔
271
272	aryptr = cgutils.alloca_once_value(pyapi.builder, ary)	1✔
273	ptr = pyapi.builder.bitcast(aryptr, pyapi.voidptr)	1✔
274
275	# Embed the Python type of the array (maybe subclass) in the LLVM IR.
276	serialized = pyapi.serialize_object(aryty.box_type)	1✔
277	serial_aryty_pytype = pyapi.unserialize(serialized)	1✔
278
279	ndim = pyapi.context.get_constant(types.int32, aryty.ndim)	1✔
280	writable = pyapi.context.get_constant(types.int32, int(aryty.mutable))	1✔
281
282	args = [ptr, serial_aryty_pytype, ndim, writable, dtypeptr]	1✔
283	return pyapi.builder.call(fn, args)	1✔
284
285	def get_queue_from_filter_string(self, builder, device):	1✔
286	"""Calls DPEXRTQueue_CreateFromFilterString to create a new sycl::queue
287	from a given filter string.
288
289	Args:
290	device (llvmlite.ir.values.FormattedConstant): An LLVM ArrayType
291	storing a const string for a DPC++ filter selector string.
292
293	Returns: A DPCTLSyclQueueRef pointer.
294	"""
295	mod = builder.module	1✔
296	fnty = llvmir.FunctionType(	1✔
297	cgutils.voidptr_t,
298	[cgutils.voidptr_t],
299	)
300	fn = cgutils.get_or_insert_function(	1✔
301	mod, fnty, "DPEXRTQueue_CreateFromFilterString"
302	)
303	fn.return_value.add_attribute("noalias")	1✔
304
305	ret = builder.call(fn, [device])	1✔
306
307	return ret	1✔
308
309	def submit_range(	1✔
310	self,
311	builder,
312	kref,
313	qref,
314	args,
315	argtys,
316	nargs,
317	range,
318	nrange,
319	depevents,
320	ndepevents,
321	):
322	"""Calls DPEXRTQueue_CreateFromFilterString to create a new sycl::queue
323	from a given filter string.
324
325	Returns: A DPCTLSyclQueueRef pointer.
326	"""
UNCOV 327	mod = builder.module	×
328	fnty = llvmir.FunctionType(	×
329	llvmir.types.VoidType(),
330	[
331	cgutils.voidptr_t,
332	cgutils.voidptr_t,
333	cgutils.voidptr_t.as_pointer(),
334	cgutils.int32_t.as_pointer(),
335	llvmir.IntType(64),
336	llvmir.IntType(64).as_pointer(),
337	llvmir.IntType(64),
338	cgutils.voidptr_t,
339	llvmir.IntType(64),
340	],
341	)
UNCOV 342	fn = cgutils.get_or_insert_function(	×
343	mod, fnty, "DpexrtQueue_SubmitRange"
344	)
345
UNCOV 346	ret = builder.call(	×
347	fn,
348	[
349	kref,
350	qref,
351	args,
352	argtys,
353	nargs,
354	range,
355	nrange,
356	depevents,
357	ndepevents,
358	],
359	)
360
UNCOV 361	return ret	×
362
363	def submit_ndrange(	1✔
364	self,
365	builder,
366	kref,
367	qref,
368	args,
369	argtys,
370	nargs,
371	grange,
372	lrange,
373	ndims,
374	depevents,
375	ndepevents,
376	):
377	"""Calls DPEXRTQueue_CreateFromFilterString to create a new sycl::queue
378	from a given filter string.
379
380	Returns: A LLVM IR call inst.
381	"""
382
UNCOV 383	mod = builder.module	×
384	fnty = llvmir.FunctionType(	×
385	llvmir.types.VoidType(),
386	[
387	cgutils.voidptr_t,
388	cgutils.voidptr_t,
389	cgutils.voidptr_t.as_pointer(),
390	cgutils.int32_t.as_pointer(),
391	llvmir.IntType(64),
392	llvmir.IntType(64).as_pointer(),
393	llvmir.IntType(64).as_pointer(),
394	llvmir.IntType(64),
395	cgutils.voidptr_t,
396	llvmir.IntType(64),
397	],
398	)
UNCOV 399	fn = cgutils.get_or_insert_function(	×
400	mod, fnty, "DpexrtQueue_SubmitNDRange"
401	)
402
UNCOV 403	ret = builder.call(	×
404	fn,
405	[
406	kref,
407	qref,
408	args,
409	argtys,
410	nargs,
411	grange,
412	lrange,
413	ndims,
414	depevents,
415	ndepevents,
416	],
417	)
418
UNCOV 419	return ret	×

IntelPython / numba-dpex / 6793858704

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