1227792495

Build Type

github

Committed by GitHub

Commit Message

Merge e32b395af into b97efdf98

Pull Request Pull Request #578: Add methods __bool__, __float__ and __int__ to usm_ndarray

Run Details

550 of 881 branches covered (62.43%)

Branch coverage included in aggregate %.

31 of 34 new or added lines in 3 files covered. (91.18%)

2 existing lines in 1 file now uncovered.

3913 of 5276 relevant lines covered (74.17%)

11.32 hits per line

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

81.48

/dpctl/tensor/_usmarray.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

import numpy as np

import dpctl
import dpctl.memory as dpmem

from ._device import Device

from cpython.mem cimport PyMem_Free
from cpython.tuple cimport PyTuple_New, PyTuple_SetItem

cimport dpctl as c_dpctl
cimport dpctl.memory as c_dpmem


cdef extern from "usm_array.hpp" namespace "usm_array":
    cdef cppclass usm_array:
        usm_array(char *, int, size_t*, Py_ssize_t *,
                  int, int, c_dpctl.DPCTLSyclQueueRef) except +


include "_stride_utils.pxi"
include "_types.pxi"
include "_slicing.pxi"

cdef class InternalUSMArrayError(Exception):
    """
    A InternalError exception is raised when internal
    inconsistency has been detected.
    """
    pass


