dpnp_utils.hpp

//*****************************************************************************
// Copyright (c) 2016-2025, 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.
//*****************************************************************************
 
#pragma once
#ifndef BACKEND_UTILS_H // Cython compatibility
#define BACKEND_UTILS_H
 
#include <algorithm>
#include <cassert>
#include <complex>
#include <iostream>
#include <iterator>
#include <stdexcept>
 
#include <sycl/sycl.hpp>
 
#include <dpnp_iface_fptr.hpp>
 
#ifndef __SYCL_COMPILER_VECTOR_ABS_CHANGED
#define __SYCL_COMPILER_VECTOR_ABS_CHANGED 20230503L
#endif
 
#ifndef __INTEL_MKL_2023_0_0_VERSION_REQUIRED
#define __INTEL_MKL_2023_0_0_VERSION_REQUIRED 20230000
#endif
 
#ifndef __INTEL_MKL_2023_2_0_VERSION_REQUIRED
#define __INTEL_MKL_2023_2_0_VERSION_REQUIRED 20230002L
#endif
 
template <typename _DataType>
void get_shape_offsets_inkernel(const _DataType *shape,
                                size_t shape_size,
                                _DataType *offsets)
{
    size_t dim_prod_input = 1;
    for (size_t i = 0; i < shape_size; ++i) {
        long i_reverse = shape_size - 1 - i;
        offsets[i_reverse] = dim_prod_input;
        dim_prod_input *= shape[i_reverse];
    }
 
    return;
}
 
template <typename _DataType>
_DataType get_xyz_id_by_id_inkernel(size_t global_id,
                                    const _DataType *offsets,
                                    size_t offsets_size,
                                    size_t axis)
{
    /* avoid warning unused variable*/
    (void)offsets_size;
 
    assert(axis < offsets_size);
 
    _DataType xyz_id = 0;
    long reminder = global_id;
    for (size_t i = 0; i < axis + 1; ++i) {
        const _DataType axis_val = offsets[i];
        xyz_id = reminder / axis_val;
        reminder = reminder % axis_val;
    }
 
    return xyz_id;
}
 
template <typename _DataType>
static inline bool array_equal(const _DataType *input1,
                               const size_t input1_size,
                               const _DataType *input2,
                               const size_t input2_size)
{
    if (input1_size != input2_size)
        return false;
 
    const std::vector<_DataType> input1_vec(input1, input1 + input1_size);
    const std::vector<_DataType> input2_vec(input2, input2 + input2_size);
 
    return std::equal(std::begin(input1_vec), std::end(input1_vec),
                      std::begin(input2_vec));
}
 
template <typename T>
static inline void validate_type_for_device(const sycl::device &d)
{
    if constexpr (std::is_same_v<T, double>) {
        if (!d.has(sycl::aspect::fp64)) {
            throw std::runtime_error("Device " +
                                     d.get_info<sycl::info::device::name>() +
                                     " does not support type 'double'");
        }
    }
    else if constexpr (std::is_same_v<T, std::complex<double>>) {
        if (!d.has(sycl::aspect::fp64)) {
            throw std::runtime_error(
                "Device " + d.get_info<sycl::info::device::name>() +
                " does not support type 'complex<double>'");
        }
    }
    else if constexpr (std::is_same_v<T, sycl::half>) {
        if (!d.has(sycl::aspect::fp16)) {
            throw std::runtime_error("Device " +
                                     d.get_info<sycl::info::device::name>() +
                                     " does not support type 'half'");
        }
    }
}
 
template <typename T>
static inline void validate_type_for_device(const sycl::queue &q)
{
    validate_type_for_device<T>(q.get_device());
}
 
template <typename T>
std::ostream &operator<<(std::ostream &out, const std::vector<T> &vec)
{
    std::string delimiter;
    out << "{";
    // std::copy(vec.begin(), vec.end(), std::ostream_iterator<T>(out, ", "));
    // out << "\b\b}"; // last two 'backspaces' needs to eliminate last
    // delimiter. ex: {2, 3, 4, }
    for (auto &elem : vec) {
        out << delimiter << elem;
        if (delimiter.empty()) {
            delimiter.assign(", ");
        }
    }
    out << "}";
 
    return out;
}
 
template <typename T>
std::ostream &operator<<(std::ostream &out, DPNPFuncType elem)
{
    out << static_cast<size_t>(elem);
 
    return out;
}
 
#endif // BACKEND_UTILS_H