os-memory.h

Go to the documentation of this file.

/*
 * This file is part of the µOS++ distribution.
 *   (https://github.com/micro-os-plus)
 * Copyright (c) 2016-2023 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/.
 */
 
#ifndef CMSIS_PLUS_RTOS_OS_MEMORY_H_
#define CMSIS_PLUS_RTOS_OS_MEMORY_H_
 
// ----------------------------------------------------------------------------
 
#if defined(__cplusplus)
 
// ----------------------------------------------------------------------------
 
#include <cmsis-plus/estd/system_error>
 
#include <limits>
#include <new>
#include <cerrno>
#include <mutex>
 
// ----------------------------------------------------------------------------
 
// These definitions refer only to the RTOS allocators.
// The application should use the similar ones from the
// os::estd:: namespace.
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
#endif
 
// ----------------------------------------------------------------------------
 
namespace os
{
  namespace estd
  {
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wreserved-identifier"
#endif
    [[noreturn]] void
    __throw_bad_alloc (void);
#pragma GCC diagnostic pop
 
    template<typename L>
      class lock_guard;
 
  }
 
  namespace rtos
  {
    namespace scheduler
    {
      class critical_section;
    }
 
    class null_locker;
 
    namespace memory
    {
      // ----------------------------------------------------------------------
 
      constexpr std::size_t
      max (std::size_t a, std::size_t b)
      {
        return (a >= b) ? a : b;
      }
 
      constexpr std::size_t
      align_size (std::size_t size, std::size_t align) noexcept
      {
        return ((size) + (align) - 1L) & ~((align) - 1L);
      }
 
      class memory_resource;
 
      // ----------------------------------------------------------------------
 
      memory_resource*
      malloc_resource (void) noexcept;
 
      memory_resource*
      set_default_resource (memory_resource* res) noexcept;
 
      memory_resource*
      get_default_resource (void) noexcept;
 
      void
      init_once_default_resource (void);
 
      // ======================================================================
      using out_of_memory_handler_t = void (*)(void);
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wsuggest-final-methods"
#pragma GCC diagnostic ignored "-Wsuggest-final-types"
#endif
      class memory_resource : public internal::object_named
      {
 
      public:
 
        static constexpr std::size_t max_align = alignof(std::max_align_t);
 
        memory_resource () = default;
 
        memory_resource (const char* name);
 
        // The rule of five.
        memory_resource (const memory_resource&) = delete;
        memory_resource (memory_resource&&) = delete;
        memory_resource&
        operator= (const memory_resource&) = delete;
        memory_resource&
        operator= (memory_resource&&) = delete;
 
        virtual
        ~memory_resource ();
 
      public:
 
        void*
        allocate (std::size_t bytes, std::size_t alignment = max_align);
 
        void
        deallocate (void* addr, std::size_t bytes, std::size_t alignment =
                        max_align) noexcept;
 
        bool
        is_equal (memory_resource const & other) const noexcept;
 
        void
        reset (void) noexcept;
 
        bool
        coalesce (void) noexcept;
 
        std::size_t
        max_size (void) const noexcept;
 
        out_of_memory_handler_t
        out_of_memory_handler (out_of_memory_handler_t handler);
 
        out_of_memory_handler_t
        out_of_memory_handler (void);
 
        std::size_t
        total_bytes (void);
 
        std::size_t
        allocated_bytes (void);
 
        std::size_t
        max_allocated_bytes (void);
 
        std::size_t
        free_bytes (void);
 
        std::size_t
        allocated_chunks (void);
 
        std::size_t
        free_chunks (void);
 
        std::size_t
        allocations (void);
 
        std::size_t
        deallocations (void);
 
        void
        trace_print_statistics (void);
 
      protected:
 
        virtual void*
        do_allocate (std::size_t bytes, std::size_t alignment) = 0;
 
        virtual void
        do_deallocate (void* addr, std::size_t bytes, std::size_t alignment)
            noexcept = 0;
 
        virtual bool
        do_is_equal (memory_resource const &other) const noexcept;
 
        virtual std::size_t
        do_max_size (void) const noexcept;
 
        virtual void
        do_reset (void) noexcept;
 
        virtual bool
        do_coalesce (void) noexcept;
 
        void
        internal_increase_allocated_statistics (std::size_t bytes) noexcept;
 
