X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/49b53eb334bc6f19b530603201d00bcc312bfd29..59251ff676c562b79573e3561166e4351e4ad11e:/src/s4u/s4u_Host.cpp

diff --git a/src/s4u/s4u_Host.cpp b/src/s4u/s4u_Host.cpp
index fdaf2cad78..7437ff74dd 100644
--- a/src/s4u/s4u_Host.cpp
+++ b/src/s4u/s4u_Host.cpp
@@ -3,19 +3,19 @@
 /* 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. */
 
-#include "simgrid/Exception.hpp"
-#include "simgrid/host.h"
-#include "simgrid/kernel/routing/NetPoint.hpp"
-#include "simgrid/s4u/Actor.hpp"
-#include "simgrid/s4u/Comm.hpp"
-#include "simgrid/s4u/Engine.hpp"
-#include "simgrid/s4u/Exec.hpp"
-#include "simgrid/s4u/VirtualMachine.hpp"
+#include <simgrid/Exception.hpp>
+#include <simgrid/host.h>
+#include <simgrid/kernel/routing/NetPoint.hpp>
+#include <simgrid/s4u/Comm.hpp>
+#include <simgrid/s4u/Engine.hpp>
+#include <simgrid/s4u/Exec.hpp>
+#include <simgrid/s4u/Host.hpp>
+#include <simgrid/s4u/VirtualMachine.hpp>
+#include <xbt/parse_units.hpp>
+
 #include "src/plugins/vm/VirtualMachineImpl.hpp"
 #include "src/surf/HostImpl.hpp"
-#include "xbt/parse_units.hpp"
 
-#include <algorithm>
 #include <string>
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(s4u_host, s4u, "Logging specific to the S4U hosts");
@@ -32,6 +32,13 @@ xbt::signal<void(Host const&)> Host::on_destruction;
 xbt::signal<void(Host const&)> Host::on_state_change;
 xbt::signal<void(Host const&)> Host::on_speed_change;
 
