opennn_types.h

Go to the documentation of this file.

// SPDX-License-Identifier: AGPL-3.0-only
// Copyright (C) 2026 Artificial Intelligence Techniques, S.L. and Roberto López González
 
#pragma once
#ifndef OPENNN_TYPES_H_
#define OPENNN_TYPES_H_
 
#if defined(__INTELLISENSE__) && !defined(OPENNN_HAS_CUDA)
#define OPENNN_HAS_CUDA
#endif
 
#ifndef EIGEN_USE_THREADS
#define EIGEN_USE_THREADS
#endif
#ifndef EIGEN_MAX_ALIGN_BYTES
#define EIGEN_MAX_ALIGN_BYTES 64
#endif
#ifndef EIGEN_NO_DEBUG
#define EIGEN_NO_DEBUG
#endif
#ifndef NOMINMAX
#define NOMINMAX
#endif
#define _SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING
#define _CRT_SECURE_NO_WARNINGS
#define EIGEN_PERMANENTLY_DISABLE_STUPID_WARNINGS
#define _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING
 
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <exception>
#include <filesystem>
#include <format>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <numeric>
#include <optional>
#include <random>
#include <set>
#include <source_location>
#include <span>
#include <sstream>
#include <stdexcept>
#include <string>
#include <string_view>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
 
#include <Eigen/Core>
#include <unsupported/Eigen/CXX11/Tensor>
 
#ifdef OPENNN_HAS_CUDA
 
#include <cuda.h>
#include <cuda_runtime.h>
#include <cublas_v2.h>
#include <cublasLt.h>
#include <cudnn.h>
#include <cuda_bf16.h>
 
using namespace std;
 
template <typename T>
void check_cuda_status(T status, const char* msg,
                       source_location loc = source_location::current())
{
    if (status != 0)
        throw runtime_error(string(msg) + " Error: " + to_string(static_cast<int>(status)) +
                                 " in " + loc.file_name() + ":" + to_string(loc.line()));
}
 
#define CHECK_CUDA(x)   check_cuda_status(x, "CUDA")
#define CHECK_CUBLAS(x) check_cuda_status(x, "CuBLAS")
#define CHECK_CUDNN(x)  check_cuda_status(x, "cuDNN")
 
#else
 
using cudaStream_t     = void*;
using cudaEvent_t      = void*;
using cudaGraph_t      = void*;
using cudaGraphExec_t  = void*;
using cublasHandle_t   = void*;
using cublasLtHandle_t = void*;
using cudnnHandle_t    = void*;
using cublasLtMatmulDesc_t   = void*;
using cublasLtMatrixLayout_t = void*;
struct cublasLtMatmulAlgo_t {};
 
struct __nv_bfloat16 { unsigned short __x; };
struct __half { unsigned short __x; };
 
enum cudaDataType_t                  { CUDA_R_32F = 0, CUDA_R_16F = 2, CUDA_R_8I = 3, CUDA_R_32I = 10, CUDA_R_16BF = 14 };
enum cublasComputeType_t             { CUBLAS_COMPUTE_32F = 68, CUBLAS_COMPUTE_32F_FAST_16BF = 75, CUBLAS_COMPUTE_32F_FAST_TF32 = 77 };
enum cublasOperation_t               { CUBLAS_OP_N = 0, CUBLAS_OP_T = 1 };
enum cublasLtEpilogue_t              { CUBLASLT_EPILOGUE_DEFAULT = 1, CUBLASLT_EPILOGUE_RELU = 2, CUBLASLT_EPILOGUE_BIAS = 4, CUBLASLT_EPILOGUE_RELU_BIAS = 6, CUBLASLT_EPILOGUE_RELU_AUX_BIAS = 134, CUBLASLT_EPILOGUE_DRELU = 136, CUBLASLT_EPILOGUE_GELU_AUX_BIAS = 164 };
 
enum cudnnDataType_t                 { CUDNN_DATA_FLOAT = 0, CUDNN_DATA_HALF = 2, CUDNN_DATA_INT8 = 3, CUDNN_DATA_INT32 = 4, CUDNN_DATA_BFLOAT16 = 9 };
 
struct cudnnTensorStruct {};
using cudnnTensorDescriptor_t      = cudnnTensorStruct*;
struct cudnnPoolingStruct {};
using cudnnPoolingDescriptor_t     = cudnnPoolingStruct*;
using cudnnDropoutDescriptor_t     = void*;
using cudnnOpTensorDescriptor_t    = void*;
using cudnnRNNDescriptor_t         = void*;
using cudnnRNNDataDescriptor_t     = void*;
 
