move kernel timers from simix:: to kernel::timer::

[simgrid.git] / src / kernel / actor / ActorImpl.hpp

diff --git a/src/kernel/actor/ActorImpl.hpp b/src/kernel/actor/ActorImpl.hpp
index e32d7c766b3c0126e235603112c511820b307fb2..85cdf80db13c4e7101ff569b4fe3de6b7a90a0b9 100644 (file)
--- a/src/kernel/actor/ActorImpl.hpp
+++ b/src/kernel/actor/ActorImpl.hpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2007-2020. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2007-2021. The SimGrid Team. All rights reserved.          */
 
 /* This program is free software; you can redistribute it and/or modify it
  * under the terms of the license (GNU LGPL) which comes with this package. */
@@ -6,6 +6,7 @@
 #ifndef SIMGRID_KERNEL_ACTOR_ACTORIMPL_HPP
 #define SIMGRID_KERNEL_ACTOR_ACTORIMPL_HPP
 
+#include "simgrid/kernel/Timer.hpp"
 #include "simgrid/s4u/Actor.hpp"
 #include "src/simix/popping_private.hpp"
 #include "xbt/PropertyHolder.hpp"
@@ -35,6 +36,9 @@ public:
   ActorImpl& operator=(const ActorImpl&) = delete;
   ~ActorImpl();
 
+  /** Retrieve the actor implementation from its PID (or nullptr if non-existent) */
+  static ActorImpl* by_pid(aid_t pid);
+
   static ActorImpl* self();
   double get_kill_time() const;
   void set_kill_time(double kill_time);
@@ -68,12 +72,13 @@ public:
   activity::ActivityImplPtr waiting_synchro_ = nullptr; /* the current blocking synchro if any */
   std::list<activity::ActivityImplPtr> activities_;     /* the current non-blocking synchros */
   s_smx_simcall simcall_;
+  std::vector<SimcallObserver*> observer_stack_;
   /* 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_;
-  simix::Timer* kill_timer_ = nullptr;
+  timer::Timer* kill_timer_ = nullptr;
 
 private:
   /* Refcounting */
@@ -118,10 +123,8 @@ public:
   ActorImpl* start(const ActorCode& code);
 
   static ActorImplPtr create(const std::string& name, const ActorCode& code, void* data, s4u::Host* host,
-                             const std::unordered_map<std::string, std::string>* properties,
                              const ActorImpl* parent_actor);
-  static ActorImplPtr attach(const std::string& name, void* data, s4u::Host* host,
-                             const std::unordered_map<std::string, std::string>* properties);
+  static ActorImplPtr attach(const std::string& name, void* data, s4u::Host* host);
   static void detach();
   void cleanup();
   void exit();
@@ -153,16 +156,18 @@ public:
   void* data                                                               = nullptr;
   s4u::Host* host                                                          = nullptr;
   double kill_time                                                         = 0.0;
-  std::shared_ptr<const std::unordered_map<std::string, std::string>> properties = nullptr;
+  const std::unordered_map<std::string, std::string> properties{};
   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;
+  ProcessArg()                  = delete;
+  ProcessArg(const ProcessArg&) = delete;
+  ProcessArg& operator=(const ProcessArg&) = delete;
 
   explicit ProcessArg(const std::string& name, const std::function<void()>& code, void* data, s4u::Host* host,
-                      double kill_time, std::shared_ptr<std::unordered_map<std::string, std::string>> properties,
+                      double kill_time, const std::unordered_map<std::string, std::string>& properties,
                       bool auto_restart)
       : name(name)
       , code(code)
@@ -184,7 +189,6 @@ public:
       , daemon_(actor->is_daemon())
       , on_exit(actor->on_exit)
   {
-    properties.reset(actor->get_properties(), [](decltype(actor->get_properties())) {});
   }
 };
 
@@ -195,6 +199,8 @@ using SynchroList =
 
 XBT_PUBLIC void create_maestro(const std::function<void()>& code);
 XBT_PUBLIC unsigned long get_maxpid();
+XBT_PUBLIC unsigned long* get_maxpid_addr(); // In MC mode, the application sends this pointers to the MC
+
 } // namespace actor
 } // namespace kernel
 } // namespace simgrid