5272060429

pending completion

Build # 5272060429

Build Type

Pull #1431

github

Committed by

web-flow

Commit Message

Merge 260c7b35d into ac2566689

Pull Request Pull Request #1431: Implementation of dpnp.mean()

Run Details

5820 of 24625 branches covered (23.63%)

Branch coverage included in aggregate %.

26 of 30 new or added lines in 2 files covered. (86.67%)

2 existing lines in 2 files now uncovered.

11396 of 17518 relevant lines covered (65.05%)

39640.36 hits per line

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

83.68

/dpnp/dpnp_algo/dpnp_algo.pyx

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

import dpctl

cimport cpython
cimport dpnp.dpnp_utils as utils

cimport numpy
import numpy

import operator


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

IntelPython / dpnp / 5272060429

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