typeinfo.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>      // For size_t
#include <type_traits>  // For standard type traits
 
// Forward declarations to avoid circular dependencies
namespace trlc {
namespace platform {
namespace detail {
// detectCacheLineSize() is defined in architecture.hpp
constexpr size_t detectPageSize() noexcept;
}  // namespace detail
}  // namespace platform
}  // namespace trlc
 
#include <cstddef>
#include <cstdint>
#include <type_traits>
 
namespace trlc {
namespace platform {
 
//==============================================================================
// Forward Declarations
//==============================================================================
 
namespace detail {
// Helper functions for compile-time calculations
template <typename Type>
constexpr size_t calculateTypePadding() noexcept;
 
template <typename Type>
constexpr bool hasTypePadding() noexcept;
 
// Platform-specific page size detection (cache line size is in architecture.hpp)
constexpr size_t detectPageSize() noexcept;
}  // namespace detail
 
//==============================================================================
// Core Type Information Functions
//==============================================================================
 
template <typename Type>
constexpr size_t getTypeSize() noexcept {
    return sizeof(Type);
}
 
template <typename Type>
constexpr size_t getTypeAlignment() noexcept {
    return alignof(Type);
}
 
constexpr size_t getCacheLineSize() noexcept {
    // Inline implementation to avoid circular dependency with architecture.hpp
#if defined(__x86_64__) || defined(_M_X64) || defined(__i386__) || defined(_M_IX86)
    return 64;  // x86/x64 typical cache line size
#elif defined(__aarch64__) || defined(_M_ARM64) || defined(__arm__) || defined(_M_ARM)
    return 64;  // ARM typical cache line size
#elif defined(__powerpc__) || defined(__ppc__) || defined(__PPC__)
    return 128;  // PowerPC typical cache line size
#else
    return 64;  // Conservative default
#endif
}
 
constexpr size_t getPageSize() noexcept {
    return detail::detectPageSize();
}
 
//==============================================================================
// Type Information Structure
//==============================================================================
 
template <typename Type>
struct TypeInfo {
    static constexpr size_t size = sizeof(Type);
 
    static constexpr size_t alignment = alignof(Type);
 
    static constexpr bool is_cache_line_aligned = (alignment >= getCacheLineSize());
 
    static constexpr bool is_trivially_copyable = std::is_trivially_copyable_v<Type>;
 
    static constexpr bool is_standard_layout = std::is_standard_layout_v<Type>;
 
    static constexpr bool is_pod = is_trivially_copyable && is_standard_layout;
 
    static constexpr bool is_empty = std::is_empty_v<Type>;
 
    static constexpr bool is_fundamental = std::is_fundamental_v<Type>;
 
    static constexpr bool is_integral = std::is_integral_v<Type>;
 
    static constexpr bool is_floating_point = std::is_floating_point_v<Type>;
 
    static constexpr bool is_pointer = std::is_pointer_v<Type>;
 
    static constexpr bool is_array = std::is_array_v<Type>;
};
 
//==============================================================================
// Padding Analysis Functions
//==============================================================================
 
template <typename Type>
constexpr size_t calculatePadding() noexcept {
    return detail::calculateTypePadding<Type>();
}
 
template <typename Type>
constexpr bool hasInternalPadding() noexcept {
    return detail::hasTypePadding<Type>();
}
 
//==============================================================================
// Alignment Helper Types
//==============================================================================
 
template <size_t TAlignment>
struct AlignedType {
    static_assert(TAlignment > 0, "Alignment must be greater than zero");
    static_assert((TAlignment & (TAlignment - 1)) == 0, "Alignment must be a power of two");
 
    alignas(TAlignment) char data[TAlignment];
 
    void* get() noexcept { return data; }
 
    const void* get() const noexcept { return data; }
 
    template <typename T>
    T* as() noexcept {
        static_assert(alignof(T) <= TAlignment, "Type alignment exceeds storage alignment");
        return reinterpret_cast<T*>(data);
    }
 
