5490609761

# 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

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

"""

from libc.time cimport time, time_t
from libcpp.vector cimport vector

import dpctl

import dpnp
import dpnp.config as config
import dpnp.dpnp_container as dpnp_container
import dpnp.dpnp_utils as utils_py
from dpnp.dpnp_array import dpnp_array

cimport cpython
cimport numpy

cimport dpnp.dpnp_utils as utils

import operator

import numpy

__all__ = [
    "dpnp_astype",
    "dpnp_flatten",
    "dpnp_init_val",
    "dpnp_queue_initialize",
    "dpnp_queue_is_cpu"
]


include "dpnp_algo_arraycreation.pxi"
include "dpnp_algo_bitwise.pxi"
include "dpnp_algo_counting.pxi"
include "dpnp_algo_indexing.pxi"
include "dpnp_algo_linearalgebra.pxi"
include "dpnp_algo_logic.pxi"
include "dpnp_algo_manipulation.pxi"
include "dpnp_algo_mathematical.pxi"
include "dpnp_algo_searching.pxi"
include "dpnp_algo_sorting.pxi"
include "dpnp_algo_special.pxi"
include "dpnp_algo_statistics.pxi"
include "dpnp_algo_trigonometric.pxi"


ctypedef c_dpctl.DPCTLSyclEventRef(*fptr_dpnp_astype_t)(c_dpctl.DPCTLSyclQueueRef,
                                                        const void *, void * , const size_t,
                                                        const c_dpctl.DPCTLEventVectorRef)
ctypedef c_dpctl.DPCTLSyclEventRef(*fptr_dpnp_flatten_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 * ,
                                                         const long * ,
                                                         const c_dpctl.DPCTLEventVectorRef)
ctypedef c_dpctl.DPCTLSyclEventRef(*fptr_dpnp_initval_t)(c_dpctl.DPCTLSyclQueueRef,
                                                         void *, void * , size_t,
                                                         const c_dpctl.DPCTLEventVectorRef)


cpdef utils.dpnp_descriptor dpnp_astype(utils.dpnp_descriptor x1, dtype):
    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)
    cdef DPNPFuncType param2_type = dpnp_dtype_to_DPNPFuncType(dtype)

    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_ASTYPE_EXT, param1_type, param2_type)

    x1_obj = x1.get_array()

    # ceate result array with type given by FPTR data
    cdef shape_type_c result_shape = x1.shape
    cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,
                                                                       kernel_data.return_type,
                                                                       None,
                                                                       device=x1_obj.sycl_device,
                                                                       usm_type=x1_obj.usm_type,
                                                                       sycl_queue=x1_obj.sycl_queue)

    result_sycl_queue = result.get_array().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_dpnp_astype_t func = <fptr_dpnp_astype_t > kernel_data.ptr
    cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref, x1.get_data(), result.get_data(), x1.size, NULL)

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

    return result


cpdef utils.dpnp_descriptor dpnp_flatten(utils.dpnp_descriptor x1):
    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)

    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_FLATTEN_EXT, param1_type, param1_type)

    cdef shape_type_c x1_shape = x1.shape
    cdef shape_type_c x1_strides = utils.strides_to_vector(x1.strides, x1_shape)

    x1_obj = x1.get_array()

    # ceate result array with type given by FPTR data
    cdef shape_type_c result_shape = (x1.size,)
    cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,
                                                                       kernel_data.return_type,
                                                                       None,
                                                                       device=x1_obj.sycl_device,
                                                                       usm_type=x1_obj.usm_type,
                                                                       sycl_queue=x1_obj.sycl_queue)

    result_sycl_queue = result.get_array().sycl_queue

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

    cdef shape_type_c result_strides = utils.strides_to_vector(result.strides, result_shape)

    cdef fptr_dpnp_flatten_t func = <fptr_dpnp_flatten_t > kernel_data.ptr
    cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,
                                                    result.get_data(),
                                                    result.size,
                                                    result.ndim,
                                                    result_shape.data(),
                                                    result_strides.data(),
                                                    x1.get_data(),
                                                    x1.size,
                                                    x1.ndim,
                                                    x1_shape.data(),
                                                    x1_strides.data(),
                                                    NULL,
                                                    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_init_val(shape, dtype, value):
    """
    same as dpnp_full(). TODO remove code dumplication
    """
    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(dtype)

    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_INITVAL_EXT, param1_type, param1_type)

    cdef utils.dpnp_descriptor result = utils_py.create_output_descriptor_py(shape, dtype, None)

    result_obj = result.get_array()

    # TODO: find better way to pass single value with type conversion
    cdef utils.dpnp_descriptor val_arr = utils_py.create_output_descriptor_py((1, ),
                                                                              dtype,
                                                                              None,
                                                                              device=result_obj.sycl_device,
                                                                              usm_type=result_obj.usm_type,
                                                                              sycl_queue=result_obj.sycl_queue)
    val_arr.get_pyobj()[0] = value

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

    cdef fptr_dpnp_initval_t func = <fptr_dpnp_initval_t > kernel_data.ptr
    cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref, result.get_data(), val_arr.get_data(), result.size, NULL)

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

    return result


cpdef dpnp_queue_initialize():
    """
    Initialize SYCL queue which will be used for any library operations.
    It takes visible time and needs to be done in the module loading procedure.
    """
    cdef time_t seed_from_time
    cdef QueueOptions queue_type = CPU_SELECTOR

    if (config.__DPNP_QUEUE_GPU__):
        queue_type = GPU_SELECTOR

    dpnp_queue_initialize_c(queue_type)
    dpnp_python_constants_initialize_c(< void*> None,
                                        < void * > dpnp.nan)

    # TODO:
    # choose seed number as is in numpy
    seed_from_time = time(NULL)
    dpnp_rng_srand_c(seed_from_time)


cpdef dpnp_queue_is_cpu():
    """Return 1 if current queue is CPU. Return 0 otherwise.

    """
    return dpnp_queue_is_cpu_c()


"""
Internal functions
"""
cdef DPNPFuncType dpnp_dtype_to_DPNPFuncType(dtype):
    dt_c = dpnp.dtype(dtype).char
    kind = dpnp.dtype(dtype).kind
    if isinstance(kind, int):
        kind = chr(kind)
    itemsize = dpnp.dtype(dtype).itemsize

    if dt_c == 'd':
        return DPNP_FT_DOUBLE
    elif dt_c == 'f':
        return DPNP_FT_FLOAT
    elif kind == 'i':
        if itemsize == 8:
            return DPNP_FT_LONG
        elif itemsize == 4:
            return DPNP_FT_INT
        else:
            utils.checker_throw_type_error("dpnp_dtype_to_DPNPFuncType", dtype)
    elif dt_c == 'F':
        return DPNP_FT_CMPLX64
    elif dt_c == 'D':
        return DPNP_FT_CMPLX128
    elif dt_c == '?':
        return DPNP_FT_BOOL
    else:
        utils.checker_throw_type_error("dpnp_dtype_to_DPNPFuncType", dtype)


cdef dpnp_DPNPFuncType_to_dtype(size_t type):
    """
    Type 'size_t' used instead 'DPNPFuncType' because Cython has lack of Enum support (0.29)
    TODO needs to use DPNPFuncType here
    """
    if type == <size_t > DPNP_FT_DOUBLE:
        return dpnp.float64
    elif type == <size_t > DPNP_FT_FLOAT:
        return dpnp.float32
    elif type == <size_t > DPNP_FT_LONG:
        return dpnp.int64
    elif type == <size_t > DPNP_FT_INT:
        return dpnp.int32
    elif type == <size_t > DPNP_FT_CMPLX64:
        return dpnp.complex64
    elif type == <size_t > DPNP_FT_CMPLX128:
        return dpnp.complex128
    elif type == <size_t > DPNP_FT_BOOL:
        return dpnp.bool
    else:
        utils.checker_throw_type_error("dpnp_DPNPFuncType_to_dtype", type)


cdef utils.dpnp_descriptor call_fptr_1in_1out(DPNPFuncName fptr_name,
                                              utils.dpnp_descriptor x1,
                                              shape_type_c result_shape,
                                              utils.dpnp_descriptor out=None,
                                              func_name=None):

    """ Convert type (x1.dtype) to C enum DPNPFuncType """
    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)

    """ get the FPTR data structure """
    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(fptr_name, param1_type, param1_type)

    result_type = dpnp_DPNPFuncType_to_dtype( < size_t > kernel_data.return_type)

    cdef utils.dpnp_descriptor result

    if out is None:
        """ Create result array with type given by FPTR data """
        x1_obj = x1.get_array()
        result = utils.create_output_descriptor(result_shape,
                                                kernel_data.return_type,
                                                None,
                                                device=x1_obj.sycl_device,
                                                usm_type=x1_obj.usm_type,
                                                sycl_queue=x1_obj.sycl_queue)
    else:
        if out.dtype != result_type:
            utils.checker_throw_value_error(func_name, 'out.dtype', out.dtype, result_type)
        if out.shape != result_shape:
            utils.checker_throw_value_error(func_name, 'out.shape', out.shape, result_shape)

        result = out

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

    result_sycl_queue = result.get_array().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_1in_1out_t func = <fptr_1in_1out_t > kernel_data.ptr

    cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref, x1.get_data(), result.get_data(), x1.size, NULL)

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

    return result


cdef utils.dpnp_descriptor call_fptr_1in_1out_strides(DPNPFuncName fptr_name,
                                                      utils.dpnp_descriptor x1,
                                                      object dtype=None,
                                                      utils.dpnp_descriptor out=None,
                                                      object where=True,
                                                      func_name=None):

    """ Convert type (x1.dtype) to C enum DPNPFuncType """
    cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)

    """ get the FPTR data structure """
    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(fptr_name, param1_type, param1_type)

    result_type = dpnp_DPNPFuncType_to_dtype( < size_t > kernel_data.return_type)

    cdef shape_type_c x1_shape = x1.shape
    cdef shape_type_c x1_strides = utils.strides_to_vector(x1.strides, x1_shape)

    cdef shape_type_c result_shape = x1_shape
    cdef utils.dpnp_descriptor result

    if out is None:
        """ Create result array with type given by FPTR data """
        x1_obj = x1.get_array()
        result = utils.create_output_descriptor(result_shape,
                                                kernel_data.return_type,
                                                None,
                                                device=x1_obj.sycl_device,
                                                usm_type=x1_obj.usm_type,
                                                sycl_queue=x1_obj.sycl_queue)
    else:
        if out.dtype != result_type:
            utils.checker_throw_value_error(func_name, 'out.dtype', out.dtype, result_type)
        if out.shape != result_shape:
            utils.checker_throw_value_error(func_name, 'out.shape', out.shape, result_shape)

        result = out

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

    result_sycl_queue = result.get_array().sycl_queue

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

    cdef shape_type_c result_strides = utils.strides_to_vector(result.strides, result_shape)

    """ Call FPTR function """
    cdef fptr_1in_1out_strides_t func = <fptr_1in_1out_strides_t > kernel_data.ptr
    cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,
                                                    result.get_data(),
                                                    result.size,
                                                    result.ndim,
                                                    result_shape.data(),
                                                    result_strides.data(),
                                                    x1.get_data(),
                                                    x1.size,
                                                    x1.ndim,
                                                    x1_shape.data(),
                                                    x1_strides.data(),
                                                    NULL,
                                                    NULL)  # dep_events_ref

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

    return result


cdef utils.dpnp_descriptor call_fptr_2in_1out(DPNPFuncName fptr_name,
                                              utils.dpnp_descriptor x1_obj,
                                              utils.dpnp_descriptor x2_obj,
                                              object dtype=None,
                                              utils.dpnp_descriptor out=None,
                                              object where=True,
                                              func_name=None):

    # Convert type (x1_obj.dtype) to C enum DPNPFuncType
    cdef DPNPFuncType x1_c_type = dpnp_dtype_to_DPNPFuncType(x1_obj.dtype)
    cdef DPNPFuncType x2_c_type = dpnp_dtype_to_DPNPFuncType(x2_obj.dtype)

    # get the FPTR data structure
    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(fptr_name, x1_c_type, x2_c_type)

    result_type = dpnp_DPNPFuncType_to_dtype( < size_t > kernel_data.return_type)

    # Create result array
    cdef shape_type_c x1_shape = x1_obj.shape
    cdef shape_type_c x2_shape = x2_obj.shape
    cdef shape_type_c result_shape = utils.get_common_shape(x1_shape, x2_shape)
    cdef utils.dpnp_descriptor result

    result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(x1_obj, x2_obj)

    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:
        if out.dtype != result_type:
            utils.checker_throw_value_error(func_name, 'out.dtype', out.dtype, result_type)
        if out.shape != result_shape:
            utils.checker_throw_value_error(func_name, 'out.shape', out.shape, result_shape)

        result = out

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

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

    """ Call FPTR function """
    cdef fptr_2in_1out_t func = <fptr_2in_1out_t > kernel_data.ptr
    cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,
                                                    result.get_data(),
                                                    x1_obj.get_data(),
                                                    x1_obj.size,
                                                    x1_shape.data(),
                                                    x1_shape.size(),
                                                    x2_obj.get_data(),
                                                    x2_obj.size,
                                                    x2_shape.data(),
                                                    x2_shape.size(),
                                                    NULL,
                                                    NULL)  # dep_events_ref)

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

    return result

cdef utils.dpnp_descriptor call_fptr_2in_1out_strides(DPNPFuncName fptr_name,
                                                      utils.dpnp_descriptor x1_obj,
                                                      utils.dpnp_descriptor x2_obj,
                                                      object dtype=None,
                                                      utils.dpnp_descriptor out=None,
                                                      object where=True,
                                                      func_name=None):

    # Convert type (x1_obj.dtype) to C enum DPNPFuncType
    cdef DPNPFuncType x1_c_type = dpnp_dtype_to_DPNPFuncType(x1_obj.dtype)
    cdef DPNPFuncType x2_c_type = dpnp_dtype_to_DPNPFuncType(x2_obj.dtype)

    # get the FPTR data structure
    cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(fptr_name, x1_c_type, x2_c_type)

    # Create result array
    cdef shape_type_c x1_shape = x1_obj.shape

    cdef shape_type_c x1_strides = utils.strides_to_vector(x1_obj.strides, x1_shape)
    cdef shape_type_c x2_shape = x2_obj.shape
    cdef shape_type_c x2_strides = utils.strides_to_vector(x2_obj.strides, x2_shape)

    cdef shape_type_c result_shape = utils.get_common_shape(x1_shape, x2_shape)
    cdef utils.dpnp_descriptor result

    result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(x1_obj, x2_obj)

    # get FPTR function and return type
    cdef fptr_2in_1out_strides_t func = < fptr_2in_1out_strides_t > kernel_data.ptr
    cdef DPNPFuncType return_type = kernel_data.return_type

    # check 'out' parameter data
    if out is not None:
        if out.shape != result_shape:
            utils.checker_throw_value_error(func_name, 'out.shape', out.shape, result_shape)

        utils.get_common_usm_allocation(x1_obj, out)  # check USM allocation is common

    if out is None or out.is_array_overlapped(x1_obj) or out.is_array_overlapped(x2_obj) or not out.match_ctype(return_type):
        """
        Create result array with type given by FPTR data.
        If 'out' array has another dtype than expected or overlaps a memory from any input array,
        we have to create a temporary array and to copy data from the temporary into 'out' array,
        once the computation is completed.
        Otherwise simultaneously access to the same memory may cause a race condition issue
        which will result into undefined behaviour.
        """
        is_result_memory_allocated = True
        result = utils.create_output_descriptor(result_shape,
                                                return_type,
                                                None,
                                                device=result_sycl_device,
                                                usm_type=result_usm_type,
                                                sycl_queue=result_sycl_queue)
    else:
        is_result_memory_allocated = False
        result = out

    cdef shape_type_c result_strides = utils.strides_to_vector(result.strides, result_shape)

    result_obj = result.get_array()

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

    """ 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(),
                                                    x1_obj.get_data(),
                                                    x1_obj.size,
                                                    x1_obj.ndim,
                                                    x1_shape.data(),
                                                    x1_strides.data(),
                                                    x2_obj.get_data(),
                                                    x2_obj.size,
                                                    x2_obj.ndim,
                                                    x2_shape.data(),
                                                    x2_strides.data(),
                                                    NULL,
                                                    NULL)  # dep_events_ref)

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

    if out is not None and is_result_memory_allocated:
        return out.get_result_desc(result)

    return result.get_result_desc()

