/**
* \file mlt_pool.c
* \brief memory pooling functionality
+ * \see mlt_pool_s
*
- * Copyright (C) 2003-2008 Ushodaya Enterprises Limited
+ * Copyright (C) 2003-2009 Ushodaya Enterprises Limited
* \author Charles Yates <charles.yates@pandora.be>
*
* This library is free software; you can redistribute it and/or
#include <malloc.h>
#endif
-/** Singleton repositories
-*/
+/** global singleton for tracking pools */
static mlt_properties pools = NULL;
typedef struct mlt_pool_s
{
- pthread_mutex_t lock;
- mlt_deque stack;
- int size;
- int count;
+ pthread_mutex_t lock; ///< lock to prevent race conditions
+ mlt_deque stack; ///< a stack of addresses to memory blocks
+ int size; ///< the size of the memory block as a power of 2
+ int count; ///< the number of blocks in the pool
}
*mlt_pool;
*mlt_release;
/** Create a pool.
-*/
+ *
+ * \private \memberof mlt_pool_s
+ * \param size the size of the memory blocks to hold as some power of two
+ * \return a new pool object
+ */
static mlt_pool pool_init( int size )
{
}
/** Get an item from the pool.
-*/
+ *
+ * \private \memberof mlt_pool_s
+ * \param this a pool
+ * \return an opaque pointer
+ */
static void *pool_fetch( mlt_pool this )
{
release->references = 1;
// Determine the ptr
- ptr = ( void * )release + sizeof( struct mlt_release_s );
+ ptr = ( char * )release + sizeof( struct mlt_release_s );
}
}
}
/** Return an item to the pool.
-*/
+ *
+ * \private \memberof mlt_pool_s
+ * \param ptr an opaque pointer
+ */
static void pool_return( void *ptr )
{
if ( ptr != NULL )
{
// Get the release pointer
- mlt_release that = ptr - sizeof( struct mlt_release_s );
+ mlt_release that = ( void * )(( char * )ptr - sizeof( struct mlt_release_s ));
// Get the pool
mlt_pool this = that->pool;
if ( ptr != NULL )
{
// Free the release itself
- free( ptr - sizeof( struct mlt_release_s ) );
+ free( ( char * )ptr - sizeof( struct mlt_release_s ) );
}
}
/** Destroy a pool.
-*/
+ *
+ * \private \memberof mlt_pool_s
+ * \param this a pool
+ */
static void pool_close( mlt_pool this )
{
while ( ( release = mlt_deque_pop_back( this->stack ) ) != NULL )
{
// We'll free this item now
- free( release - sizeof( struct mlt_release_s ) );
+ free( ( char * )release - sizeof( struct mlt_release_s ) );
}
// We can now close the stack
}
}
-/** Initialise the pool.
-*/
+/** Initialise the global pool.
+ *
+ * \public \memberof mlt_pool_s
+ */
void mlt_pool_init( )
{
}
/** Allocate size bytes from the pool.
-*/
+ *
+ * \public \memberof mlt_pool_s
+ * \param size the number of bytes
+ */
void *mlt_pool_alloc( int size )
{
}
/** Allocate size bytes from the pool.
-*/
+ *
+ * \public \memberof mlt_pool_s
+ * \param ptr an opaque pointer - can be in the pool or a new block to allocate
+ * \param size the number of bytes
+ */
void *mlt_pool_realloc( void *ptr, int size )
{
if ( ptr != NULL )
{
// Get the release pointer
- mlt_release that = ptr - sizeof( struct mlt_release_s );
+ mlt_release that = ( void * )(( char * )ptr - sizeof( struct mlt_release_s ));
// If the current pool this ptr belongs to is big enough
if ( size > that->pool->size - sizeof( struct mlt_release_s ) )
}
/** Purge unused items in the pool.
-*/
+ *
+ * A form of garbage collection.
+ * \public \memberof mlt_pool_s
+ */
void mlt_pool_purge( )
{
// We'll free all unused items now
while ( ( release = mlt_deque_pop_back( this->stack ) ) != NULL )
- free( release - sizeof( struct mlt_release_s ) );
+ free( ( char * )release - sizeof( struct mlt_release_s ) );
// Unlock the pool
pthread_mutex_unlock( &this->lock );
}
/** Release the allocated memory.
-*/
+ *
+ * \public \memberof mlt_pool_s
+ * \param release an opaque pointer of a block in the pool
+ */
void mlt_pool_release( void *release )
{
}
/** Close the pool.
-*/
+ *
+ * \public \memberof mlt_pool_s
+ */
void mlt_pool_close( )
{