Short Term Memory

Funny thing about doing your own tech is that you sometimes need to do some funny stuff. This week I needed done Short Term Memory Manager. My comment in code describe it like this:

Short Term Memory Manager (STM Manager). 
STM is memory which you want to use for short one-shot tasks: 
            Create->Execute->[GetResult]->Destroy 
It is limited by capacity so you never can use more than you pre-allocated for it. Right now it's use to transfer resource data CPU->GPU and in animations tasks.

For me this is temporary memory which I use for example to load texture data and then passing it to GPU upload (which will remove it). There are also other usage where I think using normal allocation would be a little bit overkill.

So my short term memory manager use my new memory ring buffer which look like this:

wrMemoryRingBuffer.h

#pragma once

/*
==========================================================================
This is simple ring buffer for memory. It alloc/free work as FIFO.

Inside this ring buffer there is only small overhead of memory header
(only 4 bytes which indicate size of allocation) which make it really
cheap allocator (performance and memory).
==========================================================================
*/
class wrMemoryRingBuffer
{
public:
    /** @brief   Memory size which is use with each allocation for memory header. */
    static uint32               getAllocHeaderSize( void ) { return sizeof(uint32); }

                                wrMemoryRingBuffer( void );
                                ~wrMemoryRingBuffer( void );

    /** @brief Initialize ring buffer with given amount of memory. */
    void                        init( EMemType::Enum a_memType, uint32 a_sizeInBytes );
    /** @brief Reset ring buffer (don't release memory). */
    void                        reset( void );
    /** @brief Delete memory of ring buffer . */
    void                        destroy( void );

    /** @brief Allocate N-bytes of memory. */
    void*                       alloc( size_t a_NBytes );
    /** @brief Release head allocation. */
    void                        free( void );

    /** @brief Peek into memory of head allocation. */
    const void*                 peek( void ) const;
    /** @brief Peek into size of head allocation. */
    uint32                      peekSize( void ) const;

    /** @brief   Return memory of biggest possible allocation.
        @remarks It return size of continuous memory with taking into account memory need for header. */
    uint32                      getBiggestAllocSize( void ) const;

    /** @brief Return a_sizeInBytes from wrMemoryRingBuffer::init(...). */
    WR_INLINE uint32            capacity( void )
    { 
        return m_capacity*sizeof(uint32);
    }

    /** @brief Check if given memory is contain inside this ring buffer. */
    WR_INLINE bool              contain( const void* a_ptr ) const
    { 
        return m_memory <= a_ptr && a_ptr < m_memory+m_capacity;
    }
private:
    uint32*                     m_memory;
    uint32                      m_capacity;
    uint32                      m_head;
    uint32                      m_ptr;
    uint32                      m_wrap;
};

wrMemoryRingBuffer.cpp

#include "wrBase_pch.h"
#include "wrBase/math/wrMath.h"
#include "wrBase/src/wrMemoryManager.h"
#include "wrBase/src/wrMemoryRingBuffer.h"

//////////////////////////////////////////////////////////////////////////
static uint32 bytesToInts( uint32 a_sizeInBytes )
{
    return (a_sizeInBytes+sizeof(uint32)-1)/sizeof(uint32);
}

//////////////////////////////////////////////////////////////////////////
wrMemoryRingBuffer::wrMemoryRingBuffer( void )
    : m_memory(nullptr)
{
}

//////////////////////////////////////////////////////////////////////////
wrMemoryRingBuffer::~wrMemoryRingBuffer( void )
{
    destroy();
}

//////////////////////////////////////////////////////////////////////////
void wrMemoryRingBuffer::init( EMemType::Enum a_memType, uint32 a_sizeInBytes )
{
    // Capacity is the amount ints in ring buffer
    m_capacity = bytesToInts(a_sizeInBytes);
    m_memory = wrNew(a_memType) uint32 [m_capacity];
    reset();
}
//////////////////////////////////////////////////////////////////////////
void wrMemoryRingBuffer::reset(void)
{
    m_head = m_ptr  = 0U;
    m_wrap = m_capacity;
}

//////////////////////////////////////////////////////////////////////////
void wrMemoryRingBuffer::destroy( void )
{
    SAFE_DELETE_ARRAY(m_memory);
}

//////////////////////////////////////////////////////////////////////////
void* wrMemoryRingBuffer::alloc( size_t a_sizeInBytes )
{
    WR_ERROR(m_memory, "Try of using uninitialized memory ring.");

    if (!m_memory)
    {
        return nullptr;
    }

    WR_CRITICAL(a_sizeInBytes + getAllocHeaderSize() < m_capacity*sizeof(uint32), "How you expect this to work?");

    // We checking if we have enough memory to allocate.
    const uint32 biggestMemSize = getBiggestAllocSize();
    if (biggestMemSize < a_sizeInBytes)
    {
        return nullptr;
    }

    // We calculate size of (allocation + memory header) in int's 
    uint32 sizeInInts = bytesToInts(a_sizeInBytes) + bytesToInts(getAllocHeaderSize());

    // We check if we need to wrap around end of memory
    // (there is not enough memory at the end)
    if (m_ptr <= m_wrap && m_wrap < m_ptr+sizeInInts )
    {
        m_wrap = m_ptr;
    }

    // We store size of allocation in memory.
    m_memory[m_ptr%m_wrap] = a_sizeInBytes;
    // We moving memory ptr.
    uint32 ptr = m_ptr + 1;
    m_ptr += sizeInInts;
    // And return allocated buffer.
    return m_memory + (ptr%m_wrap);
}

