gum::FixedAllocator::_Chunk_ Struct Reference

Allocates objects of one given size. More...

Public Member Functions
void	_init_ (const std::size_t &blockSize, const unsigned char &numBlocks)
	Initializes a Chunk object.
void *	_allocate_ (const std::size_t &blockSize)
	Allocates a block of memory.
void	_deallocat_ (void *p, const std::size_t &blockSize)
	Deallocates a block of memory.
void	_release_ ()
	Releases the allocated memory.

Public Attributes
unsigned char *	_pData_
	Pointer to the managed memory itself.
unsigned char	_firstAvailableBlock_
	Holds the index of the first block available in this chunck.
unsigned char	_blocksAvailable_
	Number of blocks available in this chunck.

Detailed Description

Allocates objects of one given size.

Has a fixed limit of allocation

Each object of type Chunk contains and manages a chunk of memory containing a amount of blocks. At construction time, you configure the block size and the number of blocks. A Chunk contains logic that allows you to allocate and deallocate memory blocks from that chunk of memory. When there are no more blocks available in the chunk, the allocation function returns zero.

Definition at line 98 of file fixedAllocator.h.

Member Function Documentation

_allocate_()

void * gum::FixedAllocator::_Chunk_::_allocate_

(

const std::size_t &

blockSize

)

Allocates a block of memory.

Definition at line 83 of file fixedAllocator.cpp.

                                                                    {
    if (!_blocksAvailable_) {
      // If no block is available return nullptr
      return nullptr;
    }
 
    //  _pData_ points to the beginning of allocated space.
    //  _firstAvailableBlock_ gives us how many block to pass before getting
    // the good one. We have to multiply by blockSize to get the good memory
    // emplacement
    unsigned char* pResult = _pData_ + (_firstAvailableBlock_ * blockSize);
 
    // Remember that the first byte of each block gives us the index of next
    // available slot.
    // The new first available block will be at the index indicating in this
    // block.
    _firstAvailableBlock_ = *pResult;
 
    // We lose one block
    --_blocksAvailable_;
 
    return pResult;
  }

References _blocksAvailable_, _firstAvailableBlock_, and _pData_.

_deallocat_()

void gum::FixedAllocator::_Chunk_::_deallocat_	(	void *	p,
		const std::size_t &	blockSize )

Deallocates a block of memory.

Definition at line 107 of file fixedAllocator.cpp.

                                                                                             {
    // first, ensure that deallocated is in this chunk
    GUM_ASSERT(pDeallocatedBlock >= _pData_);
 
    // Conversion pf pointer for handling
    unsigned char* toRelease = static_cast< unsigned char* >(pDeallocatedBlock);
 
    // Alignement check
    GUM_ASSERT((toRelease - _pData_) % blockSize == 0);
 
    // First byte of toRelease has now to give the index of current first
    // available block
    *toRelease = _firstAvailableBlock_;
 
    // So that first available block points to it
    _firstAvailableBlock_ = static_cast< unsigned char >((toRelease - _pData_) / blockSize);
 
    // Truncation check
    GUM_ASSERT(_firstAvailableBlock_ == (toRelease - _pData_) / blockSize);
 
    // We gain one block, yeah
    ++_blocksAvailable_;
  }

References _blocksAvailable_, _firstAvailableBlock_, and _pData_.

_init_()

void gum::FixedAllocator::_Chunk_::_init_	(	const std::size_t &	blockSize,
		const unsigned char &	numBlocks )

Initializes a Chunk object.

Definition at line 59 of file fixedAllocator.cpp.

                                                                       {
    // Chunk memory space allocation. A chunk allocates a memory of blockSize *
    // numBlocks size.
    // The chunk will then give us numBlocks distinct blocks of blockSize from
    // that space.
    _pData_ = new unsigned char[blockSize * numBlocks];
 
    // The first available block of memory is logically at the beginning.
    _firstAvailableBlock_ = 0;
 
    // The number of block still available is all the blocks at the beginning.
    _blocksAvailable_ = numBlocks;
 
    // For each unallocated block, the first byte contains a number.
    // That number is the index of the next available block
    // Since we're at the beginning, next free block is the next one simply.
    // Following code initiate those number for each block
    unsigned char* p = _pData_;
    for (unsigned char indexBlock = 0; indexBlock != numBlocks; p += blockSize) {
      *p = ++indexBlock;
    }
  }

References _blocksAvailable_, _firstAvailableBlock_, and _pData_.

Referenced by gum::FixedAllocator::allocate().

Here is the caller graph for this function:

_release_()

INLINE void gum::FixedAllocator::_Chunk_::_release_

(

)

Releases the allocated memory.

Definition at line 74 of file fixedAllocator_inl.h.

{ delete[] _pData_; }

References _pData_.

Member Data Documentation

_blocksAvailable_

unsigned char gum::FixedAllocator::_Chunk_::_blocksAvailable_

Number of blocks available in this chunck.

Definition at line 132 of file fixedAllocator.h.

Referenced by _allocate_(), _deallocat_(), and _init_().

_firstAvailableBlock_

unsigned char gum::FixedAllocator::_Chunk_::_firstAvailableBlock_

Holds the index of the first block available in this chunck.

Definition at line 127 of file fixedAllocator.h.

Referenced by _allocate_(), _deallocat_(), and _init_().

_pData_

unsigned char* gum::FixedAllocator::_Chunk_::_pData_

Pointer to the managed memory itself.

Definition at line 122 of file fixedAllocator.h.

Referenced by _allocate_(), _deallocat_(), _init_(), and _release_().

---

The documentation for this struct 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