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

diff --git a/src/surf/cpu_ti.cpp b/src/surf/cpu_ti.cpp
index 2ad9288ff4..f4db720924 100644
--- a/src/surf/cpu_ti.cpp
+++ b/src/surf/cpu_ti.cpp
@@ -1,5 +1,4 @@
-/* Copyright (c) 2013-2017. The SimGrid Team.
- * All rights reserved.                                                     */
+/* Copyright (c) 2013-2018. 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. */
@@ -362,9 +361,7 @@ void CpuTiModel::updateActionsState(double now, double /*delta*/)
   while (not actionHeapIsEmpty() && actionHeapTopDate() <= now) {
     CpuTiAction* action = static_cast<CpuTiAction*>(actionHeapPop());
     XBT_DEBUG("Action %p: finish", action);
-    action->finish(Action::State::done);
-    /* set the remains to 0 due to precision problems when updating the remaining amount */
-    action->setRemains(0);
+    action->finish(kernel::resource::Action::State::done);
     /* update remaining amount of all actions */
     action->cpu_->updateRemainingAmount(surf_get_clock());
   }
@@ -440,11 +437,12 @@ void CpuTi::apply_event(tmgr_trace_event_t event, double value)
 
       /* put all action running on cpu to failed */
       for (CpuTiAction& action : actionSet_) {
-        if (action.getState() == Action::State::running || action.getState() == Action::State::ready ||
-            action.getState() == Action::State::not_in_the_system) {
-          action.setFinishTime(date);
-          action.setState(Action::State::failed);
-          action.heapRemove(model()->getActionHeap());
+        if (action.get_state() == kernel::resource::Action::State::running ||
+            action.get_state() == kernel::resource::Action::State::ready ||
+            action.get_state() == kernel::resource::Action::State::not_in_the_system) {
+          action.set_finish_time(date);
+          action.set_state(kernel::resource::Action::State::failed);
+          action.heapRemove();
         }
       }
     }
@@ -465,54 +463,54 @@ void CpuTi::updateActionsFinishTime(double now)
 
   for (CpuTiAction const& action : actionSet_) {
     /* action not running, skip it */
-    if (action.getStateSet() != surf_cpu_model_pm->getRunningActionSet())
+    if (action.get_state_set() != surf_cpu_model_pm->getRunningActionSet())
       continue;
 
     /* bogus priority, skip it */
-    if (action.getPriority() <= 0)
+    if (action.get_priority() <= 0)
       continue;
 
     /* action suspended, skip it */
-    if (action.suspended_ != Action::SuspendStates::not_suspended)
+    if (action.suspended_ != kernel::resource::Action::SuspendStates::not_suspended)
       continue;
 
-    sum_priority += 1.0 / action.getPriority();
+    sum_priority += 1.0 / action.get_priority();
   }
   sumPriority_ = sum_priority;
 
   for (CpuTiAction& action : actionSet_) {
     double min_finish = -1;
     /* action not running, skip it */
-    if (action.getStateSet() != surf_cpu_model_pm->getRunningActionSet())
+    if (action.get_state_set() != surf_cpu_model_pm->getRunningActionSet())
       continue;
 
     /* verify if the action is really running on cpu */
-    if (action.suspended_ == Action::SuspendStates::not_suspended && action.getPriority() > 0) {
+    if (action.suspended_ == kernel::resource::Action::SuspendStates::not_suspended && action.get_priority() > 0) {
       /* total area needed to finish the action. Used in trace integration */
-      total_area = (action.getRemains()) * sum_priority * action.getPriority();
+      total_area = (action.get_remains()) * sum_priority * action.get_priority();
 
       total_area /= speed_.peak;
 
-      action.setFinishTime(speedIntegratedTrace_->solve(now, total_area));
+      action.set_finish_time(speedIntegratedTrace_->solve(now, total_area));
       /* verify which event will happen before (max_duration or finish time) */
-      if (action.getMaxDuration() > NO_MAX_DURATION &&
-          action.getStartTime() + action.getMaxDuration() < action.getFinishTime())
-        min_finish = action.getStartTime() + action.getMaxDuration();
+      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.getFinishTime();
+        min_finish = action.get_finish_time();
     } else {
       /* put the max duration time on heap */
-      if (action.getMaxDuration() > NO_MAX_DURATION)
-        min_finish = action.getStartTime() + action.getMaxDuration();
+      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)
-      action.heapUpdate(model()->getActionHeap(), min_finish, Action::Type::NOTSET);
+      action.heapUpdate(min_finish, kernel::resource::Action::Type::NOTSET);
     else
-      action.heapRemove(model()->getActionHeap());
+      action.heapRemove();
 
     XBT_DEBUG("Update finish time: Cpu(%s) Action: %p, Start Time: %f Finish Time: %f Max duration %f", getCname(),
-              &action, action.getStartTime(), action.getFinishTime(), action.getMaxDuration());
+              &action, action.get_start_time(), action.get_finish_time(), action.get_max_duration());
   }
   /* remove from modified cpu */
   modified(false);
