957611662

Build Type

github

Committed by GitHub

Commit Message

Merge 8eb4915c4 into ca5697c1b

Pull Request Pull Request #491: Added C-API hash function, used them in Python interface

Run Details

64 of 120 branches covered (53.33%)

Branch coverage included in aggregate %.

17 of 46 new or added lines in 6 files covered. (36.96%)

6 existing lines in 3 files now uncovered.

2891 of 4740 relevant lines covered (60.99%)

10.08 hits per line

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

75.89

/dpctl/_sycl_context.pyx

#                      Data Parallel Control (dpctl)
#
# Copyright 2020-2021 Intel Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# distutils: language = c++
# cython: language_level=3
# cython: linetrace=True

""" Implements SyclContext Cython extension type.
"""

import logging

from cpython cimport pycapsule
from cpython.mem cimport PyMem_Free, PyMem_Malloc

from ._backend cimport (  # noqa: E211
    DPCTLContext_AreEq,
    DPCTLContext_Copy,
    DPCTLContext_Create,
    DPCTLContext_CreateFromDevices,
    DPCTLContext_Delete,
    DPCTLContext_DeviceCount,
    DPCTLContext_GetDevices,
    DPCTLContext_Hash,
    DPCTLDevice_Copy,
    DPCTLDevice_Delete,
    DPCTLDeviceMgr_GetCachedContext,
    DPCTLDeviceVector_CreateFromArray,
    DPCTLDeviceVector_Delete,
    DPCTLDeviceVector_GetAt,
    DPCTLDeviceVector_Size,
    DPCTLDeviceVectorRef,
    DPCTLSyclContextRef,
    DPCTLSyclDeviceRef,
    error_handler_callback,
)
from ._sycl_device cimport SyclDevice
from ._sycl_queue cimport default_async_error_handler

__all__ = [
    "SyclContext",
]

_logger = logging.getLogger(__name__)

cdef void _context_capsule_deleter(object o):
    cdef DPCTLSyclContextRef CRef = NULL
    if pycapsule.PyCapsule_IsValid(o, "SyclContextRef"):
        CRef = <DPCTLSyclContextRef> pycapsule.PyCapsule_GetPointer(
            o, "SyclContextRef"
        )
        DPCTLContext_Delete(CRef)


cdef class _SyclContext:
    """ Data owner for SyclContext
    """

    def __dealloc__(self):
        DPCTLContext_Delete(self._ctxt_ref)


