initialise-free-store.cpp File Reference

#include <cmsis-plus/rtos/os-hooks.h>
#include <cmsis-plus/memory/first-fit-top.h>
#include <cmsis-plus/memory/lifo.h>
#include <cmsis-plus/memory/block-pool.h>
#include <cmsis-plus/estd/memory_resource>

Go to the source code of this file.

Typedefs
using	application_memory_resource = os::memory::first_fit_top
using	rtos_memory_resource = os::memory::lifo

Functions
void	os_rtos_application_out_of_memory_hook (void)
	Hook to handle out of memory in the application free store.
void	os_rtos_system_out_of_memory_hook (void)
	Hook to handle out of memory in the RTOS dynamic memory.
void	os_startup_initialize_free_store (void *heap_address, std::size_t heap_size_bytes)
void *	sbrk (ptrdiff_t incr)

Variables
static std::aligned_storage< sizeof(application_memory_resource), alignof(application_memory_resource)>::type	application_free_store

Typedef Documentation

application_memory_resource

using application_memory_resource = os::memory::first_fit_top

Definition at line 42 of file initialise-free-store.cpp.

rtos_memory_resource

using rtos_memory_resource = os::memory::lifo

Definition at line 48 of file initialise-free-store.cpp.

Function Documentation

os_startup_initialize_free_store()

void os_startup_initialize_free_store	(	void *	heap_address,
		std::size_t	heap_size_bytes
	)

This routine is called after the hardware is initialised, before the static constructors, to initialise the application free store and the RTOS dynamic memory (when OS_INTEGER_RTOS_DYNAMIC_MEMORY_SIZE_BYTES is defined).

If the RTOS is configured with its own memory, this area is dynamically allocated on the application free store. The RTOS memory resource (by default the one using LIFO) is also dynamically allocated on the application free store. (If it is free, why not use it; these areas are permanent anyway).

For special applications, it is possible to override this function entirely.

Definition at line 82 of file initialise-free-store.cpp.

