stk::memory::MemoryAllocator Class Reference

Memory allocator for allocating dynamic memory. More...

#include <stk_memory_allocator.h>

Classes
class	Stats
	Snapshot of the memory allocator's statistics. More...

Static Public Member Functions
static void *	Allocate (size_t size) __stk_weak
	Allocate the memory chunk.
static void	Free (void *ptr) __stk_weak
	Free the memory chunk.
static Stats	GetStats () __stk_weak
	Get stats of memory allocation.
template<typename TElement, typename... TArgs>
static TElement *	AllocateOneT (TArgs &&...args)
	Allocate a single element and construct it in-place.
template<typename TElement, typename... TArgs>
static TElement *	AllocateArrayT (size_t count, TArgs &&...args)
	Allocate an array of elements and default/copy-construct each one.
template<typename TElement>
static void	FreeOneT (TElement *ptr)
	Destroy and free a single element allocated via AllocateOne().
template<typename TElement>
static void	FreeArrayT (TElement *ptr, size_t count)
	Destroy and free an array allocated via AllocateT().

Static Public Attributes
static const size_t	CAPACITY_DEFAULT = 12288U
	Default memory pool capacity in bytes.

Detailed Description

Memory allocator for allocating dynamic memory.

Note

STK does not use dynamic memory allocation but some auxiliary classes may provide such functionality for convenience. In this case you must provide your own implementation of MemoryAllocator::Allocate() and MemoryAllocator::Free(). By default STK does not provide any implementation, therefore you will get a linker error if these two functions are left unimplemented.

Example of your trivial implementation:

void *MemoryAllocator::Allocate(size_t size)
{
    return malloc(size);
}
void MemoryAllocator::Free(void *ptr)
{
    free(ptr);
}

Definition at line 55 of file stk_memory_allocator.h.

Member Function Documentation

Allocate()

void * stk::memory::MemoryAllocator::Allocate ( size_t size )

static

Allocate the memory chunk.

Parameters

[in]

size

Size of the memory chunk.

Returns

Pointer to the allocated memory chunk, nullptr if allocator failed to allocate it.

Definition at line 44 of file stk_c_memory.cpp.

{ return malloc(size); }

References malloc().

Referenced by AllocateArrayT(), AllocateOneT(), and pvPortMalloc().

Here is the call graph for this function:

Here is the caller graph for this function:

AllocateArrayT()

template<typename TElement, typename... TArgs>

TElement * stk::memory::MemoryAllocator::AllocateArrayT ( size_t count, TArgs &&... args )

inlinestatic

Allocate an array of elements and default/copy-construct each one.

Parameters

[in]	count	Number of elements to allocate.
[in]	args	Constructor arguments forwarded to every element.

Returns

Pointer to the first element, nullptr if allocation failed or count is 0.

Note

Pair with FreeArrayT<TElement>() passing the same count to properly invoke destructors.

Definition at line 158 of file stk_memory_allocator.h.

    {
        TElement *ptr = nullptr;
      
        if (count != 0U)
        {
            STK_ASSERT(Allocate != nullptr);
 
            ptr = reinterpret_cast<TElement *>(Allocate(count * sizeof(TElement)));
            if (ptr != nullptr)
            {
                if __stk_constexpr_cpp17 (!std::is_trivially_constructible<TElement, TArgs...>())
                {
                    for (size_t i = 0U; i < count; ++i)
                    {
                        auto const elm = new (&ptr[i]) TElement(static_cast<TArgs &&>(args)...);
                        STK_UNUSED(elm);
                    }
                }
            }
        }
 
        return ptr;
    }

References __stk_constexpr_cpp17, Allocate(), STK_ASSERT, and STK_UNUSED.

Here is the call graph for this function:

AllocateOneT()

template<typename TElement, typename... TArgs>

TElement * stk::memory::MemoryAllocator::AllocateOneT ( TArgs &&... args )

inlinestatic

Allocate a single element and construct it in-place.

Parameters

[in]

args

