X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/66e4277badef8f22852720b79a78e1f091c3b679..ebc355d0c96552d0bc2aa301d90723490337bca3:/src/s4u/s4u_Host.cpp

diff --git a/src/s4u/s4u_Host.cpp b/src/s4u/s4u_Host.cpp
index 80000607cb..f17edf7f58 100644
--- a/src/s4u/s4u_Host.cpp
+++ b/src/s4u/s4u_Host.cpp
@@ -7,6 +7,7 @@
 #include "simgrid/s4u/Actor.hpp"
 #include "simgrid/s4u/Engine.hpp"
 #include "simgrid/s4u/Exec.hpp"
+#include "src/simix/smx_private.hpp"
 #include "src/surf/HostImpl.hpp"
 
 #include <string>
@@ -29,16 +30,16 @@ simgrid::xbt::signal<void(Host&)> Host::on_destruction;
 simgrid::xbt::signal<void(Host&)> Host::on_state_change;
 simgrid::xbt::signal<void(Host&)> Host::on_speed_change;
 
-Host::Host(std::string name) : name_(name)
+Host::Host(const std::string& name) : name_(name)
 {
-  xbt_assert(Host::by_name_or_null(name) == nullptr, "Refusing to create a second host named '%s'.", name.c_str());
-  Engine::get_instance()->host_register(std::string(name_), this);
+  xbt_assert(Host::by_name_or_null(name_) == nullptr, "Refusing to create a second host named '%s'.", get_cname());
+  Engine::get_instance()->host_register(name_, this);
   new simgrid::surf::HostImpl(this);
 }
 
 Host::~Host()
 {
-  xbt_assert(currentlyDestroying_, "Please call h->destroy() instead of manually deleting it.");
+  xbt_assert(currently_destroying_, "Please call h->destroy() instead of manually deleting it.");
 
   delete pimpl_;
   if (pimpl_netpoint != nullptr) // not removed yet by a children class
@@ -57,34 +58,34 @@ Host::~Host()
  */
 void Host::destroy()
 {
-  if (not currentlyDestroying_) {
-    currentlyDestroying_ = true;
+  if (not currently_destroying_) {
+    currently_destroying_ = true;
     on_destruction(*this);
     Engine::get_instance()->host_unregister(std::string(name_));
     delete this;
   }
 }
 
-Host* Host::by_name(std::string name)
+Host* Host::by_name(const std::string& name)
 {
   return Engine::get_instance()->host_by_name(name);
 }
-Host* Host::by_name_or_null(std::string name)
+Host* Host::by_name_or_null(const std::string& name)
 {
   return Engine::get_instance()->host_by_name_or_null(name);
 }
 
 Host* Host::current()
 {
-  smx_actor_t smx_proc = SIMIX_process_self();
-  if (smx_proc == nullptr)
+  smx_actor_t self = SIMIX_process_self();
+  if (self == nullptr)
     xbt_die("Cannot call Host::current() from the maestro context");
-  return smx_proc->host_;
+  return self->get_host();
 }
 
 void Host::turn_on()
 {
-  if (is_off()) {
+  if (not is_on()) {
     simgrid::simix::simcall([this] {
       this->pimpl_cpu->turn_on();
       this->pimpl_->turn_on();
@@ -187,14 +188,30 @@ std::unordered_map<std::string, std::string>* Host::get_properties()
 }
 
 /** Retrieve the property value (or nullptr if not set) */
-const char* Host::get_property(std::string key) const
+const char* Host::get_property(const std::string& key) const
 {
   return this->pimpl_->get_property(key);
 }
 
-void Host::set_property(std::string key, std::string value)
+void Host::set_property(const std::string& key, const std::string& value)
 {
-  simgrid::simix::simcall([this, key, value] { this->pimpl_->set_property(key, value); });
+  simgrid::simix::simcall([this, &key, &value] { this->pimpl_->set_property(key, value); });
+}
+/** Specify a profile turning the host on and off according to a exhaustive list or a stochastic law.
+ * The profile must contain boolean values. */
+void Host::set_state_profile(kernel::profile::Profile* p)
+{
+  return simgrid::simix::simcall([this, p] { pimpl_cpu->set_state_profile(p); });
+}
+/** Specify a profile modeling the external load according to a exhaustive list or a stochastic law.
+ *
+ * Each event of the profile represent a peak speed change that is due to external load. The values are given as a rate
+ * of the initial value. This means that the actual value is obtained by multiplying the initial value (the peek speed
+ * at this pstate level) by the rate coming from the profile.
+ */
+void Host::set_speed_profile(kernel::profile::Profile* p)
+{
+  return simgrid::simix::simcall([this, p] { pimpl_cpu->set_speed_profile(p); });
 }
 
 /** @brief Get the peak processor speed (in flops/s), at the specified pstate  */
@@ -203,13 +220,13 @@ double Host::get_pstate_speed(int pstate_index) const
   return simgrid::simix::simcall([this, pstate_index] { return this->pimpl_cpu->get_pstate_peak_speed(pstate_index); });
 }
 
-/** @brief Get the peak computing speed in flops/s at the current pstate, taking the external load into account.
+/** @brief Get the peak computing speed in flops/s at the current pstate, NOT taking the external load into account.
  *
  *  The amount of flops per second available for computing depends on several things:
  *    - The current pstate determines the maximal peak computing speed (use @ref get_pstate_speed() to retrieve the
  *      computing speed you would get at another pstate)
- *    - If you declared an external load, then this reduces the available computing speed
- *      (see @ref simgrid::surf::Cpu::set_speed_trace())
+ *    - If you declared an external load (with @ref simgrid::surf::Cpu::set_speed_profile()), you must multiply the
+ * result of get_speed() by get_available_speed() to retrieve what a new computation would get.
  *
  *  The remaining speed is then shared between the executions located on this host.
  *  You can retrieve the amount of tasks currently running on this host with @ref get_load().
@@ -233,7 +250,7 @@ double Host::get_load() const
 }
 /** @brief Get the available speed ratio, between 0 and 1.
  *
- * This accounts for external load (see @ref simgrid::surf::Cpu::set_speed_trace()).
+ * This accounts for external load (see @ref simgrid::surf::Cpu::set_speed_profile()).
  */
 double Host::get_available_speed() const
 {
@@ -288,7 +305,7 @@ std::unordered_map<std::string, Storage*> const& Host::get_mounted_storages()
 
 ExecPtr Host::exec_async(double flops)
 {
-  return this_actor::exec_init(flops)->set_host(this);
+  return this_actor::exec_init(flops);
 }
 
 void Host::execute(double flops)
@@ -298,7 +315,7 @@ void Host::execute(double flops)
 
 void Host::execute(double flops, double priority)
 {
-  this_actor::exec_init(flops)->set_host(this)->set_priority(1 / priority)->start()->wait();
+  this_actor::exec_init(flops)->set_priority(1 / priority)->start()->wait();
 }
 
 } // namespace s4u
@@ -350,12 +367,6 @@ sg_host_t sg_host_by_name(const char* name)
   return simgrid::s4u::Host::by_name_or_null(name);
 }
 
-static int hostcmp_voidp(const void* pa, const void* pb)
-{
-  return strcmp((*static_cast<simgrid::s4u::Host* const*>(pa))->get_cname(),
-                (*static_cast<simgrid::s4u::Host* const*>(pb))->get_cname());
-}
-
 xbt_dynar_t sg_hosts_as_dynar()
 {
   xbt_dynar_t res = xbt_dynar_new(sizeof(sg_host_t), nullptr);
@@ -366,7 +377,11 @@ xbt_dynar_t sg_hosts_as_dynar()
     if (host && host->pimpl_netpoint && host->pimpl_netpoint->is_host())
       xbt_dynar_push(res, &host);
   }
-  xbt_dynar_sort(res, hostcmp_voidp);
+  xbt_dynar_sort(res, [](const void* pa, const void* pb) {
+    const std::string& na = (*static_cast<simgrid::s4u::Host* const*>(pa))->get_name();
+    const std::string& nb = (*static_cast<simgrid::s4u::Host* const*>(pb))->get_name();
+    return na.compare(nb);
+  });
   return res;
 }
 
@@ -474,7 +489,7 @@ void sg_host_set_pstate(sg_host_t host, int pstate)
  *
  * @brief Start the host if it is off
  *
- * See also #sg_host_is_on() and #sg_host_is_off() to test the current state of the host and @ref plugin_energy
+ * See also #sg_host_is_on() to test the current state of the host and @ref plugin_energy
  * for more info on DVFS.
  */
 void sg_host_turn_on(sg_host_t host)
@@ -486,7 +501,7 @@ void sg_host_turn_on(sg_host_t host)
  *
  * @brief Stop the host if it is on
  *
- * See also #MSG_host_is_on() and #MSG_host_is_off() to test the current state of the host and @ref plugin_energy
+ * See also #MSG_host_is_on() to test the current state of the host and @ref plugin_energy
  * for more info on DVFS.
  */
 void sg_host_turn_off(sg_host_t host)
@@ -508,15 +523,10 @@ int sg_host_is_on(sg_host_t host)
   return host->is_on();
 }
 
-/** @ingroup m_host_management
- * @brief Determine if a host is currently off.
- *
- * See also #sg_host_turn_on() and #sg_host_turn_off() to switch the host ON and OFF and @ref plugin_energy for more
- * info on DVFS.
- */
+/** @deprecated */
 int sg_host_is_off(sg_host_t host)
 {
-  return host->is_off();
+  return not host->is_on();
 }
 
 /** @brief Get the properties of a host */
@@ -627,7 +637,17 @@ void sg_host_get_actor_list(sg_host_t host, xbt_dynar_t whereto)
 sg_host_t sg_host_self()
 {
   smx_actor_t process = SIMIX_process_self();
-  return (process == nullptr) ? nullptr : process->host_;
+  return (process == nullptr) ? nullptr : process->get_host();
+}
+
+/* needs to be public and without simcall for exceptions and logging events */
+const char* sg_host_self_get_name()
+{
+  sg_host_t host = sg_host_self();
+  if (host == nullptr || SIMIX_process_self() == simix_global->maestro_process)
+    return "";
+
+  return host->get_cname();
 }
 
 double sg_host_load(sg_host_t host)