os::memory::first_fit_top Class Reference

Memory resource implementing the first fit, top-down allocation policies, using an existing arena. More...

#include <cmsis-plus/memory/first-fit-top.h>

Inheritance diagram for os::memory::first_fit_top:

Public Member Functions
Public Member Functions
void *	allocate (std::size_t bytes, std::size_t alignment=max_align)
	Allocate a memory block.
void	deallocate (void *addr, std::size_t bytes, std::size_t alignment=max_align) noexcept
	Deallocate the previously allocated memory block.
bool	is_equal (memory_resource const &other) const noexcept
	Compare for equality with another memory_resource.
void	reset (void) noexcept
	Reset the memory manager to the initial state.
bool	coalesce (void) noexcept
	Coalesce free blocks.
std::size_t	max_size (void) const noexcept
	Get the largest value that can be passed to allocate().
out_of_memory_handler_t	out_of_memory_handler (out_of_memory_handler_t handler)
	Set the out of memory handler.
out_of_memory_handler_t	out_of_memory_handler (void)
	Get the out of memory handler.
std::size_t	total_bytes (void)
	Get the total size of managed memory.
std::size_t	allocated_bytes (void)
	Get the current size of all allocated chunks.
std::size_t	max_allocated_bytes (void)
	Get the maximum allocated size.
std::size_t	free_bytes (void)
	Get the current size of all free chunks.
std::size_t	allocated_chunks (void)
	Get the current number of allocated chunks.
std::size_t	free_chunks (void)
	Get the current number of free chunks.
std::size_t	allocations (void)
	Get the number of allocations.
std::size_t	deallocations (void)
	Get the number of deallocations.
void	trace_print_statistics (void)
	Print a long message with usage statistics.
Public Member Functions
const char *	name (void) const
	Get object name.

Static Public Attributes
static constexpr std::size_t	max_align = alignof (std::max_align_t)
	The largest alignment for the platform. Also default when supplied alignment is not supported.

Protected Member Functions
Private Member Functions
void	internal_construct_ (void *addr, std::size_t bytes)
	Internal function to construct the memory resource.
void	internal_reset_ (void) noexcept
	Internal function to reset the memory resource.
void *	internal_align_ (chunk_t *chunk, std::size_t bytes, std::size_t alignment)
	Internal function to align a chunk.
virtual void *	do_allocate (std::size_t bytes, std::size_t alignment) override
	Implementation of the memory allocator.
virtual void	do_deallocate (void *addr, std::size_t bytes, std::size_t alignment) noexcept override
	Implementation of the memory deallocator.
virtual std::size_t	do_max_size (void) const noexcept override
	Implementation of the function to get max size.
virtual void	do_reset (void) noexcept override
	Implementation of the function to reset the memory manager.
Private Member Functions
virtual bool	do_is_equal (memory_resource const &other) const noexcept
	Implementation of the equality comparator.
virtual bool	do_coalesce (void) noexcept
	Implementation of the function to coalesce free blocks.
void	internal_increase_allocated_statistics (std::size_t bytes) noexcept
	Update statistics after allocation.
void	internal_decrease_allocated_statistics (std::size_t bytes) noexcept
	Update statistics after deallocation.

Constructors & Destructor
	first_fit_top (void *addr, std::size_t bytes)
	Construct a memory resource object instance.
	first_fit_top (const char *name, void *addr, std::size_t bytes)
	Construct a named memory resource object instance.
virtual	~first_fit_top () override
	Destruct the memory resource object instance.
	first_fit_top ()=default
	Default constructor. Construct a memory resource object instance.
	first_fit_top (const char *name)
	Construct a named memory resource object instance.

Detailed Description

This memory manager was inspired by the newlib nano implementation of malloc() & free().

Neither allocation nor deallocation are deterministic, but are reasonably fast.

Definition at line 53 of file first-fit-top.h.

Constructor & Destructor Documentation

first_fit_top() [1/4]

os::memory::first_fit_top::first_fit_top ( void *  addr, std::size_t  bytes  )

inline

Parameters

[in]	addr	Begin of allocator arena.
[in]	bytes	Size of allocator arena, in bytes.

Definition at line 483 of file first-fit-top.h.

        : first_fit_top{ nullptr, addr, bytes }
    {
    }

