A size-based allocator that caches blocks for quicker access, but if the pool is exhausted it will use the heap. More...

#include <Dynamic_Cached_Allocator_With_Overflow_T.h>

Inheritance diagram for OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_LOCK >:

[legend]

Collaboration diagram for OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_LOCK >:

[legend]

Public Member Functions
	Dynamic_Cached_Allocator_With_Overflow (size_t n_chunks, size_t chunk_size)

	~Dynamic_Cached_Allocator_With_Overflow ()
	Clear things up. More...

void *	malloc (size_t nbytes=0)

virtual void *	calloc (size_t, char='\0')

virtual void *	calloc (size_t, size_t, char='\0')

void	free (void *ptr)
	Return a chunk of memory back to free list cache. More...

size_t	pool_depth ()
	Return the number of chunks available in the cache. More...

size_t	available ()

Public Member Functions inherited from ACE_New_Allocator
virtual int	remove (void)

virtual int	bind (const char name, void pointer, int duplicates=0)

virtual int	trybind (const char name, void &pointer)

virtual int	find (const char name, void &pointer)

virtual int	find (const char *name)

virtual int	unbind (const char *name)

virtual int	unbind (const char name, void &pointer)

virtual int	sync (ssize_t len=-1, int flags=MS_SYNC)

virtual int	sync (void *addr, size_t len, int flags=MS_SYNC)

virtual int	protect (ssize_t len=-1, int prot=PROT_RDWR)

virtual int	protect (void *addr, size_t len, int prot=PROT_RDWR)

virtual void	dump (void) const

Public Member Functions inherited from ACE_Allocator
	ACE_Allocator (void)

virtual	~ACE_Allocator (void)

Public Attributes
Atomic< unsigned long >	allocs_from_heap_
	number of allocations from the heap. More...

Atomic< unsigned long >	allocs_from_pool_
	number of allocations from the pool. More...

Atomic< unsigned long >	frees_to_heap_
	number of frees returned to the heap More...

Atomic< unsigned long >	frees_to_pool_
	number of frees returned to the pool More...

Private Attributes
unsigned char *	begin_

unsigned char *	end_
	The end of the pool. More...

ACE_Locked_Free_List< ACE_Cached_Mem_Pool_Node< char >, ACE_LOCK >	free_list_

size_t	chunk_size_
	Remember the size of our chunks. More...

Additional Inherited Members
Public Types inherited from ACE_Allocator
typedef size_t	size_type

Static Public Member Functions inherited from ACE_Allocator
static ACE_Allocator *	instance (void)

static ACE_Allocator *	instance (ACE_Allocator *)

static void	close_singleton (void)

Detailed Description

template<class ACE_LOCK>
class OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_LOCK >

A size-based allocator that caches blocks for quicker access, but if the pool is exhausted it will use the heap.

This class enables caching of dynamically allocated, fixed-size chunks. Notice that the chunk_size must be greater than or equal to sizeof (void*) for this to work properly.

This class can be configured flexibly with different types of ACE_LOCK strategies that support the ACE_Thread_Mutex and ACE_Process_Mutex constructor API.

Definition at line 45 of file Dynamic_Cached_Allocator_With_Overflow_T.h.

Constructor & Destructor Documentation

◆ Dynamic_Cached_Allocator_With_Overflow()

template<class ACE_LOCK>

OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_LOCK >::Dynamic_Cached_Allocator_With_Overflow	(	size_t	n_chunks,
		size_t	chunk_size
	)

inline

Create a cached memory pool with n_chunks chunks each with chunk_size size.

Definition at line 49 of file Dynamic_Cached_Allocator_With_Overflow_T.h.

   : allocs_from_heap_(0),
     allocs_from_pool_(0),
     frees_to_heap_(0),
     frees_to_pool_(0),
     free_list_(ACE_PURE_FREE_LIST)
   {
     chunk_size_ = ACE_MALLOC_ROUNDUP(chunk_size, ACE_MALLOC_ALIGN);
     begin_ = static_cast<unsigned char*> (ACE_Allocator::instance()->malloc(n_chunks * chunk_size_));
     // Remember end of the pool.
     end_ = begin_ + n_chunks * chunk_size_;
 
     // Put into free list using placement contructor, no real memory
     // allocation in the <new> below.
     for (size_t c = 0;
          c < n_chunks;
          c++) {
       void* placement = begin_ + c * chunk_size_;
 
       free_list_.add(new(placement) ACE_Cached_Mem_Pool_Node<char>);
     }
   }

◆ ~Dynamic_Cached_Allocator_With_Overflow()

template<class ACE_LOCK>

OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_LOCK >::~Dynamic_Cached_Allocator_With_Overflow ( )

inline

Clear things up.

