gum::FixedAllocator Class Reference

Allocates objects of one given size. More...

#include <agrum/tools/core/fixedAllocator.h>

Public Member Functions
const size_t &	objectSize ()
	Returns the size of block allocated by this FixedAllocator. More...
Constructors / Destructors
	FixedAllocator (const std::size_t &blockSize, const unsigned char &numBlocks=UCHAR_MAX)
	Constructor. More...
	~FixedAllocator ()
	Destructor. More...
Allocator / Deallocator
void *	allocate ()
	Allocates a block. More...
void	deallocate (void *pDeallocatedBlock)
	Deallocates a block. More...

Classes
struct	Chunk__
	Allocates objects of one given size. More...

Detailed Description

Allocates objects of one given size.

Fixed allocator knows how to allocate and deallocate blocks of fixed size but is not limited to a chunck size. Its capacity is limited only by the available memory. To achieve this, FixedAllocator aggregates a vector of Chunk objects. Whenever an allocation request occurs, FixedAllocators looks for a Chunk that can accomodate the request. If all Chunks are filled up, FixedAllocator appends a new Chunk.

Definition at line 58 of file fixedAllocator.h.

Member Typedef Documentation

Chunks__

typedef std::vector< Chunk__ > gum::FixedAllocator::Chunks__

private

Vector of Chunk__ objects.

Definition at line 178 of file fixedAllocator.h.

Constructor & Destructor Documentation

FixedAllocator()

INLINE gum::FixedAllocator::FixedAllocator	(	const std::size_t &	blockSize,
		const unsigned char &	numBlocks = UCHAR_MAX
	)

Constructor.

Parameters

blockSize	is the size of an allocated block.
numBlocks	is the number of block allocated per chunk numBlock * blockSize is the size that a chunk allocates directly when it is created

Definition at line 130 of file fixedAllocator_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                        {
    //    GUM_CONSTRUCTOR(FixedAllocator)
    blockSize__    = blockSize;
    numBlocks__    = numBlocks;
    allocChunk__   = chunks__.begin();
    deallocChunk__ = chunks__.begin();
  }

Here is the call graph for this function:

~FixedAllocator()

INLINE gum::FixedAllocator::~FixedAllocator

(

)

Destructor.

Definition at line 142 of file fixedAllocator_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                         {
    for (Chunks__::iterator chunkIter = chunks__.begin();
         chunkIter != chunks__.end();
         ++chunkIter)
      chunkIter->release__();
    //    GUM_DESTRUCTOR(FixedAllocator)
  }

Here is the call graph for this function:

Member Function Documentation

allocate()

INLINE void * gum::FixedAllocator::allocate

(

)

Allocates a block.

Definition at line 157 of file fixedAllocator_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                        {
    if (chunks__.empty() || allocChunk__->blocksAvailable__ == 0) {
      // no available memory in this chunk
      // Try to find one with memory available
      for (Chunks__::iterator chunksIter = chunks__.begin();; ++chunksIter) {
        if (chunksIter == chunks__.end()) {
          // All chunks are filled up. Adding a new one
          chunks__.reserve(chunks__.size() + 1);
          Chunk__ newChunk;
          newChunk.init__(blockSize__, numBlocks__);
          chunks__.push_back(newChunk);
          allocChunk__ = chunks__.end();
          --allocChunk__;
          deallocChunk__ = allocChunk__;
          break;
        }
        if (chunksIter->blocksAvailable__ > 0) {
          // Found a chunk
          allocChunk__ = chunksIter;
          break;
        }
      }
    }
    return allocChunk__->allocate__(blockSize__);
  }

Here is the call graph for this function:

deallocate()

INLINE void gum::FixedAllocator::deallocate

(

void *

pDeallocatedBlock

)

Deallocates a block.

Definition at line 186 of file fixedAllocator_inl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                {
    if (deallocChunk__->pData__ > pDeallocatedBlock
        || pDeallocatedBlock
              > (deallocChunk__->pData__ + (numBlocks__ * blockSize__))) {
      // If not things get ugly
      // We have to find where the Chunk containing this pointer is
      std::ptrdiff_t offset = 0;

      // We perform a bidirectionnal search from deallocChunk__
      while (true) {
        ++offset;
        // First we look for the one going to the end of the vector
        if ((deallocChunk__ + offset) < chunks__.end()) {
          if ((deallocChunk__ + offset)->pData__ <= pDeallocatedBlock
              && pDeallocatedBlock < ((deallocChunk__ + offset)->pData__
                                      + (numBlocks__ * blockSize__))) {
            // If pointed chunk contains this pointer, deallocation find the
            // place
            deallocChunk__ = (deallocChunk__ + offset);
            break;
          }
        }

        // Then we look for the one going to the beginning of the vector
        if ((deallocChunk__ - offset) >= chunks__.begin()) {
          if ((deallocChunk__ - offset)->pData__ <= pDeallocatedBlock
              && pDeallocatedBlock < ((deallocChunk__ - offset)->pData__
                                      + (numBlocks__ * blockSize__))) {
            // If pointed chunk contains this pointer, deallocation find the
            // place
            deallocChunk__ = (deallocChunk__ - offset);
            break;
          }
        }
      }
    }
    deallocChunk__->deallocat__(pDeallocatedBlock, blockSize__);
  }

Here is the call graph for this function:

objectSize()

const size_t& gum::FixedAllocator::objectSize ( )

inline

Returns the size of block allocated by this FixedAllocator.

Definition at line 162 of file fixedAllocator.h.

References blockSize__.

{ return blockSize__; }

Member Data Documentation

allocChunk__

Chunks__::iterator gum::FixedAllocator::allocChunk__

private

Last Chunk used for an allocation.

Definition at line 184 of file fixedAllocator.h.

blockSize__

std::size_t gum::FixedAllocator::blockSize__

private

Size of a memory block allocated.

Definition at line 168 of file fixedAllocator.h.

Referenced by objectSize().

chunks__

Chunks__ gum::FixedAllocator::chunks__

private

Definition at line 179 of file fixedAllocator.h.

deallocChunk__

Chunks__::iterator gum::FixedAllocator::deallocChunk__

private

Last Chunk used for a deallocation.

Definition at line 189 of file fixedAllocator.h.

numBlocks__

unsigned char gum::FixedAllocator::numBlocks__

private

The maximum number of blocks a chunk can allocate.

Definition at line 173 of file fixedAllocator.h.

---

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

• agrum/tools/core/smallobjectallocator/fixedAllocator.h
• agrum/tools/core/smallobjectallocator/fixedAllocator_inl.h