gum::FixedAllocator Class Reference

Allocates objects of one given size. More...

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

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

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

Private Types
using	_Chunks_ = std::vector< _Chunk_ >
	Vector of Chunk objects.

Private Attributes
std::size_t	_blockSize_
	Size of a memory block allocated.
unsigned char	_numBlocks_
	The maximum number of blocks a chunk can allocate.
_Chunks_	_chunks_
_Chunks_::iterator	_allocChunk_
	Last Chunk used for an allocation.
_Chunks_::iterator	_deallocChunk_
	Last Chunk used for a deallocation.

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 chunk 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 accommodate the request. If all Chunks are filled up, FixedAllocator appends a new Chunk.

Definition at line 79 of file fixedAllocator.h.

Member Typedef Documentation

_Chunks_

using gum::FixedAllocator::_Chunks_ = std::vector< _Chunk_ >

private

Vector of Chunk objects.

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

                                                                        {
    //    GUM_CONSTRUCTOR(FixedAllocator);
    _blockSize_    = blockSize;
    _numBlocks_    = numBlocks;
    _allocChunk_   = _chunks_.begin();
    _deallocChunk_ = _chunks_.begin();
  }

References _allocChunk_, _blockSize_, _chunks_, _deallocChunk_, and _numBlocks_.

~FixedAllocator()

INLINE gum::FixedAllocator::~FixedAllocator

(

)

Destructor.

Definition at line 95 of file fixedAllocator_inl.h.

                                         {
    for (_Chunks_::iterator chunkIter = _chunks_.begin(); chunkIter != _chunks_.end();
         ++chunkIter) {
      chunkIter->_release_();
    }
    //    GUM_DESTRUCTOR(FixedAllocator);
  }

References _chunks_.

Member Function Documentation

allocate()

void * gum::FixedAllocator::allocate

(

)

Allocates a block.

Definition at line 131 of file fixedAllocator.cpp.

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

References _allocChunk_, _blockSize_, _chunks_, _deallocChunk_, gum::FixedAllocator::_Chunk_::_init_(), and _numBlocks_.

Here is the call graph for this function:

deallocate()

void gum::FixedAllocator::deallocate

(

void *

pDeallocatedBlock

)

Deallocates a block.

Definition at line 157 of file fixedAllocator.cpp.

                                                         {
    bool chunk_found = true;
    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 bidirectional search from  _deallocChunk_
      bool iter_ok = true;
      while (iter_ok) {
        iter_ok = false;
        ++offset;
        // First we look for the one going to the end of the vector
        if ((_deallocChunk_ + offset) < _chunks_.end()) {
          iter_ok = true;
          if ((_deallocChunk_ + offset)->_pData_ <= pDeallocatedBlock
              && pDeallocatedBlock
                     < ((_deallocChunk_ + offset)->_pData_ + (_numBlocks_ * _blockSize_))) {
            // If pointed chunk contains this pointer, deallocation find the
            // place
            _deallocChunk_ = (_deallocChunk_ + offset);
            chunk_found    = true;
            break;
          }
        }
 
        // Then we look for the one going to the beginning of the vector
        if ((_deallocChunk_ - offset) >= _chunks_.begin()) {
          iter_ok = true;
          if ((_deallocChunk_ - offset)->_pData_ <= pDeallocatedBlock
              && pDeallocatedBlock
                     < ((_deallocChunk_ - offset)->_pData_ + (_numBlocks_ * _blockSize_))) {
            // If pointed chunk contains this pointer, deallocation find the
            // place
            _deallocChunk_ = (_deallocChunk_ - offset);
            chunk_found    = true;
            break;
          }
        }
      }
    }
 
    if (chunk_found) { _deallocChunk_->_deallocat_(pDeallocatedBlock, _blockSize_); }
  }

References _blockSize_, _chunks_, _deallocChunk_, and _numBlocks_.

objectSize()

INLINE const size_t & gum::FixedAllocator::objectSize

(

)

Returns the size of block allocated by this FixedAllocator.

Definition at line 118 of file fixedAllocator_inl.h.

{ return _blockSize_; }

References _blockSize_.

Member Data Documentation

_allocChunk_

_Chunks_::iterator gum::FixedAllocator::_allocChunk_

private

Last Chunk used for an allocation.

Definition at line 201 of file fixedAllocator.h.

Referenced by FixedAllocator(), and allocate().

_blockSize_

std::size_t gum::FixedAllocator::_blockSize_

private

Size of a memory block allocated.

Definition at line 185 of file fixedAllocator.h.

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

_chunks_

_Chunks_ gum::FixedAllocator::_chunks_

private

Definition at line 196 of file fixedAllocator.h.

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

_deallocChunk_

_Chunks_::iterator gum::FixedAllocator::_deallocChunk_

private

Last Chunk used for a deallocation.

Definition at line 206 of file fixedAllocator.h.

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

_numBlocks_

unsigned char gum::FixedAllocator::_numBlocks_

private

The maximum number of blocks a chunk can allocate.

Definition at line 190 of file fixedAllocator.h.

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

---

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

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