X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/1847d1441271d076b3de449c8853031ea208ce8f..a51412052680be35c70a5771242eb5a0a61b1dea:/src/surf/network_cm02.cpp

diff --git a/src/surf/network_cm02.cpp b/src/surf/network_cm02.cpp
index 30e3b08d65..fe92ad9e97 100644
--- a/src/surf/network_cm02.cpp
+++ b/src/surf/network_cm02.cpp
@@ -9,7 +9,7 @@
 #include "network_cm02.hpp"
 #include "simgrid/s4u/Host.hpp"
 #include "simgrid/sg_config.h"
-#include "src/instr/instr_private.h" // TRACE_is_enabled(). FIXME: remove by subscribing tracing to the surf signals
+#include "src/instr/instr_private.hpp" // TRACE_is_enabled(). FIXME: remove by subscribing tracing to the surf signals
 
 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_network);
 
@@ -134,25 +134,25 @@ namespace surf {
 NetworkCm02Model::NetworkCm02Model()
   :NetworkModel()
 {
-  char *optim = xbt_cfg_get_string("network/optim");
+  std::string optim = xbt_cfg_get_string("network/optim");
   bool select = xbt_cfg_get_boolean("network/maxmin-selective-update");
 
-  if (not strcmp(optim, "Full")) {
-    updateMechanism_ = UM_FULL;
+  if (optim == "Full") {
+    setUpdateMechanism(UM_FULL);
     selectiveUpdate_ = select;
-  } else if (not strcmp(optim, "Lazy")) {
-    updateMechanism_ = UM_LAZY;
+  } else if (optim == "Lazy") {
+    setUpdateMechanism(UM_LAZY);
     selectiveUpdate_ = true;
     xbt_assert(select || (xbt_cfg_is_default_value("network/maxmin-selective-update")),
                "You cannot disable selective update when using the lazy update mechanism");
   } else {
-    xbt_die("Unsupported optimization (%s) for this model. Accepted: Full, Lazy.", optim);
+    xbt_die("Unsupported optimization (%s) for this model. Accepted: Full, Lazy.", optim.c_str());
   }
 
   maxminSystem_ = lmm_system_new(selectiveUpdate_);
   loopback_     = createLink("__loopback__", 498000000, 0.000015, SURF_LINK_FATPIPE);
 
-  if (updateMechanism_ == UM_LAZY) {
+  if (getUpdateMechanism() == UM_LAZY) {
     actionHeap_ = xbt_heap_new(8, nullptr);
     xbt_heap_set_update_callback(actionHeap_, surf_action_lmm_update_index_heap);
     modifiedSet_ = new ActionLmmList();
@@ -165,7 +165,7 @@ NetworkCm02Model::NetworkCm02Model(void (*specificSolveFun)(lmm_system_t self))
   maxminSystem_->solve_fun = specificSolveFun;
 }
 
-LinkImpl* NetworkCm02Model::createLink(const char* name, double bandwidth, double latency,
+LinkImpl* NetworkCm02Model::createLink(const std::string& name, double bandwidth, double latency,
                                        e_surf_link_sharing_policy_t policy)
 {
   return new NetworkCm02Link(this, name, bandwidth, latency, policy, maxminSystem_);
@@ -186,7 +186,7 @@ void NetworkCm02Model::updateActionsStateLazy(double now, double /*delta*/)
         NetworkCm02Link *link = static_cast<NetworkCm02Link*>(lmm_constraint_id(constraint));
         double value = lmm_variable_getvalue(action->getVariable())*
             lmm_get_cnst_weight_from_var(maxminSystem_, action->getVariable(), i);
-        TRACE_surf_link_set_utilization(link->cname(), action->getCategory(), value, action->getLastUpdate(),
+        TRACE_surf_link_set_utilization(link->getCname(), action->getCategory(), value, action->getLastUpdate(),
                                         now - action->getLastUpdate());
       }
     }
@@ -204,8 +204,7 @@ void NetworkCm02Model::updateActionsStateLazy(double now, double /*delta*/)
         // assume that flows that reached max_duration have remaining of 0
       XBT_DEBUG("Action %p finished", action);
       action->setRemains(0);
-      action->finish();
-      action->setState(Action::State::done);
+      action->finish(Action::State::done);
       action->heapRemove(actionHeap_);
     }
   }
@@ -240,7 +239,7 @@ void NetworkCm02Model::updateActionsStateFull(double now, double delta)
           lmm_constraint_t constraint = lmm_get_cnst_from_var(maxminSystem_, action->getVariable(), i);
 
           NetworkCm02Link* link = static_cast<NetworkCm02Link*>(lmm_constraint_id(constraint));
-          TRACE_surf_link_set_utilization(link->cname(), action->getCategory(),
+          TRACE_surf_link_set_utilization(link->getCname(), action->getCategory(),
                                           (lmm_variable_getvalue(action->getVariable()) *
                                            lmm_get_cnst_weight_from_var(maxminSystem_, action->getVariable(), i)),
                                           action->getLastUpdate(), now - action->getLastUpdate());
@@ -259,8 +258,7 @@ void NetworkCm02Model::updateActionsStateFull(double now, double delta)
 
     if (((action->getRemains() <= 0) && (lmm_get_variable_weight(action->getVariable()) > 0)) ||
         ((action->getMaxDuration() > NO_MAX_DURATION) && (action->getMaxDuration() <= 0))) {
-      action->finish();
-      action->setState(Action::State::done);
+      action->finish(Action::State::done);
     }
   }
 }
@@ -295,9 +293,9 @@ Action* NetworkCm02Model::communicate(s4u::Host* src, s4u::Host* dst, double siz
   action->weight_ = latency;
   action->latency_ = latency;
   action->rate_ = rate;
-  if (updateMechanism_ == UM_LAZY) {
-    action->indexHeap_ = -1;
-    action->lastUpdate_ = surf_get_clock();
+  if (getUpdateMechanism() == UM_LAZY) {
+    action->updateIndexHeap(-1);
+    action->refreshLastUpdate();
   }
 
   double bandwidth_bound = -1.0;
@@ -319,14 +317,14 @@ Action* NetworkCm02Model::communicate(s4u::Host* src, s4u::Host* dst, double siz
     constraints_per_variable += back_route->size();
 
   if (action->latency_ > 0) {
-    action->variable_ = lmm_variable_new(maxminSystem_, action, 0.0, -1.0, constraints_per_variable);
-    if (updateMechanism_ == UM_LAZY) {
+    action->setVariable(lmm_variable_new(maxminSystem_, action, 0.0, -1.0, constraints_per_variable));
+    if (getUpdateMechanism() == UM_LAZY) {
       // add to the heap the event when the latency is payed
-      XBT_DEBUG("Added action (%p) one latency event at date %f", action, action->latency_ + action->lastUpdate_);
-      action->heapInsert(actionHeap_, action->latency_ + action->lastUpdate_, route->empty() ? NORMAL : LATENCY);
+      XBT_DEBUG("Added action (%p) one latency event at date %f", action, action->latency_ + action->getLastUpdate());
+      action->heapInsert(actionHeap_, action->latency_ + action->getLastUpdate(), route->empty() ? NORMAL : LATENCY);
     }
   } else
-    action->variable_ = lmm_variable_new(maxminSystem_, action, 1.0, -1.0, constraints_per_variable);
+    action->setVariable(lmm_variable_new(maxminSystem_, action, 1.0, -1.0, constraints_per_variable));
 
   if (action->rate_ < 0) {
     lmm_update_variable_bound(maxminSystem_, action->getVariable(), (action->latCurrent_ > 0) ? sg_tcp_gamma / (2.0 * action->latCurrent_) : -1.0);
@@ -358,7 +356,7 @@ Action* NetworkCm02Model::communicate(s4u::Host* src, s4u::Host* dst, double siz
 /************
  * Resource *
  ************/
-NetworkCm02Link::NetworkCm02Link(NetworkCm02Model* model, const char* name, double bandwidth, double latency,
+NetworkCm02Link::NetworkCm02Link(NetworkCm02Model* model, const std::string& name, double bandwidth, double latency,
                                  e_surf_link_sharing_policy_t policy, lmm_system_t system)
     : LinkImpl(model, name, lmm_constraint_new(system, this, sg_bandwidth_factor * bandwidth))
 {
@@ -419,7 +417,7 @@ void NetworkCm02Link::setBandwidth(double value)
 
   lmm_update_constraint_bound(model()->getMaxminSystem(), constraint(),
                               sg_bandwidth_factor * (bandwidth_.peak * bandwidth_.scale));
-  TRACE_surf_link_set_bandwidth(surf_get_clock(), cname(), sg_bandwidth_factor * bandwidth_.peak * bandwidth_.scale);
+  TRACE_surf_link_set_bandwidth(surf_get_clock(), getCname(), sg_bandwidth_factor * bandwidth_.peak * bandwidth_.scale);
 
   if (sg_weight_S_parameter > 0) {
     double delta = sg_weight_S_parameter / value - sg_weight_S_parameter / (bandwidth_.peak * bandwidth_.scale);
@@ -478,27 +476,29 @@ void NetworkCm02Action::updateRemainingLazy(double now)
   if (suspended_ != 0)
     return;
 
-  double delta = now - lastUpdate_;
+  double delta        = now - getLastUpdate();
+  double max_duration = getMaxDuration();
 
-  if (remains_ > 0) {
-    XBT_DEBUG("Updating action(%p): remains was %f, last_update was: %f", this, remains_, lastUpdate_);
-    double_update(&(remains_), lastValue_ * delta, sg_maxmin_precision*sg_surf_precision);
+  if (getRemainsNoUpdate() > 0) {
+    XBT_DEBUG("Updating action(%p): remains was %f, last_update was: %f", this, getRemainsNoUpdate(), getLastUpdate());
+    updateRemains(getLastValue() * delta);
 
-    XBT_DEBUG("Updating action(%p): remains is now %f", this, remains_);
+    XBT_DEBUG("Updating action(%p): remains is now %f", this, getRemainsNoUpdate());
   }
 
-  if (maxDuration_ > NO_MAX_DURATION)
-    double_update(&maxDuration_, delta, sg_surf_precision);
+  if (max_duration > NO_MAX_DURATION) {
+    double_update(&max_duration, delta, sg_surf_precision);
+    setMaxDuration(max_duration);
+  }
 
-  if ((remains_ <= 0 && (lmm_get_variable_weight(getVariable()) > 0)) ||
-      ((maxDuration_ > NO_MAX_DURATION) && (maxDuration_ <= 0))) {
-    finish();
-    setState(Action::State::done);
+  if ((getRemainsNoUpdate() <= 0 && (lmm_get_variable_weight(getVariable()) > 0)) ||
+      ((max_duration > NO_MAX_DURATION) && (max_duration <= 0))) {
+    finish(Action::State::done);
     heapRemove(getModel()->getActionHeap());
   }
 
-  lastUpdate_ = now;
-  lastValue_ = lmm_variable_getvalue(getVariable());
+  refreshLastUpdate();
+  setLastValue(lmm_variable_getvalue(getVariable()));
 }
 
 }