OpenDDS::DCPS::MemoryPool Class Reference

#include <MemoryPool.h>

Collaboration diagram for OpenDDS::DCPS::MemoryPool:

Public Member Functions
	MemoryPool (unsigned int pool_size, size_t granularity=8)
	~MemoryPool ()
bool	includes (void *ptr) const
void *	pool_alloc (size_t size)
bool	pool_free (void *ptr)
size_t	lwm_free_bytes () const
size_t	size () const

Static Public Member Functions
static size_t	align (size_t size, size_t granularity)

Private Types
enum	{ min_free_size = sizeof(FreeHeader) }

Private Member Functions
void	remove_free_alloc (FreeHeader *block_to_alloc)
void	insert_free_alloc (FreeHeader *block_freed)
void	join_free_allocs (FreeHeader *block_freed)
unsigned char *	allocate (FreeHeader *free_block, size_t alloc_size)
bool	joinable_next (FreeHeader *freed)
bool	joinable_prev (FreeHeader *freed)

Private Attributes
const size_t	granularity_
	Configured granularity. More...
const size_t	min_alloc_size_
	Aligned minimum allocation size. More...
const size_t	pool_size_
	Configured pool size. More...
size_t	lwm_free_bytes_
	Low water mark of available bytes. More...
unsigned char *	pool_ptr_
	Pointer to pool. More...
FreeHeader *	largest_free_
	Pointer to largest free index. More...
FreeIndex	free_index_
	Index of free nodex. More...

Friends
class	Test::MemoryPoolTest

Detailed Description

Definition at line 162 of file MemoryPool.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Enumerator
min_free_size

Definition at line 199 of file MemoryPool.h.

       {
    min_free_size = sizeof(FreeHeader)
  };

Constructor & Destructor Documentation

MemoryPool()

OpenDDS::DCPS::MemoryPool::MemoryPool ( unsigned int  pool_size, size_t  granularity = 8  )

explicit

Definition at line 300 of file MemoryPool.cpp.

References free_index_, OpenDDS::DCPS::FreeIndex::init(), OpenDDS::DCPS::FreeHeader::init_free_block(), largest_free_, lwm_free_bytes_, pool_ptr_, pool_size_, and OpenDDS::DCPS::AllocHeader::size().

: granularity_(align(granularity, 8))
, min_alloc_size_(align(min_free_size - sizeof(AllocHeader), granularity_))
, pool_size_(align(pool_size, granularity_))
, pool_ptr_(new unsigned char[pool_size_])
, largest_free_(NULL)
, free_index_(largest_free_)
{
  AllocHeader* the_pool = new (pool_ptr_) AllocHeader();
  FreeHeader* first_free = reinterpret_cast<FreeHeader*>(the_pool);
  first_free->init_free_block(static_cast<unsigned int>(pool_size_));
  largest_free_ = first_free;
  free_index_.init(first_free);
  lwm_free_bytes_ = largest_free_->size();
#if defined(WITH_VALGRIND)
  VALGRIND_MAKE_MEM_NOACCESS(pool_ptr_, pool_size_);
  VALGRIND_CREATE_MEMPOOL(pool_ptr_, 0, false);
#endif
}

~MemoryPool()

OpenDDS::DCPS::MemoryPool::~MemoryPool

(

)

Definition at line 320 of file MemoryPool.cpp.

References pool_ptr_.

{
#ifndef OPENDDS_SAFETY_PROFILE
  delete [] pool_ptr_;
#endif
}

Member Function Documentation

align()

static size_t OpenDDS::DCPS::MemoryPool::align ( size_t  size, size_t  granularity  )

inlinestatic

Calculate aligned size of allocation

Definition at line 184 of file MemoryPool.h.

Referenced by pool_alloc().

                                                       {
     return (size + granularity - 1) / granularity * granularity; }

allocate()

unsigned char * OpenDDS::DCPS::MemoryPool::allocate ( FreeHeader *  free_block, size_t  alloc_size  )

private

Definition at line 496 of file MemoryPool.cpp.

References includes(), insert_free_alloc(), min_free_size, OpenDDS::DCPS::AllocHeader::next_adjacent(), OpenDDS::DCPS::AllocHeader::ptr(), remove_free_alloc(), OpenDDS::DCPS::AllocHeader::set_allocated(), OpenDDS::DCPS::AllocHeader::set_prev_size(), OpenDDS::DCPS::AllocHeader::set_size(), and OpenDDS::DCPS::AllocHeader::size().

Referenced by pool_alloc().

