Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
[s4u] Host snake_case
[simgrid.git] / src / surf / plugins / energy.cpp
index 75b43a2..bbbb065 100644 (file)
@@ -60,7 +60,7 @@ using simgrid::energy::HostEnergy;
 namespace simgrid {
 namespace energy {
 
-simgrid::xbt::Extension<simgrid::Host, HostEnergy> HostEnergy::EXTENSION_ID;
+simgrid::xbt::Extension<simgrid::s4u::Host, HostEnergy> HostEnergy::EXTENSION_ID;
 
 /* Computes the consumption so far.  Called lazily on need. */
 void HostEnergy::update()
@@ -83,7 +83,7 @@ void HostEnergy::update()
        double previous_energy = this->total_energy;
 
        double instantaneous_consumption;
-       if (host->isOff())
+       if (host->is_off())
                instantaneous_consumption = this->watts_off;
        else
                instantaneous_consumption = this->getCurrentWattsValue(cpu_load);
@@ -97,13 +97,14 @@ void HostEnergy::update()
            surf_host->getName(), start_time, finish_time, surf_host->p_cpu->m_speedPeak, previous_energy, energy_this_step);
 }
 
-HostEnergy::HostEnergy(simgrid::Host *ptr) :
+HostEnergy::HostEnergy(simgrid::s4u::Host *ptr) :
   host(ptr), last_updated(surf_get_clock())
 {
   initWattsRangeList();
 
-  if (host->getProperties() != NULL) {
-    char* off_power_str = (char*)xbt_dict_get_or_null(host->getProperties(), "watt_off");
+  if (host->properties() != NULL) {
+    char* off_power_str = (char*)xbt_dict_get_or_null(
+      host->properties(), "watt_off");
     if (off_power_str != NULL)
       watts_off = atof(off_power_str);
     else
@@ -114,25 +115,19 @@ HostEnergy::HostEnergy(simgrid::Host *ptr) :
 
 HostEnergy::~HostEnergy()
 {
-  // Ignore virtual machines
-  if (dynamic_cast<simgrid::surf::VirtualMachine*>(host->extension<simgrid::surf::Host>()))
-    return;
-  this->update();
-  XBT_INFO("Total energy of host %s: %f Joules",
-    host->getName().c_str(), this->getConsumedEnergy());
 }
 
 double HostEnergy::getWattMinAt(int pstate)
 {
   xbt_assert(!power_range_watts_list.empty(),
-    "No power range properties specified for host %s", host->getName().c_str());
+    "No power range properties specified for host %s", host->name().c_str());
   return power_range_watts_list[pstate].first;
 }
 
 double HostEnergy::getWattMaxAt(int pstate)
 {
   xbt_assert(!power_range_watts_list.empty(),
-    "No power range properties specified for host %s", host->getName().c_str());
+    "No power range properties specified for host %s", host->name().c_str());
   return power_range_watts_list[pstate].second;
 }
 
@@ -140,11 +135,11 @@ double HostEnergy::getWattMaxAt(int pstate)
 double HostEnergy::getCurrentWattsValue(double cpu_load)
 {
        xbt_assert(!power_range_watts_list.empty(),
-    "No power range properties specified for host %s", host->getName().c_str());
+    "No power range properties specified for host %s", host->name().c_str());
 
   /* min_power corresponds to the idle power (cpu load = 0) */
   /* max_power is the power consumed at 100% cpu load       */
-  auto range = power_range_watts_list.at(host->getPState());
+  auto range = power_range_watts_list.at(host->pstate());
   double min_power = range.first;
   double max_power = range.second;
   double power_slope = max_power - min_power;
@@ -158,17 +153,18 @@ double HostEnergy::getCurrentWattsValue(double cpu_load)
 
 double HostEnergy::getConsumedEnergy()
 {
-       if(last_updated < surf_get_clock())
-               this->update();
+       if (last_updated < surf_get_clock()) // We need to simcall this as it modifies the environment
+         simgrid::simix::kernel(std::bind(&HostEnergy::update, this));
+
        return total_energy;
 }
 
 void HostEnergy::initWattsRangeList()
 {
-       if (host->getProperties() == NULL)
+       if (host->properties() == NULL)
                return;
        char* all_power_values_str =
-    (char*)xbt_dict_get_or_null(host->getProperties(), "watt_per_state");
+    (char*)xbt_dict_get_or_null(host->properties(), "watt_per_state");
        if (all_power_values_str == NULL)
                return;
 
@@ -182,7 +178,7 @@ void HostEnergy::initWattsRangeList()
                xbt_assert(xbt_dynar_length(current_power_values) > 1,
                                "Power properties incorrectly defined - "
         "could not retrieve min and max power values for host %s",
-                               host->getName().c_str());
+                               host->name().c_str());
 
                /* min_power corresponds to the idle power (cpu load = 0) */
                /* max_power is the power consumed at 100% cpu load       */
@@ -194,34 +190,54 @@ void HostEnergy::initWattsRangeList()
        xbt_dynar_free(&all_power_values);
 }
 
