X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=libs%2Fpbd%2Fpool.cc;h=249a31ddb3c36f234c79d8cb922d1a373a695146;hb=6e017eff224209935eed67ade6f60c504cb0a01c;hp=bbe57b7ee291f423f53aef1fc83002eed9af0c56;hpb=a7d465fcb7254ad4acdf25208976802553c0f6a5;p=ardour.git diff --git a/libs/pbd/pool.cc b/libs/pbd/pool.cc index bbe57b7ee2..249a31ddb3 100644 --- a/libs/pbd/pool.cc +++ b/libs/pbd/pool.cc @@ -1,6 +1,6 @@ /* Copyright (C) 1998-99 Paul Barton-Davis - + This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or @@ -19,13 +19,15 @@ */ #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; @@ -33,12 +35,15 @@ using namespace PBD; Pool::Pool (string n, unsigned long item_size, unsigned long nitems) : free_list (nitems) , _name (n) +#ifndef NDEBUG + , max_usage (0) +#endif { _name = n; /* since some overloaded ::operator new() might use this, its important that we use a "lower level" allocator to - get more space. + get more space. */ block = malloc (nitems * item_size); @@ -55,6 +60,10 @@ Pool::Pool (string n, unsigned long item_size, unsigned long nitems) Pool::~Pool () { +#ifndef NDEBUG + // TODO: after collecting some stats, use DEBUG::PoolStats here + cerr << "Pool: '" << _name << "' max: " << max_usage << " / " << total() << endmsg; +#endif free (block); } @@ -66,9 +75,15 @@ Pool::alloc () { void *ptr; +#ifndef NDEBUG + if (used () > max_usage) { + max_usage = used () + 1; + } +#endif + if (free_list.read (&ptr, 1) < 1) { fatal << "CRITICAL: " << _name << " POOL OUT OF MEMORY - RECOMPILE WITH LARGER SIZE!!" << endmsg; - /*NOTREACHED*/ + abort(); /*NOTREACHED*/ return 0; } else { return ptr; @@ -76,7 +91,7 @@ Pool::alloc () } /** Release an item's memory by writing its location to the free list */ -void +void Pool::release (void *ptr) { free_list.write (&ptr, 1); @@ -84,39 +99,29 @@ Pool::release (void *ptr) /*---------------------------------------------*/ -MultiAllocSingleReleasePool::MultiAllocSingleReleasePool (string n, unsigned long isize, unsigned long nitems) +MultiAllocSingleReleasePool::MultiAllocSingleReleasePool (string n, unsigned long isize, unsigned long nitems) : Pool (n, isize, nitems) - , m_lock(0) { } MultiAllocSingleReleasePool::~MultiAllocSingleReleasePool () { - delete m_lock; } -SingleAllocMultiReleasePool::SingleAllocMultiReleasePool (string n, unsigned long isize, unsigned long nitems) +SingleAllocMultiReleasePool::SingleAllocMultiReleasePool (string n, unsigned long isize, unsigned long nitems) : Pool (n, isize, nitems) - , m_lock(0) { } SingleAllocMultiReleasePool::~SingleAllocMultiReleasePool () { - 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; } @@ -136,18 +141,13 @@ 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 +static void free_per_thread_pool (void* ptr) { /* Rather than deleting the CrossThreadPool now, we add it to our trash buffer. @@ -170,17 +170,11 @@ free_per_thread_pool (void* ptr) cp->parent()->add_to_trash (cp); } } - + PerThreadPool::PerThreadPool () - : _trash (0) + : _key (free_per_thread_pool) + , _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. @@ -191,20 +185,33 @@ PerThreadPool::PerThreadPool () 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); + _key.set (new CrossThreadPool (n, isize, nitems, this)); +} + +/** @return True if CrossThreadPool for the current thread exists, + * False otherwise + */ +bool +PerThreadPool::has_per_thread_pool () +{ + CrossThreadPool* p = _key.get(); + if (p) { + return true; + } + return false; } + /** @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 () +PerThreadPool::per_thread_pool (bool must_exist) { - CrossThreadPool* p = static_cast (g_private_get (_key)); - if (!p) { - fatal << "programming error: no per-thread pool \"" << _name << "\" for thread " << pthread_self() << endmsg; - /*NOTREACHED*/ + CrossThreadPool* p = _key.get(); + if (!p && must_exist) { + fatal << "programming error: no per-thread pool \"" << _name << "\" for thread " << pthread_name() << endmsg; + abort(); /*NOTREACHED*/ } return p; } @@ -212,7 +219,7 @@ PerThreadPool::per_thread_pool () void PerThreadPool::set_trash (RingBuffer* t) { - Glib::Mutex::Lock lm (_trash_mutex); + Glib::Threads::Mutex::Lock lm (_trash_mutex); _trash = t; } @@ -220,8 +227,8 @@ PerThreadPool::set_trash (RingBuffer* t) void PerThreadPool::add_to_trash (CrossThreadPool* p) { - Glib::Mutex::Lock lm (_trash_mutex); - + 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; @@ -230,7 +237,7 @@ PerThreadPool::add_to_trash (CrossThreadPool* p) /* 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); } @@ -239,22 +246,47 @@ CrossThreadPool::CrossThreadPool (string n, unsigned long isize, unsigned long , pending (nitems) , _parent (p) { - + } -void* -CrossThreadPool::alloc () +void +CrossThreadPool::flush_pending_with_ev (void *ptr) +{ + push (ptr); + flush_pending (); +} + +void +CrossThreadPool::flush_pending () { void* ptr; + bool did_release = false; + + DEBUG_TRACE (DEBUG::Pool, string_compose ("%1 %2 has %3 pending free entries waiting, status size %4 free %5 used %6\n", pthread_name(), name(), pending.read_space(), + total(), available(), used())); + while (pending.read (&ptr, 1) == 1) { - cerr << name() << " pushes back a pending free list entry before allocating\n"; + 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); + did_release = true; + } + + if (did_release) { + DEBUG_TRACE (DEBUG::Pool, string_compose ("Pool size: %1 free %2 used %3 pending now %4\n", total(), available(), used(), pending_size())); } +} + +void* +CrossThreadPool::alloc () +{ + /* process anything waiting to be deleted (i.e. moved back to the free list) */ + flush_pending (); + /* now allocate from the potentially larger free list */ return Pool::alloc (); } void -CrossThreadPool::push (void* t) +CrossThreadPool::push (void* t) { pending.write (&t, 1); }