{
  size_t free_block_size = free_block->size();
  size_t remainder = free_block_size - alloc_size;

  // May not be enough room for another allocation
  if (remainder < min_free_size) {
    alloc_size = free_block_size; // use it all
    remainder = 0;
  }

  // If we are NOT allocating the whole block
  if (remainder) {
    // Account for header here - won't overflow due to check, above
    remainder -= sizeof(AllocHeader);

    // Adjust current adjacent block (after free block)
    AllocHeader* next_adjacent = free_block->next_adjacent();
    if (includes(next_adjacent)) {
      next_adjacent->set_prev_size(static_cast<int>(alloc_size));
    }

    // Always remove, resize, and reinsert to make sure free list and free
    // index are in sync
    remove_free_alloc(free_block);
    free_block->set_size(remainder);
    insert_free_alloc(free_block);

    // After resize, can use next_adjacent() to safely get to the end of the
    // resized block.
    // Taking free memory and allocating, so invoke constructor
    AllocHeader* alloc_block = new(free_block->next_adjacent()) AllocHeader();

    // Allocate adjacent block (at end of existing block)
    alloc_block->set_size(alloc_size);
    alloc_block->set_allocated();
    alloc_block->set_prev_size(static_cast<int>(remainder));
    return alloc_block->ptr();
  // Else we ARE allocating the whole block
  } else {
    free_block->set_allocated();
    // remove free_block from free list
    remove_free_alloc(free_block);
    return free_block->ptr();
  }
}

includes()

bool OpenDDS::DCPS::MemoryPool::includes ( void *  ptr ) const

inline

Does the pool include a given pointer

Definition at line 169 of file MemoryPool.h.

Referenced by allocate(), join_free_allocs(), joinable_next(), joinable_prev(), and pool_free().

                                 {
     return (pool_ptr_ <= ptr) && (ptr < pool_ptr_ + pool_size_); }

insert_free_alloc()

void OpenDDS::DCPS::MemoryPool::insert_free_alloc ( FreeHeader *  block_freed )

private

Definition at line 465 of file MemoryPool.cpp.

References OpenDDS::DCPS::FreeIndex::add(), OpenDDS::DCPS::FreeIndex::find(), free_index_, largest_free_, pool_ptr_, OpenDDS::DCPS::FreeHeader::set_larger_free(), OpenDDS::DCPS::FreeHeader::set_smaller_free(), OpenDDS::DCPS::AllocHeader::size(), and OpenDDS::DCPS::FreeHeader::smaller_free().

Referenced by allocate(), and join_free_allocs().

{
  // Find free alloc freed size or larger
  FreeHeader* alloc = free_index_.find(freed->size(), pool_ptr_);
  // If found
  if (alloc) {
    FreeHeader* smaller = alloc->smaller_free(pool_ptr_);

    // Insert into list
    freed->set_larger_free(alloc, pool_ptr_);
    alloc->set_smaller_free(freed, pool_ptr_);
    if (smaller) {
      smaller->set_larger_free(freed, pool_ptr_);
      freed->set_smaller_free(smaller, pool_ptr_);
    }
  // Else freed the largest alloc
  } else {
    if (freed != largest_free_) {
      freed->set_smaller_free(largest_free_, pool_ptr_);
      if (largest_free_) {
        largest_free_->set_larger_free(freed, pool_ptr_);
      }
      largest_free_ = freed;
    }
  }

  // Insert and replace alloc if necessary
  free_index_.add(freed);
}

join_free_allocs()

void OpenDDS::DCPS::MemoryPool::join_free_allocs ( FreeHeader *  block_freed )

private

Definition at line 408 of file MemoryPool.cpp.

References includes(), insert_free_alloc(), OpenDDS::DCPS::AllocHeader::join_next(), joinable_next(), joinable_prev(), OpenDDS::DCPS::AllocHeader::next_adjacent(), OpenDDS::DCPS::AllocHeader::prev_adjacent(), remove_free_alloc(), OpenDDS::DCPS::AllocHeader::set_prev_size(), and OpenDDS::DCPS::AllocHeader::size().

Referenced by pool_free().

