1263677918

Build Type

github

Committed by GitHub

Commit Message

Merge ba9c37d65 into ebc8b6dc2

Pull Request Pull Request #586: usm_ndarray used to be declared public api, now just api

Run Details

644 of 1028 branches covered (62.65%)

Branch coverage included in aggregate %.

257 of 526 new or added lines in 5 files covered. (48.86%)

4 existing lines in 1 file now uncovered.

4185 of 5777 relevant lines covered (72.44%)

10.39 hits per line

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

68.6

/dpctl/tensor/_copy_utils.py

import operator

import numpy as np

import dpctl.memory as dpm
import dpctl.tensor as dpt


def contract_iter2(shape, strides1, strides2):
    p = np.argsort(np.abs(strides1))[::-1]
    sh = [operator.index(shape[i]) for i in p]
    disp1 = 0
    disp2 = 0
    st1 = []
    st2 = []
    contractable = True
    for i in p:
        this_stride1 = operator.index(strides1[i])
        this_stride2 = operator.index(strides2[i])
        if this_stride1 < 0 and this_stride2 < 0:
            disp1 += this_stride1 * (shape[i] - 1)
            this_stride1 = -this_stride1
            disp2 += this_stride2 * (shape[i] - 1)
            this_stride2 = -this_stride2
        if this_stride1 < 0 or this_stride2 < 0:
            contractable = False
        st1.append(this_stride1)
        st2.append(this_stride2)
    while contractable:
        changed = False
        k = len(sh) - 1
        for i in range(k):
            step1 = st1[i + 1]
            jump1 = st1[i] - (sh[i + 1] - 1) * step1
            step2 = st2[i + 1]
            jump2 = st2[i] - (sh[i + 1] - 1) * step2
            if jump1 == step1 and jump2 == step2:
                changed = True
                st1[i:-1] = st1[i + 1 :]
                st2[i:-1] = st2[i + 1 :]
                sh[i] *= sh[i + 1]
                sh[i + 1 : -1] = sh[i + 2 :]
                sh = sh[:-1]
                st1 = st1[:-1]
                st2 = st2[:-1]
                break
        if not changed:
            break
    return (sh, st1, disp1, st2, disp2)


def has_memory_overlap(x1, x2):
    m1 = dpm.as_usm_memory(x1)
    m2 = dpm.as_usm_memory(x2)
    if m1.sycl_device == m2.sycl_device:
        p1_beg = m1._pointer
        p1_end = p1_beg + m1.nbytes
        p2_beg = m2._pointer
        p2_end = p2_beg + m2.nbytes
        return p1_beg > p2_end or p2_beg < p1_end
    else:
        return False


def copy_to_numpy(ary):
    if type(ary) is not dpt.usm_ndarray:
        raise TypeError
    h = ary.usm_data.copy_to_host().view(ary.dtype)
    itsz = ary.itemsize
    strides_bytes = tuple(si * itsz for si in ary.strides)
    offset = ary.__sycl_usm_array_interface__.get("offset", 0) * itsz
    return np.ndarray(
        ary.shape,
        dtype=ary.dtype,
        buffer=h,
        strides=strides_bytes,
        offset=offset,
    )


def copy_from_numpy(np_ary, usm_type="device", queue=None):
    "Copies numpy array `np_ary` into a new usm_ndarray"
    # This may peform a copy to meet stated requirements
    Xnp = np.require(np_ary, requirements=["A", "O", "C", "E"])
    if queue:
        ctor_kwargs = {"queue": queue}
    else:
        ctor_kwargs = dict()
    Xusm = dpt.usm_ndarray(
        Xnp.shape,
        dtype=Xnp.dtype,
        buffer=usm_type,
        buffer_ctor_kwargs=ctor_kwargs,
    )
    Xusm.usm_data.copy_from_host(Xnp.reshape((-1)).view("u1"))
    return Xusm


def copy_from_numpy_into(dst, np_ary):
    if not isinstance(np_ary, np.ndarray):
        raise TypeError("Expected numpy.ndarray, got {}".format(type(np_ary)))
    for i in range(dst.size):
        mi = np.unravel_index(i, dst.shape)
        host_buf = np.array(np_ary[mi], ndmin=1).view("u1")
        usm_mem = dpm.as_usm_memory(dst[mi])
        usm_mem.copy_from_host(host_buf)


