G3D::BufferPool Class Reference

Classes
class	MemBlock

Public Types
enum	{ tinyBufferSize = 128, smallBufferSize = 1024, medBufferSize = 4096 }
enum	{ maxTinyBuffers = 250000, maxSmallBuffers = 40000, maxMedBuffers = 5000 }

Public Member Functions
	BufferPool ()
	~BufferPool ()
UserPtr	realloc (UserPtr ptr, size_t bytes)
UserPtr	malloc (size_t bytes)
void	free (UserPtr ptr)
std::string	performance () const
std::string	status () const

Public Attributes
int	totalMallocs
int	mallocsFromTinyPool
int	mallocsFromSmallPool
int	mallocsFromMedPool
volatile size_t	bytesAllocated

Private Types
typedef void *	UserPtr
typedef void *	RealPtr

Private Member Functions
void	lock ()
void	unlock ()
UserPtr	tinyMalloc (size_t bytes)
bool	inTinyHeap (UserPtr ptr)
void	tinyFree (UserPtr ptr)
void	flushPool (MemBlock *pool, int &poolSize)
UserPtr	malloc (MemBlock *pool, int &poolSize, size_t bytes)

Private Attributes
MemBlock	smallPool [maxSmallBuffers]
int	smallPoolSize
MemBlock	medPool [maxMedBuffers]
int	medPoolSize
void *	tinyPool [maxTinyBuffers]
int	tinyPoolSize
void *	tinyHeap
Spinlock	m_lock

Member Typedef Documentation

typedef void* G3D::BufferPool::RealPtr

private

Actual block allocated on the heap

typedef void* G3D::BufferPool::UserPtr

private

Pointer given to the program. Unless in the tiny heap, the user size of the block is stored right in front of the pointer as a uint32.

Member Enumeration Documentation

anonymous enum

Only store buffers up to these sizes (in bytes) in each pool-> Different pools have different management strategies.

A large block is preallocated for tiny buffers; they are used with tremendous frequency. Other buffers are allocated as demanded. Tiny buffers are 128 bytes long because that seems to align well with cache sizes on many machines.

Enumerator
tinyBufferSize
smallBufferSize
medBufferSize

{tinyBufferSize = 128, smallBufferSize = 1024, medBufferSize = 4096};

anonymous enum

Most buffers we're allowed to store. 250000 * { 128 | 256} = {32 | 64} MB (preallocated) 40000 * {1024 | 2048} = {40 | 80} MB (allocated on demand) 5000 * {4096 | 8192} = {20 | 40} MB (allocated on demand)

Enumerator
maxTinyBuffers
maxSmallBuffers
maxMedBuffers

{maxTinyBuffers = 250000, maxSmallBuffers = 40000, maxMedBuffers = 5000};

Constructor & Destructor Documentation

G3D::BufferPool::BufferPool ( )

inline

----------------------------—— old mutex