cdef class usm_ndarray:
    """
    usm_ndarray(
        shape, dtype="|f8", strides=None, buffer='device',
        offset=0, order='C',
        buffer_ctor_kwargs=dict()
    )

    See :class:`dpctl.memory.MemoryUSMShared` for allowed
    keyword arguments.

    `buffer` can be 'shared', 'host', 'device' to allocate
    new device memory by calling respective constructor with
    the specified `buffer_ctor_kwrds`; `buffer` can be an
    instance of :class:`dpctl.memory.MemoryUSMShared`,
    :class:`dpctl.memory.MemoryUSMDevice`, or
    :class:`dpctl.memory.MemoryUSMHost`; `buffer` can also be
    another usm_ndarray instance, in which case its underlying
    MemoryUSM* buffer is used for buffer.
    """

    cdef void _reset(usm_ndarray self):
        """
        Initializes member fields
        """
        self.base_ = None
        self.nd_ = -1
        self.data_ = <char *>0
        self.shape_ = <Py_ssize_t *>0
        self.strides_ = <Py_ssize_t *>0
        self.flags_ = 0

    cdef void _cleanup(usm_ndarray self):
        if (self.shape_):
            PyMem_Free(self.shape_)
        if (self.strides_):
            PyMem_Free(self.strides_)
        self._reset()

    cdef usm_ndarray _clone(usm_ndarray self):
        """
        Provides a copy of Python object pointing to the same data
        """
        cdef int item_size = self.get_itemsize()
        cdef Py_ssize_t offset_elems = self.get_offset()
        cdef usm_ndarray res = usm_ndarray.__new__(
            usm_ndarray, _make_int_tuple(self.nd_, self.shape_),
            dtype=_make_typestr(self.typenum_),
            strides=(
                _make_int_tuple(self.nd_, self.strides_) if (self.strides_)
                else None),
            buffer=self.base_,
            offset=offset_elems,
            order=('C' if (self.flags_ & USM_ARRAY_C_CONTIGUOUS) else 'F')
        )
        res.flags_ = self.flags_
        if (res.data_ != self.data_):
            raise InternalUSMArrayError(
                "Data pointers of cloned and original objects are different.")
        return res

    def __cinit__(self, shape, dtype="|f8", strides=None, buffer='device',
                  Py_ssize_t offset=0, order='C', buffer_ctor_kwargs=dict()):
        """
        strides and offset must be given in units of array elements.
        buffer can be strings ('device'|'shared'|'host' to allocate new memory)
        or dpctl.memory.MemoryUSM* buffers, or usm_ndrray instances.
        """
        cdef int nd = 0
        cdef int typenum = 0
        cdef int itemsize = 0
        cdef int err = 0
        cdef int contig_flag = 0
        cdef Py_ssize_t *shape_ptr = NULL
        cdef Py_ssize_t ary_nelems = 0
        cdef Py_ssize_t ary_nbytes = 0
        cdef Py_ssize_t *strides_ptr = NULL
        cdef Py_ssize_t _offset = offset
        cdef Py_ssize_t ary_min_displacement = 0
        cdef Py_ssize_t ary_max_displacement = 0
        cdef Py_ssize_t tmp = 0
        cdef char * data_ptr = NULL

        self._reset()
        if (not isinstance(shape, (list, tuple))
                and not hasattr(shape, 'tolist')):
            try:
                tmp = <Py_ssize_t> shape
                shape = [shape, ]
            except Exception:
                raise TypeError("Argument shape must be a list or a tuple.")
        nd = len(shape)
        typenum = dtype_to_typenum(dtype)
        itemsize = type_bytesize(typenum)
        if (itemsize < 1):
            raise TypeError("dtype=" + dtype + " is not supported.")
        # allocate host C-arrays for shape, strides
        err = _from_input_shape_strides(
            nd, shape, strides, itemsize, <char> ord(order),
            &shape_ptr, &strides_ptr, &ary_nelems,
            &ary_min_displacement, &ary_max_displacement, &contig_flag
        )
        if (err):
            self._cleanup()
            if err == ERROR_MALLOC:
                raise MemoryError("Memory allocation for shape/strides "
                                  "array failed.")
            elif err == ERROR_INCORRECT_ORDER:
                raise ValueError(
                    "Unsupported order='{}' given. "
                    "Supported values are 'C' or 'F'.".format(order))
            elif err == ERROR_UNEXPECTED_STRIDES:
                raise ValueError(
                    "strides={} is not understood".format(strides))
            else:
                raise InternalUSMArrayError(
                    " .. while processing shape and strides.")
        ary_nbytes = (ary_max_displacement -
                      ary_min_displacement + 1) * itemsize
        if isinstance(buffer, dpmem._memory._Memory):
            _buffer = buffer
        elif isinstance(buffer, (str, bytes)):
            if isinstance(buffer, bytes):
                buffer = buffer.decode("UTF-8")
            _offset = -ary_min_displacement
            if (buffer == "shared"):
                _buffer = dpmem.MemoryUSMShared(ary_nbytes,
                                                **buffer_ctor_kwargs)
            elif (buffer == "device"):
                _buffer = dpmem.MemoryUSMDevice(ary_nbytes,
                                                **buffer_ctor_kwargs)
            elif (buffer == "host"):
                _buffer = dpmem.MemoryUSMHost(ary_nbytes,
                                              **buffer_ctor_kwargs)
            else:
                self._cleanup()
                raise ValueError(
                    "buffer='{}' is not understood. "
                    "Recognized values are 'device', 'shared',  'host', "
                    "an instance of `MemoryUSM*` object, or a usm_ndarray"
                    "".format(buffer))
        elif isinstance(buffer, usm_ndarray):
            _buffer = buffer.usm_data
        else:
            self._cleanup()
            raise ValueError("buffer='{}' was not understood.".format(buffer))
        if (_offset + ary_min_displacement < 0 or
           (_offset + ary_max_displacement + 1) * itemsize > _buffer.nbytes):
            self._cleanup()
            raise ValueError("buffer='{}' can not accomodate the requested "
                             "array.".format(buffer))
        self.base_ = _buffer
        self.data_ = (<char *> (<size_t> _buffer._pointer)) + itemsize * _offset
        self.shape_ = shape_ptr
        self.strides_ = strides_ptr
        self.typenum_ = typenum
        self.flags_ = contig_flag
        self.nd_ = nd

    def __dealloc__(self):
        self._cleanup()

    cdef Py_ssize_t get_offset(self) except *:
        cdef char *mem_ptr = NULL
        cdef char *ary_ptr = self.get_data()
        mem_ptr = <char *>(<size_t> self.base_._pointer)
        byte_offset = ary_ptr - mem_ptr
        item_size = self.get_itemsize()
        if (byte_offset % item_size):
            raise InternalUSMArrayError(
                "byte_offset is not a multiple of item_size.")
        return byte_offset // item_size

    cdef char* get_data(self):
        """Returns the USM pointer for this array."""
        return self.data_

    cdef int get_ndim(self):
        """
        Returns the number of indices needed to address
        an element of this array.
        """
        return self.nd_

    cdef Py_ssize_t* get_shape(self):
        """
        Returns pointer to shape C-array for this array.

        C-array has at least `ndim` non-negative elements,
        which determine the range of permissible indices
        addressing individual elements of this array.
        """
        return self.shape_

    cdef Py_ssize_t* get_strides(self):
        """
        Returns pointer to strides C-array for this array.

        The pointer can be NULL (contiguous array), or the
        array size is at least `ndim` elements
        """
        return self.strides_

    cdef int get_typenum(self):
        """Returns typenum corresponding to values of this array"""
        return self.typenum_

    cdef int get_itemsize(self):
        """
        Returns itemsize of this arrays in bytes
        """
        return type_bytesize(self.typenum_)

    cdef int get_flags(self):
        """Returns flags of this array"""
        return self.flags_

    cdef object get_base(self):
        """Returns the object owning the USM data addressed by this array"""
        return self.base_

    cdef c_dpctl.SyclQueue get_sycl_queue(self):
        cdef c_dpmem._Memory mem
        if not isinstance(self.base_, dpctl.memory._Memory):
            raise InternalUSMArrayError(
                "This array has unexpected memory owner"
            )
        mem = <c_dpmem._Memory> self.base_
        return mem.queue

    cdef c_dpctl.DPCTLSyclQueueRef get_queue_ref(self) except *:
        cdef c_dpctl.SyclQueue q = self.get_sycl_queue()
        cdef c_dpctl.DPCTLSyclQueueRef QRef = q.get_queue_ref()
        cdef c_dpctl.DPCTLSyclQueueRef QRefCopy = NULL
        if QRef is not NULL:
            QRefCopy = c_dpctl.DPCTLQueue_Copy(QRef)
            return QRefCopy
        else:
            raise InternalUSMArrayError(
                "Memory owner of this array is corrupted"
            )

    @property
    def __sycl_usm_array_interface__(self):
        """
        Gives __sycl_usm_array_interface__ dictionary describing the array
        """
        cdef Py_ssize_t byte_offset = -1
        cdef int item_size = -1
        cdef Py_ssize_t elem_offset = -1
        cdef char *mem_ptr = NULL
        cdef char *ary_ptr = NULL
        if (not isinstance(self.base_, dpmem._memory._Memory)):
            raise ValueError("Invalid instance of usm_ndarray ecountered")
        ary_iface = self.base_.__sycl_usm_array_interface__
        mem_ptr = <char *>(<size_t> ary_iface['data'][0])
        ary_ptr = <char *>(<size_t> self.data_)
        ro_flag = False if (self.flags_ & USM_ARRAY_WRITEABLE) else True
        ary_iface['data'] = (<size_t> mem_ptr, ro_flag)
        ary_iface['shape'] = self.shape
        if (self.strides_):
            ary_iface['strides'] = _make_int_tuple(self.nd_, self.strides_)
        else:
            if (self.flags_ & USM_ARRAY_C_CONTIGUOUS):
                ary_iface['strides'] = None
            elif (self.flags_ & USM_ARRAY_F_CONTIGUOUS):
                ary_iface['strides'] = _f_contig_strides(self.nd_, self.shape_)
            else:
                raise ValueError("USM Array is not contiguous and "
                                 "has empty strides")
        ary_iface['typestr'] = _make_typestr(self.typenum_)
        byte_offset = ary_ptr - mem_ptr
        item_size = self.get_itemsize()
        if (byte_offset % item_size):
            raise InternalUSMArrayError(
                "byte_offset is not a multiple of item_size.")
        elem_offset = byte_offset // item_size
        ary_iface['offset'] = elem_offset
        return ary_iface

    @property
    def ndim(self):
        """
        Gives the number of indices needed to address elements of this array.
        """
        return self.nd_

    @property
    def usm_data(self):
        """
        Gives USM memory object underlying usm_array instance.
        """
        return self.base_

    @property
    def shape(self):
        """
        Elements of the shape tuple give the lengths of the
        respective array dimensions.
        """
        if self.nd_ > 0:
            return _make_int_tuple(self.nd_, self.shape_)
        else:
            return tuple()

    @property
    def strides(self):
        """
        Returns memory displacement in array elements, upon unit
        change of respective index.

        E.g. for strides (s1, s2, s3) and multi-index (i1, i2, i3)

           a[i1, i2, i3] == (&a[0,0,0])[ s1*s1 + s2*i2 + s3*i3]
        """
        if (self.strides_):
            return _make_int_tuple(self.nd_, self.strides_)
        else:
            if (self.flags_ & USM_ARRAY_C_CONTIGUOUS):
                return _c_contig_strides(self.nd_, self.shape_)
            elif (self.flags_ & USM_ARRAY_F_CONTIGUOUS):
                return _f_contig_strides(self.nd_, self.shape_)
            else:
                raise ValueError("Inconsitent usm_ndarray data")

    @property
    def flags(self):
        """
        Currently returns integer whose bits correspond to the flags.
        """
        return self.flags_

    @property
    def usm_type(self):
        """
        USM type of underlying memory. Can be 'device', 'shared', or 'host'.

        See: https://docs.oneapi.com/versions/latest/dpcpp/iface/usm.html
        """
        return self.base_.get_usm_type()

    @property
    def itemsize(self):
        """
        Size of array element in bytes.
        """
        return self.get_itemsize()

    @property
    def nbytes(self):
        """
        Total bytes consumed by the elements of the array.
        """
        return (
            shape_to_elem_count(self.nd_, self.shape_) *
            self.get_itemsize())

    @property
    def size(self):
        """
        Number of elements in the array.
        """
        return shape_to_elem_count(self.nd_, self.shape_)

    @property
    def dtype(self):
        """
        Returns NumPy's dtype corresponding to the type of the array elements.
        """
        return np.dtype(_make_typestr(self.typenum_))

    @property
    def sycl_queue(self):
        """
        Returns `dpctl.SyclQueue` object associated with USM data.
        """
        return self.get_sycl_queue()

    @property
    def sycl_device(self):
        """
        Returns `dpctl.SyclDevice` object on which USM data was allocated.
        """
        q = self.sycl_queue
        return q.sycl_device

    @property
    def device(self):
        """
        Returns data-API object representing residence of the array data.
        """
        return Device.create_device(self.sycl_queue)

    @property
    def sycl_context(self):
        """
        Returns `dpctl.SyclContext` object to which USM data is bound.
        """
        q = self.sycl_queue
        return q.sycl_context

    @property
    def T(self):
        if self.nd_ < 2:
            return self
        else:
            return _transpose(self)

    @property
    def real(self):
        if (self.typenum_ < UAR_CFLOAT):
            # elements are real
            return self
        if (self.typenum_ < UAR_TYPE_SENTINEL):
            return _real_view(self)

    @property
    def imag(self):
        if (self.typenum_ < UAR_CFLOAT):
            # elements are real
            return _zero_like(self)
        if (self.typenum_ < UAR_TYPE_SENTINEL):
            return _imag_view(self)

    def __getitem__(self, ind):
        cdef tuple _meta = _basic_slice_meta(
            ind, (<object>self).shape, (<object> self).strides,
            self.get_offset())
        cdef usm_ndarray res

        res = usm_ndarray.__new__(
            usm_ndarray,
            _meta[0],
            dtype=_make_typestr(self.typenum_),
            strides=_meta[1],
            buffer=self.base_,
            offset=_meta[2]
        )
        res.flags_ |= (self.flags_ & USM_ARRAY_WRITEABLE)
        return res

    def __bool__(self):
        if self.size == 1:
            mem_view = dpmem.as_usm_memory(self)
            return mem_view.copy_to_host().view(self.dtype).__bool__()

        if self.size == 0:
            raise ValueError(
                "The truth value of an empty array is ambiguous"
            )

        raise ValueError(
            "The truth value of an array with more than one element is "
            "ambiguous. Use a.any() or a.all()"
        )

    def __float__(self):
        if self.size == 1:
            mem_view = dpmem.as_usm_memory(self)
            return mem_view.copy_to_host().view(self.dtype).__float__()

        raise ValueError(
            "only size-1 arrays can be converted to Python scalars"
        )

    def __int__(self):
        if self.size == 1:
            mem_view = dpmem.as_usm_memory(self)
            return mem_view.copy_to_host().view(self.dtype).__int__()

        raise ValueError(
            "only size-1 arrays can be converted to Python scalars"
        )

    def __index__(self):
        if np.issubdtype(self.dtype, np.integer):
            return int(self)

        raise IndexError("only integer arrays are valid indices")

    def to_device(self, target_device):
        """
        Transfer array to target device
        """
        d = Device.create_device(target_device)
        if (d.sycl_device == self.sycl_device):
            return self
        elif (d.sycl_context == self.sycl_context):
            res = usm_ndarray(
                self.shape,
                self.dtype,
                buffer=self.usm_data,
                strides=self.strides,
                offset=self.get_offset()
            )
            res.flags_ = self.flags
            return res
        else:
            nbytes = self.usm_data.nbytes
            new_buffer = type(self.usm_data)(
                nbytes, queue=d.sycl_queue
            )
            new_buffer.copy_from_device(self.usm_data)
            res = usm_ndarray(
                self.shape,
                self.dtype,
                buffer=new_buffer,
                strides=self.strides,
                offset=self.get_offset()
            )
            res.flags_ = self.flags
            return res


