X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fpbd%2Fpool.cc;h=aac98a2c155540a15b6f9b07770b8610f8e3cf20;hb=ad547e53fc168410b22628a8cb125e8d4da4b293;hp=089766482d0c7c54500358b038219344f301fa96;hpb=481f7c39655afec832ac10430dd61a3bb464aa58;p=ardour.git diff --git a/libs/pbd/pool.cc b/libs/pbd/pool.cc index 089766482d..aac98a2c15 100644 --- a/libs/pbd/pool.cc +++ b/libs/pbd/pool.cc @@ -18,21 +18,24 @@ $Id$ */ +#include #include #include +#include +#include -#include -#include +#include "pbd/pool.h" +#include "pbd/error.h" using namespace std; using namespace PBD; Pool::Pool (string n, unsigned long item_size, unsigned long nitems) + : free_list (nitems) + , _name (n) { _name = n; - free_list = new RingBuffer (nitems); - /* since some overloaded ::operator new() might use this, its important that we use a "lower level" allocator to get more space. @@ -46,8 +49,7 @@ Pool::Pool (string n, unsigned long item_size, unsigned long nitems) ptrlist[i] = static_cast (static_cast(block) + (i * item_size)); } - free_list->write (ptrlist, nitems); - + free_list.write (ptrlist, nitems); free (ptrlist); } @@ -56,51 +58,52 @@ Pool::~Pool () free (block); } +/** Allocate an item's worth of memory in the Pool by taking one from the free list. + * @return Pointer to free item. + */ void * Pool::alloc () { void *ptr; -// cerr << _name << " pool " << " alloc, thread = " << pthread_name() << " space = " << free_list->read_space() << endl; - - if (free_list->read (&ptr, 1) < 1) { + if (free_list.read (&ptr, 1) < 1) { fatal << "CRITICAL: " << _name << " POOL OUT OF MEMORY - RECOMPILE WITH LARGER SIZE!!" << endmsg; /*NOTREACHED*/ return 0; } else { return ptr; } -}; +} +/** Release an item's memory by writing its location to the free list */ void Pool::release (void *ptr) { - free_list->write (&ptr, 1); -// cerr << _name << ": release, now has " << free_list->read_space() << endl; + free_list.write (&ptr, 1); } /*---------------------------------------------*/ MultiAllocSingleReleasePool::MultiAllocSingleReleasePool (string n, unsigned long isize, unsigned long nitems) - : Pool (n, isize, nitems), - m_lock(0) + : Pool (n, isize, nitems) + , m_lock(0) { } MultiAllocSingleReleasePool::~MultiAllocSingleReleasePool () { - if(m_lock) delete m_lock; + delete m_lock; } SingleAllocMultiReleasePool::SingleAllocMultiReleasePool (string n, unsigned long isize, unsigned long nitems) - : Pool (n, isize, nitems), - m_lock(0) + : Pool (n, isize, nitems) + , m_lock(0) { } SingleAllocMultiReleasePool::~SingleAllocMultiReleasePool () { - if(m_lock) delete m_lock; + delete m_lock; } void* @@ -142,3 +145,123 @@ SingleAllocMultiReleasePool::release (void* ptr) Pool::release (ptr); } +/*-------------------------------------------------------*/ + +static void +free_per_thread_pool (void* ptr) +{ + /* Rather than deleting the CrossThreadPool now, we add it to our trash buffer. + * This prevents problems if other threads still require access to this CrossThreadPool. + * We assume that some other agent will clean out the trash buffer as required. + */ + CrossThreadPool* cp = static_cast (ptr); + assert (cp); + + if (cp->empty()) { + /* This CrossThreadPool is already empty, and the thread is finishing so nothing + * more can be added to it. We can just delete the pool. + */ + delete cp; + } else { + /* This CrossThreadPool is not empty, meaning that there's some Events in it + * which another thread may yet read, so we can't delete the pool just yet. + * Put it in the trash and hope someone deals with it at some stage. + */ + cp->parent()->add_to_trash (cp); + } +} + +PerThreadPool::PerThreadPool () + : _trash (0) +{ + { + /* for some reason this appears necessary to get glib's thread private stuff to work */ + GPrivate* key; + key = g_private_new (NULL); + } + + _key = g_private_new (free_per_thread_pool); +} + +/** Create a new CrossThreadPool and set the current thread's private _key to point to it. + * @param n Name. + * @param isize Size of each item in the pool. + * @param nitems Number of items in the pool. + */ +void +PerThreadPool::create_per_thread_pool (string n, unsigned long isize, unsigned long nitems) +{ + CrossThreadPool* p = new CrossThreadPool (n, isize, nitems, this); + g_private_set (_key, p); +} + +/** @return CrossThreadPool for the current thread, which must previously have been created by + * calling create_per_thread_pool in the current thread. + */ +CrossThreadPool* +PerThreadPool::per_thread_pool () +{ + CrossThreadPool* p = static_cast (g_private_get (_key)); + if (!p) { + fatal << "programming error: no per-thread pool \"" << _name << "\" for thread " << pthread_self() << endmsg; + /*NOTREACHED*/ + } + return p; +} + +void +PerThreadPool::set_trash (RingBuffer* t) +{ + Glib::Mutex::Lock lm (_trash_mutex); + _trash = t; +} + +/** Add a CrossThreadPool to our trash, if we have one. If not, a warning is emitted. */ +void +PerThreadPool::add_to_trash (CrossThreadPool* p) +{ + Glib::Mutex::Lock lm (_trash_mutex); + + if (!_trash) { + warning << "Pool " << p->name() << " has no trash collector; a memory leak has therefore occurred" << endmsg; + return; + } + + /* we have a lock here so that multiple threads can safely call add_to_trash (even though there + can only be one writer to the _trash RingBuffer) + */ + + _trash->write (&p, 1); +} + +CrossThreadPool::CrossThreadPool (string n, unsigned long isize, unsigned long nitems, PerThreadPool* p) + : Pool (n, isize, nitems) + , pending (nitems) + , _parent (p) +{ + +} + +void* +CrossThreadPool::alloc () +{ + void* ptr; + while (pending.read (&ptr, 1) == 1) { + free_list.write (&ptr, 1); + } + return Pool::alloc (); +} + +void +CrossThreadPool::push (void* t) +{ + pending.write (&t, 1); +} + +/** @return true if there is nothing in this pool */ +bool +CrossThreadPool::empty () +{ + return (free_list.write_space() == pending.read_space()); +} +