definitions.h

Go to the documentation of this file.

 
 
#pragma once
#include "mjolnir/core/fundamental_types.h"
#include "mjolnir/core/utility/type.h"
#include "mjolnir/core/x86/x86.h"
#include <type_traits>
 
#include <array>
 
// === DECLARATION ====================================================================================================
 
namespace mjolnir::x86
{
 
 
template <typename T_Type>
concept VectorRegister = is_any_of<T_Type, __m128, __m128d, __m128i, __m256, __m256d, __m256i>();
 
 
template <typename T_Type>
concept FloatVectorRegister = is_any_of<T_Type, __m128, __m128d, __m256, __m256d>();
 
 
template <typename T_Type>
concept FloatSSERegister = is_any_of<T_Type, __m128, __m128d>();
 
 
template <typename T_Type>
concept FloatAVXRegister = is_any_of<T_Type, __m256, __m256d>();
 
 
template <typename T_Type>
concept SinglePrecisionVectorRegister = is_any_of<T_Type, __m128, __m256>();
 
 
template <typename T_Type>
concept DoublePrecisionVectorRegister = is_any_of<T_Type, __m128d, __m256d>();
 
 
template <typename T_Type>
concept IntegerVectorRegister = is_any_of<T_Type, __m128i, __m256i>();
 
 
template <typename T_Type>
inline constexpr bool is_m128 = std::is_same_v<T_Type, __m128>;
 
 
template <typename T_Type>
inline constexpr bool is_m128d = std::is_same_v<T_Type, __m128d>;
 
 
template <typename T_Type>
inline constexpr bool is_m128i = std::is_same_v<T_Type, __m128i>;
 
 
template <typename T_Type>
inline constexpr bool is_m256 = std::is_same_v<T_Type, __m256>;
 
 
template <typename T_Type>
inline constexpr bool is_m256d = std::is_same_v<T_Type, __m256d>;
 
 
template <typename T_Type>
inline constexpr bool is_m256i = std::is_same_v<T_Type, __m256i>;
 
 
template <typename T_Type>
inline constexpr bool is_vector_register = is_any_of<T_Type, __m128, __m128d, __m128i, __m256, __m256d, __m256i>();
 
 
template <typename T_Type>
inline constexpr bool is_sse_register = is_any_of<T_Type, __m128, __m128d, __m128i>();
 
 
template <typename T_Type>
inline constexpr bool is_avx_register = is_any_of<T_Type, __m256, __m256d, __m256i>();
 
 
template <typename T_Type>
inline constexpr bool is_float_register = is_any_of<T_Type, __m128, __m128d, __m256, __m256d>();
 
 
template <typename T_Type>
inline constexpr bool is_integer_register = is_any_of<T_Type, __m128i, __m256i>();
 
 
// ---internal declarations -------------------------------------------------------------------------------------------
 
namespace internal
{
template <VectorRegister T_Type>
[[nodiscard]] consteval auto get_alignment_bytes() noexcept -> UST;
 
template <VectorRegister T_Type>
[[nodiscard]] consteval auto get_num_lanes() noexcept -> UST;
 
 
} // namespace internal
 
 
// --- continued public declarations ----------------------------------------------------------------------------------
 
template <FloatVectorRegister T_RegisterType>
using ElementType = typename std::conditional_t<is_any_of<T_RegisterType, __m128d, __m256d>(), F64, F32>;
 
 
template <FloatVectorRegister T_RegisterType>
inline constexpr bool is_single_precision = std::is_same_v<ElementType<T_RegisterType>, F32>;
 
 
template <FloatVectorRegister T_RegisterType>
inline constexpr bool is_double_precision = std::is_same_v<ElementType<T_RegisterType>, F64>;
 
 
template <VectorRegister T_RegisterType>
inline constexpr UST alignment_bytes = internal::get_alignment_bytes<T_RegisterType>();
 
 
template <VectorRegister T_RegisterType>
inline constexpr UST num_lanes = internal::get_num_lanes<T_RegisterType>();
 
 
template <FloatVectorRegister T_RegisterType>
inline constexpr UST num_elements = sizeof(T_RegisterType) / sizeof(ElementType<T_RegisterType>);
 
 
template <FloatVectorRegister T_RegisterType>
inline constexpr UST num_lane_elements = num_elements<T_RegisterType> / num_lanes<T_RegisterType>;
 
 
template <FloatVectorRegister T_RegisterType>
inline constexpr bool is_multi_lane = num_lanes<T_RegisterType> > 1;
 
 
template <FloatVectorRegister T_RegisterType>
struct alignas(alignment_bytes<T_RegisterType>) VectorDataArray
    : public std::array<ElementType<T_RegisterType>, num_elements<T_RegisterType>>
{
};
 
 
} // namespace mjolnir::x86
 
 
// === DEFINITIONS ====================================================================================================
 
namespace mjolnir::x86::internal
{
// --------------------------------------------------------------------------------------------------------------------
 
template <VectorRegister T_Type>
[[nodiscard]] consteval auto get_alignment_bytes() noexcept -> UST
{
    constexpr UST alignment_bytes_sse = 16;
    constexpr UST alignment_bytes_avx = 32;
 
    if constexpr (is_sse_register<T_Type>)
        return alignment_bytes_sse;
    else
        return alignment_bytes_avx;
}
 
 
// --------------------------------------------------------------------------------------------------------------------
 
template <VectorRegister T_Type>
[[nodiscard]] consteval auto get_num_lanes() noexcept -> UST
{
    constexpr UST num_lanes_sse = 1;
    constexpr UST num_lanes_avx = 2;
 
    if constexpr (is_sse_register<T_Type>)
        return num_lanes_sse;
    else
        return num_lanes_avx;
}
 
 
} // namespace mjolnir::x86::internal