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 __blocksAvailable, __firstAvailableBlock, and __pData.

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

__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 __blocksAvailable, __firstAvailableBlock, and __pData.

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

__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 __blocksAvailable, __firstAvailableBlock, and __pData.

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

                                                                              {
    // 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 caller 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 __pData.

{ delete[] __pData; }

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.

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

Referenced by __allocate(), __deallocat(), __init(), __release(), and gum::FixedAllocator::deallocate().

---

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

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