first_fit_top() [2/4]

os::memory::first_fit_top::first_fit_top ( const char *  name, void *  addr, std::size_t  bytes  )

inline

Parameters

[in]	name	Pointer to name.
[in]	addr	Begin of allocator arena.
[in]	bytes	Size of allocator arena, in bytes.

Definition at line 488 of file first-fit-top.h.

        : rtos::memory::memory_resource{ name }
    {
      trace::printf ("%s(%p,%u) @%p %s\n", __func__, addr, bytes, this,
                     this->name ());
 
      internal_construct_ (addr, bytes);
    }

References internal_construct_(), and os::trace::printf().

first_fit_top() [3/4]

os::memory::first_fit_top::first_fit_top ( )

protecteddefault

first_fit_top() [4/4]

os::memory::first_fit_top::first_fit_top ( const char *  name )

inlineprotected

Parameters

[in]

name

Pointer to name.

Definition at line 478 of file first-fit-top.h.

        : rtos::memory::memory_resource{ name }
    {
    }

~first_fit_top()

os::memory::first_fit_top::~first_fit_top ( )

overridevirtual

Definition at line 34 of file first-fit-top.cpp.

    {
      trace::printf ("first_fit_top::%s() @%p %s\n", __func__, this, name ());
    }

References os::rtos::internal::object_named::name(), and os::trace::printf().

Member Function Documentation

allocate()

void * os::rtos::memory::memory_resource::allocate ( std::size_t  bytes, std::size_t  alignment = max_align  )

inlineinherited

Parameters

bytes	Number of bytes to allocate.
alignment	Alignment constraint (power of 2).

Returns

Pointer to newly allocated block, or nullptr.

Allocate storage with a size of at least bytes bytes. The returned storage is aligned to the specified alignment if such alignment is supported, and to alignof(std::max_align_t) otherwise.

If the storage of the requested size and alignment cannot be obtained:

• if the out of memory handler is not set, return nullptr;
• if the out of memory handler is set, call it and retry.

Equivalent to return do_allocate(bytes, alignment);.

Exceptions

The code itself throws nothing, but if the out of memory handler is set, it may throw a bad_alloc() exception.

See also

do_allocate();

Definition at line 1290 of file os-memory.h.

      {
        ++allocations_;
        return do_allocate (bytes, alignment);
      }

References os::rtos::memory::memory_resource::do_allocate().

Referenced by os::estd::pmr::polymorphic_allocator< T >::allocate(), calloc(), malloc(), operator new(), and realloc().

allocated_bytes()

std::size_t os::rtos::memory::memory_resource::allocated_bytes ( void  )

inlineinherited

Parameters

None.

Returns

Number of bytes.

Definition at line 1402 of file os-memory.h.

      {
        return allocated_bytes_;
      }

Referenced by os::rtos::memory::memory_resource::trace_print_statistics().

allocated_chunks()

std::size_t os::rtos::memory::memory_resource::allocated_chunks ( void  )

inlineinherited

Parameters

None.

Returns

Number of chunks.

Definition at line 1420 of file os-memory.h.

      {
        return allocated_chunks_;
      }

Referenced by os::rtos::memory::memory_resource::trace_print_statistics().

allocations()

std::size_t os::rtos::memory::memory_resource::allocations ( void  )

inlineinherited

Parameters

None.

Returns

Number of allocations.

Definition at line 1432 of file os-memory.h.

      {
        return allocations_;
      }

Referenced by os::rtos::memory::memory_resource::trace_print_statistics().

coalesce()

bool os::rtos::memory::memory_resource::coalesce ( void  )

inlinenoexceptinherited

Parameters

None.

Return values

true	if the operation freed more memory.
false	if the operation was ineffective.

In case the memory manager does not coalesce during deallocation, traverse the list of free blocks and coalesce.

Return true if the operation was successful and at least one larger block resulted.

See also

do_coalesce();

Definition at line 1365 of file os-memory.h.

      {
        return do_coalesce ();
      }

deallocate()

void os::rtos::memory::memory_resource::deallocate ( void *  addr, std::size_t  bytes, std::size_t  alignment = max_align  )

inlinenoexceptinherited

Parameters

