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 177 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 129 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 141 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 154 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 183 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 161 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 183 of file fixedAllocator.h.

_blockSize_

std::size_t gum::FixedAllocator::_blockSize_

private

Size of a memory block allocated.

Definition at line 167 of file fixedAllocator.h.

Referenced by objectSize().

_chunks_

_Chunks_ gum::FixedAllocator::_chunks_

private

Definition at line 178 of file fixedAllocator.h.

_deallocChunk_

_Chunks_::iterator gum::FixedAllocator::_deallocChunk_

private

Last Chunk used for a deallocation.

Definition at line 188 of file fixedAllocator.h.

_numBlocks_

unsigned char gum::FixedAllocator::_numBlocks_

private

The maximum number of blocks a chunk can allocate.

Definition at line 172 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