X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fpbd%2Fpool.cc;h=cdcd9abdd7a9e40d3f0d97d7fba76b44e62d8442;hb=ce818efe37a1e8a68789a9eb8124fd828b672dd7;hp=434429e69d7d93e386b5a1a0e96272243c920035;hpb=da45f489dd3d923bbba8f1cee39ab445c4bf1b64;p=ardour.git diff --git a/libs/pbd/pool.cc b/libs/pbd/pool.cc index 434429e69d..cdcd9abdd7 100644 --- a/libs/pbd/pool.cc +++ b/libs/pbd/pool.cc @@ -19,21 +19,25 @@ */ #include -#include #include +#include +#include -#include -#include +#include "pbd/pool.h" +#include "pbd/pthread_utils.h" +#include "pbd/error.h" +#include "pbd/debug.h" +#include "pbd/compose.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. @@ -47,8 +51,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); } @@ -57,14 +60,15 @@ 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; @@ -73,48 +77,38 @@ Pool::alloc () } } +/** 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) { } MultiAllocSingleReleasePool::~MultiAllocSingleReleasePool () { - if(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) { } SingleAllocMultiReleasePool::~SingleAllocMultiReleasePool () { - if(m_lock) delete m_lock; } void* MultiAllocSingleReleasePool::alloc () { void *ptr; - if(!m_lock) { - m_lock = new Glib::Mutex(); - // umm, I'm not sure that this doesn't also allocate memory. - if(!m_lock) error << "cannot create Glib::Mutex in pool.cc" << endmsg; - } - - Glib::Mutex::Lock guard(*m_lock); + Glib::Threads::Mutex::Lock guard (m_lock); ptr = Pool::alloc (); return ptr; } @@ -134,12 +128,123 @@ SingleAllocMultiReleasePool::alloc () void SingleAllocMultiReleasePool::release (void* ptr) { - if(!m_lock) { - m_lock = new Glib::Mutex(); - // umm, I'm not sure that this doesn't also allocate memory. - if(!m_lock) error << "cannot create Glib::Mutex in pool.cc" << endmsg; - } - Glib::Mutex::Lock guard(*m_lock); + Glib::Threads::Mutex::Lock guard (m_lock); 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 () + : _key (free_per_thread_pool) + , _trash (0) +{ +} + +/** 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) +{ + _key.set (new CrossThreadPool (n, isize, nitems, this)); +} + +/** @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 = _key.get(); + if (!p) { + fatal << "programming error: no per-thread pool \"" << _name << "\" for thread " << pthread_name() << endmsg; + /*NOTREACHED*/ + } + return p; +} + +void +PerThreadPool::set_trash (RingBuffer* t) +{ + Glib::Threads::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::Threads::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; + + DEBUG_TRACE (DEBUG::Pool, string_compose ("%1 %2 has %3 pending free entries waiting\n", pthread_name(), name(), pending.read_space())); + while (pending.read (&ptr, 1) == 1) { + DEBUG_TRACE (DEBUG::Pool, string_compose ("%1 %2 pushes back a pending free list entry before allocating\n", pthread_name(), name())); + 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()); +} +