UObjectAllocator.h

Go to the documentation of this file.

 
/*=============================================================================
    UnObjAllocator.h: Unreal object allocation
=============================================================================*/
 
// This system needs further writing to conform with UE
// https://github.com/ravimohan1991/KarmaEngine/discussions/10
 
#pragma once
 
#include "KarmaTypes.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)
        {
        }
 
        ~FUObjectAllocator();

        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);

        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;
}