cdef class SyclContext(_SyclContext):
    """
    SyclContext(arg=None)
    Python class representing ``cl::sycl::context``. There are multiple
    ways to create a :class:`dpctl.SyclContext` object:

        - Invoking the constructor with no arguments creates a context using
          the default selector.

        :Example:
            .. code-block:: python

                import dpctl

                # Create a default SyclContext
                ctx = dpctl.SyclContext()
                print(ctx.get_devices())

        - Invoking the constuctor with a specific filter string that creates a
          context for the device corresponding to the filter string.

        :Example:
            .. code-block:: python

                import dpctl

                # Create SyclContext for a gpu device
                ctx = dpctl.SyclContext("gpu")
                d = ctx.get_devices()[0]
                assert(d.is_gpu)

        - Invoking the constuctor with a :class:`dpctl.SyclDevice` object
          creates a context for that device.

        :Example:
            .. code-block:: python

                import dpctl

                # Create a level zero gpu device
                d = dpctl.SyclDevice("level_zero:gpu")
                ctx = dpctl.SyclContext(d)
                d = ctx.get_devices()[0]
                assert(d.is_gpu)

        - Invoking the constuctor with a list of :class:`dpctl.SyclDevice`
          objects creates a common context for all the devices. This
          constructor call is especially useful when creation a context for
          multiple sub-devices.

        :Example:
            .. code-block:: python

                import dpctl

                # Create a CPU device using the opencl driver
                cpu_d = dpctl.SyclDevice("opencl:cpu")
                # Partition the CPU device into sub-devices with two cores each.
                sub_devices = cpu_d.create_sub_devices(partition=2)
                # Create a context common to all the sub-devices.
                ctx = dpctl.SyclContext(sub_devices)
                assert(len(ctx.get_devices) == len(sub_devices))

        - Invoking the constuctor with a named ``PyCapsule`` with name
          **"SyclContextRef"** that carries a pointer to a ``sycl::context``
          object. The capsule will be renamed upon successful consumption
          to ensure one-time use. A new named capsule can be constructed by
          using :func:`dpctl.SyclContext._get_capsule` method.

    Args:
        arg (optional): Defaults to ``None``.
            The argument can be a selector string, a :class:`dpctl.SyclDevice`
            instance, a :obj:`list` of :class:`dpctl.SyclDevice` objects, or a
            named ``PyCapsule`` called **"SyclContextRef"**.

    Raises:
        MemoryError: If the constructor could not allocate necessary
                     temporary memory.
        ValueError: If the :class:`dpctl.SyclContext` object creation failed.
        TypeError: If the list of :class:`dpctl.SyclDevice` objects was empty,
                   or the input capsule contained a null pointer or could not
                   be renamed.

    """

    @staticmethod
    cdef void _init_helper(_SyclContext context, DPCTLSyclContextRef CRef):
        context._ctxt_ref = CRef

    @staticmethod
    cdef SyclContext _create(DPCTLSyclContextRef ctxt):
        """
        Calls DPCTLContext_Delete(ctxt).

        Users should pass a copy if they intend to keep the argument ctxt alive.
        """
        cdef _SyclContext ret = <_SyclContext>_SyclContext.__new__(_SyclContext)
        SyclContext._init_helper(ret, ctxt)
        return SyclContext(ret)

    cdef int _init_context_from__SyclContext(self, _SyclContext other):
        self._ctxt_ref = DPCTLContext_Copy(other._ctxt_ref)
        if (self._ctxt_ref is NULL):
            return -1
        return 0

    cdef int _init_context_from_one_device(self, SyclDevice device, int props):
        cdef DPCTLSyclDeviceRef DRef = device.get_device_ref()
        cdef DPCTLSyclContextRef CRef = NULL
        cdef error_handler_callback * eh_callback = (
            <error_handler_callback *>&default_async_error_handler)
        # look up cached contexts for root devices first
        CRef = DPCTLDeviceMgr_GetCachedContext(DRef)
        if (CRef is NULL):
            # look-up failed, create a new one
            CRef = DPCTLContext_Create(DRef, eh_callback, props)
            if (CRef is NULL):
                return -1
        SyclContext._init_helper(<_SyclContext> self, CRef)
        return 0

    cdef int _init_context_from_devices(self, object devices, int props):
        cdef int num_devices = len(devices)
        cdef int i = 0
        cdef int j = 0
        cdef size_t num_bytes
        cdef DPCTLDeviceVectorRef DVRef = NULL
        cdef error_handler_callback * eh_callback = (
            <error_handler_callback *>&default_async_error_handler)
        cdef DPCTLSyclContextRef CRef = NULL
        cdef DPCTLSyclDeviceRef *elems

        if num_devices > 0:
            num_bytes = num_devices * sizeof(DPCTLSyclDeviceRef *)
            elems = <DPCTLSyclDeviceRef *>PyMem_Malloc(num_bytes)
            if (elems is NULL):
                return -3
            for dev in devices:
                if not isinstance(dev, SyclDevice):
                    elems[i] = NULL
                else:
                    elems[i] = (<SyclDevice>dev).get_device_ref()
                if (elems[i] is NULL):
                    PyMem_Free(elems)
                    return -4
                i = i + 1
            # CreateFromArray will make copies of devices referenced by elems
            DVRef = DPCTLDeviceVector_CreateFromArray(num_devices, elems)
            if (DVRef is NULL):
                PyMem_Free(elems)
                return -5
            PyMem_Free(elems)
        else:
            return -2
        CRef = DPCTLContext_CreateFromDevices(DVRef, eh_callback, props)
        DPCTLDeviceVector_Delete(DVRef)
        if (CRef is NULL):
            return -1
        SyclContext._init_helper(<_SyclContext> self, CRef)
        return 0

    cdef int _init_context_from_capsule(self, object cap):
        """
        For named ``PyCapsule`` with name **"SyclContextRef"**, which carries
        pointer to ``sycl::context`` object, interpreted as
        ``DPCTLSyclContextRef``, creates corresponding
        :class:`dpctl.SyclContext`.
        """
        cdef DPCTLSyclContextRef CRef = NULL
        cdef DPCTLSyclContextRef CRef_copy = NULL
        cdef int ret = 0
        if pycapsule.PyCapsule_IsValid(cap, "SyclContextRef"):
            CRef = <DPCTLSyclContextRef> pycapsule.PyCapsule_GetPointer(
                cap, "SyclContextRef"
            )
            if (CRef is NULL):
                return -6
            ret = pycapsule.PyCapsule_SetName(cap, "used_SyclContextRef")
            if (ret):
                return -6
            CRef_copy = DPCTLContext_Copy(CRef)
            if (CRef_copy is NULL):
                return -7
            self._ctxt_ref = CRef_copy
            return 0
        else:
            # __cinit__ checks that capsule is valid, so one can be here only
            # if call to `_init_context_from_capsule` was made outside of
            # __cinit__ and the capsule was not checked to be valid
            return -128

    def __cinit__(self, arg=None):
        cdef int ret = 0
        if isinstance(arg, _SyclContext):
            ret = self._init_context_from__SyclContext(<_SyclContext> arg)
        elif isinstance(arg, SyclDevice):
            ret = self._init_context_from_one_device(<SyclDevice> arg, 0)
        elif pycapsule.PyCapsule_IsValid(arg, "SyclContextRef"):
            status = self._init_context_from_capsule(arg)
        elif isinstance(arg, (list, tuple)) and all(
            [isinstance(argi, SyclDevice) for argi in arg]
        ):
            ret = self._init_context_from_devices(arg, 0)
        else:
            dev = SyclDevice(arg)
            ret = self._init_context_from_one_device(<SyclDevice> dev, 0)
        if (ret < 0):
            if (ret == -1):
                raise ValueError("Context failed to be created.")
            elif (ret == -2):
                raise TypeError(
                    "List of devices to create context from must be non-empty."
                )
            elif (ret == -3):
                raise MemoryError(
                    "Could not allocate necessary temporary memory."
                )
            elif (ret == -4) or (ret == -7):
                raise ValueError(
                    "Internal Error: Could not create a copy of a sycl device."
                )
            elif (ret == -5):
                raise ValueError(
                    "Internal Error: Creation of DeviceVector failed."
                )
            elif (ret == -6):
                raise TypeError(
                    "Input capsule {} contains a null pointer or could not be"
                    " renamed".format(arg)
                )
            raise ValueError(
                "Unrecognized error code ({}) encountered.".format(ret)
            )

    cdef bool equals(self, SyclContext ctxt):
        """
        Returns true if the :class:`dpctl.SyclContext` argument has the
        same underlying ``DPCTLSyclContextRef`` object as this
        :class:`dpctl.SyclContext` instance.

        Returns:
            :obj:`bool`: ``True`` if the two :class:`dpctl.SyclContext` objects
            point to the same ``DPCTLSyclContextRef`` object, otherwise
            ``False``.
        """
        return DPCTLContext_AreEq(self._ctxt_ref, ctxt.get_context_ref())

    def __eq__(self, other):
        """
        Returns True if the :class:`dpctl.SyclContext` argument has the
        same underlying ``DPCTLSyclContextRef`` object as this
        :class:`dpctl.SyclContext` instance.

        Returns:
            :obj:`bool`: ``True`` if the two :class:`dpctl.SyclContext` objects
            point to the same ``DPCTLSyclContextRef`` object, otherwise
            ``False``.
        """
        if isinstance(other, SyclContext):
            return self.equals(<SyclContext> other)
        else:
            return False

    def __hash__(self):
        """
        Returns hash value corresponding to ``self._ctxt_ref``.

        """
        return DPCTLContext_Hash(self._ctxt_ref)

    cdef DPCTLSyclContextRef get_context_ref(self):
        return self._ctxt_ref

    def addressof_ref(self):
        """
        Returns the address of the ``DPCTLSyclContextRef`` pointer as a
        ``size_t``.

        Returns:
            :obj:`int`: The address of the ``DPCTLSyclContextRef`` object
            used to create this :class:`dpctl.SyclContext` cast to a
            ``size_t``.
        """
        return <size_t>self._ctxt_ref

    def get_devices(self):
        """
        Returns the list of :class:`dpctl.SyclDevice` objects associated with
        :class:`dpctl.SyclContext` instance.

        Returns:
            :obj:`list`: A :obj:`list` of :class:`dpctl.SyclDevice` objects
            that belong to this context.

        Raises:
            ValueError: If the ``DPCTLContext_GetDevices`` call returned
                        ``NULL`` instead of a ``DPCTLDeviceVectorRef`` object.
        """
        cdef DPCTLDeviceVectorRef DVRef = DPCTLContext_GetDevices(
            self.get_context_ref()
        )
        cdef size_t num_devs
        cdef size_t i
        cdef DPCTLSyclDeviceRef DRef
        if (DVRef is NULL):
            raise ValueError("Internal error: NULL device vector encountered")
        num_devs = DPCTLDeviceVector_Size(DVRef)
        devices = []
        for i in range(num_devs):
            DRef = DPCTLDeviceVector_GetAt(DVRef, i)
            devices.append(SyclDevice._create(DRef))
        DPCTLDeviceVector_Delete(DVRef)
        return devices

    @property
    def device_count(self):
        """
        The number of sycl devices associated with the
        :class:`dpctl.SyclContext` instance.

        Returns:
            :obj:`int`: Number of devices associated with the context.

        Raises:
            ValueError: If ``DPCTLContext_DeviceCount`` led to a
                        failure.
        """
        cdef size_t num_devs = DPCTLContext_DeviceCount(self.get_context_ref())
        if num_devs:
            return num_devs
        else:
            raise ValueError(
                "An error was encountered quering the number of devices "
                "associated with this context"
            )

    @property
    def __name__(self):
        return "SyclContext"

    def __repr__(self):
        """
        Returns the name of the class and number of devices in the context.

        :Example:
            .. code-block:: python

                import dpctl

                # Create a default SyclContext
                ctx = dpctl.SyclContext()
                print(ctx) # E.g : <dpctl.SyclContext at 0x7f154d8ab070>

                cpu_d = dpctl.SyclDevice("opencl:cpu")
                sub_devices = create_sub_devices(partition=2)
                ctx2 = dpctl.SyclContext(sub_devices)
                # prints: <dpctl.SyclContext for 4 devices at 0x7f154d8ab070>
                print(ctx2)

        Returns:
            :obj:`str`: A string representation of the
            :class:`dpctl.SyclContext` object.

        """
        cdef size_t n = self.device_count
        if n == 1:
            return ("<dpctl." + self.__name__ + " at {}>".format(hex(id(self))))
        else:
            return (
                "<dpctl."
                + self.__name__
                + " for {} devices at {}>".format(n, hex(id(self)))
            )

    def _get_capsule(self):
        """
        Returns a copy of the underlying ``sycl::context`` pointer as a void
        pointer inside a named ``PyCapsule`` that has the name
        **SyclContextRef**. The ownership of the pointer inside the capsule is
        passed to the caller, and pointer is deleted when the capsule goes out
        of scope.

        Returns:
            :class:`pycapsule`: A capsule object storing a copy of the
            ``sycl::context`` pointer belonging to thus
            :class:`dpctl.SyclContext` instance.

        Raises:
            ValueError: If the ``DPCTLContext_Copy`` fails to copy the
                        ``sycl::context`` pointer.
        """
        cdef DPCTLSyclContextRef CRef = NULL
        CRef = DPCTLContext_Copy(self._ctxt_ref)
        if (CRef is NULL):
            raise ValueError("SyclContext copy failed.")
        return pycapsule.PyCapsule_New(
            <void *>CRef,
            "SyclContextRef",
            &_context_capsule_deleter
        )