#endif
 
#define OPENNN_CUDA_STUB_BODY(name) { throw runtime_error(#name " requires CUDA support."); }
#define OPENNN_CUDA_STUB(ret, name, sig) static ret name sig OPENNN_CUDA_STUB_BODY(name)
 
#define OPENNN_CUDA_TEMPLATE_STUB(name)                        template<typename... Ts, typename... As>                   static void name(As&&...) OPENNN_CUDA_STUB_BODY(name)
 
using namespace std;
using Eigen::Index;
 
using type = float;
 
namespace opennn {
 
using DeviceStream = cudaStream_t;
using DeviceEvent = cudaEvent_t;
using DeviceGraph = cudaGraph_t;
using DeviceGraphExec = cudaGraphExec_t;
using BlasHandle = cublasHandle_t;
using BlasLtHandle = cublasLtHandle_t;
using DnnHandle = cudnnHandle_t;
using DnnOpTensorDescriptor = cudnnOpTensorDescriptor_t;
using DnnDataType = cudnnDataType_t;
#ifdef OPENNN_HAS_CUDA
using DnnStatus = cudnnStatus_t;
#else
using DnnStatus = int;
#endif
using DnnTensorDescriptor = cudnnTensorDescriptor_t;
using DnnRNNDataDescriptor = cudnnRNNDataDescriptor_t;
using DnnRNNDescriptor = cudnnRNNDescriptor_t;
using DnnDropoutDescriptor = cudnnDropoutDescriptor_t;
using DnnPoolingDescriptor = cudnnPoolingDescriptor_t;
#ifdef OPENNN_HAS_CUDA
using DnnRNNMode = cudnnRNNMode_t;
#else
using DnnRNNMode = int;
#endif
using BlasComputeType = cublasComputeType_t;
#ifdef OPENNN_HAS_CUDA
using BlasPointerMode = cublasPointerMode_t;
using BlasMathMode = cublasMath_t;
#else
using BlasPointerMode = int;
using BlasMathMode = int;
#endif
using BlasOperation = cublasOperation_t;
using DeviceDataType = cudaDataType_t;
 
using namespace Eigen;
using bfloat16 = __nv_bfloat16;
 
inline float bfloat16_to_float_host(const uint16_t value)
{
    return bit_cast<float>(uint32_t(value) << 16);
}
 
inline uint16_t float_to_bfloat16_host(const float value)
{
    uint32_t bits = bit_cast<uint32_t>(value);
    if ((bits & 0x7FFFFFFFu) > 0x7F800000u)
        return uint16_t((bits >> 16) | 0x0040u);
 
    bits += 0x7FFFu + ((bits >> 16) & 1u);
    return uint16_t(bits >> 16);
}
 
inline void float_2_bfloat16_host(const Index count,
                                  const float* source,
                                  uint16_t* destination)
{
    #pragma omp parallel for if(count > 4096)
    for (Index i = 0; i < count; ++i)
        destination[i] = float_to_bfloat16_host(source[i]);
}
 
using type = float;
 
class Json;
class JsonDocument;
class JsonWriter;
 
namespace detail
{
 
#if defined(__CUDA_ARCH__)
 
template<typename Message, typename... Args>
[[noreturn]] __device__ inline void throw_formatted(Message&&, Args&&...)
{
    __trap();
}
 
#else
 
[[noreturn]] inline void throw_formatted(string_view message,
                                         const source_location& loc = source_location::current())
{
    // The file name, never the path it was built from. The applications show this
    // text to the user exactly as it arrives, so the full path would put the build
    // machine's directory layout in a dialog on someone else's computer.
    const string_view file = loc.file_name();
    const size_t separator = file.find_last_of("/\\");
 
    throw runtime_error(format("{} [at {}:{}]",
                               message,
                               separator == string_view::npos
                                   ? file
                                   : file.substr(separator + 1),
                               loc.line()));
}
 
template<typename... Args>
[[noreturn]] inline void throw_formatted(format_string<Args...> message, Args&&... args)
{
    throw runtime_error(format(message, std::forward<Args>(args)...));
}
 
#endif
 
}
 
#define throw_if(condition, ...)                                           do                                                                     {                                                                          if (condition)                                                             ::opennn::detail::throw_formatted(__VA_ARGS__);                }                                                                      while (false)
 
namespace detail
{
 
template<typename Map>
void make_bounded_cache_room(Map& entries, const size_t capacity)
{
    throw_if(capacity == 0, "A bounded cache requires a positive capacity.");
 
    if (entries.size() >= capacity)
        entries.erase(entries.begin());
}
 
template<typename Map, typename Key>
typename Map::mapped_type& bounded_cache_entry(Map& entries,
                                               const Key& key,
                                               const size_t capacity)
{
    if (const auto found = entries.find(key); found != entries.end())
        return found->second;
 
    make_bounded_cache_room(entries, capacity);
 
    return entries.try_emplace(key).first->second;
}
 
}
 
template <typename T, typename... Candidates>
constexpr bool is_one_of(const T& value, const Candidates&... candidates)
{
    return ((value == candidates) || ...);
}
 
template <typename F>
class ScopeExit
{
public:
 
