Mind,Mrntt: Use async pattern in Mind; init threads before initializeSmo

In Mrntt, we now initialize Mind:: object threads before calling initializeSalmanoffReq(). We've also propagated the spinscale async pattern into the Mind class.
2025-09-11 20:11:10 -04:00
parent 89947dfc71
commit 4429135539
3 changed files with 266 additions and 143 deletions
@@ -1,5 +1,7 @@
 #include <iostream>
 #include <opts.h>
+#include <asynchronousContinuation.h>
+#include <asynchronousLoop.h>
 #include <mind.h>
 #include <componentThread.h>

@@ -16,94 +18,6 @@ Mind::Mind(void)
 {
 }

-void Mind::initialize()
-{
-    /* Distribute threads across available CPUs */
-    try
-    {
-        distributeAndPinThreadsAcrossCpus();
-    }
-    catch (const std::exception& e)
-    {
-        std::cerr << "Salmanoff couldn't distribute the mind threads across "
-            "the CPUs, so performance may be suboptimal.\n"
-            "Error: " << e.what() << "\n";
-    }
-
-    /* Jolt the threads, then start them */
-    joltAllMindThreadsReq(
-        [this]()
-        {
-            std::cout << "Mrntt: All mind threads JOLTed." << "\n";
-            // Start all threads after JOLTing
-            startAllMindThreadsReq(
-                []()
-                {
-                    std::cout << "Mrntt: All mind threads started." << "\n";
-                }
-            );
-        }
-    );
-}
-
-void Mind::finalizeReq(std::function<void()> callback)
-{
-    /* If the threads haven't been jolted, we need to do that first, because
-     * otherwise they'll just enter their main loops and wait for control
-     * messages from mrntt after processing the exit request.
-     */
-    if (!threadsHaveBeenJolted)
-    {
-        joltAllMindThreadsReq(
-            [this, callback]()
-            {
-                exitAllMindThreadsReq(
-                    [callback]()
-                    {
-                        std::cout << "Mrntt: All mind threads exited." << "\n";
-                        if (callback) { callback(); }
-                    }
-                );
-            }
-        );
-    }
-    else
-    {
-        exitAllMindThreadsReq(
-            [callback]()
-            {
-                std::cout << "Mrntt: All mind threads exited." << "\n";
-                if (callback) { callback(); }
-            }
-        );
-    }
-}
-
-void Mind::joltAllMindThreadsReq(std::function<void()> callback)
-{
-    // Create a counter to track when all threads have been jolted
-    auto counter = std::make_shared<std::atomic<int>>(componentThreads.size());
-
-    for (auto& thread : componentThreads)
-	{
-        thread->joltThreadReq([counter, callback, this]() {
-            if (--(*counter) == 0)
-			{
-                // Set the flag only after all threads have ACKed their JOLT
-                threadsHaveBeenJolted = true;
-                if (callback) { callback(); }
-            }
-        });
-    }
-
-    // If no threads, set flag and call callback immediately
-    if (componentThreads.empty())
-	{
-        threadsHaveBeenJolted = true;
-        if (callback) { callback(); }
-    }
-}
-
 std::shared_ptr<ComponentThread>
 Mind::getComponentThread(ComponentThread::ThreadId id) const
 {
@@ -141,6 +55,117 @@ Mind::getMindThreads() const
    return componentThreads;
 }

