X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/1fd762bbcbc15aa4ffafe2d15df5cb650d1fa1ff..afa62e573131c8a346d4703b58037ee1ff80e69e:/src/kernel/actor/ActorImpl.hpp

diff --git a/src/kernel/actor/ActorImpl.hpp b/src/kernel/actor/ActorImpl.hpp
index cef9f09895..81a710a7a5 100644
--- a/src/kernel/actor/ActorImpl.hpp
+++ b/src/kernel/actor/ActorImpl.hpp
@@ -15,11 +15,6 @@
 #include <map>
 #include <memory>
 
-struct s_smx_process_exit_fun_t {
-  std::function<void(bool, void*)> fun;
-  void* arg;
-};
-
 namespace simgrid {
 namespace kernel {
 namespace actor {
@@ -64,15 +59,16 @@ public:
 
   std::exception_ptr exception_;
   bool finished_  = false;
-  bool blocked_   = false; /* FIXME this field is never set to true. Either use it or remove it. */
   bool suspended_ = false;
 
   activity::ActivityImplPtr waiting_synchro = nullptr; /* the current blocking synchro if any */
   std::list<activity::ActivityImplPtr> comms;          /* the current non-blocking communication synchros */
   s_smx_simcall simcall;
-  std::vector<s_smx_process_exit_fun_t> on_exit; /* list of functions executed when the process dies */
+  /* list of functions executed when the process dies */
+  std::shared_ptr<std::vector<std::function<void(bool)>>> on_exit =
+      std::make_shared<std::vector<std::function<void(bool)>>>();
 
-  std::function<void()> code;
+  std::function<void()> code_;
   simix::Timer* kill_timer = nullptr;
 
 private:
@@ -80,6 +76,7 @@ private:
   std::atomic_int_fast32_t refcount_{0};
 
 public:
+  int get_refcount() { return refcount_; }
   friend void intrusive_ptr_add_ref(ActorImpl* actor)
   {
     // std::memory_order_relaxed ought to be enough here instead of std::memory_order_seq_cst
@@ -102,6 +99,9 @@ public:
   /* S4U/implem interfaces */
 private:
   s4u::Actor piface_; // Our interface is part of ourselves
+
+  void undaemonize();
+
 public:
   s4u::ActorPtr iface() { return s4u::ActorPtr(&piface_); }
   s4u::Actor* ciface() { return &piface_; }
@@ -110,9 +110,9 @@ public:
   ActorImpl* start(const simix::ActorCode& code);
 
   static ActorImplPtr create(const std::string& name, const simix::ActorCode& code, void* data, s4u::Host* host,
-                             std::unordered_map<std::string, std::string>* properties, ActorImpl* parent_actor);
+                             const std::unordered_map<std::string, std::string>* properties, ActorImpl* parent_actor);
   static ActorImplPtr attach(const std::string& name, void* data, s4u::Host* host,
-                             std::unordered_map<std::string, std::string>* properties);
+                             const std::unordered_map<std::string, std::string>* properties);
   static void detach();
   void cleanup();
   void exit();
@@ -129,6 +129,12 @@ public:
   activity::ActivityImplPtr sleep(double duration);
   /** Ask the actor to throw an exception right away */
   void throw_exception(std::exception_ptr e);
+
+  /** execute the pending simcall -- must be called from the maestro context */
+  void simcall_handle(int value);
+  /** Terminates a simcall currently executed in maestro context. The actor will be restarted in the next scheduling
+   * round */
+  void simcall_answer();
 };
 
 class ProcessArg {
@@ -138,9 +144,12 @@ public:
   void* data                                                               = nullptr;
   s4u::Host* host                                                          = nullptr;
   double kill_time                                                         = 0.0;
-  std::shared_ptr<std::unordered_map<std::string, std::string>> properties = nullptr;
+  std::shared_ptr<const std::unordered_map<std::string, std::string>> properties = nullptr;
   bool auto_restart                                                        = false;
   bool daemon_                                                             = false;
+  /* list of functions executed when the process dies */
+  const std::shared_ptr<std::vector<std::function<void(bool)>>> on_exit;
+
   ProcessArg()                                                             = default;
 
   explicit ProcessArg(const std::string& name, const std::function<void()>& code, void* data, s4u::Host* host,
@@ -158,12 +167,13 @@ public:
 
   explicit ProcessArg(s4u::Host* host, ActorImpl* actor)
       : name(actor->get_name())
-      , code(actor->code)
+      , code(actor->code_)
       , data(actor->get_user_data())
       , host(host)
       , kill_time(actor->get_kill_time())
       , auto_restart(actor->has_to_auto_restart())
       , daemon_(actor->is_daemon())
+      , on_exit(actor->on_exit)
   {
     properties.reset(actor->get_properties(), [](decltype(actor->get_properties())) {});
   }
@@ -175,12 +185,11 @@ typedef boost::intrusive::list<ActorImpl, boost::intrusive::member_hook<ActorImp
     SynchroList;
 
 XBT_PUBLIC void create_maestro(const std::function<void()>& code);
+XBT_PUBLIC int get_maxpid();
 } // namespace actor
 } // namespace kernel
 } // namespace simgrid
 
 extern void (*SMPI_switch_data_segment)(simgrid::s4u::ActorPtr actor);
 
-XBT_PRIVATE void SIMIX_process_sleep_destroy(simgrid::kernel::activity::SleepImplPtr synchro);
-
 #endif