addr	Address of the block to free.
bytes	Number of bytes to deallocate (may be 0 if unknown).
alignment	Alignment constraint (power of 2).

Returns

Nothing.

Deallocate the storage pointed to by addr. The address shall have been returned by a prior call to allocate() on a memory_resource that compares equal to *this, and the storage it points to shall not yet have been deallocated.

Equivalent to return do_deallocate(p, bytes, alignment);.

Exceptions

Throws nothing.

See also

do_deallocate();

Definition at line 1312 of file os-memory.h.

      {
        ++deallocations_;
        do_deallocate (addr, bytes, alignment);
      }

Referenced by os::estd::pmr::polymorphic_allocator< T >::deallocate(), free(), and realloc().

deallocations()

std::size_t os::rtos::memory::memory_resource::deallocations ( void  )

inlineinherited

Parameters

None.

Returns

Number of deallocations

Definition at line 1438 of file os-memory.h.

      {
        return deallocations_;
      }

Referenced by os::rtos::memory::memory_resource::trace_print_statistics().

do_allocate()

void * os::memory::first_fit_top::do_allocate ( std::size_t  bytes, std::size_t  alignment  )

overrideprotectedvirtual

Parameters

[in]	bytes	Number of bytes to allocate.
[in]	alignment	Alignment constraint (power of 2).

Returns

Pointer to newly allocated block, or nullptr.

The allocator tries to be fast and grasps the first block large enough, possibly splitting large blocks and increasing fragmentation. If the block is only slightly larger (the remaining space is not large enough for a minimum chunk) the block is not split, but left partly unused.

When large blocks are split, the top sub-block is returned; in other words, memory is allocated top-down. This speeds up deallocation for blocks allocated recently.

Exceptions

Throws nothing by itself, but the out of memory handler may throw bad_alloc().

Implements os::rtos::memory::memory_resource.

Reimplemented in os::memory::lifo.

Definition at line 112 of file first-fit-top.cpp.

    {
      std::size_t block_padding = calc_block_padding (alignment);
      std::size_t alloc_size = rtos::memory::align_size (bytes, chunk_align);
      alloc_size += block_padding;
      alloc_size += chunk_offset;
 
      std::size_t block_minchunk = calc_block_minchunk (block_padding);
      alloc_size = os::rtos::memory::max (alloc_size, block_minchunk);
 
      chunk_t* chunk;
 
      while (true)
        {
          chunk_t* prev_chunk = free_list_;
          chunk = prev_chunk;
 
          while (chunk)
            {
              int rem = static_cast<int> (chunk->size - alloc_size);
              if (rem >= 0)
                {
                  if ((static_cast<std::size_t> (rem)) >= block_minchunk)
                    {
                      // Found a chunk that is much larger than required size
                      // (at least one more chunk is available);
                      // break it into two chunks and return the second one.
 
                      chunk->size = static_cast<std::size_t> (rem);
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-align"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
#endif
                      chunk = reinterpret_cast<chunk_t*> (
                          reinterpret_cast<char*> (chunk) + rem);
#pragma GCC diagnostic pop
                      chunk->size = alloc_size;
 
                      // Splitting one chunk creates one more chunk.
                      ++free_chunks_;
                    }
                  else
                    {
                      // Found a chunk that is exactly the size or slightly
                      // larger than the requested size; return this chunk.
 
                      if (prev_chunk == chunk)
                        {
                          // This implies p==r==free_list, i.e. the list head.
                          // The next chunk becomes the first list element.
                          free_list_ = chunk->next;
 
                          // If this was the last chunk, the free list is
                          // empty.
                        }
                      else
                        {
                          // Normal case. Remove it from the free_list.
                          prev_chunk->next = chunk->next;
                        }
                    }
                  break;
                }
              prev_chunk = chunk;
              chunk = chunk->next;
            }
 
          if (chunk != nullptr)
            {
              break;
            }
 
          if (out_of_memory_handler_ == nullptr)
            {
#if defined(OS_TRACE_LIBCPP_MEMORY_RESOURCE)
              trace::printf ("first_fit_top::%s(%u,%u)=0 @%p %s\n", __func__,
                             bytes, alignment, this, name ());
#endif
 
              return nullptr;
            }
 
#if defined(OS_TRACE_LIBCPP_MEMORY_RESOURCE)
          trace::printf ("first_fit_top::%s(%u,%u) @%p %s out of memory\n",
                         __func__, bytes, alignment, this, name ());
#endif
          out_of_memory_handler_ ();
 
          // If the handler returned, assume it freed some memory
          // and try again to allocate.
        }
 
      void* aligned_payload = internal_align_ (chunk, bytes, alignment);
 
#if defined(OS_TRACE_LIBCPP_MEMORY_RESOURCE)
      trace::printf ("first_fit_top::%s(%u,%u)=%p,%u @%p %s\n", __func__,
                     bytes, alignment, aligned_payload, alloc_size, this,
                     name ());
#endif
 
      return aligned_payload;
    }

