5272120760

# cython: language_level=3
# cython: linetrace=True
# -*- coding: utf-8 -*-
# *****************************************************************************
# Copyright (c) 2016-2023, Intel Corporation
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# - Redistributions of source code must retain the above copyright notice,
#   this list of conditions and the following disclaimer.
# - Redistributions in binary form must reproduce the above copyright notice,
#   this list of conditions and the following disclaimer in the documentation
#   and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
# THE POSSIBILITY OF SUCH DAMAGE.
# *****************************************************************************

"""Module Backend (linear algebra routines)

This module contains interface functions between C backend layer
and the rest of the library

"""

# NO IMPORTs here. All imports must be placed into main "dpnp_algo.pyx" file

__all__ += [
    "dpnp_dot",
    "dpnp_inner",
    "dpnp_kron",
    "dpnp_matmul",
    "dpnp_outer"
]


# C function pointer to the C library template functions
ctypedef c_dpctl.DPCTLSyclEventRef(*fptr_2in_1out_shapes_t)(c_dpctl.DPCTLSyclQueueRef,
                                                            void *, void * , void * , shape_elem_type * ,
                                                            shape_elem_type *, shape_elem_type * , size_t,
                                                            const c_dpctl.DPCTLEventVectorRef)
ctypedef c_dpctl.DPCTLSyclEventRef(*fptr_2in_1out_dot_t)(c_dpctl.DPCTLSyclQueueRef,
                                                         void * , const size_t, const size_t,
                                                         const shape_elem_type *, const shape_elem_type * ,
                                                         void * , const size_t, const size_t,
                                                         const shape_elem_type *, const shape_elem_type * ,
                                                         void * , const size_t, const size_t,
                                                         const shape_elem_type *, const shape_elem_type * ,
                                                         const c_dpctl.DPCTLEventVectorRef)
ctypedef c_dpctl.DPCTLSyclEventRef(*fptr_2in_1out_matmul_t)(c_dpctl.DPCTLSyclQueueRef,
                                                            void * , const size_t, const size_t,
                                                            const shape_elem_type *, const shape_elem_type * ,
                                                            void * , const size_t, const size_t,
                                                            const shape_elem_type *, const shape_elem_type * ,
                                                            void * , const size_t, const size_t,
                                                            const shape_elem_type *, const shape_elem_type * ,
                                                            const c_dpctl.DPCTLEventVectorRef)

