92 lines
3.0 KiB
C++
92 lines
3.0 KiB
C++
#ifndef _MIND_H
|
|
#define _MIND_H
|
|
|
|
#include <config.h>
|
|
#include <thread>
|
|
#include <functional>
|
|
#include <memory>
|
|
#include <unordered_map>
|
|
#include <string>
|
|
|
|
#include <director/director.h>
|
|
#include <simulator/simulator.h>
|
|
#include <componentThread.h>
|
|
|
|
namespace smo {
|
|
|
|
class Mind : public std::enable_shared_from_this<Mind>
|
|
{
|
|
public:
|
|
Mind(void);
|
|
~Mind(void) = default;
|
|
|
|
typedef std::function<void(bool)> mindLifetimeMgmtOpCbFn;
|
|
void initializeReq(mindLifetimeMgmtOpCbFn callback);
|
|
void finalizeReq(mindLifetimeMgmtOpCbFn callback);
|
|
void initializeBodyReq(mindLifetimeMgmtOpCbFn callback);
|
|
void finalizeBodyReq(mindLifetimeMgmtOpCbFn callback);
|
|
|
|
// ComponentThread access methods
|
|
std::shared_ptr<ComponentThread> getComponentThread(
|
|
ComponentThread::ThreadId id) const;
|
|
std::shared_ptr<ComponentThread> getComponentThread(
|
|
const std::string& name) const;
|
|
// Get all this Mind's component threads.
|
|
std::vector<std::shared_ptr<ComponentThread>> getMindThreads() const;
|
|
|
|
// Thread management methods (moved from ComponentThread)
|
|
typedef std::function<void()> mindThreadLifetimeMgmtOpCbFn;
|
|
void joltAllMindThreadsReq(mindThreadLifetimeMgmtOpCbFn callback);
|
|
void startAllMindThreadsReq(mindThreadLifetimeMgmtOpCbFn callback);
|
|
void pauseAllMindThreadsReq(mindThreadLifetimeMgmtOpCbFn callback);
|
|
void resumeAllMindThreadsReq(mindThreadLifetimeMgmtOpCbFn callback);
|
|
void exitAllMindThreadsReq(mindThreadLifetimeMgmtOpCbFn callback);
|
|
|
|
// CPU distribution method
|
|
void distributeAndPinThreadsAcrossCpus();
|
|
|
|
public:
|
|
std::thread directorThread;
|
|
std::thread simulatorThread;
|
|
std::thread subconsciousThread;
|
|
|
|
director::Director director;
|
|
simulator::Simulator canvas;
|
|
|
|
private:
|
|
/**
|
|
* Indicates whether all mind threads have been JOLTed at least once.
|
|
*
|
|
* JOLTing serves two critical purposes:
|
|
*
|
|
* 1. **Global Constructor Sequencing**: Since pthreads begin executing while
|
|
* global constructors are still being executed, globally defined pthreads
|
|
* cannot depend on global objects having been constructed. JOLTing is done
|
|
* by the CRT's main thread within main(), which provides a sequencing
|
|
* guarantee that global constructors have been called.
|
|
*
|
|
* 2. **shared_from_this Safety**: shared_from_this() requires a prior
|
|
* shared_ptr handle to be established. The global list of
|
|
* shared_ptr<ComponentThread> guarantees that at least one shared_ptr to
|
|
* each ComponentThread has been initialized before JOLTing occurs.
|
|
*
|
|
* This flag ensures that JOLTing happens exactly once and provides
|
|
* a synchronization point for the entire system initialization.
|
|
*/
|
|
bool threadsHaveBeenJolted = false;
|
|
// Collection of ComponentThread instances (excluding marionette)
|
|
std::vector<std::shared_ptr<ComponentThread>> componentThreads;
|
|
|
|
class MindLifetimeMgmtOp;
|
|
class MindThreadLifetimeMgmtOp;
|
|
class InitializeBodyReq;
|
|
class FinalizeBodyReq;
|
|
};
|
|
|
|
// Global Mind instance will be defined in marionette.cpp
|
|
extern std::shared_ptr<Mind> globalMind;
|
|
|
|
} // namespace smo
|
|
|
|
#endif
|