Split: Cleanly split spinscale off from SMO

Remaining areas to split off:
* The handleLoopException, exceptionInd logic.
* getThreadName().

CMakeLists.txt

@@ -75,6 +75,7 @@ add_library(spinscale SHARED
 	src/lockerAndInvokerBase.cpp
 	src/componentThread.cpp
 	src/component.cpp
+	src/puppeteerComponent.cpp
 	src/puppetApplication.cpp
 	src/runtime.cpp
 	src/callableTracer.cpp

include/spinscale/component.h

@@ -2,8 +2,8 @@
 #define COMPONENT_H
 
 #include <config.h>
+#include <atomic>
 #include <memory>
-#include <functional>
 #include <spinscale/callback.h>
 #include <spinscale/puppetApplication.h>
 
@@ -40,13 +40,22 @@ class PuppetComponent
 :	public Component
 {
 public:
+	virtual void handleLoopExceptionHook() = 0;
+
 	PuppetComponent(
 		PuppetApplication &parent,
 		const std::shared_ptr<PuppetThread> &thread);
 	~PuppetComponent() = default;
 
+	static void defaultPuppetMain(const PuppetThread::EntryFnArguments &args);
+
 public:
 	PuppetApplication &parent;
+
+protected:
+	virtual void postJoltHook() {}
+	virtual void preLoopHook() {}
+	virtual void postLoopHook() {}
 };
 
 namespace pptr {
@@ -55,10 +64,26 @@ class PuppeteerComponent
 :	public Component
 {
 public:
+	virtual void handleLoopExceptionHook() = 0;
+
 	PuppeteerComponent(const std::shared_ptr<PuppeteerThread> &thread);
 	~PuppeteerComponent() = default;
+
+	static void defaultPuppeteerMain(
+		const PuppeteerThread::EntryFnArguments &args);
+
+protected:
+	virtual void postJoltHook() {}
+	virtual void tryBlock1Hook() {}
+	virtual void preLoopHook() {}
+	virtual void postLoopHook() {}
+	virtual void postTryBlock1CatchHook() {}
+	virtual void handleTryBlock1TypedException(const std::exception& e);
+	virtual void handleTryBlock1UnknownException();
 };
 
+extern std::atomic<int> exitCode;
+
 } // namespace pptr
 
 } // namespace sscl

include/spinscale/componentThread.h