cpdef utils.dpnp_descriptor dpnp_dot(utils.dpnp_descriptor in_array1,
                                     utils.dpnp_descriptor in_array2,
                                     utils.dpnp_descriptor out=None):
    cdef shape_type_c shape1, shape2

    shape1 = in_array1.shape
    shape2 = in_array2.shape

    # convert string type names (array.dtype) to C enum DPNPFuncType
    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(in_array1.dtype)
    cdef DPNPFuncType param2_type = dpnp_dtype_to_DPNPFuncType(in_array2.dtype)

    # get the FPTR data structure
    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_DOT_EXT, param1_type, param2_type)
    cdef utils.dpnp_descriptor result

    ndim1 = in_array1.ndim
    ndim2 = in_array2.ndim
    cdef shape_type_c result_shape
    if ndim1 == 0:
        result_shape = shape2
    elif ndim2 == 0:
        result_shape = shape1
    elif ndim1 == 1 and ndim2 == 1:
        result_shape = ()
    elif ndim1 == 1:  # ndim2 > 1
        result_shape = shape2[::-2] if ndim2 == 2 else shape2[::2]
    elif ndim2 == 1:  # ndim1 > 1
        result_shape = shape1[:-1]
    else:
        if ndim1 == 1:
            shape1 = (1, shape1[0])
        if ndim2 == 1:
            shape2 = (shape1[0], 1)
        result_shape = shape1[:-1] + shape2[:-2] + shape2[-1:]

    result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(in_array1, in_array2)

    if out is None:
        # create result array with type given by FPTR data
        result = utils.create_output_descriptor(result_shape,
                                                kernel_data.return_type,
                                                None,
                                                device=result_sycl_device,
                                                usm_type=result_usm_type,
                                                sycl_queue=result_sycl_queue)
    else:
        result_type = dpnp_DPNPFuncType_to_dtype(< size_t > kernel_data.return_type)
        if out.dtype != result_type:
            utils.checker_throw_value_error('dot', 'out.dtype', out.dtype, result_type)
        if out.shape != result_shape:
            utils.checker_throw_value_error('dot', 'out.shape', out.shape, result_shape)

        result = out

        utils.get_common_usm_allocation(in_array1, result)  # check USM allocation is common

    cdef shape_type_c result_strides = utils.strides_to_vector(result.strides, result.shape)
    cdef shape_type_c in_array1_shape = in_array1.shape
    cdef shape_type_c in_array1_strides = utils.strides_to_vector(in_array1.strides, in_array1.shape)
    cdef shape_type_c in_array2_shape = in_array2.shape
    cdef shape_type_c in_array2_strides = utils.strides_to_vector(in_array2.strides, in_array2.shape)

    cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue
    cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()

    cdef fptr_2in_1out_dot_t func = <fptr_2in_1out_dot_t > kernel_data.ptr
    # call FPTR function
    cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,
                                                    result.get_data(),
                                                    result.size,
                                                    result.ndim,
                                                    result_shape.data(),
                                                    result_strides.data(),
                                                    in_array1.get_data(),
                                                    in_array1.size,
                                                    in_array1.ndim,
                                                    in_array1_shape.data(),
                                                    in_array1_strides.data(),
                                                    in_array2.get_data(),
                                                    in_array2.size,
                                                    in_array2.ndim,
                                                    in_array2_shape.data(),
                                                    in_array2_strides.data(),
                                                    NULL)  # dep_events_ref

    with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)
    c_dpctl.DPCTLEvent_Delete(event_ref)

    return result


cpdef utils.dpnp_descriptor dpnp_inner(dpnp_descriptor array1, dpnp_descriptor array2):
    result_type = numpy.promote_types(array1.dtype, array1.dtype)

    assert(len(array1.shape) == len(array2.shape))

    cdef shape_type_c array1_no_last_axes = array1.shape[:-1]
    cdef shape_type_c array2_no_last_axes = array2.shape[:-1]

    cdef shape_type_c result_shape = array1_no_last_axes
    result_shape.insert(result_shape.end(), array2_no_last_axes.begin(), array2_no_last_axes.end())

    result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(array1, array2)

    # ceate result array with type given by FPTR data
    cdef utils.dpnp_descriptor result = utils_py.create_output_descriptor_py(result_shape,
                                                                             result_type,
                                                                             None,
                                                                             device=result_sycl_device,
                                                                             usm_type=result_usm_type,
                                                                             sycl_queue=result_sycl_queue)

    # calculate input arrays offsets
    cdef shape_type_c array1_offsets = [1] * len(array1.shape)
    cdef shape_type_c array2_offsets = [1] * len(array2.shape)
    cdef size_t acc1 = 1
    cdef size_t acc2 = 1
    for axis in range(len(array1.shape) - 1, -1, -1):
        array1_offsets[axis] = acc1
        array2_offsets[axis] = acc2
        acc1 *= array1.shape[axis]
        acc2 *= array2.shape[axis]

    cdef shape_type_c result_shape_offsets = [1] * len(result.shape)
    acc = 1
    for i in range(len(result.shape) - 1, -1, -1):
        result_shape_offsets[i] = acc
        acc *= result.shape[i]

    cdef shape_type_c xyz
    cdef size_t array1_lin_index_base
    cdef size_t array2_lin_index_base
    cdef size_t axis2
    cdef long remainder
    cdef long quotient

    result_flatiter = result.get_pyobj().flat
    array1_flatiter = array1.get_pyobj().flat
    array2_flatiter = array2.get_pyobj().flat

    for idx1 in range(result.size):
        # reconstruct x,y,z from linear index
        xyz.clear()
        remainder = idx1
        for i in result_shape_offsets:
            quotient, remainder = divmod(remainder, i)
            xyz.push_back(quotient)

        # calculate linear base input index
        array1_lin_index_base = 0
        array2_lin_index_base = 0
        for axis in range(len(array1_offsets) - 1):
            axis2 = axis + (len(xyz) / 2)
            array1_lin_index_base += array1_offsets[axis] * xyz[axis]
            array2_lin_index_base += array2_offsets[axis] * xyz[axis2]

        # do inner product
        result_flatiter[idx1] = 0
        for idx2 in range(array1.shape[-1]):
            result_flatiter[idx1] += array1_flatiter[array1_lin_index_base + idx2] * \
                array2_flatiter[array2_lin_index_base + idx2]

    return result


