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

diff --git a/src/surf/cpu_ti.cpp b/src/surf/cpu_ti.cpp
index 40c049080b..c29102b845 100644
--- a/src/surf/cpu_ti.cpp
+++ b/src/surf/cpu_ti.cpp
@@ -1,14 +1,14 @@
-/* Copyright (c) 2013-2018. The SimGrid Team. All rights reserved.          */
+/* Copyright (c) 2013-2019. 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/surf/surf_interface.hpp"
-#include "src/surf/trace_mgr.hpp"
 #include "surf/surf.hpp"
 
-#define EPSILON 0.000000001
+constexpr double EPSILON = 0.000000001;
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_cpu_ti, surf_cpu, "Logging specific to the SURF CPU TRACE INTEGRATION module");
 
@@ -19,15 +19,15 @@ namespace surf {
  * Trace *
  *********/
 
-CpuTiTrace::CpuTiTrace(tmgr_trace_t speedTrace)
+CpuTiProfile::CpuTiProfile(kernel::profile::Profile* profile)
 {
   double integral = 0;
   double time = 0;
   int i = 0;
-  nb_points_      = speedTrace->event_list.size() + 1;
+  nb_points_      = profile->event_list.size() + 1;
   time_points_    = new double[nb_points_];
   integral_       = new double[nb_points_];
-  for (auto const& val : speedTrace->event_list) {
+  for (auto const& val : profile->event_list) {
     time_points_[i] = time;
     integral_[i] = integral;
     integral += val.date_ * val.value_;
@@ -38,7 +38,7 @@ CpuTiTrace::CpuTiTrace(tmgr_trace_t speedTrace)
   integral_[i] = integral;
 }
 
-CpuTiTrace::~CpuTiTrace()
+CpuTiProfile::~CpuTiProfile()
 {
   delete[] time_points_;
   delete [] integral_;
@@ -46,19 +46,19 @@ CpuTiTrace::~CpuTiTrace()
 
 CpuTiTmgr::~CpuTiTmgr()
 {
-  delete trace_;
+  delete profile_;
 }
 
 /**
-* \brief Integrate trace
-*
-* Wrapper around surf_cpu_integrate_trace_simple() to get
-* the cyclic effect.
-*
-* \param a      Begin of interval
-* \param b      End of interval
-* \return the integrate value. -1 if an error occurs.
-*/
+ * @brief Integrate trace
+ *
+ * Wrapper around surf_cpu_integrate_trace_simple() to get
+ * the cyclic effect.
+ *
+ * @param a      Begin of interval
+ * @param b      End of interval
+ * @return the integrate value. -1 if an error occurs.
+ */
 double CpuTiTmgr::integrate(double a, double b)
 {
   if ((a < 0.0) || (a > b)) {
@@ -81,12 +81,12 @@ double CpuTiTmgr::integrate(double a, double b)
   int b_index = static_cast<int>(floor(b / last_time_));
 
   if (a_index > b_index) {      /* Same chunk */
-    return trace_->integrate_simple(a - (a_index - 1) * last_time_, b - (b_index)*last_time_);
+    return profile_->integrate_simple(a - (a_index - 1) * last_time_, b - (b_index)*last_time_);
   }
 
-  double first_chunk  = trace_->integrate_simple(a - (a_index - 1) * last_time_, last_time_);
+  double first_chunk  = profile_->integrate_simple(a - (a_index - 1) * last_time_, last_time_);
   double middle_chunk = (b_index - a_index) * total_;
-  double last_chunk   = trace_->integrate_simple(0.0, b - (b_index)*last_time_);
+  double last_chunk   = profile_->integrate_simple(0.0, b - (b_index)*last_time_);
 
   XBT_DEBUG("first_chunk=%.2f  middle_chunk=%.2f  last_chunk=%.2f\n", first_chunk, middle_chunk, last_chunk);
 
@@ -94,21 +94,21 @@ double CpuTiTmgr::integrate(double a, double b)
 }
 
 /**
- * \brief Auxiliary function to compute the integral between a and b.
+ * @brief Auxiliary function to compute the integral between a and b.
  *     It simply computes the integrals at point a and b and returns the difference between them.
- * \param a  Initial point
- * \param b  Final point
-*/
-double CpuTiTrace::integrate_simple(double a, double b)
+ * @param a  Initial point
+ * @param b  Final point
+ */
+double CpuTiProfile::integrate_simple(double a, double b)
 {
   return integrate_simple_point(b) - integrate_simple_point(a);
 }
 
 /**
- * \brief Auxiliary function to compute the integral at point a.
- * \param a        point
+ * @brief Auxiliary function to compute the integral at point a.
+ * @param a        point
  */
-double CpuTiTrace::integrate_simple_point(double a)
+double CpuTiProfile::integrate_simple_point(double a)
 {
   double integral = 0;
   double a_aux = a;
@@ -127,14 +127,14 @@ double CpuTiTrace::integrate_simple_point(double a)
 }
 
 /**
-* \brief Computes the time needed to execute "amount" on cpu.
-*
-* Here, amount can span multiple trace periods
-*
-* \param a        Initial time
-* \param amount  Amount to be executed
-* \return  End time
-*/
+ * @brief Computes the time needed to execute "amount" on cpu.
+ *
+ * Here, amount can span multiple trace periods
+ *
+ * @param a        Initial time
+ * @param amount  Amount to be executed
+ * @return  End time
+ */
 double CpuTiTmgr::solve(double a, double amount)
 {
   /* Fix very small negative numbers */
@@ -175,9 +175,9 @@ double CpuTiTmgr::solve(double a, double amount)
   double amount_till_end = integrate(reduced_a, last_time_);
 
   if (amount_till_end > reduced_amount) {
-    reduced_b = trace_->solve_simple(reduced_a, reduced_amount);
+    reduced_b = profile_->solve_simple(reduced_a, reduced_amount);
   } else {
-    reduced_b = last_time_ + trace_->solve_simple(0.0, reduced_amount - amount_till_end);
+    reduced_b = last_time_ + profile_->solve_simple(0.0, reduced_amount - amount_till_end);
   }
 
   /* Re-map to the original b and amount */
@@ -185,13 +185,13 @@ double CpuTiTmgr::solve(double a, double amount)
 }
 
 /**
- * \brief Auxiliary function to solve integral.
+ * @brief Auxiliary function to solve integral.
  *  It returns the date when the requested amount of flops is available
- * \param a        Initial point
- * \param amount  Amount of flops
- * \return The date when amount is available.
-*/
-double CpuTiTrace::solve_simple(double a, double amount)
+ * @param a        Initial point
+ * @param amount  Amount of flops
+ * @return The date when amount is available.
+ */
+double CpuTiProfile::solve_simple(double a, double amount)
 {
   double integral_a = integrate_simple_point(a);
   int ind           = binary_search(integral_, integral_a + amount, 0, nb_points_ - 1);
@@ -203,34 +203,34 @@ double CpuTiTrace::solve_simple(double a, double amount)
 }
 
 /**
-* \brief Auxiliary function to update the CPU speed scale.
-*
-*  This function uses the trace structure to return the speed scale at the determined time a.
-* \param a        Time
-* \return CPU speed scale
-*/
+ * @brief Auxiliary function to update the CPU speed scale.
+ *
+ *  This function uses the trace structure to return the speed scale at the determined time a.
+ * @param a        Time
+ * @return CPU speed scale
+ */
 double CpuTiTmgr::get_power_scale(double a)
 {
   double reduced_a          = a - floor(a / last_time_) * last_time_;
-  int point                 = trace_->binary_search(trace_->time_points_, reduced_a, 0, trace_->nb_points_ - 1);
-  trace_mgr::DatedValue val = speed_trace_->event_list.at(point);
+  int point                 = profile_->binary_search(profile_->time_points_, reduced_a, 0, profile_->nb_points_ - 1);
+  kernel::profile::DatedValue val = speed_profile_->event_list.at(point);
   return val.value_;
 }
 
 /**
- * \brief Creates a new integration trace from a tmgr_trace_t
+ * @brief Creates a new integration trace from a tmgr_trace_t
  *
- * \param  speed_trace    CPU availability trace
- * \param  value          Percentage of CPU speed available (useful to fixed tracing)
- * \return  Integration trace structure
+ * @param  speed_trace    CPU availability trace
+ * @param  value          Percentage of CPU speed available (useful to fixed tracing)
+ * @return  Integration trace structure
  */
-CpuTiTmgr::CpuTiTmgr(tmgr_trace_t speed_trace, double value) : speed_trace_(speed_trace)
+CpuTiTmgr::CpuTiTmgr(kernel::profile::Profile* speed_profile, double value) : speed_profile_(speed_profile)
 {
   double total_time = 0.0;
-  trace_ = 0;
+  profile_          = 0;
 
   /* no availability file, fixed trace */
-  if (not speed_trace) {
+  if (not speed_profile) {
     type_  = Type::FIXED;
     value_ = value;
     XBT_DEBUG("No availability trace. Constant value = %f", value);
@@ -238,35 +238,35 @@ CpuTiTmgr::CpuTiTmgr(tmgr_trace_t speed_trace, double value) : speed_trace_(spee
   }
 
   /* only one point available, fixed trace */
-  if (speed_trace->event_list.size() == 1) {
+  if (speed_profile->event_list.size() == 1) {
     type_  = Type::FIXED;
-    value_ = speed_trace->event_list.front().value_;
+    value_ = speed_profile->event_list.front().value_;
     return;
   }
 
   type_ = Type::DYNAMIC;
 
   /* count the total time of trace file */
-  for (auto const& val : speed_trace->event_list)
+  for (auto const& val : speed_profile->event_list)
     total_time += val.date_;
 
-  trace_     = new CpuTiTrace(speed_trace);
+  profile_   = new CpuTiProfile(speed_profile);
   last_time_ = total_time;
-  total_     = trace_->integrate_simple(0, total_time);
+  total_     = profile_->integrate_simple(0, total_time);
 
   XBT_DEBUG("Total integral %f, last_time %f ", total_, last_time_);
 }
 
 /**
- * \brief Binary search in array.
+ * @brief Binary search in array.
  *  It returns the first point of the interval in which "a" is.
- * \param array    Array
- * \param a        Value to search
- * \param low     Low bound to search in array
- * \param high    Upper bound to search in array
- * \return Index of point
-*/
-int CpuTiTrace::binary_search(double* array, double a, int low, int high)
+ * @param array    Array
+ * @param a        Value to search
+ * @param low     Low bound to search in array
+ * @param high    Upper bound to search in array
+ * @return Index of point
+ */
+int CpuTiProfile::binary_search(double* array, double a, int low, int high)
 {
   xbt_assert(low < high, "Wrong parameters: low (%d) should be smaller than high (%d)", low, high);
 
@@ -304,7 +304,7 @@ void CpuTiModel::create_pm_vm_models()
 
 CpuTiModel::CpuTiModel() : CpuModel(Model::UpdateAlgo::FULL)
 {
-  all_existing_models->push_back(this);
+  all_existing_models.push_back(this);
 }
 
 CpuTiModel::~CpuTiModel()
@@ -367,20 +367,22 @@ CpuTi::~CpuTi()
   set_modified(false);
   delete speed_integrated_trace_;
 }
-void CpuTi::set_speed_trace(tmgr_trace_t trace)
+void CpuTi::set_speed_profile(kernel::profile::Profile* profile)
 {
   delete speed_integrated_trace_;
-  speed_integrated_trace_ = new CpuTiTmgr(trace, speed_.scale);
+  speed_integrated_trace_ = new CpuTiTmgr(profile, speed_.scale);
 
   /* add a fake trace event if periodicity == 0 */
-  if (trace && trace->event_list.size() > 1) {
-    trace_mgr::DatedValue val = trace->event_list.back();
-    if (val.date_ < 1e-12)
-      speed_.event = future_evt_set->add_trace(new simgrid::trace_mgr::trace(), this);
+  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);
+    }
   }
 }
 
-void CpuTi::apply_event(tmgr_trace_event_t event, double value)
+void CpuTi::apply_event(kernel::profile::Event* event, double value)
 {
   if (event == speed_.event) {
     XBT_DEBUG("Speed changed in trace! New fixed value: %f", value);
@@ -398,11 +400,12 @@ void CpuTi::apply_event(tmgr_trace_event_t event, double value)
 
   } else if (event == state_event_) {
     if (value > 0) {
-      if (is_off())
-        host_that_restart.push_back(get_host());
-      turn_on();
+      if (not is_on()) {
+        XBT_VERB("Restart processes on host %s", get_host()->get_cname());
+        get_host()->turn_on();
+      }
     } else {
-      turn_off();
+      get_host()->turn_off();
       double date = surf_get_clock();
 
       /* put all action running on cpu to failed */
@@ -460,18 +463,18 @@ void CpuTi::update_actions_finish_time(double now)
 
       action.set_finish_time(speed_integrated_trace_->solve(now, total_area));
       /* verify which event will happen before (max_duration or finish time) */
-      if (action.get_max_duration() > NO_MAX_DURATION &&
+      if (action.get_max_duration() != NO_MAX_DURATION &&
           action.get_start_time() + action.get_max_duration() < action.get_finish_time())
         min_finish = action.get_start_time() + action.get_max_duration();
       else
         min_finish = action.get_finish_time();
     } else {
       /* put the max duration time on heap */
-      if (action.get_max_duration() > NO_MAX_DURATION)
+      if (action.get_max_duration() != NO_MAX_DURATION)
         min_finish = action.get_start_time() + action.get_max_duration();
     }
     /* add in action heap */
-    if (min_finish > NO_MAX_DURATION)
+    if (min_finish != NO_MAX_DURATION)
       get_model()->get_action_heap().update(&action, min_finish, kernel::resource::ActionHeap::Type::unset);
     else
       get_model()->get_action_heap().remove(&action);
@@ -554,7 +557,7 @@ CpuAction *CpuTi::sleep(double duration)
 
   action->set_max_duration(duration);
   action->suspended_ = kernel::resource::Action::SuspendStates::sleeping;
-  if (duration < 0) // NO_MAX_DURATION
+  if (duration == NO_MAX_DURATION)
     action->set_state(simgrid::kernel::resource::Action::State::IGNORED);
 
   action_set_.push_back(*action);
@@ -580,7 +583,7 @@ void CpuTi::set_modified(bool modified)
  * Action *
  **********/
 
-CpuTiAction::CpuTiAction(CpuTi* cpu, double cost) : CpuAction(cpu->get_model(), cost, cpu->is_off()), cpu_(cpu)
+CpuTiAction::CpuTiAction(CpuTi* cpu, double cost) : CpuAction(cpu->get_model(), cost, not cpu->is_on()), cpu_(cpu)
 {
   cpu_->set_modified(true);
 }