        void
        internal_decrease_allocated_statistics (std::size_t bytes) noexcept;
 
      protected:
 
        out_of_memory_handler_t out_of_memory_handler_ = nullptr;
 
        std::size_t total_bytes_ = 0;
        std::size_t allocated_bytes_ = 0;
        std::size_t free_bytes_ = 0;
        std::size_t allocated_chunks_ = 0;
        std::size_t free_chunks_ = 0;
        std::size_t max_allocated_bytes_ = 0;
        std::size_t allocations_ = 0;
        std::size_t deallocations_ = 0;
 
      };
#pragma GCC diagnostic pop
 
      bool
      operator== (const memory_resource& lhs, const memory_resource& rhs)
          noexcept;
 
      bool
      operator!= (const memory_resource& lhs, const memory_resource& rhs)
          noexcept;
 
      // ======================================================================
      template<typename T>
        class allocator_stateless_default_resource
        {
        public:
 
          using value_type = T;
 
          allocator_stateless_default_resource () noexcept = default;
 
          allocator_stateless_default_resource (
              allocator_stateless_default_resource const & other) = default;
 
          template<typename U>
            allocator_stateless_default_resource (
                allocator_stateless_default_resource<U> const & other) noexcept;
 
          allocator_stateless_default_resource (
              allocator_stateless_default_resource && other) = default;
 
          ~allocator_stateless_default_resource () = default;
 
          allocator_stateless_default_resource&
          operator= (allocator_stateless_default_resource const & other) = default;
 
          allocator_stateless_default_resource&
          operator= (allocator_stateless_default_resource && other) = default;
 
        public:
 
          value_type*
          allocate (std::size_t elements);
 
          void
          deallocate (value_type* addr, std::size_t elements) noexcept;
 
          std::size_t
          max_size (void) const noexcept;
 
        protected:
 
          // This class should have no member variables, to meet the
          // default allocator stateless requirements.
        };
 
      // ======================================================================
 
      template<typename L>
        class lock_guard;
 
      using F = memory_resource* (void);
 
      template<typename T, typename L, F get_resource>
        class allocator_stateless_polymorphic_synchronized
        {
        public:
 
          using value_type = T;
          using locker_type = L;
 
          allocator_stateless_polymorphic_synchronized () noexcept;
 
          allocator_stateless_polymorphic_synchronized (
              allocator_stateless_polymorphic_synchronized const & other) = default;
 
          template<typename U>
            allocator_stateless_polymorphic_synchronized (
                allocator_stateless_polymorphic_synchronized<U, L, get_resource> const & other)
                    noexcept;
 
          allocator_stateless_polymorphic_synchronized (
              allocator_stateless_polymorphic_synchronized && other) = default;
 
          ~allocator_stateless_polymorphic_synchronized () = default;
 
          allocator_stateless_polymorphic_synchronized&
          operator= (allocator_stateless_polymorphic_synchronized const & other) = default;
 
          allocator_stateless_polymorphic_synchronized&
          operator= (allocator_stateless_polymorphic_synchronized && other) = default;
 
        public:
 
          template<typename U>
            struct rebind
            {
              using other = allocator_stateless_polymorphic_synchronized<U, L, get_resource>;
            };
 
          value_type*
          allocate (std::size_t elements);
 
          void
          deallocate (value_type* addr, std::size_t elements) noexcept;
 
          std::size_t
          max_size (void) const noexcept;
 
#if 0
          allocator_stateless_polymorphic_synchronized
          select_on_container_copy_construction (void) const noexcept;
 
          memory_resource*
          resource (void) const noexcept;
#endif
 
        private:
 
          // This class should have no member variables, to meet the
          // default allocator stateless requirements.
        };
 
      template<typename T1, typename T2, typename L, F get_resource>
        bool
        operator== (
            const allocator_stateless_polymorphic_synchronized<T1, L,
                get_resource>& lhs,
            const allocator_stateless_polymorphic_synchronized<T2, L,
                get_resource>& rhs) noexcept;
 
      template<typename T1, typename T2, typename L, F get_resource>
        bool
        operator!= (
            const allocator_stateless_polymorphic_synchronized<T1, L,
                get_resource>& lhs,
            const allocator_stateless_polymorphic_synchronized<T2, L,
                get_resource>& rhs) noexcept;
 