{
  // Check adjacent
  if (joinable_next(freed)) {
    FreeHeader* next_free = reinterpret_cast<FreeHeader*>(freed->next_adjacent());
    remove_free_alloc(next_free);
    freed->join_next();
    // Adjust psize of adjacent
    AllocHeader* next = freed->next_adjacent();
    if (includes(next)) {
      next->set_prev_size(freed->size());
    }
  }
  if (joinable_prev(freed)) {
    FreeHeader* prev_free = reinterpret_cast<FreeHeader*>(freed->prev_adjacent());
    remove_free_alloc(prev_free);
    // Join prev with freed
    prev_free->join_next();
    insert_free_alloc(prev_free);
    // Adjust psize of adjacent
    AllocHeader* next = prev_free->next_adjacent();
    if (includes(next)) {
      next->set_prev_size(prev_free->size());
    }
  } else {
    insert_free_alloc(freed);
  }
}

joinable_next()

bool OpenDDS::DCPS::MemoryPool::joinable_next ( FreeHeader *  freed )

private

Definition at line 544 of file MemoryPool.cpp.

References includes(), OpenDDS::DCPS::AllocHeader::is_free(), and OpenDDS::DCPS::AllocHeader::next_adjacent().

Referenced by join_free_allocs().

{
  AllocHeader* next_alloc = freed->next_adjacent();
  return freed->is_free() &&
         includes(next_alloc) &&
         next_alloc->is_free();
}

joinable_prev()

bool OpenDDS::DCPS::MemoryPool::joinable_prev ( FreeHeader *  freed )

private

Definition at line 553 of file MemoryPool.cpp.

References free_index_, includes(), OpenDDS::DCPS::AllocHeader::is_free(), OpenDDS::DCPS::FreeHeader::larger_free(), largest_free_, OpenDDS::DCPS::AllocHeader::next_adjacent(), OPENDDS_END_VERSIONED_NAMESPACE_DECL, pool_ptr_, pool_size_, OpenDDS::DCPS::AllocHeader::prev_adjacent(), OpenDDS::DCPS::AllocHeader::prev_size(), ACE_OS::printf(), OpenDDS::DCPS::AllocHeader::ptr(), OpenDDS::DCPS::AllocHeader::size(), OpenDDS::DCPS::FreeHeader::smaller_free(), snprintf(), and TEST_CHECK.

Referenced by join_free_allocs().

{
  AllocHeader* prev_alloc = freed->prev_adjacent();
  return freed->is_free() &&
         includes(prev_alloc) &&
         prev_alloc->is_free();
}

lwm_free_bytes()

size_t OpenDDS::DCPS::MemoryPool::lwm_free_bytes

(

)

const

Low water mark of maximum available bytes for an allocation

Definition at line 328 of file MemoryPool.cpp.

References lwm_free_bytes_.

{
  return lwm_free_bytes_;
}

pool_alloc()

void * OpenDDS::DCPS::MemoryPool::pool_alloc

(

size_t

size

)

Allocate size bytes from the pool

Definition at line 334 of file MemoryPool.cpp.

References align(), allocate(), OpenDDS::DCPS::FreeIndex::find(), free_index_, granularity_, largest_free_, lwm_free_bytes_, min_alloc_size_, pool_ptr_, pool_size_, and OpenDDS::DCPS::AllocHeader::size().

{
#if defined(WITH_VALGRIND)
  VALGRIND_DISABLE_ADDR_ERROR_REPORTING_IN_RANGE(pool_ptr_, pool_size_);
#endif

  // Pointer to return
  unsigned char* block = NULL;

  // Round up to 8-byte boundary
  size_t aligned_size = align(size, granularity_);

  if (aligned_size < min_alloc_size_) {
    aligned_size = min_alloc_size_;
  }

  // The block to allocate from
  FreeHeader* block_to_alloc = free_index_.find(aligned_size, pool_ptr_);

  if (block_to_alloc) {
    block = allocate(block_to_alloc, aligned_size);
  }

  // Update lwm
  size_t largest_free_bytes = largest_free_ ? largest_free_->size() : 0;
  if (largest_free_bytes < lwm_free_bytes_) {
    lwm_free_bytes_ = largest_free_bytes;
  }

#ifdef VALIDATE_MEMORY_POOL
  validate_pool(*this, false);
#endif

#if defined(WITH_VALGRIND)
  VALGRIND_ENABLE_ADDR_ERROR_REPORTING_IN_RANGE(pool_ptr_, pool_size_);
  VALGRIND_MEMPOOL_ALLOC(pool_ptr_, block, size);
#endif

  return block;
}

pool_free()

bool OpenDDS::DCPS::MemoryPool::pool_free

(

void *

ptr

)

Attempt to free an allocation. Return true if allocation is managed by this pool (and thus was freed).

Definition at line 376 of file MemoryPool.cpp.

References header, includes(), join_free_allocs(), pool_ptr_, pool_size_, and OpenDDS::DCPS::FreeHeader::set_free().