class Dummy:
    def __init__(self, iface):
        self.__sycl_usm_array_interface__ = iface


def copy_same_dtype(dst, src):
    if type(dst) is not dpt.usm_ndarray or type(src) is not dpt.usm_ndarray:
        raise TypeError

    if dst.shape != src.shape:
        raise ValueError

    if dst.dtype != src.dtype:
        raise ValueError

    # check that memory regions do not overlap
    if has_memory_overlap(dst, src):
        tmp = copy_to_numpy(src)
        copy_from_numpy_into(dst, tmp)
        return

    if (dst.flags & 1) and (src.flags & 1):
        dst.usm_data.copy_from_device(src.usm_data)
        return

    # simplify strides
    sh_i, dst_st, dst_disp, src_st, src_disp = contract_iter2(
        dst.shape, dst.strides, src.strides
    )
    # sh_i, dst_st, dst_disp, src_st, src_disp = (
    #    dst.shape, dst.strides, 0, src.strides, 0
    # )
    src_iface = src.__sycl_usm_array_interface__
    dst_iface = dst.__sycl_usm_array_interface__
    src_iface["shape"] = tuple()
    src_iface.pop("strides", None)
    dst_iface["shape"] = tuple()
    dst_iface.pop("strides", None)
    dst_disp = dst_disp + dst_iface.get("offset", 0)
    src_disp = src_disp + src_iface.get("offset", 0)
    for i in range(dst.size):
        mi = np.unravel_index(i, sh_i)
        dst_offset = dst_disp
        src_offset = src_disp
        for j, dst_stj, src_stj in zip(mi, dst_st, src_st):
            dst_offset = dst_offset + j * dst_stj
            src_offset = src_offset + j * src_stj
        dst_iface["offset"] = dst_offset
        src_iface["offset"] = src_offset
        msrc = dpm.as_usm_memory(Dummy(src_iface))
        mdst = dpm.as_usm_memory(Dummy(dst_iface))
        mdst.copy_from_device(msrc)


def copy_same_shape(dst, src):
    if src.dtype == dst.dtype:
        copy_same_dtype(dst, src)

    # check that memory regions do not overlap
    if has_memory_overlap(dst, src):
        tmp = copy_to_numpy(src)
        tmp = tmp.astype(dst.dtype)
        copy_from_numpy_into(dst, tmp)
        return

    # simplify strides
    sh_i, dst_st, dst_disp, src_st, src_disp = contract_iter2(
        dst.shape, dst.strides, src.strides
    )
    # sh_i, dst_st, dst_disp, src_st, src_disp = (
    #    dst.shape, dst.strides, 0, src.strides, 0
    # )
    src_iface = src.__sycl_usm_array_interface__
    dst_iface = dst.__sycl_usm_array_interface__
    src_iface["shape"] = tuple()
    src_iface.pop("strides", None)
    dst_iface["shape"] = tuple()
    dst_iface.pop("strides", None)
    dst_disp = dst_disp + dst_iface.get("offset", 0)
    src_disp = src_disp + src_iface.get("offset", 0)
    for i in range(dst.size):
        mi = np.unravel_index(i, sh_i)
        dst_offset = dst_disp
        src_offset = src_disp
        for j, dst_stj, src_stj in zip(mi, dst_st, src_st):
            dst_offset = dst_offset + j * dst_stj
            src_offset = src_offset + j * src_stj
        dst_iface["offset"] = dst_offset
        src_iface["offset"] = src_offset
        msrc = dpm.as_usm_memory(Dummy(src_iface))
        mdst = dpm.as_usm_memory(Dummy(dst_iface))
        tmp = msrc.copy_to_host().view(src.dtype)
        tmp = tmp.astype(dst.dtype)
        mdst.copy_from_host(tmp.view("u1"))


