add a new name for the region-layering-editor-action that tells us we were started...

[ardour.git] / libs / pbd / pthread_utils.cc

diff --git a/libs/pbd/pthread_utils.cc b/libs/pbd/pthread_utils.cc
index 495214a481364d0db1e41f1bfbcdb67121e4c044..d9e5ca40785f6c2aba4e76ad5876b68da8121338 100644 (file)
--- a/libs/pbd/pthread_utils.cc
+++ b/libs/pbd/pthread_utils.cc
@@ -18,9 +18,10 @@
     $Id$
 */
 
-#include <map>
+#include <set>
 #include <iostream>
 #include <string>
+#include <cstring>
 #include <stdint.h>
 
 #include "pbd/pthread_utils.h"
@@ -30,14 +31,13 @@
 
 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 pthread_mutex_t gui_notify_lock = PTHREAD_MUTEX_INITIALIZER;
+static Glib::StaticPrivate<char> thread_name;
 
 namespace PBD {
-       sigc::signal<void,pthread_t>             ThreadLeaving;
-       sigc::signal<void,std::string, pthread_t,std::string,uint32_t> ThreadCreatedWithRequestSize;
+       PBD::Signal4<void,std::string, pthread_t,std::string,uint32_t> ThreadCreatedWithRequestSize;
 }
 
 using namespace PBD;
@@ -54,17 +54,31 @@ static int thread_creator (pthread_t* thread_id, const pthread_attr_t* attr, voi
 void
 PBD::notify_gui_about_thread_creation (std::string target_gui, pthread_t thread, std::string str, int request_count)
 {
-       pthread_mutex_lock (&gui_notify_lock);
        ThreadCreatedWithRequestSize (target_gui, thread, str, request_count);
-       pthread_mutex_unlock (&gui_notify_lock);
 }
 
-void
-PBD::notify_gui_about_thread_exit (pthread_t thread)
+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)
 {
-       pthread_mutex_lock (&gui_notify_lock);
-       ThreadLeaving (thread);
-       pthread_mutex_unlock (&gui_notify_lock);
+       ThreadStartWithName* ts = (ThreadStartWithName*) arg;
+       void* (*thread_work)(void*) = ts->thread_work;
+       void* thread_arg = ts->arg;
+
+       pthread_set_name (ts->name.c_str());
+
+       delete ts;
+       /* name will be deleted by the default handler for GStaticPrivate, when the thread exits */
+
+       return thread_work (thread_arg);
 }
 
 int  
@@ -72,18 +86,16 @@ pthread_create_and_store (string name, pthread_t  *thread, void * (*start_routin
 {
        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;
+       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.insert (newpair);
+               all_threads.insert (*thread);
                pthread_mutex_unlock (&thread_map_lock);
        }
 
@@ -92,21 +104,22 @@ pthread_create_and_store (string name, pthread_t  *thread, void * (*start_routin
        return ret;
 }
 
-string
+void
+pthread_set_name (const char *str)
+{
+       /* copy string and delete it when exiting */
+       
+       thread_name.set (strdup (str), free);
+}
+
+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";
 }
 
@@ -115,8 +128,8 @@ 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 ((*i) != pthread_self()) {
+                       pthread_kill ((*i), signum);
                }
        }
        all_threads.clear();
@@ -128,8 +141,8 @@ 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);
+               if ((*i) != pthread_self()) {
+                       pthread_cancel ((*i));
                }
        }
        all_threads.clear();
@@ -141,7 +154,7 @@ 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 ((*i) == thread) {
                        all_threads.erase (i);
                        break;
                }
@@ -158,7 +171,7 @@ pthread_exit_pbd (void* status)
 
        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;
                }