mem_alloc.h

#pragma once
#include "gaia/config/config.h"
#include "gaia/config/profiler.h"
 
#include <cstdint>
#include <cstring>
#include <stdlib.h>
#include <type_traits>
#include <utility>
 
#if GAIA_ALLOC_ARENA_LOCK || GAIA_ASSERT_ENABLED
  #include <atomic>
#endif
#if !GAIA_ALLOC_ARENA_LOCK && GAIA_ASSERT_ENABLED
  #include <thread>
#endif
 
#if GAIA_PLATFORM_WINDOWS
  #define GAIA_MEM_ALLC(size) ::malloc(size)
  #define GAIA_MEM_FREE(ptr) ::free(ptr)
 
  // Clang with MSVC codegen needs some remapping
  #if !defined(aligned_alloc)
    #define GAIA_MEM_ALLC_A(size, alig) ::_aligned_malloc(size, alig)
    #define GAIA_MEM_FREE_A(ptr) ::_aligned_free(ptr)
  #else
    #define GAIA_MEM_ALLC_A(size, alig) ::aligned_alloc(alig, size)
    #define GAIA_MEM_FREE_A(ptr) ::aligned_free(ptr)
  #endif
#else
  #define GAIA_MEM_ALLC(size) ::malloc(size)
  #define GAIA_MEM_ALLC_A(size, alig) ::aligned_alloc(alig, size)
  #define GAIA_MEM_FREE(ptr) ::free(ptr)
  #define GAIA_MEM_FREE_A(ptr) ::free(ptr)
#endif
 
namespace gaia {
  namespace mem {
    namespace detail {
      class ArenaLock final {
#if GAIA_ALLOC_ARENA_LOCK
        inline static std::atomic_int32_t s_lock{0};
#elif GAIA_ASSERT_ENABLED
        inline static std::atomic_flag s_entered = ATOMIC_FLAG_INIT;
        inline static std::atomic<std::thread::id> s_owner{};
  #if GAIA_ECS_TEST_HOOKS
        inline static std::atomic_uint32_t s_testViolations = 0;
  #endif
#endif
 
      public:
        ArenaLock() noexcept {
#if GAIA_ALLOC_ARENA_LOCK
          while (s_lock.exchange(1, std::memory_order_acquire) != 0) {
            while (s_lock.load(std::memory_order_relaxed) != 0)
  #if defined(__aarch64__)
              __asm__ volatile("yield");
  #else
              ;
  #endif
          }
#elif GAIA_ASSERT_ENABLED
          const auto me = std::this_thread::get_id();
          if (s_entered.test_and_set(std::memory_order_acquire)) {
            const auto other = s_owner.load(std::memory_order_relaxed);
  #if GAIA_ECS_TEST_HOOKS
            if (other != me)
              ++s_testViolations;
  #else
            // Same-thread re-entry is tolerated; a different thread means two Worlds
            // are allocating or freeing concurrently through the same process-wide arena.
            GAIA_ASSERT(
                other == me && "Allocation arena entered concurrently from two "
                               "threads. Define GAIA_ALLOC_ARENA_LOCK=1 to serialize the arenas, or "
                               "keep one mutating World per process.");
  #endif
          } else {
            s_owner.store(me, std::memory_order_relaxed);
          }
#endif
        }
 
        ~ArenaLock() noexcept {
#if GAIA_ALLOC_ARENA_LOCK
          s_lock.store(0, std::memory_order_release);
#elif GAIA_ASSERT_ENABLED
          s_entered.clear(std::memory_order_release);
#endif
        }
 
        ArenaLock(const ArenaLock&) = delete;
        ArenaLock& operator=(const ArenaLock&) = delete;
 
        GAIA_NODISCARD static uint32_t test_violations() noexcept {
#if !GAIA_ALLOC_ARENA_LOCK && GAIA_ASSERT_ENABLED && GAIA_ECS_TEST_HOOKS
          return s_testViolations.load(std::memory_order_relaxed);
#else
          return 0;
#endif
        }
      };
    } // namespace detail
 
