X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/8301d2fc929ad1ce873e4de1e97540827cdd940a..b0c36e046aa9d57ba90e5be5875b4754d9b8a545:/src/surf/cpu_ti.cpp

diff --git a/src/surf/cpu_ti.cpp b/src/surf/cpu_ti.cpp
index 1232dbe8e6..0e1e208ccf 100644
--- a/src/surf/cpu_ti.cpp
+++ b/src/surf/cpu_ti.cpp
@@ -1,10 +1,11 @@
-/* Copyright (c) 2013-2019. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2013-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. */
 
 #include "cpu_ti.hpp"
-#include "src/kernel/resource/profile/trace_mgr.hpp"
+#include "src/kernel/resource/profile/Event.hpp"
+#include "src/kernel/resource/profile/Profile.hpp"
 #include "src/surf/surf_interface.hpp"
 #include "surf/surf.hpp"
 
@@ -22,7 +23,7 @@ namespace resource {
  * Trace *
  *********/
 
-CpuTiProfile::CpuTiProfile(profile::Profile* profile)
+CpuTiProfile::CpuTiProfile(const profile::Profile* profile)
 {
   double integral = 0;
   double time = 0;
@@ -39,11 +40,6 @@ CpuTiProfile::CpuTiProfile(profile::Profile* profile)
   integral_.push_back(integral);
 }
 
-CpuTiTmgr::~CpuTiTmgr()
-{
-  delete profile_;
-}
-
 /**
  * @brief Integrate trace
  *
@@ -207,7 +203,7 @@ double CpuTiProfile::solve_simple(double a, double amount)
 double CpuTiTmgr::get_power_scale(double a)
 {
   double reduced_a          = a - floor(a / last_time_) * last_time_;
-  int point                       = profile_->binary_search(profile_->time_points_, reduced_a);
+  int point                       = CpuTiProfile::binary_search(profile_->time_points_, reduced_a);
   kernel::profile::DatedValue val = speed_profile_->event_list.at(point);
   return val.value_;
 }
@@ -222,11 +218,10 @@ double CpuTiTmgr::get_power_scale(double a)
 CpuTiTmgr::CpuTiTmgr(kernel::profile::Profile* speed_profile, double value) : speed_profile_(speed_profile)
 {
   double total_time = 0.0;
-  profile_          = 0;
+  profile_.reset(nullptr);
 
   /* no availability file, fixed trace */
   if (not speed_profile) {
-    type_  = Type::FIXED;
     value_ = value;
     XBT_DEBUG("No availability trace. Constant value = %f", value);
     return;
@@ -234,7 +229,6 @@ CpuTiTmgr::CpuTiTmgr(kernel::profile::Profile* speed_profile, double value) : sp
 
   /* only one point available, fixed trace */
   if (speed_profile->event_list.size() == 1) {
-    type_  = Type::FIXED;
     value_ = speed_profile->event_list.front().value_;
     return;
   }
@@ -245,7 +239,7 @@ CpuTiTmgr::CpuTiTmgr(kernel::profile::Profile* speed_profile, double value) : sp
   for (auto const& val : speed_profile->event_list)
     total_time += val.date_;
 
-  profile_   = new CpuTiProfile(speed_profile);
+  profile_.reset(new CpuTiProfile(speed_profile));
   last_time_ = total_time;
   total_     = profile_->integrate_simple(0, total_time);
 
@@ -276,8 +270,8 @@ void CpuTiModel::create_pm_vm_models()
   xbt_assert(surf_cpu_model_pm == nullptr, "CPU model already initialized. This should not happen.");
   xbt_assert(surf_cpu_model_vm == nullptr, "CPU model already initialized. This should not happen.");
 
-  surf_cpu_model_pm = new simgrid::kernel::resource::CpuTiModel();
-  surf_cpu_model_vm = new simgrid::kernel::resource::CpuTiModel();
+  surf_cpu_model_pm = new CpuTiModel();
+  surf_cpu_model_vm = new CpuTiModel();
 }
 
 CpuTiModel::CpuTiModel() : CpuModel(Model::UpdateAlgo::FULL)
@@ -290,12 +284,12 @@ CpuTiModel::~CpuTiModel()
   surf_cpu_model_pm = nullptr;
 }
 