-double surf_host_get_wattmin_at(sg_host_t host, int pstate)
-{
-  xbt_assert(HostEnergy::EXTENSION_ID.valid(),
-    "The Energy plugin is not active. "
-    "Please call sg_energy_plugin_init() during initialization.");
-  return host->extension<HostEnergy>()->getWattMinAt(pstate);
 }
-double surf_host_get_wattmax_at(sg_host_t host, int pstate)
-{
-  xbt_assert(HostEnergy::EXTENSION_ID.valid(),
-    "The Energy plugin is not active. "
-    "Please call sg_energy_plugin_init() during initialization.");
-  return host->extension<HostEnergy>()->getWattMaxAt(pstate);
 }
 
-double surf_host_get_consumed_energy(sg_host_t host)
-{
-  xbt_assert(HostEnergy::EXTENSION_ID.valid(),
-    "The Energy plugin is not active. "
-    "Please call sg_energy_plugin_init() during initialization.");
-  return host->extension<HostEnergy>()->getConsumedEnergy();
+/* **************************** events  callback *************************** */
+static void onCreation(simgrid::s4u::Host& host) {
+  simgrid::surf::Host* surf_host = host.extension<simgrid::surf::Host>();
+  if (dynamic_cast<simgrid::surf::VirtualMachine*>(surf_host)) // Ignore virtual machines
+    return;
+  host.extension_set(new HostEnergy(&host));
 }
 
+static void onActionStateChange(simgrid::surf::CpuAction *action,
+    e_surf_action_state_t old, e_surf_action_state_t cur) {
+  const char *name = getActionCpu(action)->getName();
+  simgrid::surf::Host *host = sg_host_by_name(name)->extension<simgrid::surf::Host>();
+  simgrid::surf::VirtualMachine *vm = dynamic_cast<simgrid::surf::VirtualMachine*>(host);
+  if (vm) // If it's a VM, take the corresponding PM
+    host = vm->getPm()->extension<simgrid::surf::Host>();
+
+  HostEnergy *host_energy = host->p_host->extension<HostEnergy>();
+
+  if(host_energy->last_updated < surf_get_clock())
+    host_energy->update();
 }
+
+static void onHostStateChange(simgrid::s4u::Host &host) {
+  simgrid::surf::Host* surf_host = host.extension<simgrid::surf::Host>();
+  if (dynamic_cast<simgrid::surf::VirtualMachine*>(surf_host)) // Ignore virtual machines
+    return;
+
+  HostEnergy *host_energy = host.extension<HostEnergy>();
+
+  if(host_energy->last_updated < surf_get_clock())
+    host_energy->update();
 }
 
-/* **************************** Public interface *************************** */
+static void onHostDestruction(simgrid::s4u::Host& host) {
+  // Ignore virtual machines
+  simgrid::surf::Host* surf_host = host.extension<simgrid::surf::Host>();
+  if (dynamic_cast<simgrid::surf::VirtualMachine*>(surf_host))
+    return;
+  HostEnergy *host_energy = host.extension<HostEnergy>();
+  host_energy->update();
+  XBT_INFO("Total energy of host %s: %f Joules",
+    host.name().c_str(), host_energy->getConsumedEnergy());
+}
 
+/* **************************** Public interface *************************** */
 /** \ingroup SURF_plugin_energy
  * \brief Enable energy plugin
  * \details Enable energy plugin to get joules consumption of each cpu. You should call this function before #MSG_init().
@@ -231,41 +247,12 @@ void sg_energy_plugin_init(void)
   if (HostEnergy::EXTENSION_ID.valid())
     return;
 
-  HostEnergy::EXTENSION_ID = simgrid::Host::extension_create<HostEnergy>();
-
-  /* The following attaches an anonymous function to the Host::onCreation signal */
-  /* Search for "C++ lambda" for more information on the syntax used here */
-  simgrid::surf::Host::onCreation.connect([](simgrid::surf::Host *host) {
-    if (dynamic_cast<simgrid::surf::VirtualMachine*>(host)) // Ignore virtual machines
-      return;
-    host->p_host->extension_set(new HostEnergy(host->p_host));
-  });
-
-  simgrid::surf::CpuAction::onStateChange.connect([](simgrid::surf::CpuAction *action,
-      e_surf_action_state_t old,
-      e_surf_action_state_t cur) {
-    const char *name = getActionCpu(action)->getName();
-    simgrid::surf::Host *host = sg_host_by_name(name)->extension<simgrid::surf::Host>();
-    simgrid::surf::VirtualMachine *vm = dynamic_cast<simgrid::surf::VirtualMachine*>(host);
-    if (vm) // If it's a VM, take the corresponding PM
-        host = vm->getPm()->extension<simgrid::surf::Host>();
-
-    HostEnergy *host_energy = host->p_host->extension<HostEnergy>();
-
-    if(host_energy->last_updated < surf_get_clock())
-      host_energy->update();
-
-  });
-
-  simgrid::surf::Host::onStateChange.connect([] (simgrid::surf::Host *host) {
-    if (dynamic_cast<simgrid::surf::VirtualMachine*>(host)) // Ignore virtual machines
-      return;
-
-    HostEnergy *host_energy = host->p_host->extension<HostEnergy>();
+  HostEnergy::EXTENSION_ID = simgrid::s4u::Host::extension_create<HostEnergy>();
 
-    if(host_energy->last_updated < surf_get_clock())
-      host_energy->update();
-  });
+  simgrid::s4u::Host::onCreation.connect(&onCreation);
+  simgrid::s4u::Host::onStateChange.connect(&onHostStateChange);
+  simgrid::s4u::Host::onDestruction.connect(&onHostDestruction);
+  simgrid::surf::CpuAction::onStateChange.connect(&onActionStateChange);
 }
 
 /** @brief Returns the total energy consumed by the host so far (in Joules)
@@ -273,18 +260,23 @@ void sg_energy_plugin_init(void)
  *  See also @ref SURF_plugin_energy.
  */
 double sg_host_get_consumed_energy(sg_host_t host) {
-  return simgrid::energy::surf_host_get_consumed_energy(host);
+  xbt_assert(HostEnergy::EXTENSION_ID.valid(),
+    "The Energy plugin is not active. "
+    "Please call sg_energy_plugin_init() during initialization.");
+  return host->extension<HostEnergy>()->getConsumedEnergy();
 }
 
 /** @brief Get the amount of watt dissipated at the given pstate when the host is idling */
 double sg_host_get_wattmin_at(sg_host_t host, int pstate) {
-  return simgrid::simix::kernel(std::bind(
-      simgrid::energy::surf_host_get_wattmin_at, host, pstate
-  ));
+  xbt_assert(HostEnergy::EXTENSION_ID.valid(),
+    "The Energy plugin is not active. "
+    "Please call sg_energy_plugin_init() during initialization.");
+  return host->extension<HostEnergy>()->getWattMinAt(pstate);
 }
 /** @brief  Returns the amount of watt dissipated at the given pstate when the host burns CPU at 100% */
 double sg_host_get_wattmax_at(sg_host_t host, int pstate) {
-  return simgrid::simix::kernel(std::bind(
-      simgrid::energy::surf_host_get_wattmax_at, host, pstate
-  ));
+  xbt_assert(HostEnergy::EXTENSION_ID.valid(),
+    "The Energy plugin is not active. "
+    "Please call sg_energy_plugin_init() during initialization.");
+  return host->extension<HostEnergy>()->getWattMaxAt(pstate);
 }