1	# cython: language_level=3	1✔
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
30
31	This module contains interface functions between C backend layer
32	and the rest of the library
33
34	"""
35
36	from libc.time cimport time, time_t
37	from libcpp.vector cimport vector
38
39	import dpctl	1✔
40
41	import dpnp	1✔
42	import dpnp.config as config	1✔
43	import dpnp.dpnp_container as dpnp_container	1✔
44	import dpnp.dpnp_utils as utils_py	1✔
45	from dpnp.dpnp_array import dpnp_array	1✔
46
47	cimport cpython
48	cimport numpy
49
50	cimport dpnp.dpnp_utils as utils
51
52	import operator	1✔
53
54	import numpy	1✔
55
56	__all__ = [	1✔
57	"dpnp_astype",
58	"dpnp_flatten",
59	"dpnp_init_val",
60	"dpnp_queue_initialize",
61	"dpnp_queue_is_cpu"
62	]
63
64
65	include "dpnp_algo_arraycreation.pxi"
66	include "dpnp_algo_bitwise.pxi"
67	include "dpnp_algo_counting.pxi"
68	include "dpnp_algo_indexing.pxi"
69	include "dpnp_algo_linearalgebra.pxi"
70	include "dpnp_algo_logic.pxi"
71	include "dpnp_algo_manipulation.pxi"
72	include "dpnp_algo_mathematical.pxi"
73	include "dpnp_algo_searching.pxi"
74	include "dpnp_algo_sorting.pxi"
75	include "dpnp_algo_special.pxi"
76	include "dpnp_algo_statistics.pxi"
77	include "dpnp_algo_trigonometric.pxi"
78
79
80	ctypedef c_dpctl.DPCTLSyclEventRef(*fptr_dpnp_astype_t)(c_dpctl.DPCTLSyclQueueRef,
81	const void , void , const size_t,
82	const c_dpctl.DPCTLEventVectorRef)
83	ctypedef c_dpctl.DPCTLSyclEventRef(*fptr_dpnp_flatten_t)(c_dpctl.DPCTLSyclQueueRef,
84	void *, const size_t, const size_t,
85	const shape_elem_type * , const shape_elem_type * ,
86	void *, const size_t, const size_t,
87	const shape_elem_type * , const shape_elem_type * ,
88	const long * ,
89	const c_dpctl.DPCTLEventVectorRef)
90	ctypedef c_dpctl.DPCTLSyclEventRef(*fptr_dpnp_initval_t)(c_dpctl.DPCTLSyclQueueRef,
91	void , void , size_t,
92	const c_dpctl.DPCTLEventVectorRef)
93
94
95	cpdef utils.dpnp_descriptor dpnp_astype(utils.dpnp_descriptor x1, dtype):	1✔
96	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)	1✔
UNCOV 97	cdef DPNPFuncType param2_type = dpnp_dtype_to_DPNPFuncType(dtype)	×
98
99	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_ASTYPE_EXT, param1_type, param2_type)	×
100
101	x1_obj = x1.get_array()	1✔
102
103	# ceate result array with type given by FPTR data
104	cdef shape_type_c result_shape = x1.shape	1✔
UNCOV 105	cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,	×
106	kernel_data.return_type,
107	None,
108	device=x1_obj.sycl_device,	1✔
UNCOV 109	usm_type=x1_obj.usm_type,	×
110	sycl_queue=x1_obj.sycl_queue)	×
111
112	result_sycl_queue = result.get_array().sycl_queue	1✔
113
114	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	×
115	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	×
116
UNCOV 117	cdef fptr_dpnp_astype_t func = <fptr_dpnp_astype_t > kernel_data.ptr	×
118	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref, x1.get_data(), result.get_data(), x1.size, NULL)	×
119
120	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
UNCOV 121	c_dpctl.DPCTLEvent_Delete(event_ref)	×
122
123	return result	1✔
124
125
126	cpdef utils.dpnp_descriptor dpnp_flatten(utils.dpnp_descriptor x1):	1✔
127	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)	1✔
128
129	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_FLATTEN_EXT, param1_type, param1_type)	1✔
130
131	cdef shape_type_c x1_shape = x1.shape	1✔
132	cdef shape_type_c x1_strides = utils.strides_to_vector(x1.strides, x1_shape)	1✔
133
134	x1_obj = x1.get_array()	1✔
135
136	# ceate result array with type given by FPTR data
137	cdef shape_type_c result_shape = (x1.size,)	1✔
138	cdef utils.dpnp_descriptor result = utils.create_output_descriptor(result_shape,	1✔
139	kernel_data.return_type,
140	None,
141	device=x1_obj.sycl_device,	1✔
142	usm_type=x1_obj.usm_type,	1✔
143	sycl_queue=x1_obj.sycl_queue)	1✔
144
145	result_sycl_queue = result.get_array().sycl_queue	1✔
146
147	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
148	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
149
150	cdef shape_type_c result_strides = utils.strides_to_vector(result.strides, result_shape)	1✔
151
152	cdef fptr_dpnp_flatten_t func = <fptr_dpnp_flatten_t > kernel_data.ptr	1✔
153	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
154	result.get_data(),
155	result.size,	1✔
156	result.ndim,	1✔
157	result_shape.data(),
158	result_strides.data(),
159	x1.get_data(),
160	x1.size,	1✔
161	x1.ndim,	1✔
162	x1_shape.data(),
163	x1_strides.data(),
164	NULL,
165	NULL) # dep_events_ref
166
167	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
168	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
169
170	return result	1✔
171
172
173	cpdef utils.dpnp_descriptor dpnp_init_val(shape, dtype, value):	1✔
174	"""
175	same as dpnp_full(). TODO remove code dumplication
176	"""
177	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(dtype)	×
178
179	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_INITVAL_EXT, param1_type, param1_type)	1✔
180
181	cdef utils.dpnp_descriptor result = utils_py.create_output_descriptor_py(shape, dtype, None)	×
182
183	result_obj = result.get_array()	1✔
184
185	# TODO: find better way to pass single value with type conversion
186	cdef utils.dpnp_descriptor val_arr = utils_py.create_output_descriptor_py((1, ),	×
187	dtype,
188	None,	×
189	device=result_obj.sycl_device,	×
190	usm_type=result_obj.usm_type,	×
191	sycl_queue=result_obj.sycl_queue)	×
192	val_arr.get_pyobj()[0] = value	×
193
194	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_obj.sycl_queue	×
195	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	×
196
197	cdef fptr_dpnp_initval_t func = <fptr_dpnp_initval_t > kernel_data.ptr	×
198	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref, result.get_data(), val_arr.get_data(), result.size, NULL)	1✔
199
200	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	×
201	c_dpctl.DPCTLEvent_Delete(event_ref)	×
202
203	return result	×
204
205
206	cpdef dpnp_queue_initialize():	1✔
207	"""
208	Initialize SYCL queue which will be used for any library operations.
209	It takes visible time and needs to be done in the module loading procedure.
210	"""
211	cdef time_t seed_from_time
212	cdef QueueOptions queue_type = CPU_SELECTOR	×
213
214	if (config.__DPNP_QUEUE_GPU__):	×
215	queue_type = GPU_SELECTOR	×
216
217	dpnp_queue_initialize_c(queue_type)	×
218	dpnp_python_constants_initialize_c(< void*> None,	×
219	< void * > dpnp.nan)	×
220
221	# TODO:
222	# choose seed number as is in numpy
223	seed_from_time = time(NULL)	×
224	dpnp_rng_srand_c(seed_from_time)	×
225
226
227	cpdef dpnp_queue_is_cpu():	1✔
228	"""Return 1 if current queue is CPU. Return 0 otherwise.
229
230	"""
231	return dpnp_queue_is_cpu_c()	1✔
232
233
234	"""
235	Internal functions
236	"""
237	cdef DPNPFuncType dpnp_dtype_to_DPNPFuncType(dtype):	1✔
238	dt_c = dpnp.dtype(dtype).char	1✔
239	kind = dpnp.dtype(dtype).kind	1✔
240	if isinstance(kind, int):	1✔
241	kind = chr(kind)	×
242	itemsize = dpnp.dtype(dtype).itemsize	1✔
243
244	if dt_c == 'd':	1✔
245	return DPNP_FT_DOUBLE	1✔
246	elif dt_c == 'f':	1✔
247	return DPNP_FT_FLOAT	1✔
248	elif kind == 'i':	1✔
249	if itemsize == 8:	1✔
250	return DPNP_FT_LONG	1✔
251	elif itemsize == 4:	1✔
252	return DPNP_FT_INT	1✔
253	else:
254	utils.checker_throw_type_error("dpnp_dtype_to_DPNPFuncType", dtype)	×
255	elif dt_c == 'F':	1✔
256	return DPNP_FT_CMPLX64	1✔
257	elif dt_c == 'D':	1✔
258	return DPNP_FT_CMPLX128	1✔
259	elif dt_c == '?':	1✔
260	return DPNP_FT_BOOL	1✔
261	else:
262	utils.checker_throw_type_error("dpnp_dtype_to_DPNPFuncType", dtype)	×
263
264
265	cdef dpnp_DPNPFuncType_to_dtype(size_t type):	1✔
266	"""
267	Type 'size_t' used instead 'DPNPFuncType' because Cython has lack of Enum support (0.29)
268	TODO needs to use DPNPFuncType here
269	"""
270	if type == <size_t > DPNP_FT_DOUBLE:	1✔
271	return dpnp.float64	1✔
272	elif type == <size_t > DPNP_FT_FLOAT:	1✔
273	return dpnp.float32	1✔
274	elif type == <size_t > DPNP_FT_LONG:	1✔
275	return dpnp.int64	1✔
276	elif type == <size_t > DPNP_FT_INT:	1✔
277	return dpnp.int32	1✔
278	elif type == <size_t > DPNP_FT_CMPLX64:	1✔
279	return dpnp.complex64	1✔
280	elif type == <size_t > DPNP_FT_CMPLX128:	1✔
281	return dpnp.complex128	1✔
282	elif type == <size_t > DPNP_FT_BOOL:	1✔
283	return dpnp.bool	1✔
284	else:
285	utils.checker_throw_type_error("dpnp_DPNPFuncType_to_dtype", type)	×
286
287
288	cdef utils.dpnp_descriptor call_fptr_1in_1out(DPNPFuncName fptr_name,	1✔
289	utils.dpnp_descriptor x1,
290	shape_type_c result_shape,
291	utils.dpnp_descriptor out=None,
292	func_name=None):
293
294	""" Convert type (x1.dtype) to C enum DPNPFuncType """
295	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)	1✔
296
297	""" get the FPTR data structure """
298	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(fptr_name, param1_type, param1_type)	1✔
299
300	result_type = dpnp_DPNPFuncType_to_dtype( < size_t > kernel_data.return_type)	1✔
301
302	cdef utils.dpnp_descriptor result
303
304	if out is None:	1✔
305	""" Create result array with type given by FPTR data """
306	x1_obj = x1.get_array()	1✔
307	result = utils.create_output_descriptor(result_shape,	1✔
308	kernel_data.return_type,
309	None,
310	device=x1_obj.sycl_device,	1✔
311	usm_type=x1_obj.usm_type,	1✔
312	sycl_queue=x1_obj.sycl_queue)	1✔
313	else:
314	if out.dtype != result_type:	×
315	utils.checker_throw_value_error(func_name, 'out.dtype', out.dtype, result_type)	×
316	if out.shape != result_shape:	×
317	utils.checker_throw_value_error(func_name, 'out.shape', out.shape, result_shape)	1✔
318
319	result = out	×
320
321	utils.get_common_usm_allocation(x1, result) # check USM allocation is common	×
322
323	result_sycl_queue = result.get_array().sycl_queue	1✔
324
325	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
326	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
327
328	cdef fptr_1in_1out_t func = <fptr_1in_1out_t > kernel_data.ptr	1✔
329
330	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref, x1.get_data(), result.get_data(), x1.size, NULL)	1✔
331
332	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
333	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
334
335	return result	1✔
336
337
338	cdef utils.dpnp_descriptor call_fptr_1in_1out_strides(DPNPFuncName fptr_name,	1✔
339	utils.dpnp_descriptor x1,
340	object dtype=None,
341	utils.dpnp_descriptor out=None,
342	object where=True,
343	func_name=None):
344
345	""" Convert type (x1.dtype) to C enum DPNPFuncType """
346	cdef DPNPFuncType param1_type = dpnp_dtype_to_DPNPFuncType(x1.dtype)	1✔
347
348	""" get the FPTR data structure """
349	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(fptr_name, param1_type, param1_type)	1✔
350
351	result_type = dpnp_DPNPFuncType_to_dtype( < size_t > kernel_data.return_type)	1✔
352
353	cdef shape_type_c x1_shape = x1.shape	1✔
354	cdef shape_type_c x1_strides = utils.strides_to_vector(x1.strides, x1_shape)	1✔
355
356	cdef shape_type_c result_shape = x1_shape	1✔
357	cdef utils.dpnp_descriptor result
358
359	if out is None:	1✔
360	""" Create result array with type given by FPTR data """
361	x1_obj = x1.get_array()	1✔
362	result = utils.create_output_descriptor(result_shape,	1✔
363	kernel_data.return_type,
364	None,
365	device=x1_obj.sycl_device,	1✔
366	usm_type=x1_obj.usm_type,	1✔
367	sycl_queue=x1_obj.sycl_queue)	1✔
368	else:
369	if out.dtype != result_type:	1✔
370	utils.checker_throw_value_error(func_name, 'out.dtype', out.dtype, result_type)	1✔
371	if out.shape != result_shape:	1✔
372	utils.checker_throw_value_error(func_name, 'out.shape', out.shape, result_shape)	1✔
373
374	result = out	1✔
375
376	utils.get_common_usm_allocation(x1, result) # check USM allocation is common	1✔
377
378	result_sycl_queue = result.get_array().sycl_queue	1✔
379
380	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
381	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
382
383	cdef shape_type_c result_strides = utils.strides_to_vector(result.strides, result_shape)	1✔
384
385	""" Call FPTR function """
386	cdef fptr_1in_1out_strides_t func = <fptr_1in_1out_strides_t > kernel_data.ptr	1✔
387	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
388	result.get_data(),
389	result.size,	1✔
390	result.ndim,	1✔
391	result_shape.data(),
392	result_strides.data(),
393	x1.get_data(),
394	x1.size,	1✔
395	x1.ndim,	1✔
396	x1_shape.data(),
397	x1_strides.data(),
398	NULL,
399	NULL) # dep_events_ref
400
401	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
402	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
403
404	return result	1✔
405
406
407	cdef utils.dpnp_descriptor call_fptr_2in_1out(DPNPFuncName fptr_name,	1✔
408	utils.dpnp_descriptor x1_obj,
409	utils.dpnp_descriptor x2_obj,
410	object dtype=None,
411	utils.dpnp_descriptor out=None,
412	object where=True,
413	func_name=None):
414
415	# Convert type (x1_obj.dtype) to C enum DPNPFuncType
416	cdef DPNPFuncType x1_c_type = dpnp_dtype_to_DPNPFuncType(x1_obj.dtype)	1✔
417	cdef DPNPFuncType x2_c_type = dpnp_dtype_to_DPNPFuncType(x2_obj.dtype)	1✔
418
419	# get the FPTR data structure
420	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(fptr_name, x1_c_type, x2_c_type)	1✔
421
422	result_type = dpnp_DPNPFuncType_to_dtype( < size_t > kernel_data.return_type)	1✔
423
424	# Create result array
425	cdef shape_type_c x1_shape = x1_obj.shape	1✔
426	cdef shape_type_c x2_shape = x2_obj.shape	1✔
427	cdef shape_type_c result_shape = utils.get_common_shape(x1_shape, x2_shape)	1✔
428	cdef utils.dpnp_descriptor result
429
430	result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(x1_obj, x2_obj)	1✔
431
432	if out is None:	1✔
433	""" Create result array with type given by FPTR data """
434	result = utils.create_output_descriptor(result_shape,	1✔
435	kernel_data.return_type,
436	None,
437	device=result_sycl_device,
438	usm_type=result_usm_type,
439	sycl_queue=result_sycl_queue)
440	else:
441	if out.dtype != result_type:	×
442	utils.checker_throw_value_error(func_name, 'out.dtype', out.dtype, result_type)	×
443	if out.shape != result_shape:	1✔
444	utils.checker_throw_value_error(func_name, 'out.shape', out.shape, result_shape)	1✔
445
446	result = out	×
447
448	utils.get_common_usm_allocation(x1_obj, result) # check USM allocation is common	×
449
450	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
451	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
452
453	""" Call FPTR function """
454	cdef fptr_2in_1out_t func = <fptr_2in_1out_t > kernel_data.ptr	1✔
455	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
456	result.get_data(),
457	x1_obj.get_data(),
458	x1_obj.size,	1✔
459	x1_shape.data(),
460	x1_shape.size(),
461	x2_obj.get_data(),
462	x2_obj.size,	1✔
463	x2_shape.data(),
464	x2_shape.size(),
465	NULL,
466	NULL) # dep_events_ref)
467
468	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
469	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
470
471	return result	1✔
472
473	cdef utils.dpnp_descriptor call_fptr_2in_1out_strides(DPNPFuncName fptr_name,	1✔
474	utils.dpnp_descriptor x1_obj,
475	utils.dpnp_descriptor x2_obj,
476	object dtype=None,
477	utils.dpnp_descriptor out=None,
478	object where=True,
479	func_name=None):
480
481	# Convert type (x1_obj.dtype) to C enum DPNPFuncType
482	cdef DPNPFuncType x1_c_type = dpnp_dtype_to_DPNPFuncType(x1_obj.dtype)	1✔
483	cdef DPNPFuncType x2_c_type = dpnp_dtype_to_DPNPFuncType(x2_obj.dtype)	1✔
484
485	# get the FPTR data structure
486	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(fptr_name, x1_c_type, x2_c_type)	1✔
487
488	# Create result array
489	cdef shape_type_c x1_shape = x1_obj.shape	1✔
490
491	cdef shape_type_c x1_strides = utils.strides_to_vector(x1_obj.strides, x1_shape)	1✔
492	cdef shape_type_c x2_shape = x2_obj.shape	1✔
493	cdef shape_type_c x2_strides = utils.strides_to_vector(x2_obj.strides, x2_shape)	1✔
494
495	cdef shape_type_c result_shape = utils.get_common_shape(x1_shape, x2_shape)	1✔
496	cdef utils.dpnp_descriptor result
497
498	result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(x1_obj, x2_obj)	1✔
499
500	# get FPTR function and return type
501	cdef fptr_2in_1out_strides_t func = < fptr_2in_1out_strides_t > kernel_data.ptr	1✔
502	cdef DPNPFuncType return_type = kernel_data.return_type	1✔
503
504	# check 'out' parameter data
505	if out is not None:	1✔
506	if out.shape != result_shape:	1✔
507	utils.checker_throw_value_error(func_name, 'out.shape', out.shape, result_shape)	1✔
508
509	utils.get_common_usm_allocation(x1_obj, out) # check USM allocation is common	1✔
510
511	if out is None or out.is_array_overlapped(x1_obj) or out.is_array_overlapped(x2_obj) or not out.match_ctype(return_type):	1✔
512	"""
513	Create result array with type given by FPTR data.
514	If 'out' array has another dtype than expected or overlaps a memory from any input array,
515	we have to create a temporary array and to copy data from the temporary into 'out' array,
516	once the computation is completed.
517	Otherwise simultaneously access to the same memory may cause a race condition issue
518	which will result into undefined behaviour.
519	"""
520	is_result_memory_allocated = True	1✔
521	result = utils.create_output_descriptor(result_shape,	1✔
522	return_type,
523	None,
524	device=result_sycl_device,
525	usm_type=result_usm_type,
526	sycl_queue=result_sycl_queue)
527	else:
528	is_result_memory_allocated = False	1✔
529	result = out	1✔
530
531	cdef shape_type_c result_strides = utils.strides_to_vector(result.strides, result_shape)	1✔
532
533	result_obj = result.get_array()	1✔
534
535	cdef c_dpctl.SyclQueue q = < c_dpctl.SyclQueue > result_obj.sycl_queue	1✔
536	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
537
538	""" Call FPTR function """
539	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
540	result.get_data(),
541	result.size,	1✔
542	result.ndim,	1✔
543	result_shape.data(),
544	result_strides.data(),
545	x1_obj.get_data(),
546	x1_obj.size,	1✔
547	x1_obj.ndim,	1✔
548	x1_shape.data(),
549	x1_strides.data(),
550	x2_obj.get_data(),
551	x2_obj.size,	1✔
552	x2_obj.ndim,	1✔
553	x2_shape.data(),
554	x2_strides.data(),
555	NULL,
556	NULL) # dep_events_ref)
557
558	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
559	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
560
561	if out is not None and is_result_memory_allocated:	1✔
562	return out.get_result_desc(result)	1✔
563
564	return result.get_result_desc()	1✔

IntelPython / dpnp / 5490609761

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