-kernel::resource::Cpu* CpuTiModel::create_cpu(s4u::Host* host, const std::vector<double>& speed_per_pstate, int core)
+Cpu* CpuTiModel::create_cpu(s4u::Host* host, const std::vector<double>& speed_per_pstate, int core)
 {
   return new CpuTi(this, host, speed_per_pstate, core);
 }
 
-double CpuTiModel::next_occuring_event(double now)
+double CpuTiModel::next_occurring_event(double now)
 {
   double min_action_duration = -1;
 
@@ -318,9 +312,9 @@ double CpuTiModel::next_occuring_event(double now)
 void CpuTiModel::update_actions_state(double now, double /*delta*/)
 {
   while (not get_action_heap().empty() && double_equals(get_action_heap().top_date(), now, sg_surf_precision)) {
-    CpuTiAction* action = static_cast<CpuTiAction*>(get_action_heap().pop());
+    auto* action = static_cast<CpuTiAction*>(get_action_heap().pop());
     XBT_DEBUG("Action %p: finish", action);
-    action->finish(kernel::resource::Action::State::FINISHED);
+    action->finish(Action::State::FINISHED);
     /* update remaining amount of all actions */
     action->cpu_->update_remaining_amount(surf_get_clock());
   }
@@ -329,7 +323,7 @@ void CpuTiModel::update_actions_state(double now, double /*delta*/)
 /************
  * Resource *
  ************/
-CpuTi::CpuTi(CpuTiModel* model, simgrid::s4u::Host* host, const std::vector<double>& speed_per_pstate, int core)
+CpuTi::CpuTi(CpuTiModel* model, s4u::Host* host, const std::vector<double>& speed_per_pstate, int core)
     : Cpu(model, host, speed_per_pstate, core)
 {
   xbt_assert(core == 1, "Multi-core not handled by this model yet");
@@ -345,6 +339,7 @@ CpuTi::~CpuTi()
   set_modified(false);
   delete speed_integrated_trace_;
 }
+
 void CpuTi::set_speed_profile(kernel::profile::Profile* profile)
 {
   delete speed_integrated_trace_;
@@ -354,8 +349,8 @@ void CpuTi::set_speed_profile(kernel::profile::Profile* profile)
   if (profile && profile->event_list.size() > 1) {
     kernel::profile::DatedValue val = profile->event_list.back();
     if (val.date_ < 1e-12) {
-      simgrid::kernel::profile::Profile* prof = new simgrid::kernel::profile::Profile();
-      speed_.event                            = prof->schedule(&future_evt_set, this);
+      auto* prof   = new kernel::profile::Profile();
+      speed_.event = prof->schedule(&profile::future_evt_set, this);
     }
   }
 }
@@ -379,7 +374,7 @@ void CpuTi::apply_event(kernel::profile::Event* event, double value)
   } else if (event == 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 {
@@ -388,11 +383,10 @@ void CpuTi::apply_event(kernel::profile::Event* event, double value)
 
       /* put all action running on cpu to failed */
       for (CpuTiAction& action : action_set_) {
-        if (action.get_state() == kernel::resource::Action::State::INITED ||
-            action.get_state() == kernel::resource::Action::State::STARTED ||
-            action.get_state() == kernel::resource::Action::State::IGNORED) {
+        if (action.get_state() == Action::State::INITED || action.get_state() == Action::State::STARTED ||
+            action.get_state() == Action::State::IGNORED) {
           action.set_finish_time(date);
-          action.set_state(kernel::resource::Action::State::FAILED);
+          action.set_state(Action::State::FAILED);
           get_model()->get_action_heap().remove(&action);
         }
       }
@@ -418,14 +412,14 @@ void CpuTi::update_actions_finish_time(double now)
       continue;
 
     /* bogus priority, skip it */
-    if (action.get_priority() <= 0)
+    if (action.get_sharing_penalty() <= 0)
       continue;
 
     /* action suspended, skip it */
     if (not action.is_running())
       continue;
 
-    sum_priority_ += 1.0 / action.get_priority();
+    sum_priority_ += 1.0 / action.get_sharing_penalty();
   }
 
   for (CpuTiAction& action : action_set_) {
@@ -435,9 +429,9 @@ void CpuTi::update_actions_finish_time(double now)
       continue;
 
     /* verify if the action is really running on cpu */
-    if (action.is_running() && action.get_priority() > 0) {
+    if (action.is_running() && action.get_sharing_penalty() > 0) {
       /* total area needed to finish the action. Used in trace integration */
-      double total_area = (action.get_remains() * sum_priority_ * action.get_priority()) / speed_.peak;
+      double total_area = (action.get_remains() * sum_priority_ * action.get_sharing_penalty()) / speed_.peak;
 
       action.set_finish_time(speed_integrated_trace_->solve(now, total_area));
       /* verify which event will happen before (max_duration or finish time) */
@@ -453,7 +447,7 @@ void CpuTi::update_actions_finish_time(double now)
     }
     /* add in action heap */
     if (min_finish != NO_MAX_DURATION)
-      get_model()->get_action_heap().update(&action, min_finish, kernel::resource::ActionHeap::Type::unset);
+      get_model()->get_action_heap().update(&action, min_finish, ActionHeap::Type::unset);
     else
       get_model()->get_action_heap().remove(&action);
 
@@ -491,7 +485,7 @@ void CpuTi::update_remaining_amount(double now)
       continue;
 
     /* bogus priority, skip it */
-    if (action.get_priority() <= 0)
+    if (action.get_sharing_penalty() <= 0)
       continue;
 
     /* action suspended, skip it */
@@ -507,16 +501,16 @@ void CpuTi::update_remaining_amount(double now)
       continue;
 
     /* update remaining */
-    action.update_remains(area_total / (sum_priority_ * action.get_priority()));
+    action.update_remains(area_total / (sum_priority_ * action.get_sharing_penalty()));
     XBT_DEBUG("Update remaining action(%p) remaining %f", &action, action.get_remains_no_update());
   }
   last_update_ = now;
 }
 
-kernel::resource::CpuAction* CpuTi::execution_start(double size)
+CpuAction* CpuTi::execution_start(double size)
 {
   XBT_IN("(%s,%g)", get_cname(), size);
-  CpuTiAction* action = new CpuTiAction(this, size);
+  auto* action = new CpuTiAction(this, size);
 
   action_set_.push_back(*action); // Actually start the action
 
@@ -524,18 +518,18 @@ kernel::resource::CpuAction* CpuTi::execution_start(double size)
   return action;
 }
 
-kernel::resource::CpuAction* CpuTi::sleep(double duration)
+CpuAction* CpuTi::sleep(double duration)
 {
   if (duration > 0)
     duration = std::max(duration, sg_surf_precision);
 
   XBT_IN("(%s,%g)", get_cname(), duration);
-  CpuTiAction* action = new CpuTiAction(this, 1.0);
+  auto* action = new CpuTiAction(this, 1.0);
 
   action->set_max_duration(duration);
-  action->set_suspend_state(kernel::resource::Action::SuspendStates::SLEEPING);
+  action->set_suspend_state(Action::SuspendStates::SLEEPING);
   if (duration == NO_MAX_DURATION)
-    action->set_state(simgrid::kernel::resource::Action::State::IGNORED);
+    action->set_state(Action::State::IGNORED);
 
   action_set_.push_back(*action);
 
@@ -552,7 +546,7 @@ void CpuTi::set_modified(bool modified)
     }
   } else {
     if (cpu_ti_hook.is_linked())
-      simgrid::xbt::intrusive_erase(modified_cpus, *this);
+      xbt::intrusive_erase(modified_cpus, *this);
   }
 }
 
@@ -568,7 +562,7 @@ CpuTiAction::~CpuTiAction()
 {
   /* remove from action_set */
   if (action_ti_hook.is_linked())
-    simgrid::xbt::intrusive_erase(cpu_->action_set_, *this);
+    xbt::intrusive_erase(cpu_->action_set_, *this);
   /* remove from heap */
   get_model()->get_action_heap().remove(this);
   cpu_->set_modified(true);
@@ -623,15 +617,15 @@ void CpuTiAction::set_max_duration(double duration)
     min_finish = get_finish_time();
 
   /* add in action heap */
-  get_model()->get_action_heap().update(this, min_finish, kernel::resource::ActionHeap::Type::unset);
+  get_model()->get_action_heap().update(this, min_finish, ActionHeap::Type::unset);
 
   XBT_OUT();
 }
 
-void CpuTiAction::set_priority(double priority)
+void CpuTiAction::set_sharing_penalty(double sharing_penalty)
 {
-  XBT_IN("(%p,%g)", this, priority);
-  set_priority_no_update(priority);
+  XBT_IN("(%p,%g)", this, sharing_penalty);
+  set_sharing_penalty_no_update(sharing_penalty);
   cpu_->set_modified(true);
   XBT_OUT();
 }