X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/a851f5dfed8bd7b708b0d5b426f95fc23c3a3a96..7d28d93b90eedd2a49da8b9b990296669e46d05c:/src/kernel/actor/ActorImpl.hpp

diff --git a/src/kernel/actor/ActorImpl.hpp b/src/kernel/actor/ActorImpl.hpp
index 9349f8f21d..71230189cd 100644
--- a/src/kernel/actor/ActorImpl.hpp
+++ b/src/kernel/actor/ActorImpl.hpp
@@ -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 */
@@ -37,7 +36,7 @@ public:
   ~ActorImpl();
 
   static ActorImpl* self();
-  double get_kill_time();
+  double get_kill_time() const;
   void set_kill_time(double kill_time);
   boost::intrusive::list_member_hook<> host_actor_list_hook;   /* simgrid::simix::Host::process_list */
   boost::intrusive::list_member_hook<> smx_destroy_list_hook;  /* simix_global->actors_to_destroy */
@@ -49,18 +48,16 @@ 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; }
-  bool is_daemon() { return daemon_; } /** Whether this actor has been daemonized */
-  bool has_to_auto_restart() { return auto_restart_; }
+  bool is_daemon() const { return daemon_; } /** Whether this actor has been daemonized */
+  bool has_to_auto_restart() const { return auto_restart_; }
   void set_auto_restart(bool autorestart) { auto_restart_ = autorestart; }
   void set_stacksize(unsigned stacksize) { stacksize_ = stacksize; }
-  unsigned get_stacksize() { return stacksize_; }
+  unsigned get_stacksize() const { return stacksize_; }
 
   std::unique_ptr<context::Context> context_; /* the context (uctx/raw/thread) that executes the user function */
 
@@ -68,22 +65,22 @@ public:
   bool finished_  = false;
   bool suspended_ = false;
 
-  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;
+  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_;
   /* 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;
+  simix::Timer* kill_timer_ = nullptr;
 
 private:
   /* Refcounting */
   std::atomic_int_fast32_t refcount_{0};
 
 public:
-  int get_refcount() { return refcount_; }
+  int get_refcount() const { return refcount_; }
   friend void intrusive_ptr_add_ref(ActorImpl* actor)
   {
     // This whole memory consistency semantic drives me nuts.
@@ -114,25 +111,26 @@ 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);
+  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, ActorImpl* parent_actor);
+                             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 void detach();
   void cleanup();
   void exit();
-  void kill(ActorImpl* actor);
-  void kill_all();
+  void kill(ActorImpl* actor) const;
+  void kill_all() const;
 
   void yield();
   void daemonize();
-  bool is_suspended() { return suspended_; }
+  bool is_suspended() const { return suspended_; }
   s4u::Actor* restart();
   void suspend();
   void resume();
@@ -191,9 +189,9 @@ public:
 };
 
 /* 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();
@@ -203,8 +201,4 @@ XBT_PUBLIC int get_maxpid();
 
 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