    explicit ScopeExit(F new_cleanup)
        : cleanup(std::move(new_cleanup))
    {
    }
 
    ~ScopeExit() noexcept
    {
        if (!active) return;
        try { cleanup(); }
        catch (...) {}
    }
 
    ScopeExit(const ScopeExit&) = delete;
    ScopeExit& operator=(const ScopeExit&) = delete;
 
    void release() noexcept { active = false; }
 
private:
 
    F cleanup;
    bool active = true;
};
 
template <typename F> ScopeExit(F) -> ScopeExit<F>;
 
constexpr float EPSILON = numeric_limits<float>::epsilon();
constexpr float MAX = numeric_limits<float>::max();
constexpr float POS_INFINITY = numeric_limits<float>::infinity();
constexpr float NEG_INFINITY = -numeric_limits<float>::infinity();
constexpr float QUIET_NAN = numeric_limits<float>::quiet_NaN();
constexpr float SOFTMAX_MASK_VALUE = float(-1e9f);
 
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& vec)
{
    os << "[ ";
    for (size_t i = 0; i < vec.size(); ++i)
    {
        os << vec[i];
        if (i + 1 < vec.size()) os << "; ";
    }
    os << " ]";
    return os;
}
}
 
constexpr int Layout = Eigen::RowMajor;
 
using MatrixR = Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Layout>;
using MatrixI = Eigen::Matrix<Index, Eigen::Dynamic, Eigen::Dynamic, Layout>;
using MatrixB = Eigen::Matrix<bool, Eigen::Dynamic, Eigen::Dynamic, Layout>;
 
using VectorR = Eigen::Matrix<float, Eigen::Dynamic, 1>;
using VectorI = Eigen::Matrix<Index, Eigen::Dynamic, 1>;
using VectorB = Eigen::Matrix<bool, Eigen::Dynamic, 1>;
 
using VectorMap = Eigen::Map<VectorR, Eigen::AlignedMax>;
using ConstVectorMap = Eigen::Map<const VectorR, Eigen::AlignedMax>;
using ConstUnalignedVectorMap = Eigen::Map<const VectorR>;
using MatrixMap = Eigen::Map<MatrixR, Eigen::AlignedMax>;
 
inline ConstUnalignedVectorMap as_vector_map(const span<const float> values)
{
    return ConstUnalignedVectorMap(values.data(), Index(values.size()));
}
 
using Tensor0 = Eigen::Tensor<float, 0, Layout | Eigen::AlignedMax>;
using Tensor1 = Eigen::Tensor<float, 1, Layout | Eigen::AlignedMax>;
using Tensor2 = Eigen::Tensor<float, 2, Layout | Eigen::AlignedMax>;
using Tensor3 = Eigen::Tensor<float, 3, Layout | Eigen::AlignedMax>;
using Tensor4 = Eigen::Tensor<float, 4, Layout | Eigen::AlignedMax>;
 
template <int Rank>
using TensorR = Eigen::Tensor<float, Rank, Layout | Eigen::AlignedMax>;
 
using TensorMap3 = Eigen::TensorMap<Eigen::Tensor<float, 3, Layout | Eigen::AlignedMax>, Eigen::AlignedMax>;
using TensorMap4 = Eigen::TensorMap<Eigen::Tensor<float, 4, Layout | Eigen::AlignedMax>, Eigen::AlignedMax>;
 
template <int Rank>
using TensorMapR = Eigen::TensorMap<Eigen::Tensor<float, Rank, Layout | Eigen::AlignedMax>, Eigen::AlignedMax>;
 
#endif