References os::rtos::memory::align_size(), internal_align_(), os::rtos::memory::max(), os::rtos::internal::object_named::name(), and os::trace::printf().

do_coalesce()

bool os::rtos::memory::memory_resource::do_coalesce ( void  )

protectedvirtualnoexceptinherited

Parameters

None.

Return values

true	if the operation resulted in larger blocks.
false	if the operation was ineffective.

The default implementation of this virtual function returns false, meaning the operation was ineffective.

Override this function to perform the action.

Standard compliance

Extension to standard.

Definition at line 468 of file os-memory.cpp.

      {
        return false;
      }

do_deallocate()

void os::memory::first_fit_top::do_deallocate ( void *  addr, std::size_t  bytes, std::size_t  alignment  )

overrideprotectedvirtualnoexcept

Parameters

[in]	addr	Address of a previously allocated block to free.
[in]	bytes	Number of bytes to deallocate (may be 0 if unknown).
[in]	alignment	Alignment constraint (power of 2).

Returns

Nothing.

Deallocation is not guaranteed to be deterministic, but if done in strict reverse allocation order, it becomes deterministic, otherwise a traversal of the free list is required, the older the block, the more nodes to traverse (the free list is kept in ascending addresses order).

If the block is already in the free list, issue a trace message, but otherwise ignore the condition.

Exceptions

Throws nothing.

Implements os::rtos::memory::memory_resource.