    struct DefaultAllocator {
      GAIA_NODISCARD static void* alloc(size_t size) {
        GAIA_ASSERT(size > 0);
 
        void* ptr = GAIA_MEM_ALLC(size);
        GAIA_ASSERT(ptr != nullptr);
        GAIA_PROF_ALLOC(ptr, size);
        return ptr;
      }
 
      GAIA_NODISCARD static void* alloc([[maybe_unused]] const char* name, size_t size) {
        GAIA_ASSERT(size > 0);
 
        void* ptr = GAIA_MEM_ALLC(size);
        GAIA_ASSERT(ptr != nullptr);
        GAIA_PROF_ALLOC2(ptr, size, name);
        return ptr;
      }
 
      GAIA_NODISCARD static void* alloc_alig(size_t size, size_t alig) {
        GAIA_ASSERT(size > 0);
        GAIA_ASSERT(alig > 0);
 
        // Make sure size is a multiple of the alignment
        size = (size + alig - 1) & ~(alig - 1);
        void* ptr = GAIA_MEM_ALLC_A(size, alig);
        GAIA_ASSERT(ptr != nullptr);
        GAIA_PROF_ALLOC(ptr, size);
        return ptr;
      }
 
      GAIA_NODISCARD static void* alloc_alig([[maybe_unused]] const char* name, size_t size, size_t alig) {
        GAIA_ASSERT(size > 0);
        GAIA_ASSERT(alig > 0);
 
        // Make sure size is a multiple of the alignment
        size = (size + alig - 1) & ~(alig - 1);
        void* ptr = GAIA_MEM_ALLC_A(size, alig);
        GAIA_ASSERT(ptr != nullptr);
        GAIA_PROF_ALLOC2(ptr, size, name);
        return ptr;
      }
 
      static void free(void* ptr) {
        GAIA_ASSERT(ptr != nullptr);
 
        GAIA_MEM_FREE(ptr);
        GAIA_PROF_FREE(ptr);
      }
 
      static void free([[maybe_unused]] const char* name, void* ptr) {
        GAIA_ASSERT(ptr != nullptr);
 
        GAIA_MEM_FREE(ptr);
        GAIA_PROF_FREE2(ptr, name);
      }
 
      static void free_alig(void* ptr) {
        GAIA_ASSERT(ptr != nullptr);
 
        GAIA_MEM_FREE_A(ptr);
        GAIA_PROF_FREE(ptr);
      }
 
      static void free_alig([[maybe_unused]] const char* name, void* ptr) {
        GAIA_ASSERT(ptr != nullptr);
 
        GAIA_MEM_FREE_A(ptr);
        GAIA_PROF_FREE2(ptr, name);
      }
    };
 
    struct DefaultAllocatorAdaptor {
      static DefaultAllocator& get() {
        static DefaultAllocator s_allocator;
        return s_allocator;
      }
    };
 
    struct AllocHelper {
      template <typename T, typename Adaptor = DefaultAllocatorAdaptor>
      GAIA_NODISCARD static T* alloc(uint32_t cnt = 1) {
        return (T*)Adaptor::get().alloc(sizeof(T) * cnt);
      }
      template <typename T, typename Adaptor = DefaultAllocatorAdaptor>
      GAIA_NODISCARD static T* alloc(const char* name, uint32_t cnt = 1) {
        return (T*)Adaptor::get().alloc(name, sizeof(T) * cnt);
      }
      template <typename T, typename Adaptor = DefaultAllocatorAdaptor>
      GAIA_NODISCARD static T* alloc_alig(size_t alig, uint32_t cnt = 1) {
        return (T*)Adaptor::get().alloc_alig(sizeof(T) * cnt, alig);
      }
      template <typename T, typename Adaptor = DefaultAllocatorAdaptor>
      GAIA_NODISCARD static T* alloc_alig(const char* name, size_t alig, uint32_t cnt = 1) {
        return (T*)Adaptor::get().alloc_alig(name, sizeof(T) * cnt, alig);
      }
      template <typename Adaptor = DefaultAllocatorAdaptor>
      static void free(void* ptr) {
        Adaptor::get().free(ptr);
      }
      template <typename Adaptor = DefaultAllocatorAdaptor>
      static void free(const char* name, void* ptr) {
        Adaptor::get().free(name, ptr);
      }
      template <typename Adaptor = DefaultAllocatorAdaptor>
      static void free_alig(void* ptr) {
        Adaptor::get().free_alig(ptr);
      }
      template <typename Adaptor = DefaultAllocatorAdaptor>
      static void free_alig(const char* name, void* ptr) {
        Adaptor::get().free_alig(name, ptr);
      }
    };
 