{
  trace::printf ("%s(%p,%u)\n", __func__, heap_address, heap_size_bytes);
 
#if !defined(OS_EXCLUDE_DYNAMIC_MEMORY_ALLOCATIONS)
 
  // Construct the memory resource used for the application free store.
  new (&application_free_store)
      application_memory_resource{ "app", heap_address, heap_size_bytes };
 
  // Configure the memory manager to throw an exception when out of memory.
  reinterpret_cast<rtos::memory::memory_resource*> (&application_free_store)
      ->out_of_memory_handler (os_rtos_application_out_of_memory_hook);
 
  // Set the application free store memory manager.
  estd::pmr::set_default_resource (
      reinterpret_cast<estd::pmr::memory_resource*> (&application_free_store));
 
  // Adjust sbrk() to prevent it overlapping the free store.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wuseless-cast"
  sbrk (
      static_cast<char*> (static_cast<char*> (heap_address) + heap_size_bytes)
      - static_cast<char*> (sbrk (0)));
#pragma GCC diagnostic pop
 
#if defined(OS_INTEGER_RTOS_DYNAMIC_MEMORY_SIZE_BYTES)
 
  {
    // Allocate the RTOS dynamic memory on the application free store.
    void* rtos_arena
        = reinterpret_cast<rtos::memory::memory_resource*> (
              &application_free_store)
              ->allocate (OS_INTEGER_RTOS_DYNAMIC_MEMORY_SIZE_BYTES);
 
    // Allocate & construct the memory resource used for the RTOS.
    rtos::memory::memory_resource* mr = new rtos_memory_resource{
      "sys", rtos_arena, OS_INTEGER_RTOS_DYNAMIC_MEMORY_SIZE_BYTES
    };
 
    // Configure the memory manager to throw an exception when out of memory.
    mr->out_of_memory_handler (os_rtos_system_out_of_memory_hook);
 
    // Set RTOS system memory manager.
    rtos::memory::set_default_resource (mr);
  }
 
#else
 
  // The RTOS system memory manager is identical with the application one.
  rtos::memory::set_default_resource (
      reinterpret_cast<rtos::memory::memory_resource*> (
          &application_free_store));
 
#endif /* defined(OS_INTEGER_RTOS_DYNAMIC_MEMORY_SIZE_BYTES) */
 
#if defined(OS_INTEGER_RTOS_ALLOC_THREAD_POOL_SIZE)
 
  {
    static_assert (OS_INTEGER_RTOS_ALLOC_THREAD_POOL_SIZE > 1,
                   "Mutex pool size must be >1.");
    rtos::memory::memory_resource* mr
        = new os::memory::block_pool_typed_inclusive<
            rtos::thread, OS_INTEGER_RTOS_ALLOC_THREAD_POOL_SIZE> ("pool-th");
 
    // Configure the memory manager to throw an exception when out of memory.
    mr->out_of_memory_handler (os_rtos_system_out_of_memory_hook);
 
    rtos::memory::set_resource_typed<rtos::thread> (mr);
  }
 
#endif /* defined(OS_INTEGER_RTOS_ALLOC_THREAD_POOL_SIZE) */
 
#if defined(OS_INTEGER_RTOS_ALLOC_CONDITION_VARIABLE_POOL_SIZE)
 
  {
    static_assert (OS_INTEGER_RTOS_ALLOC_CONDITION_VARIABLE_POOL_SIZE > 1,
                   "Mutex pool size must be >1.");
    rtos::memory::memory_resource* mr
        = new os::memory::block_pool_typed_inclusive<
            rtos::condition_variable,
            OS_INTEGER_RTOS_ALLOC_CONDITION_VARIABLE_POOL_SIZE> ("pool-cv");
 
    // Configure the memory manager to throw an exception when out of memory.
    mr->out_of_memory_handler (os_rtos_system_out_of_memory_hook);
 
    rtos::memory::set_resource_typed<rtos::condition_variable> (mr);
  }
 
#endif /* defined(OS_INTEGER_RTOS_ALLOC_CONDITION_VARIABLE_POOL_SIZE) */
 
#if defined(OS_INTEGER_RTOS_ALLOC_EVENT_FLAGS_POOL_SIZE)
 
  {
    static_assert (OS_INTEGER_RTOS_ALLOC_EVENT_FLAGS_POOL_SIZE > 1,
                   "Mutex pool size must be >1.");
    rtos::memory::memory_resource* mr
        = new os::memory::block_pool_typed_inclusive<
            rtos::event_flags, OS_INTEGER_RTOS_ALLOC_EVENT_FLAGS_POOL_SIZE> (
            "pool-ef");
 
    // Configure the memory manager to throw an exception when out of memory.
    mr->out_of_memory_handler (os_rtos_system_out_of_memory_hook);
 
    rtos::memory::set_resource_typed<rtos::event_flags> (mr);
  }
 
#endif /* defined(OS_INTEGER_RTOS_ALLOC_EVENT_FLAGS_POOL_SIZE) */
 
#if defined(OS_INTEGER_RTOS_ALLOC_MEMORY_POOL_POOL_SIZE)
 
  {
    static_assert (OS_INTEGER_RTOS_ALLOC_MEMORY_POOL_POOL_SIZE > 1,
                   "Mutex pool size must be >1.");
    rtos::memory::memory_resource* mr
        = new os::memory::block_pool_typed_inclusive<
            rtos::memory_pool, OS_INTEGER_RTOS_ALLOC_MEMORY_POOL_POOL_SIZE> (
            "pool-mp");
 
    // Configure the memory manager to throw an exception when out of memory.
    mr->out_of_memory_handler (os_rtos_system_out_of_memory_hook);
 
    rtos::memory::set_resource_typed<rtos::memory_pool> (mr);
  }
 
#endif /* defined(OS_INTEGER_RTOS_ALLOC_MEMORY_POOL_POOL_SIZE) */
 
#if defined(OS_INTEGER_RTOS_ALLOC_MESSAGE_QUEUE_POOL_SIZE)
 
  {
    static_assert (OS_INTEGER_RTOS_ALLOC_MESSAGE_QUEUE_POOL_SIZE > 1,
                   "Mutex pool size must be >1.");
    rtos::memory::memory_resource* mr
        = new os::memory::block_pool_typed_inclusive<
            rtos::message_queue,
            OS_INTEGER_RTOS_ALLOC_MESSAGE_QUEUE_POOL_SIZE> ("pool-mq");
 
    // Configure the memory manager to throw an exception when out of memory.
    mr->out_of_memory_handler (os_rtos_system_out_of_memory_hook);
 
    rtos::memory::set_resource_typed<rtos::message_queue> (mr);
  }
 
#endif /* defined(OS_INTEGER_RTOS_ALLOC_MESSAGE_QUEUE_POOL_SIZE) */
 
#if defined(OS_INTEGER_RTOS_ALLOC_MUTEX_POOL_SIZE)
 
  {
    static_assert (OS_INTEGER_RTOS_ALLOC_MUTEX_POOL_SIZE > 1,
                   "Mutex pool size must be >1.");
    rtos::memory::memory_resource* mr
        = new os::memory::block_pool_typed_inclusive<
            rtos::mutex, OS_INTEGER_RTOS_ALLOC_MUTEX_POOL_SIZE> ("pool-mx");
 
    // Configure the memory manager to throw an exception when out of memory.
    mr->out_of_memory_handler (os_rtos_system_out_of_memory_hook);
 
    rtos::memory::set_resource_typed<rtos::mutex> (mr);
  }
 
#endif /* defined(OS_INTEGER_RTOS_ALLOC_MUTEX_POOL_SIZE) */
 
#if defined(OS_INTEGER_RTOS_ALLOC_SEMAPHORE_POOL_SIZE)
 
  {
    static_assert (OS_INTEGER_RTOS_ALLOC_SEMAPHORE_POOL_SIZE > 1,
                   "Semaphore pool size must be >1.");
    rtos::memory::memory_resource* mr
        = new os::memory::block_pool_typed_inclusive<
            rtos::semaphore, OS_INTEGER_RTOS_ALLOC_MUTEX_POOL_SIZE> (
            "pool-sp");
 
    // Configure the memory manager to throw an exception when out of memory.
    mr->out_of_memory_handler (os_rtos_system_out_of_memory_hook);
 
    rtos::memory::set_resource_typed<rtos::semaphore> (mr);
  }
 
#endif /* defined(OS_INTEGER_RTOS_ALLOC_SEMAPHORE_POOL_SIZE) */
 
#if defined(OS_INTEGER_RTOS_ALLOC_TIMER_POOL_SIZE)
 
  {
    static_assert (OS_INTEGER_RTOS_ALLOC_TIMER_POOL_SIZE > 1,
                   "Mutex pool size must be >1.");
    rtos::memory::memory_resource* mr
        = new os::memory::block_pool_typed_inclusive<
            rtos::timer, OS_INTEGER_RTOS_ALLOC_TIMER_POOL_SIZE> ("pool-tm");
 
    // Configure the memory manager to throw an exception when out of memory.
    mr->out_of_memory_handler (os_rtos_system_out_of_memory_hook);
 
    rtos::memory::set_resource_typed<rtos::timer> (mr);
  }
 
#endif /* defined(OS_INTEGER_RTOS_ALLOC_TIMER_POOL_SIZE) */
 
#endif /* !defined(OS_EXCLUDE_DYNAMIC_MEMORY_ALLOCATIONS) */
}

