MediaObjectPool.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Queue.h"
#include "Misc/ScopeLock.h"
#include "Templates/SharedPointer.h"
#include "Templates/UniquePtr.h"
 
 
class IMediaPoolable
{
public:
 
    virtual void InitializePoolable() { }
 
    virtual void ShutdownPoolable() { }
 
    virtual bool IsReadyForReuse()
    {
        return true;
    }
 
public:
 
    virtual ~IMediaPoolable() { }
};
 
 
template<typename ObjectType> class TMediaPoolDefaultObjectAllocator
{
public:
    static ObjectType *Alloc() { return new ObjectType; }
};
 
template<typename ObjectType, typename ObjectAllocator=TMediaPoolDefaultObjectAllocator<ObjectType>>
class TMediaObjectPool
{
    static_assert(TPointerIsConvertibleFromTo<ObjectType, IMediaPoolable>::Value, "Poolable objects must implement the IMediaPoolable interface.");
 
    class TStorage
    {
    public:
        TStorage(ObjectAllocator *InObjectAllocatorInstance)
            : ObjectAllocatorInstance(InObjectAllocatorInstance)
        {}
 
        ~TStorage()
        {
            Reserve(0);
            ObjectType* Object;
            while (WaitReadyForReuse.Dequeue(Object))
            {
                Object->ShutdownPoolable();
                delete Object;
            }
        }
 
    public:
 
        ObjectType* Acquire(bool bAlloc = true)
        {
            ObjectType* Result = nullptr;
            {
                FScopeLock Lock(&CriticalSection);
 
                if (Pool.Num() > 0)
                {
                    Result = Pool.Pop(EAllowShrinking::No);
                }
                else
                {
                    // Check for objects to ready to enter the pool & grab the first we find as our result...
                    // (we move all into the pool, we can to possibly safe on resources allocated by the objects)
                    ObjectType* PeekObject;
                    while (WaitReadyForReuse.Peek(PeekObject))
                    {
                        if (!PeekObject->IsReadyForReuse())
                        {
                            break;
                        }
 
                        WaitReadyForReuse.Pop();
                        PeekObject->ShutdownPoolable();
                        if (!Result)
                        {
                            Result = PeekObject;
                        }
                        else
                        {
                            Pool.Add(PeekObject);
                        }
                    }
                }
            }
 
            if (Result == nullptr && bAlloc)
            {
                Result = ObjectAllocatorInstance->Alloc();
            }
            else
            {
                return Result;
            }
            
            Result->InitializePoolable();
 
            return Result;
        }
 
        int32 Num() const
        {
            FScopeLock Lock(&CriticalSection);
            return Pool.Num();
        }
 
        void Release(ObjectType* Object)
        {
            if (Object == nullptr)
            {
                return;
            }
 
            FScopeLock Lock(&CriticalSection);
 
            if (Object->IsReadyForReuse())
            {
                Object->ShutdownPoolable();
                Pool.Push(Object);
            }
            else
            {
                WaitReadyForReuse.Enqueue(Object);
            }
        }
 
        void Reserve(uint32 NumObjects)
        {
            FScopeLock Lock(&CriticalSection);
 
            while (NumObjects < (uint32)Pool.Num())
            {
                delete Pool.Pop(EAllowShrinking::No);
            }
 
            while (NumObjects > (uint32)Pool.Num())
            {
                Pool.Push(ObjectAllocatorInstance->Alloc());
            }
        }
 
        void Tick()
        {
            if (WaitReadyForReuse.IsEmpty())
            {
                // Conservative early out to avoid CS: we will get any items missed the next time around
                return;
            }
 
            FScopeLock Lock(&CriticalSection);
 
            ObjectType* Object;
            while (WaitReadyForReuse.Peek(Object))
            {
                if (!Object->IsReadyForReuse())
                {
                    break;
                }
 
                Object->ShutdownPoolable();
                Pool.Push(Object);
                WaitReadyForReuse.Pop();
            }
        }
 
    private:
 
        mutable FCriticalSection CriticalSection;
 
        TArray<ObjectType*> Pool;
 
        TQueue<ObjectType*> WaitReadyForReuse;
 
        ObjectAllocator *ObjectAllocatorInstance;
    };
 
 
    class TDeleter
    {
    public:
 
        TDeleter(const TSharedRef<TStorage, ESPMode::ThreadSafe>& InStorage)
            : StoragePtr(InStorage)
        { }
 
        void operator()(ObjectType* ObjectToDelete)
        {
            TSharedPtr<TStorage, ESPMode::ThreadSafe> PinnedStorage = StoragePtr.Pin();
 
            if (PinnedStorage.IsValid())
            {
                PinnedStorage->Release(ObjectToDelete);
            }
            else
            {
                delete ObjectToDelete;
            }
        }
 
    private:
 
        TWeakPtr<TStorage, ESPMode::ThreadSafe> StoragePtr;
    };
 
public:
 
    TMediaObjectPool(ObjectAllocator *ObjectAllocatorInstance = nullptr)
        : Storage(MakeShareable(new TStorage(ObjectAllocatorInstance)))
    { }
 
    TMediaObjectPool(uint32 NumReserve)
        : Storage(MakeShareable(new TStorage(nullptr)))
    {
        Storage->Reserve(NumReserve);
    }
 
public:
 
    ObjectType* Acquire(bool bAlloc = true)
    {
        return Storage->Acquire(bAlloc);
    }
 
    TSharedRef<ObjectType, ESPMode::ThreadSafe> AcquireShared()
    {
        ObjectType* Object = Acquire(true);
        check(Object != nullptr);
        return MakeShareable(Object, TDeleter(Storage));
    }
 
    TSharedPtr<ObjectType, ESPMode::ThreadSafe> AcquireShared(bool bAlloc)
    {
        ObjectType* Object = Acquire(bAlloc);
        if (!Object && !bAlloc)
        {
            return nullptr;
        }
        check(Object != nullptr);
 
        return MakeShareable(Object, TDeleter(Storage));
    }
 
    int32 Num() const
    {
        return Storage->Num();
    }
 
    TSharedRef<ObjectType, ESPMode::ThreadSafe> ToShared(ObjectType* Object)
    {
        return MakeShareable(Object, TDeleter(Storage));
    }
 
    void Release(ObjectType* Object)
    {
        Storage->Release(Object);
    }
 
    void Reset(uint32 NumObjects = 0)
    {
        Storage->Reserve(NumObjects);
    }
 
    void Tick()
    {
        Storage->Tick();
    }
 
private:
 
    TSharedRef<TStorage, ESPMode::ThreadSafe> Storage;
};