UObjectAllocator.h

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    UnObjAllocator.h: Unreal object allocation
=============================================================================*/
 
// This system needs further writing to conform with UE
// https://github.com/ravimohan1991/KarmaEngine/discussions/10
 
#pragma once
 
#include "krpch.h"
 
namespace Karma
{
    class UObjectBase;
 
    typedef void (*FUObjectAllocatorCallback)(void* InObject, const std::string& InName, size_t InSize, size_t InAlignment, class UClass* InClass);
 
    template <typename T>
    struct TIsIntegral
    {
        enum { Value = false };
    };
 
    template <> struct TIsIntegral<         bool> { enum { Value = true }; };
    template <> struct TIsIntegral<         char> { enum { Value = true }; };
    template <> struct TIsIntegral<signed   char> { enum { Value = true }; };
    template <> struct TIsIntegral<unsigned char> { enum { Value = true }; };
    template <> struct TIsIntegral<         char16_t> { enum { Value = true }; };
    template <> struct TIsIntegral<         char32_t> { enum { Value = true }; };
    template <> struct TIsIntegral<         wchar_t> { enum { Value = true }; };
    template <> struct TIsIntegral<         short> { enum { Value = true }; };
    template <> struct TIsIntegral<unsigned short> { enum { Value = true }; };
    template <> struct TIsIntegral<         int> { enum { Value = true }; };
    template <> struct TIsIntegral<unsigned int> { enum { Value = true }; };
    template <> struct TIsIntegral<         long> { enum { Value = true }; };
    template <> struct TIsIntegral<unsigned long> { enum { Value = true }; };
    template <> struct TIsIntegral<         long long> { enum { Value = true }; };
    template <> struct TIsIntegral<unsigned long long> { enum { Value = true }; };
 
    template <typename T> struct TIsIntegral<const          T> { enum { Value = TIsIntegral<T>::Value }; };
    template <typename T> struct TIsIntegral<      volatile T> { enum { Value = TIsIntegral<T>::Value }; };
    template <typename T> struct TIsIntegral<const volatile T> { enum { Value = TIsIntegral<T>::Value }; };
 
    template <typename T>
    struct TIsPointer
    {
        enum { Value = false };
    };
 
    template <typename T> struct TIsPointer<T*> { enum { Value = true }; };
 
    template <typename T> struct TIsPointer<const          T> { enum { Value = TIsPointer<T>::Value }; };
    template <typename T> struct TIsPointer<      volatile T> { enum { Value = TIsPointer<T>::Value }; };
    template <typename T> struct TIsPointer<const volatile T> { enum { Value = TIsPointer<T>::Value }; };
 
    template <typename T>
    FORCEINLINE constexpr T Align(T Val, uint64_t Alignment)
    {
        KR_CORE_ASSERT(TIsIntegral<T>::Value || TIsPointer<T>::Value, "Align expects an integer or pointer type");
 
        return (T)(((uint64_t)Val + Alignment - 1) & ~(Alignment - 1));
    }
 
    class FUObjectAllocator
    {
    public:
 
        FUObjectAllocator() :
            m_PermanentObjectPoolSize(0),
            m_PermanentObjectPool(nullptr),
            m_PermanentObjectPoolTail(nullptr),
            m_PermanentObjectPoolExceededTail(nullptr)
        {
        }
 
        void AllocatePermanentObjectPool(int32_t InPermanentObjectPoolSize);
 
        void Initialize(uint8_t* pMemoryStart, size_t elemetSizeBytes, size_t numberOfElemets);
 
        void BootMessage();
 
        FORCEINLINE bool ResidesInPermanentPool(const UObjectBase* Object) const
        {
            return ((const uint8_t*)Object >= m_PermanentObjectPool) && ((const uint8_t*)Object < m_PermanentObjectPoolTail);
        }
 
        UObjectBase* AllocateUObject(size_t Size, size_t Alignment, bool bAllowPermanent);
 
        void DumpUObjectsInformation(void* InObject, const std::string& InName, size_t InSize, size_t InAlignment, class UClass* InClass);
 
        /*
         * Routine for registering callback function for statistics purposes
         * 
         * @see FUObjectAllocator::DumpUObjectsInformation
         */
        void RegisterUObjectsStatisticsCallback(FUObjectAllocatorCallback dumpCallback);
 
        //void FreeUObject(UObjectBase* Object) const;
 
        //
        // Getters
        //
        uint8_t* GetPermanentObjectPoolTail() const { return m_PermanentObjectPoolTail; }
 
        uint8_t* GetPermanentObjectPool() const { return m_PermanentObjectPool; }
 
        uint32_t GetPermanentPoolSize() const { return m_PermanentObjectPoolSize; }
 
        uint8_t* GetPermanentObjectPoolEnd() const { return m_PermanentObjectPoolEnd; }
 
        uint32_t GetBareUObjectSize() const { return m_BareUObjectsSize; }
 
        uint32_t GetAlignedUObjectSize() const { return m_AlignedUObjectsSize; }
 
        uint32_t GetNumberOfUObjects() const { return m_NumberOfUObjects; }
 
    private:
 
        int32_t                         m_PermanentObjectPoolSize;
 
        uint8_t*                        m_PermanentObjectPool;
 
        uint8_t*                        m_PermanentObjectPoolTail;
 
        uint8_t*                        m_PermanentObjectPoolEnd;
 
        uint8_t*                        m_PermanentObjectPoolExceededTail;
 
        uint32_t                        m_BareUObjectsSize;
 
        uint32_t                        m_AlignedUObjectsSize;
 
        uint32_t                        m_NumberOfUObjects;
 
        KarmaVector<FUObjectAllocatorCallback> m_DumpingCallbacks;
    };
 
    extern KARMA_API FUObjectAllocator GUObjectAllocator;
}