References application_free_store, OS_INTEGER_RTOS_ALLOC_CONDITION_VARIABLE_POOL_SIZE, OS_INTEGER_RTOS_ALLOC_EVENT_FLAGS_POOL_SIZE, OS_INTEGER_RTOS_ALLOC_MEMORY_POOL_POOL_SIZE, OS_INTEGER_RTOS_ALLOC_MESSAGE_QUEUE_POOL_SIZE, OS_INTEGER_RTOS_ALLOC_MUTEX_POOL_SIZE, OS_INTEGER_RTOS_ALLOC_SEMAPHORE_POOL_SIZE, OS_INTEGER_RTOS_ALLOC_THREAD_POOL_SIZE, OS_INTEGER_RTOS_ALLOC_TIMER_POOL_SIZE, OS_INTEGER_RTOS_DYNAMIC_MEMORY_SIZE_BYTES, os_rtos_application_out_of_memory_hook(), os_rtos_system_out_of_memory_hook(), os::rtos::memory::memory_resource::out_of_memory_handler(), os::trace::printf(), sbrk(), os::estd::pmr::set_default_resource(), and os::rtos::memory::set_default_resource().

sbrk()

void * sbrk

(

ptrdiff_t

incr

)

Referenced by os_startup_initialize_free_store().

Variable Documentation

application_free_store

std::aligned_storage<sizeof(application_memory_resource),alignof(application_memory_resource)>::type application_free_store

static

Definition at line 61 of file initialise-free-store.cpp.

Referenced by os_startup_initialize_free_store().