stk_memory_allocator.h

Go to the documentation of this file.

/*
 * SuperTinyKernel(TM) RTOS: Lightweight High-Performance Deterministic C++ RTOS for Embedded Systems.
 *
 * Source: https://github.com/SuperTinyKernel-RTOS
 *
 * Copyright (c) 2022-2026 Neutron Code Limited <stk@neutroncode.com>. All Rights Reserved.
 * License: MIT License, see LICENSE for a full text.
 */
 
#ifndef STK_MEMORY_ALLOCATOR_H_
#define STK_MEMORY_ALLOCATOR_H_
 
#include "stk_defs.h"

#ifndef STK_MEMORY_PLACEMENT_NEW
    #define STK_MEMORY_PLACEMENT_NEW (1)
#endif
 
#if STK_MEMORY_PLACEMENT_NEW
#include <type_traits>
#include <new>
#endif

 
namespace stk {
namespace memory {

struct MemoryAllocator
{
    static const size_t CAPACITY_DEFAULT = 12288U;

    struct Stats
    {
        Stats(size_t _capacity = CAPACITY_DEFAULT)
            : capacity(_capacity), allocated(0U), allocate_count(0U), free_count(0U), 
              min_ever_free(_capacity)
        {}
 
        const size_t    capacity;       
        volatile size_t allocated;      
        volatile size_t allocate_count; 
        volatile size_t free_count;     
        volatile size_t min_ever_free;  

        size_t GetCapacity() const { return capacity; }

        size_t GetAvailable() const { return ((allocated < capacity) ? (capacity - allocated) : 0U); }

        void RecordAllocate(size_t size)
        {
            allocated += size;
            ++allocate_count;
            min_ever_free = Min(GetAvailable(), min_ever_free);
        }

        void RecordFree(size_t size)
        {
            STK_ASSERT(allocated >= size);
 
            allocated -= size;
            ++free_count;
        }
    };

    static void *Allocate(size_t size) __stk_weak;

    static void Free(void *ptr) __stk_weak;

    static Stats GetStats() __stk_weak;
 
#if STK_MEMORY_PLACEMENT_NEW

    template <typename TElement, typename... TArgs>
    static inline TElement *AllocateOneT(TArgs &&...args)
    {
        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;
    }

    template <typename TElement, typename... TArgs>
    static inline TElement *AllocateArrayT(size_t count, TArgs &&...args)
    {
        TElement *ptr = nullptr;
      
        if (count != 0U)
        {
          STK_ASSERT(hw::PtrToWord(&Allocate) != 0U);
 
            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;
    }

    template <typename TElement>
    static inline void FreeOneT(TElement *ptr)
    {
        STK_ASSERT(Free != nullptr);
 
        if (ptr != nullptr)
        {
            if __stk_constexpr_cpp17 (!std::is_trivially_destructible<TElement>())
            {
                ptr->~TElement();
            }
 
            Free(ptr);
        }
    }

    template <typename TElement>
    static inline void FreeArrayT(TElement ptr[], size_t count)
    {
        STK_ASSERT(hw::PtrToWord(&Free) != 0U);
 
        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);
        }
    }
 
#endif // STK_MEMORY_PLACEMENT_NEW
};
 
} // namespace memory
} // namespace stk
 
#endif /* STK_MEMORY_ALLOCATOR_H_ */