//////////////////////////////////////////////////////////////////////////
void wrMemoryRingBuffer::free( void )
{
    uint32 sizeInBytes = m_memory[m_head];
    m_head += 1 + bytesToInts(sizeInBytes);

    WR_CRITICAL(m_head <= m_ptr, "Releasing of unallocated memory")

    // If head passed wrap we can wrap it and release extra memory behind wrap.
    if (m_head >= m_wrap)
    {
        m_head -= m_wrap;
        m_ptr  -= m_wrap;
        m_wrap  = m_capacity;
    }
}

//////////////////////////////////////////////////////////////////////////
const void* wrMemoryRingBuffer::peek(void) const
{
    return (m_head == m_ptr) ? nullptr : m_memory + m_head + 1;
}
//////////////////////////////////////////////////////////////////////////
uint32 wrMemoryRingBuffer::peekSize(void) const
{
    return (m_head == m_ptr) ? 0 : m_memory[m_head];
}

//////////////////////////////////////////////////////////////////////////
uint32 wrMemoryRingBuffer::getBiggestAllocSize( void ) const
{
    using namespace wre::math;

    int32 mem = (m_wrap > m_ptr) ? max<int32>(m_wrap-m_ptr, m_head) // 1. |   |XXXX|   | - There are two different continuous memory on begin and on end separated by existing allocation 
                                 : m_head-(m_ptr%m_wrap);           // 2. |XXX|    |XXX| - There is only one continuous memory in middle.

    return max<int32>(0, mem*sizeof(uint32)-getAllocHeaderSize());
}

After creating this code the rest was easy:

    //////////////////////////////////////////////////////////////////////////
    uint8* CShortTermMemoryMgr::cpuAlloc( uint32 a_Nbytes, uint32 a_alignment )
    {
        // memory is HEADER + ALIGNMENT_MEMORY(ALIGNMENT-1) + HEADER_OFFSET(+1) + a_Nbytes
        uint32 memorySize = sizeof(SHeaderCPU) + a_alignment +a_Nbytes;

        uint8* memory = nullptr;

        {
            CMutexAutoLock lock(m_cpuMutex);

            memory = (uint8*)m_cpuMemory.alloc(memorySize);

            if (!memory)
            {
                if (cpuRecoverMemory(memorySize))
                {
                    memory = (uint8*)m_cpuMemory.alloc(memorySize);
                }
                else
                {
                    WR_ERROR(false, "There is not enough memory for this allocation.");
                    return nullptr;
                }
            }
        }

        // Create memory header
        SHeaderCPU* header = (SHeaderCPU*)memory;
        header->isUse = true;
        header->size = a_Nbytes;

        // Fill offset info
        uint8* data = wrAlignAdress(memory + sizeof(SHeaderCPU)+1, a_alignment);
        data[-1] = static_cast<uint8>(data-memory);

        return data; 
    }

    //////////////////////////////////////////////////////////////////////////
    void CShortTermMemoryMgr::cpuFree( uint8* memory )
    {
        if (memory)
        {
            CMutexAutoLock lock(m_cpuMutex);
            SHeaderCPU* header = (SHeaderCPU*)(memory - memory[-1]);
            header->isUse = false;
        }
    }
    //////////////////////////////////////////////////////////////////////////
    bool CShortTermMemoryMgr::cpuRecoverMemory( uint32 a_memoryNeed )
    {
        const void* memory = nullptr;

        while(m_cpuMemory.getBiggestAllocSize() < a_memoryNeed && (memory = m_cpuMemory.peek()))
        {
            const SHeaderCPU* header = (const SHeaderCPU*)memory;

            if (!header->isUse)
            {
                m_cpuMemory.free();
            }
            else
            {
                break;
            }
        }

        return m_cpuMemory.getBiggestAllocSize() >= a_memoryNeed;
    }

I added also two helper functions:

    
    template<class t="">
    T* CShortTermMemoryMgr::cpuAllocT( uint32 a_alignment )
    {
        if (uint8* memory = cpuAlloc(sizeof(T), a_alignment))
        {
            return wrNewExt(memory) T;
        }

        return nullptr;
    }

    template<class t="">
    void CShortTermMemoryMgr::cpuFreeT( T* a_memory )
    {
        if (a_memory)
        {
            a_memory->~T();
            cpuFree((uint8*)a_memory);
        }
    }

And this finalized my work :] Personally I really like how this came out. Its simple and pretty efficient but well I'm curious what you think about this? Maybe you have some betters idea how to resolve problems like this?

Greg