cdef usm_ndarray _real_view(usm_ndarray ary):
    """
    View into real parts of a complex type array
    """
    cdef usm_ndarray r = ary._clone()
    if (ary.typenum_ == UAR_CFLOAT):
        r.typenum_ = UAR_FLOAT
    elif (ary.typenum_ == UAR_CDOUBLE):
        r.typenum_ = UAR_DOUBLE
    else:
        raise InternalUSMArrayError(
            "_real_view call on array of non-complex type.")
    return r


cdef usm_ndarray _imag_view(usm_ndarray ary):
    """
    View into imaginary parts of a complex type array
    """
    cdef usm_ndarray r = ary._clone()
    if (ary.typenum_ == UAR_CFLOAT):
        r.typenum_ = UAR_FLOAT
    elif (ary.typenum_ == UAR_CDOUBLE):
        r.typenum_ = UAR_DOUBLE
    else:
        raise InternalUSMArrayError(
            "_real_view call on array of non-complex type.")
    # displace pointer to imaginary part
    r.data_ = r.data_ + type_bytesize(r.typenum_)
    return r


cdef usm_ndarray _transpose(usm_ndarray ary):
    """
    Construct transposed array without copying the data
    """
    cdef usm_ndarray r = usm_ndarray.__new__(
        usm_ndarray,
        _make_reversed_int_tuple(ary.nd_, ary.shape_),
        dtype=_make_typestr(ary.typenum_),
        strides=(
            _make_reversed_int_tuple(ary.nd_, ary.strides_)
            if (ary.strides_) else None),
        buffer=ary.base_,
        order=('F' if (ary.flags_ & USM_ARRAY_C_CONTIGUOUS) else 'C')
    )
    r.flags_ |= (ary.flags_ & USM_ARRAY_WRITEABLE)
    return r