{
  bool freed = false;
  if (ptr && includes(ptr)) {
#if defined(WITH_VALGRIND)
    VALGRIND_DISABLE_ADDR_ERROR_REPORTING_IN_RANGE(pool_ptr_, pool_size_);
#endif

    FreeHeader* header = reinterpret_cast<FreeHeader*>(
        reinterpret_cast<AllocHeader*>(ptr) - 1);

    // Free header
    header->set_free();

    join_free_allocs(header);

#ifdef VALIDATE_MEMORY_POOL
    validate_pool(*this, false);
#endif

    freed = true;

#if defined(WITH_VALGRIND)
    VALGRIND_DISABLE_ADDR_ERROR_REPORTING_IN_RANGE(pool_ptr_, pool_size_);
    VALGRIND_MEMPOOL_FREE(pool_ptr_, ptr);
#endif
  }

  return freed;
}

remove_free_alloc()

void OpenDDS::DCPS::MemoryPool::remove_free_alloc ( FreeHeader *  block_to_alloc )

private

Definition at line 438 of file MemoryPool.cpp.

References free_index_, OpenDDS::DCPS::FreeHeader::larger_free(), largest_free_, pool_ptr_, OpenDDS::DCPS::FreeIndex::remove(), OpenDDS::DCPS::FreeHeader::set_larger_free(), OpenDDS::DCPS::FreeHeader::set_smaller_free(), and OpenDDS::DCPS::FreeHeader::smaller_free().

Referenced by allocate(), and join_free_allocs().

{
  FreeHeader* smaller = block_to_alloc->smaller_free(pool_ptr_);
  FreeHeader* larger = block_to_alloc->larger_free(pool_ptr_);

  block_to_alloc->set_smaller_free(NULL, NULL);
  block_to_alloc->set_larger_free(NULL, NULL);

  // If this was the largest free alloc
  if (block_to_alloc == largest_free_) {
    // It no longer is
    largest_free_ = smaller;
  }

  if (larger) {
    larger->set_smaller_free(smaller, pool_ptr_);
  }

  if (smaller) {
    smaller->set_larger_free(larger, pool_ptr_);
  }

  // Remove from free index
  free_index_.remove(block_to_alloc, larger);
}

size()

size_t OpenDDS::DCPS::MemoryPool::size ( void  ) const

inline

Definition at line 187 of file MemoryPool.h.

{ return pool_size_; }

Friends And Related Function Documentation

Test::MemoryPoolTest

friend class Test::MemoryPoolTest

friend

Definition at line 163 of file MemoryPool.h.

Member Data Documentation

free_index_

FreeIndex OpenDDS::DCPS::MemoryPool::free_index_

private

Index of free nodex.

Definition at line 197 of file MemoryPool.h.

Referenced by insert_free_alloc(), joinable_prev(), MemoryPool(), pool_alloc(), and remove_free_alloc().

granularity_

const size_t OpenDDS::DCPS::MemoryPool::granularity_

private

Configured granularity.

Definition at line 190 of file MemoryPool.h.

Referenced by pool_alloc().

largest_free_

FreeHeader* OpenDDS::DCPS::MemoryPool::largest_free_

private

Pointer to largest free index.

Definition at line 196 of file MemoryPool.h.

Referenced by insert_free_alloc(), joinable_prev(), MemoryPool(), pool_alloc(), and remove_free_alloc().

lwm_free_bytes_

size_t OpenDDS::DCPS::MemoryPool::lwm_free_bytes_

private

Low water mark of available bytes.

Definition at line 193 of file MemoryPool.h.

Referenced by lwm_free_bytes(), MemoryPool(), and pool_alloc().

min_alloc_size_

const size_t OpenDDS::DCPS::MemoryPool::min_alloc_size_

private

Aligned minimum allocation size.

Definition at line 191 of file MemoryPool.h.

Referenced by pool_alloc().

pool_ptr_

unsigned char* OpenDDS::DCPS::MemoryPool::pool_ptr_

private

Pointer to pool.

Definition at line 194 of file MemoryPool.h.

Referenced by insert_free_alloc(), joinable_prev(), MemoryPool(), pool_alloc(), pool_free(), remove_free_alloc(), and ~MemoryPool().

pool_size_

const size_t OpenDDS::DCPS::MemoryPool::pool_size_

private

Configured pool size.

Definition at line 192 of file MemoryPool.h.

Referenced by joinable_prev(), MemoryPool(), pool_alloc(), and pool_free().

---

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

• MemoryPool.h
• MemoryPool.cpp