gum::FixedAllocator::_Chunk_ Struct Reference

Allocates objects of one given size. More...

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

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

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 80 of file fixedAllocator.h.

Member Function Documentation

_allocate_()

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

(

const std::size_t &

blockSize

)

Allocates a block of memory.

Definition at line 65 of file fixedAllocator_inl.h.

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

                                                                           {
    if (!_blocksAvailable_)
      // If no block is available return nullptr
      return NULL;

    //  _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 availble block will be at the index indicating in this
    // block.
    _firstAvailableBlock_ = *pResult;

    // We lose one block
    --_blocksAvailable_;

    return pResult;
  }

Here is the call graph for this function:

_deallocat_()

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

Deallocates a block of memory.

Definition at line 91 of file fixedAllocator_inl.h.

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

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

Here is the call graph for this function:

_init_()

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

Initializes a Chunk object.

Definition at line 39 of file fixedAllocator_inl.h.

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

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

Here is the call graph for this function:

_release_()

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

(

)

Releases the allocated memory.

Definition at line 119 of file fixedAllocator_inl.h.

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

{ delete[] _pData_; }

Here is the call graph for this function:

Member Data Documentation

_blocksAvailable_

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

Number of blocks available in this chunck.

Definition at line 114 of file fixedAllocator.h.

_firstAvailableBlock_

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

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

Definition at line 109 of file fixedAllocator.h.

_pData_

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

Pointer to the managed memory itself.

Definition at line 104 of file fixedAllocator.h.

---

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

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