cdef usm_ndarray _zero_like(usm_ndarray ary):
    """
    Make C-contiguous array of zero elements with same shape
    and type as ary.
    """
    cdef usm_ndarray r = usm_ndarray(
        _make_int_tuple(ary.nd_, ary.shape_),
        dtype=_make_typestr(ary.typenum_),
        buffer=ary.base_.get_usm_type()
    )
    # TODO: call function to set array elements to zero
    return r

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	import numpy as np	1✔
22
23	import dpctl	1✔
24	import dpctl.memory as dpmem	1✔
25
26	from ._device import Device	1✔
27
28	from cpython.mem cimport PyMem_Free
29	from cpython.tuple cimport PyTuple_New, PyTuple_SetItem
30
31	cimport dpctl as c_dpctl
32	cimport dpctl.memory as c_dpmem
33
34
35	cdef extern from "usm_array.hpp" namespace "usm_array":
36	cdef cppclass usm_array:
37	usm_array(char , int, size_t, Py_ssize_t *,
38	int, int, c_dpctl.DPCTLSyclQueueRef) except +
39
40
41	include "_stride_utils.pxi"
42	include "_types.pxi"
43	include "_slicing.pxi"
44
45	cdef class InternalUSMArrayError(Exception):
46	"""
47	A InternalError exception is raised when internal
48	inconsistency has been detected.
49	"""
50	pass
51
52
53	cdef class usm_ndarray:
54	"""
55	usm_ndarray(
56	shape, dtype="\|f8", strides=None, buffer='device',
57	offset=0, order='C',
58	buffer_ctor_kwargs=dict()
59	)
60
61	See :class:`dpctl.memory.MemoryUSMShared` for allowed
62	keyword arguments.
63
64	`buffer` can be 'shared', 'host', 'device' to allocate
65	new device memory by calling respective constructor with
66	the specified `buffer_ctor_kwrds`; `buffer` can be an
67	instance of :class:`dpctl.memory.MemoryUSMShared`,
68	:class:`dpctl.memory.MemoryUSMDevice`, or
69	:class:`dpctl.memory.MemoryUSMHost`; `buffer` can also be
70	another usm_ndarray instance, in which case its underlying
71	MemoryUSM* buffer is used for buffer.
72	"""
73
74	cdef void _reset(usm_ndarray self):	1✔
75	"""
76	Initializes member fields
77	"""
78	self.base_ = None	1✔
79	self.nd_ = -1	1✔
80	self.data_ = <char *>0	1✔
81	self.shape_ = <Py_ssize_t *>0	1✔
82	self.strides_ = <Py_ssize_t *>0	1✔
83	self.flags_ = 0	1✔
84
85	cdef void _cleanup(usm_ndarray self):	1✔
86	if (self.shape_):	1✔
87	PyMem_Free(self.shape_)	1✔
88	if (self.strides_):	1✔
89	PyMem_Free(self.strides_)	1✔
90	self._reset()	1✔
91
92	cdef usm_ndarray _clone(usm_ndarray self):	1✔
93	"""
94	Provides a copy of Python object pointing to the same data
95	"""
96	cdef int item_size = self.get_itemsize()	1✔
97	cdef Py_ssize_t offset_elems = self.get_offset()	1✔
98	cdef usm_ndarray res = usm_ndarray.__new__(	1✔
99	usm_ndarray, _make_int_tuple(self.nd_, self.shape_),	1✔
100	dtype=_make_typestr(self.typenum_),	1✔
101	strides=(
102	_make_int_tuple(self.nd_, self.strides_) if (self.strides_)	1✔
103	else None),	1✔
104	buffer=self.base_,	1✔
105	offset=offset_elems,	1✔
106	order=('C' if (self.flags_ & USM_ARRAY_C_CONTIGUOUS) else 'F')	1✔
107	)
108	res.flags_ = self.flags_	1✔
109	if (res.data_ != self.data_):	1✔
110	raise InternalUSMArrayError(	×
111	"Data pointers of cloned and original objects are different.")
112	return res	1✔
113
114	def __cinit__(self, shape, dtype="\|f8", strides=None, buffer='device',
115	Py_ssize_t offset=0, order='C', buffer_ctor_kwargs=dict()):	1✔
116	"""
117	strides and offset must be given in units of array elements.
118	buffer can be strings ('device'\|'shared'\|'host' to allocate new memory)
119	or dpctl.memory.MemoryUSM* buffers, or usm_ndrray instances.
120	"""
121	cdef int nd = 0	1✔
122	cdef int typenum = 0	1✔
123	cdef int itemsize = 0	1✔
124	cdef int err = 0	1✔
125	cdef int contig_flag = 0	1✔
126	cdef Py_ssize_t *shape_ptr = NULL	1✔
127	cdef Py_ssize_t ary_nelems = 0	1✔
128	cdef Py_ssize_t ary_nbytes = 0	1✔
129	cdef Py_ssize_t *strides_ptr = NULL	1✔
130	cdef Py_ssize_t _offset = offset	1✔
131	cdef Py_ssize_t ary_min_displacement = 0	1✔
132	cdef Py_ssize_t ary_max_displacement = 0	1✔
133	cdef Py_ssize_t tmp = 0	1✔
134	cdef char * data_ptr = NULL	1✔
135
136	self._reset()	1✔
137	if (not isinstance(shape, (list, tuple))	1✔
138	and not hasattr(shape, 'tolist')):	1✔
139	try:	1✔
140	tmp = <Py_ssize_t> shape	1✔
141	shape = [shape, ]	1✔
142	except Exception:	1✔
143	raise TypeError("Argument shape must be a list or a tuple.")	1✔
144	nd = len(shape)	1✔
145	typenum = dtype_to_typenum(dtype)	1✔
146	itemsize = type_bytesize(typenum)	1✔
147	if (itemsize < 1):	1✔
148	raise TypeError("dtype=" + dtype + " is not supported.")	1✔
149	# allocate host C-arrays for shape, strides
150	err = _from_input_shape_strides(	1✔
151	nd, shape, strides, itemsize, <char> ord(order),	1✔
152	&shape_ptr, &strides_ptr, &ary_nelems,
153	&ary_min_displacement, &ary_max_displacement, &contig_flag
154	)
155	if (err):	1✔
156	self._cleanup()	1✔
157	if err == ERROR_MALLOC:	1✔
158	raise MemoryError("Memory allocation for shape/strides "	×
159	"array failed.")
160	elif err == ERROR_INCORRECT_ORDER:	1✔
161	raise ValueError(	1✔
162	"Unsupported order='{}' given. "
163	"Supported values are 'C' or 'F'.".format(order))	1✔
164	elif err == ERROR_UNEXPECTED_STRIDES:	×
165	raise ValueError(	1✔
166	"strides={} is not understood".format(strides))	×
167	else:
168	raise InternalUSMArrayError(	×
169	" .. while processing shape and strides.")
170	ary_nbytes = (ary_max_displacement -
171	ary_min_displacement + 1) * itemsize	1✔
172	if isinstance(buffer, dpmem._memory._Memory):	1✔
173	_buffer = buffer	1✔
174	elif isinstance(buffer, (str, bytes)):	1✔
175	if isinstance(buffer, bytes):	1✔
176	buffer = buffer.decode("UTF-8")	1✔
177	_offset = -ary_min_displacement	1✔
178	if (buffer == "shared"):	1✔
179	_buffer = dpmem.MemoryUSMShared(ary_nbytes,	1✔
180	**buffer_ctor_kwargs)	1✔
181	elif (buffer == "device"):	1✔
182	_buffer = dpmem.MemoryUSMDevice(ary_nbytes,	1✔
183	**buffer_ctor_kwargs)	1✔
184	elif (buffer == "host"):	1✔
185	_buffer = dpmem.MemoryUSMHost(ary_nbytes,	1✔
186	**buffer_ctor_kwargs)	1✔
187	else:
188	self._cleanup()	1✔
189	raise ValueError(	1✔
190	"buffer='{}' is not understood. "
191	"Recognized values are 'device', 'shared', 'host', "
192	"an instance of `MemoryUSM*` object, or a usm_ndarray"
193	"".format(buffer))	1✔
194	elif isinstance(buffer, usm_ndarray):	1✔
195	_buffer = buffer.usm_data	1✔
196	else:
197	self._cleanup()	1✔
198	raise ValueError("buffer='{}' was not understood.".format(buffer))	1✔
199	if (_offset + ary_min_displacement < 0 or	1✔
200	(_offset + ary_max_displacement + 1) * itemsize > _buffer.nbytes):	1✔
201	self._cleanup()	×
202	raise ValueError("buffer='{}' can not accomodate the requested "	1✔
203	"array.".format(buffer))	×
204	self.base_ = _buffer	1✔
205	self.data_ = (<char > (<size_t> _buffer._pointer)) + itemsize _offset	1✔
206	self.shape_ = shape_ptr	1✔
207	self.strides_ = strides_ptr	1✔
208	self.typenum_ = typenum	1✔
209	self.flags_ = contig_flag	1✔
210	self.nd_ = nd	1✔
211
212	def __dealloc__(self):
213	self._cleanup()	1✔
214
215	cdef Py_ssize_t get_offset(self) except *:	1✔
216	cdef char *mem_ptr = NULL	1✔
217	cdef char *ary_ptr = self.get_data()	1✔
218	mem_ptr = <char *>(<size_t> self.base_._pointer)	1✔
219	byte_offset = ary_ptr - mem_ptr	1✔
220	item_size = self.get_itemsize()	1✔
221	if (byte_offset % item_size):	1✔
222	raise InternalUSMArrayError(	×
223	"byte_offset is not a multiple of item_size.")
224	return byte_offset // item_size	1✔
225
226	cdef char* get_data(self):	1✔
227	"""Returns the USM pointer for this array."""
228	return self.data_	1✔
229
230	cdef int get_ndim(self):	1✔
231	"""
232	Returns the number of indices needed to address
233	an element of this array.
234	"""
235	return self.nd_	×
236
237	cdef Py_ssize_t* get_shape(self):	1✔
238	"""
239	Returns pointer to shape C-array for this array.
240
241	C-array has at least `ndim` non-negative elements,
242	which determine the range of permissible indices
243	addressing individual elements of this array.
244	"""
245	return self.shape_	×
246
247	cdef Py_ssize_t* get_strides(self):	1✔
248	"""
249	Returns pointer to strides C-array for this array.
250
251	The pointer can be NULL (contiguous array), or the
252	array size is at least `ndim` elements
253	"""
254	return self.strides_	×
255
256	cdef int get_typenum(self):	1✔
257	"""Returns typenum corresponding to values of this array"""
258	return self.typenum_	×
259
260	cdef int get_itemsize(self):	1✔
261	"""
262	Returns itemsize of this arrays in bytes
263	"""
264	return type_bytesize(self.typenum_)	1✔
265
266	cdef int get_flags(self):	1✔
267	"""Returns flags of this array"""
268	return self.flags_	×
269
270	cdef object get_base(self):	1✔
271	"""Returns the object owning the USM data addressed by this array"""
272	return self.base_	×
273
274	cdef c_dpctl.SyclQueue get_sycl_queue(self):	1✔
275	cdef c_dpmem._Memory mem
276	if not isinstance(self.base_, dpctl.memory._Memory):	1✔
277	raise InternalUSMArrayError(	×
278	"This array has unexpected memory owner"
279	)
280	mem = <c_dpmem._Memory> self.base_	1✔
281	return mem.queue	1✔
282
283	cdef c_dpctl.DPCTLSyclQueueRef get_queue_ref(self) except *:	1✔
284	cdef c_dpctl.SyclQueue q = self.get_sycl_queue()	×
285	cdef c_dpctl.DPCTLSyclQueueRef QRef = q.get_queue_ref()	×
286	cdef c_dpctl.DPCTLSyclQueueRef QRefCopy = NULL	1✔
287	if QRef is not NULL:	1✔
288	QRefCopy = c_dpctl.DPCTLQueue_Copy(QRef)	1✔
289	return QRefCopy	×
290	else:
291	raise InternalUSMArrayError(	1✔
292	"Memory owner of this array is corrupted"
293	)
294
295	@property
296	def __sycl_usm_array_interface__(self):
297	"""
298	Gives __sycl_usm_array_interface__ dictionary describing the array
299	"""
300	cdef Py_ssize_t byte_offset = -1	1✔
301	cdef int item_size = -1	1✔
302	cdef Py_ssize_t elem_offset = -1	1✔
303	cdef char *mem_ptr = NULL	1✔
304	cdef char *ary_ptr = NULL	1✔
305	if (not isinstance(self.base_, dpmem._memory._Memory)):	1✔
306	raise ValueError("Invalid instance of usm_ndarray ecountered")	×
307	ary_iface = self.base_.__sycl_usm_array_interface__	1✔
308	mem_ptr = <char *>(<size_t> ary_iface['data'][0])	1✔
309	ary_ptr = <char *>(<size_t> self.data_)	1✔
310	ro_flag = False if (self.flags_ & USM_ARRAY_WRITEABLE) else True	1✔
311	ary_iface['data'] = (<size_t> mem_ptr, ro_flag)	1✔
312	ary_iface['shape'] = self.shape	1✔
313	if (self.strides_):	1✔
314	ary_iface['strides'] = _make_int_tuple(self.nd_, self.strides_)	1✔
315	else:
316	if (self.flags_ & USM_ARRAY_C_CONTIGUOUS):	1✔
317	ary_iface['strides'] = None	1✔
318	elif (self.flags_ & USM_ARRAY_F_CONTIGUOUS):	1✔
319	ary_iface['strides'] = _f_contig_strides(self.nd_, self.shape_)	1✔
320	else:
321	raise ValueError("USM Array is not contiguous and "	×
322	"has empty strides")
323	ary_iface['typestr'] = _make_typestr(self.typenum_)	1✔
324	byte_offset = ary_ptr - mem_ptr	1✔
325	item_size = self.get_itemsize()	1✔
326	if (byte_offset % item_size):	1✔
327	raise InternalUSMArrayError(	×
328	"byte_offset is not a multiple of item_size.")
329	elem_offset = byte_offset // item_size	1✔
330	ary_iface['offset'] = elem_offset	1✔
331	return ary_iface	1✔
332
333	@property
334	def ndim(self):
335	"""
336	Gives the number of indices needed to address elements of this array.
337	"""
338	return self.nd_	1✔
339
340	@property
341	def usm_data(self):
342	"""
343	Gives USM memory object underlying usm_array instance.
344	"""
345	return self.base_	1✔
346
347	@property
348	def shape(self):
349	"""
350	Elements of the shape tuple give the lengths of the
351	respective array dimensions.
352	"""
353	if self.nd_ > 0:	1✔
354	return _make_int_tuple(self.nd_, self.shape_)	1✔
355	else:
356	return tuple()	1✔
357
358	@property
359	def strides(self):
360	"""
361	Returns memory displacement in array elements, upon unit
362	change of respective index.
363
364	E.g. for strides (s1, s2, s3) and multi-index (i1, i2, i3)
365
366	a[i1, i2, i3] == (&a[0,0,0])[ s1s1 + s2i2 + s3*i3]
367	"""
368	if (self.strides_):	1✔
369	return _make_int_tuple(self.nd_, self.strides_)	1✔
370	else:
371	if (self.flags_ & USM_ARRAY_C_CONTIGUOUS):	1✔
372	return _c_contig_strides(self.nd_, self.shape_)	1✔
373	elif (self.flags_ & USM_ARRAY_F_CONTIGUOUS):	1✔
374	return _f_contig_strides(self.nd_, self.shape_)	1✔
375	else:
376	raise ValueError("Inconsitent usm_ndarray data")	×
377
378	@property
379	def flags(self):
380	"""
381	Currently returns integer whose bits correspond to the flags.
382	"""
383	return self.flags_	1✔
384
385	@property
386	def usm_type(self):
387	"""
388	USM type of underlying memory. Can be 'device', 'shared', or 'host'.
389
390	See: https://docs.oneapi.com/versions/latest/dpcpp/iface/usm.html
391	"""
392	return self.base_.get_usm_type()	1✔
393
394	@property
395	def itemsize(self):
396	"""
397	Size of array element in bytes.
398	"""
399	return self.get_itemsize()	1✔
400
401	@property
402	def nbytes(self):
403	"""
404	Total bytes consumed by the elements of the array.
405	"""
406	return (	1✔
407	shape_to_elem_count(self.nd_, self.shape_) *	1✔
408	self.get_itemsize())
409
410	@property
411	def size(self):
412	"""
413	Number of elements in the array.
414	"""
415	return shape_to_elem_count(self.nd_, self.shape_)	1✔
416
417	@property
418	def dtype(self):
419	"""
420	Returns NumPy's dtype corresponding to the type of the array elements.
421	"""
422	return np.dtype(_make_typestr(self.typenum_))	1✔
423
424	@property
425	def sycl_queue(self):
426	"""
427	Returns `dpctl.SyclQueue` object associated with USM data.
428	"""
429	return self.get_sycl_queue()	1✔
430
431	@property
432	def sycl_device(self):
433	"""
434	Returns `dpctl.SyclDevice` object on which USM data was allocated.
435	"""
436	q = self.sycl_queue	1✔
437	return q.sycl_device	1✔
438
439	@property
440	def device(self):
441	"""
442	Returns data-API object representing residence of the array data.
443	"""
444	return Device.create_device(self.sycl_queue)	1✔
445
446	@property
447	def sycl_context(self):
448	"""
449	Returns `dpctl.SyclContext` object to which USM data is bound.
450	"""
451	q = self.sycl_queue	1✔
452	return q.sycl_context	1✔
453
454	@property
455	def T(self):
456	if self.nd_ < 2:	1✔
457	return self	×
458	else:
459	return _transpose(self)	1✔
460
461	@property
462	def real(self):
463	if (self.typenum_ < UAR_CFLOAT):	1✔
464	# elements are real
465	return self	×
466	if (self.typenum_ < UAR_TYPE_SENTINEL):	1✔
467	return _real_view(self)	1✔
468
469	@property
470	def imag(self):
471	if (self.typenum_ < UAR_CFLOAT):	1✔
472	# elements are real
473	return _zero_like(self)	×
474	if (self.typenum_ < UAR_TYPE_SENTINEL):	1✔
475	return _imag_view(self)	1✔
476
477	def __getitem__(self, ind):
478	cdef tuple _meta = _basic_slice_meta(	1✔
479	ind, (<object>self).shape, (<object> self).strides,	1✔
480	self.get_offset())	1✔
481	cdef usm_ndarray res
482
483	res = usm_ndarray.__new__(	1✔
484	usm_ndarray,
485	_meta[0],	1✔
486	dtype=_make_typestr(self.typenum_),	1✔
487	strides=_meta[1],	1✔
488	buffer=self.base_,	1✔
489	offset=_meta[2]	1✔
490	)
491	res.flags_ \|= (self.flags_ & USM_ARRAY_WRITEABLE)	1✔
492	return res	1✔
493
494	def __bool__(self):
495	if self.size == 1:	1✔
496	mem_view = dpmem.as_usm_memory(self)	1✔
497	return mem_view.copy_to_host().view(self.dtype).__bool__()	1✔
498
499	if self.size == 0:	1✔
500	raise ValueError(	1✔
501	"The truth value of an empty array is ambiguous"
502	)
503
504	raise ValueError(	1✔
505	"The truth value of an array with more than one element is "
506	"ambiguous. Use a.any() or a.all()"
507	)
508
509	def __float__(self):
510	if self.size == 1:	1✔
511	mem_view = dpmem.as_usm_memory(self)	1✔
512	return mem_view.copy_to_host().view(self.dtype).__float__()	1✔
513
514	raise ValueError(	1✔
515	"only size-1 arrays can be converted to Python scalars"
516	)
517
518	def __int__(self):
519	if self.size == 1:	1✔
520	mem_view = dpmem.as_usm_memory(self)	1✔
521	return mem_view.copy_to_host().view(self.dtype).__int__()	1✔
522
523	raise ValueError(	1✔
524	"only size-1 arrays can be converted to Python scalars"
525	)
526
527	def __index__(self):
528	if np.issubdtype(self.dtype, np.integer):	1✔
529	return int(self)	1✔
530
531	raise IndexError("only integer arrays are valid indices")	1✔
532
533	def to_device(self, target_device):
534	"""
535	Transfer array to target device
536	"""
537	d = Device.create_device(target_device)	1✔
538	if (d.sycl_device == self.sycl_device):	1✔
539	return self	1✔
NEW UNCOV 540	elif (d.sycl_context == self.sycl_context):	×
NEW 541	res = usm_ndarray(	×
542	self.shape,	×
543	self.dtype,	×
544	buffer=self.usm_data,	×
545	strides=self.strides,	×
546	offset=self.get_offset()	×
547	)
548	res.flags_ = self.flags	×
549	return res	1✔
550	else:
551	nbytes = self.usm_data.nbytes	×
552	new_buffer = type(self.usm_data)(	×
553	nbytes, queue=d.sycl_queue	×
554	)
555	new_buffer.copy_from_device(self.usm_data)	×
556	res = usm_ndarray(	×
557	self.shape,	×
558	self.dtype,	×
559	buffer=new_buffer,	×
560	strides=self.strides,	×
561	offset=self.get_offset()	×
562	)
563	res.flags_ = self.flags	×
564	return res	×
565
566
567	cdef usm_ndarray _real_view(usm_ndarray ary):	1✔
568	"""
569	View into real parts of a complex type array
570	"""
571	cdef usm_ndarray r = ary._clone()	1✔
572	if (ary.typenum_ == UAR_CFLOAT):	1✔
573	r.typenum_ = UAR_FLOAT	×
574	elif (ary.typenum_ == UAR_CDOUBLE):	1✔
575	r.typenum_ = UAR_DOUBLE	1✔
576	else:
577	raise InternalUSMArrayError(	×
578	"_real_view call on array of non-complex type.")
579	return r	1✔
580
581
582	cdef usm_ndarray _imag_view(usm_ndarray ary):	1✔
583	"""
584	View into imaginary parts of a complex type array
585	"""
586	cdef usm_ndarray r = ary._clone()	1✔
587	if (ary.typenum_ == UAR_CFLOAT):	1✔
UNCOV 588	r.typenum_ = UAR_FLOAT	×
589	elif (ary.typenum_ == UAR_CDOUBLE):	1✔
590	r.typenum_ = UAR_DOUBLE	1✔
591	else:
592	raise InternalUSMArrayError(	×
593	"_real_view call on array of non-complex type.")
594	# displace pointer to imaginary part
595	r.data_ = r.data_ + type_bytesize(r.typenum_)	1✔
596	return r	1✔
597
598
599	cdef usm_ndarray _transpose(usm_ndarray ary):	1✔
600	"""
601	Construct transposed array without copying the data
602	"""
603	cdef usm_ndarray r = usm_ndarray.__new__(	1✔
604	usm_ndarray,
605	_make_reversed_int_tuple(ary.nd_, ary.shape_),	1✔
606	dtype=_make_typestr(ary.typenum_),	1✔
607	strides=(
608	_make_reversed_int_tuple(ary.nd_, ary.strides_)	×
609	if (ary.strides_) else None),	1✔
610	buffer=ary.base_,	1✔
611	order=('F' if (ary.flags_ & USM_ARRAY_C_CONTIGUOUS) else 'C')	1✔
612	)
613	r.flags_ \|= (ary.flags_ & USM_ARRAY_WRITEABLE)	1✔
614	return r	1✔
615
616
617	cdef usm_ndarray _zero_like(usm_ndarray ary):	1✔
618	"""
619	Make C-contiguous array of zero elements with same shape
620	and type as ary.
621	"""
622	cdef usm_ndarray r = usm_ndarray(	×
623	_make_int_tuple(ary.nd_, ary.shape_),	×
624	dtype=_make_typestr(ary.typenum_),	×
625	buffer=ary.base_.get_usm_type()	×
626	)
627	# TODO: call function to set array elements to zero
628	return r	×

IntelPython / dpctl / 1227792495

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