PhysiologyEnginePool.h

/* Distributed under the Apache License, Version 2.0.
See accompanying NOTICE file for details.*/
 
#pragma once
 
#include "cdm/PhysiologyEngineThunk.h"
#include "cdm/utils/ThreadPool.h"
#include <chrono>
 
#include "cdm/engine/SEDataRequested.h"
#include "cdm/engine/SEEngineInitialization.h"
#include "cdm/substance/SESubstanceManager.h"
 
// TODO Template these class and move to CDM
// (Template is the PhysiologEngine type)
 
class SEPhysiologyEnginePoolEngine : public Loggable
{
  friend class SEPhysiologyEnginePool;
  friend class PhysiologyEnginePoolThunk;
protected:
  SEPhysiologyEnginePoolEngine(Logger* logger = nullptr);
 
public:
  ~SEPhysiologyEnginePoolEngine();
 
  bool                              IsActive=false;
  SEEngineInitialization            EngineInitialization;
  std::vector<const SEAction*>      Actions;
  SEDataRequested                   DataRequested;
  std::unique_ptr<PhysiologyEngine> Engine;
};
 
class CDM_DECL SEPhysiologyEnginePool : public Loggable
{
  friend class PhysiologyEnginePoolThunk;
public:
  SEPhysiologyEnginePool(size_t poolSize = 0, const std::string& dataDir="./", Logger* logger = nullptr);
  ~SEPhysiologyEnginePool();
 
  const size_t GetWorkerCount() const { return m_Pool.workerCount(); }
 
  bool RemoveEngine(int id);
  const std::map<int, SEPhysiologyEnginePoolEngine*>& GetEngines() const;
  SEPhysiologyEnginePoolEngine* GetEngine(int id) const;
  SEPhysiologyEnginePoolEngine* CreateEngine(int id);
 
  bool InitializeEngines();
 
  // Advance all engines the same amount of time
  // If you want to advance individual engines/different times
  // Add an SEAdvanceTime action to the SEPhysiologyEnginePoolEngine Actions vector
  bool AdvanceModelTime(double time, const TimeUnit& unit);
 
  // Process the same action on all engines
  bool ProcessAction(const SEAction& action);
 
  // Process all the actions on each engine pool engine
  bool ProcessActions();
 
  void ClearDataRequested();// Call to clear out log/events after you PullData and examine it
                            // If not, the vector of events/logs can get large...
  void PullDataRequested(std::vector<SEDataRequested*>&);
 
protected:
  virtual void AllocateEngine(SEPhysiologyEnginePoolEngine& pe) = 0;
 
  bool m_IsActive;
  SESubstanceManager m_SubMgr;
  std::map<int, SEPhysiologyEnginePoolEngine*> m_Engines;
  ThreadPool m_Pool;
};
 
class CDM_DECL PhysiologyEnginePoolThunk
{
public:
  PhysiologyEnginePoolThunk(size_t poolSize = 0, const std::string& dataDir="./");
  virtual ~PhysiologyEnginePoolThunk();
 
  bool InitializeEngines(std::string const& engineInitializationList, eSerializationFormat format);
 
  bool RemoveEngine(int id);
 
  bool ProcessActions(std::string const& actions, eSerializationFormat format);
 
  std::string PullRequestedData(eSerializationFormat format);
 
private:
  class pimpl;
  pimpl* data;
};