1	# Data Parallel Control (dpctl)	1✔
2	#
3	# Copyright 2020-2021 Intel Corporation
4	#
5	# Licensed under the Apache License, Version 2.0 (the "License");
6	# you may not use this file except in compliance with the License.
7	# You may obtain a copy of the License at
8	#
9	# http://www.apache.org/licenses/LICENSE-2.0
10	#
11	# Unless required by applicable law or agreed to in writing, software
12	# distributed under the License is distributed on an "AS IS" BASIS,
13	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	# See the License for the specific language governing permissions and
15	# limitations under the License.
16
17	# distutils: language = c++
18	# cython: language_level=3
19	# cython: linetrace=True
20
21	""" Implements SyclContext Cython extension type.
22	"""
23
24	import logging	1✔
25
26	from cpython cimport pycapsule
27	from cpython.mem cimport PyMem_Free, PyMem_Malloc
28
29	from ._backend cimport ( # noqa: E211
30	DPCTLContext_AreEq,
31	DPCTLContext_Copy,
32	DPCTLContext_Create,
33	DPCTLContext_CreateFromDevices,
34	DPCTLContext_Delete,
35	DPCTLContext_DeviceCount,
36	DPCTLContext_GetDevices,
37	DPCTLContext_Hash,
38	DPCTLDevice_Copy,
39	DPCTLDevice_Delete,
40	DPCTLDeviceMgr_GetCachedContext,
41	DPCTLDeviceVector_CreateFromArray,
42	DPCTLDeviceVector_Delete,
43	DPCTLDeviceVector_GetAt,
44	DPCTLDeviceVector_Size,
45	DPCTLDeviceVectorRef,
46	DPCTLSyclContextRef,
47	DPCTLSyclDeviceRef,
48	error_handler_callback,
49	)
50	from ._sycl_device cimport SyclDevice
51	from ._sycl_queue cimport default_async_error_handler
52
53	__all__ = [	1✔
54	"SyclContext",
55	]
56
57	_logger = logging.getLogger(__name__)	1✔
58
59	cdef void _context_capsule_deleter(object o):	1✔
60	cdef DPCTLSyclContextRef CRef = NULL	1✔
61	if pycapsule.PyCapsule_IsValid(o, "SyclContextRef"):	1✔
62	CRef = <DPCTLSyclContextRef> pycapsule.PyCapsule_GetPointer(	×
63	o, "SyclContextRef"
64	)
65	DPCTLContext_Delete(CRef)	×
66
67
68	cdef class _SyclContext:
69	""" Data owner for SyclContext
70	"""
71
72	def __dealloc__(self):
73	DPCTLContext_Delete(self._ctxt_ref)	1✔
74
75
76	cdef class SyclContext(_SyclContext):
77	"""
78	SyclContext(arg=None)
79	Python class representing ``cl::sycl::context``. There are multiple
80	ways to create a :class:`dpctl.SyclContext` object:
81
82	- Invoking the constructor with no arguments creates a context using
83	the default selector.
84
85	:Example:
86	.. code-block:: python
87
88	import dpctl
89
90	# Create a default SyclContext
91	ctx = dpctl.SyclContext()
92	print(ctx.get_devices())
93
94	- Invoking the constuctor with a specific filter string that creates a
95	context for the device corresponding to the filter string.
96
97	:Example:
98	.. code-block:: python
99
100	import dpctl
101
102	# Create SyclContext for a gpu device
103	ctx = dpctl.SyclContext("gpu")
104	d = ctx.get_devices()[0]
105	assert(d.is_gpu)
106
107	- Invoking the constuctor with a :class:`dpctl.SyclDevice` object
108	creates a context for that device.
109
110	:Example:
111	.. code-block:: python
112
113	import dpctl
114
115	# Create a level zero gpu device
116	d = dpctl.SyclDevice("level_zero:gpu")
117	ctx = dpctl.SyclContext(d)
118	d = ctx.get_devices()[0]
119	assert(d.is_gpu)
120
121	- Invoking the constuctor with a list of :class:`dpctl.SyclDevice`
122	objects creates a common context for all the devices. This
123	constructor call is especially useful when creation a context for
124	multiple sub-devices.
125
126	:Example:
127	.. code-block:: python
128
129	import dpctl
130
131	# Create a CPU device using the opencl driver
132	cpu_d = dpctl.SyclDevice("opencl:cpu")
133	# Partition the CPU device into sub-devices with two cores each.
134	sub_devices = cpu_d.create_sub_devices(partition=2)
135	# Create a context common to all the sub-devices.
136	ctx = dpctl.SyclContext(sub_devices)
137	assert(len(ctx.get_devices) == len(sub_devices))
138
139	- Invoking the constuctor with a named ``PyCapsule`` with name
140	"SyclContextRef" that carries a pointer to a ``sycl::context``
141	object. The capsule will be renamed upon successful consumption
142	to ensure one-time use. A new named capsule can be constructed by
143	using :func:`dpctl.SyclContext._get_capsule` method.
144
145	Args:
146	arg (optional): Defaults to ``None``.
147	The argument can be a selector string, a :class:`dpctl.SyclDevice`
148	instance, a :obj:`list` of :class:`dpctl.SyclDevice` objects, or a
149	named ``PyCapsule`` called "SyclContextRef".
150
151	Raises:
152	MemoryError: If the constructor could not allocate necessary
153	temporary memory.
154	ValueError: If the :class:`dpctl.SyclContext` object creation failed.
155	TypeError: If the list of :class:`dpctl.SyclDevice` objects was empty,
156	or the input capsule contained a null pointer or could not
157	be renamed.
158
159	"""
160
161	@staticmethod
162	cdef void _init_helper(_SyclContext context, DPCTLSyclContextRef CRef):	1✔
163	context._ctxt_ref = CRef	1✔
164
165	@staticmethod
166	cdef SyclContext _create(DPCTLSyclContextRef ctxt):	1✔
167	"""
168	Calls DPCTLContext_Delete(ctxt).
169
170	Users should pass a copy if they intend to keep the argument ctxt alive.
171	"""
172	cdef _SyclContext ret = <_SyclContext>_SyclContext.__new__(_SyclContext)	1✔
173	SyclContext._init_helper(ret, ctxt)	1✔
174	return SyclContext(ret)	1✔
175
176	cdef int _init_context_from__SyclContext(self, _SyclContext other):	1✔
177	self._ctxt_ref = DPCTLContext_Copy(other._ctxt_ref)	1✔
178	if (self._ctxt_ref is NULL):	1✔
179	return -1	×
180	return 0	1✔
181
182	cdef int _init_context_from_one_device(self, SyclDevice device, int props):	1✔
183	cdef DPCTLSyclDeviceRef DRef = device.get_device_ref()	1✔
184	cdef DPCTLSyclContextRef CRef = NULL	1✔
185	cdef error_handler_callback * eh_callback = (
186	<error_handler_callback *>&default_async_error_handler)	1✔
187	# look up cached contexts for root devices first
188	CRef = DPCTLDeviceMgr_GetCachedContext(DRef)	1✔
189	if (CRef is NULL):	1✔
190	# look-up failed, create a new one
191	CRef = DPCTLContext_Create(DRef, eh_callback, props)	×
192	if (CRef is NULL):	×
193	return -1	×
194	SyclContext._init_helper(<_SyclContext> self, CRef)	1✔
195	return 0	1✔
196
197	cdef int _init_context_from_devices(self, object devices, int props):	1✔
198	cdef int num_devices = len(devices)	1✔
199	cdef int i = 0	1✔
200	cdef int j = 0	1✔
201	cdef size_t num_bytes
202	cdef DPCTLDeviceVectorRef DVRef = NULL	1✔
203	cdef error_handler_callback * eh_callback = (
204	<error_handler_callback *>&default_async_error_handler)	1✔
205	cdef DPCTLSyclContextRef CRef = NULL	1✔
206	cdef DPCTLSyclDeviceRef *elems
207
208	if num_devices > 0:	1✔
209	num_bytes = num_devices * sizeof(DPCTLSyclDeviceRef *)	1✔
210	elems = <DPCTLSyclDeviceRef *>PyMem_Malloc(num_bytes)	1✔
211	if (elems is NULL):	1✔
212	return -3	×
213	for dev in devices:	1✔
214	if not isinstance(dev, SyclDevice):	1✔
215	elems[i] = NULL	×
216	else:
217	elems[i] = (<SyclDevice>dev).get_device_ref()	1✔
218	if (elems[i] is NULL):	1✔
219	PyMem_Free(elems)	×
220	return -4	×
221	i = i + 1	1✔
222	# CreateFromArray will make copies of devices referenced by elems
223	DVRef = DPCTLDeviceVector_CreateFromArray(num_devices, elems)	1✔
224	if (DVRef is NULL):	1✔
225	PyMem_Free(elems)	×
226	return -5	1✔
227	PyMem_Free(elems)	1✔
228	else:
229	return -2	×
230	CRef = DPCTLContext_CreateFromDevices(DVRef, eh_callback, props)	1✔
231	DPCTLDeviceVector_Delete(DVRef)	1✔
232	if (CRef is NULL):	1✔
233	return -1	×
234	SyclContext._init_helper(<_SyclContext> self, CRef)	1✔
235	return 0	1✔
236
237	cdef int _init_context_from_capsule(self, object cap):	1✔
238	"""
239	For named ``PyCapsule`` with name "SyclContextRef", which carries
240	pointer to ``sycl::context`` object, interpreted as
241	``DPCTLSyclContextRef``, creates corresponding
242	:class:`dpctl.SyclContext`.
243	"""
244	cdef DPCTLSyclContextRef CRef = NULL	1✔
245	cdef DPCTLSyclContextRef CRef_copy = NULL	1✔
246	cdef int ret = 0	1✔
247	if pycapsule.PyCapsule_IsValid(cap, "SyclContextRef"):	1✔
248	CRef = <DPCTLSyclContextRef> pycapsule.PyCapsule_GetPointer(	1✔
249	cap, "SyclContextRef"
250	)
251	if (CRef is NULL):	1✔
252	return -6	×
253	ret = pycapsule.PyCapsule_SetName(cap, "used_SyclContextRef")	1✔
254	if (ret):	1✔
255	return -6	×
256	CRef_copy = DPCTLContext_Copy(CRef)	1✔
257	if (CRef_copy is NULL):	1✔
258	return -7	×
259	self._ctxt_ref = CRef_copy	1✔
260	return 0	1✔
261	else:
262	# __cinit__ checks that capsule is valid, so one can be here only
263	# if call to `_init_context_from_capsule` was made outside of
264	# __cinit__ and the capsule was not checked to be valid
265	return -128	×
266
267	def __cinit__(self, arg=None):
268	cdef int ret = 0	1✔
269	if isinstance(arg, _SyclContext):	1✔
270	ret = self._init_context_from__SyclContext(<_SyclContext> arg)	1✔
271	elif isinstance(arg, SyclDevice):	1✔
272	ret = self._init_context_from_one_device(<SyclDevice> arg, 0)	1✔
273	elif pycapsule.PyCapsule_IsValid(arg, "SyclContextRef"):	1✔
274	status = self._init_context_from_capsule(arg)	1✔
275	elif isinstance(arg, (list, tuple)) and all(	1✔
276	[isinstance(argi, SyclDevice) for argi in arg]	1✔
277	):
278	ret = self._init_context_from_devices(arg, 0)	1✔
279	else:
280	dev = SyclDevice(arg)	1✔
281	ret = self._init_context_from_one_device(<SyclDevice> dev, 0)	1✔
282	if (ret < 0):	1✔
283	if (ret == -1):	×
284	raise ValueError("Context failed to be created.")	×
285	elif (ret == -2):
286	raise TypeError(	1✔
287	"List of devices to create context from must be non-empty."
288	)
289	elif (ret == -3):
290	raise MemoryError(	×
291	"Could not allocate necessary temporary memory."
292	)
UNCOV 293	elif (ret == -4) or (ret == -7):	×
294	raise ValueError(	×
295	"Internal Error: Could not create a copy of a sycl device."
296	)
297	elif (ret == -5):
298	raise ValueError(	1✔
299	"Internal Error: Creation of DeviceVector failed."
300	)
301	elif (ret == -6):
302	raise TypeError(	×
303	"Input capsule {} contains a null pointer or could not be"
304	" renamed".format(arg)	×
305	)
306	raise ValueError(	×
307	"Unrecognized error code ({}) encountered.".format(ret)	×
308	)
309
310	cdef bool equals(self, SyclContext ctxt):	1✔
311	"""
312	Returns true if the :class:`dpctl.SyclContext` argument has the
313	same underlying ``DPCTLSyclContextRef`` object as this
314	:class:`dpctl.SyclContext` instance.
315
316	Returns:
317	:obj:`bool`: ``True`` if the two :class:`dpctl.SyclContext` objects
318	point to the same ``DPCTLSyclContextRef`` object, otherwise
319	``False``.
320	"""
321	return DPCTLContext_AreEq(self._ctxt_ref, ctxt.get_context_ref())	1✔
322
323	def __eq__(self, other):
324	"""
325	Returns True if the :class:`dpctl.SyclContext` argument has the
326	same underlying ``DPCTLSyclContextRef`` object as this
327	:class:`dpctl.SyclContext` instance.
328
329	Returns:
330	:obj:`bool`: ``True`` if the two :class:`dpctl.SyclContext` objects
331	point to the same ``DPCTLSyclContextRef`` object, otherwise
332	``False``.
333	"""
334	if isinstance(other, SyclContext):	1✔
335	return self.equals(<SyclContext> other)	1✔
336	else:
337	return False	1✔
338
339	def __hash__(self):
340	"""
341	Returns hash value corresponding to ``self._ctxt_ref``.
342
343	"""
344	return DPCTLContext_Hash(self._ctxt_ref)	1✔
345
346	cdef DPCTLSyclContextRef get_context_ref(self):	1✔
347	return self._ctxt_ref	1✔
348
349	def addressof_ref(self):
350	"""
351	Returns the address of the ``DPCTLSyclContextRef`` pointer as a
352	``size_t``.
353
354	Returns:
355	:obj:`int`: The address of the ``DPCTLSyclContextRef`` object
356	used to create this :class:`dpctl.SyclContext` cast to a
357	``size_t``.
358	"""
359	return <size_t>self._ctxt_ref	1✔
360
361	def get_devices(self):
362	"""
363	Returns the list of :class:`dpctl.SyclDevice` objects associated with
364	:class:`dpctl.SyclContext` instance.
365
366	Returns:
367	:obj:`list`: A :obj:`list` of :class:`dpctl.SyclDevice` objects
368	that belong to this context.
369
370	Raises:
371	ValueError: If the ``DPCTLContext_GetDevices`` call returned
372	``NULL`` instead of a ``DPCTLDeviceVectorRef`` object.
373	"""
374	cdef DPCTLDeviceVectorRef DVRef = DPCTLContext_GetDevices(	1✔
375	self.get_context_ref()
376	)
377	cdef size_t num_devs
378	cdef size_t i
379	cdef DPCTLSyclDeviceRef DRef
380	if (DVRef is NULL):	1✔
381	raise ValueError("Internal error: NULL device vector encountered")	×
382	num_devs = DPCTLDeviceVector_Size(DVRef)	1✔
383	devices = []	1✔
384	for i in range(num_devs):	1✔
385	DRef = DPCTLDeviceVector_GetAt(DVRef, i)	1✔
386	devices.append(SyclDevice._create(DRef))	1✔
387	DPCTLDeviceVector_Delete(DVRef)	1✔
388	return devices	1✔
389
390	@property
391	def device_count(self):
392	"""
393	The number of sycl devices associated with the
394	:class:`dpctl.SyclContext` instance.
395
396	Returns:
397	:obj:`int`: Number of devices associated with the context.
398
399	Raises:
400	ValueError: If ``DPCTLContext_DeviceCount`` led to a
401	failure.
402	"""
403	cdef size_t num_devs = DPCTLContext_DeviceCount(self.get_context_ref())	1✔
404	if num_devs:	1✔
405	return num_devs	1✔
406	else:
407	raise ValueError(	×
408	"An error was encountered quering the number of devices "
409	"associated with this context"
410	)
411
412	@property
413	def __name__(self):
414	return "SyclContext"	1✔
415
416	def __repr__(self):
417	"""
418	Returns the name of the class and number of devices in the context.
419
420	:Example:
421	.. code-block:: python
422
423	import dpctl
424
425	# Create a default SyclContext
426	ctx = dpctl.SyclContext()
427	print(ctx) # E.g : <dpctl.SyclContext at 0x7f154d8ab070>
428
429	cpu_d = dpctl.SyclDevice("opencl:cpu")
430	sub_devices = create_sub_devices(partition=2)
431	ctx2 = dpctl.SyclContext(sub_devices)
432	# prints: <dpctl.SyclContext for 4 devices at 0x7f154d8ab070>
433	print(ctx2)
434
435	Returns:
436	:obj:`str`: A string representation of the
437	:class:`dpctl.SyclContext` object.
438
439	"""
440	cdef size_t n = self.device_count	×
441	if n == 1:	1✔
442	return ("<dpctl." + self.__name__ + " at {}>".format(hex(id(self))))	×
443	else:
444	return (	×
445	"<dpctl."
446	+ self.__name__	×
447	+ " for {} devices at {}>".format(n, hex(id(self)))	×
448	)
449
450	def _get_capsule(self):
451	"""
452	Returns a copy of the underlying ``sycl::context`` pointer as a void
453	pointer inside a named ``PyCapsule`` that has the name
454	SyclContextRef. The ownership of the pointer inside the capsule is
455	passed to the caller, and pointer is deleted when the capsule goes out
456	of scope.
457
458	Returns:
459	:class:`pycapsule`: A capsule object storing a copy of the
460	``sycl::context`` pointer belonging to thus
461	:class:`dpctl.SyclContext` instance.
462
463	Raises:
464	ValueError: If the ``DPCTLContext_Copy`` fails to copy the
465	``sycl::context`` pointer.
466	"""
467	cdef DPCTLSyclContextRef CRef = NULL	1✔
468	CRef = DPCTLContext_Copy(self._ctxt_ref)	1✔
469	if (CRef is NULL):	1✔
470	raise ValueError("SyclContext copy failed.")	×
471	return pycapsule.PyCapsule_New(	1✔
472	<void *>CRef,
473	"SyclContextRef",
474	&_context_capsule_deleter	1✔
475	)

IntelPython / dpctl / 957611662

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