1199708344

Build # 1199708344

Build Type

github

Committed by GitHub

Commit Message

Merge 35946d438 into 5544129c7

Pull Request Pull Request #575: Coverage memory

Run Details

547 of 881 branches covered (62.09%)

Branch coverage included in aggregate %.

10 of 11 new or added lines in 2 files covered. (90.91%)

17 existing lines in 2 files now uncovered.

3717 of 5256 relevant lines covered (70.72%)

11.33 hits per line

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

66.67

/dpctl/_sycl_queue_manager.pyx

#                      Data Parallel Control (dpctl)
#
# Copyright 2020 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

import logging
from contextlib import contextmanager

from .enum_types import backend_type, device_type

from ._backend cimport (  # noqa: E211
    DPCTLQueueMgr_GetCurrentQueue,
    DPCTLQueueMgr_GetQueueStackSize,
    DPCTLQueueMgr_GlobalQueueIsCurrent,
    DPCTLQueueMgr_PopQueue,
    DPCTLQueueMgr_PushQueue,
    DPCTLQueueMgr_SetGlobalQueue,
    DPCTLSyclQueueRef,
    _backend_type,
    _device_type,
)
from ._sycl_context cimport SyclContext

__all__ = [
    "device_context",
    "get_current_backend",
    "get_current_device_type",
    "get_current_queue",
    "get_num_activated_queues",
    "is_in_device_context",
    "set_global_queue",
]

_logger = logging.getLogger(__name__)


cdef class _SyclQueueManager:
    """ Provides a SYCL queue manager interface for Python.
    """

    def _set_as_current_queue(self, arg):
        cdef SyclQueue q
        cdef DPCTLSyclQueueRef queue_ref = NULL

        if isinstance(arg, SyclQueue):
            q_obj = arg
        else:
            q_obj = SyclQueue(arg)

        q = <SyclQueue> q_obj
        queue_ref = q.get_queue_ref()
        DPCTLQueueMgr_PushQueue(queue_ref)

        return q_obj

    def _remove_current_queue(self):
        DPCTLQueueMgr_PopQueue()

    cpdef get_current_backend(self):
        """
        Returns the backend for the current queue as a `backend_type` enum.

        Returns:
            backend_type: The SYCL backend for the currently selected queue.
        """
        return self.get_current_queue().backend

    cpdef get_current_device_type(self):
        """
        Returns current device type as a `device_type` enum.

        Returns:
            device_type: The SYCL device type for the currently selected queue.
            Possible values can be gpu, cpu, accelerator, or host.
        """
        return self.get_current_queue().sycl_device.device_type

    cpdef SyclQueue get_current_queue(self):
        """
        Returns the currently activated SYCL queue as a new SyclQueue object.

        Returns:
            SyclQueue: If there is a currently active SYCL queue that queue
            is returned wrapped in a SyclQueue object. The SyclQueue object
            owns a copy of the currently active SYCL queue as an opaque
            `DPCTLSyclQueueRef` pointer. The pointer is freed when the SyclQueue
            is garbage collected.

        Raises:
            SyclQueueCreationError: If no currently active SYCL queue found.
        """
        return SyclQueue._create(DPCTLQueueMgr_GetCurrentQueue())

    def get_num_activated_queues(self):
        """
        Returns the number of currently activated queues for this thread.

        Whenever a program's control enters a :func:`dpctl.device_context()`
        scope, either a new SYCL queue is created or a previously created
        queue is retrieved from a cache and yielded. The queue yielded by the
        context manager is termed to be "activated". If a program creates
        multiple nested :func:`dpctl.device_context()` scopes then multiple
        queues can be activated at the same time, although only the latest
        activated queue is usable directly via calling
        :func:`dpctl.get_current_queue()`. This function returns the number of
        currently activated queues.

        Returns:
            int: The number of currently activated queues.

        """
        return DPCTLQueueMgr_GetQueueStackSize()

    def is_in_device_context(self):
        """
        Checks if the control is inside a :func:`dpctl.device_context()` scope.

        Returns:
            bool: True if the control is within a
            :func:`dpctl.device_context()` scope, otherwise False.
        """
        cdef int inCtx = DPCTLQueueMgr_GlobalQueueIsCurrent()
        return not bool(inCtx)

    def set_global_queue(self, arg):
        """
        Sets the global queue to the SYCL queue specified explicitly,
        or created from given arguments.

        Args:
            arg: An instance of :class:`dpctl.SyclQueue` or a filter selector
                string to be used to construct a :class:`dpctl.SyclQueue`. The
                queue is stored in the dpctl queue manager as the default queue.
        Raises:
            SyclQueueCreationError: If a SYCL queue could not be created.
        """
        cdef SyclQueue q
        cdef DPCTLSyclQueueRef queue_ref = NULL

        if type(arg) is SyclQueue:
            q = <SyclQueue> arg
        else:
            q_obj = SyclQueue(arg)
            q = <SyclQueue> q_obj

        queue_ref = q.get_queue_ref()
        DPCTLQueueMgr_SetGlobalQueue(queue_ref)


