os-memory.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.
 */
 
/*
 * [Partly inspired from the LLVM libcxx sources].
 * Copyright (c) 2009-2013 by the contributors listed in
 * 'LLVM libcxx Credits.txt'. See 'LLVM libcxx License.txt' for details.
 *
 * References are to ISO/IEC 14882:2011(E) Third edition (2011-09-01).
 */
 
#if defined(OS_USE_OS_APP_CONFIG_H)
#include <cmsis-plus/os-app-config.h>
#endif
 
#include <cmsis-plus/rtos/os.h>
#include <cmsis-plus/estd/memory_resource>
#include <cmsis-plus/memory/malloc.h>
#include <cmsis-plus/memory/null.h>
 
// ----------------------------------------------------------------------------
 
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#endif
 
// ----------------------------------------------------------------------------
 
using namespace os;
 
// ----------------------------------------------------------------------------
 
namespace os
{
  namespace rtos
  {
    namespace memory
    {
      // ======================================================================
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wexit-time-destructors"
#pragma clang diagnostic ignored "-Wglobal-constructors"
#endif
 
      // The memory resources must not be destructed, since some
      // static objects will want to deallocate memory they manage.
 
      static std::aligned_storage<
          sizeof (os::memory::malloc_memory_resource),
          alignof (os::memory::malloc_memory_resource)>::type malloc_res;
 
      static std::aligned_storage<
          sizeof (os::memory::null_memory_resource),
          alignof (os::memory::null_memory_resource)>::type null_res;
 
      static std::aligned_storage<
          sizeof (os::memory::new_delete_memory_resource),
          alignof (os::memory::new_delete_memory_resource)>::type
          new_delete_res;
 
      void
      init_once_default_resource (void)
      {
        static int guard; // Cleared during BSS init.
        if (guard == 0)
          {
            guard = 1;
 
            trace::printf ("rtos::memory::%s() \n", __func__);
 
            new (&malloc_res) os::memory::malloc_memory_resource ("malloc");
            new (&null_res) os::memory::null_memory_resource ();
            new (&new_delete_res) os::memory::new_delete_memory_resource ();
          }
      }
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wreserved-identifier"
#endif
      // This guarantees that the memory resources are initialised
      // before entering main().
      static void __attribute__ ((constructor))
      __constructor (void)
      {
        init_once_default_resource ();
      }
#pragma GCC diagnostic pop
 
      // allocator_pool<mutex> allocator_mutex_instance;
 
#pragma GCC diagnostic pop
 
      // The default RTOS system memory resource.
#if !defined(OS_IS_CROSS_BUILD)
 
      memory_resource* default_resource __attribute__ ((weak))
      = reinterpret_cast<memory_resource*> (&malloc_res);
 
      // ----------------------------------------------------------------------
 
      memory_resource* resource_thread __attribute__ ((weak))
      = reinterpret_cast<memory_resource*> (&malloc_res);
 
      memory_resource* resource_condition_variable __attribute__ ((weak))
      = reinterpret_cast<memory_resource*> (&malloc_res);
 
      memory_resource* resource_event_flags __attribute__ ((weak))
      = reinterpret_cast<memory_resource*> (&malloc_res);
 
      memory_resource* resource_memory_pool __attribute__ ((weak))
      = reinterpret_cast<memory_resource*> (&malloc_res);
 
      memory_resource* resource_message_queue __attribute__ ((weak))
      = reinterpret_cast<memory_resource*> (&malloc_res);
 
      memory_resource* resource_mutex __attribute__ ((weak))
      = reinterpret_cast<memory_resource*> (&malloc_res);
 
      memory_resource* resource_semaphore __attribute__ ((weak))
      = reinterpret_cast<memory_resource*> (&malloc_res);
 
      memory_resource* resource_timer __attribute__ ((weak))
      = reinterpret_cast<memory_resource*> (&malloc_res);
 
#else
 
      memory_resource* default_resource __attribute__ ((weak))
      = reinterpret_cast<memory_resource*> (&null_res);
 
      // ----------------------------------------------------------------------
 
      memory_resource* resource_thread __attribute__ ((weak))
      = reinterpret_cast<memory_resource*> (&null_res);
 
      memory_resource* resource_condition_variable __attribute__ ((weak))
      = reinterpret_cast<memory_resource*> (&null_res);
 
      memory_resource* resource_event_flags __attribute__ ((weak))
      = reinterpret_cast<memory_resource*> (&null_res);
 
      memory_resource* resource_memory_pool __attribute__ ((weak))
      = reinterpret_cast<memory_resource*> (&null_res);
 
      memory_resource* resource_message_queue __attribute__ ((weak))
      = reinterpret_cast<memory_resource*> (&null_res);
 
      memory_resource* resource_mutex __attribute__ ((weak))
      = reinterpret_cast<memory_resource*> (&null_res);
 
      memory_resource* resource_semaphore __attribute__ ((weak))
      = reinterpret_cast<memory_resource*> (&null_res);
 
      memory_resource* resource_timer __attribute__ ((weak))
      = reinterpret_cast<memory_resource*> (&null_res);
 
#endif
 
