6328198945

Committed 27 Sep 2023 03:35PM UTC coverage: 76.346% (-0.4%) from 76.734%

Build # 6328198945

Build Type

Pull #1134

github

Committed by

web-flow

Commit Message

Merge 3bba852b0 into e674b5838

Pull Request Pull Request #1134: WIP: Add sycl event

Run Details

1073 of 1633 branches covered (0.0%)

Branch coverage included in aggregate %.

36 of 76 new or added lines in 7 files covered. (47.37%)

20 existing lines in 2 files now uncovered.

4501 of 5668 relevant lines covered (79.41%)

0.79 hits per line

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

75.64

/numba_dpex/core/datamodel/models.py

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

from numba.core import datamodel, types
from numba.core.datamodel.models import PrimitiveModel, StructModel
from numba.core.extending import register_model

from numba_dpex.core.exceptions import UnreachableError
from numba_dpex.utils import address_space

from ..types import (
    Array,
    DpctlSyclEvent,
    DpctlSyclQueue,
    DpnpNdArray,
    USMNdArray,
)


class GenericPointerModel(PrimitiveModel):
    def __init__(self, dmm, fe_type):
        adrsp = (
            fe_type.addrspace
            if fe_type.addrspace is not None
            else address_space.GLOBAL
        )
        be_type = dmm.lookup(fe_type.dtype).get_data_type().as_pointer(adrsp)
        super(GenericPointerModel, self).__init__(dmm, fe_type, be_type)


class USMArrayModel(StructModel):
    """A data model to represent a Dpex's array types in LLVM IR.

    Dpex's ArrayModel is based on Numba's ArrayModel for NumPy arrays. The
    dpex model adds an extra address space attribute to all pointer members
    in the array.
    """

    def __init__(self, dmm, fe_type):
        ndim = fe_type.ndim
        members = [
            (
                "meminfo",
                types.CPointer(fe_type.dtype, addrspace=fe_type.addrspace),
            ),
            (
                "parent",
                types.CPointer(types.pyobject, addrspace=fe_type.addrspace),
            ),
            ("nitems", types.intp),
            ("itemsize", types.intp),
            (
                "data",
                types.CPointer(fe_type.dtype, addrspace=fe_type.addrspace),
            ),
            (
                "sycl_queue",
                types.CPointer(types.void, addrspace=fe_type.addrspace),
            ),
            ("shape", types.UniTuple(types.intp, ndim)),
            ("strides", types.UniTuple(types.intp, ndim)),
        ]
        super(USMArrayModel, self).__init__(dmm, fe_type, members)

    @property
    def flattened_field_count(self):
        """Return the number of fields in an instance of a USMArrayModel."""
        flattened_member_count = 0
        members = self._members
        for member in members:
            if isinstance(member, types.UniTuple):
                flattened_member_count += member.count
            elif isinstance(
                member,
                (
                    types.scalars.Integer,
                    types.misc.PyObject,
                    types.misc.RawPointer,
                    types.misc.CPointer,
                    types.misc.MemInfoPointer,
                ),
            ):
                flattened_member_count += 1
            else:
                raise UnreachableError

        return flattened_member_count


