Inline function.

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

diff --git a/src/kernel/actor/ActorImpl.hpp b/src/kernel/actor/ActorImpl.hpp
index 6e9691f35f7e267ef16254279302d80ae5e93338..657d6ed3a7b975f2d4fd80cc71cdccb9d027877b 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. */
@@ -21,8 +21,7 @@ namespace actor {
 
 class XBT_PUBLIC ActorImpl : public xbt::PropertyHolder {
   s4u::Host* host_   = nullptr; /* the host on which the actor is running */
-  // XBT_DEPRECATED_v329
-  void* userdata_    = nullptr; /* kept for compatibility, it should be replaced with moddata */
+  void* userdata_    = nullptr; /* XBT_ATTRIB_DEPRECATED_v329 kept for compatibility, should be replaced with moddata */
   aid_t pid_         = 0;
   aid_t ppid_        = -1;
   bool daemon_       = false; /* Daemon actors are automatically killed when the last non-daemon leaves */
@@ -36,6 +35,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);
@@ -49,10 +51,8 @@ public:
   // Accessors to private fields
   s4u::Host* get_host() { return host_; }
   void set_host(s4u::Host* dest);
-  // XBT_DEPRECATED_v329
-  void* get_user_data() { return userdata_; }
-  // XBT_DEPRECATED_v329
-  void set_user_data(void* data) { userdata_ = data; }
+  void* get_user_data() { return userdata_; }          // XBT_ATTRIB_DEPRECATED_v329
+  void set_user_data(void* data) { userdata_ = data; } // XBT_ATTRIB_DEPRECATED_v329
   aid_t get_pid() const { return pid_; }
   aid_t get_ppid() const { return ppid_; }
   void set_ppid(aid_t ppid) { ppid_ = ppid; }
@@ -114,17 +114,15 @@ private:
   void undaemonize();
 
 public:
-  s4u::ActorPtr iface() { return s4u::ActorPtr(&piface_); }
-  s4u::Actor* ciface() { return &piface_; }
+  s4u::ActorPtr get_iface() { return s4u::ActorPtr(&piface_); }
+  s4u::Actor* get_ciface() { return &piface_; }
 
   ActorImplPtr init(const std::string& name, s4u::Host* host) const;
   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();
@@ -156,16 +154,16 @@ 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;
 
   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)
@@ -187,25 +185,22 @@ public:
       , daemon_(actor->is_daemon())
       , on_exit(actor->on_exit)
   {
-    properties.reset(actor->get_properties(), [](decltype(actor->get_properties())) {});
   }
 };
 
 /* Used to keep the list of actors blocked on a synchro  */
-typedef boost::intrusive::list<ActorImpl, boost::intrusive::member_hook<ActorImpl, boost::intrusive::list_member_hook<>,
-                                                                        &ActorImpl::smx_synchro_hook>>
-    SynchroList;
+using SynchroList =
+    boost::intrusive::list<ActorImpl, boost::intrusive::member_hook<ActorImpl, boost::intrusive::list_member_hook<>,
+                                                                    &ActorImpl::smx_synchro_hook>>;
 
 XBT_PUBLIC void create_maestro(const std::function<void()>& code);
-XBT_PUBLIC int get_maxpid();
+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
 
 extern void (*SMPI_switch_data_segment)(simgrid::s4u::ActorPtr actor);
 
-XBT_PUBLIC smx_actor_t simcall_process_create(const std::string& name, const simgrid::kernel::actor::ActorCode& code,
-                                              void* data, sg_host_t host,
-                                              std::unordered_map<std::string, std::string>* properties);
-
 #endif