MassEntityManagerStorage.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Async/TransactionallySafeMutex.h"
#include "Containers/ChunkedArray.h"
#include "Misc/TVariant.h"
#include "Templates/SharedPointer.h"
#include "MassProcessingTypes.h"
 
struct FMassArchetypeData;
struct FMassEntityHandle;
 
struct FMassEntityManager_InitParams_SingleThreaded {};
 
struct FMassEntityManager_InitParams_Concurrent
{
    uint32 MaxEntityCount = 1 << 30; // 1 billion
 
    uint32 MaxEntitiesPerPage = 1 << 16; // 65536
};
 
using FMassEntityManagerStorageInitParams = TVariant<FMassEntityManager_InitParams_SingleThreaded, FMassEntityManager_InitParams_Concurrent>;
 
namespace UE::Mass
{
    class IEntityStorageInterface
    {
    public:
        enum class EEntityState
        {
            Free,
            Reserved,
            Created
        };
        virtual ~IEntityStorageInterface() = default;
 
        virtual FMassArchetypeData* GetArchetype(int32 Index) = 0;
        virtual const FMassArchetypeData* GetArchetype(int32 Index) const = 0;
        virtual TSharedPtr<FMassArchetypeData>& GetArchetypeAsShared(int32 Index) = 0;
        virtual const TSharedPtr<FMassArchetypeData>& GetArchetypeAsShared(int32 Index) const = 0;
 
        virtual void SetArchetypeFromShared(int32 Index, TSharedPtr<FMassArchetypeData>& Archetype) = 0;
        virtual void SetArchetypeFromShared(int32 Index, const TSharedPtr<FMassArchetypeData>& Archetype) = 0;
 
        virtual EEntityState GetEntityState(int32 Index) const = 0;
 
        virtual int32 GetSerialNumber(int32 Index) const = 0;
 
        virtual bool IsValidIndex(int32 Index) const = 0;
 
        virtual bool IsValidHandle(FMassEntityHandle EntityHandle) const = 0;
 
        virtual bool IsEntityActive(FMassEntityHandle EntityHandle) const = 0;
 
        virtual SIZE_T GetAllocatedSize() const = 0;
 
        virtual bool IsValid(int32 Index) const = 0;
 
        virtual FMassEntityHandle AcquireOne() = 0;
 
        int32 Acquire(const int32 Count, TArray<FMassEntityHandle>& OutEntityHandles);
        virtual int32 Acquire(TArrayView<FMassEntityHandle> OutEntityHandles) = 0;
 
        virtual int32 Release(TConstArrayView<FMassEntityHandle> Handles) = 0;
        virtual int32 ReleaseOne(FMassEntityHandle Handles) = 0;
 
        virtual int32 ForceRelease(TConstArrayView<FMassEntityHandle> Handles) = 0;
        virtual int32 ForceReleaseOne(FMassEntityHandle Handle) = 0;
 
        virtual int32 Num() const = 0;
 
        virtual int32 ComputeFreeSize() const = 0;
    };
 
    //-----------------------------------------------------------------------------
    // FSingleThreadedEntityStorage
    //-----------------------------------------------------------------------------
    class FSingleThreadedEntityStorage final : public IEntityStorageInterface
    {
    public:
        void Initialize(const FMassEntityManager_InitParams_SingleThreaded&);
        virtual FMassArchetypeData* GetArchetype(int32 Index) override;
        virtual const FMassArchetypeData* GetArchetype(int32 Index) const override;
        virtual TSharedPtr<FMassArchetypeData>& GetArchetypeAsShared(int32 Index) override;
        virtual const TSharedPtr<FMassArchetypeData>& GetArchetypeAsShared(int32 Index) const override;
        virtual void SetArchetypeFromShared(int32 Index, TSharedPtr<FMassArchetypeData>&) override;
        virtual void SetArchetypeFromShared(int32 Index, const TSharedPtr<FMassArchetypeData>&) override;
        virtual EEntityState GetEntityState(int32 Index) const override;
        virtual int32 GetSerialNumber(int32 Index) const override;
        virtual bool IsValidIndex(int32 Index) const override;
        virtual bool IsValidHandle(FMassEntityHandle EntityHandle) const override;
        virtual bool IsEntityActive(FMassEntityHandle EntityHandle) const override;
        virtual SIZE_T GetAllocatedSize() const override;
        virtual bool IsValid(int32 Index) const override;
        virtual FMassEntityHandle AcquireOne() override;
        using IEntityStorageInterface::Acquire;
        virtual int32 Acquire(TArrayView<FMassEntityHandle> OutEntityHandles) override;
        virtual int32 Release(TConstArrayView<FMassEntityHandle> Handles) override;
        virtual int32 ReleaseOne(FMassEntityHandle Handle) override;
        virtual int32 ForceRelease(TConstArrayView<FMassEntityHandle> Handles) override;
        virtual int32 ForceReleaseOne(FMassEntityHandle Handle) override;
        virtual int32 Num() const override;
        virtual int32 ComputeFreeSize() const override;
 