def copy_from_usm_ndarray_to_usm_ndarray(dst, src):
    if type(dst) is not dpt.usm_ndarray or type(src) is not dpt.usm_ndarray:
        raise TypeError

    if dst.ndim == src.ndim and dst.shape == src.shape:
        copy_same_shape(dst, src)

    try:
        common_shape = np.broadcast_shapes(dst.shape, src.shape)
    except ValueError:
        raise ValueError

    if dst.size < src.size:
        raise ValueError

    if len(common_shape) > dst.ndim:
        ones_count = len(common_shape) - dst.ndim
        for k in range(ones_count):
            if common_shape[k] != 1:
                raise ValueError
        common_shape = common_shape[ones_count:]

    if src.ndim < len(common_shape):
        new_src_strides = (0,) * (len(common_shape) - src.ndim) + src.strides
        src_same_shape = dpt.usm_ndarray(
            common_shape, dtype=src.dtype, buffer=src, strides=new_src_strides
        )
    else:
        src_same_shape = src

    copy_same_shape(dst, src_same_shape)


def astype(usm_ary, newdtype, order="K", casting="unsafe", copy=True):
    """
    astype(usm_array, new_dtype, order="K", casting="unsafe", copy=True)

    Returns a copy of the array, cast to a specified type.

    A view can be returned, if possible, when `copy=False` is used.
    """
    if not isinstance(usm_ary, dpt.usm_ndarray):
        return TypeError(
            "Expected object of type dpt.usm_ndarray, got {}".format(
                type(usm_ary)
            )
        )
    ary_dtype = usm_ary.dtype
    target_dtype = np.dtype(newdtype)
    if not np.can_cast(ary_dtype, target_dtype, casting=casting):
        raise TypeError(
            "Can not cast from {} to {} according to rule {}".format(
                ary_dtype, newdtype, casting
            )
        )
    c_contig = usm_ary.flags & 1
    f_contig = usm_ary.flags & 2
    needs_copy = copy or not (ary_dtype == target_dtype)
    if not needs_copy and (order != "K"):
        needs_copy = (c_contig and order not in ["A", "C"]) or (
            f_contig and order not in ["A", "F"]
        )
    if needs_copy:
        copy_order = "C"
        if order == "C":
            pass
        elif order == "F":
            copy_order = order
        elif order == "A":
            if usm_ary.flags & 2:
                copy_order = "F"
        elif order == "K":
            if usm_ary.flags & 2:
                copy_order = "F"
        R = dpt.usm_ndarray(
            usm_ary.shape,
            dtype=target_dtype,
            buffer=usm_ary.usm_type,
            order=copy_order,
            buffer_ctor_kwargs={"queue": usm_ary.sycl_queue},
        )
        if order == "K" and (not c_contig and not f_contig):
            original_strides = usm_ary.strides
            ind = sorted(
                range(usm_ary.ndim),
                key=lambda i: abs(original_strides[i]),
                reverse=True,
            )
            new_strides = tuple(R.strides[ind[i]] for i in ind)
            R = dpt.usm_ndarray(
                usm_ary.shape,
                dtype=target_dtype,
                buffer=R.usm_data,
                strides=new_strides,
            )
        copy_from_usm_ndarray_to_usm_ndarray(R, usm_ary)
        return R
    else:
        return usm_ary