@@ -19,9 +19,14 @@
 
 namespace sscl {
 
+class PuppetComponent;
 class PuppeteerThread;
 class PuppetThread;
 
+namespace pptr {
+class PuppeteerComponent;
+}
+
 // ThreadId is a generic type - application-specific enums should be defined elsewhere
 typedef uint8_t ThreadId;
 
@@ -29,8 +34,7 @@ class ComponentThread
 {
 protected:
 	ComponentThread(ThreadId _id)
-    :   id(_id), name(getThreadName(_id)),
-        work(io_service)
+    : id(_id), name(getThreadName(_id)), work(io_service)
 	{}
 
 public:
@@ -45,9 +49,11 @@ public:
 
 	static const std::shared_ptr<ComponentThread> getSelf(void);
 	static bool tlsInitialized(void);
-	static std::shared_ptr<PuppeteerThread> getMrntt();
-
-	typedef void (mainFn)(ComponentThread &self);
+	static void setPuppeteerThread(const std::shared_ptr<PuppeteerThread> &t);
+	static void setPuppeteerThreadId(ThreadId id);
+	static std::shared_ptr<PuppeteerThread> getPptr();
+	static std::shared_ptr<PuppeteerThread> getPuppeteer()
+		{ return getPptr(); }
 
 	// CPU management methods
 	static int getAvailableCpuCount();
@@ -71,16 +77,44 @@ class PuppeteerThread
 	public ComponentThread
 {
 public:
-	PuppeteerThread(ThreadId id = 0)
-	:	ComponentThread(id),
-	thread(main, std::ref(*this))
-	{
-	}
+	typedef void (*preJoltHookFn)(PuppeteerThread &);
+
+	struct EntryFnArguments
+	{
+		PuppeteerThread &usableBeforeJolt;
+		/**	EXPLANATION:
+		 * The `Puppet*Component` ref points at the Component object which this
+		 * thread is associated with. However, we have no guarantee that this
+		 * object has been constructed at the point of OS thread entry.
+		 *
+		 * Hence this ref must be dereferenced only after JOLT.
+		 */
+		pptr::PuppeteerComponent &useOnlyAfterJolt;
+		preJoltHookFn preJoltHook;
+	};
+
+	using entryPointFn = std::function<void(const EntryFnArguments &)>;
+
+	PuppeteerThread(
+		ThreadId id, entryPointFn entryPoint,
+		pptr::PuppeteerComponent &component,
+		preJoltHookFn preJoltFn)
+	:	ComponentThread(id),
+	entryFnArguments(*this, component, preJoltFn),
+	thread(std::move(entryPoint), std::cref(entryFnArguments))
+	{}
 
-	static void main(PuppeteerThread& self);
 	void initializeTls(void);
+	void exitLoop(void);
 
 public:
+	EntryFnArguments entryFnArguments;
+	/**	EXPLANATION:
+	 * Must always be memberwise-initialized last.
+	 * This ensures that the ref to this `ComponentThread` object, which is
+	 * passed to the entry point function, is fully constructed when the OS
+	 * thread begins executing.
+	 */
 	std::thread thread;
 };
 
@@ -89,6 +123,20 @@ class PuppetThread
 	public ComponentThread
 {
 public:
+	typedef void (*preJoltHookFn)(PuppetThread &);
+
+	struct EntryFnArguments
+	{
+		PuppetThread &usableBeforeJolt;
+		/** See comment above in:
+		 * PuppeteerThread::EntryFnArguments::useOnlyAfterJolt.
+		 */
+		PuppetComponent &useOnlyAfterJolt;
+		preJoltHookFn preJoltHook;
+	};
+
+	using entryPointFn = std::function<void(const EntryFnArguments &)>;
+
 	enum class ThreadOp
 	{
 		START,
@@ -99,17 +147,18 @@ public:
 		N_ITEMS
 	};
 
-	PuppetThread(ThreadId _id)
+	PuppetThread(
+		ThreadId _id, entryPointFn entryPoint, PuppetComponent &component,
+		preJoltHookFn preJoltFn)
 	:	ComponentThread(_id),
 	pinnedCpuId(-1),
 	pause_work(pause_io_service),
-	thread(main, std::ref(*this))
-	{
-	}
+	entryFnArguments(*this, component, preJoltFn),
+	thread(std::move(entryPoint), std::cref(entryFnArguments))
+	{}
 
 	virtual ~PuppetThread() = default;
 
-	static void main(PuppetThread& self);
 	void initializeTls(void);
 
 	// Thread management methods
@@ -137,17 +186,16 @@ public:
 	// CPU management methods
 	void pinToCpu(int cpuId);
 
-protected:
-	/**
-	 * Handle exception - called from main() when an exception occurs.
-	 * Derived classes can override to provide application-specific handling.
-	 */
-	virtual void handleException() {}
-
 public:
 	int pinnedCpuId;
 	boost::asio::io_service pause_io_service;
 	boost::asio::io_service::work pause_work;
+
+public:
+	EntryFnArguments entryFnArguments;
+	/** Must always be memberwise-initialized last.
+	 * See comment on `PuppeteerThread::thread` for explanation.
+	 */
 	std::thread thread;
 
 public:
@@ -156,11 +204,7 @@ public:
 
 namespace pptr {
 extern std::shared_ptr<PuppeteerThread> thread;
-
-// Forward declaration for puppeteer thread ID management
-// Must be after sscl namespace so ThreadId is defined
 extern ThreadId puppeteerThreadId;
-void setPuppeteerThreadId(ThreadId id);
 } // namespace pptr
 
 } // namespace sscl

include/spinscale/marionette.h

@@ -1,59 +0,0 @@
-#ifndef _MARIONETTE_H
-#define _MARIONETTE_H
-
-#include <cstdint>
-#include <atomic>
-#include <memory>
-#include <spinscale/component.h>
-
-namespace sscl {
-
-class PuppeteerThread;
-extern std::shared_ptr<sscl::PuppeteerThread> thread;
-
-namespace pptr {
-
-class MarionetteComponent
-:	public sscl::Component
-{
-public:
-	MarionetteComponent(const std::shared_ptr<sscl::ComponentThread> &thread);
-	~MarionetteComponent() = default;
-
-public:
-	typedef std::function<void(bool)> mrnttLifetimeMgmtOpCbFn;
-	void initializeReq(sscl::Callback<mrnttLifetimeMgmtOpCbFn> callback);
-	void finalizeReq(sscl::Callback<mrnttLifetimeMgmtOpCbFn> callback);
-	// Intentionally doesn't take a callback.
-	void exceptionInd();
-
-private:
-	class MrnttLifetimeMgmtOp;
-	class TerminationEvent;
-};
-
-extern std::atomic<int> exitCode;
-void exitMarionetteLoop();
-void marionetteFinalizeReqCb(bool success);
-extern MarionetteComponent mrntt;
-
-} // namespace pptr
-
-struct CrtCommandLineArgs
-{
-	CrtCommandLineArgs(int argc, char *argv[], char *envp[])
-	:	argc(argc), argv(argv), envp(envp)
-	{}
-
-	int argc;
-	char **argv;
-	char **envp;
-
-	static void set(int argc, char *argv[], char *envp[]);
-};
-
-extern CrtCommandLineArgs crtCommandLineArgs;
-
-} // namespace sscl
-
-#endif // _MARIONETTE_H

include/spinscale/runtime.h

@@ -0,0 +1,23 @@
+#ifndef RUNTIME_H
+#define RUNTIME_H
+
+namespace sscl {
+
+struct CrtCommandLineArgs
+{
+	CrtCommandLineArgs(int argc, char *argv[], char *envp[])
+	:	argc(argc), argv(argv), envp(envp)
+	{}
+
+	int argc;
+	char **argv;
+	char **envp;
+
+	static void set(int argc, char *argv[], char *envp[]);
+};
+
+extern CrtCommandLineArgs crtCommandLineArgs;
+
+} // namespace sscl
+
+#endif // RUNTIME_H

src/component.cpp

@@ -1,6 +1,8 @@
+#include <iostream>
+#include <pthread.h>
 #include <spinscale/component.h>
+#include <spinscale/componentThread.h>
 #include <spinscale/puppetApplication.h>
-#include <spinscale/marionette.h>
 
 namespace sscl {
 
@@ -16,10 +18,76 @@ parent(parent)
 {
 }
 
+void PuppetComponent::defaultPuppetMain(
+	const PuppetThread::EntryFnArguments &args)
+{
+	PuppetThread &thr = args.usableBeforeJolt;
+	PuppetComponent &comp = args.useOnlyAfterJolt;
+
+	if (args.preJoltHook) { args.preJoltHook(thr); }
+
+	/**	FIXME:
+	 * Figure out why we don't call reset() here, and then explicitly document
+	 * it.
+	 */
+	thr.getIoService().run();
+	thr.initializeTls();
+
+	comp.postJoltHook();
+	comp.preLoopHook();
+
+	/* We loop here because when an exception is caught, we need to first catch
+	 * it in the catch blocks and invoke handleLoopExceptionHook so the
+	 * application can respond (e.g. notify a controller). We then re-enter
+	 * the loop to await control messages.
+	 *
+	 * We can't just exit on our own. Rather, keepLooping must be set to false
+	 * by the application when shutdown is desired.
+	 */
+	for (thr.keepLooping = true; thr.keepLooping;)
+	{
+		bool sendExceptionInd = false;
+
+		try {
+			/**		EXPLANATION:
+			 * This reset() call is crucial for async bridging patterns
+			 * to work.
+			 * When the outermost thread's io_service is stop()ped (e.g.,
+			 * from JOLT sequence), it won't process any new work until
+			 * reset() is called, even if nested async operations try to
+			 * post work to it. This means async bridges invoked from
+			 * the outermost thread main sequence won't work until this
+			 * reset() call.
+			 */
+			thr.getIoService().reset();
+			thr.getIoService().run();
+		}
+		catch (const std::exception& e)
+		{
+			sendExceptionInd = true;
+			std::cerr << thr.name << ":" << __func__
+				<< ": Exception occurred: " << e.what() << "\n";
+		}
+		catch (...)
+		{
+			sendExceptionInd = true;
+			std::cerr << thr.name << ":" << __func__
+				<< ": Unknown exception occurred" << "\n";
+		}
+
+		if (sendExceptionInd)
+		{
+			comp.handleLoopExceptionHook();
+		}
+	}
+
+	comp.postLoopHook();
+}
+
 namespace pptr {
 
-MarionetteComponent::MarionetteComponent(
-	const std::shared_ptr<sscl::ComponentThread> &thread)
+PuppeteerComponent::PuppeteerComponent(
+	const std::shared_ptr<sscl::PuppeteerThread> &thread)
 :	sscl::Component(thread)
 {
 }

src/componentThread.cpp

@@ -8,35 +8,48 @@
 #include <spinscale/asynchronousContinuation.h>
 #include <spinscale/callback.h>
 #include <spinscale/callableTracer.h>
+#include <spinscale/component.h>
 #include <spinscale/componentThread.h>
-#include <spinscale/marionette.h>
 
 namespace sscl {
 
 namespace pptr {
 /* Global variable to store the puppeteer thread ID
  * Default value is 0, but should be set by application code via
- * setPuppeteerThreadId().
+ * ComponentThread::setPuppeteerThreadId().
  */
 ThreadId puppeteerThreadId = 0;
-/* Global puppeteer thread instance - defined here but initialized by
- * application code.
+/* Global puppeteer thread instance - assigned by application code
+ * (e.g. smo::mrntt::thread) via setPuppeteerThread().
  */
 std::shared_ptr<PuppeteerThread> thread;
 
-void setPuppeteerThreadId(ThreadId id)
-{
-	puppeteerThreadId = id;
-}
-
 } // namespace pptr
 
 thread_local std::shared_ptr<ComponentThread> thisComponentThread;
 
-// Implementation of static method
-std::shared_ptr<PuppeteerThread> ComponentThread::getMrntt()
+void ComponentThread::setPuppeteerThreadId(ThreadId id)
 {
-	return sscl::pptr::thread;
+	pptr::puppeteerThreadId = id;
+}
+
+void ComponentThread::setPuppeteerThread(
+	const std::shared_ptr<PuppeteerThread> &t
+	)
+{
+	pptr::thread = t;
+}
+
+std::shared_ptr<PuppeteerThread> ComponentThread::getPptr()
+{
+	return pptr::thread;
+}
+
+void PuppeteerThread::exitLoop(void)
+{
+	keepLooping = false;
+	getIoService().stop();
+	std::cout << name << ": Signaled main loop to exit." << "\n";
 }
 
 void PuppeteerThread::initializeTls(void)
@@ -191,7 +204,7 @@ void PuppetThread::joltThreadReq(
 			+ ": invoked on puppeteer thread");
 	}
 
-	std::shared_ptr<PuppeteerThread> puppeteer = sscl::pptr::thread;
+	std::shared_ptr<PuppeteerThread> puppeteer = pptr::thread;
 
 	auto request = std::make_shared<ThreadLifetimeMgmtOp>(
 		puppeteer, selfPtr, callback);

src/puppeteerComponent.cpp

@@ -0,0 +1,99 @@
+#include <iostream>
+#include <pthread.h>
+#include <spinscale/component.h>
+#include <spinscale/componentThread.h>
+
+namespace sscl {
+namespace pptr {
+
+std::atomic<int> exitCode{0};
+
+void PuppeteerComponent::defaultPuppeteerMain(
+	const PuppeteerThread::EntryFnArguments &args)
+{
+	PuppeteerThread &thr = args.usableBeforeJolt;
+	PuppeteerComponent &comp = args.useOnlyAfterJolt;
+
+	if (args.preJoltHook) { args.preJoltHook(thr); }
+
+	thr.getIoService().reset();
+	thr.getIoService().run();
+	thr.initializeTls();
+
+	comp.postJoltHook();
+
+	try {
+		comp.tryBlock1Hook();
+		comp.preLoopHook();
+
+		/* We loop here because when an exception occurs, we need to
+		 * both direct the puppet threads to exit gracefully, and then we
+		 * also need to post messages to our own event loop to initiate
+		 * our own orderly exit. So we loop here to re-enter the event
+		 * loop, both to receive the ACK messages from the puppet
+		 * threads, and to post messages to our own event loop to
+		 * initiate our own orderly exit.
+		 */
+		for (thr.keepLooping = true; thr.keepLooping;)
+		{
+			bool sendExceptionInd = false;
+
+			try {
+				/**		EXPLANATION:
+				 * This reset() call is crucial for async bridging
+				 * patterns to work.
+				 * When the outermost thread's io_service is stop()ped
+				 * (e.g., from JOLT sequence), it won't process any new
+				 * work until reset() is called, even if nested async
+				 * operations try to post work to it. This means async
+				 * bridges invoked from the outermost thread main sequence
+				 * won't work until this reset() call.
+				 */
+				thr.getIoService().reset();
+				thr.getIoService().run();
+			}
+			catch (const std::exception& e)
+			{
+				sendExceptionInd = true;
+				std::cerr << thr.name << ":main: Exception occurred: "
+					<< e.what() << "\n";
+			}
+			catch (...)
+			{
+				sendExceptionInd = true;
+				std::cerr << thr.name
+					<< ":main: Unknown exception occurred" << "\n";
+			}
+
+			if (sendExceptionInd)
+			{
+				comp.handleLoopExceptionHook();
+			}
+		}
+
+		comp.postLoopHook();
+	}
+	catch (const std::exception& e)
+	{
+		comp.handleTryBlock1TypedException(e);
+	}
+	catch (...)
+	{
+		comp.handleTryBlock1UnknownException();
+	}
+
+	comp.postTryBlock1CatchHook();
+}
+
+void PuppeteerComponent::handleTryBlock1TypedException(const std::exception& e)
+{
+	std::cerr << "main: Exception occurred: " << e.what() << std::endl;
+}
+
+void PuppeteerComponent::handleTryBlock1UnknownException()
+{
+	std::cerr << "main: Unknown exception occurred" << std::endl;
+}
+
+} // namespace pptr
+} // namespace sscl

src/runtime.cpp

@@ -1,4 +1,4 @@
-#include <spinscale/marionette.h>
+#include <spinscale/runtime.h>
 
 namespace sscl {