Definition at line 231 of file first-fit-top.cpp.

    {
#if defined(OS_TRACE_LIBCPP_MEMORY_RESOURCE)
      trace::printf ("first_fit_top::%s(%p,%u,%u) @%p %s\n", __func__, addr,
                     bytes, alignment, this, name ());
#endif
 
      // The address must be inside the arena; no exceptions.
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
#endif
      if ((addr < arena_addr_)
          || (addr > (static_cast<char*> (arena_addr_) + total_bytes_)))
        {
          assert (false);
          return;
        }
#pragma GCC diagnostic pop
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-align"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
#endif
      // Compute the chunk address from the user address.
      chunk_t* chunk = reinterpret_cast<chunk_t*> (static_cast<char*> (addr)
                                                   - chunk_offset);
 
      // If the block was aligned, the offset appears as size; adjust back.
      if (static_cast<std::ptrdiff_t> (chunk->size) < 0)
        {
          chunk = reinterpret_cast<chunk_t*> (
              reinterpret_cast<char*> (chunk)
              + static_cast<std::ptrdiff_t> (chunk->size));
        }
#pragma GCC diagnostic pop
 
      if (bytes)
        {
          // If size is known, validate.
          // (when called from free(), the size is not known).
          if (bytes + chunk_offset > chunk->size)
            {
              assert (false);
              return;
            }
        }
 
      // Update statistics.
      // What is subtracted from allocated is added to free.
      internal_decrease_allocated_statistics (chunk->size);
 
      // If the free list is empty, create it with the current chunk, alone.
      if (free_list_ == nullptr)
        {
          // Mark the end of the list with a null pointer.
          chunk->next = nullptr;
 
          // The chunk becomes the first list element.
          free_list_ = chunk;
          assert (free_chunks_ == 1);
 
          return;
        }
 
      // The free list exists; is the chunk before the list head?
      if (chunk < free_list_)
        {
          // Is the chunk *right* before the list head?
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
#endif
          if (reinterpret_cast<char*> (chunk) + chunk->size
              == reinterpret_cast<char*> (free_list_))
            {
              // Coalesce chunk to the list head.
              chunk->size += free_list_->size;
              chunk->next = free_list_->next; // May be nullptr
 
              // Coalescing means one less chunk.
              --free_chunks_;
            }
          else
            {
              // Insert before the list head.
              chunk->next = free_list_;
            }
#pragma GCC diagnostic pop
          // The chunk becomes the new list head.
          free_list_ = chunk;
 
          return;
        }
 
      // Walk the free list to find the place to insert,
      // (the list must be ordered by addresses).
      // Warning: not deterministic!
 
      chunk_t* next_chunk = free_list_;
      chunk_t* prev_chunk;
      do
        {
          prev_chunk = next_chunk;
          next_chunk = next_chunk->next;
        }
      while (next_chunk != nullptr && next_chunk <= chunk);
 
      // Now prev_chunk <= chunk and either next_chunk == nullptr or
      // next_chunk > chunk.
      // Try to merge with chunks immediately before/after it.
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
#endif
      if (reinterpret_cast<char*> (prev_chunk) + prev_chunk->size
          == reinterpret_cast<char*> (chunk))
        {
          // Chunk to be freed is adjacent to a free chunk before it.
          prev_chunk->size += chunk->size;
 
          // Coalescing means one less chunk.
          --free_chunks_;
 
          // If the merged chunk is also adjacent to the chunk after it,
          // merge again. Does not match if next_chunk == nullptr.
          if (reinterpret_cast<char*> (prev_chunk) + prev_chunk->size
              == reinterpret_cast<char*> (next_chunk))
            {
              prev_chunk->size += next_chunk->size;
              prev_chunk->next = next_chunk->next;
 
              // Coalescing means one less chunk.
              --free_chunks_;
            }
        }
      else if (reinterpret_cast<char*> (prev_chunk) + prev_chunk->size
               > reinterpret_cast<char*> (chunk))
        {
          // Already freed.
 
          // Revert statistics.
          // What is subtracted from free is added to allocated.
          allocated_bytes_ += chunk->size;
          free_bytes_ -= chunk->size;
          ++allocated_chunks_;
          --free_chunks_;
 
          trace::printf ("first_fit_top::%s(%p,%u,%u) @%p %s already freed\n",
                         __func__, addr, bytes, alignment, this, name ());
 
          return;
        }
      // Does not match if next_chunk == nullptr.
      else if (reinterpret_cast<char*> (chunk) + chunk->size
               == reinterpret_cast<char*> (next_chunk))
        {
          // The chunk to be freed is adjacent to a free chunk after it.
          chunk->size += next_chunk->size;
          chunk->next = next_chunk->next; // May be nullptr.
          prev_chunk->next = chunk;
 
          // Coalescing means one less chunk.
          --free_chunks_;
        }
      else
        {
          // Not adjacent to any chunk. Just insert it.
          // The result is a new fragment. Not great...
          chunk->next = next_chunk; // May be nullptr.
          prev_chunk->next = chunk;
        }
    }

References os::trace::printf().

do_is_equal()

bool os::rtos::memory::memory_resource::do_is_equal ( memory_resource const &  other ) const

protectedvirtualnoexceptinherited

Parameters

other

Reference to another memory_resource.

Return values

true	The memory_resource objects are equal.
false	The memory_resource objects are not equal.

Compares *this for equality with other. Two memory_resources compare equal if and only if memory allocated from one memory_resource can be deallocated from the other and vice versa.

The most-derived type of other may not match the most derived type of *this. A derived class implementation therefore must typically check whether the most derived types of *this and other match using dynamic_cast, and immediately return false if the cast fails.

Exceptions

Throws nothing.

Definition at line 419 of file os-memory.cpp.

      {
        return &other == this;
      }

do_max_size()

std::size_t os::memory::first_fit_top::do_max_size ( void  ) const

overrideprotectedvirtualnoexcept

Parameters

None.

Returns

Integer with size in bytes, or 0 if unknown.

Reimplemented from os::rtos::memory::memory_resource.

Definition at line 410 of file first-fit-top.cpp.

    {
      return total_bytes_;
    }

do_reset()

void os::memory::first_fit_top::do_reset ( void  )

overrideprotectedvirtualnoexcept

Parameters

None.

Returns

Nothing.

Reimplemented from os::rtos::memory::memory_resource.

