10313254333

Committed 09 Aug 2024 03:38AM UTC coverage: 87.995% (+0.07%) from 87.93%

Build # 10313254333

Build Type

Pull #1781

github

Committed by

web-flow

Commit Message

Merge 4c360d3de into dea8b8341

Pull Request Pull Request #1781: Support `kDLCPU` DLDeviceType for `from_dlpack` and `__dlpack__`

Run Details

3450 of 3959 branches covered (87.14%)

Branch coverage included in aggregate %.

182 of 204 new or added lines in 3 files covered. (89.22%)

1 existing line in 1 file now uncovered.

11525 of 13059 relevant lines covered (88.25%)

7103.92 hits per line

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

97.87

/dpctl/tensor/_flags.pyx

#                       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.

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

from libcpp cimport bool as cpp_bool

from dpctl.tensor._usmarray cimport (
    USM_ARRAY_C_CONTIGUOUS,
    USM_ARRAY_F_CONTIGUOUS,
    USM_ARRAY_WRITABLE,
    usm_ndarray,
)


cdef cpp_bool _check_bit(int flag, int mask):
    return (flag & mask) == mask


cdef class Flags:
    """
    Helper class to query the flags of a :class:`dpctl.tensor.usm_ndarray`
    instance, which describe how the instance interfaces with its underlying
    memory.
    """
    cdef int flags_
    cdef usm_ndarray arr_

    def __cinit__(self, usm_ndarray arr, int flags):
        self.arr_ = arr
        self.flags_ = flags

    @property
    def flags(self):
        """
        Integer representation of the memory layout flags of
        :class:`dpctl.tensor.usm_ndarray` instance.
        """
        return self.flags_

    @property
    def c_contiguous(self):
        """
        True if the memory layout of the
        :class:`dpctl.tensor.usm_ndarray` instance is C-contiguous.
        """
        return _check_bit(self.flags_, USM_ARRAY_C_CONTIGUOUS)

    @property
    def f_contiguous(self):
        """
        True if the memory layout of the
        :class:`dpctl.tensor.usm_ndarray` instance is F-contiguous.
        """
        return _check_bit(self.flags_, USM_ARRAY_F_CONTIGUOUS)

    @property
    def writable(self):
        """
        True if :class:`dpctl.tensor.usm_ndarray` instance is writable.
        """
        return _check_bit(self.flags_, USM_ARRAY_WRITABLE)

    @writable.setter
    def writable(self, new_val):
        if not isinstance(new_val, bool):
            raise TypeError("Expecting a boolean value")
        self.arr_._set_writable_flag(new_val)

    @property
    def fc(self):
        """
        True if the memory layout of the :class:`dpctl.tensor.usm_ndarray`
        instance is C-contiguous and F-contiguous.
        """
        return (
           _check_bit(self.flags_, USM_ARRAY_C_CONTIGUOUS)
           and _check_bit(self.flags_, USM_ARRAY_F_CONTIGUOUS)
        )

    @property
    def forc(self):
        """
        True if the memory layout of the :class:`dpctl.tensor.usm_ndarray`
        instance is C-contiguous or F-contiguous.
        """
        return (
           _check_bit(self.flags_, USM_ARRAY_C_CONTIGUOUS)
           or _check_bit(self.flags_, USM_ARRAY_F_CONTIGUOUS)
        )

    @property
    def fnc(self):
        """
        True if the memory layout of the :class:`dpctl.tensor.usm_ndarray`
        instance is F-contiguous and not C-contiguous.
        """
        return (
           _check_bit(self.flags_, USM_ARRAY_F_CONTIGUOUS)
           and not _check_bit(self.flags_, USM_ARRAY_C_CONTIGUOUS)
        )

    @property
    def contiguous(self):
        """
        True if the memory layout of the :class:`dpctl.tensor.usm_ndarray`
        instance is C-contiguous and F-contiguous.
        Equivalent to `forc.`
        """
        return self.forc

    def __getitem__(self, name):
        if name in ["C_CONTIGUOUS", "C"]:
            return self.c_contiguous
        elif name in ["F_CONTIGUOUS", "F"]:
            return self.f_contiguous
        elif name in ["WRITABLE", "W"]:
            return self.writable
        elif name == "FC":
            return self.fc
        elif name == "FNC":
            return self.fnc
        elif name in ["FORC", "CONTIGUOUS"]:
            return self.forc

    def __setitem__(self, name, val):
        if name in ["WRITABLE", "W"]:
            self.writable = val
        else:
            raise ValueError(
                "Only writable ('W' or 'WRITABLE') flag can be set"
            )

    def __repr__(self):
        out = []
        for name in "C_CONTIGUOUS", "F_CONTIGUOUS", "WRITABLE":
            out.append("  {} : {}".format(name, self[name]))
        return '\n'.join(out)

    def __eq__(self, other):
        cdef Flags other_
        if isinstance(other, self.__class__):
           other_ = <Flags>other
           return self.flags_ == other_.flags_
        elif isinstance(other, int):
           return self.flags_ == <int>other
        else:
           return False

