X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/8c4d4c169bacafe232f5af91236be37fcf45de35..dc6258583c78a558d0bfc6d317272810e1b278ac:/src/s4u/s4u_Host.cpp

diff --git a/src/s4u/s4u_Host.cpp b/src/s4u/s4u_Host.cpp
index c2e01693f4..a298510165 100644
--- a/src/s4u/s4u_Host.cpp
+++ b/src/s4u/s4u_Host.cpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2006-2019. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2006-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. */
@@ -18,9 +18,8 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(s4u_host, s4u, "Logging specific to the S4U host
 XBT_LOG_EXTERNAL_CATEGORY(surf_route);
 
 namespace simgrid {
-namespace xbt {
-template class Extendable<s4u::Host>;
-} // namespace xbt
+
+template class xbt::Extendable<s4u::Host>;
 
 namespace s4u {
 
@@ -51,7 +50,7 @@ Host::~Host()
  *
  * Don't delete directly a host, call h->destroy() instead.
  *
- * This is cumbersome but this is the simplest solution to ensure that the onDestruction() callback receives a valid
+ * This is cumbersome but this is the simplest solution to ensure that the on_destruction() callback receives a valid
  * object (because of the destructor order in a class hierarchy).
  */
 void Host::destroy()
@@ -75,7 +74,7 @@ Host* Host::by_name_or_null(const std::string& name)
 
 Host* Host::current()
 {
-  kernel::actor::ActorImpl* self = SIMIX_process_self();
+  kernel::actor::ActorImpl* self = kernel::actor::ActorImpl::self();
   if (self == nullptr)
     xbt_die("Cannot call Host::current() from the maestro context");
   return self->get_host();
@@ -96,7 +95,7 @@ void Host::turn_on()
 void Host::turn_off()
 {
   if (is_on()) {
-    kernel::actor::ActorImpl* self = SIMIX_process_self();
+    kernel::actor::ActorImpl* self = kernel::actor::ActorImpl::self();
     kernel::actor::simcall([this, self] {
       for (VirtualMachine* const& vm : vm::VirtualMachineImpl::allVms_)
         if (vm->get_pm() == this) {
@@ -126,13 +125,13 @@ int Host::get_pstate_count() const
  *
  * Daemons and regular actors are all mixed in this list.
  */
-std::vector<ActorPtr> Host::get_all_actors()
+std::vector<ActorPtr> Host::get_all_actors() const
 {
   return pimpl_->get_all_actors();
 }
 
 /** @brief Returns how many actors (daemonized or not) have been launched on this host */
-int Host::get_actor_count()
+int Host::get_actor_count() const
 {
   return pimpl_->get_actor_count();
 }
@@ -149,7 +148,7 @@ int Host::get_actor_count()
  * walk through the routing components tree and find a route between hosts
  * by calling each "get_route" function in each routing component.
  */
-void Host::route_to(Host* dest, std::vector<Link*>& links, double* latency)
+void Host::route_to(const Host* dest, std::vector<Link*>& links, double* latency) const
 {
   std::vector<kernel::resource::LinkImpl*> linkImpls;
   this->route_to(dest, linkImpls, latency);
@@ -158,7 +157,7 @@ void Host::route_to(Host* dest, std::vector<Link*>& links, double* latency)
 }
 
 /** @brief Just like Host::routeTo, but filling an array of link implementations */
-void Host::route_to(Host* dest, std::vector<kernel::resource::LinkImpl*>& links, double* latency)
+void Host::route_to(const Host* dest, std::vector<kernel::resource::LinkImpl*>& links, double* latency) const
 {
   kernel::routing::NetZoneImpl::get_global_route(pimpl_netpoint_, dest->get_netpoint(), links, latency);
   if (XBT_LOG_ISENABLED(surf_route, xbt_log_priority_debug)) {
@@ -228,44 +227,19 @@ double Host::get_pstate_speed(int pstate_index) const
   return this->pimpl_cpu->get_pstate_peak_speed(pstate_index);
 }
 
-/** @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 (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().
- *
- *  The host may have multiple cores, and your executions may be able to use more than a single core.
- *
- *  Finally, executions of priority 2 get twice the amount of flops than executions of priority 1.
- */
 double Host::get_speed() const
 {
   return this->pimpl_cpu->get_speed(1.0);
 }
-/** @brief Returns the current computation load (in flops per second)
- *
- * The external load (coming from an availability trace) is not taken in account.
- * You may also be interested in the load plugin.
- */
 double Host::get_load() const
 {
   return this->pimpl_cpu->get_load();
 }
-/** @brief Get the available speed ratio, between 0 and 1.
- *
- * This accounts for external load (see @ref simgrid::surf::Cpu::set_speed_profile()).
- */
 double Host::get_available_speed() const
 {
   return this->pimpl_cpu->get_speed_ratio();
 }
 
-/** @brief Returns the number of core of the processor. */
 int Host::get_core_count() const
 {
   return this->pimpl_cpu->get_core_count();
@@ -308,12 +282,9 @@ std::vector<const char*> Host::get_attached_storages() const
 
 std::unordered_map<std::string, Storage*> const& Host::get_mounted_storages()
 {
-  if (mounts_ == nullptr) {
-    mounts_ = new std::unordered_map<std::string, Storage*>();
-    for (auto const& m : this->pimpl_->storage_) {
-      mounts_->insert({m.first, m.second->get_iface()});
-    }
-  }
+  if (mounts_ == nullptr)
+    mounts_ = pimpl_->get_mounted_storages();
+
   return *mounts_;
 }
 
@@ -340,16 +311,6 @@ size_t sg_host_count()
 {
   return simgrid::s4u::Engine::get_instance()->get_host_count();
 }
-/** @brief Returns the host list
- *
- * Uses sg_host_count() to know the array size.
- *
- * @return an array of @ref sg_host_t containing all the hosts in the platform.
- * @remark The host order in this array is generally different from the
- * creation/declaration order in the XML platform (we use a hash table
- * internally).
- * @see sg_host_count()
- */
 sg_host_t* sg_host_list()
 {
   xbt_assert(sg_host_count() > 0, "There is no host!");
@@ -361,12 +322,12 @@ sg_host_t* sg_host_list()
   return res;
 }
 
-const char* sg_host_get_name(sg_host_t host)
+const char* sg_host_get_name(const_sg_host_t host)
 {
   return host->get_cname();
 }
 
-void* sg_host_extension_get(sg_host_t host, size_t ext)
+void* sg_host_extension_get(const_sg_host_t host, size_t ext)
 {
   return host->extension(ext);
 }
@@ -399,7 +360,7 @@ xbt_dynar_t sg_hosts_as_dynar()
 // ========= Layering madness ==============*
 
 // ========== User data Layer ==========
-void* sg_host_data(sg_host_t host)
+void* sg_host_data(const_sg_host_t host)
 {
   return host->get_data();
 }
@@ -427,14 +388,14 @@ xbt_dict_t sg_host_get_mounted_storage_list(sg_host_t host)
   xbt_dict_t res = xbt_dict_new_homogeneous(nullptr);
   for (auto const& elm : host->get_mounted_storages()) {
     const char* mount_name = elm.first.c_str();
-    sg_storage_t storage   = elm.second;
+    const simgrid::s4u::Storage* storage = elm.second;
     xbt_dict_set(res, mount_name, (void*)storage->get_cname());
   }
 
   return res;
 }
 
-xbt_dynar_t sg_host_get_attached_storage_list(sg_host_t host)
+xbt_dynar_t sg_host_get_attached_storage_list(const_sg_host_t host)
 {
   xbt_dynar_t storage_dynar               = xbt_dynar_new(sizeof(const char*), nullptr);
   std::vector<const char*> storage_vector = host->get_attached_storages();
@@ -446,7 +407,7 @@ xbt_dynar_t sg_host_get_attached_storage_list(sg_host_t host)
 // =========== user-level functions ===============
 // ================================================
 /** @brief Returns the total speed of a host */
-double sg_host_speed(sg_host_t host)
+double sg_host_speed(const_sg_host_t host)
 {
   return host->get_speed();
 }
@@ -457,7 +418,7 @@ double sg_host_speed(sg_host_t host)
  * @param pstate_index pstate to test
  * @return Returns the processor speed associated with pstate_index
  */
-double sg_host_get_pstate_speed(sg_host_t host, int pstate_index)
+double sg_host_get_pstate_speed(const_sg_host_t host, int pstate_index)
 {
   return host->get_pstate_speed(pstate_index);
 }
@@ -468,12 +429,12 @@ double sg_host_get_pstate_speed(sg_host_t host, int pstate_index)
  * @param host a host
  * @return the number of cores
  */
-int sg_host_core_count(sg_host_t host)
+int sg_host_core_count(const_sg_host_t host)
 {
   return host->get_core_count();
 }
 
-double sg_host_get_available_speed(sg_host_t host)
+double sg_host_get_available_speed(const_sg_host_t host)
 {
   return host->get_available_speed();
 }
@@ -482,7 +443,7 @@ double sg_host_get_available_speed(sg_host_t host)
  *
  *  See also @ref plugin_energy.
  */
-int sg_host_get_nb_pstates(sg_host_t host)
+int sg_host_get_nb_pstates(const_sg_host_t host)
 {
   return host->get_pstate_count();
 }
@@ -491,7 +452,7 @@ int sg_host_get_nb_pstates(sg_host_t host)
  *
  *  See also @ref plugin_energy.
  */
-int sg_host_get_pstate(sg_host_t host)
+int sg_host_get_pstate(const_sg_host_t host)
 {
   return host->get_pstate();
 }
@@ -537,13 +498,13 @@ void sg_host_turn_off(sg_host_t host)
  * @param host host to test
  * @return Returns true if the host is up and running, and false if it's currently down
  */
-int sg_host_is_on(sg_host_t host)
+int sg_host_is_on(const_sg_host_t host)
 {
   return host->is_on();
 }
 
 /** @brief Get the properties of a host */
-xbt_dict_t sg_host_get_properties(sg_host_t host)
+xbt_dict_t sg_host_get_properties(const_sg_host_t host)
 {
   xbt_dict_t as_dict = xbt_dict_new_homogeneous(xbt_free_f);
   const std::unordered_map<std::string, std::string>* props = host->get_properties();
@@ -562,7 +523,7 @@ xbt_dict_t sg_host_get_properties(sg_host_t host)
  * @param name a property name
  * @return value of a property (or nullptr if property not set)
  */
-const char* sg_host_get_property_value(sg_host_t host, const char* name)
+const char* sg_host_get_property_value(const_sg_host_t host, const char* name)
 {
   return host->get_property(name);
 }
@@ -579,7 +540,7 @@ void sg_host_set_property_value(sg_host_t host, const char* name, const char* va
  * @param to where to
  * @param links [OUT] where to store the list of links (must exist, cannot be nullptr).
  */
-void sg_host_route(sg_host_t from, sg_host_t to, xbt_dynar_t links)
+void sg_host_route(const_sg_host_t from, const_sg_host_t to, xbt_dynar_t links)
 {
   std::vector<simgrid::s4u::Link*> vlinks;
   from->route_to(to, vlinks, nullptr);
@@ -592,7 +553,7 @@ void sg_host_route(sg_host_t from, sg_host_t to, xbt_dynar_t links)
  * @param from where from
  * @param to where to
  */
-double sg_host_route_latency(sg_host_t from, sg_host_t to)
+double sg_host_route_latency(const_sg_host_t from, const_sg_host_t to)
 {
   std::vector<simgrid::s4u::Link*> vlinks;
   double res = 0;
@@ -605,7 +566,7 @@ double sg_host_route_latency(sg_host_t from, sg_host_t to)
  * @param from where from
  * @param to where to
  */
-double sg_host_route_bandwidth(sg_host_t from, sg_host_t to)
+double sg_host_route_bandwidth(const_sg_host_t from, const_sg_host_t to)
 {
   double min_bandwidth = -1.0;
 
@@ -625,7 +586,7 @@ void sg_host_send_to(sg_host_t from, sg_host_t to, double byte_amount)
 }
 
 /** @brief Displays debugging information about a host */
-void sg_host_dump(sg_host_t host)
+void sg_host_dump(const_sg_host_t host)
 {
   XBT_INFO("Displaying host %s", host->get_cname());
   XBT_INFO("  - speed: %.0f", host->get_speed());
@@ -645,25 +606,31 @@ void sg_host_dump(sg_host_t host)
  * @param host a host
  * @param whereto a dynar in which we should push actors living on that host
  */
-void sg_host_get_actor_list(sg_host_t host, xbt_dynar_t whereto)
+void sg_host_get_actor_list(const_sg_host_t host, xbt_dynar_t whereto)
 {
-  auto actors = host->get_all_actors();
-  for (auto& actor : actors)
+  auto const actors = host->get_all_actors();
+  for (auto const& actor : actors)
     xbt_dynar_push(whereto, &actor);
 }
 
 sg_host_t sg_host_self()
 {
-  return SIMIX_is_maestro() ? nullptr : SIMIX_process_self()->get_host();
+  return SIMIX_is_maestro() ? nullptr : simgrid::kernel::actor::ActorImpl::self()->get_host();
 }
 
 /* needs to be public and without simcall for exceptions and logging events */
 const char* sg_host_self_get_name()
 {
-  return SIMIX_is_maestro() ? "" : SIMIX_process_self()->get_host()->get_cname();
+  const char* res = "";
+  if (not SIMIX_is_maestro()) {
+    const simgrid::s4u::Host* host = simgrid::kernel::actor::ActorImpl::self()->get_host();
+    if (host != nullptr)
+      res = host->get_cname();
+  }
+  return res;
 }
 
-double sg_host_load(sg_host_t host)
+double sg_host_load(const_sg_host_t host)
 {
   return host->get_load();
 }