# This private instance of the _SyclQueueManager should not be directly
# accessed outside the module.
_mgr = _SyclQueueManager()

# Global bound functions
get_num_activated_queues = _mgr.get_num_activated_queues
set_global_queue = _mgr.set_global_queue
is_in_device_context = _mgr.is_in_device_context


cpdef SyclQueue get_current_queue():
    """
    Returns the currently activate SYCL queue as a new SyclQueue object.

    Returns:
        SyclQueue: If there is a currently active SYCL queue that queue
        is returned wrapped in a SyclQueue object. The SyclQueue object
        owns a copy of the currently active SYCL queue as an opaque
        `DPCTLSyclQueueRef` pointer. The pointer is freed when the SyclQueue
        is garbage collected.

    Raises:
        SyclQueueCreationError: If no currently active SYCL queue found.
    """
    return _mgr.get_current_queue()


cpdef get_current_device_type():
    """
    Returns current device type as a `device_type` enum.

    Returns:
        device_type: The SYCL device type for the currently selected queue.
        Possible values can be gpu, cpu, accelerator, or host.
    """
    return _mgr.get_current_device_type()


cpdef get_current_backend():
    """
    Returns the backend for the current queue as a `backend_type` enum.

    Returns:
        backend_type: The SYCL backend for the currently selected queue.
    """
    return _mgr.get_current_backend()


@contextmanager
def device_context(arg):
    """
    Yields a SYCL queue corresponding to the input filter string.

    This context manager "activates", *i.e.*, sets as the currently usable
    queue, the SYCL queue defined by the argument `arg`.
    The activated queue is yielded by the context manager and can also be
    accessed by any subsequent call to :func:`dpctl.get_current_queue()` inside
    the context manager's scope. The yielded queue is removed as the currently
    usable queue on exiting the context manager.

    Args:

        queue_str (str) : A string corresponding to the DPC++ filter selector.

    Yields:
        :class:`.SyclQueue`: A SYCL queue corresponding to the specified
        filter string.

    Raises:
        SyclQueueCreationError: If the SYCL queue creation failed.

    :Example:
        To create a scope within which the Level Zero GPU number 0 is active,
        a programmer needs to do the following.

        .. code-block:: python

            import dpctl
            with dpctl.device_context("level0:gpu:0"):
                pass

    """
    ctxt = None
    try:
        ctxt = _mgr._set_as_current_queue(arg)
        yield ctxt
    finally:
        # Code to release resource
        if ctxt:
            _logger.debug(
                "Removing the queue from the stack of active queues")
            _mgr._remove_current_queue()
        else:
            _logger.debug("No queue was created so nothing to do")