+class Mind::MindLifetimeMgmtOp
+:	public AsynchronousContinuation<mindLifetimeMgmtOpCbFn>
+{
+public:
+	MindLifetimeMgmtOp(
+		Mind &parent, mindLifetimeMgmtOpCbFn callback)
+	:	AsynchronousContinuation<mindLifetimeMgmtOpCbFn>(callback),
+		parent(parent)
+	{}
+
+	void callOriginalCbFn(void)
+	{
+		if (originalCbFn) {
+			originalCbFn(true);
+		}
+	}
+
+public:
+	Mind &parent;
+
+public:
+	void initializeReq1(
+		[[maybe_unused]] std::shared_ptr<MindLifetimeMgmtOp> context
+		)
+	{
+		std::cout << "Mrntt: All mind threads JOLTed." << "\n";
+
+		parent.startAllMindThreadsReq(
+			std::bind(
+				&MindLifetimeMgmtOp::initializeReq2,
+				context.get(), context));
+	}
+
+	void initializeReq2(
+		[[maybe_unused]] std::shared_ptr<MindLifetimeMgmtOp> context
+		)
+	{
+		std::cout << "Mrntt: All mind threads started." << "\n";
+		callOriginalCbFn();
+	}
+
+	void finalizeReq1(
+		[[maybe_unused]] std::shared_ptr<MindLifetimeMgmtOp> context
+		)
+	{
+		std::cout << "Mrntt: All mind threads JOLTed." << "\n";
+
+		parent.exitAllMindThreadsReq(
+			std::bind(
+				&MindLifetimeMgmtOp::finalizeReq2,
+				context.get(), context));
+	}
+
+	void finalizeReq2(
+		[[maybe_unused]] std::shared_ptr<MindLifetimeMgmtOp> context
+		)
+	{
+		std::cout << "Mrntt: All mind threads exited." << "\n";
+		callOriginalCbFn();
+	}
+};
+
+void Mind::initializeReq(mindLifetimeMgmtOpCbFn callback)
+{
+    /* Distribute threads across available CPUs */
+    try
+    {
+        distributeAndPinThreadsAcrossCpus();
+    }
+    catch (const std::exception& e)
+    {
+        std::cerr << "Salmanoff couldn't distribute the mind threads across "
+            "the CPUs, so performance may be suboptimal.\n"
+            "Error: " << e.what() << "\n";
+    }
+
+	auto request = std::make_shared<MindLifetimeMgmtOp>(
+		*this, callback);
+
+    /* Jolt the threads, then start them */
+    joltAllMindThreadsReq(
+		std::bind(
+			&MindLifetimeMgmtOp::initializeReq1,
+			request.get(), request));
+}
+
+void Mind::finalizeReq(mindLifetimeMgmtOpCbFn callback)
+{
+	auto request = std::make_shared<MindLifetimeMgmtOp>(
+		*this, callback);
+
+    /* If the threads haven't been jolted, we need to do that first, because
+     * otherwise they'll just enter their main loops and wait for control
+     * messages from mrntt after processing the exit request.
+     */
+    if (!threadsHaveBeenJolted)
+    {
+        joltAllMindThreadsReq(
+			std::bind(
+				&MindLifetimeMgmtOp::finalizeReq1,
+				request.get(), request));
+    }
+    else
+    {
+        exitAllMindThreadsReq(
+			std::bind(
+				&MindLifetimeMgmtOp::finalizeReq1,
+				request.get(), request));
+    }
+}
+
 void Mind::distributeAndPinThreadsAcrossCpus()
 {
    int cpuCount = ComponentThread::getAvailableCpuCount();
@@ -162,82 +187,165 @@ void Mind::distributeAndPinThreadsAcrossCpus()
 		<< "across " << cpuCount << " CPUs\n";
 }

+class Mind::MindThreadLifetimeMgmtOp
+:	public AsynchronousContinuation<mindThreadLifetimeMgmtOpCbFn>
+{
+public:
+	MindThreadLifetimeMgmtOp(
+		Mind &parent,unsigned int nThreads,
+		mindThreadLifetimeMgmtOpCbFn callback)
+	:	AsynchronousContinuation<mindThreadLifetimeMgmtOpCbFn>(callback),
+	loop(nThreads),
+	parent(parent)
+	{}
+
+	void callOriginalCbFn(void)
+	{
+		if (originalCbFn) {
+			originalCbFn();
+		}
+	}
+
+public:
+	AsynchronousLoop	loop;
+	Mind &parent;
+
+public:
+	void joltAllMindThreadsReq1(
+		[[maybe_unused]] std::shared_ptr<MindThreadLifetimeMgmtOp> context
+		)
+	{
+		loop.incrementSuccessOrFailureDueTo(true);
+		if (!loop.isComplete()) {
+			return;
+		}
+
+		parent.threadsHaveBeenJolted = true;
+		callOriginalCbFn();
+	}
+
+	void executeGenericOpOnAllMindThreadsReq1(
+		[[maybe_unused]] std::shared_ptr<MindThreadLifetimeMgmtOp> context
+		)
+	{
+		loop.incrementSuccessOrFailureDueTo(true);
+		if (!loop.isComplete()) {
+			return;
+		}
+
+		callOriginalCbFn();
+	}
+
+	void exitAllMindThreadsReq1(
+		[[maybe_unused]] std::shared_ptr<MindThreadLifetimeMgmtOp> context
+		)
+	{
+		loop.incrementSuccessOrFailureDueTo(true);
+		if (!loop.isComplete()) {
+			return;
+		}
+
+		for (auto& thread : parent.componentThreads) {
+			thread->thread.join();
+		}
+
+		callOriginalCbFn();
+	}
+};
+
+void Mind::joltAllMindThreadsReq(mindThreadLifetimeMgmtOpCbFn callback)
+{
+    // Create a counter to track when all threads have been jolted
+    auto request = std::make_shared<MindThreadLifetimeMgmtOp>(
+		*this, componentThreads.size(), callback);
+
+    for (auto& thread : componentThreads)
+	{
+        thread->joltThreadReq(
+			std::bind(
+				&MindThreadLifetimeMgmtOp::joltAllMindThreadsReq1,
+				request.get(), request));
+    }
+
+    // If no threads, set flag and call callback immediately
+    if (request->loop.nTotalIsZero() && callback)
+	{
+        threadsHaveBeenJolted = true;
+        callback();
+    }
+}
+
 // Thread management methods (moved from ComponentThread)
