ComponentThreads: now basics are working.

Next step is to get the unified event loops working generically
and then we can begin region-splitting up the data in harikoff.

We'll assign all the global resource managers to Marionette and
then assign the Mind components to the respective component threads.

hcore/Makefile.am

@@ -2,5 +2,5 @@ SUBDIRS = deviceManager senseApis
 AM_CPPFLAGS+= -I"$(top_srcdir)/hcore/include"
 
 noinst_LIBRARIES = libhcore.a
-libhcore_a_SOURCES = mind.cpp opts.cpp componentThreads.cpp
+libhcore_a_SOURCES = mind.cpp opts.cpp componentThread.cpp
 

hcore/componentThread.cpp

@@ -0,0 +1,70 @@
+#include <iostream>
+#include <componentThread.h>
+
+namespace hk {
+
+namespace director {
+ComponentThread director;
+}
+namespace simulator {
+ComponentThread canvas;
+}
+namespace subconscious {
+ComponentThread subconscious;
+}
+
+std::unordered_map<std::thread::id, ComponentThread&>
+	ComponentThread::componentThreads =
+{
+	{director::director.thread.get_id(), director::director},
+	{simulator::canvas.thread.get_id(), simulator::canvas},
+	{subconscious::subconscious.thread.get_id(), subconscious::subconscious}
+};
+
+void ComponentThread::signalThread(std::thread::id id)
+{
+	auto it = componentThreads.find(id);
+	if (it == componentThreads.end())
+	{
+		throw std::runtime_error(std::string(__func__)
+			+ ": Thread ID not found in componentThreads map");
+	}
+
+	ComponentThread& componentThread = it->second;
+	{
+		std::lock_guard<std::mutex> lock(componentThread.startupSync.mutex);
+		componentThread.startupSync.ready = true;
+	}
+	componentThread.startupSync.cv.notify_one();
+}
+
+void ComponentThread::main(ComponentThread& self)
+{
+	std::cout << __func__ << ": Entered." << std::endl;
+	// We sleep on spawn until the main thread tells us to continue.
+	{
+		std::unique_lock<std::mutex> lock(self.startupSync.mutex);
+		self.startupSync.cv.wait(lock, [&self]() {
+			return self.startupSync.ready;
+		});
+	}
+
+	std::cout << __func__ << ": Starting event loop." << std::endl;
+	self.getIoService().run();
+	std::cout << __func__ << ": Exiting." << std::endl;
+}
+
+void ComponentThread::validateThreadIds(void)
+{
+	for (const auto& [id, componentThread] : componentThreads)
+	{
+		// std::thread::id() is usable as an invalid ID.
+		if (id == std::thread::id())
+		{
+			throw std::runtime_error(
+				std::string(__func__) + ": Invalid Thread ID.");
+		}
+	}
+}
+
+} // namespace hk

hcore/componentThreads.cpp

@@ -1,23 +0,0 @@
-#include <componentThread.h>
-
-namespace hk {
-
-namespace director {
-ComponentThread director;
-}
-namespace simulator {
-ComponentThread canvas;
-}
-namespace subconscious {
-ComponentThread subconscious;
-}
-
-std::unordered_map<std::thread::id, ComponentThread&>
-	ComponentThread::componentThreads =
-{
-	{director::director.thread.get_id(), director::director},
-	{simulator::canvas.thread.get_id(), simulator::canvas},
-	{subconscious::subconscious.thread.get_id(), subconscious::subconscious}
-};
-
-} // namespace hk

hcore/include/componentThread.h

@@ -13,7 +13,8 @@ class ComponentThread
 {
 public:
 	ComponentThread()
-			: work(io_service), startupSync()
+    :   work(io_service), startupSync(),
+        thread(ComponentThread::main, std::ref(*this))
 	{}
 
 	boost::asio::io_service& getIoService(void) { return io_service; }
@@ -31,10 +32,13 @@ public:
 		return it->second.getIoService();
 	}
 
+	static void main(ComponentThread &self);
+	static void signalThread(std::thread::id id);
+	static void validateThreadIds(void);
+
 public:
 	boost::asio::io_service io_service;
 	boost::asio::io_service::work work;
-	std::thread thread;
 	struct StartupSync {
 		std::mutex mutex;
 		std::condition_variable cv;
@@ -43,6 +47,10 @@ public:
 		StartupSync() : ready(false) {}
 	} startupSync;
 
+    /* Always ensure that this is last so that the thread is spawned after
+     * everything else.
+     */
+	std::thread thread;
 	static std::unordered_map<std::thread::id, ComponentThread&> componentThreads;
 };