1	# Data Parallel Control (dpctl)	1✔
2	#
3	# Copyright 2020 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	import logging	1✔
22	from contextlib import contextmanager	1✔
23
24	from .enum_types import backend_type, device_type	1✔
25
26	from ._backend cimport ( # noqa: E211
27	DPCTLQueueMgr_GetCurrentQueue,
28	DPCTLQueueMgr_GetQueueStackSize,
29	DPCTLQueueMgr_GlobalQueueIsCurrent,
30	DPCTLQueueMgr_PopQueue,
31	DPCTLQueueMgr_PushQueue,
32	DPCTLQueueMgr_SetGlobalQueue,
33	DPCTLSyclQueueRef,
34	_backend_type,
35	_device_type,
36	)
37	from ._sycl_context cimport SyclContext
38
39	__all__ = [	1✔
40	"device_context",
41	"get_current_backend",
42	"get_current_device_type",
43	"get_current_queue",
44	"get_num_activated_queues",
45	"is_in_device_context",
46	"set_global_queue",
47	]
48
49	_logger = logging.getLogger(__name__)	1✔
50
51
52	cdef class _SyclQueueManager:
53	""" Provides a SYCL queue manager interface for Python.
54	"""
55
56	def _set_as_current_queue(self, arg):
57	cdef SyclQueue q
UNCOV 58	cdef DPCTLSyclQueueRef queue_ref = NULL	×
59
UNCOV 60	if isinstance(arg, SyclQueue):	×
61	q_obj = arg	×
62	else:
UNCOV 63	q_obj = SyclQueue(arg)	×
64
UNCOV 65	q = <SyclQueue> q_obj	×
UNCOV 66	queue_ref = q.get_queue_ref()	×
UNCOV 67	DPCTLQueueMgr_PushQueue(queue_ref)	×
68
UNCOV 69	return q_obj	×
70
71	def _remove_current_queue(self):
UNCOV 72	DPCTLQueueMgr_PopQueue()	×
73
74	cpdef get_current_backend(self):	1✔
75	"""
76	Returns the backend for the current queue as a `backend_type` enum.
77
78	Returns:
79	backend_type: The SYCL backend for the currently selected queue.
80	"""
81	return self.get_current_queue().backend	1✔
82
83	cpdef get_current_device_type(self):	1✔
84	"""
85	Returns current device type as a `device_type` enum.
86
87	Returns:
88	device_type: The SYCL device type for the currently selected queue.
89	Possible values can be gpu, cpu, accelerator, or host.
90	"""
91	return self.get_current_queue().sycl_device.device_type	1✔
92
93	cpdef SyclQueue get_current_queue(self):	1✔
94	"""
95	Returns the currently activated SYCL queue as a new SyclQueue object.
96
97	Returns:
98	SyclQueue: If there is a currently active SYCL queue that queue
99	is returned wrapped in a SyclQueue object. The SyclQueue object
100	owns a copy of the currently active SYCL queue as an opaque
101	`DPCTLSyclQueueRef` pointer. The pointer is freed when the SyclQueue
102	is garbage collected.
103
104	Raises:
105	SyclQueueCreationError: If no currently active SYCL queue found.
106	"""
107	return SyclQueue._create(DPCTLQueueMgr_GetCurrentQueue())	1✔
108
109	def get_num_activated_queues(self):
110	"""
111	Returns the number of currently activated queues for this thread.
112
113	Whenever a program's control enters a :func:`dpctl.device_context()`
114	scope, either a new SYCL queue is created or a previously created
115	queue is retrieved from a cache and yielded. The queue yielded by the
116	context manager is termed to be "activated". If a program creates
117	multiple nested :func:`dpctl.device_context()` scopes then multiple
118	queues can be activated at the same time, although only the latest
119	activated queue is usable directly via calling
120	:func:`dpctl.get_current_queue()`. This function returns the number of
121	currently activated queues.
122
123	Returns:
124	int: The number of currently activated queues.
125
126	"""
127	return DPCTLQueueMgr_GetQueueStackSize()	1✔
128
129	def is_in_device_context(self):
130	"""
131	Checks if the control is inside a :func:`dpctl.device_context()` scope.
132
133	Returns:
134	bool: True if the control is within a
135	:func:`dpctl.device_context()` scope, otherwise False.
136	"""
137	cdef int inCtx = DPCTLQueueMgr_GlobalQueueIsCurrent()	1✔
138	return not bool(inCtx)	1✔
139
140	def set_global_queue(self, arg):
141	"""
142	Sets the global queue to the SYCL queue specified explicitly,
143	or created from given arguments.
144
145	Args:
146	arg: An instance of :class:`dpctl.SyclQueue` or a filter selector
147	string to be used to construct a :class:`dpctl.SyclQueue`. The
148	queue is stored in the dpctl queue manager as the default queue.
149	Raises:
150	SyclQueueCreationError: If a SYCL queue could not be created.
151	"""
152	cdef SyclQueue q
153	cdef DPCTLSyclQueueRef queue_ref = NULL	1✔
154
155	if type(arg) is SyclQueue:	1✔
156	q = <SyclQueue> arg	1✔
157	else:
158	q_obj = SyclQueue(arg)	1✔
159	q = <SyclQueue> q_obj	1✔
160
161	queue_ref = q.get_queue_ref()	1✔
162	DPCTLQueueMgr_SetGlobalQueue(queue_ref)	1✔
163
164
165	# This private instance of the _SyclQueueManager should not be directly
166	# accessed outside the module.
167	_mgr = _SyclQueueManager()	1✔
168
169	# Global bound functions
170	get_num_activated_queues = _mgr.get_num_activated_queues	1✔
171	set_global_queue = _mgr.set_global_queue	1✔
172	is_in_device_context = _mgr.is_in_device_context	1✔
173
174
175	cpdef SyclQueue get_current_queue():	1✔
176	"""
177	Returns the currently activate SYCL queue as a new SyclQueue object.
178
179	Returns:
180	SyclQueue: If there is a currently active SYCL queue that queue
181	is returned wrapped in a SyclQueue object. The SyclQueue object
182	owns a copy of the currently active SYCL queue as an opaque
183	`DPCTLSyclQueueRef` pointer. The pointer is freed when the SyclQueue
184	is garbage collected.
185
186	Raises:
187	SyclQueueCreationError: If no currently active SYCL queue found.
188	"""
189	return _mgr.get_current_queue()	1✔
190
191
192	cpdef get_current_device_type():	1✔
193	"""
194	Returns current device type as a `device_type` enum.
195
196	Returns:
197	device_type: The SYCL device type for the currently selected queue.
198	Possible values can be gpu, cpu, accelerator, or host.
199	"""
200	return _mgr.get_current_device_type()	1✔
201
202
203	cpdef get_current_backend():	1✔
204	"""
205	Returns the backend for the current queue as a `backend_type` enum.
206
207	Returns:
208	backend_type: The SYCL backend for the currently selected queue.
209	"""
210	return _mgr.get_current_backend()	1✔
211
212
213	@contextmanager	1✔
214	def device_context(arg):	1✔
215	"""
216	Yields a SYCL queue corresponding to the input filter string.
217
218	This context manager "activates", i.e., sets as the currently usable
219	queue, the SYCL queue defined by the argument `arg`.
220	The activated queue is yielded by the context manager and can also be
221	accessed by any subsequent call to :func:`dpctl.get_current_queue()` inside
222	the context manager's scope. The yielded queue is removed as the currently
223	usable queue on exiting the context manager.
224
225	Args:
226
227	queue_str (str) : A string corresponding to the DPC++ filter selector.
228
229	Yields:
230	:class:`.SyclQueue`: A SYCL queue corresponding to the specified
231	filter string.
232
233	Raises:
234	SyclQueueCreationError: If the SYCL queue creation failed.
235
236	:Example:
237	To create a scope within which the Level Zero GPU number 0 is active,
238	a programmer needs to do the following.
239
240	.. code-block:: python
241
242	import dpctl
243	with dpctl.device_context("level0:gpu:0"):
244	pass
245
246	"""
UNCOV 247	ctxt = None	×
UNCOV 248	try:	×
UNCOV 249	ctxt = _mgr._set_as_current_queue(arg)	×
UNCOV 250	yield ctxt	×
251	finally:
252	# Code to release resource
UNCOV 253	if ctxt:	×
UNCOV 254	_logger.debug(	×
255	"Removing the queue from the stack of active queues")
UNCOV 256	_mgr._remove_current_queue()	×
257	else:
258	_logger.debug("No queue was created so nothing to do")	×

IntelPython / dpctl / 1199708344

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