5717251500

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

    x1_obj = x1.get_array()

    # get FPTR function and return type
    cdef (DPNPFuncType, void *) ret_type_and_func = utils.get_ret_type_and_func(kernel_data,
                                                                                x1_obj.sycl_device.has_aspect_fp64)
    cdef DPNPFuncType return_type = ret_type_and_func[0]
    cdef fptr_1in_1out_strides_t func = < fptr_1in_1out_strides_t > ret_type_and_func[1]

    result_type = dpnp_DPNPFuncType_to_dtype( < size_t > 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 """
        result = utils.create_output_descriptor(result_shape,
                                                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 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_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(x1_obj, x2_obj)

    # get FPTR function and return type
    cdef (DPNPFuncType, void *) ret_type_and_func = utils.get_ret_type_and_func(kernel_data,
                                                                                result_sycl_device.has_aspect_fp64)
    cdef DPNPFuncType return_type = ret_type_and_func[0]
    cdef fptr_2in_1out_t func = < fptr_2in_1out_t > ret_type_and_func[1]

    result_type = dpnp_DPNPFuncType_to_dtype( < size_t > 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

    if out is None:
        """ Create result array with type given by FPTR data """
        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:
        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 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)

    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 (DPNPFuncType, void *) ret_type_and_func = utils.get_ret_type_and_func(kernel_data,
                                                                                result_sycl_device.has_aspect_fp64)
    cdef DPNPFuncType return_type = ret_type_and_func[0]
    cdef fptr_2in_1out_strides_t func = < fptr_2in_1out_strides_t > ret_type_and_func[1]

    # 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

    # 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✔
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)	1✔
100
101	x1_obj = x1.get_array()	×
102
103	# ceate result array with type given by FPTR data
104	cdef shape_type_c result_shape = x1.shape	×
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✔
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()	1✔
116
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)	×
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
UNCOV 179	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(DPNP_FN_INITVAL_EXT, param1_type, param1_type)	×
180
181	cdef utils.dpnp_descriptor result = utils_py.create_output_descriptor_py(shape, dtype, None)	×
182
183	result_obj = result.get_array()	×
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, ),	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
UNCOV 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	x1_obj = x1.get_array()	1✔
352
353	# get FPTR function and return type
354	cdef (DPNPFuncType, void *) ret_type_and_func = utils.get_ret_type_and_func(kernel_data,	1✔
355	x1_obj.sycl_device.has_aspect_fp64)	1✔
356	cdef DPNPFuncType return_type = ret_type_and_func[0]	1✔
357	cdef fptr_1in_1out_strides_t func = < fptr_1in_1out_strides_t > ret_type_and_func[1]	1✔
358
359	result_type = dpnp_DPNPFuncType_to_dtype( < size_t > return_type)	1✔
360
361	cdef shape_type_c x1_shape = x1.shape	1✔
362	cdef shape_type_c x1_strides = utils.strides_to_vector(x1.strides, x1_shape)	1✔
363
364	cdef shape_type_c result_shape = x1_shape	1✔
365	cdef utils.dpnp_descriptor result
366
367	if out is None:	1✔
368	""" Create result array with type given by FPTR data """
369	result = utils.create_output_descriptor(result_shape,	1✔
370	return_type,
371	None,
372	device=x1_obj.sycl_device,	1✔
373	usm_type=x1_obj.usm_type,	1✔
374	sycl_queue=x1_obj.sycl_queue)	1✔
375	else:
376	if out.dtype != result_type:	1✔
377	utils.checker_throw_value_error(func_name, 'out.dtype', out.dtype, result_type)	1✔
378	if out.shape != result_shape:	1✔
379	utils.checker_throw_value_error(func_name, 'out.shape', out.shape, result_shape)	1✔
380
381	result = out	1✔
382
383	utils.get_common_usm_allocation(x1, result) # check USM allocation is common	1✔
384
385	result_sycl_queue = result.get_array().sycl_queue	1✔
386
387	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
388	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
389
390	cdef shape_type_c result_strides = utils.strides_to_vector(result.strides, result_shape)	1✔
391
392	""" Call FPTR function """
393	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
394	result.get_data(),
395	result.size,	1✔
396	result.ndim,	1✔
397	result_shape.data(),
398	result_strides.data(),
399	x1.get_data(),
400	x1.size,	1✔
401	x1.ndim,	1✔
402	x1_shape.data(),
403	x1_strides.data(),
404	NULL,
405	NULL) # dep_events_ref
406
407	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
408	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
409
410	return result	1✔
411
412
413	cdef utils.dpnp_descriptor call_fptr_2in_1out(DPNPFuncName fptr_name,	1✔
414	utils.dpnp_descriptor x1_obj,
415	utils.dpnp_descriptor x2_obj,
416	object dtype=None,
417	utils.dpnp_descriptor out=None,
418	object where=True,
419	func_name=None):
420
421	# Convert type (x1_obj.dtype) to C enum DPNPFuncType
422	cdef DPNPFuncType x1_c_type = dpnp_dtype_to_DPNPFuncType(x1_obj.dtype)	1✔
423	cdef DPNPFuncType x2_c_type = dpnp_dtype_to_DPNPFuncType(x2_obj.dtype)	1✔
424
425	# get the FPTR data structure
426	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(fptr_name, x1_c_type, x2_c_type)	1✔
427
428	result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(x1_obj, x2_obj)	1✔
429
430	# get FPTR function and return type
431	cdef (DPNPFuncType, void *) ret_type_and_func = utils.get_ret_type_and_func(kernel_data,	1✔
432	result_sycl_device.has_aspect_fp64)	1✔
433	cdef DPNPFuncType return_type = ret_type_and_func[0]	1✔
434	cdef fptr_2in_1out_t func = < fptr_2in_1out_t > ret_type_and_func[1]	1✔
435
436	result_type = dpnp_DPNPFuncType_to_dtype( < size_t > return_type)	1✔
437
438	# Create result array
439	cdef shape_type_c x1_shape = x1_obj.shape	1✔
440	cdef shape_type_c x2_shape = x2_obj.shape	1✔
441	cdef shape_type_c result_shape = utils.get_common_shape(x1_shape, x2_shape)	1✔
442	cdef utils.dpnp_descriptor result
443
444	if out is None:	1✔
445	""" Create result array with type given by FPTR data """
446	result = utils.create_output_descriptor(result_shape,	1✔
447	return_type,
448	None,
449	device=result_sycl_device,
450	usm_type=result_usm_type,
451	sycl_queue=result_sycl_queue)
452	else:
453	if out.dtype != result_type:	×
454	utils.checker_throw_value_error(func_name, 'out.dtype', out.dtype, result_type)	×
455	if out.shape != result_shape:	1✔
456	utils.checker_throw_value_error(func_name, 'out.shape', out.shape, result_shape)	×
457
458	result = out	×
459
460	utils.get_common_usm_allocation(x1_obj, result) # check USM allocation is common	×
461
462	cdef c_dpctl.SyclQueue q = <c_dpctl.SyclQueue> result_sycl_queue	1✔
463	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
464
465	""" Call FPTR function """
466	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
467	result.get_data(),
468	x1_obj.get_data(),
469	x1_obj.size,	1✔
470	x1_shape.data(),
471	x1_shape.size(),
472	x2_obj.get_data(),
473	x2_obj.size,	1✔
474	x2_shape.data(),
475	x2_shape.size(),
476	NULL,
477	NULL) # dep_events_ref)
478
479	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
480	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
481
482	return result	1✔
483
484	cdef utils.dpnp_descriptor call_fptr_2in_1out_strides(DPNPFuncName fptr_name,	1✔
485	utils.dpnp_descriptor x1_obj,
486	utils.dpnp_descriptor x2_obj,
487	object dtype=None,
488	utils.dpnp_descriptor out=None,
489	object where=True,
490	func_name=None):
491
492	# Convert type (x1_obj.dtype) to C enum DPNPFuncType
493	cdef DPNPFuncType x1_c_type = dpnp_dtype_to_DPNPFuncType(x1_obj.dtype)	1✔
494	cdef DPNPFuncType x2_c_type = dpnp_dtype_to_DPNPFuncType(x2_obj.dtype)	1✔
495
496	# get the FPTR data structure
497	cdef DPNPFuncData kernel_data = get_dpnp_function_ptr(fptr_name, x1_c_type, x2_c_type)	1✔
498
499	result_sycl_device, result_usm_type, result_sycl_queue = utils.get_common_usm_allocation(x1_obj, x2_obj)	1✔
500
501	# get FPTR function and return type
502	cdef (DPNPFuncType, void *) ret_type_and_func = utils.get_ret_type_and_func(kernel_data,	1✔
503	result_sycl_device.has_aspect_fp64)	1✔
504	cdef DPNPFuncType return_type = ret_type_and_func[0]	1✔
505	cdef fptr_2in_1out_strides_t func = < fptr_2in_1out_strides_t > ret_type_and_func[1]	1✔
506
507	# Create result array
508	cdef shape_type_c x1_shape = x1_obj.shape	1✔
509
510	cdef shape_type_c x1_strides = utils.strides_to_vector(x1_obj.strides, x1_shape)	1✔
511	cdef shape_type_c x2_shape = x2_obj.shape	1✔
512	cdef shape_type_c x2_strides = utils.strides_to_vector(x2_obj.strides, x2_shape)	1✔
513
514	cdef shape_type_c result_shape = utils.get_common_shape(x1_shape, x2_shape)	1✔
515	cdef utils.dpnp_descriptor result
516
517	# check 'out' parameter data
518	if out is not None:	1✔
519	if out.shape != result_shape:	1✔
520	utils.checker_throw_value_error(func_name, 'out.shape', out.shape, result_shape)	1✔
521
522	utils.get_common_usm_allocation(x1_obj, out) # check USM allocation is common	1✔
523
524	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✔
525	"""
526	Create result array with type given by FPTR data.
527	If 'out' array has another dtype than expected or overlaps a memory from any input array,
528	we have to create a temporary array and to copy data from the temporary into 'out' array,
529	once the computation is completed.
530	Otherwise simultaneously access to the same memory may cause a race condition issue
531	which will result into undefined behaviour.
532	"""
533	is_result_memory_allocated = True	1✔
534	result = utils.create_output_descriptor(result_shape,	1✔
535	return_type,
536	None,
537	device=result_sycl_device,
538	usm_type=result_usm_type,
539	sycl_queue=result_sycl_queue)
540	else:
541	is_result_memory_allocated = False	1✔
542	result = out	1✔
543
544	cdef shape_type_c result_strides = utils.strides_to_vector(result.strides, result_shape)	1✔
545
546	result_obj = result.get_array()	1✔
547
548	cdef c_dpctl.SyclQueue q = < c_dpctl.SyclQueue > result_obj.sycl_queue	1✔
549	cdef c_dpctl.DPCTLSyclQueueRef q_ref = q.get_queue_ref()	1✔
550
551	""" Call FPTR function """
552	cdef c_dpctl.DPCTLSyclEventRef event_ref = func(q_ref,	1✔
553	result.get_data(),
554	result.size,	1✔
555	result.ndim,	1✔
556	result_shape.data(),
557	result_strides.data(),
558	x1_obj.get_data(),
559	x1_obj.size,	1✔
560	x1_obj.ndim,	1✔
561	x1_shape.data(),
562	x1_strides.data(),
563	x2_obj.get_data(),
564	x2_obj.size,	1✔
565	x2_obj.ndim,	1✔
566	x2_shape.data(),
567	x2_strides.data(),
568	NULL,
569	NULL) # dep_events_ref)
570
571	with nogil: c_dpctl.DPCTLEvent_WaitAndThrow(event_ref)	1✔
572	c_dpctl.DPCTLEvent_Delete(event_ref)	1✔
573
574	if out is not None and is_result_memory_allocated:	1✔
575	return out.get_result_desc(result)	1✔
576
577	return result.get_result_desc()	1✔

IntelPython / dpnp / 5717251500

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