+Host* Host::set_cpu(kernel::resource::CpuImpl* cpu)
+{
+  pimpl_cpu_ = cpu;
+  return this;
+}
+
+#ifndef DOXYGEN
 Host* Host::set_netpoint(kernel::routing::NetPoint* netpoint)
 {
   pimpl_netpoint_ = netpoint;
@@ -42,8 +49,9 @@ Host::~Host()
 {
   if (pimpl_netpoint_ != nullptr) // not removed yet by a children class
     Engine::get_instance()->netpoint_unregister(pimpl_netpoint_);
-  delete pimpl_cpu;
+  delete pimpl_cpu_;
 }
+#endif
 
 /** @brief Fire the required callbacks and destroy the object
  *
@@ -87,7 +95,7 @@ void Host::turn_on()
 {
   if (not is_on()) {
     kernel::actor::simcall([this] {
-      this->pimpl_cpu->turn_on();
+      this->pimpl_cpu_->turn_on();
       this->pimpl_->turn_on();
       on_state_change(*this);
     });
@@ -105,7 +113,7 @@ void Host::turn_off()
           vm->shutdown();
           vm->turn_off();
         }
-      this->pimpl_cpu->turn_off();
+      this->pimpl_cpu_->turn_off();
       this->pimpl_->turn_off(self);
 
       on_state_change(*this);
@@ -115,12 +123,12 @@ void Host::turn_off()
 
 bool Host::is_on() const
 {
-  return this->pimpl_cpu->is_on();
+  return this->pimpl_cpu_->is_on();
 }
 
-int Host::get_pstate_count() const
+unsigned long Host::get_pstate_count() const
 {
-  return this->pimpl_cpu->get_pstate_count();
+  return this->pimpl_cpu_->get_pstate_count();
 }
 
 /**
@@ -134,7 +142,7 @@ std::vector<ActorPtr> Host::get_all_actors() const
 }
 
 /** @brief Returns how many actors (daemonized or not) have been launched on this host */
-int Host::get_actor_count() const
+size_t Host::get_actor_count() const
 {
   return pimpl_->get_actor_count();
 }
@@ -146,7 +154,6 @@ int Host::get_actor_count() const
  * @param links [OUT] where to store the list of links (must exist, cannot be nullptr).
  * @param latency [OUT] where to store the latency experienced on the path (or nullptr if not interested)
  *                It is the caller responsibility to initialize latency to 0 (we add to provided route)
- * @pre links!=nullptr
  *
  * walk through the routing components tree and find a route between hosts
  * by calling each "get_route" function in each routing component.
@@ -172,25 +179,27 @@ void Host::route_to(const Host* dest, std::vector<kernel::resource::LinkImpl*>&
 }
 
 /** @brief Returns the networking zone englobing that host */
-NetZone* Host::get_englobing_zone()
+NetZone* Host::get_englobing_zone() const
 {
   return pimpl_netpoint_->get_englobing_zone()->get_iface();
 }
 
-void Host::sendto(Host* dest, double byte_amount) // deprecated 331
+#ifndef DOXYGEN
+void Host::sendto(Host* dest, double byte_amount) // XBT_ATTRIB_DEPRECATED_v331
 {
   Comm::sendto_async(this, dest, byte_amount)->wait();
 }
 
-CommPtr Host::sendto_async(Host* dest, double byte_amount) // deprecated 331
+CommPtr Host::sendto_async(Host* dest, double byte_amount) // XBT_ATTRIB_DEPRECATED_v331
 {
   return Comm::sendto_async(this, dest, byte_amount);
 }
 
-void Host::send_to(Host* dest, double byte_amount) // deprecated 330
+void Host::send_to(Host* dest, double byte_amount) // XBT_ATTRIB_DEPRECATED_v330
 {
   Comm::sendto(this, dest, byte_amount);
 }
+#endif
 
 /** Get the properties assigned to a host */
 const std::unordered_map<std::string, std::string>* Host::get_properties() const
@@ -220,7 +229,7 @@ Host* Host::set_properties(const std::unordered_map<std::string, std::string>& p
  * The profile must contain boolean values. */
 Host* Host::set_state_profile(kernel::profile::Profile* p)
 {
-  kernel::actor::simcall([this, p] { pimpl_cpu->set_state_profile(p); });
+  kernel::actor::simcall([this, p] { pimpl_cpu_->set_state_profile(p); });
   return this;
 }
 /** Specify a profile modeling the external load according to an exhaustive list or a stochastic law.
@@ -231,43 +240,54 @@ Host* Host::set_state_profile(kernel::profile::Profile* p)
  */
 Host* Host::set_speed_profile(kernel::profile::Profile* p)
 {
-  kernel::actor::simcall([this, p] { pimpl_cpu->set_speed_profile(p); });
+  kernel::actor::simcall([this, p] { pimpl_cpu_->set_speed_profile(p); });
   return this;
 }
 
 /** @brief Get the peak processor speed (in flops/s), at the specified pstate  */
-double Host::get_pstate_speed(int pstate_index) const
+double Host::get_pstate_speed(unsigned long pstate_index) const
 {
-  return this->pimpl_cpu->get_pstate_peak_speed(pstate_index);
+  return this->pimpl_cpu_->get_pstate_peak_speed(pstate_index);
 }
 
 double Host::get_speed() const
 {
-  return this->pimpl_cpu->get_speed(1.0);
+  return this->pimpl_cpu_->get_speed(1.0);
 }
 double Host::get_load() const
 {
-  return this->pimpl_cpu->get_load();
+  return this->pimpl_cpu_->get_load();
 }
 double Host::get_available_speed() const
 {
-  return this->pimpl_cpu->get_speed_ratio();
+  return this->pimpl_cpu_->get_speed_ratio();
+}
+
+Host* Host::set_sharing_policy(SharingPolicy policy, const s4u::NonLinearResourceCb& cb)
+{
+  kernel::actor::simcall([this, policy, &cb] { pimpl_cpu_->set_sharing_policy(policy, cb); });
+  return this;
+}
+
+Host::SharingPolicy Host::get_sharing_policy() const
+{
+  return this->pimpl_cpu_->get_sharing_policy();
 }
 
 int Host::get_core_count() const
 {
-  return this->pimpl_cpu->get_core_count();
+  return this->pimpl_cpu_->get_core_count();
 }
 
 Host* Host::set_core_count(int core_count)
 {
-  kernel::actor::simcall([this, core_count] { this->pimpl_cpu->set_core_count(core_count); });
+  kernel::actor::simcall([this, core_count] { this->pimpl_cpu_->set_core_count(core_count); });
   return this;
 }
 
 Host* Host::set_pstate_speed(const std::vector<double>& speed_per_state)
 {
-  kernel::actor::simcall([this, &speed_per_state] { pimpl_cpu->set_pstate_speed(speed_per_state); });
+  kernel::actor::simcall([this, &speed_per_state] { pimpl_cpu_->set_pstate_speed(speed_per_state); });
   return this;
 }
 
@@ -277,10 +297,10 @@ std::vector<double> Host::convert_pstate_speed_vector(const std::vector<std::str
   speed_list.reserve(speed_per_state.size());
   for (const auto& speed_str : speed_per_state) {
     try {
-      double speed = xbt_parse_get_speed("", 0, speed_str.c_str(), nullptr, "");
+      double speed = xbt_parse_get_speed("", 0, speed_str, "");
       speed_list.push_back(speed);
     } catch (const simgrid::ParseError&) {
-      xbt_die("Host: Impossible to set_pstate_speed, invalid speed %s", speed_str.c_str());
+      throw std::invalid_argument(std::string("Invalid speed value: ") + speed_str);
     }
   }
   return speed_list;
@@ -293,18 +313,30 @@ Host* Host::set_pstate_speed(const std::vector<std::string>& speed_per_state)
 }
 
 /** @brief Set the pstate at which the host should run */
-Host* Host::set_pstate(int pstate_index)
+Host* Host::set_pstate(unsigned long pstate_index)
 {
-  kernel::actor::simcall([this, pstate_index] { this->pimpl_cpu->set_pstate(pstate_index); });
+  kernel::actor::simcall([this, pstate_index] { this->pimpl_cpu_->set_pstate(pstate_index); });
   return this;
 }
 
 /** @brief Retrieve the pstate at which the host is currently running */
-int Host::get_pstate() const
+unsigned long Host::get_pstate() const
+{
+  return this->pimpl_cpu_->get_pstate();
+}
+
+Host* Host::set_factor_cb(const std::function<CpuFactorCb>& cb)
 {
-  return this->pimpl_cpu->get_pstate();
+  kernel::actor::simcall([this, &cb] { pimpl_cpu_->set_factor_cb(cb); });
+  return this;
 }
 
+Host* Host::set_coordinates(const std::string& coords)
+{
+  if (not coords.empty())
+    kernel::actor::simcall([this, coords] { this->pimpl_netpoint_->set_coordinates(coords); });
+  return this;
+}
 std::vector<Disk*> Host::get_disks() const
 {
   return this->pimpl_->get_disks();
@@ -312,9 +344,30 @@ std::vector<Disk*> Host::get_disks() const
 
 Disk* Host::create_disk(const std::string& name, double read_bandwidth, double write_bandwidth)
 {
-  auto disk =
-      this->get_netpoint()->get_englobing_zone()->get_disk_model()->create_disk(name, read_bandwidth, write_bandwidth);
-  return disk->set_host(this)->get_iface();
+  return kernel::actor::simcall([this, &name, read_bandwidth, write_bandwidth] {
+    auto* disk = pimpl_->create_disk(name, read_bandwidth, write_bandwidth);
+    pimpl_->add_disk(disk);
+    return disk;
+  });
+}
+
+Disk* Host::create_disk(const std::string& name, const std::string& read_bandwidth, const std::string& write_bandwidth)
+{
+  double d_read;
+  try {
+    d_read = xbt_parse_get_bandwidth("", 0, read_bandwidth, "");
+  } catch (const simgrid::ParseError&) {
+    throw std::invalid_argument(std::string("Impossible to create disk: ") + name +
+                                std::string(". Invalid read bandwidth: ") + read_bandwidth);
+  }
+  double d_write;
+  try {
+    d_write = xbt_parse_get_bandwidth("", 0, write_bandwidth, "");
+  } catch (const simgrid::ParseError&) {
+    throw std::invalid_argument(std::string("Impossible to create disk: ") + name +
+                                std::string(". Invalid write bandwidth: ") + write_bandwidth);
+  }
+  return create_disk(name, d_read, d_write);
 }
 
 void Host::add_disk(const Disk* disk)
@@ -347,10 +400,11 @@ void Host::execute(double flops, double priority) const
   this_actor::exec_init(flops)->set_priority(1 / priority)->vetoable_start()->wait();
 }
 
-void Host::seal()
+Host* Host::seal()
 {
-  kernel::actor::simcall([this]() { this->pimpl_cpu->seal(); });
   kernel::actor::simcall([this]() { this->pimpl_->seal(); });
+  simgrid::s4u::Host::on_creation(*this); // notify the signal
+  return this;
 }
 
 } // namespace s4u
@@ -369,7 +423,7 @@ sg_host_t* sg_host_list()
   xbt_assert(host_count > 0, "There is no host!");
   std::vector<simgrid::s4u::Host*> hosts = e->get_all_hosts();
 
-  sg_host_t* res = xbt_new(sg_host_t, hosts.size());
+  auto* res = xbt_new(sg_host_t, hosts.size());
   std::copy(begin(hosts), end(hosts), res);
 
   return res;
@@ -452,13 +506,13 @@ double sg_host_speed(const_sg_host_t host) // XBT_ATTRIB_DEPRECATED_v330
   return sg_host_get_speed(host);
 }
 