      template<typename A>
        class allocator_deleter
        {
        public:
 
          using allocator_type = A;
 
          using allocator_traits = std::allocator_traits<A>;
 
          using pointer = typename allocator_traits::pointer;
 
          allocator_deleter ();
 
          allocator_deleter (const allocator_type& other);
 
          allocator_deleter (allocator_deleter&& other) = default;
 
          ~allocator_deleter () = default;
 
          allocator_deleter&
          operator= (const allocator_deleter& other) = default;
 
          allocator_deleter&
          operator= (allocator_deleter&& other) = default;
 
          // /**
          //  * @brief Function operator.
          //  * @param addr Pointer to memory to deallocate.
          //  */
          void
          operator() (pointer addr) const;
 
        protected:
 
          allocator_type a_;
 
        };
 
      template<typename T, typename A, typename ... Args>
        auto
        allocate_unique (const A& allocator, Args&&... args);
 
      // ----------------------------------------------------------------------
 
      template<typename T>
        memory_resource*
        set_resource_typed (memory_resource* res) noexcept;
 
      template<typename T>
        memory_resource*
        get_resource_typed (void) noexcept;
 
      // ----------------------------------------------------------------------
 
      template<>
        memory_resource*
        set_resource_typed<thread> (memory_resource* res) noexcept;
 
      template<>
        memory_resource*
        get_resource_typed<thread> (void) noexcept;
 
      // ----------------------------------------------------------------------
 
      template<>
        memory_resource*
        set_resource_typed<condition_variable> (memory_resource* res) noexcept;
 
      template<>
        memory_resource*
        get_resource_typed<condition_variable> (void) noexcept;
 
      // ----------------------------------------------------------------------
 
      template<>
        memory_resource*
        set_resource_typed<event_flags> (memory_resource* res) noexcept;
 
      template<>
        memory_resource*
        get_resource_typed<event_flags> (void) noexcept;
 
      // ----------------------------------------------------------------------
 
      template<>
        memory_resource*
        set_resource_typed<memory_pool> (memory_resource* res) noexcept;
 
      template<>
        memory_resource*
        get_resource_typed<memory_pool> (void) noexcept;
 
      // ----------------------------------------------------------------------
 
      template<>
        memory_resource*
        set_resource_typed<message_queue> (memory_resource* res) noexcept;
 
      template<>
        memory_resource*
        get_resource_typed<message_queue> (void) noexcept;
 
      // ----------------------------------------------------------------------
 
      template<>
        memory_resource*
        set_resource_typed<mutex> (memory_resource* res) noexcept;
 
      template<>
        memory_resource*
        get_resource_typed<mutex> (void) noexcept;
 
      // ----------------------------------------------------------------------
 
      template<>
        memory_resource*
        set_resource_typed<semaphore> (memory_resource* res) noexcept;
 
      template<>
        memory_resource*
        get_resource_typed<semaphore> (void) noexcept;
 
      // ----------------------------------------------------------------------
 
      template<>
        memory_resource*
        set_resource_typed<timer> (memory_resource* res) noexcept;
 
      template<>
        memory_resource*
        get_resource_typed<timer> (void) noexcept;
 
      // ----------------------------------------------------------------------
      template<typename T, typename U = T>
        using allocator_typed = allocator_stateless_polymorphic_synchronized<T, scheduler::lockable, get_resource_typed<U>>;
 
      template<typename T, typename U = T>
        using unique_ptr = std::unique_ptr<T, allocator_deleter<allocator_typed<T, U>>>;
 
    // ------------------------------------------------------------------------
    } /* namespace memory */
  } /* namespace rtos */
} /* namespace os */
 
// ===== Inline & template implementations ====================================
 
namespace os
{
  namespace rtos
  {
    namespace memory
    {
      // ----------------------------------------------------------------------
 
      extern memory_resource* default_resource;
 
      extern memory_resource* resource_thread;
      extern memory_resource* resource_condition_variable;
      extern memory_resource* resource_event_flags;
      extern memory_resource* resource_memory_pool;
      extern memory_resource* resource_message_queue;
      extern memory_resource* resource_mutex;
      extern memory_resource* resource_semaphore;
      extern memory_resource* resource_timer;
 