    GAIA_NODISCARD inline void* mem_alloc(size_t size) {
      return DefaultAllocatorAdaptor::get().alloc(size);
    }
 
    GAIA_NODISCARD inline void* mem_alloc(const char* name, size_t size) {
      return DefaultAllocatorAdaptor::get().alloc(name, size);
    }
 
    GAIA_NODISCARD inline void* mem_alloc_alig(size_t size, size_t alig) {
      return DefaultAllocatorAdaptor::get().alloc_alig(size, alig);
    }
 
    GAIA_NODISCARD inline void* mem_alloc_alig(const char* name, size_t size, size_t alig) {
      return DefaultAllocatorAdaptor::get().alloc_alig(name, size, alig);
    }
 
    inline void mem_free(void* ptr) {
      DefaultAllocatorAdaptor::get().free(ptr);
    }
 
    inline void mem_free(const char* name, void* ptr) {
      DefaultAllocatorAdaptor::get().free(name, ptr);
    }
 
    inline void mem_free_alig(void* ptr) {
      DefaultAllocatorAdaptor::get().free_alig(ptr);
    }
 
    inline void mem_free_alig(const char* name, void* ptr) {
      DefaultAllocatorAdaptor::get().free_alig(name, ptr);
    }
 
    template <typename T, typename V>
    GAIA_NODISCARD constexpr T align(T num, V alignment) {
      return alignment == 0 ? num : ((num + (alignment - 1)) / alignment) * alignment;
    }
 
    template <size_t alignment, typename T>
    GAIA_NODISCARD constexpr T align(T num) {
      return ((num + (alignment - 1)) & ~(alignment - 1));
    }
 
    template <typename T, typename V>
    GAIA_NODISCARD constexpr uint32_t padding(T num, V alignment) {
      return (uint32_t)(align(num, alignment) - num);
    }
 
    template <size_t alignment, typename T>
    GAIA_NODISCARD constexpr uint32_t padding(T num) {
      return (uint32_t)(align<alignment>(num) - num);
    }
 
    template <typename Dst, typename Src>
    GAIA_NODISCARD Dst bit_cast(const Src& src) {
      static_assert(sizeof(Dst) == sizeof(Src));
      static_assert(std::is_trivially_copyable_v<Src>);
      static_assert(std::is_trivially_copyable_v<Dst>);
 
      // int i = {};
      // float f = *(*float)&i; // undefined behavior
      // memcpy(&f, &i, sizeof(float)); // okay
      Dst dst;
      memmove((void*)&dst, (const void*)&src, sizeof(Dst));
      return dst;
    }
 
    template <typename T>
    class unaligned_ref {
      void* m_p;
 
    public:
      unaligned_ref(void* p): m_p(p) {}
 
      unaligned_ref& operator=(const T& value) {
        memmove(m_p, (const void*)&value, sizeof(T));
        return *this;
      }
 
      GAIA_NODISCARD operator T() const {
        T tmp;
        memmove((void*)&tmp, (const void*)m_p, sizeof(T));
        return tmp;
      }
    };
  } // namespace mem
} // namespace gaia