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 120 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