      // ----------------------------------------------------------------------
      inline memory_resource*
      get_default_resource (void) noexcept
      {
        rtos::memory::init_once_default_resource ();
        return default_resource;
      }
 
      template<>
        inline memory_resource*
        get_resource_typed<thread> (void) noexcept
        {
          rtos::memory::init_once_default_resource ();
          return resource_thread;
        }
 
      template<>
        inline memory_resource*
        get_resource_typed<condition_variable> (void) noexcept
        {
          rtos::memory::init_once_default_resource ();
          return resource_condition_variable;
        }
 
      template<>
        inline memory_resource*
        get_resource_typed<event_flags> (void) noexcept
        {
          rtos::memory::init_once_default_resource ();
          return resource_event_flags;
        }
 
      template<>
        inline memory_resource*
        get_resource_typed<memory_pool> (void) noexcept
        {
          rtos::memory::init_once_default_resource ();
          return resource_memory_pool;
        }
 
      template<>
        inline memory_resource*
        get_resource_typed<message_queue> (void) noexcept
        {
          rtos::memory::init_once_default_resource ();
          return resource_message_queue;
        }
 
      template<>
        inline memory_resource*
        get_resource_typed<mutex> (void) noexcept
        {
          rtos::memory::init_once_default_resource ();
          return resource_mutex;
        }
 
      template<>
        inline memory_resource*
        get_resource_typed<semaphore> (void) noexcept
        {
          rtos::memory::init_once_default_resource ();
          return resource_semaphore;
        }
 
      template<>
        inline memory_resource*
        get_resource_typed<timer> (void) noexcept
        {
          rtos::memory::init_once_default_resource ();
          return resource_timer;
        }
 
      // ======================================================================
 
      inline
      memory_resource::memory_resource (const char* name) :
          object_named
            { name }
      {
      }
 
      inline void*
      memory_resource::allocate (std::size_t bytes, std::size_t alignment)
      {
        ++allocations_;
        return do_allocate (bytes, alignment);
      }
 
      inline void
      memory_resource::deallocate (void* addr, std::size_t bytes,
                                   std::size_t alignment) noexcept
      {
        ++deallocations_;
        do_deallocate (addr, bytes, alignment);
      }
 
      inline bool
      memory_resource::is_equal (memory_resource const & other) const noexcept
      {
        return do_is_equal (other);
      }
 
      inline std::size_t
      memory_resource::max_size (void) const noexcept
      {
        return do_max_size ();
      }
 
      inline void
      memory_resource::reset (void) noexcept
      {
        do_reset ();
      }
 
      inline bool
      memory_resource::coalesce (void) noexcept
      {
        return do_coalesce ();
      }
 
      inline out_of_memory_handler_t
      memory_resource::out_of_memory_handler (out_of_memory_handler_t handler)
      {
        trace::printf ("%s(%p) @%p %s\n", __func__, handler, this, name ());
 
        out_of_memory_handler_t tmp = out_of_memory_handler_;
        out_of_memory_handler_ = handler;
 
        return tmp;
      }
 
      inline out_of_memory_handler_t
      memory_resource::out_of_memory_handler (void)
      {
        return out_of_memory_handler_;
      }
 
      inline std::size_t
      memory_resource::total_bytes (void)
      {
        return total_bytes_;
      }
 
      inline std::size_t
      memory_resource::allocated_bytes (void)
      {
        return allocated_bytes_;
      }
 
      inline std::size_t
      memory_resource::max_allocated_bytes (void)
      {
        return max_allocated_bytes_;
      }
 
      inline std::size_t
      memory_resource::free_bytes (void)
      {
        return free_bytes_;
      }
 
      inline std::size_t
      memory_resource::allocated_chunks (void)
      {
        return allocated_chunks_;
      }
 
      inline std::size_t
      memory_resource::free_chunks (void)
      {
        return free_chunks_;
      }
 
      inline std::size_t
      memory_resource::allocations (void)
      {
        return allocations_;
      }
 
      inline std::size_t
      memory_resource::deallocations (void)
      {
        return deallocations_;
      }
 
