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
 
    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(uint inSize) :
        mBase(static_cast<uint8 *>(AlignedAllocate(inSize, JPH_RVECTOR_ALIGNMENT))),
        mSize(inSize)
    {
    }
 
    virtual                         ~TempAllocatorImpl() override
    {
        JPH_ASSERT(mTop == 0);
        AlignedFree(mBase);
    }
 
    // See: TempAllocator
    virtual void *                  Allocate(uint inSize) override
    {
        if (inSize == 0)
        {
            return nullptr;
        }
        else
        {
            uint new_top = mTop + AlignUp(inSize, JPH_RVECTOR_ALIGNMENT);
            if (new_top > mSize)
            {
                Trace("TempAllocator: Out of memory");
                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;
    }
 
    uint                            GetSize() const
    {
        return mSize;
    }
 
    uint                            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;                          
    uint                            mSize;                          
    uint                            mTop = 0;                       
};
 
class JPH_EXPORT TempAllocatorMalloc final : public TempAllocator
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
    // See: TempAllocator
    virtual void *                  Allocate(uint inSize) override
    {
        return inSize > 0? AlignedAllocate(inSize, JPH_RVECTOR_ALIGNMENT) : nullptr;
    }
 
    // See: TempAllocator
    virtual void                    Free(void *inAddress, [[maybe_unused]] uint inSize) override
    {
        if (inAddress != nullptr)
            AlignedFree(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