Definition at line 82 of file first-fit-top.cpp.

    {
#if defined(OS_TRACE_LIBCPP_MEMORY_RESOURCE)
      trace::printf ("first_fit_top::%s() @%p %s\n", __func__, this, name ());
#endif
 
      internal_reset_ ();
    }

References os::trace::printf().

free_bytes()

std::size_t os::rtos::memory::memory_resource::free_bytes ( void  )

inlineinherited

Parameters

None.

Returns

Number of bytes.

Definition at line 1414 of file os-memory.h.

      {
        return free_bytes_;
      }

Referenced by os::rtos::memory::memory_resource::trace_print_statistics().

free_chunks()

std::size_t os::rtos::memory::memory_resource::free_chunks ( void  )

inlineinherited

Parameters

None.

Returns

Number of chunks.

Definition at line 1426 of file os-memory.h.

      {
        return free_chunks_;
      }

Referenced by os::rtos::memory::memory_resource::trace_print_statistics().

internal_align_()

void * os::memory::first_fit_top::internal_align_ ( chunk_t *  chunk, std::size_t  bytes, std::size_t  alignment  )

protected

Parameters

[in]	chunk	Pointer to chunk.
[in]	bytes	Bytes to allocate.
[in]	alignment	Power of two.

Returns

Pointer to aligned payload.

Definition at line 416 of file first-fit-top.cpp.

    {
      // Update statistics.
      // The value subtracted from free is added to allocated.
      internal_increase_allocated_statistics (chunk->size);
 
      // Compute pointer to payload area.
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
#endif
      char* payload = reinterpret_cast<char*> (chunk) + chunk_offset;
#pragma GCC diagnostic pop
 
      // Align it to user provided alignment.
      void* aligned_payload = payload;
      std::size_t aligned_size = chunk->size - chunk_offset;
 
      void* res;
      res = std::align (alignment, bytes, aligned_payload, aligned_size);
      if (res == nullptr)
        {
          assert (res != nullptr);
        }
 
      // Compute the possible alignment offset.
      std::ptrdiff_t offset = static_cast<char*> (aligned_payload) - payload;
      if (offset)
        {
          // If non-zero, store it in the gap left by alignment in the
          // chunk header.
 
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-align"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wunsafe-buffer-usage"
#endif
          chunk_t* adj_chunk = reinterpret_cast<chunk_t*> (
              static_cast<char*> (aligned_payload) - chunk_offset);
          adj_chunk->size = static_cast<std::size_t> (-offset);
#pragma GCC diagnostic pop
        }
 
      assert ((reinterpret_cast<uintptr_t> (aligned_payload) & (alignment - 1))
              == 0);
 
      return aligned_payload;
    }

References os::rtos::memory::memory_resource::internal_increase_allocated_statistics().

Referenced by do_allocate(), and os::memory::lifo::do_allocate().

internal_construct_()

void os::memory::first_fit_top::internal_construct_ ( void *  addr, std::size_t  bytes  )

protected

Parameters

[in]	addr	Begin of allocator arena.
[in]	bytes	Size of allocator arena, in bytes.

Returns

Nothing.

Definition at line 40 of file first-fit-top.cpp.

    {
      assert (bytes > chunk_minsize);
 
      arena_addr_ = addr;
      total_bytes_ = bytes;
 
      // Align address for first chunk.
      void* res;
      // Possibly adjust the last two parameters.
      res = std::align (chunk_align, chunk_minsize, arena_addr_, total_bytes_);
      // std::align() will fail if it cannot fit the min chunk.
      if (res == nullptr)
        {
          assert (res != nullptr);
        }
      assert ((total_bytes_ % chunk_align) == 0);
 
      internal_reset_ ();
    }

References internal_reset_().

Referenced by first_fit_top(), os::memory::first_fit_top_allocated< A >::first_fit_top_allocated(), os::memory::first_fit_top_inclusive< N >::first_fit_top_inclusive(), os::memory::lifo_allocated< A >::lifo_allocated(), and os::memory::lifo_inclusive< N >::lifo_inclusive().

internal_decrease_allocated_statistics()

void os::rtos::memory::memory_resource::internal_decrease_allocated_statistics ( std::size_t  bytes )

protectednoexceptinherited