Definition at line 73 of file Dynamic_Cached_Allocator_With_Overflow_T.h.

                                             {
     ACE_Allocator::instance()->free(begin_);
     begin_ = 0;
     chunk_size_ = 0;
   }

Member Function Documentation

◆ available()

template<class ACE_LOCK>

size_t OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_LOCK >::available ( void )

inline

How many chunks are available at this time.

Definition at line 212 of file Dynamic_Cached_Allocator_With_Overflow_T.h.

Referenced by OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_Thread_Mutex >::free(), and OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_Thread_Mutex >::malloc().

                      {
     return free_list_.size();
   };

◆ calloc() [1/2]

template<class ACE_LOCK>

virtual void* OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_LOCK >::calloc	(	size_t	,
		char	= `'\0'`
	)

inlinevirtual

Get a chunk of memory from free list cache, giving them initial_value. Note that nbytes is only checked to make sure that it's less or equal to chunk_size, and is otherwise ignored since calloc() always returns a pointer to an item of chunk_size.

Reimplemented from ACE_New_Allocator.

Definition at line 137 of file Dynamic_Cached_Allocator_With_Overflow_T.h.

                                       {
     ACE_NOTSUP_RETURN(0);
   }

◆ calloc() [2/2]

template<class ACE_LOCK>

virtual void* OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_LOCK >::calloc	(	size_t	,
		size_t	,
		char	= `'\0'`
	)

inlinevirtual

This method is a no-op and just returns 0 since the free list only works with fixed sized entities.

Reimplemented from ACE_New_Allocator.

Definition at line 144 of file Dynamic_Cached_Allocator_With_Overflow_T.h.

                                       {
     ACE_NOTSUP_RETURN(0);
   }

◆ free()

template<class ACE_LOCK>

void OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_LOCK >::free ( void * ptr )

inlinevirtual

Return a chunk of memory back to free list cache.

Reimplemented from ACE_New_Allocator.

Definition at line 151 of file Dynamic_Cached_Allocator_With_Overflow_T.h.

                         {
     unsigned char* tmp = static_cast<unsigned char*> (ptr);
     if (tmp < begin_ ||
         tmp >= end_) {
       ACE_Allocator::instance()->free(tmp);
       frees_to_heap_ ++;
 
       if (frees_to_heap_ > allocs_from_heap_) {
         ACE_ERROR((LM_ERROR,
                    "(%P|%t) ERROR: Dynamic_Cached_Allocator_With_Overflow::free %x"
                    " more deletes %d than allocs %d to the heap\n",
                    this,
                    frees_to_heap_.load(),
                    allocs_from_heap_.load()));
       }
 
       if (DCPS_debug_level >= 6) {
         if (frees_to_heap_ % 500 == 0) {
           ACE_DEBUG((LM_DEBUG,
                      "(%P|%t) Dynamic_Cached_Allocator_With_Overflow::free %@"
                      " %Lu heap allocs with %Lu outstanding\n",
                      this, allocs_from_heap_.load(),
                      allocs_from_heap_.load() - frees_to_heap_.load()));
         }
       }
 
       return;
 
     } else if (ptr != 0) {
       frees_to_pool_ ++;
 
       if (frees_to_pool_ > allocs_from_pool_) {
         ACE_ERROR((LM_ERROR,
                    "(%P|%t) ERROR: Dynamic_Cached_Allocator_With_Overflow::free %x"
                    " more deletes %d than allocs %d from the pool\n",
                    this,
                    frees_to_pool_.load(),
                    allocs_from_pool_.load()));
       }
 
       free_list_.add((ACE_Cached_Mem_Pool_Node<char> *) ptr) ;
 
       if (DCPS_debug_level >= 6)
         if (available() % 500 == 0)
           ACE_DEBUG((LM_DEBUG,
                      "(%P|%t) Dynamic_Cached_Allocator_With_Overflow::malloc %x"
                      " %d pool allocs %d pool frees with %d available\n",
                      this, allocs_from_pool_.load(), frees_to_pool_.load(),
                      available()));
     }
   }

◆ malloc()

template<class ACE_LOCK>

void* OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_LOCK >::malloc ( size_t nbytes = 0 )

inlinevirtual

Get a chunk of memory from free list cache. Note that nbytes is only checked to make sure that it's less or equal to chunk_size, and is otherwise ignored since malloc() always returns a pointer to an item of chunk_size size.

Reimplemented from ACE_New_Allocator.