Constructor arguments forwarded to TElement.

Returns

Pointer to the constructed element, nullptr if allocation failed.

Note

Pair with FreeOneT<TElement>() to properly invoke the destructor.

Definition at line 134 of file stk_memory_allocator.h.

    {
        STK_ASSERT(Allocate != nullptr);
 
        TElement *ptr = reinterpret_cast<TElement *>(Allocate(sizeof(TElement)));
        if (ptr != nullptr)
        {
            if __stk_constexpr_cpp17 (!std::is_trivially_constructible<TElement, TArgs...>())
            {
                auto const elm = new (ptr) TElement(static_cast<TArgs &&>(args)...);
                STK_UNUSED(elm);
            }
        }
 
        return ptr;
    }

References __stk_constexpr_cpp17, Allocate(), STK_ASSERT, and STK_UNUSED.

Here is the call graph for this function:

Free()

void stk::memory::MemoryAllocator::Free ( void * ptr )

static

Free the memory chunk.

Parameters

[in]

ptr

Pointer to the memory chunk. nullptr is allowed and results in noop.

Definition at line 45 of file stk_c_memory.cpp.

{ free(ptr); }

References free().

Referenced by FreeArrayT(), FreeOneT(), and vPortFree().

Here is the call graph for this function:

Here is the caller graph for this function:

FreeArrayT()

template<typename TElement>

void stk::memory::MemoryAllocator::FreeArrayT ( TElement * ptr, size_t count )

inlinestatic

Destroy and free an array allocated via AllocateT().

Parameters

[in]	ptr	Pointer to the first element. nullptr is allowed and results in noop.
[in]	count	Number of elements (must match the count passed to AllocateT()).

Definition at line 207 of file stk_memory_allocator.h.

    {
        STK_ASSERT(Free != nullptr);
 
        if (ptr != nullptr)
        {
            if __stk_constexpr_cpp17 (!std::is_trivially_destructible<TElement>())
            {
                // destroy in reverse order (mirrors stack unwinding)
                for (size_t i = count; i > 0U; --i)
                {
                    ptr[i - 1].~TElement();
                }
            }
            else
            {
                STK_UNUSED(count);
            }
 
            Free(ptr);
        }
    }

References __stk_constexpr_cpp17, Free(), STK_ASSERT, and STK_UNUSED.

Referenced by stk::memory::BlockMemoryPool::~BlockMemoryPool().

Here is the call graph for this function:

Here is the caller graph for this function:

FreeOneT()

template<typename TElement>

void stk::memory::MemoryAllocator::FreeOneT ( TElement * ptr )

inlinestatic

Destroy and free a single element allocated via AllocateOne().

Parameters

[in]

ptr

Pointer to the element. nullptr is allowed and results in noop.

Definition at line 187 of file stk_memory_allocator.h.

    {
        STK_ASSERT(Free != nullptr);
 
        if (ptr != nullptr)
        {
            if __stk_constexpr_cpp17 (!std::is_trivially_destructible<TElement>())
            {
                ptr->~TElement();
            }
 
            Free(ptr);
        }
    }

References __stk_constexpr_cpp17, Free(), and STK_ASSERT.

Here is the call graph for this function:

GetStats()

stk::memory::MemoryAllocator::Stats stk::memory::MemoryAllocator::GetStats ( )

static

Get stats of memory allocation.

Returns

Stats structure.

Definition at line 107 of file freertos_stk.cpp.

{
    return s_MemStats;
}

References s_MemStats.

Member Data Documentation

CAPACITY_DEFAULT

const size_t stk::memory::MemoryAllocator::CAPACITY_DEFAULT = 12288U

static

Default memory pool capacity in bytes.

See also

Stats

Definition at line 60 of file stk_memory_allocator.h.

Referenced by stk::memory::MemoryAllocator::Stats::Stats().

---

The documentation for this class was generated from the following files:

• stk_memory_allocator.h
• stk_c_memory.cpp
• cmsis_os2_stk.cpp
• freertos_stk.cpp