cpdef utils.dpnp_descriptor dpnp_kron(dpnp_descriptor in_array1, dpnp_descriptor in_array2):
    cdef size_t ndim = max(in_array1.ndim, in_array2.ndim)

    cdef shape_type_c in_array1_shape
    if in_array1.ndim < ndim:
        for i in range(ndim - in_array1.ndim):
            in_array1_shape.push_back(1)
    for i in range(in_array1.ndim):
        in_array1_shape.push_back(in_array1.shape[i])

    cdef shape_type_c in_array2_shape
    if in_array2.ndim < ndim:
        for i in range(ndim - in_array2.ndim):
            in_array2_shape.push_back(1)
    for i in range(in_array2.ndim):
        in_array2_shape.push_back(in_array2.shape[i])

    cdef shape_type_c result_shape
    for i in range(ndim):
        result_shape.push_back(in_array1_shape[i] * in_array2_shape[i])

    # convert string type names (array.dtype) to C enum DPNPFuncType
    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(in_array1.dtype)
    cdef DPNPFuncType param2_type = dpnp_dtype_to_DPNPFuncType(in_array2.dtype)

    # get the FPTR data structure
    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_KRON_EXT, param1_type, param2_type)

    result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(in_array1, in_array2)

    # ceate result array with type given by FPTR data
    cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,
                                                                       kernel_data.return_type,
                                                                       None,
                                                                       device=result_sycl_device,
                                                                       usm_type=result_usm_type,
                                                                       sycl_queue=result_sycl_queue)

    cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue
    cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()

    cdef fptr_2in_1out_shapes_t func = <fptr_2in_1out_shapes_t > kernel_data.ptr
    # call FPTR function
    cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,
                                                    in_array1.get_data(),
                                                    in_array2.get_data(),
                                                    result.get_data(),
                                                    in_array1_shape.data(),
                                                    in_array2_shape.data(),
                                                    result_shape.data(),
                                                    ndim,
                                                    NULL)  # dep_events_ref

    with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)
    c_dpctl.DPCTLEvent_Delete(event_ref)

    return result


