slight mods to factory (for future module reporting); pool purge function; consumer...

[melted] / src / framework / mlt_pool.c

diff --git a/src/framework/mlt_pool.c b/src/framework/mlt_pool.c
index daa0d29..ee1d244 100644 (file)
--- a/src/framework/mlt_pool.c
+++ b/src/framework/mlt_pool.c
@@ -22,10 +22,14 @@
 #include "mlt_deque.h"
 
 #include <stdlib.h>
-#include <malloc.h>
 #include <string.h>
 #include <pthread.h>
 
+// Not nice - memalign is defined here apparently?
+#ifdef linux
+#include <malloc.h>
+#endif
+
 /** Singleton repositories
 */
 
@@ -101,11 +105,18 @@ static void *pool_fetch( mlt_pool this )
                else
                {
                        // We need to generate a release item
+#ifdef linux
                        mlt_release release = memalign( 16, this->size );
+#else
+                       mlt_release release = malloc( this->size );
+#endif
 
                        // Initialise it
                        if ( release != NULL )
                        {
+                               // Increment the number of items allocated to this pool
+                               this->count ++;
+
                                // Assign the pool
                                release->pool = this;
 
@@ -242,6 +253,75 @@ void *mlt_pool_alloc( int size )
        return pool_fetch( pool );
 }
 
+/** Allocate size bytes from the pool.
+*/
+
+void *mlt_pool_realloc( void *ptr, int size )
+{
+       // Result to return
+       void *result = NULL;
+
+       // Check if we actually have an address
+       if ( ptr != NULL )
+       {
+               // Get the release pointer
+               mlt_release that = 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 ) )
+               {
+                       // Allocate
+                       result = mlt_pool_alloc( size );
+
+                       // Copy
+                       memcpy( result, ptr, that->pool->size - sizeof( struct mlt_release_s ) );
+
+                       // Release
+                       mlt_pool_release( ptr );
+               }
+               else
+               {
+                       // Nothing to do
+                       result = ptr;
+               }
+       }
+       else
+       {
+               // Simply allocate
+               result = mlt_pool_alloc( size );
+       }
+
+       return result;
+}
+
+/** Purge unused items in the pool.
+*/
+
+void mlt_pool_purge( )
+{
+       int i = 0;
+
+       // For each pool
+       for ( i = 0; i < mlt_properties_count( pools ); i ++ )
+       {
+               // Get the pool
+               mlt_pool this = mlt_properties_get_data_at( pools, i, NULL );
+
+               // Pointer to unused memory
+               void *release = NULL;
+
+               // Lock the pool
+               pthread_mutex_lock( &this->lock );
+
+               // We'll free all unused items now
+               while ( ( release = mlt_deque_pop_back( this->stack ) ) != NULL )
+                       free( release - sizeof( struct mlt_release_s ) );
+
+               // Unlock the pool
+               pthread_mutex_unlock( &this->lock );
+       }
+}
+
 /** Release the allocated memory.
 */
 
@@ -256,6 +336,19 @@ void mlt_pool_release( void *release )
 
 void mlt_pool_close( )
 {
+#ifdef _MLT_POOL_CHECKS_
+       // Stats dump on close
+       int i = 0;
+       fprintf( stderr, "Usage:\n\n" );
+       for ( i = 0; i < mlt_properties_count( pools ); i ++ )
+       {
+               mlt_pool pool = mlt_properties_get_data_at( pools, i, NULL );
+               if ( pool->count )
+                       fprintf( stderr, "%d: allocated %d returned %d %c\n", pool->size, pool->count, mlt_deque_count( pool->stack ),
+                                                                                                                                 pool->count !=  mlt_deque_count( pool->stack ) ? '*' : ' ' );
+       }
+#endif
+
        // Close the properties
        mlt_properties_close( pools );
 }