1	# Data Parallel Control (dpctl)	1✔
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	# distutils: language = c++
18	# cython: language_level=3
19	# cython: linetrace=True
20
21	from libcpp cimport bool as cpp_bool
22
23	from dpctl.tensor._usmarray cimport (
24	USM_ARRAY_C_CONTIGUOUS,
25	USM_ARRAY_F_CONTIGUOUS,
26	USM_ARRAY_WRITABLE,
27	usm_ndarray,
28	)
29
30
31	cdef cpp_bool _check_bit(int flag, int mask):	1✔
32	return (flag & mask) == mask	1✔
33
34
35	cdef class Flags:
36	"""
37	Helper class to query the flags of a :class:`dpctl.tensor.usm_ndarray`
38	instance, which describe how the instance interfaces with its underlying
39	memory.
40	"""
41	cdef int flags_
42	cdef usm_ndarray arr_
43
44	def __cinit__(self, usm_ndarray arr, int flags):
45	self.arr_ = arr	1✔
46	self.flags_ = flags	1✔
47
48	@property
49	def flags(self):
50	"""
51	Integer representation of the memory layout flags of
52	:class:`dpctl.tensor.usm_ndarray` instance.
53	"""
UNCOV 54	return self.flags_	×
55
56	@property
57	def c_contiguous(self):
58	"""
59	True if the memory layout of the
60	:class:`dpctl.tensor.usm_ndarray` instance is C-contiguous.
61	"""
62	return _check_bit(self.flags_, USM_ARRAY_C_CONTIGUOUS)	1✔
63
64	@property
65	def f_contiguous(self):
66	"""
67	True if the memory layout of the
68	:class:`dpctl.tensor.usm_ndarray` instance is F-contiguous.
69	"""
70	return _check_bit(self.flags_, USM_ARRAY_F_CONTIGUOUS)	1✔
71
72	@property
73	def writable(self):
74	"""
75	True if :class:`dpctl.tensor.usm_ndarray` instance is writable.
76	"""
77	return _check_bit(self.flags_, USM_ARRAY_WRITABLE)	1✔
78
79	@writable.setter
80	def writable(self, new_val):
81	if not isinstance(new_val, bool):	1✔
82	raise TypeError("Expecting a boolean value")	1✔
83	self.arr_._set_writable_flag(new_val)	1✔
84
85	@property
86	def fc(self):
87	"""
88	True if the memory layout of the :class:`dpctl.tensor.usm_ndarray`
89	instance is C-contiguous and F-contiguous.
90	"""
91	return (	1✔
92	_check_bit(self.flags_, USM_ARRAY_C_CONTIGUOUS)	1✔
93	and _check_bit(self.flags_, USM_ARRAY_F_CONTIGUOUS)	1✔
94	)
95
96	@property
97	def forc(self):
98	"""
99	True if the memory layout of the :class:`dpctl.tensor.usm_ndarray`
100	instance is C-contiguous or F-contiguous.
101	"""
102	return (	1✔
103	_check_bit(self.flags_, USM_ARRAY_C_CONTIGUOUS)	1✔
104	or _check_bit(self.flags_, USM_ARRAY_F_CONTIGUOUS)	1✔
105	)
106
107	@property
108	def fnc(self):
109	"""
110	True if the memory layout of the :class:`dpctl.tensor.usm_ndarray`
111	instance is F-contiguous and not C-contiguous.
112	"""
113	return (	1✔
114	_check_bit(self.flags_, USM_ARRAY_F_CONTIGUOUS)	1✔
115	and not _check_bit(self.flags_, USM_ARRAY_C_CONTIGUOUS)	1✔
116	)
117
118	@property
119	def contiguous(self):
120	"""
121	True if the memory layout of the :class:`dpctl.tensor.usm_ndarray`
122	instance is C-contiguous and F-contiguous.
123	Equivalent to `forc.`
124	"""
125	return self.forc	1✔
126
127	def __getitem__(self, name):
128	if name in ["C_CONTIGUOUS", "C"]:	1✔
129	return self.c_contiguous	1✔
130	elif name in ["F_CONTIGUOUS", "F"]:	1✔
131	return self.f_contiguous	1✔
132	elif name in ["WRITABLE", "W"]:	1✔
133	return self.writable	1✔
134	elif name == "FC":	1✔
135	return self.fc	1✔
136	elif name == "FNC":	1✔
137	return self.fnc	1✔
138	elif name in ["FORC", "CONTIGUOUS"]:	1✔
139	return self.forc	1✔
140
141	def __setitem__(self, name, val):
142	if name in ["WRITABLE", "W"]:	1✔
143	self.writable = val	1✔
144	else:
145	raise ValueError(	1✔
146	"Only writable ('W' or 'WRITABLE') flag can be set"
147	)
148
149	def __repr__(self):
150	out = []	1✔
151	for name in "C_CONTIGUOUS", "F_CONTIGUOUS", "WRITABLE":	1✔
152	out.append(" {} : {}".format(name, self[name]))	1✔
153	return '\n'.join(out)	1✔
154
155	def __eq__(self, other):
156	cdef Flags other_
157	if isinstance(other, self.__class__):	1✔
158	other_ = <Flags>other	1✔
159	return self.flags_ == other_.flags_	1✔
160	elif isinstance(other, int):	1✔
161	return self.flags_ == <int>other	1✔
162	else:
163	return False	1✔

IntelPython / dpctl / 10313254333

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