@@ -542,28 +540,28 @@ void CpuTi::updateRemainingAmount(double now)
   XBT_DEBUG("Flops total: %f, Last update %f", area_total, lastUpdate_);
   for (CpuTiAction& action : actionSet_) {
     /* action not running, skip it */
-    if (action.getStateSet() != model()->getRunningActionSet())
+    if (action.get_state_set() != model()->getRunningActionSet())
       continue;
 
     /* bogus priority, skip it */
-    if (action.getPriority() <= 0)
+    if (action.get_priority() <= 0)
       continue;
 
     /* action suspended, skip it */
-    if (action.suspended_ != Action::SuspendStates::not_suspended)
+    if (action.suspended_ != kernel::resource::Action::SuspendStates::not_suspended)
       continue;
 
     /* action don't need update */
-    if (action.getStartTime() >= now)
+    if (action.get_start_time() >= now)
       continue;
 
     /* skip action that are finishing now */
-    if (action.getFinishTime() >= 0 && action.getFinishTime() <= now)
+    if (action.get_finish_time() >= 0 && action.get_finish_time() <= now)
       continue;
 
     /* update remaining */
-    action.updateRemains(area_total / (sumPriority_ * action.getPriority()));
-    XBT_DEBUG("Update remaining action(%p) remaining %f", &action, action.getRemainsNoUpdate());
+    action.update_remains(area_total / (sumPriority_ * action.get_priority()));
+    XBT_DEBUG("Update remaining action(%p) remaining %f", &action, action.get_remains_no_update());
   }
   lastUpdate_ = now;
 }
@@ -588,13 +586,13 @@ CpuAction *CpuTi::sleep(double duration)
   XBT_IN("(%s,%g)", getCname(), duration);
   CpuTiAction* action = new CpuTiAction(static_cast<CpuTiModel*>(model()), 1.0, isOff(), this);
 
-  action->setMaxDuration(duration);
-  action->suspended_ = Action::SuspendStates::sleeping;
+  action->set_max_duration(duration);
+  action->suspended_ = kernel::resource::Action::SuspendStates::sleeping;
   if (duration == NO_MAX_DURATION) {
     /* Move to the *end* of the corresponding action set. This convention is used to speed up update_resource_state */
-    simgrid::xbt::intrusive_erase(*action->getStateSet(), *action);
-    action->stateSet_ = &static_cast<CpuTiModel*>(model())->runningActionSetThatDoesNotNeedBeingChecked_;
-    action->getStateSet()->push_back(*action);
+    simgrid::xbt::intrusive_erase(*action->get_state_set(), *action);
+    action->state_set_ = &static_cast<CpuTiModel*>(model())->runningActionSetThatDoesNotNeedBeingChecked_;
+    action->get_state_set()->push_back(*action);
   }
 
   actionSet_.push_back(*action);
@@ -625,35 +623,26 @@ CpuTiAction::CpuTiAction(CpuTiModel *model_, double cost, bool failed, CpuTi *cp
 {
   cpu_->modified(true);
 }
-
-void CpuTiAction::setState(Action::State state)
+CpuTiAction::~CpuTiAction()
 {
-  CpuAction::setState(state);
+  /* remove from action_set */
+  if (action_ti_hook.is_linked())
+    simgrid::xbt::intrusive_erase(cpu_->actionSet_, *this);
+  /* remove from heap */
+  heapRemove();
   cpu_->modified(true);
 }
 
-int CpuTiAction::unref()
+void CpuTiAction::set_state(Action::State state)
 {
-  refcount_--;
-  if (not refcount_) {
-    if (stateSetHook_.is_linked())
-      simgrid::xbt::intrusive_erase(*getStateSet(), *this);
-    /* remove from action_set */
-    if (action_ti_hook.is_linked())
-      simgrid::xbt::intrusive_erase(cpu_->actionSet_, *this);
-    /* remove from heap */
-    heapRemove(getModel()->getActionHeap());
-    cpu_->modified(true);
-    delete this;
-    return 1;
-  }
-  return 0;
+  CpuAction::set_state(state);
+  cpu_->modified(true);
 }
 
 void CpuTiAction::cancel()
 {
-  this->setState(Action::State::failed);
-  heapRemove(getModel()->getActionHeap());
+  this->set_state(Action::State::failed);
+  heapRemove();
   cpu_->modified(true);
 }
 
@@ -662,7 +651,7 @@ void CpuTiAction::suspend()
   XBT_IN("(%p)", this);
   if (suspended_ != Action::SuspendStates::sleeping) {
     suspended_ = Action::SuspendStates::suspended;
-    heapRemove(getModel()->getActionHeap());
+    heapRemove();
     cpu_->modified(true);
   }
   XBT_OUT();
@@ -678,40 +667,40 @@ void CpuTiAction::resume()
   XBT_OUT();
 }
 
-void CpuTiAction::setMaxDuration(double duration)
+void CpuTiAction::set_max_duration(double duration)
 {
   double min_finish;
 
   XBT_IN("(%p,%g)", this, duration);
 
-  Action::setMaxDuration(duration);
+  Action::set_max_duration(duration);
 
   if (duration >= 0)
-    min_finish = (getStartTime() + getMaxDuration()) < getFinishTime() ?
-                 (getStartTime() + getMaxDuration()) : getFinishTime();
+    min_finish = (get_start_time() + get_max_duration()) < get_finish_time() ? (get_start_time() + get_max_duration())
+                                                                             : get_finish_time();
   else
-    min_finish = getFinishTime();
+    min_finish = get_finish_time();
 
   /* add in action heap */
-  heapUpdate(getModel()->getActionHeap(), min_finish, Action::Type::NOTSET);
+  heapUpdate(min_finish, Action::Type::NOTSET);
 
   XBT_OUT();
 }
 
-void CpuTiAction::setSharingWeight(double priority)
+void CpuTiAction::set_priority(double priority)
 {
   XBT_IN("(%p,%g)", this, priority);
-  setSharingWeightNoUpdate(priority);
+  set_priority_no_update(priority);
   cpu_->modified(true);
   XBT_OUT();
 }
 
-double CpuTiAction::getRemains()
+double CpuTiAction::get_remains()
 {
   XBT_IN("(%p)", this);
   cpu_->updateRemainingAmount(surf_get_clock());
   XBT_OUT();
-  return getRemainsNoUpdate();
+  return get_remains_no_update();
 }
 
 }