1	import operator	1✔
2
3	import numpy as np	1✔
4
5	import dpctl.memory as dpm	1✔
6	import dpctl.tensor as dpt	1✔
7
8
9	def contract_iter2(shape, strides1, strides2):	1✔
10	p = np.argsort(np.abs(strides1))[::-1]	1✔
11	sh = [operator.index(shape[i]) for i in p]	1✔
12	disp1 = 0	1✔
13	disp2 = 0	1✔
14	st1 = []	1✔
15	st2 = []	1✔
16	contractable = True	1✔
17	for i in p:	1✔
18	this_stride1 = operator.index(strides1[i])	1✔
19	this_stride2 = operator.index(strides2[i])	1✔
20	if this_stride1 < 0 and this_stride2 < 0:	1✔
21	disp1 += this_stride1 * (shape[i] - 1)	1✔
22	this_stride1 = -this_stride1	1✔
23	disp2 += this_stride2 * (shape[i] - 1)	1✔
24	this_stride2 = -this_stride2	1✔
25	if this_stride1 < 0 or this_stride2 < 0:	1✔
26	contractable = False	1✔
27	st1.append(this_stride1)	1✔
28	st2.append(this_stride2)	1✔
29	while contractable:	1✔
30	changed = False	1✔
31	k = len(sh) - 1	1✔
32	for i in range(k):	1✔
33	step1 = st1[i + 1]	1✔
34	jump1 = st1[i] - (sh[i + 1] - 1) * step1	1✔
35	step2 = st2[i + 1]	1✔
36	jump2 = st2[i] - (sh[i + 1] - 1) * step2	1✔
37	if jump1 == step1 and jump2 == step2:	1!
38	changed = True	1✔
39	st1[i:-1] = st1[i + 1 :]	1✔
40	st2[i:-1] = st2[i + 1 :]	1✔
41	sh[i] *= sh[i + 1]	1✔
42	sh[i + 1 : -1] = sh[i + 2 :]	1✔
43	sh = sh[:-1]	1✔
44	st1 = st1[:-1]	1✔
45	st2 = st2[:-1]	1✔
46	break	1✔
47	if not changed:	1✔
48	break	1✔
49	return (sh, st1, disp1, st2, disp2)	1✔
50
51
52	def has_memory_overlap(x1, x2):	1✔
53	m1 = dpm.as_usm_memory(x1)	1✔
54	m2 = dpm.as_usm_memory(x2)	1✔
55	if m1.sycl_device == m2.sycl_device:	1!
56	p1_beg = m1._pointer	1✔
57	p1_end = p1_beg + m1.nbytes	1✔
58	p2_beg = m2._pointer	1✔
59	p2_end = p2_beg + m2.nbytes	1✔
60	return p1_beg > p2_end or p2_beg < p1_end	1✔
61	else:
NEW 62	return False	×
63
64
65	def copy_to_numpy(ary):	1✔
66	if type(ary) is not dpt.usm_ndarray:	1!
NEW 67	raise TypeError	×
68	h = ary.usm_data.copy_to_host().view(ary.dtype)	1✔
69	itsz = ary.itemsize	1✔
70	strides_bytes = tuple(si * itsz for si in ary.strides)	1✔
71	offset = ary.__sycl_usm_array_interface__.get("offset", 0) * itsz	1✔
72	return np.ndarray(	1✔
73	ary.shape,
74	dtype=ary.dtype,
75	buffer=h,
76	strides=strides_bytes,
77	offset=offset,
78	)
79
80
81	def copy_from_numpy(np_ary, usm_type="device", queue=None):	1✔
82	"Copies numpy array `np_ary` into a new usm_ndarray"
83	# This may peform a copy to meet stated requirements
84	Xnp = np.require(np_ary, requirements=["A", "O", "C", "E"])	1✔
85	if queue:	1✔
86	ctor_kwargs = {"queue": queue}	1✔
87	else:
88	ctor_kwargs = dict()	1✔
89	Xusm = dpt.usm_ndarray(	1✔
90	Xnp.shape,
91	dtype=Xnp.dtype,
92	buffer=usm_type,
93	buffer_ctor_kwargs=ctor_kwargs,
94	)
95	Xusm.usm_data.copy_from_host(Xnp.reshape((-1)).view("u1"))	1✔
96	return Xusm	1✔
97
98
99	def copy_from_numpy_into(dst, np_ary):	1✔
100	if not isinstance(np_ary, np.ndarray):	1!
NEW 101	raise TypeError("Expected numpy.ndarray, got {}".format(type(np_ary)))	×
102	for i in range(dst.size):	1✔
103	mi = np.unravel_index(i, dst.shape)	1✔
104	host_buf = np.array(np_ary[mi], ndmin=1).view("u1")	1✔
105	usm_mem = dpm.as_usm_memory(dst[mi])	1✔
106	usm_mem.copy_from_host(host_buf)	1✔
107
108
109	class Dummy:	1✔
110	def __init__(self, iface):	1✔
111	self.__sycl_usm_array_interface__ = iface	1✔
112
113
114	def copy_same_dtype(dst, src):	1✔
115	if type(dst) is not dpt.usm_ndarray or type(src) is not dpt.usm_ndarray:	1!
NEW 116	raise TypeError	×
117
118	if dst.shape != src.shape:	1!
NEW 119	raise ValueError	×
120
121	if dst.dtype != src.dtype:	1!
NEW 122	raise ValueError	×
123
124	# check that memory regions do not overlap
125	if has_memory_overlap(dst, src):	1✔
126	tmp = copy_to_numpy(src)	1✔
127	copy_from_numpy_into(dst, tmp)	1✔
128	return	1✔
129
130	if (dst.flags & 1) and (src.flags & 1):	1✔
131	dst.usm_data.copy_from_device(src.usm_data)	1✔
132	return	1✔
133
134	# simplify strides
135	sh_i, dst_st, dst_disp, src_st, src_disp = contract_iter2(	1✔
136	dst.shape, dst.strides, src.strides
137	)
138	# sh_i, dst_st, dst_disp, src_st, src_disp = (
139	# dst.shape, dst.strides, 0, src.strides, 0
140	# )
141	src_iface = src.__sycl_usm_array_interface__	1✔
142	dst_iface = dst.__sycl_usm_array_interface__	1✔
143	src_iface["shape"] = tuple()	1✔
144	src_iface.pop("strides", None)	1✔
145	dst_iface["shape"] = tuple()	1✔
146	dst_iface.pop("strides", None)	1✔
147	dst_disp = dst_disp + dst_iface.get("offset", 0)	1✔
148	src_disp = src_disp + src_iface.get("offset", 0)	1✔
149	for i in range(dst.size):	1✔
150	mi = np.unravel_index(i, sh_i)	1✔
151	dst_offset = dst_disp	1✔
152	src_offset = src_disp	1✔
153	for j, dst_stj, src_stj in zip(mi, dst_st, src_st):	1✔
154	dst_offset = dst_offset + j * dst_stj	1✔
155	src_offset = src_offset + j * src_stj	1✔
156	dst_iface["offset"] = dst_offset	1✔
157	src_iface["offset"] = src_offset	1✔
158	msrc = dpm.as_usm_memory(Dummy(src_iface))	1✔
159	mdst = dpm.as_usm_memory(Dummy(dst_iface))	1✔
160	mdst.copy_from_device(msrc)	1✔
161
162
163	def copy_same_shape(dst, src):	1✔
164	if src.dtype == dst.dtype:	1!
165	copy_same_dtype(dst, src)	1✔
166
167	# check that memory regions do not overlap
168	if has_memory_overlap(dst, src):	1✔
169	tmp = copy_to_numpy(src)	1✔
170	tmp = tmp.astype(dst.dtype)	1✔
171	copy_from_numpy_into(dst, tmp)	1✔
172	return	1✔
173
174	# simplify strides
175	sh_i, dst_st, dst_disp, src_st, src_disp = contract_iter2(	1✔
176	dst.shape, dst.strides, src.strides
177	)
178	# sh_i, dst_st, dst_disp, src_st, src_disp = (
179	# dst.shape, dst.strides, 0, src.strides, 0
180	# )
181	src_iface = src.__sycl_usm_array_interface__	1✔
182	dst_iface = dst.__sycl_usm_array_interface__	1✔
183	src_iface["shape"] = tuple()	1✔
184	src_iface.pop("strides", None)	1✔
185	dst_iface["shape"] = tuple()	1✔
186	dst_iface.pop("strides", None)	1✔
187	dst_disp = dst_disp + dst_iface.get("offset", 0)	1✔
188	src_disp = src_disp + src_iface.get("offset", 0)	1✔
189	for i in range(dst.size):	1✔
190	mi = np.unravel_index(i, sh_i)	1✔
191	dst_offset = dst_disp	1✔
192	src_offset = src_disp	1✔
193	for j, dst_stj, src_stj in zip(mi, dst_st, src_st):	1✔
194	dst_offset = dst_offset + j * dst_stj	1✔
195	src_offset = src_offset + j * src_stj	1✔
196	dst_iface["offset"] = dst_offset	1✔
197	src_iface["offset"] = src_offset	1✔
198	msrc = dpm.as_usm_memory(Dummy(src_iface))	1✔
199	mdst = dpm.as_usm_memory(Dummy(dst_iface))	1✔
200	tmp = msrc.copy_to_host().view(src.dtype)	1✔
201	tmp = tmp.astype(dst.dtype)	1✔
202	mdst.copy_from_host(tmp.view("u1"))	1✔
203
204
205	def copy_from_usm_ndarray_to_usm_ndarray(dst, src):	1✔
206	if type(dst) is not dpt.usm_ndarray or type(src) is not dpt.usm_ndarray:	1!
NEW 207	raise TypeError	×
208
209	if dst.ndim == src.ndim and dst.shape == src.shape:	1!
210	copy_same_shape(dst, src)	1✔
211
212	try:	1✔
213	common_shape = np.broadcast_shapes(dst.shape, src.shape)	1✔
NEW 214	except ValueError:	×
NEW 215	raise ValueError	×
216
217	if dst.size < src.size:	1!
NEW 218	raise ValueError	×
219
220	if len(common_shape) > dst.ndim:	1!
NEW 221	ones_count = len(common_shape) - dst.ndim	×
NEW 222	for k in range(ones_count):	×
NEW 223	if common_shape[k] != 1:	×
NEW 224	raise ValueError	×
NEW 225	common_shape = common_shape[ones_count:]	×
226
227	if src.ndim < len(common_shape):	1!
NEW 228	new_src_strides = (0,) * (len(common_shape) - src.ndim) + src.strides	×
NEW 229	src_same_shape = dpt.usm_ndarray(	×
230	common_shape, dtype=src.dtype, buffer=src, strides=new_src_strides
231	)
232	else:
233	src_same_shape = src	1✔
234
235	copy_same_shape(dst, src_same_shape)	1✔
236
237
238	def astype(usm_ary, newdtype, order="K", casting="unsafe", copy=True):	1✔
239	"""
240	astype(usm_array, new_dtype, order="K", casting="unsafe", copy=True)
241
242	Returns a copy of the array, cast to a specified type.
243
244	A view can be returned, if possible, when `copy=False` is used.
245	"""
NEW 246	if not isinstance(usm_ary, dpt.usm_ndarray):	×
NEW 247	return TypeError(	×
248	"Expected object of type dpt.usm_ndarray, got {}".format(
249	type(usm_ary)
250	)
251	)
NEW 252	ary_dtype = usm_ary.dtype	×
NEW 253	target_dtype = np.dtype(newdtype)	×
NEW 254	if not np.can_cast(ary_dtype, target_dtype, casting=casting):	×
NEW 255	raise TypeError(	×
256	"Can not cast from {} to {} according to rule {}".format(
257	ary_dtype, newdtype, casting
258	)
259	)
NEW 260	c_contig = usm_ary.flags & 1	×
NEW 261	f_contig = usm_ary.flags & 2	×
NEW 262	needs_copy = copy or not (ary_dtype == target_dtype)	×
NEW 263	if not needs_copy and (order != "K"):	×
NEW 264	needs_copy = (c_contig and order not in ["A", "C"]) or (	×
265	f_contig and order not in ["A", "F"]
266	)
NEW 267	if needs_copy:	×
NEW 268	copy_order = "C"	×
NEW 269	if order == "C":	×
NEW 270	pass	×
NEW 271	elif order == "F":	×
NEW 272	copy_order = order	×
NEW 273	elif order == "A":	×
NEW 274	if usm_ary.flags & 2:	×
NEW 275	copy_order = "F"	×
NEW 276	elif order == "K":	×
NEW 277	if usm_ary.flags & 2:	×
NEW 278	copy_order = "F"	×
NEW 279	R = dpt.usm_ndarray(	×
280	usm_ary.shape,
281	dtype=target_dtype,
282	buffer=usm_ary.usm_type,
283	order=copy_order,
284	buffer_ctor_kwargs={"queue": usm_ary.sycl_queue},
285	)
NEW 286	if order == "K" and (not c_contig and not f_contig):	×
NEW 287	original_strides = usm_ary.strides	×
NEW 288	ind = sorted(	×
289	range(usm_ary.ndim),
290	key=lambda i: abs(original_strides[i]),
291	reverse=True,
292	)
NEW 293	new_strides = tuple(R.strides[ind[i]] for i in ind)	×
NEW 294	R = dpt.usm_ndarray(	×
295	usm_ary.shape,
296	dtype=target_dtype,
297	buffer=R.usm_data,
298	strides=new_strides,
299	)
NEW 300	copy_from_usm_ndarray_to_usm_ndarray(R, usm_ary)	×
NEW 301	return R	×
302	else:
NEW 303	return usm_ary	×

IntelPython / dpctl / 1263677918

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