Parameters

[in]

bytes

Number of deallocated bytes.

Returns

Nothing.

Definition at line 490 of file os-memory.cpp.

      {
        // Update statistics.
        // What is subtracted from allocated is added to free.
        allocated_bytes_ -= bytes;
        free_bytes_ += bytes;
        --allocated_chunks_;
        ++free_chunks_;
      }

internal_increase_allocated_statistics()

void os::rtos::memory::memory_resource::internal_increase_allocated_statistics ( std::size_t  bytes )

protectednoexceptinherited

Parameters

[in]

bytes

Number of allocated bytes.

Returns

Nothing.

Definition at line 474 of file os-memory.cpp.

      {
        // 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_;
      }

Referenced by os::memory::block_pool::do_allocate(), and internal_align_().

internal_reset_()

void os::memory::first_fit_top::internal_reset_ ( void  )

protectednoexcept

Parameters

None.

Definition at line 62 of file first-fit-top.cpp.

    {
      // Fill it with the first chunk.
      chunk_t* chunk = reinterpret_cast<chunk_t*> (arena_addr_);
      // Entire arena is a big free chunk.
      chunk->size = total_bytes_;
      // Mark the end of the list with a null pointer.
      chunk->next = nullptr;
 
      allocated_bytes_ = 0;
      max_allocated_bytes_ = 0;
      free_bytes_ = total_bytes_;
      allocated_chunks_ = 0;
      free_chunks_ = 1;
 
      // Remember first chunk as list head.
      free_list_ = chunk;
    }

Referenced by internal_construct_().

is_equal()

bool os::rtos::memory::memory_resource::is_equal ( memory_resource const &  other ) const

inlinenoexceptinherited

Parameters

other

Reference to another memory_resource.

Return values

true	The memory_resource objects are equal.
false	The memory_resource objects are not equal.

Compare *this for equality with other. Two memory_resources compare equal if and only if memory allocated from one memory_resource can be deallocated from the other and vice versa.

Exceptions

Throws nothing.

See also

do_is_equal();

Definition at line 1331 of file os-memory.h.

      {
        return do_is_equal (other);
      }

max_allocated_bytes()

std::size_t os::rtos::memory::memory_resource::max_allocated_bytes ( void  )

inlineinherited

Parameters

None.

Returns

Number of bytes.

Definition at line 1408 of file os-memory.h.

      {
        return max_allocated_bytes_;
      }

Referenced by os::rtos::memory::memory_resource::trace_print_statistics().

max_size()

std::size_t os::rtos::memory::memory_resource::max_size ( void  ) const

inlinenoexceptinherited

Parameters

None.

Returns

Number of bytes or 0 if unknown.

See also

do_max_size();

Definition at line 1340 of file os-memory.h.

      {
        return do_max_size ();
      }

name()

const char * os::rtos::internal::object_named::name ( void  ) const

inlineinherited

Parameters

None.

Returns

A null terminated string.

All objects return a non-null string; anonymous objects return "-".

Note

Can be invoked from Interrupt Service Routines.

Definition at line 753 of file os-decls.h.

      {
        return name_;
      }

