9198956347

Committed 22 May 2024 10:02PM UTC coverage: 87.915% (-0.03%) from 87.943%

Build # 9198956347

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1691 from IntelPython/add-emulated-aspect

Add support for aspect::emulated

Run Details

3254 of 3746 branches covered (86.87%)

Branch coverage included in aggregate %.

9 of 12 new or added lines in 2 files covered. (75.0%)

2 existing lines in 2 files now uncovered.

11041 of 12514 relevant lines covered (88.23%)

8252.61 hits per line

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

89.29

/dpctl/_device_selection.py

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

import collections.abc
from itertools import chain

from ._sycl_device import SyclDevice, SyclDeviceCreationError
from ._sycl_device_factory import get_devices


def select_device_with_aspects(required_aspects, excluded_aspects=None):
    """Selects the root :class:`dpctl.SyclDevice` that has the highest
    default selector score among devices that have all aspects in the
    `required_aspects` list, and do not have any aspects in `excluded_aspects`
    list.

    The list of SYCL device aspects can be found in SYCL 2020 specs:

    https://www.khronos.org/registry/SYCL/specs/sycl-2020/html/sycl-2020.html#sec:device-aspects

        :Example:
            .. code-block:: python

                import dpctl
                # select a GPU that supports double precision
                dpctl.select_device_with_aspects(['fp64', 'gpu'])
                # select non-custom device with USM shared allocations
                dpctl.select_device_with_aspects(
                    ['usm_shared_allocations'], excluded_aspects=['custom'])
    """
    if excluded_aspects is None:
        excluded_aspects = []
    if isinstance(required_aspects, str):
        required_aspects = [
            required_aspects,
        ]
    if isinstance(excluded_aspects, str):
        excluded_aspects = [
            excluded_aspects,
        ]
    seq = collections.abc.Sequence
    input_types_ok = isinstance(required_aspects, seq) and isinstance(
        excluded_aspects, seq
    )
    if not input_types_ok:
        raise TypeError(
            "Aspects are expected to be Python sequences, "
            "e.g. lists, of strings"
        )
    for asp in chain(required_aspects, excluded_aspects):
        if not isinstance(asp, str):
            raise TypeError("The list objects must be of a string type")
        if not hasattr(SyclDevice, "has_aspect_" + asp):
            raise AttributeError(f"The {asp} aspect is not supported in dpctl")
    devs = get_devices()
    max_score = 0
    selected_dev = None

    for dev in devs:
        aspect_status = all(
            (
                getattr(dev, "has_aspect_" + asp) is True
                for asp in required_aspects
            )
        )
        aspect_status = aspect_status and not (
            any(
                (
                    getattr(dev, "has_aspect_" + asp) is True
                    for asp in excluded_aspects
                )
            )
        )
        if aspect_status and dev.default_selector_score > max_score:
            max_score = dev.default_selector_score
            selected_dev = dev

    if selected_dev is None:
        raise SyclDeviceCreationError(
            f"Requested device is unavailable: "
            f"required_aspects={required_aspects}, "
            f"excluded_aspects={excluded_aspects}"
        )

    return selected_dev

1	# Data Parallel Control (dpctl)
2	#
3	# Copyright 2020-2024 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	import collections.abc	1✔
18	from itertools import chain	1✔
19
20	from ._sycl_device import SyclDevice, SyclDeviceCreationError	1✔
21	from ._sycl_device_factory import get_devices	1✔
22
23
24	def select_device_with_aspects(required_aspects, excluded_aspects=None):	1✔
25	"""Selects the root :class:`dpctl.SyclDevice` that has the highest
26	default selector score among devices that have all aspects in the
27	`required_aspects` list, and do not have any aspects in `excluded_aspects`
28	list.
29
30	The list of SYCL device aspects can be found in SYCL 2020 specs:
31
32	https://www.khronos.org/registry/SYCL/specs/sycl-2020/html/sycl-2020.html#sec:device-aspects
33
34	:Example:
35	.. code-block:: python
36
37	import dpctl
38	# select a GPU that supports double precision
39	dpctl.select_device_with_aspects(['fp64', 'gpu'])
40	# select non-custom device with USM shared allocations
41	dpctl.select_device_with_aspects(
42	['usm_shared_allocations'], excluded_aspects=['custom'])
43	"""
44	if excluded_aspects is None:	1✔
45	excluded_aspects = []	1✔
46	if isinstance(required_aspects, str):	1✔
47	required_aspects = [	1✔
48	required_aspects,
49	]
50	if isinstance(excluded_aspects, str):	1✔
51	excluded_aspects = [	1✔
52	excluded_aspects,
53	]
54	seq = collections.abc.Sequence	1✔
55	input_types_ok = isinstance(required_aspects, seq) and isinstance(	1✔
56	excluded_aspects, seq
57	)
58	if not input_types_ok:	1!
59	raise TypeError(	×
60	"Aspects are expected to be Python sequences, "
61	"e.g. lists, of strings"
62	)
63	for asp in chain(required_aspects, excluded_aspects):	1✔
64	if not isinstance(asp, str):	1!
65	raise TypeError("The list objects must be of a string type")	×
66	if not hasattr(SyclDevice, "has_aspect_" + asp):	1!
UNCOV 67	raise AttributeError(f"The {asp} aspect is not supported in dpctl")	×
68	devs = get_devices()	1✔
69	max_score = 0	1✔
70	selected_dev = None	1✔
71
72	for dev in devs:	1✔
73	aspect_status = all(	1✔
74	(
75	getattr(dev, "has_aspect_" + asp) is True
76	for asp in required_aspects
77	)
78	)
79	aspect_status = aspect_status and not (	1✔
80	any(
81	(
82	getattr(dev, "has_aspect_" + asp) is True
83	for asp in excluded_aspects
84	)
85	)
86	)
87	if aspect_status and dev.default_selector_score > max_score:	1✔
88	max_score = dev.default_selector_score	1✔
89	selected_dev = dev	1✔
90
91	if selected_dev is None:	1✔
92	raise SyclDeviceCreationError(	1✔
93	f"Requested device is unavailable: "
94	f"required_aspects={required_aspects}, "
95	f"excluded_aspects={excluded_aspects}"
96	)
97
98	return selected_dev	1✔

IntelPython / dpctl / 9198956347

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