gum::FixedAllocator Class Reference

Allocates objects of one given size. More...

#include <agrum/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 56 of file fixedAllocator.h.

Member Typedef Documentation

__Chunks

typedef std::vector< __Chunk > gum::FixedAllocator::__Chunks

private

Vector of __Chunk objects.

Definition at line 176 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 128 of file fixedAllocator_inl.h.

References __allocChunk, __blockSize, __chunks, __deallocChunk, and __numBlocks.

                                                                        {
    //    GUM_CONSTRUCTOR(FixedAllocator)
    __blockSize = blockSize;
    __numBlocks = numBlocks;
    __allocChunk = __chunks.begin();
    __deallocChunk = __chunks.begin();
  }

~FixedAllocator()

INLINE gum::FixedAllocator::~FixedAllocator

(

)

Destructor.

Definition at line 140 of file fixedAllocator_inl.h.

References __chunks.

                                         {
    for (__Chunks::iterator chunkIter = __chunks.begin();
         chunkIter != __chunks.end();
         ++chunkIter)
      chunkIter->__release();
    //    GUM_DESTRUCTOR(FixedAllocator)
  }

Member Function Documentation

allocate()

INLINE void * gum::FixedAllocator::allocate

(

)

Allocates a block.

Definition at line 155 of file fixedAllocator_inl.h.

References __allocChunk, __blockSize, __chunks, __deallocChunk, gum::FixedAllocator::__Chunk::__init(), and __numBlocks.

                                        {
    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 184 of file fixedAllocator_inl.h.

References __blockSize, __chunks, __deallocChunk, __numBlocks, and gum::FixedAllocator::__Chunk::__pData.

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

objectSize()

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

inline

Returns the size of block allocated by this FixedAllocator.

Definition at line 160 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 182 of file fixedAllocator.h.

Referenced by allocate(), and FixedAllocator().

__blockSize

std::size_t gum::FixedAllocator::__blockSize

private

Size of a memory block allocated.

Definition at line 166 of file fixedAllocator.h.

Referenced by allocate(), deallocate(), FixedAllocator(), and objectSize().

__chunks

__Chunks gum::FixedAllocator::__chunks

private

Definition at line 177 of file fixedAllocator.h.

Referenced by allocate(), deallocate(), FixedAllocator(), and ~FixedAllocator().

__deallocChunk

__Chunks::iterator gum::FixedAllocator::__deallocChunk

private

Last Chunk used for a deallocation.

Definition at line 187 of file fixedAllocator.h.

Referenced by allocate(), deallocate(), and FixedAllocator().

__numBlocks

unsigned char gum::FixedAllocator::__numBlocks

private

The maximum number of blocks a chunk can allocate.

Definition at line 171 of file fixedAllocator.h.

Referenced by allocate(), deallocate(), and FixedAllocator().

---

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

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