Referenced by os::memory::lifo::lifo(), os::memory::malloc_memory_resource::malloc_memory_resource(), os::rtos::message_queue_typed< T, Allocator >::message_queue_typed(), os::memory::block_pool::~block_pool(), os::rtos::event_flags::~event_flags(), ~first_fit_top(), os::memory::lifo::~lifo(), os::memory::malloc_memory_resource::~malloc_memory_resource(), os::rtos::memory_pool::~memory_pool(), os::rtos::message_queue::~message_queue(), os::rtos::mutex::~mutex(), os::rtos::semaphore::~semaphore(), os::rtos::thread::~thread(), os::rtos::timer::~timer(), os::rtos::memory_pool::alloc(), os::rtos::thread::cancel(), os::rtos::event_flags::clear(), os::rtos::mutex::consistent(), os::rtos::thread::detach(), os::memory::new_delete_memory_resource::do_allocate(), os::memory::block_pool::do_allocate(), do_allocate(), os::memory::lifo::do_allocate(), os::memory::malloc_memory_resource::do_allocate(), os::rtos::thread::flags_raise(), os::rtos::memory_pool::free(), os::rtos::event_flags::get(), os::rtos::thread::interrupt(), os::rtos::thread::join(), os::rtos::thread::kill(), os::rtos::internal::terminated_threads_list::link(), os::rtos::mutex::lock(), os::rtos::memory::memory_resource::out_of_memory_handler(), os::rtos::semaphore::post(), os::rtos::mutex::prio_ceiling(), os::rtos::mutex::prio_ceiling(), os::rtos::thread::priority(), os::rtos::thread::priority_inherited(), os::rtos::event_flags::raise(), os::rtos::message_queue::receive(), os::rtos::memory_pool::reset(), os::rtos::message_queue::reset(), os::rtos::mutex::reset(), os::rtos::semaphore::reset(), os::rtos::thread::resume(), os::rtos::message_queue::send(), os::rtos::clock::sleep_for(), os::rtos::timer::start(), os::rtos::timer::stop(), os::rtos::memory_pool::timed_alloc(), os::rtos::mutex::timed_lock(), os::rtos::message_queue::timed_receive(), os::rtos::message_queue::timed_send(), os::rtos::semaphore::timed_wait(), os::rtos::event_flags::timed_wait(), os::rtos::memory::memory_resource::trace_print_statistics(), os::rtos::memory_pool::try_alloc(), os::rtos::mutex::try_lock(), os::rtos::message_queue::try_receive(), os::rtos::message_queue::try_send(), os::rtos::event_flags::try_wait(), os::rtos::semaphore::try_wait(), os::rtos::internal::ready_threads_list::unlink_head(), os::rtos::mutex::unlock(), os::rtos::event_flags::wait(), os::rtos::semaphore::wait(), and os::rtos::event_flags::waiting().

out_of_memory_handler() [1/2]

out_of_memory_handler_t os::rtos::memory::memory_resource::out_of_memory_handler ( out_of_memory_handler_t  handler )

inlineinherited

Parameters

handler

Pointer to new handler.

Returns

Pointer to old handler.

Standard compliance

Extension to standard.

Definition at line 1375 of file os-memory.h.

      {
        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;
      }

References os::rtos::internal::object_named::name(), and os::trace::printf().

Referenced by os_startup_initialize_free_store().

out_of_memory_handler() [2/2]

out_of_memory_handler_t os::rtos::memory::memory_resource::out_of_memory_handler ( void  )

inlineinherited

Parameters

None.

Returns

Pointer to existing handler.

Standard compliance

Extension to standard.

Definition at line 1390 of file os-memory.h.

      {
        return out_of_memory_handler_;
      }

reset()

void os::rtos::memory::memory_resource::reset ( void  )

inlinenoexceptinherited

Parameters

None.

Returns

Nothing.

See also

do_reset();

Definition at line 1349 of file os-memory.h.

      {
        do_reset ();
      }

total_bytes()

std::size_t os::rtos::memory::memory_resource::total_bytes ( void  )

inlineinherited

Returns

Number of bytes.

Definition at line 1396 of file os-memory.h.

      {
        return total_bytes_;
      }

Referenced by os::rtos::memory::memory_resource::trace_print_statistics().

trace_print_statistics()

void os::rtos::memory::memory_resource::trace_print_statistics ( void  )

inlineinherited

Parameters

None.

Returns

Nothing.

Definition at line 1444 of file os-memory.h.

      {
#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) */
      }

References os::rtos::memory::memory_resource::allocated_bytes(), os::rtos::memory::memory_resource::allocated_chunks(), os::rtos::memory::memory_resource::allocations(), os::rtos::memory::memory_resource::deallocations(), os::rtos::memory::memory_resource::free_bytes(), os::rtos::memory::memory_resource::free_chunks(), os::rtos::memory::memory_resource::max_allocated_bytes(), os::rtos::internal::object_named::name(), os::trace::printf(), and os::rtos::memory::memory_resource::total_bytes().

Referenced by os_terminate_goodbye().

Member Data Documentation

max_align

constexpr std::size_t os::rtos::memory::memory_resource::max_align = alignof (std::max_align_t)

staticconstexprinherited

Definition at line 166 of file os-memory.h.

---

The documentation for this class was generated from the following files:

• first-fit-top.h
• first-fit-top.cpp