Prefer to use emplace_back.

[simgrid.git] / src / surf / ptask_L07.cpp

diff --git a/src/surf/ptask_L07.cpp b/src/surf/ptask_L07.cpp
index 4478d53..fb4cb6e 100644 (file)
--- a/src/surf/ptask_L07.cpp
+++ b/src/surf/ptask_L07.cpp
@@ -57,8 +57,10 @@ NetworkL07Model::NetworkL07Model(HostL07Model* hmodel, kernel::lmm::System* sys)
     : NetworkModel(Model::UpdateAlgo::FULL), hostModel_(hmodel)
 {
   set_maxmin_system(sys);
-  loopback_ = NetworkL07Model::create_link("__loopback__", std::vector<double>{498000000}, 0.000015,
-                                           s4u::Link::SharingPolicy::FATPIPE);
+  loopback_ = NetworkL07Model::create_link("__loopback__", 
+                                            std::vector<double>{simgrid::config::get_value<double>("network/loopback-bw")},
+                                            simgrid::config::get_value<double>("network/loopback-lat"),
+                                            s4u::Link::SharingPolicy::FATPIPE);
 }
 
 NetworkL07Model::~NetworkL07Model()
@@ -70,9 +72,9 @@ double HostL07Model::next_occurring_event(double now)
 {
   double min = HostModel::next_occurring_event_full(now);
   for (kernel::resource::Action const& action : *get_started_action_set()) {
-    const L07Action& net_action = static_cast<const L07Action&>(action);
-    if (net_action.latency_ > 0 && (min < 0 || net_action.latency_ < min)) {
-      min = net_action.latency_;
+    const auto& net_action = static_cast<const L07Action&>(action);
+    if (net_action.get_latency() > 0 && (min < 0 || net_action.get_latency() < min)) {
+      min = net_action.get_latency();
       XBT_DEBUG("Updating min with %p (start %f): %f", &net_action, net_action.get_start_time(), min);
     }
   }
@@ -84,15 +86,15 @@ double HostL07Model::next_occurring_event(double now)
 void HostL07Model::update_actions_state(double /*now*/, double delta)
 {
   for (auto it = std::begin(*get_started_action_set()); it != std::end(*get_started_action_set());) {
-    L07Action& action = static_cast<L07Action&>(*it);
+    auto& action = static_cast<L07Action&>(*it);
     ++it; // increment iterator here since the following calls to action.finish() may invalidate it
-    if (action.latency_ > 0) {
-      if (action.latency_ > delta) {
-        double_update(&(action.latency_), delta, sg_surf_precision);
+    if (action.get_latency() > 0) {
+      if (action.get_latency() > delta) {
+        action.update_latency(delta, sg_surf_precision);
       } else {
-        action.latency_ = 0.0;
+        action.set_latency(0.0);
       }
-      if ((action.latency_ <= 0.0) && (action.is_suspended() == 0)) {
+      if ((action.get_latency() <= 0.0) && (action.is_suspended() == 0)) {
         action.updateBound();
         get_maxmin_system()->update_variable_penalty(action.get_variable(), 1.0);
         action.set_last_update();
@@ -142,7 +144,7 @@ kernel::resource::CpuAction* HostL07Model::execute_parallel(const std::vector<s4
 
 L07Action::L07Action(kernel::resource::Model* model, const std::vector<s4u::Host*>& host_list,
                      const double* flops_amount, const double* bytes_amount, double rate)
-    : CpuAction(model, 1, 0), computationAmount_(flops_amount), communicationAmount_(bytes_amount), rate_(rate)
+    : CpuAction(model, 1.0, false), computationAmount_(flops_amount), communicationAmount_(bytes_amount), rate_(rate)
 {
   size_t link_nb      = 0;
   size_t used_host_nb = 0; /* Only the hosts with something to compute (>0 flops) are counted) */
@@ -210,8 +212,8 @@ L07Action::L07Action(kernel::resource::Model* model, const std::vector<s4u::Host
 kernel::resource::Action* NetworkL07Model::communicate(s4u::Host* src, s4u::Host* dst, double size, double rate)
 {
   std::vector<s4u::Host*> host_list = {src, dst};
-  const double* flops_amount        = new double[2]();
-  double* bytes_amount = new double[4]();
+  const auto* flops_amount          = new double[2]();
+  auto* bytes_amount                = new double[4]();
 
   bytes_amount[1] = size;
 
@@ -261,7 +263,7 @@ kernel::resource::CpuAction* CpuL07::execution_start(double size)
 {
   std::vector<s4u::Host*> host_list = {get_host()};
 
-  double* flops_amount = new double[host_list.size()]();
+  auto* flops_amount = new double[host_list.size()]();
   flops_amount[0] = size;
 
   kernel::resource::CpuAction* res =
@@ -272,7 +274,7 @@ kernel::resource::CpuAction* CpuL07::execution_start(double size)
 
 kernel::resource::CpuAction* CpuL07::sleep(double duration)
 {
-  L07Action *action = static_cast<L07Action*>(execution_start(1.0));
+  auto* action = static_cast<L07Action*>(execution_start(1.0));
   action->set_max_duration(duration);
   action->set_suspend_state(kernel::resource::Action::SuspendStates::SLEEPING);
   get_model()->get_maxmin_system()->update_variable_penalty(action->get_variable(), 0.0);
@@ -293,7 +295,7 @@ void CpuL07::on_speed_change()
 
   get_model()->get_maxmin_system()->update_constraint_bound(get_constraint(), speed_.peak * speed_.scale);
   while ((var = get_constraint()->get_variable(&elem))) {
-    const kernel::resource::Action* action = static_cast<kernel::resource::Action*>(var->get_id());
+    const kernel::resource::Action* action = var->get_id();
 
     get_model()->get_maxmin_system()->update_variable_bound(action->get_variable(), speed_.scale * speed_.peak);
   }
@@ -317,7 +319,7 @@ void CpuL07::apply_event(kernel::profile::Event* triggered, double value)
   } else if (triggered == state_event_) {
     if (value > 0) {
       if (not is_on()) {
-        XBT_VERB("Restart processes on host %s", get_host()->get_cname());
+        XBT_VERB("Restart actors on host %s", get_host()->get_cname());
         get_host()->turn_on();
       }
     } else