initialise-free-store.cpp

Go to the documentation of this file.

/*
 * This file is part of the µOS++ project (https://micro-os-plus.github.io/).
 * Copyright (c) 2016-2025 Liviu Ionescu. All rights reserved.
 *
 * Permission to use, copy, modify, and/or distribute this software
 * for any purpose is hereby granted, under the terms of the MIT license.
 *
 * If a copy of the license was not distributed with this file, it can
 * be obtained from https://opensource.org/licenses/mit.
 */
 
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wempty-translation-unit"
#endif
 
// ----------------------------------------------------------------------------
 
#if defined(__ARM_EABI__)
 
// ----------------------------------------------------------------------------
 
#if defined(OS_USE_OS_APP_CONFIG_H)
#include <cmsis-plus/os-app-config.h>
#endif
 
#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>
 
// ----------------------------------------------------------------------------
 
using namespace os;
 
// ----------------------------------------------------------------------------
 
#if defined(OS_TYPE_APPLICATION_MEMORY_RESOURCE)
using application_memory_resource = OS_TYPE_APPLICATION_MEMORY_RESOURCE;
#else
// using free_store_memory_resource = os::memory::lifo;
using application_memory_resource = os::memory::first_fit_top;
#endif
 
#if defined(OS_TYPE_RTOS_MEMORY_RESOURCE)
using rtos_memory_resource = OS_TYPE_RTOS_MEMORY_RESOURCE;
#else
using rtos_memory_resource = os::memory::lifo;
#endif
 
extern "C" void*
sbrk (ptrdiff_t incr);
 
// ----------------------------------------------------------------------------
 
#if !defined(OS_EXCLUDE_DYNAMIC_MEMORY_ALLOCATIONS)
 
// Reserve storage for the application memory resource.
static std::aligned_storage<sizeof (application_memory_resource),
                            alignof (application_memory_resource)>::type
    application_free_store;
 
#endif /* !defined(OS_EXCLUDE_DYNAMIC_MEMORY_ALLOCATIONS) */
 
void __attribute__ ((weak))
os_startup_initialize_free_store (void* heap_address,
                                  std::size_t heap_size_bytes)
{
  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) */
}
 
void __attribute__ ((weak))
os_rtos_application_out_of_memory_hook (void)
{
  estd::__throw_bad_alloc ();
}
 
#if defined(OS_INTEGER_RTOS_DYNAMIC_MEMORY_SIZE_BYTES)
 
void __attribute__ ((weak))
os_rtos_system_out_of_memory_hook (void)
{
  estd::__throw_bad_alloc ();
}
 
#endif
 
// ----------------------------------------------------------------------------
 
#endif /* defined(__ARM_EABI__) */