-------------------------------— old mutex

 {
 totalMallocs = 0;

 mallocsFromTinyPool = 0;
 mallocsFromSmallPool = 0;
 mallocsFromMedPool = 0;

 bytesAllocated = 0;

 tinyPoolSize = 0;
 tinyHeap = NULL;

 smallPoolSize = 0;

 medPoolSize = 0;


 // Initialize the tiny heap as a bunch of pointers into one
 // pre-allocated buffer.
 tinyHeap = ::malloc(maxTinyBuffers * tinyBufferSize);
 for (int i = 0; i < maxTinyBuffers; ++i) {
 tinyPool[i] = (uint8*)tinyHeap + (tinyBufferSize * i);
 }
 tinyPoolSize = maxTinyBuffers;

#if 0 
# ifdef G3D_WINDOWS
 InitializeCriticalSection(&mutex);
# else
 pthread_mutex_init(&mutex, NULL);
# endif
#endif 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G3D::BufferPool::~BufferPool ( )

inline

 {
 ::free(tinyHeap);
 flushPool(smallPool, smallPoolSize);
 flushPool(medPool, medPoolSize);
#if 0 //-------------------------------- old mutex
# ifdef G3D_WINDOWS
 DeleteCriticalSection(&mutex);
# else
 // No destruction on pthreads
# endif
#endif //--------------------------------old mutex
 }

Here is the call graph for this function:

Member Function Documentation

void G3D::BufferPool::flushPool ( MemBlock *  pool, int &  poolSize  )

inlineprivate

 {
 for (int i = 0; i < poolSize; ++i) {
 bytesAllocated -= USERSIZE_TO_REALSIZE(pool[i].bytes);
 ::free(USERPTR_TO_REALPTR(pool[i].ptr));
 pool[i].ptr = NULL;
 pool[i].bytes = 0;
 }
 poolSize = 0;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BufferPool::free ( UserPtr  ptr )

inline

 {
 if (ptr == NULL) {
 // Free does nothing on null pointers
 return;
 }

 assert(isValidPointer(ptr));

 if (inTinyHeap(ptr)) {
 lock();
 tinyFree(ptr);
 unlock();
 return;
 }

 size_t bytes = USERSIZE_FROM_USERPTR(ptr);

 lock();
 if (bytes <= smallBufferSize) {
 if (smallPoolSize < maxSmallBuffers) {
 smallPool[smallPoolSize] = MemBlock(ptr, bytes);
 ++smallPoolSize;
 unlock();
 return;
 }
 } else if (bytes <= medBufferSize) {
 if (medPoolSize < maxMedBuffers) {
 medPool[medPoolSize] = MemBlock(ptr, bytes);
 ++medPoolSize;
 unlock();
 return;
 }
 }
 bytesAllocated -= USERSIZE_TO_REALSIZE(bytes);
 unlock();

 // Free; the buffer pools are full or this is too big to store.
 ::free(USERPTR_TO_REALPTR(ptr));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool G3D::BufferPool::inTinyHeap ( UserPtr  ptr )

inlineprivate

Returns true if this is a pointer into the tiny heap.

 {
 return 
 (ptr >= tinyHeap) && 
 (ptr < (uint8*)tinyHeap + maxTinyBuffers * tinyBufferSize);
 }

Here is the caller graph for this function:

void G3D::BufferPool::lock ( )

inlineprivate

 {
 m_lock.lock();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

UserPtr G3D::BufferPool::malloc ( MemBlock *  pool, int &  poolSize, size_t  bytes  )

inlineprivate

Allocate out of a specific pool. Return NULL if no suitable memory was found.

 {

 // OPT: find the smallest block that satisfies the request.

 // See if there's something we can use in the buffer pool.
 // Search backwards since usually we'll re-use the last one.
 for (int i = (int)poolSize - 1; i >= 0; --i) {
 if (pool[i].bytes >= bytes) {
 // We found a suitable entry in the pool.

 // No need to offset the pointer; it is already offset
 UserPtr ptr = pool[i].ptr;

 // Remove this element from the pool, replacing it with
 // the one from the end (same as Array::fastRemove)
 --poolSize;
 pool[i] = pool[poolSize];

 return ptr;
 }
 }

 return NULL;
 }

Here is the caller graph for this function:

UserPtr G3D::BufferPool::malloc ( size_t  bytes )

inline

 {
 lock();
 ++totalMallocs;

 if (bytes <= tinyBufferSize) {

 UserPtr ptr = tinyMalloc(bytes);

 if (ptr) {
 ++mallocsFromTinyPool;
 unlock();
 return ptr;
 }

 } 
 
 // Failure to allocate a tiny buffer is allowed to flow
 // through to a small buffer
 if (bytes <= smallBufferSize) {
 
 UserPtr ptr = malloc(smallPool, smallPoolSize, bytes);

 if (ptr) {
 ++mallocsFromSmallPool;
 unlock();
 return ptr;
 }

 } else if (bytes <= medBufferSize) {
 // Note that a small allocation failure does *not* fall
 // through into a medium allocation because that would
 // waste the medium buffer's resources.

 UserPtr ptr = malloc(medPool, medPoolSize, bytes);

 if (ptr) {
 ++mallocsFromMedPool;
 unlock();
 debugAssertM(ptr != NULL, "BufferPool::malloc returned NULL");
 return ptr;
 }
 }

 bytesAllocated += USERSIZE_TO_REALSIZE(bytes);
 unlock();

 // Heap allocate

 // Allocate 4 extra bytes for our size header (unfortunate,
 // since malloc already added its own header).
 RealPtr ptr = ::malloc(USERSIZE_TO_REALSIZE(bytes));

 if (ptr == NULL) {
# ifdef G3D_WINDOWS
 // Check for memory corruption
 alwaysAssertM(_CrtCheckMemory() == TRUE, "Heap corruption detected.");
# endif

 // Flush memory pools to try and recover space
 flushPool(smallPool, smallPoolSize);
 flushPool(medPool, medPoolSize);
 ptr = ::malloc(USERSIZE_TO_REALSIZE(bytes));
 }

 if (ptr == NULL) {
 if ((System::outOfMemoryCallback() != NULL) &&
 (System::outOfMemoryCallback()(USERSIZE_TO_REALSIZE(bytes), true) == true)) {
 // Re-attempt the malloc
 ptr = ::malloc(USERSIZE_TO_REALSIZE(bytes));
 }
 }

 if (ptr == NULL) {
 if (System::outOfMemoryCallback() != NULL) {
 // Notify the application
 System::outOfMemoryCallback()(USERSIZE_TO_REALSIZE(bytes), false);
 }
# ifdef G3D_DEBUG
 debugPrintf("::malloc(%d) returned NULL\n", (int)USERSIZE_TO_REALSIZE(bytes));
# endif
 debugAssertM(ptr != NULL, 
 "::malloc returned NULL. Either the "
 "operating system is out of memory or the "
 "heap is corrupt.");
 return NULL;
 }

 ((size_t*)ptr)[0] = bytes;

 return REALPTR_TO_USERPTR(ptr);
 }

Here is the call graph for this function:

std::string G3D::BufferPool::performance ( ) const

inline

 {
 if (totalMallocs > 0) {
 int pooled = mallocsFromTinyPool +
 mallocsFromSmallPool + 
 mallocsFromMedPool;

 int total = totalMallocs;

 return format("malloc performance: %5.1f%% <= %db, %5.1f%% <= %db, "
 "%5.1f%% <= %db, %5.1f%% > %db",
 100.0 * mallocsFromTinyPool / total,
 BufferPool::tinyBufferSize,
 100.0 * mallocsFromSmallPool / total,
 BufferPool::smallBufferSize,
 100.0 * mallocsFromMedPool / total,
 BufferPool::medBufferSize,
 100.0 * (1.0 - (double)pooled / total),
 BufferPool::medBufferSize);
 } else {
 return "No System::malloc calls made yet.";
 }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

UserPtr G3D::BufferPool::realloc ( UserPtr  ptr, size_t  bytes  )

inline

 {
 if (ptr == NULL) {
 return malloc(bytes);
 }

 if (inTinyHeap(ptr)) {
 if (bytes <= tinyBufferSize) {
 // The old pointer actually had enough space.
 return ptr;
 } else {
 // Free the old pointer and malloc
 
 UserPtr newPtr = malloc(bytes);
 System::memcpy(newPtr, ptr, tinyBufferSize);
 tinyFree(ptr);
 return newPtr;

 }
 } else {
 // In one of our heaps.

 // See how big the block really was
 size_t userSize = USERSIZE_FROM_USERPTR(ptr);
 if (bytes <= userSize) {
 // The old block was big enough.
 return ptr;
 }

 // Need to reallocate and move
 UserPtr newPtr = malloc(bytes);
 System::memcpy(newPtr, ptr, userSize);
 free(ptr);
 return newPtr;
 }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

std::string G3D::BufferPool::status ( ) const

inline

 {
 return format("preallocated shared buffers: %5d/%d x %db",
 maxTinyBuffers - tinyPoolSize, maxTinyBuffers, tinyBufferSize);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G3D::BufferPool::tinyFree ( UserPtr  ptr )

inlineprivate

 {
 assert(ptr);
 assert(tinyPoolSize < maxTinyBuffers);
 // "Tried to free a tiny pool buffer when the tiny pool freelist is full.");

# ifdef G3D_DEBUG
 if (tinyPoolSize > 0) {
 UserPtr prevOnHeap = tinyPool[tinyPoolSize - 1];
 assert(prevOnHeap != ptr); 
// "System::malloc heap corruption detected: "
// "the last two pointers on the freelist are identical (during tinyFree).");
 }
# endif

 assert(tinyPool[tinyPoolSize] == NULL);

 // Put the pointer back into the free list
 tinyPool[tinyPoolSize] = ptr;
 ++tinyPoolSize;

 }

Here is the caller graph for this function:

UserPtr G3D::BufferPool::tinyMalloc ( size_t  bytes )

inlineprivate

Malloc out of the tiny heap. Returns NULL if allocation failed.

 {
 // Note that we ignore the actual byte size
 // and create a constant size block.
 (void)bytes;
 assert(tinyBufferSize >= bytes);

 UserPtr ptr = NULL;

 if (tinyPoolSize > 0) {
 --tinyPoolSize;

 // Return the old last pointer from the freelist
 ptr = tinyPool[tinyPoolSize];

# ifdef G3D_DEBUG
 if (tinyPoolSize > 0) {
 assert(tinyPool[tinyPoolSize - 1] != ptr); 
 // "System::malloc heap corruption detected: "
 // "the last two pointers on the freelist are identical (during tinyMalloc).");
 }
# endif

 // NULL out the entry to help detect corruption
 tinyPool[tinyPoolSize] = NULL;
 }

 return ptr;
 }

Here is the caller graph for this function:

void G3D::BufferPool::unlock ( )

inlineprivate

 {
 m_lock.unlock();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

volatile size_t G3D::BufferPool::bytesAllocated

Amount of memory currently allocated (according to the application). This does not count the memory still remaining in the buffer pool, but does count extra memory required for rounding off to the size of a buffer. Primarily useful for detecting leaks.

Spinlock G3D::BufferPool::m_lock

private

int G3D::BufferPool::mallocsFromMedPool

int G3D::BufferPool::mallocsFromSmallPool

int G3D::BufferPool::mallocsFromTinyPool

MemBlock G3D::BufferPool::medPool[maxMedBuffers]

private

int G3D::BufferPool::medPoolSize

private

MemBlock G3D::BufferPool::smallPool[maxSmallBuffers]

private

int G3D::BufferPool::smallPoolSize

private

void* G3D::BufferPool::tinyHeap

private

Pointer to the data in the tiny pool

void* G3D::BufferPool::tinyPool[maxTinyBuffers]

private

The tiny pool is a single block of storage into which all tiny objects are allocated. This provides better locality for small objects and avoids the search time, since all tiny blocks are exactly the same size.

int G3D::BufferPool::tinyPoolSize

private

int G3D::BufferPool::totalMallocs

Count of memory allocations that have occurred.

---

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

• dep/g3dlite/source/System.cpp