X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=libs%2Fpbd%2Fpthread_utils.cc;h=5daa60ac424aec37fd6252bd0d2c490f59af04e8;hb=99d284930d7403d3924eb5cd522d349f9217e11e;hp=3408f2c0b79b35578b27e979115f662678da8252;hpb=f7563c2b158252339f98e38719cfc3e092ef7ac7;p=ardour.git diff --git a/libs/pbd/pthread_utils.cc b/libs/pbd/pthread_utils.cc index 3408f2c0b7..5daa60ac42 100644 --- a/libs/pbd/pthread_utils.cc +++ b/libs/pbd/pthread_utils.cc @@ -1,5 +1,5 @@ /* - Copyright (C) 2002 Paul Davis + Copyright (C) 2002 Paul 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 @@ -18,84 +18,155 @@ $Id$ */ -#include -#include +#include #include +#include #include -#include +#include "pbd/pthread_utils.h" +#ifdef WINE_THREAD_SUPPORT +#include +#endif + +#ifdef COMPILER_MSVC +DECLARE_DEFAULT_COMPARISONS(pthread_t) // Needed for 'DECLARE_DEFAULT_COMPARISONS'. Objects in an STL container can be + // searched and sorted. Thus, when instantiating the container, MSVC complains + // if the type of object being contained has no appropriate comparison operators + // defined (specifically, if operators '<' and '==' are undefined). This seems + // to be the case with ptw32 'pthread_t' which is a simple struct. +#endif using namespace std; -typedef std::map ThreadMap; +typedef std::list ThreadMap; static ThreadMap all_threads; static pthread_mutex_t thread_map_lock = PTHREAD_MUTEX_INITIALIZER; +static Glib::Threads::Private thread_name (free); namespace PBD { - sigc::signal ThreadCreated; - sigc::signal ThreadCreatedWithRequestSize; + PBD::Signal3 ThreadCreatedWithRequestSize; } using namespace PBD; -int -pthread_create_and_store (string name, pthread_t *thread, pthread_attr_t *attr, void * (*start_routine)(void *), void * arg) +static int thread_creator (pthread_t* thread_id, const pthread_attr_t* attr, void *(*function)(void*), void* arg) { - int ret; +#ifdef WINE_THREAD_SUPPORT + return wine_pthread_create (thread_id, attr, function, arg); +#else + return pthread_create (thread_id, attr, function, arg); +#endif +} - pthread_attr_t default_attr; - bool use_default_attr = (attr == NULL); - - if (use_default_attr) { - // set default stack size to sensible default for memlocking - pthread_attr_init(&default_attr); - pthread_attr_setstacksize(&default_attr, 500000); - attr = &default_attr; + +void +PBD::notify_event_loops_about_thread_creation (pthread_t thread, const std::string& emitting_thread_name, int request_count) +{ + /* notify threads that may exist in the future (they may also exist + * already, in which case they will catch the + * ThreadCreatedWithRequestSize signal) + */ + EventLoop::pre_register (emitting_thread_name, request_count); + + /* notify all existing threads */ + ThreadCreatedWithRequestSize (thread, emitting_thread_name, request_count); +} + +struct ThreadStartWithName { + void* (*thread_work)(void*); + void* arg; + std::string name; + + ThreadStartWithName (void* (*f)(void*), void* a, const std::string& 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; + + /* name will be deleted by the default handler for GStaticPrivate, when the thread exits */ + + pthread_set_name (ts->name.c_str()); + + /* we don't need this object anymore */ + + delete ts; + + /* actually run the thread's work function */ + + void* ret = thread_work (thread_arg); + + /* cleanup */ + + pthread_mutex_lock (&thread_map_lock); + + for (ThreadMap::iterator i = all_threads.begin(); i != all_threads.end(); ++i) { + if (pthread_equal ((*i), pthread_self())) { + all_threads.erase (i); + break; + } } - if ((ret = pthread_create (thread, attr, start_routine, arg)) == 0) { - std::pair newpair; - newpair.first = name; - newpair.second = *thread; + pthread_mutex_unlock (&thread_map_lock); - pthread_mutex_lock (&thread_map_lock); - all_threads.insert (newpair); + /* done */ + + return ret; +} + +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); + + ThreadStartWithName* ts = new ThreadStartWithName (start_routine, arg, name); + if ((ret = thread_creator (thread, &default_attr, fake_thread_start, ts)) == 0) { + pthread_mutex_lock (&thread_map_lock); + all_threads.push_back (*thread); pthread_mutex_unlock (&thread_map_lock); } - if (use_default_attr) { - pthread_attr_destroy(&default_attr); - } - + pthread_attr_destroy(&default_attr); + return ret; } -string +void +pthread_set_name (const char *str) +{ + /* copy string and delete it when exiting */ + + thread_name.set (strdup (str)); // leaks +} + +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; - } + if (str) { + return str; } - pthread_mutex_unlock (&thread_map_lock); return "unknown"; } void -pthread_kill_all (int signum) -{ +pthread_kill_all (int signum) +{ 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 (!pthread_equal ((*i), pthread_self())) { + pthread_kill ((*i), signum); } } all_threads.clear(); @@ -103,24 +174,31 @@ pthread_kill_all (int signum) } void -pthread_cancel_all () -{ +pthread_cancel_all () +{ 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); + + for (ThreadMap::iterator i = all_threads.begin(); i != all_threads.end(); ) { + + ThreadMap::iterator nxt = i; + ++nxt; + + if (!pthread_equal ((*i), pthread_self())) { + pthread_cancel ((*i)); } + + i = nxt; } all_threads.clear(); pthread_mutex_unlock (&thread_map_lock); } void -pthread_cancel_one (pthread_t thread) -{ +pthread_cancel_one (pthread_t thread) +{ pthread_mutex_lock (&thread_map_lock); for (ThreadMap::iterator i = all_threads.begin(); i != all_threads.end(); ++i) { - if (i->second == thread) { + if (pthread_equal ((*i), thread)) { all_threads.erase (i); break; } @@ -129,19 +207,3 @@ pthread_cancel_one (pthread_t thread) pthread_cancel (thread); pthread_mutex_unlock (&thread_map_lock); } - -void -pthread_exit_pbd (void* status) -{ - pthread_t thread = pthread_self(); - - pthread_mutex_lock (&thread_map_lock); - for (ThreadMap::iterator i = all_threads.begin(); i != all_threads.end(); ++i) { - if (i->second == thread) { - all_threads.erase (i); - break; - } - } - pthread_mutex_unlock (&thread_map_lock); - pthread_exit (status); -}