    template <typename T>
    const T* as() const noexcept {
        static_assert(alignof(T) <= TAlignment, "Type alignment exceeds storage alignment");
        return reinterpret_cast<const T*>(data);
    }
};
 
using CacheLineAligned = AlignedType<64>;  // Most common cache line size
 
using PageAligned = AlignedType<4096>;  // Most common page size
 
//==============================================================================
// Memory Layout Verification Functions
//==============================================================================
 
template <typename Type, size_t TExpectedSize>
constexpr bool verifyTypeSize() noexcept {
    return sizeof(Type) == TExpectedSize;
}
 
template <typename Type, size_t TExpectedAlignment>
constexpr bool verifyTypeAlignment() noexcept {
    return alignof(Type) == TExpectedAlignment;
}
 
template <typename Type>
constexpr bool isCacheLineAligned() noexcept {
    return alignof(Type) >= getCacheLineSize();
}
 
template <typename Type>
constexpr bool isPageAligned() noexcept {
    return alignof(Type) >= getPageSize();
}
 
//==============================================================================
// Size and Alignment Calculation Utilities
//==============================================================================
 
constexpr size_t alignedSize(size_t size, size_t alignment) noexcept {
    return (size + alignment - 1) & ~(alignment - 1);
}
 
constexpr uintptr_t alignedAddress(uintptr_t addr, size_t alignment) noexcept {
    return (addr + alignment - 1) & ~(alignment - 1);
}
 
constexpr bool isAligned(uintptr_t addr, size_t alignment) noexcept {
    return (addr & (alignment - 1)) == 0;
}
 
inline bool isAligned(const void* ptr, size_t alignment) noexcept {
    return isAligned(reinterpret_cast<uintptr_t>(ptr), alignment);
}
 
//==============================================================================
// Implementation Details
//==============================================================================
 
namespace detail {
 
template <typename Type>
constexpr size_t calculateTypePadding() noexcept {
    if constexpr (std::is_fundamental_v<Type> || std::is_pointer_v<Type>) {
        // Fundamental types and pointers typically have no internal padding
        return 0;
    } else if constexpr (std::is_empty_v<Type>) {
        // Empty types have no padding
        return 0;
    } else {
        // For other types, we can only estimate
        // The actual padding calculation would require reflection or compiler intrinsics
        // For now, we assume minimal padding based on alignment
        constexpr size_t type_size = sizeof(Type);
        constexpr size_t type_alignment = alignof(Type);
 
        // If size is not a multiple of alignment, there's likely trailing padding
        return (type_alignment - (type_size % type_alignment)) % type_alignment;
    }
}
 
template <typename Type>
constexpr bool hasTypePadding() noexcept {
    return calculateTypePadding<Type>() > 0;
}
 
// Note: detectCacheLineSize() is defined in architecture.hpp to avoid duplication
 
constexpr size_t detectPageSize() noexcept {
    // Platform-specific detection
#if defined(_WIN32) || defined(_WIN64)
    // Windows typically uses 4KB pages (though large pages are possible)
    return 4096;
#elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__) || \
    defined(__OpenBSD__)
    // Most Unix-like systems use 4KB pages by default
    return 4096;
#elif defined(__sparc__)
    // SPARC systems often use 8KB pages
    return 8192;
#elif defined(__ia64__)
    // Itanium systems often use 16KB pages
    return 16384;
#else
    // Conservative default for unknown platforms
    return 4096;
#endif
}
 
}  // namespace detail
 
}  // namespace platform
}  // namespace trlc
 
//==============================================================================
// Utility Macros
//==============================================================================
 
#define TRLC_ALIGNOF(type) (alignof(type))
 
#define TRLC_SIZEOF(type) (sizeof(type))
 
#define TRLC_CACHE_LINE_SIZE (trlc::platform::getCacheLineSize())
 
#define TRLC_PAGE_SIZE (trlc::platform::getPageSize())
 
#define TRLC_ALIGN_TO_CACHE_LINE alignas(trlc::platform::getCacheLineSize())
 
#define TRLC_ALIGN_TO_PAGE alignas(trlc::platform::getPageSize())
 
// Note: TRLC_CACHE_ALIGNED is defined in macros.hpp
 
#define TRLC_PAGE_ALIGNED(type, name) TRLC_ALIGN_TO_PAGE type name
 
//==============================================================================
// Static Assertions for Compile-Time Validation
//==============================================================================
 
// Verify that our alignment helpers work correctly
static_assert(alignof(trlc::platform::CacheLineAligned) >= 64,
              "CacheLineAligned should be at least 64-byte aligned");
static_assert(alignof(trlc::platform::PageAligned) >= 4096,
              "PageAligned should be at least 4096-byte aligned");
 
// Verify that our size functions work
static_assert(trlc::platform::getTypeSize<char>() == 1, "char should be 1 byte");
static_assert(trlc::platform::getTypeAlignment<char>() == 1, "char should be 1-byte aligned");
 
// Verify that our verification functions work
static_assert(trlc::platform::verifyTypeSize<char, 1>(), "Type size verification should work");
static_assert(trlc::platform::verifyTypeAlignment<char, 1>(),
              "Type alignment verification should work");
 
// Verify TypeInfo works correctly
static_assert(trlc::platform::TypeInfo<int>::size == sizeof(int),
              "TypeInfo size should match sizeof");
static_assert(trlc::platform::TypeInfo<int>::alignment == alignof(int),
              "TypeInfo alignment should match alignof");
static_assert(trlc::platform::TypeInfo<int>::is_fundamental, "int should be fundamental");
static_assert(trlc::platform::TypeInfo<int>::is_integral, "int should be integral");
static_assert(!trlc::platform::TypeInfo<int>::is_floating_point,
              "int should not be floating point");