redesign cross-thread registration/signalling system

This new design will work even when threads that need to receive
messages from RT threads are created *after* the RT threads. The
existing design would fail because the RT thread(s) would never
be known the later created threads, and so signals emitted by the
RT thread and causing call_slot() in the receiver would end up
being enqueued using a lock-protected list. The new design ensures
that communication always uses a lock-free FIFO instead

6 files changed, 45 insertions, 5 deletions

diff --git a/libs/ardour/ardour/control_protocol_manager.h b/libs/ardour/ardour/control_protocol_manager.h
index 0c14d2a049..dbbb0c3891 100644
--- a/libs/ardour/ardour/control_protocol_manager.h
+++ b/libs/ardour/ardour/control_protocol_manager.h
@@ -65,6 +65,7 @@ class LIBARDOUR_API ControlProtocolManager : public PBD::Stateful, public ARDOUR
 	void load_mandatory_protocols ();
 	void midi_connectivity_established ();
 	void drop_protocols ();
+	void register_request_buffer_factories ();
 
 	int activate (ControlProtocolInfo&);
         int deactivate (ControlProtocolInfo&);
diff --git a/libs/ardour/ardour/midi_ui.h b/libs/ardour/ardour/midi_ui.h
index 7f57f22e24..2f0f7d3a45 100644
--- a/libs/ardour/ardour/midi_ui.h
+++ b/libs/ardour/ardour/midi_ui.h
@@ -51,6 +51,7 @@ class LIBARDOUR_API MidiControlUI : public AbstractUI<MidiUIRequest>
 	~MidiControlUI ();
 
 	static MidiControlUI* instance() { return _instance; }
+	static void* request_factory (uint32_t num_requests);
 
 	void change_midi_ports ();
 
diff --git a/libs/ardour/audioengine.cc b/libs/ardour/audioengine.cc
index 3452d1d14c..9c8407e8d7 100644
--- a/libs/ardour/audioengine.cc
+++ b/libs/ardour/audioengine.cc
@@ -1226,8 +1226,7 @@ AudioEngine::thread_init_callback (void* arg)
 
 	SessionEvent::create_per_thread_pool (X_("AudioEngine"), 512);
 
-	PBD::notify_gui_about_thread_creation ("gui", pthread_self(), X_("AudioEngine"), 4096);
-	PBD::notify_gui_about_thread_creation ("midiUI", pthread_self(), X_("AudioEngine"), 128);
+	PBD::notify_event_loops_about_thread_creation (pthread_self(), X_("AudioEngine"), 4096);
 
 	AsyncMIDIPort::set_process_thread (pthread_self());
 
diff --git a/libs/ardour/control_protocol_manager.cc b/libs/ardour/control_protocol_manager.cc
index 4e2cb7d9f7..6583869fed 100644
--- a/libs/ardour/control_protocol_manager.cc
+++ b/libs/ardour/control_protocol_manager.cc
@@ -22,6 +22,7 @@
 #include <glibmm/fileutils.h>
 
 #include "pbd/compose.h"
+#include "pbd/event_loop.h"
 #include "pbd/file_utils.h"
 #include "pbd/error.h"
 
@@ -487,3 +488,15 @@ ControlProtocolManager::midi_connectivity_established ()
 		(*p)->midi_connectivity_established ();
 	}
 }
+
+void
+ControlProtocolManager::register_request_buffer_factories ()
+{
+	Glib::Threads::Mutex::Lock lm (protocols_lock);
+
+	for (list<ControlProtocolInfo*>::iterator i = control_protocol_info.begin(); i != control_protocol_info.end(); ++i) {
+		if ((*i)->descriptor->request_buffer_factory) {
+			EventLoop::register_request_buffer_factory ((*i)->descriptor->name, (*i)->descriptor->request_buffer_factory);
+		}
+	}
+}
diff --git a/libs/ardour/globals.cc b/libs/ardour/globals.cc
index b2ad67d053..9f4a1399b3 100644
--- a/libs/ardour/globals.cc
+++ b/libs/ardour/globals.cc
@@ -97,6 +97,7 @@
 #include "ardour/event_type_map.h"
 #include "ardour/filesystem_paths.h"
 #include "ardour/midi_region.h"
+#include "ardour/midi_ui.h"
 #include "ardour/midiport_manager.h"
 #include "ardour/mix.h"
 #include "ardour/operations.h"
@@ -513,6 +514,22 @@ ARDOUR::init (bool use_windows_vst, bool try_optimization, const char* localedir
 #endif
 	(void) EventTypeMap::instance();
 
+	ControlProtocolManager::instance().discover_control_protocols ();
+
+	/* for each control protocol, check for a request buffer factory method
+	   and if it exists, store it in the EventLoop list of such
+	   methods. This allows the relevant threads to register themselves
+	   with EventLoops so that signal emission can be RT-safe.
+	*/
+
+	ControlProtocolManager::instance().register_request_buffer_factories ();
+	/* it would be nice if this could auto-register itself in the
+	   constructor, since MidiControlUI is a singleton, but it can't be
+	   created until after the engine is running. Therefore we have to
+	   explicitly register it here.
+	*/
+	EventLoop::register_request_buffer_factory (X_("midiUI"), MidiControlUI::request_factory);
+
         ProcessThread::init ();
 	/* the + 4 is a bit of a handwave. i don't actually know
 	   how many more per-thread buffer sets we need above
@@ -553,8 +570,6 @@ ARDOUR::init (bool use_windows_vst, bool try_optimization, const char* localedir
 void
 ARDOUR::init_post_engine ()
 {
-	ControlProtocolManager::instance().discover_control_protocols ();
-
 	XMLNode* node;
 	if ((node = Config->control_protocol_state()) != 0) {
 		ControlProtocolManager::instance().set_state (*node, Stateful::loading_state_version);
diff --git a/libs/ardour/midi_ui.cc b/libs/ardour/midi_ui.cc
index 96304fa051..1d2fe7c7e1 100644
--- a/libs/ardour/midi_ui.cc
+++ b/libs/ardour/midi_ui.cc
@@ -60,6 +60,17 @@ MidiControlUI::~MidiControlUI ()
 	_instance = 0;
 }
 
+void*
+MidiControlUI::request_factory (uint32_t num_requests)
+{
+	/* AbstractUI<T>::request_buffer_factory() is a template method only
+	   instantiated in this source module. To provide something visible for
+	   use when registering the factory, we have this static method that is
+	   template-free.
+	*/
+	return request_buffer_factory (num_requests);
+}
+
 void
 MidiControlUI::do_request (MidiUIRequest* req)
 {
@@ -131,7 +142,7 @@ MidiControlUI::thread_init ()
 
 	pthread_set_name (X_("midiUI"));
 
-	PBD::notify_gui_about_thread_creation (X_("gui"), pthread_self(), X_("midiUI"), 2048);
+	PBD::notify_event_loops_about_thread_creation (pthread_self(), X_("midiUI"), 2048);
 	SessionEvent::create_per_thread_pool (X_("midiUI"), 128);
 
 	memset (&rtparam, 0, sizeof (rtparam));