class DpnpNdArrayModel(StructModel):
    """Data model for the DpnpNdArray type.

    DpnpNdArrayModel is used by the numba_dpex.types.DpnpNdArray type and
    abstracts the usmarystruct_t C type defined in
    numba_dpex.core.runtime._usmarraystruct.h.

    The DpnpNdArrayModel differs from numba's ArrayModel by including an extra
    member sycl_queue that maps to _usmarraystruct.sycl_queue pointer. The
    _usmarraystruct.sycl_queue pointer stores the C++ sycl::queue pointer that
    was used to allocate the data for the dpnp.ndarray represented by an
    instance of _usmarraystruct.
    """

    def __init__(self, dmm, fe_type):
        ndim = fe_type.ndim
        members = [
            ("meminfo", types.MemInfoPointer(fe_type.dtype)),
            ("parent", types.pyobject),
            ("nitems", types.intp),
            ("itemsize", types.intp),
            ("data", types.CPointer(fe_type.dtype)),
            ("sycl_queue", types.voidptr),
            ("shape", types.UniTuple(types.intp, ndim)),
            ("strides", types.UniTuple(types.intp, ndim)),
        ]
        super(DpnpNdArrayModel, self).__init__(dmm, fe_type, members)

    @property
    def flattened_field_count(self):
        """Return the number of fields in an instance of a DpnpNdArrayModel."""
        flattened_member_count = 0
        members = self._members
        for member in members:
            if isinstance(member, types.UniTuple):
                flattened_member_count += member.count
            elif isinstance(
                member,
                (
                    types.scalars.Integer,
                    types.misc.PyObject,
                    types.misc.RawPointer,
                    types.misc.CPointer,
                    types.misc.MemInfoPointer,
                ),
            ):
                flattened_member_count += 1
            else:
                raise UnreachableError

        return flattened_member_count


class SyclQueueModel(StructModel):
    """Represents the native data model for a dpctl.SyclQueue PyObject.

    Numba-dpex uses a C struct as defined in
    numba_dpex/core/runtime._queuestruct.h to store the required attributes for
    a ``dpctl.SyclQueue`` Python object.

        - ``queue_ref``: An opaque C pointer to an actual SYCL queue C++ object.
        - ``parent``: A PyObject* that stores a reference back to the original
                      ``dpctl.SyclQueue`` PyObject if the native struct is
                      created by unboxing the PyObject.
    """

    def __init__(self, dmm, fe_type):
        members = [
            (
                "parent",
                types.CPointer(types.int8),
            ),
            (
                "queue_ref",
                types.CPointer(types.int8),
            ),
        ]
        super(SyclQueueModel, self).__init__(dmm, fe_type, members)


class SyclEventModel(StructModel):
    """Represents the native data model for a dpctl.SyclEvent PyObject.

    Numba-dpex uses a C struct as defined in
    numba_dpex/core/runtime._queuestruct.h to store the required attributes for
    a ``dpctl.SyclQueue`` Python object.

        - ``event_ref``: An opaque C pointer to an actual SYCL event C++ object.
        - ``parent``: A PyObject* that stores a reference back to the original
                      ``dpctl.SyclQueue`` PyObject if the native struct is
                      created by unboxing the PyObject.
    """

    def __init__(self, dmm, fe_type):
        members = [
            (
                "parent",
                types.CPointer(types.int8),
            ),
            (
                "event_ref",
                types.CPointer(types.int8),
            ),
        ]
        super(SyclEventModel, self).__init__(dmm, fe_type, members)


def _init_data_model_manager() -> datamodel.DataModelManager:
    """Initializes a DpexKernelTarget-specific data model manager.

    SPIRV kernel functions for certain types of devices require an explicit
    address space qualifier for pointers. For OpenCL HD Graphics
    devices, defining a kernel function (spir_kernel calling convention) with
    pointer arguments that have no address space qualifier causes a run time
    crash. For this reason, numba-dpex defines two separate data
    models: USMArrayModel and DpnpNdArrayModel. When a dpnp.ndarray object is
    passed as an argument to a ``numba_dpex.kernel`` decorated function it uses
    the USMArrayModel and when passed to a ``numba_dpex.dpjit`` decorated
    function it uses the DpnpNdArrayModel. The difference is due to the fact
    that inside a ``dpjit`` decorated function a dpnp.ndarray object can be
    passed to any other regular function.

    Returns:
        DataModelManager: A numba-dpex DpexKernelTarget-specific data model
        manager
    """
    dmm = datamodel.default_manager.copy()
    dmm.register(types.CPointer, GenericPointerModel)
    dmm.register(Array, USMArrayModel)

    # Register the USMNdArray type to USMArrayModel in numba_dpex's data model
    # manager. The dpex_data_model_manager is used by the DpexKernelTarget
    dmm.register(USMNdArray, USMArrayModel)

    # Register the DpnpNdArray type to USMArrayModel in numba_dpex's data model
    # manager. The dpex_data_model_manager is used by the DpexKernelTarget
    dmm.register(DpnpNdArray, USMArrayModel)

    # Register the DpctlSyclQueue type to SyclQueueModel in numba_dpex's data
    # model manager. The dpex_data_model_manager is used by the DpexKernelTarget
    dmm.register(DpctlSyclQueue, SyclQueueModel)

    # Register the DpctlSyclEvent type to SyclQueueModel in numba_dpex's data
    # model manager. The dpex_data_model_manager is used by the DpexKernelTarget
    dmm.register(DpctlSyclEvent, SyclEventModel)

    return dmm