cpdef utils.dpnp_descriptor dpnp_matmul(utils.dpnp_descriptor in_array1, utils.dpnp_descriptor in_array2, utils.dpnp_descriptor out=None):

    cdef shape_type_c shape_result

    cdef shape_type_c shape1 = in_array1.shape
    cdef shape_type_c shape2 = in_array2.shape

    cdef size_t size_m = 0
    cdef size_t size_n = 0
    cdef size_t size_k = 0

    # Calling this function on an empty container causes undefined behavior.
    if not shape1.empty():
        size_m = shape1.front()
    if not shape2.empty():
        size_n = shape2.back()
    if not shape1.empty():
        size_k = shape1.back()

    cdef size_t ndim_max = max(in_array1.ndim, in_array2.ndim)

    if in_array1.ndim < ndim_max or ndim_max == 1:
        """
        shape1(2,), shape2(2,4)
        test: pytest tests/test_matmul.py::test_matmul[shape_pair4-types0] -v -s
        or
        shape1(2,), shape2(2,)
        test: pytest tests/test_matmul.py::test_matmul[shape_pair8-types0] -v -s
        """
        size_m = 1

    if in_array2.ndim < ndim_max or ndim_max == 1:
        """
        shape1(5,2), shape2(2,)
        test: pytest tests/test_matmul.py::test_matmul[shape_pair6-types0] -v -s
        or
        shape1(3,), shape2(3,)
        test: pytest tests/test_matmul.py::test_matmul[shape_pair8-types0] -v -s
        """
        size_n = 1

    shape_result = shape1[:-1] + shape2[-1:]

    # convert string type names (array.dtype) to C enum DPNPFuncType
    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(in_array1.dtype)
    cdef DPNPFuncType param2_type = dpnp_dtype_to_DPNPFuncType(in_array2.dtype)

    # get the FPTR data structure
    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_MATMUL_EXT, param1_type, param2_type)

    # ceate result array with type given by FPTR data
    result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(in_array1, in_array2)
    cdef utils.dpnp_descriptor result = utils.create_output_descriptor(shape_result,
                                                                       kernel_data.return_type,
                                                                       out,
                                                                       device=result_sycl_device,
                                                                       usm_type=result_usm_type,
                                                                       sycl_queue=result_sycl_queue)
    if result.size == 0:
        return result

    cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue
    cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()

    cdef fptr_2in_1out_matmul_t func = <fptr_2in_1out_matmul_t > kernel_data.ptr
    # call FPTR function
    cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,
                                                    result.get_data(),
                                                    result.size,
                                                    result.ndim,
                                                    NULL,  # result_shape
                                                    NULL,  # result_strides
                                                    in_array1.get_data(),
                                                    in_array1.size,
                                                    in_array1.ndim,
                                                    shape1.data(),
                                                    NULL,  # in_array1_strides
                                                    in_array2.get_data(),
                                                    in_array2.size,
                                                    in_array2.ndim,
                                                    shape2.data(),
                                                    NULL,  # in_array2_strides
                                                    NULL)  # dep_event_vec_ref
    with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)
    c_dpctl.DPCTLEvent_Delete(event_ref)

    return result


cpdef utils.dpnp_descriptor dpnp_outer(utils.dpnp_descriptor array1, utils.dpnp_descriptor array2):
    cdef shape_type_c result_shape = (array1.size, array2.size)
    result_type = numpy.promote_types(array1.dtype, array1.dtype)

    result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(array1, array2)

    cdef utils.dpnp_descriptor result = utils_py.create_output_descriptor_py(result_shape,
                                                                             result_type,
                                                                             None,
                                                                             device=result_sycl_device,
                                                                             usm_type=result_usm_type,
                                                                             sycl_queue=result_sycl_queue)

    result_flatiter = result.get_pyobj().flat
    array1_flatiter = array1.get_pyobj().flat
    array2_flatiter = array2.get_pyobj().flat

    for idx1 in range(array1.size):
        for idx2 in range(array2.size):
            result_flatiter[idx1 * array2.size + idx2] = array1_flatiter[idx1] * array2_flatiter[idx2]

    return result