    private:
        struct FEntityData
        {
            TSharedPtr<FMassArchetypeData> CurrentArchetype;
            int32 SerialNumber = 0;
 
            ~FEntityData();
            void Reset();
            bool IsValid() const;
        };
 
        std::atomic<int32> NextSerialNumber = 0;
 
        UE_AUTORTFM_ALWAYS_OPEN
        int32 GenerateSerialNumber()
        {
            // The serial number only needs to be unique; it doesn't need to be rolled back if an AutoRTFM transaction fails.
            return NextSerialNumber.fetch_add(1);
        }
 
        TChunkedArray<FEntityData> Entities;
        TArray<int32> EntityFreeIndexList;
    };
 
    //-----------------------------------------------------------------------------
    // FConcurrentEntityStorage
    //-----------------------------------------------------------------------------
    class FConcurrentEntityStorage final : public IEntityStorageInterface
    {
    public:
 
        void Initialize(const FMassEntityManager_InitParams_Concurrent& InInitializationParams);
 
        virtual ~FConcurrentEntityStorage() override;
 
        virtual FMassArchetypeData* GetArchetype(int32 Index) override;
        virtual const FMassArchetypeData* GetArchetype(int32 Index) const override;
        virtual TSharedPtr<FMassArchetypeData>& GetArchetypeAsShared(int32 Index) override;
        virtual const TSharedPtr<FMassArchetypeData>& GetArchetypeAsShared(int32 Index) const override;
        virtual void SetArchetypeFromShared(int32 Index, TSharedPtr<FMassArchetypeData>& Archetype) override;
        virtual void SetArchetypeFromShared(int32 Index, const TSharedPtr<FMassArchetypeData>& Archetype) override;
        virtual EEntityState GetEntityState(int32 Index) const override;
        virtual int32 GetSerialNumber(int32 Index) const override;
        virtual bool IsValidIndex(int32 Index) const override;
        virtual bool IsValidHandle(FMassEntityHandle EntityHandle) const override;
        virtual bool IsEntityActive(FMassEntityHandle EntityHandle) const override;
        virtual SIZE_T GetAllocatedSize() const override;
        virtual bool IsValid(int32 Index) const override;
        virtual FMassEntityHandle AcquireOne() override;
        using IEntityStorageInterface::Acquire;
        virtual int32 Acquire(TArrayView<FMassEntityHandle> OutEntityHandles) override;
        virtual int32 Release(TConstArrayView<FMassEntityHandle> Handles) override;
        virtual int32 ReleaseOne(FMassEntityHandle Handle) override;
        virtual int32 ForceRelease(TConstArrayView<FMassEntityHandle> Handles) override;
        virtual int32 ForceReleaseOne(FMassEntityHandle Handle) override;
        virtual int32 Num() const override;
        virtual int32 ComputeFreeSize() const override;
#if WITH_MASSENTITY_DEBUG
        MASSENTITY_API static bool DebugAssumptionsSelfTest();
#endif // WITH_MASSENTITY_DEBUG
    private:
 
        struct FEntityData
        {
            static constexpr int MaxGenerationBits = 30;
 
            TSharedPtr<FMassArchetypeData> CurrentArchetype;
            uint32 GenerationId : MaxGenerationBits = 0;
            uint32 bIsAllocated : 1 = 0;
 
            ~FEntityData();
            int32 GetSerialNumber() const;
 
            bool operator==(const FEntityData& Other) const;
        };
 
        EEntityState GetEntityStateInternal(const FEntityData& EntityData) const;
 
        FEntityData& LookupEntity(int32 Index);
        const FEntityData& LookupEntity(int32 Index) const;
 
        uint64 ComputePageSize() const;
 
        bool AddPage();
 
        uint32 EntityCount = 0;
        uint32 MaximumEntityCountShift = 0;
        uint32 MaxEntitiesPerPage = 0;
        uint32 MaxEntitiesPerPageShift = 0;
        uint32 PageCount = 0;
        UE::FTransactionallySafeMutex PageAllocateMutex;
        FEntityData** EntityPages = nullptr;
 
        TArray<int32> EntityFreeIndexList;
        UE::FTransactionallySafeMutex FreeListMutex;
    };
 
} // namespace UE::Mass