X-Git-Url: http://research.m1stereo.tv/gitweb?a=blobdiff_plain;f=src%2Fframework%2Fmlt_pool.c;h=daa0d297b28e0573f44327cde91529e4283cf856;hb=2af8bb9f6a61f6510aab8f45abf5f26e9e619c78;hp=ab51392345fabec8228f3c8a033e3e41fb47e350;hpb=94dce1aea965163f8dcd2f97271f2652abb0e62d;p=melted

diff --git a/src/framework/mlt_pool.c b/src/framework/mlt_pool.c
index ab51392..daa0d29 100644
--- a/src/framework/mlt_pool.c
+++ b/src/framework/mlt_pool.c
@@ -22,6 +22,7 @@
 #include "mlt_deque.h"
 
 #include <stdlib.h>
+#include <malloc.h>
 #include <string.h>
 #include <pthread.h>
 
@@ -38,16 +39,14 @@ typedef struct mlt_pool_s
 	pthread_mutex_t lock;
 	mlt_deque stack;
 	int size;
+	int count;
 }
 *mlt_pool;
 
-/** Private release structure
-*/
-
 typedef struct mlt_release_s
 {
-	void *ptr;
 	mlt_pool pool;
+	int references;
 }
 *mlt_release;
 
@@ -79,10 +78,10 @@ static mlt_pool pool_init( int size )
 /** Get an item from the pool.
 */
 
-static mlt_release pool_fetch( mlt_pool this )
+static void *pool_fetch( mlt_pool this )
 {
 	// We will generate a release object
-	mlt_release release = NULL;
+	void *ptr = NULL;
 
 	// Sanity check
 	if ( this != NULL )
@@ -94,21 +93,27 @@ static mlt_release pool_fetch( mlt_pool this )
 		if ( mlt_deque_count( this->stack ) != 0 )
 		{
 			// Pop the top of the stack
-			release = mlt_deque_pop_back( this->stack );
+			ptr = mlt_deque_pop_back( this->stack );
+
+			// Assign the reference
+			( ( mlt_release )ptr )->references = 1;
 		}
 		else
 		{
 			// We need to generate a release item
-			release = calloc( 1, sizeof( struct mlt_release_s ) );
+			mlt_release release = memalign( 16, this->size );
 
 			// Initialise it
 			if ( release != NULL )
 			{
-				// Allocate the real memory
-				release->ptr = malloc( this->size );
-
 				// Assign the pool
 				release->pool = this;
+
+				// Assign the reference
+				release->references = 1;
+
+				// Determine the ptr
+				ptr = ( void * )release + sizeof( struct mlt_release_s );
 			}
 		}
 
@@ -117,42 +122,44 @@ static mlt_release pool_fetch( mlt_pool this )
 	}
 
 	// Return the generated release object
-	return release;
+	return ptr;
 }
 
 /** Return an item to the pool.
 */
 
-static void pool_return( mlt_pool this, mlt_release that )
+static void pool_return( void *ptr )
 {
 	// Sanity checks
-	if ( this != NULL && that != NULL )
+	if ( ptr != NULL )
 	{
-		// Ensure that the pools match
-		if ( this == that->pool )
+		// Get the release pointer
+		mlt_release that = ptr - sizeof( struct mlt_release_s );
+
+		// Get the pool
+		mlt_pool this = that->pool;
+
+		if ( this != NULL )
 		{
 			// Lock the pool
 			pthread_mutex_lock( &this->lock );
 
 			// Push the that back back on to the stack
-			mlt_deque_push_back( this->stack, that );
+			mlt_deque_push_back( this->stack, ptr );
 
 			// Unlock the pool
 			pthread_mutex_unlock( &this->lock );
 
 			// Ensure that we don't clean up
-			that = NULL;
+			ptr = NULL;
 		}
 	}
 
 	// Tidy up - this will only occur if the returned item is incorrect
-	if ( that != NULL )
+	if ( ptr != NULL )
 	{
-		// Free the memory
-		free( that->ptr );
-
 		// Free the release itself
-		free( that );
+		free( ptr - sizeof( struct mlt_release_s ) );
 	}
 }
 
@@ -164,13 +171,13 @@ static void pool_close( mlt_pool this )
 	if ( this != NULL )
 	{
 		// We need to free up all items in the pool
-		mlt_release release = NULL;
+		void *release = NULL;
 
 		// Iterate through the stack until depleted
 		while ( ( release = mlt_deque_pop_back( this->stack ) ) != NULL )
 		{
-			// We'll return this item to NULL
-			pool_return( NULL, release );
+			// We'll free this item now
+			free( release - sizeof( struct mlt_release_s ) );
 		}
 
 		// We can now close the stack
@@ -196,7 +203,7 @@ void mlt_pool_init( )
 	pools = mlt_properties_new( );
 
 	// Create the pools
-	for ( i = 8; i < 32; i ++ )
+	for ( i = 8; i < 31; i ++ )
 	{
 		// Each properties item needs a name
 		char name[ 32 ];
@@ -215,40 +222,24 @@ void mlt_pool_init( )
 /** Allocate size bytes from the pool.
 */
 
-void *mlt_pool_allocate( int size, void **release )
+void *mlt_pool_alloc( int size )
 {
-	// This is the real release structure we'll return
-	mlt_release real = NULL;
-
 	// This will be used to obtain the pool to use
 	mlt_pool pool = NULL;
 
 	// Determines the index of the pool to use
-	int index = 1;
+	int index = 8;
 
 	// Minimum size pooled is 256 bytes
-	size = size >> 8;
+	size = size + sizeof( mlt_release );
 	while ( ( 1 << index ) < size )
 		index ++;
 
 	// Now get the pool at the index
-	pool = mlt_properties_get_data_at( pools, index + 1, NULL );
+	pool = mlt_properties_get_data_at( pools, index - 8, NULL );
 
 	// Now get the real item
-	real = pool_fetch( pool );
-
-	// Deal with return
-	if ( real != NULL )
-	{
-		// Assign to release
-		*release = real;
-
-		// Return the pointer
-		return real->ptr;
-	}
-
-	// Otherwise return a NULL to indicate failure
-	return NULL;
+	return pool_fetch( pool );
 }
 
 /** Release the allocated memory.
@@ -256,15 +247,8 @@ void *mlt_pool_allocate( int size, void **release )
 
 void mlt_pool_release( void *release )
 {
-	// Sanity check
-	if ( release != NULL )
-	{
-		// Get the real release structure
-		mlt_release real = release;
-
-		// Return to the pool
-		pool_return( real->pool, real );
-	}
+	// Return to the pool
+	pool_return( release );
 }
 
 /** Close the pool.