[sonar] Const for pointer and reference parameters (slight return).

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

diff --git a/src/kernel/actor/ActorImpl.hpp b/src/kernel/actor/ActorImpl.hpp
index c0883ae97d0416befb1483c9bb177b90169a2112..6e9691f35f7e267ef16254279302d80ae5e93338 100644 (file)
--- a/src/kernel/actor/ActorImpl.hpp
+++ b/src/kernel/actor/ActorImpl.hpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2007-2019. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2007-2020. 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. */
@@ -27,6 +27,7 @@ class XBT_PUBLIC ActorImpl : public xbt::PropertyHolder {
   aid_t ppid_        = -1;
   bool daemon_       = false; /* Daemon actors are automatically killed when the last non-daemon leaves */
   bool auto_restart_ = false;
+  unsigned stacksize_; // set to default value in constructor
 
 public:
   xbt::string name_;
@@ -36,7 +37,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 */
@@ -55,9 +56,11 @@ public:
   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() const { return stacksize_; }
 
   std::unique_ptr<context::Context> context_; /* the context (uctx/raw/thread) that executes the user function */
 
@@ -65,22 +68,22 @@ public:
   bool finished_  = false;
   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;
+  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.
@@ -107,32 +110,34 @@ public:
 private:
   s4u::Actor piface_; // Our interface is part of ourselves
 
+  void cleanup_from_simix();
   void undaemonize();
 
 public:
   s4u::ActorPtr iface() { return s4u::ActorPtr(&piface_); }
   s4u::Actor* ciface() { return &piface_; }
 
-  ActorImplPtr init(const std::string& name, s4u::Host* host);
-  ActorImpl* start(const simix::ActorCode& code);
+  ActorImplPtr init(const std::string& name, s4u::Host* host) const;
+  ActorImpl* start(const ActorCode& code);
 
-  static ActorImplPtr create(const std::string& name, const simix::ActorCode& code, void* data, s4u::Host* host,
-                             const std::unordered_map<std::string, std::string>* properties, ActorImpl* parent_actor);
+  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 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();
-  activity::ActivityImplPtr join(ActorImpl* actor, double timeout);
+  activity::ActivityImplPtr join(const ActorImpl* actor, double timeout);
   activity::ActivityImplPtr sleep(double duration);
   /** Ask the actor to throw an exception right away */
   void throw_exception(std::exception_ptr e);
@@ -199,4 +204,8 @@ 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