      // ----------------------------------------------------------------------
      memory_resource*
      malloc_resource (void) noexcept
      {
        return reinterpret_cast<memory_resource*> (&malloc_res);
      }
 
      // ----------------------------------------------------------------------
 
      memory_resource*
      set_default_resource (memory_resource* res) noexcept
      {
        trace::printf ("rtos::memory::%s(%p) \n", __func__, res);
 
        memory_resource* old = default_resource;
        default_resource = res;
 
        return old;
      }
 
      // ----------------------------------------------------------------------
 
      template <>
      memory_resource*
      set_resource_typed<thread> (memory_resource* res) noexcept
      {
        trace::printf ("rtos::memory::%s(%p) \n", __func__, res);
 
        memory_resource* old = resource_thread;
        resource_thread = res;
 
        return old;
      }
 
      template <>
      memory_resource*
      set_resource_typed<condition_variable> (memory_resource* res) noexcept
      {
        trace::printf ("rtos::memory::%s(%p) \n", __func__, res);
 
        memory_resource* old = resource_condition_variable;
        resource_condition_variable = res;
 
        return old;
      }
 
      template <>
      memory_resource*
      set_resource_typed<event_flags> (memory_resource* res) noexcept
      {
        trace::printf ("rtos::memory::%s(%p) \n", __func__, res);
 
        memory_resource* old = resource_event_flags;
        resource_event_flags = res;
 
        return old;
      }
 
      template <>
      memory_resource*
      set_resource_typed<memory_pool> (memory_resource* res) noexcept
      {
        trace::printf ("rtos::memory::%s(%p) \n", __func__, res);
 
        memory_resource* old = resource_memory_pool;
        resource_memory_pool = res;
 
        return old;
      }
 
      template <>
      memory_resource*
      set_resource_typed<message_queue> (memory_resource* res) noexcept
      {
        trace::printf ("rtos::memory::%s(%p) \n", __func__, res);
 
        memory_resource* old = resource_message_queue;
        resource_message_queue = res;
 
        return old;
      }
 
      template <>
      memory_resource*
      set_resource_typed<mutex> (memory_resource* res) noexcept
      {
        trace::printf ("rtos::memory::%s(%p) \n", __func__, res);
 
        memory_resource* old = resource_mutex;
        resource_mutex = res;
 
        return old;
      }
 
      template <>
      memory_resource*
      set_resource_typed<semaphore> (memory_resource* res) noexcept
      {
        trace::printf ("rtos::memory::%s(%p) \n", __func__, res);
 
        memory_resource* old = resource_semaphore;
        resource_semaphore = res;
 
        return old;
      }
 
      template <>
      memory_resource*
      set_resource_typed<timer> (memory_resource* res) noexcept
      {
        trace::printf ("rtos::memory::%s(%p) \n", __func__, res);
 
        memory_resource* old = resource_timer;
        resource_timer = res;
 
        return old;
      }
 
      // ======================================================================
 
      memory_resource::~memory_resource ()
      {
      }
 
      bool
      memory_resource::do_is_equal (
          memory_resource const& other) const noexcept
      {
        return &other == this;
      }
 
      std::size_t
      memory_resource::do_max_size (void) const noexcept
      {
        return 0;
      }
 
      void
      memory_resource::do_reset (void) noexcept
      {
        return;
      }
 
      bool
      memory_resource::do_coalesce (void) noexcept
      {
        return false;
      }
 
      void
      memory_resource::internal_increase_allocated_statistics (
          std::size_t bytes) noexcept
      {
        // Update statistics.
        // What is subtracted from free is added to allocated.
        allocated_bytes_ += bytes;
        if (allocated_bytes_ > max_allocated_bytes_)
          {
            max_allocated_bytes_ = allocated_bytes_;
          }
        free_bytes_ -= bytes;
        ++allocated_chunks_;
        --free_chunks_;
      }
 
      void
      memory_resource::internal_decrease_allocated_statistics (
          std::size_t bytes) noexcept
      {
        // Update statistics.
        // What is subtracted from allocated is added to free.
        allocated_bytes_ -= bytes;
        free_bytes_ += bytes;
        --allocated_chunks_;
        ++free_chunks_;
      }
 
      // ----------------------------------------------------------------------
 
    } /* namespace memory */
  } /* namespace rtos */
} /* namespace os */
 
namespace os
{
  namespace estd
  {
    namespace pmr
    {
      memory_resource*
      new_delete_resource (void) noexcept
      {
        return reinterpret_cast<memory_resource*> (
            &rtos::memory::new_delete_res);
      }
 
      memory_resource*
      null_memory_resource (void) noexcept
      {
        return reinterpret_cast<memory_resource*> (&rtos::memory::null_res);
      }
 
#if !defined(OS_IS_CROSS_BUILD)
      memory_resource* default_resource __attribute__ ((weak))
      = reinterpret_cast<memory_resource*> (&rtos::memory::malloc_res);
#else
      memory_resource* default_resource __attribute__ ((weak))
      = reinterpret_cast<memory_resource*> (&rtos::memory::null_res);
#endif
 
    } /* namespace pmr */
  } /* namespace estd */
} /* namespace os */
 
// ----------------------------------------------------------------------------