      inline void
      memory_resource::trace_print_statistics (void)
      {
#if defined(TRACE)
        trace::printf ("Memory '%s' @%p: \n"
                       "\ttotal: %u bytes, \n"
                       "\tallocated: %u bytes in %u chunk(s), \n"
                       "\tfree: %u bytes in %u chunk(s), \n"
                       "\tmax: %u bytes, \n"
                       "\tcalls: %u allocs, %u deallocs\n",
                       name (), this, total_bytes (), allocated_bytes (),
                       allocated_chunks (), free_bytes (), free_chunks (),
                       max_allocated_bytes (), allocations (),
                       deallocations ());
#endif /* defined(TRACE) */
      }
 
      // ======================================================================
 
      inline bool
      operator== (memory_resource const & lhs, memory_resource const & rhs) noexcept
      {
        return &lhs == &rhs || lhs.is_equal (rhs);
      }
 
      inline bool
      operator!= (memory_resource const & lhs, memory_resource const & rhs) noexcept
      {
        return !(lhs == rhs);
      }
 
      // ======================================================================
 
      template<typename T>
        template<typename U>
          inline
          allocator_stateless_default_resource<T>::allocator_stateless_default_resource (
              allocator_stateless_default_resource<U> const & other __attribute__((unused))) noexcept
          {
          }
 
      template<typename T>
        inline typename allocator_stateless_default_resource<T>::value_type*
        allocator_stateless_default_resource<T>::allocate (std::size_t elements)
        {
          scheduler::critical_section scs;
 
          return static_cast<value_type*> (get_default_resource ()->allocate (
              elements * sizeof(value_type)));
        }
 
      template<typename T>
        inline void
        allocator_stateless_default_resource<T>::deallocate (
            value_type* addr, std::size_t elements) noexcept
        {
          scheduler::critical_section scs;
 
          get_default_resource ()->deallocate (addr,
                                               elements * sizeof(value_type));
        }
 
      template<typename T>
        inline std::size_t
        allocator_stateless_default_resource<T>::max_size (void) const noexcept
        {
          return get_default_resource ()->max_size () / sizeof(value_type);
        }
 
      // ======================================================================
 
      template<typename T, typename U, typename L, F get_resource>
        inline bool
        operator== (
            allocator_stateless_polymorphic_synchronized<T, L, get_resource> const & lhs,
            allocator_stateless_polymorphic_synchronized<U, L, get_resource> const & rhs) noexcept
        {
          return *lhs.resource () == *rhs.resource ();
        }
 
      template<typename T, typename U, typename L, F get_resource>
        inline bool
        operator!= (
            allocator_stateless_polymorphic_synchronized<T, L, get_resource> const & lhs,
            allocator_stateless_polymorphic_synchronized<U, L, get_resource> const & rhs) noexcept
        {
          return !(lhs == rhs);
        }
 
      // ======================================================================
 
      template<typename T, typename L, F get_resource>
        inline
        allocator_stateless_polymorphic_synchronized<T, L, get_resource>::allocator_stateless_polymorphic_synchronized () noexcept
        {
          trace::printf ("%s() @%p %p\n", __func__, this, get_resource ());
        }
 
      template<typename T, typename L, F get_resource>
        template<typename U>
          inline
          allocator_stateless_polymorphic_synchronized<T, L, get_resource>::allocator_stateless_polymorphic_synchronized (
              allocator_stateless_polymorphic_synchronized<U, L, get_resource> const & other __attribute__((unused))) noexcept
          {
          }
 
      template<typename T, typename L, F get_resource>
        typename allocator_stateless_polymorphic_synchronized<T, L, get_resource>::value_type*
        allocator_stateless_polymorphic_synchronized<T, L, get_resource>::allocate (
            std::size_t elements)
        {
          trace::printf ("%s(%u) @%p\n", __func__, elements, this);
 
#if 0
          std::size_t ms = max_size ();
          if ((ms > 0) && (elements > max_size ()))
            {
              estd::__throw_system_error (
                  EINVAL,
                  "allocator_stateless_polymorphic_synchronized<T>::allocate(size_t n)"
                  " 'n' exceeds maximum supported size");
            }
#endif
 
          locker_type lk;
          std::lock_guard<locker_type> ulk
            { lk };
 
          return static_cast<value_type*> (get_resource ()->allocate (
              elements * sizeof(value_type), alignof(value_type)));
        }
 