-void Mind::startAllMindThreadsReq(std::function<void()> callback)
+void Mind::startAllMindThreadsReq(mindThreadLifetimeMgmtOpCbFn callback)
 {
    // Create a counter to track when all threads have started
-    auto counter = std::make_shared<std::atomic<int>>(componentThreads.size());
+    auto request = std::make_shared<MindThreadLifetimeMgmtOp>(
+		*this, componentThreads.size(), callback);

    for (auto& thread : componentThreads)
 	{
-        thread->startThreadReq([counter, callback]() {
-            if (--(*counter) == 0 && callback) { callback(); }
-        });
+        thread->startThreadReq(
+			std::bind(
+				&MindThreadLifetimeMgmtOp::executeGenericOpOnAllMindThreadsReq1,
+				request.get(), request));
    }

    // If no threads, call callback immediately
-    if (componentThreads.empty() && callback) { callback(); }
+    if (request->loop.nTotalIsZero() && callback) { callback(); }
 }

-void Mind::pauseAllMindThreadsReq(std::function<void()> callback)
+void Mind::pauseAllMindThreadsReq(mindThreadLifetimeMgmtOpCbFn callback)
 {
    // Create a counter to track when all threads have paused
-    auto counter = std::make_shared<std::atomic<int>>(componentThreads.size());
+    auto request = std::make_shared<MindThreadLifetimeMgmtOp>(
+		*this, componentThreads.size(), callback);

    for (auto& thread : componentThreads)
 	{
-        thread->pauseThreadReq([counter, callback]() {
-            if (--(*counter) == 0 && callback) { callback(); }
-        });
+        thread->pauseThreadReq(
+			std::bind(
+				&MindThreadLifetimeMgmtOp::executeGenericOpOnAllMindThreadsReq1,
+				request.get(), request));
    }

    // If no threads, call callback immediately
-    if (componentThreads.empty() && callback) {
-        callback();
-    }
+    if (request->loop.nTotalIsZero() && callback) { callback(); }
 }

-void Mind::resumeAllMindThreadsReq(std::function<void()> callback)
+void Mind::resumeAllMindThreadsReq(mindThreadLifetimeMgmtOpCbFn callback)
 {
    // Create a counter to track when all threads have resumed
-    auto counter = std::make_shared<std::atomic<int>>(componentThreads.size());
+    auto request = std::make_shared<MindThreadLifetimeMgmtOp>(
+		*this, componentThreads.size(), callback);

    for (auto& thread : componentThreads)
 	{
-        thread->resumeThreadReq([counter, callback]() {
-            if (--(*counter) == 0 && callback) { callback(); }
-        });
+        thread->resumeThreadReq(
+			std::bind(
+				&MindThreadLifetimeMgmtOp::executeGenericOpOnAllMindThreadsReq1,
+				request.get(), request));
    }

    // If no threads, call callback immediately
-    if (componentThreads.empty() && callback) {
-        callback();
-    }
+    if (request->loop.nTotalIsZero() && callback) { callback(); }
 }

-void Mind::exitAllMindThreadsReq(std::function<void()> callback)
+void Mind::exitAllMindThreadsReq(mindThreadLifetimeMgmtOpCbFn callback)
 {
    // Create a counter to track when all threads have exited
-    auto counter = std::make_shared<std::atomic<int>>(componentThreads.size());
+    auto request = std::make_shared<MindThreadLifetimeMgmtOp>(
+		*this, componentThreads.size(), callback);

    for (auto& thread : componentThreads)
 	{
-		thread->exitThreadReq([counter, callback, this]() {
-			if (--(*counter) == 0)
-			{
-				// All threads have exited their loops, now join them
-				for (auto& t : componentThreads) {
-					t->thread.join();
-				}
-				if (callback) { callback(); }
-			}
-		});
+		thread->exitThreadReq(
+			std::bind(
+				&MindThreadLifetimeMgmtOp::executeGenericOpOnAllMindThreadsReq1,
+				request.get(), request));
    }

    // If no threads, call callback immediately
-    if (componentThreads.empty() && callback) {
-        callback();
-    }
+    if (request->loop.nTotalIsZero() && callback) { callback(); }
 }

 } // namespace smo