-/** @brief Return the speed of the processor (in flop/s) at a given pstate. See also @ref plugin_energy.
+/** @brief Return the speed of the processor (in flop/s) at a given pstate. See also @ref plugin_host_energy.
  *
  * @param  host host to test
  * @param pstate_index pstate to test
  * @return Returns the processor speed associated with pstate_index
  */
-double sg_host_get_pstate_speed(const_sg_host_t host, int pstate_index)
+double sg_host_get_pstate_speed(const_sg_host_t host, unsigned long pstate_index)
 {
   return host->get_pstate_speed(pstate_index);
 }
@@ -481,26 +535,26 @@ double sg_host_get_available_speed(const_sg_host_t host)
 
 /** @brief Returns the number of power states for a host.
  *
- *  See also @ref plugin_energy.
+ *  See also @ref plugin_host_energy.
  */
-int sg_host_get_nb_pstates(const_sg_host_t host)
+unsigned long sg_host_get_nb_pstates(const_sg_host_t host)
 {
   return host->get_pstate_count();
 }
 
 /** @brief Gets the pstate at which that host currently runs.
  *
- *  See also @ref plugin_energy.
+ *  See also @ref plugin_host_energy.
  */
-int sg_host_get_pstate(const_sg_host_t host)
+unsigned long sg_host_get_pstate(const_sg_host_t host)
 {
   return host->get_pstate();
 }
 /** @brief Sets the pstate at which that host should run.
  *
- *  See also @ref plugin_energy.
+ *  See also @ref plugin_host_energy.
  */
-void sg_host_set_pstate(sg_host_t host, int pstate)
+void sg_host_set_pstate(sg_host_t host, unsigned long pstate)
 {
   host->set_pstate(pstate);
 }
@@ -509,7 +563,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() 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_host_energy
  * for more info on DVFS.
  */
 void sg_host_turn_on(sg_host_t host)
@@ -521,7 +575,7 @@ void sg_host_turn_on(sg_host_t host)
  *
  * @brief Stop the host if it is on
  *
- * See also #MSG_host_is_on() 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_host_energy
  * for more info on DVFS.
  */
 void sg_host_turn_off(sg_host_t host)
@@ -532,8 +586,8 @@ void sg_host_turn_off(sg_host_t host)
 /** @ingroup m_host_management
  * @brief Determine if a host is up and running.
  *
- * 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.
+ * See also #sg_host_turn_on() and #sg_host_turn_off() to switch the host ON and OFF and @ref plugin_host_energy for
+ * more info on DVFS.
  *
  * @param host host to test
  * @return Returns true if the host is up and running, and false if it's currently down