TempAllocator.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Jolt/Core/NonCopyable.h>
 
JPH_NAMESPACE_BEGIN
 
class JPH_EXPORT TempAllocator : public NonCopyable
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
    static constexpr bool           needs_aligned_allocate = JPH_RVECTOR_ALIGNMENT > __STDCPP_DEFAULT_NEW_ALIGNMENT__;
 
    virtual                         ~TempAllocator() = default;
 
    virtual void *                  Allocate(uint inSize) = 0;
 
    virtual void                    Free(void *inAddress, uint inSize) = 0;
};
 
class JPH_EXPORT TempAllocatorImpl final : public TempAllocator
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
    explicit                        TempAllocatorImpl(size_t inSize) : mSize(inSize)
    {
        if constexpr (needs_aligned_allocate)
            mBase = static_cast<uint8 *>(AlignedAllocate(inSize, JPH_RVECTOR_ALIGNMENT));
        else
            mBase = static_cast<uint8 *>(JPH::Allocate(inSize));
    }
 
    virtual                         ~TempAllocatorImpl() override
    {
        JPH_ASSERT(mTop == 0);
        if constexpr (needs_aligned_allocate)
            AlignedFree(mBase);
        else
            JPH::Free(mBase);
    }
 
    // See: TempAllocator
    virtual void *                  Allocate(uint inSize) override
    {
        if (inSize == 0)
        {
            return nullptr;
        }
        else
        {
            size_t new_top = mTop + AlignUp(inSize, JPH_RVECTOR_ALIGNMENT);
            if (new_top > mSize)
            {
                Trace("TempAllocator: Out of memory trying to allocate %u bytes", inSize);
                std::abort();
            }
            void *address = mBase + mTop;
            mTop = new_top;
            return address;
        }
    }
 
    // See: TempAllocator
    virtual void                    Free(void *inAddress, uint inSize) override
    {
        if (inAddress == nullptr)
        {
            JPH_ASSERT(inSize == 0);
        }
        else
        {
            mTop -= AlignUp(inSize, JPH_RVECTOR_ALIGNMENT);
            if (mBase + mTop != inAddress)
            {
                Trace("TempAllocator: Freeing in the wrong order");
                std::abort();
            }
        }
    }
 
    bool                            IsEmpty() const
    {
        return mTop == 0;
    }
 
    size_t                          GetSize() const
    {
        return mSize;
    }
 
    size_t                          GetUsage() const
    {
        return mTop;
    }
 
    bool                            CanAllocate(uint inSize) const
    {
        return mTop + AlignUp(inSize, JPH_RVECTOR_ALIGNMENT) <= mSize;
    }
 
    bool                            OwnsMemory(const void *inAddress) const
    {
        return inAddress >= mBase && inAddress < mBase + mSize;
    }
 
private:
    uint8 *                         mBase;                          
    size_t                          mSize;                          
    size_t                          mTop = 0;                       
};
 
class JPH_EXPORT TempAllocatorMalloc final : public TempAllocator
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
    // See: TempAllocator
    virtual void *                  Allocate(uint inSize) override
    {
        if (inSize > 0)
        {
            if constexpr (needs_aligned_allocate)
                return AlignedAllocate(inSize, JPH_RVECTOR_ALIGNMENT);
            else
                return JPH::Allocate(inSize);
        }
        else
            return nullptr;
    }
 
    // See: TempAllocator
    virtual void                    Free(void *inAddress, [[maybe_unused]] uint inSize) override
    {
        if (inAddress != nullptr)
        {
            if constexpr (needs_aligned_allocate)
                AlignedFree(inAddress);
            else
                JPH::Free(inAddress);
        }
    }
};
 
class JPH_EXPORT TempAllocatorImplWithMallocFallback final : public TempAllocator
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
    explicit                        TempAllocatorImplWithMallocFallback(uint inSize) :
        mAllocator(inSize)
    {
    }
 
    // See: TempAllocator
    virtual void *                  Allocate(uint inSize) override
    {
        if (mAllocator.CanAllocate(inSize))
            return mAllocator.Allocate(inSize);
        else
            return mFallbackAllocator.Allocate(inSize);
    }
 
    // See: TempAllocator
    virtual void                    Free(void *inAddress, uint inSize) override
    {
        if (inAddress == nullptr)
        {
            JPH_ASSERT(inSize == 0);
        }
        else
        {
            if (mAllocator.OwnsMemory(inAddress))
                mAllocator.Free(inAddress, inSize);
            else
                mFallbackAllocator.Free(inAddress, inSize);
        }
    }
 
private:
    TempAllocatorImpl               mAllocator;
    TempAllocatorMalloc             mFallbackAllocator;
};
 
JPH_NAMESPACE_END