      template<typename T, typename L, F get_resource>
        void
        allocator_stateless_polymorphic_synchronized<T, L, get_resource>::deallocate (
            value_type* addr, std::size_t elements) noexcept
        {
          trace::printf ("%s(%p,%u) @%p\n", __func__, addr, elements, this);
 
#if 0
          std::size_t ms = max_size ();
          if (ms > 0)
            {
              assert (elements <= max_size ());
            }
#endif
 
          locker_type lk;
          std::lock_guard<locker_type> ulk
            { lk };
 
          get_resource ()->deallocate (addr, elements * sizeof(value_type),
                                       alignof(value_type));
        }
 
      template<typename T, typename L, F get_resource>
        inline std::size_t
        allocator_stateless_polymorphic_synchronized<T, L, get_resource>::max_size (
            void) const noexcept
        {
          return get_resource ()->max_size () / sizeof(T);
        }
 
#if 0
      template<typename T, typename L, F get_resource>
      inline allocator_stateless_polymorphic_synchronized<T, L, get_resource>
      allocator_stateless_polymorphic_synchronized<T, L, get_resource>::select_on_container_copy_construction (
          void) const noexcept
        {
          return allocator_stateless_polymorphic_synchronized ();
        }
 
      template<typename T, typename L, F get_resource>
      inline memory_resource*
      allocator_stateless_polymorphic_synchronized<T, L, get_resource>::resource (
          void) const noexcept
        {
          return get_resource ();
        }
#endif
 
      // ======================================================================
 
      template<typename A>
        inline
        allocator_deleter<A>::allocator_deleter ()
        {
        }
 
      template<typename A>
        inline
        allocator_deleter<A>::allocator_deleter (const allocator_type& other) :
            a_
              { other }
        {
        }
 
      template<typename A>
        inline void
        allocator_deleter<A>::operator() (pointer addr) const
        {
          // Local allocator, without it many errors are issued.
          // TODO: understand exactly why.
          allocator_type alloc
            { a_ };
 
          // Call the object destructor.
          allocator_traits::destroy (alloc, std::addressof (*addr));
 
          // Deallocate the object, using the same allocator
          // used to allocate the object.
          allocator_traits::deallocate (alloc, addr, 1);
        }
 
      // ======================================================================
 
      template<typename T, typename A, typename ... Args>
        auto
        allocate_unique (const A& allocator, Args&&... args)
        {
          using allocator_type = A;
 
          using allocator_traits = std::allocator_traits<A>;
 
          static_assert(std::is_same<typename allocator_traits::value_type, std::remove_cv_t<T>>::value
              || std::is_base_of<typename allocator_traits::value_type, std::remove_cv_t<T>>::value,
              "Allocator must be of same type or derived.");
 
          static_assert(sizeof(T) <= sizeof(typename allocator_traits::value_type),
              "Derived type must not be larger.");
 
          allocator_type alloc
            { allocator };
 
          // Allocate space for 1 object instance of type T.
          auto p = allocator_traits::allocate (alloc, 1);
 
#if defined(__EXCEPTIONS)
 
          try
            {
              // Use placement new to construct the object.
              allocator_traits::construct (alloc, std::addressof (*p),
                  std::forward<Args>(args)...);
 
              // Figure out the deleter type.
              using D = allocator_deleter<A>;
 
              // Make the unique pointer with the object and the deleter.
              return std::unique_ptr<T, D> (p, D (alloc));
            }
          catch (...)
            {
              allocator_traits::deallocate (alloc, p, 1);
              throw;
            }
 
#else
 
          // Use placement new to construct the object.
          allocator_traits::construct (alloc, std::addressof (*p),
                                       std::forward<Args>(args)...);
 
          // Figure out the deleter type.
          using D = allocator_deleter<A>;
 
          // Make the unique pointer with the object and the deleter.
          return std::unique_ptr<T, D> (p, D (alloc));
 
#endif /* defined(__EXCEPTIONS) */
        }
 
    // ------------------------------------------------------------------------
    } /* namespace memory */
  } /* namespace rtos */
} /* namespace os */
 
#pragma GCC diagnostic pop
 
// ----------------------------------------------------------------------------
 
#endif /* __cplusplus */
 
// ----------------------------------------------------------------------------
 
#endif /* CMSIS_PLUS_RTOS_OS_MEMORY_H_ */