Definition at line 85 of file Dynamic_Cached_Allocator_With_Overflow_T.h.

                                   {
     // Check if size requested fits within pre-determined size.
     if (nbytes > chunk_size_)
       return 0;
 
     // addr() call is really not absolutely necessary because of the way
     // ACE_Cached_Mem_Pool_Node's internal structure arranged.
     void* rtn = free_list_.remove()->addr();
 
     if (0 == rtn) {
       rtn = ACE_Allocator::instance()->malloc(chunk_size_);
       allocs_from_heap_++;
 
       if (DCPS_debug_level >= 2) {
         if (allocs_from_heap_ == 1 && DCPS_debug_level >= 2)
           ACE_DEBUG((LM_DEBUG,
                      "(%P|%t) Dynamic_Cached_Allocator_With_Overflow::malloc %x"
                      " %d heap allocs with %d outstanding\n",
                      this, allocs_from_heap_.load(),
                      allocs_from_heap_.load() - frees_to_heap_.load()));
 
         if (DCPS_debug_level >= 6)
           if (allocs_from_heap_ % 500 == 0)
             ACE_DEBUG((LM_DEBUG,
                        "(%P|%t) Dynamic_Cached_Allocator_With_Overflow::malloc %@"
                        " %Lu heap allocs with %Lu outstanding\n",
                        this, allocs_from_heap_.load(),
                        allocs_from_heap_.load() - frees_to_heap_.load()));
       }
 
     } else {
       allocs_from_pool_++;
 
       if (DCPS_debug_level >= 6)
         if (allocs_from_pool_ % 500 == 0)
           ACE_DEBUG((LM_DEBUG,
                      "(%P|%t) Dynamic_Cached_Allocator_With_Overflow::malloc %x"
                      " %d pool allocs %d pool free with %d available\n",
                      this, allocs_from_pool_.load(),
                      frees_to_pool_.load(),
                      available()));
     }
 
     return rtn;
   }

◆ pool_depth()

template<class ACE_LOCK>

size_t OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_LOCK >::pool_depth ( )

inline

Return the number of chunks available in the cache.

Definition at line 204 of file Dynamic_Cached_Allocator_With_Overflow_T.h.

                       {
     return free_list_.size() ;
   }

Member Data Documentation

◆ allocs_from_heap_

template<class ACE_LOCK>

Atomic<unsigned long> OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_LOCK >::allocs_from_heap_

number of allocations from the heap.

Definition at line 214 of file Dynamic_Cached_Allocator_With_Overflow_T.h.

Referenced by OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_Thread_Mutex >::free(), and OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_Thread_Mutex >::malloc().

◆ allocs_from_pool_

template<class ACE_LOCK>

Atomic<unsigned long> OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_LOCK >::allocs_from_pool_

number of allocations from the pool.

Definition at line 219 of file Dynamic_Cached_Allocator_With_Overflow_T.h.

Referenced by OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_Thread_Mutex >::free(), and OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_Thread_Mutex >::malloc().

◆ begin_

template<class ACE_LOCK>

unsigned char* OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_LOCK >::begin_

private

Remember how we allocate the memory in the first place so we can clear things up later.

Definition at line 227 of file Dynamic_Cached_Allocator_With_Overflow_T.h.

Referenced by OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_Thread_Mutex >::Dynamic_Cached_Allocator_With_Overflow(), OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_Thread_Mutex >::free(), and OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_Thread_Mutex >::~Dynamic_Cached_Allocator_With_Overflow().

◆ chunk_size_

template<class ACE_LOCK>

size_t OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_LOCK >::chunk_size_

private

Remember the size of our chunks.

Definition at line 238 of file Dynamic_Cached_Allocator_With_Overflow_T.h.

Referenced by OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_Thread_Mutex >::Dynamic_Cached_Allocator_With_Overflow(), OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_Thread_Mutex >::malloc(), and OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_Thread_Mutex >::~Dynamic_Cached_Allocator_With_Overflow().

◆ end_

template<class ACE_LOCK>

unsigned char* OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_LOCK >::end_

private

The end of the pool.

Definition at line 229 of file Dynamic_Cached_Allocator_With_Overflow_T.h.

Referenced by OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_Thread_Mutex >::Dynamic_Cached_Allocator_With_Overflow(), and OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_Thread_Mutex >::free().

◆ free_list_

template<class ACE_LOCK>

ACE_Locked_Free_List<ACE_Cached_Mem_Pool_Node<char>, ACE_LOCK> OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_LOCK >::free_list_

private

Maintain a cached memory free list. We use char as template parameter, although sizeof(char) is usually less than sizeof(void*). Really important is that chunk_size must be greater or equal to sizeof(void*).

Definition at line 235 of file Dynamic_Cached_Allocator_With_Overflow_T.h.

Referenced by OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_Thread_Mutex >::available(), OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_Thread_Mutex >::Dynamic_Cached_Allocator_With_Overflow(), OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_Thread_Mutex >::free(), OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_Thread_Mutex >::malloc(), and OpenDDS::DCPS::Dynamic_Cached_Allocator_With_Overflow< ACE_Thread_Mutex >::pool_depth().