knows about it.
*/
+ char* c = new char[12];
+ strcpy (c, X_("audioengine"));
+ pthread_set_name (c);
+
PBD::notify_gui_about_thread_creation ("gui", pthread_self(), X_("Audioengine"), 4096);
PBD::notify_gui_about_thread_creation ("midiui", pthread_self(), X_("Audioengine"), 128);
routes.flush ();
boost::shared_ptr<RouteList> r = routes.reader ();
- cerr << "\n\n\n AFTER ROUTE CLEARING, there are " << r->size() << " routes in RCU\n";
DEBUG_TRACE (DEBUG::Destruction, "delete diskstreams\n");
{
for (RouteList::iterator x = new_routes.begin(); x != new_routes.end(); ++x) {
boost::weak_ptr<Route> wpr (*x);
+ boost::shared_ptr<Route> r (*x);
- (*x)->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
- (*x)->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, wpr));
- (*x)->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
- (*x)->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
- (*x)->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
- (*x)->route_group_changed.connect_same_thread (*this, boost::bind (&Session::route_group_changed, this));
+ r->listen_changed.connect_same_thread (*this, boost::bind (&Session::route_listen_changed, this, _1, wpr));
+ r->solo_changed.connect_same_thread (*this, boost::bind (&Session::route_solo_changed, this, _1, wpr));
+ r->mute_changed.connect_same_thread (*this, boost::bind (&Session::route_mute_changed, this, _1));
+ r->output()->changed.connect_same_thread (*this, boost::bind (&Session::set_worst_io_latencies_x, this, _1, _2));
+ r->processors_changed.connect_same_thread (*this, boost::bind (&Session::route_processors_changed, this, _1));
+ r->route_group_changed.connect_same_thread (*this, boost::bind (&Session::route_group_changed, this));
- if ((*x)->is_master()) {
- _master_out = (*x);
+ if (r->is_master()) {
+ _master_out = r;
}
- if ((*x)->is_control()) {
- _control_out = (*x);
+ if (r->is_control()) {
+ _control_out = r;
}
}
XMLNode* child;
const XMLProperty* prop;
int ret = -1;
- extern void boost_debug_shared_ptr_show_live_debugging (bool);
_state_of_the_state = StateOfTheState (_state_of_the_state|CannotSave);
DataType type = DataType::AUDIO;
const XMLProperty* prop = node.property("default-type");
+ boost::shared_ptr<Route> ret;
if (prop) {
type = DataType(prop->value());
if (type == DataType::AUDIO) {
AudioTrack* at = new AudioTrack (*this, node, version);
boost_debug_shared_ptr_mark_interesting (at, "Track");
- return boost::shared_ptr<Route> (at);
-
+ ret.reset (at);
+
} else {
- boost::shared_ptr<Route> ret (new MidiTrack (*this, node, version));
- return ret;
+ ret.reset (new MidiTrack (*this, node, version));
}
} else {
Route* rt = new Route (*this, node);
boost_debug_shared_ptr_mark_interesting (rt, "Route");
- return boost::shared_ptr<Route> (rt);
+ ret.reset (rt);
}
+
+ return ret;
}
int
strings = ::backtrace_symbols (trace, size);
#endif
if (strings) {
- for (i = 5; i < 5+18 && i < size; i++) {
+ for (i = 3; i < 5+18 && i < size; i++) {
str << strings[i] << std::endl;
}
free (strings);
}
void
-boost_debug_shared_ptr_reset (void const *sp, void const *obj, int use_count)
+boost_debug_shared_ptr_reset (void const *sp, void const *old_obj, int old_use_count, void const *obj, int new_use_count)
{
- if (is_interesting_object (obj)) {
+ if (old_obj == 0 && obj == 0) {
+ return;
+ }
+
+ Glib::Mutex::Lock guard (the_lock);
+
+ if (is_interesting_object (old_obj) || is_interesting_object (obj)) {
if (debug_out) {
- cerr << "reset sp to object @ " << obj << " @ " << sp << " UC was " << use_count << " (total sp's = " << sptrs.size() << ')' << endl;
+ cerr << "RESET SWAPS " << old_obj << " & " << obj << endl;
+ }
+ }
+
+ if (is_interesting_object (old_obj)) {
+ if (debug_out) {
+ cerr << "\tlost old sp @ " << sp << " for " << old_obj << " UC = " << old_use_count << " now for " << obj << " UC = " << new_use_count
+ << " (total sp's = " << sptrs.size() << ')' << endl;
+ }
+ PointerMap::iterator x = sptrs.find (sp);
+
+ if (x != sptrs.end()) {
+ sptrs.erase (x);
+ if (debug_out) {
+ cerr << "\tRemoved (by reset) sp for " << old_obj << " @ " << sp << " UC = " << old_use_count << " (total sp's = " << sptrs.size() << ')' << endl;
+ }
}
}
+
+ if (is_interesting_object (obj)) {
+
+ pair<void const*, SPDebug*> newpair;
+
+ newpair.first = sp;
+ newpair.second = new SPDebug (new Backtrace());
+
+ sptrs.insert (newpair);
+
+ if (debug_out) {
+ cerr << "reset created sp for " << obj << " @ " << sp << " used to point to " << old_obj << " UC = " << old_use_count
+ << " UC = " << new_use_count
+ << " (total sp's = " << sptrs.size() << ')' << endl;
+ cerr << *newpair.second << endl;
+ }
+ }
}
void
void pthread_cancel_all ();
void pthread_kill_all (int signum);
void pthread_exit_pbd (void* status);
-std::string pthread_name ();
+const char* pthread_name ();
+void pthread_set_name (const char* name);
namespace PBD {
extern void notify_gui_about_thread_creation (std::string, pthread_t, std::string, int requests = 256);
$Id$
*/
-#include <map>
+#include <set>
#include <iostream>
#include <string>
#include <stdint.h>
using namespace std;
-typedef std::map<string,pthread_t> ThreadMap;
+typedef std::set<pthread_t> ThreadMap;
static ThreadMap all_threads;
static pthread_mutex_t thread_map_lock = PTHREAD_MUTEX_INITIALIZER;
+static Glib::StaticPrivate<char> thread_name;
namespace PBD {
PBD::Signal4<void,std::string, pthread_t,std::string,uint32_t> ThreadCreatedWithRequestSize;
ThreadCreatedWithRequestSize (target_gui, thread, str, request_count);
}
+struct ThreadStartWithName {
+ void* (*thread_work)(void*);
+ void* arg;
+ const char* name;
+
+ ThreadStartWithName (void* (*f)(void*), void* a, const char* s)
+ : thread_work (f), arg (a), name (s) {}
+};
+
+static void*
+fake_thread_start (void* arg)
+{
+ ThreadStartWithName* ts = (ThreadStartWithName*) arg;
+ void* (*thread_work)(void*) = ts->thread_work;
+ void* thread_arg = ts->arg;
+
+ pthread_set_name (ts->name);
+
+ delete ts;
+ /* name will be deleted by the default handler for GStaticPrivate, when the thread exits */
+
+ return thread_work (thread_arg);
+}
+
int
pthread_create_and_store (string name, pthread_t *thread, void * (*start_routine)(void *), void * arg)
{
pthread_attr_t default_attr;
int ret;
-
+
// set default stack size to sensible default for memlocking
pthread_attr_init(&default_attr);
pthread_attr_setstacksize(&default_attr, 500000);
- if ((ret = thread_creator (thread, &default_attr, start_routine, arg)) == 0) {
- std::pair<string,pthread_t> newpair;
- newpair.first = name;
- newpair.second = *thread;
+ char* cname = new char[name.length() + 1];
+ strcpy (cname, name.c_str());
+ ThreadStartWithName* ts = new ThreadStartWithName (start_routine, arg, cname);
+
+ if ((ret = thread_creator (thread, &default_attr, fake_thread_start, ts)) == 0) {
pthread_mutex_lock (&thread_map_lock);
- all_threads.insert (newpair);
+ all_threads.insert (*thread);
pthread_mutex_unlock (&thread_map_lock);
}
return ret;
}
-string
+void
+pthread_set_name (const char *str)
+{
+ /* str will be deleted when this thread exits */
+ thread_name.set (const_cast<char*>(str));
+}
+
+const char *
pthread_name ()
{
- pthread_t self = pthread_self();
- string str;
+ const char* str = thread_name.get ();
- pthread_mutex_lock (&thread_map_lock);
- for (ThreadMap::iterator i = all_threads.begin(); i != all_threads.end(); ++i) {
- if (i->second == self) {
- str = i->first;
- pthread_mutex_unlock (&thread_map_lock);
- return str;
- }
- }
- pthread_mutex_unlock (&thread_map_lock);
+ if (str) {
+ return str;
+ }
return "unknown";
}
{
pthread_mutex_lock (&thread_map_lock);
for (ThreadMap::iterator i = all_threads.begin(); i != all_threads.end(); ++i) {
- if (i->second != pthread_self()) {
- pthread_kill (i->second, signum);
+ if ((*i) != pthread_self()) {
+ pthread_kill ((*i), signum);
}
}
all_threads.clear();
{
pthread_mutex_lock (&thread_map_lock);
for (ThreadMap::iterator i = all_threads.begin(); i != all_threads.end(); ++i) {
- if (i->second != pthread_self()) {
- pthread_cancel (i->second);
+ if ((*i) != pthread_self()) {
+ pthread_cancel ((*i));
}
}
all_threads.clear();
{
pthread_mutex_lock (&thread_map_lock);
for (ThreadMap::iterator i = all_threads.begin(); i != all_threads.end(); ++i) {
- if (i->second == thread) {
+ if ((*i) == thread) {
all_threads.erase (i);
break;
}
pthread_mutex_lock (&thread_map_lock);
for (ThreadMap::iterator i = all_threads.begin(); i != all_threads.end(); ++i) {
- if (i->second == thread) {
+ if ((*i) == thread) {
all_threads.erase (i);
break;
}
projects / ardour.git / commitdiff