dpex_data_model_manager = _init_data_model_manager()


# Register the USMNdArray type to USMArrayModel in numba's default data model
# manager
register_model(USMNdArray)(USMArrayModel)

# Register the DpnpNdArray type to DpnpNdArrayModel in numba's default data
# model manager
register_model(DpnpNdArray)(DpnpNdArrayModel)

# Register the DpctlSyclQueue type
register_model(DpctlSyclQueue)(SyclQueueModel)

# Register the DpctlSyclEvent type
register_model(DpctlSyclEvent)(SyclEventModel)

1	# SPDX-FileCopyrightText: 2022 - 2023 Intel Corporation
2	#
3	# SPDX-License-Identifier: Apache-2.0
4
5	from numba.core import datamodel, types	1✔
6	from numba.core.datamodel.models import PrimitiveModel, StructModel	1✔
7	from numba.core.extending import register_model	1✔
8
9	from numba_dpex.core.exceptions import UnreachableError	1✔
10	from numba_dpex.utils import address_space	1✔
11
12	from ..types import (	1✔
13	Array,
14	DpctlSyclEvent,
15	DpctlSyclQueue,
16	DpnpNdArray,
17	USMNdArray,
18	)
19
20
21	class GenericPointerModel(PrimitiveModel):	1✔
22	def __init__(self, dmm, fe_type):	1✔
23	adrsp = (	1✔
24	fe_type.addrspace
25	if fe_type.addrspace is not None
26	else address_space.GLOBAL
27	)
28	be_type = dmm.lookup(fe_type.dtype).get_data_type().as_pointer(adrsp)	1✔
29	super(GenericPointerModel, self).__init__(dmm, fe_type, be_type)	1✔
30
31
32	class USMArrayModel(StructModel):	1✔
33	"""A data model to represent a Dpex's array types in LLVM IR.
34
35	Dpex's ArrayModel is based on Numba's ArrayModel for NumPy arrays. The
36	dpex model adds an extra address space attribute to all pointer members
37	in the array.
38	"""
39
40	def __init__(self, dmm, fe_type):	1✔
41	ndim = fe_type.ndim	1✔
42	members = [	1✔
43	(
44	"meminfo",
45	types.CPointer(fe_type.dtype, addrspace=fe_type.addrspace),
46	),
47	(
48	"parent",
49	types.CPointer(types.pyobject, addrspace=fe_type.addrspace),
50	),
51	("nitems", types.intp),
52	("itemsize", types.intp),
53	(
54	"data",
55	types.CPointer(fe_type.dtype, addrspace=fe_type.addrspace),
56	),
57	(
58	"sycl_queue",
59	types.CPointer(types.void, addrspace=fe_type.addrspace),
60	),
61	("shape", types.UniTuple(types.intp, ndim)),
62	("strides", types.UniTuple(types.intp, ndim)),
63	]
64	super(USMArrayModel, self).__init__(dmm, fe_type, members)	1✔
65
66	@property	1✔
67	def flattened_field_count(self):	1✔
68	"""Return the number of fields in an instance of a USMArrayModel."""
69	flattened_member_count = 0	1✔
70	members = self._members	1✔
71	for member in members:	1✔
72	if isinstance(member, types.UniTuple):	1✔
73	flattened_member_count += member.count	1✔
74	elif isinstance(	1!
75	member,
76	(
77	types.scalars.Integer,
78	types.misc.PyObject,
79	types.misc.RawPointer,
80	types.misc.CPointer,
81	types.misc.MemInfoPointer,
82	),
83	):
84	flattened_member_count += 1	1✔
85	else:
86	raise UnreachableError	×
87
88	return flattened_member_count	1✔
89
90
91	class DpnpNdArrayModel(StructModel):	1✔
92	"""Data model for the DpnpNdArray type.
93
94	DpnpNdArrayModel is used by the numba_dpex.types.DpnpNdArray type and
95	abstracts the usmarystruct_t C type defined in
96	numba_dpex.core.runtime._usmarraystruct.h.
97
98	The DpnpNdArrayModel differs from numba's ArrayModel by including an extra
99	member sycl_queue that maps to _usmarraystruct.sycl_queue pointer. The
100	_usmarraystruct.sycl_queue pointer stores the C++ sycl::queue pointer that
101	was used to allocate the data for the dpnp.ndarray represented by an
102	instance of _usmarraystruct.
103	"""
104
105	def __init__(self, dmm, fe_type):	1✔
106	ndim = fe_type.ndim	1✔
107	members = [	1✔
108	("meminfo", types.MemInfoPointer(fe_type.dtype)),
109	("parent", types.pyobject),
110	("nitems", types.intp),
111	("itemsize", types.intp),
112	("data", types.CPointer(fe_type.dtype)),
113	("sycl_queue", types.voidptr),
114	("shape", types.UniTuple(types.intp, ndim)),
115	("strides", types.UniTuple(types.intp, ndim)),
116	]
117	super(DpnpNdArrayModel, self).__init__(dmm, fe_type, members)	1✔
118
119	@property	1✔
120	def flattened_field_count(self):	1✔
121	"""Return the number of fields in an instance of a DpnpNdArrayModel."""
122	flattened_member_count = 0	×
123	members = self._members	×
124	for member in members:	×
125	if isinstance(member, types.UniTuple):	×
126	flattened_member_count += member.count	×
127	elif isinstance(	×
128	member,
129	(
130	types.scalars.Integer,
131	types.misc.PyObject,
132	types.misc.RawPointer,
133	types.misc.CPointer,
134	types.misc.MemInfoPointer,
135	),
136	):
137	flattened_member_count += 1	×
138	else:
139	raise UnreachableError	×
140
141	return flattened_member_count	×
142
143
144	class SyclQueueModel(StructModel):	1✔
145	"""Represents the native data model for a dpctl.SyclQueue PyObject.
146
147	Numba-dpex uses a C struct as defined in
148	numba_dpex/core/runtime._queuestruct.h to store the required attributes for
149	a ``dpctl.SyclQueue`` Python object.
150
151	- ``queue_ref``: An opaque C pointer to an actual SYCL queue C++ object.
152	- ``parent``: A PyObject* that stores a reference back to the original
153	``dpctl.SyclQueue`` PyObject if the native struct is
154	created by unboxing the PyObject.
155	"""
156
157	def __init__(self, dmm, fe_type):	1✔
158	members = [	1✔
159	(
160	"parent",
161	types.CPointer(types.int8),
162	),
163	(
164	"queue_ref",
165	types.CPointer(types.int8),
166	),
167	]
168	super(SyclQueueModel, self).__init__(dmm, fe_type, members)	1✔
169
170
171	class SyclEventModel(StructModel):	1✔
172	"""Represents the native data model for a dpctl.SyclEvent PyObject.
173
174	Numba-dpex uses a C struct as defined in
175	numba_dpex/core/runtime._queuestruct.h to store the required attributes for
176	a ``dpctl.SyclQueue`` Python object.
177
178	- ``event_ref``: An opaque C pointer to an actual SYCL event C++ object.
179	- ``parent``: A PyObject* that stores a reference back to the original
180	``dpctl.SyclQueue`` PyObject if the native struct is
181	created by unboxing the PyObject.
182	"""
183
184	def __init__(self, dmm, fe_type):	1✔
NEW 185	members = [	×
186	(
187	"parent",
188	types.CPointer(types.int8),
189	),
190	(
191	"event_ref",
192	types.CPointer(types.int8),
193	),
194	]
NEW 195	super(SyclEventModel, self).__init__(dmm, fe_type, members)	×
196
197
198	def _init_data_model_manager() -> datamodel.DataModelManager:	1✔
199	"""Initializes a DpexKernelTarget-specific data model manager.
200
201	SPIRV kernel functions for certain types of devices require an explicit
202	address space qualifier for pointers. For OpenCL HD Graphics
203	devices, defining a kernel function (spir_kernel calling convention) with
204	pointer arguments that have no address space qualifier causes a run time
205	crash. For this reason, numba-dpex defines two separate data
206	models: USMArrayModel and DpnpNdArrayModel. When a dpnp.ndarray object is
207	passed as an argument to a ``numba_dpex.kernel`` decorated function it uses
208	the USMArrayModel and when passed to a ``numba_dpex.dpjit`` decorated
209	function it uses the DpnpNdArrayModel. The difference is due to the fact
210	that inside a ``dpjit`` decorated function a dpnp.ndarray object can be
211	passed to any other regular function.
212
213	Returns:
214	DataModelManager: A numba-dpex DpexKernelTarget-specific data model
215	manager
216	"""
217	dmm = datamodel.default_manager.copy()	1✔
218	dmm.register(types.CPointer, GenericPointerModel)	1✔
219	dmm.register(Array, USMArrayModel)	1✔
220
221	# Register the USMNdArray type to USMArrayModel in numba_dpex's data model
222	# manager. The dpex_data_model_manager is used by the DpexKernelTarget
223	dmm.register(USMNdArray, USMArrayModel)	1✔
224
225	# Register the DpnpNdArray type to USMArrayModel in numba_dpex's data model
226	# manager. The dpex_data_model_manager is used by the DpexKernelTarget
227	dmm.register(DpnpNdArray, USMArrayModel)	1✔
228
229	# Register the DpctlSyclQueue type to SyclQueueModel in numba_dpex's data
230	# model manager. The dpex_data_model_manager is used by the DpexKernelTarget
231	dmm.register(DpctlSyclQueue, SyclQueueModel)	1✔
232
233	# Register the DpctlSyclEvent type to SyclQueueModel in numba_dpex's data
234	# model manager. The dpex_data_model_manager is used by the DpexKernelTarget
235	dmm.register(DpctlSyclEvent, SyclEventModel)	1✔
236
237	return dmm	1✔
238
239
240	dpex_data_model_manager = _init_data_model_manager()	1✔
241
242
243	# Register the USMNdArray type to USMArrayModel in numba's default data model
244	# manager
245	register_model(USMNdArray)(USMArrayModel)	1✔
246
247	# Register the DpnpNdArray type to DpnpNdArrayModel in numba's default data
248	# model manager
249	register_model(DpnpNdArray)(DpnpNdArrayModel)	1✔
250
251	# Register the DpctlSyclQueue type
252	register_model(DpctlSyclQueue)(SyclQueueModel)	1✔
253
254	# Register the DpctlSyclEvent type
255	register_model(DpctlSyclEvent)(SyclEventModel)	1✔

IntelPython / numba-dpex / 6328198945

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