1	# cython: language_level=3
2	# cython: linetrace=True
3	# -- coding: utf-8 --
4	# *****************************************************************************
5	# Copyright (c) 2016-2023, Intel Corporation
6	# All rights reserved.
7	#
8	# Redistribution and use in source and binary forms, with or without
9	# modification, are permitted provided that the following conditions are met:
10	# - Redistributions of source code must retain the above copyright notice,
11	# this list of conditions and the following disclaimer.
12	# - Redistributions in binary form must reproduce the above copyright notice,
13	# this list of conditions and the following disclaimer in the documentation
14	# and/or other materials provided with the distribution.
15	#
16	# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17	# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18	# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19	# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20	# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21	# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22	# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23	# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24	# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25	# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
26	# THE POSSIBILITY OF SUCH DAMAGE.
27	# *****************************************************************************
28
29	"""Module Backend (linear algebra routines)
30
31	This module contains interface functions between C backend layer
32	and the rest of the library
33
34	"""
35
36	# NO IMPORTs here. All imports must be placed into main "dpnp_algo.pyx" file
37
38	__all__ += [	×
39	"dpnp_dot",
40	"dpnp_inner",
41	"dpnp_kron",
42	"dpnp_matmul",
43	"dpnp_outer"
44	]
45
46
47	# C function pointer to the C library template functions
48	ctypedef c_dpctl.DPCTLSyclEventRef(*fptr_2in_1out_shapes_t)(c_dpctl.DPCTLSyclQueueRef,
49	void , void , void * , shape_elem_type * ,
50	shape_elem_type , shape_elem_type , size_t,
51	const c_dpctl.DPCTLEventVectorRef)
52	ctypedef c_dpctl.DPCTLSyclEventRef(*fptr_2in_1out_dot_t)(c_dpctl.DPCTLSyclQueueRef,
53	void * , const size_t, const size_t,
54	const shape_elem_type , const shape_elem_type ,
55	void * , const size_t, const size_t,
56	const shape_elem_type , const shape_elem_type ,
57	void * , const size_t, const size_t,
58	const shape_elem_type , const shape_elem_type ,
59	const c_dpctl.DPCTLEventVectorRef)
60	ctypedef c_dpctl.DPCTLSyclEventRef(*fptr_2in_1out_matmul_t)(c_dpctl.DPCTLSyclQueueRef,
61	void * , const size_t, const size_t,
62	const shape_elem_type , const shape_elem_type ,
63	void * , const size_t, const size_t,
64	const shape_elem_type , const shape_elem_type ,
65	void * , const size_t, const size_t,
66	const shape_elem_type , const shape_elem_type ,
67	const c_dpctl.DPCTLEventVectorRef)
68
UNCOV 69	cpdef utils.dpnp_descriptor dpnp_dot(utils.dpnp_descriptor in_array1,	×
70	utils.dpnp_descriptor in_array2,
71	utils.dpnp_descriptor out=None):
72	cdef shape_type_c shape1, shape2
73
74	shape1 = in_array1.shape	1✔
75	shape2 = in_array2.shape	1✔
76
77	# convert string type names (array.dtype) to C enum DPNPFuncType
78	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(in_array1.dtype)	1✔
79	cdef DPNPFuncType param2_type = dpnp_dtype_to_DPNPFuncType(in_array2.dtype)	1✔
80
81	# get the FPTR data structure
82	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_DOT_EXT, param1_type, param2_type)	1✔
83	cdef utils.dpnp_descriptor result
84
85	ndim1 = in_array1.ndim	1✔
86	ndim2 = in_array2.ndim	1✔
87	cdef shape_type_c result_shape
88	if ndim1 == 0:	1✔
89	result_shape = shape2	1✔
90	elif ndim2 == 0:	1✔
91	result_shape = shape1	1✔
92	elif ndim1 == 1 and ndim2 == 1:	1✔
93	result_shape = ()	1✔
94	elif ndim1 == 1: # ndim2 > 1	1✔
95	result_shape = shape2[::-2] if ndim2 == 2 else shape2[::2]	1✔
96	elif ndim2 == 1: # ndim1 > 1	1✔
97	result_shape = shape1[:-1]	1✔
98	else:
99	if ndim1 == 1:	1✔
UNCOV 100	shape1 = (1, shape1[0])	×
101	if ndim2 == 1:	1✔
UNCOV 102	shape2 = (shape1[0], 1)	×
103	result_shape = shape1[:-1] + shape2[:-2] + shape2[-1:]	1✔
104
105	result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(in_array1, in_array2)	1✔
106
107	if out is None:	1✔
108	# create result array with type given by FPTR data
109	result = utils.create_output_descriptor(result_shape,	1✔
110	kernel_data.return_type,
111	None,
112	device=result_sycl_device,
113	usm_type=result_usm_type,
114	sycl_queue=result_sycl_queue)
115	else:
116	result_type = dpnp_DPNPFuncType_to_dtype(< size_t > kernel_data.return_type)	1✔
117	if out.dtype != result_type:	1✔
118	utils.checker_throw_value_error('dot', 'out.dtype', out.dtype, result_type)	1✔
119	if out.shape != result_shape:	1✔
120	utils.checker_throw_value_error('dot', 'out.shape', out.shape, result_shape)	1✔
121
122	result = out	1✔
123
124	utils.get_common_usm_allocation(in_array1, result) # check USM allocation is common	1✔
125
126	cdef shape_type_c result_strides = utils.strides_to_vector(result.strides, result.shape)	1✔
127	cdef shape_type_c in_array1_shape = in_array1.shape	1✔
128	cdef shape_type_c in_array1_strides = utils.strides_to_vector(in_array1.strides, in_array1.shape)	1✔
129	cdef shape_type_c in_array2_shape = in_array2.shape	1✔
130	cdef shape_type_c in_array2_strides = utils.strides_to_vector(in_array2.strides, in_array2.shape)	1✔
131
132	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
133	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
134
135	cdef fptr_2in_1out_dot_t func = <fptr_2in_1out_dot_t > kernel_data.ptr	1✔
136	# call FPTR function
137	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
138	result.get_data(),
139	result.size,	1✔
140	result.ndim,	1✔
141	result_shape.data(),
142	result_strides.data(),
143	in_array1.get_data(),
144	in_array1.size,	1✔
145	in_array1.ndim,	1✔
146	in_array1_shape.data(),
147	in_array1_strides.data(),
148	in_array2.get_data(),
149	in_array2.size,	1✔
150	in_array2.ndim,	1✔
151	in_array2_shape.data(),
152	in_array2_strides.data(),
153	NULL) # dep_events_ref
154
155	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
156	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
157
158	return result	1✔
159
160
UNCOV 161	cpdef utils.dpnp_descriptor dpnp_inner(dpnp_descriptor array1, dpnp_descriptor array2):	×
162	result_type = numpy.promote_types(array1.dtype, array1.dtype)	1✔
163
164	assert(len(array1.shape) == len(array2.shape))	1✔
165
166	cdef shape_type_c array1_no_last_axes = array1.shape[:-1]	1✔
167	cdef shape_type_c array2_no_last_axes = array2.shape[:-1]	1✔
168
169	cdef shape_type_c result_shape = array1_no_last_axes	1✔
170	result_shape.insert(result_shape.end(), array2_no_last_axes.begin(), array2_no_last_axes.end())	1✔
171
172	result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(array1, array2)	1✔
173
174	# ceate result array with type given by FPTR data
175	cdef utils.dpnp_descriptor result = utils_py.create_output_descriptor_py(result_shape,	1✔
176	result_type,
177	None,	1✔
178	device=result_sycl_device,	1✔
179	usm_type=result_usm_type,	1✔
180	sycl_queue=result_sycl_queue)	1✔
181
182	# calculate input arrays offsets
183	cdef shape_type_c array1_offsets = [1] * len(array1.shape)	1✔
184	cdef shape_type_c array2_offsets = [1] * len(array2.shape)	1✔
185	cdef size_t acc1 = 1	1✔
186	cdef size_t acc2 = 1	1✔
187	for axis in range(len(array1.shape) - 1, -1, -1):	1✔
188	array1_offsets[axis] = acc1	1✔
189	array2_offsets[axis] = acc2	1✔
190	acc1 *= array1.shape[axis]	1✔
191	acc2 *= array2.shape[axis]	1✔
192
193	cdef shape_type_c result_shape_offsets = [1] * len(result.shape)	1✔
194	acc = 1	1✔
195	for i in range(len(result.shape) - 1, -1, -1):	1✔
196	result_shape_offsets[i] = acc	1✔
197	acc *= result.shape[i]	1✔
198
199	cdef shape_type_c xyz
200	cdef size_t array1_lin_index_base
201	cdef size_t array2_lin_index_base
202	cdef size_t axis2
203	cdef long remainder
204	cdef long quotient
205
206	result_flatiter = result.get_pyobj().flat	1✔
207	array1_flatiter = array1.get_pyobj().flat	1✔
208	array2_flatiter = array2.get_pyobj().flat	1✔
209
210	for idx1 in range(result.size):	1✔
211	# reconstruct x,y,z from linear index
212	xyz.clear()	1✔
213	remainder = idx1	1✔
214	for i in result_shape_offsets:	1✔
215	quotient, remainder = divmod(remainder, i)	1✔
216	xyz.push_back(quotient)	1✔
217
218	# calculate linear base input index
219	array1_lin_index_base = 0	1✔
220	array2_lin_index_base = 0	1✔
221	for axis in range(len(array1_offsets) - 1):	1✔
222	axis2 = axis + (len(xyz) / 2)	1✔
223	array1_lin_index_base += array1_offsets[axis] * xyz[axis]	1✔
224	array2_lin_index_base += array2_offsets[axis] * xyz[axis2]	1✔
225
226	# do inner product
227	result_flatiter[idx1] = 0	1✔
228	for idx2 in range(array1.shape[-1]):	1✔
229	result_flatiter[idx1] += array1_flatiter[array1_lin_index_base + idx2] * \	1✔
230	array2_flatiter[array2_lin_index_base + idx2]	1✔
231
232	return result	1✔
233
234
UNCOV 235	cpdef utils.dpnp_descriptor dpnp_kron(dpnp_descriptor in_array1, dpnp_descriptor in_array2):	×
236	cdef size_t ndim = max(in_array1.ndim, in_array2.ndim)	1✔
237
238	cdef shape_type_c in_array1_shape
239	if in_array1.ndim < ndim:	1✔
240	for i in range(ndim - in_array1.ndim):	1✔
241	in_array1_shape.push_back(1)	1✔
242	for i in range(in_array1.ndim):	1✔
243	in_array1_shape.push_back(in_array1.shape[i])	1✔
244
245	cdef shape_type_c in_array2_shape
246	if in_array2.ndim < ndim:	1✔
247	for i in range(ndim - in_array2.ndim):	×
UNCOV 248	in_array2_shape.push_back(1)	×
249	for i in range(in_array2.ndim):	1✔
250	in_array2_shape.push_back(in_array2.shape[i])	1✔
251
252	cdef shape_type_c result_shape
253	for i in range(ndim):	1✔
254	result_shape.push_back(in_array1_shape[i] * in_array2_shape[i])	1✔
255
256	# convert string type names (array.dtype) to C enum DPNPFuncType
257	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(in_array1.dtype)	1✔
258	cdef DPNPFuncType param2_type = dpnp_dtype_to_DPNPFuncType(in_array2.dtype)	1✔
259
260	# get the FPTR data structure
261	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_KRON_EXT, param1_type, param2_type)	1✔
262
263	result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(in_array1, in_array2)	1✔
264
265	# ceate result array with type given by FPTR data
266	cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,	1✔
267	kernel_data.return_type,
268	None,
269	device=result_sycl_device,
270	usm_type=result_usm_type,
271	sycl_queue=result_sycl_queue)
272
273	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
274	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
275
276	cdef fptr_2in_1out_shapes_t func = <fptr_2in_1out_shapes_t > kernel_data.ptr	1✔
277	# call FPTR function
278	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
279	in_array1.get_data(),
280	in_array2.get_data(),
281	result.get_data(),
282	in_array1_shape.data(),
283	in_array2_shape.data(),
284	result_shape.data(),
285	ndim,
286	NULL) # dep_events_ref
287
288	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
289	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
290
291	return result	1✔
292
293
UNCOV 294	cpdef utils.dpnp_descriptor dpnp_matmul(utils.dpnp_descriptor in_array1, utils.dpnp_descriptor in_array2, utils.dpnp_descriptor out=None):	×
295
296	cdef shape_type_c shape_result
297
298	cdef shape_type_c shape1 = in_array1.shape	1✔
299	cdef shape_type_c shape2 = in_array2.shape	1✔
300
301	cdef size_t size_m = 0	1✔
302	cdef size_t size_n = 0	1✔
303	cdef size_t size_k = 0	1✔
304
305	# Calling this function on an empty container causes undefined behavior.
306	if not shape1.empty():	1✔
307	size_m = shape1.front()	1✔
308	if not shape2.empty():	1✔
309	size_n = shape2.back()	1✔
310	if not shape1.empty():	1✔
311	size_k = shape1.back()	1✔
312
313	cdef size_t ndim_max = max(in_array1.ndim, in_array2.ndim)	1✔
314
315	if in_array1.ndim < ndim_max or ndim_max == 1:	1✔
316	"""
317	shape1(2,), shape2(2,4)
318	test: pytest tests/test_matmul.py::test_matmul[shape_pair4-types0] -v -s
319	or
320	shape1(2,), shape2(2,)
321	test: pytest tests/test_matmul.py::test_matmul[shape_pair8-types0] -v -s
322	"""
UNCOV 323	size_m = 1	×
324
325	if in_array2.ndim < ndim_max or ndim_max == 1:	1✔
326	"""
327	shape1(5,2), shape2(2,)
328	test: pytest tests/test_matmul.py::test_matmul[shape_pair6-types0] -v -s
329	or
330	shape1(3,), shape2(3,)
331	test: pytest tests/test_matmul.py::test_matmul[shape_pair8-types0] -v -s
332	"""
UNCOV 333	size_n = 1	×
334
335	shape_result = shape1[:-1] + shape2[-1:]	1✔
336
337	# convert string type names (array.dtype) to C enum DPNPFuncType
338	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(in_array1.dtype)	1✔
339	cdef DPNPFuncType param2_type = dpnp_dtype_to_DPNPFuncType(in_array2.dtype)	1✔
340
341	# get the FPTR data structure
342	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_MATMUL_EXT, param1_type, param2_type)	1✔
343
344	# ceate result array with type given by FPTR data
345	result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(in_array1, in_array2)	1✔
346	cdef utils.dpnp_descriptor result = utils.create_output_descriptor(shape_result,	1✔
347	kernel_data.return_type,
348	out,
349	device=result_sycl_device,
350	usm_type=result_usm_type,
351	sycl_queue=result_sycl_queue)
352	if result.size == 0:	1✔
UNCOV 353	return result	×
354
355	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
356	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
357
358	cdef fptr_2in_1out_matmul_t func = <fptr_2in_1out_matmul_t > kernel_data.ptr	1✔
359	# call FPTR function
360	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
361	result.get_data(),
362	result.size,	1✔
363	result.ndim,	1✔
364	NULL, # result_shape
365	NULL, # result_strides
366	in_array1.get_data(),
367	in_array1.size,	1✔
368	in_array1.ndim,	1✔
369	shape1.data(),
370	NULL, # in_array1_strides
371	in_array2.get_data(),
372	in_array2.size,	1✔
373	in_array2.ndim,	1✔
374	shape2.data(),
375	NULL, # in_array2_strides
376	NULL) # dep_event_vec_ref
377	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
378	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
379
380	return result	1✔
381
382
UNCOV 383	cpdef utils.dpnp_descriptor dpnp_outer(utils.dpnp_descriptor array1, utils.dpnp_descriptor array2):	×
UNCOV 384	cdef shape_type_c result_shape = (array1.size, array2.size)	×
UNCOV 385	result_type = numpy.promote_types(array1.dtype, array1.dtype)	×
386
UNCOV 387	result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(array1, array2)	×
388
UNCOV 389	cdef utils.dpnp_descriptor result = utils_py.create_output_descriptor_py(result_shape,	×
390	result_type,
UNCOV 391	None,	×
UNCOV 392	device=result_sycl_device,	×
UNCOV 393	usm_type=result_usm_type,	×
UNCOV 394	sycl_queue=result_sycl_queue)	×
395
UNCOV 396	result_flatiter = result.get_pyobj().flat	×
UNCOV 397	array1_flatiter = array1.get_pyobj().flat	×
UNCOV 398	array2_flatiter = array2.get_pyobj().flat	×
399
UNCOV 400	for idx1 in range(array1.size):	×
UNCOV 401	for idx2 in range(array2.size):	×
UNCOV 402	result_flatiter[idx1 * array2.size + idx2] = array1_flatiter[idx1] * array2_flatiter[idx2]	×
403
UNCOV 404	return result	×

IntelPython / dpnp / 5272120760

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