Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
rename the fields of CpuTi
[simgrid.git] / src / surf / cpu_ti.cpp
index ae2984e..724a9c5 100644 (file)
@@ -35,32 +35,32 @@ CpuTiTrace::CpuTiTrace(tmgr_trace_t speedTrace)
   double integral = 0;
   double time = 0;
   int i = 0;
-  p_timePoints = (double*) xbt_malloc0(sizeof(double) *
+  timePoints_ = (double*) xbt_malloc0(sizeof(double) *
                   (xbt_dynar_length(speedTrace->event_list) + 1));
-  p_integral = (double*) xbt_malloc0(sizeof(double) *
+  integral_ = (double*) xbt_malloc0(sizeof(double) *
                   (xbt_dynar_length(speedTrace->event_list) + 1));
-  m_nbPoints = xbt_dynar_length(speedTrace->event_list) + 1;
+  nbPoints_ = xbt_dynar_length(speedTrace->event_list) + 1;
   xbt_dynar_foreach(speedTrace->event_list, cpt, val) {
-    p_timePoints[i] = time;
-    p_integral[i] = integral;
+    timePoints_[i] = time;
+    integral_[i] = integral;
     integral += val.delta * val.value;
     time += val.delta;
     i++;
   }
-  p_timePoints[i] = time;
-  p_integral[i] = integral;
+  timePoints_[i] = time;
+  integral_[i] = integral;
 }
 
 CpuTiTrace::~CpuTiTrace()
 {
-  xbt_free(p_timePoints);
-  xbt_free(p_integral);
+  xbt_free(timePoints_);
+  xbt_free(integral_);
 }
 
 CpuTiTgmr::~CpuTiTgmr()
 {
-  if (p_trace)
-    delete p_trace;
+  if (trace_)
+    delete trace_;
 }
 
 /**
@@ -90,34 +90,34 @@ double CpuTiTgmr::integrate(double a, double b)
   if (a == b)
     return 0.0;
 
-  if (m_type == TRACE_FIXED) {
-    return ((b - a) * m_value);
+  if (type_ == TRACE_FIXED) {
+    return ((b - a) * value_);
   }
 
-  if (ceil(a / m_lastTime) == a / m_lastTime)
-    a_index = 1 + (int) (ceil(a / m_lastTime));
+  if (ceil(a / lastTime_) == a / lastTime_)
+    a_index = 1 + (int) (ceil(a / lastTime_));
   else
-    a_index = (int) (ceil(a / m_lastTime));
+    a_index = (int) (ceil(a / lastTime_));
 
-  b_index = (int) (floor(b / m_lastTime));
+  b_index = (int) (floor(b / lastTime_));
 
   if (a_index > b_index) {      /* Same chunk */
-    return p_trace->integrateSimple(a - (a_index -
-                                              1) * m_lastTime,
+    return trace_->integrateSimple(a - (a_index -
+                                              1) * lastTime_,
                                          b -
                                          (b_index) *
-                                         m_lastTime);
+                                         lastTime_);
   }
 
-  first_chunk = p_trace->integrateSimple(a - (a_index -
+  first_chunk = trace_->integrateSimple(a - (a_index -
                                                    1) *
-                                              m_lastTime,
-                                              m_lastTime);
-  middle_chunk = (b_index - a_index) * m_total;
-  last_chunk = p_trace->integrateSimple(0.0,
+                                              lastTime_,
+                                              lastTime_);
+  middle_chunk = (b_index - a_index) * total_;
+  last_chunk = trace_->integrateSimple(0.0,
                                              b -
                                              (b_index) *
-                                             m_lastTime);
+                                             lastTime_);
 
   XBT_DEBUG("first_chunk=%.2f  middle_chunk=%.2f  last_chunk=%.2f\n",
          first_chunk, middle_chunk, last_chunk);
@@ -139,24 +139,21 @@ double CpuTiTrace::integrateSimple(double a, double b)
 /**
  * \brief Auxiliary function to compute the integral at point a.
  * \param a        point
-*/
+ */
 double CpuTiTrace::integrateSimplePoint(double a)
 {
   double integral = 0;
   int ind;
   double a_aux = a;
-  ind = binarySearch(p_timePoints, a, 0, m_nbPoints - 1);
-  integral += p_integral[ind];
-  XBT_DEBUG
-      ("a %f ind %d integral %f ind + 1 %f ind %f time +1 %f time %f",
-       a, ind, integral, p_integral[ind + 1], p_integral[ind],
-       p_timePoints[ind + 1], p_timePoints[ind]);
-  double_update(&a_aux, p_timePoints[ind], sg_maxmin_precision*sg_surf_precision);
+  ind = binarySearch(timePoints_, a, 0, nbPoints_ - 1);
+  integral += integral_[ind];
+  XBT_DEBUG("a %f ind %d integral %f ind + 1 %f ind %f time +1 %f time %f",
+       a, ind, integral, integral_[ind + 1], integral_[ind],
+       timePoints_[ind + 1], timePoints_[ind]);
+  double_update(&a_aux, timePoints_[ind], sg_maxmin_precision*sg_surf_precision);
   if (a_aux > 0)
-    integral +=
-        ((p_integral[ind + 1] -
-          p_integral[ind]) / (p_timePoints[ind + 1] -
-                              p_timePoints[ind])) * (a - p_timePoints[ind]);
+    integral +=((integral_[ind + 1] -
+          integral_[ind]) / (timePoints_[ind + 1] - timePoints_[ind])) * (a - timePoints_[ind]);
   XBT_DEBUG("Integral a %f = %f", a, integral);
 
   return integral;
@@ -167,7 +164,6 @@ double CpuTiTrace::integrateSimplePoint(double a)
 *
 * Here, amount can span multiple trace periods
 *
-* \param trace   CPU trace structure
 * \param a        Initial time
 * \param amount  Amount to be executed
 * \return  End time
@@ -202,16 +198,16 @@ double CpuTiTgmr::solve(double a, double amount)
     return a;
 
 /* Is the trace fixed ? */
-  if (m_type == TRACE_FIXED) {
-    return (a + (amount / m_value));
+  if (type_ == TRACE_FIXED) {
+    return (a + (amount / value_));
   }
 
-  XBT_DEBUG("amount %f total %f", amount, m_total);
+  XBT_DEBUG("amount %f total %f", amount, total_);
 /* Reduce the problem to one where amount <= trace_total */
-  quotient = (int) (floor(amount / m_total));
-  reduced_amount = (m_total) * ((amount / m_total) -
-                                     floor(amount / m_total));
-  reduced_a = a - (m_lastTime) * (int) (floor(a / m_lastTime));
+  quotient = (int) (floor(amount / total_));
+  reduced_amount = (total_) * ((amount / total_) -
+                                     floor(amount / total_));
+  reduced_a = a - (lastTime_) * (int) (floor(a / lastTime_));
 
   XBT_DEBUG("Quotient: %d reduced_amount: %f reduced_a: %f", quotient,
          reduced_amount, reduced_a);
@@ -224,8 +220,8 @@ double CpuTiTgmr::solve(double a, double amount)
   reduced_b = solveSomewhatSimple(reduced_a, reduced_amount);
 
 /* Re-map to the original b and amount */
-  b = (m_lastTime) * (int) (floor(a / m_lastTime)) +
-      (quotient * m_lastTime) + reduced_b;
+  b = (lastTime_) * (int) (floor(a / lastTime_)) +
+      (quotient * lastTime_) + reduced_b;
   return b;
 }
 
@@ -242,15 +238,15 @@ double CpuTiTgmr::solveSomewhatSimple(double a, double amount)
   double b;
 
   XBT_DEBUG("Solve integral: [%.2f, amount=%.2f]", a, amount);
-  amount_till_end = integrate(a, m_lastTime);
+  amount_till_end = integrate(a, lastTime_);
 /*
    fprintf(stderr,"amount_till_end=%.2f\n",amount_till_end);
  */
 
   if (amount_till_end > amount) {
-    b = p_trace->solveSimple(a, amount);
+    b = trace_->solveSimple(a, amount);
   } else {
-    b = m_lastTime + p_trace->solveSimple(0.0, amount - amount_till_end);
+    b = lastTime_ + trace_->solveSimple(0.0, amount - amount_till_end);
   }
   return b;
 }
@@ -269,14 +265,14 @@ double CpuTiTrace::solveSimple(double a, double amount)
   int ind;
   double time;
   integral_a = integrateSimplePoint(a);
-  ind = binarySearch(p_integral, integral_a + amount, 0, m_nbPoints - 1);
-  time = p_timePoints[ind];
+  ind = binarySearch(integral_, integral_a + amount, 0, nbPoints_ - 1);
+  time = timePoints_[ind];
   time +=
       (integral_a + amount -
-       p_integral[ind]) / ((p_integral[ind + 1] -
-                                 p_integral[ind]) /
-                                (p_timePoints[ind + 1] -
-                                 p_timePoints[ind]));
+       integral_[ind]) / ((integral_[ind + 1] -
+                                 integral_[ind]) /
+                                (timePoints_[ind + 1] -
+                                 timePoints_[ind]));
 
   return time;
 }
@@ -295,10 +291,10 @@ double CpuTiTgmr::getPowerScale(double a)
   int point;
   s_tmgr_event_t val;
 
-  reduced_a = a - floor(a / m_lastTime) * m_lastTime;
-  point = p_trace->binarySearch(p_trace->p_timePoints, reduced_a, 0,
-                                p_trace->m_nbPoints - 1);
-  xbt_dynar_get_cpy(p_speedTrace->event_list, point, &val);
+  reduced_a = a - floor(a / lastTime_) * lastTime_;
+  point = trace_->binarySearch(trace_->timePoints_, reduced_a, 0,
+                                trace_->nbPoints_ - 1);
+  xbt_dynar_get_cpy(speedTrace_->event_list, point, &val);
   return val.value;
 }
 
@@ -315,12 +311,12 @@ CpuTiTgmr::CpuTiTgmr(tmgr_trace_t speedTrace, double value)
   double total_time = 0.0;
   s_tmgr_event_t val;
   unsigned int cpt;
-  p_trace = 0;
+  trace_ = 0;
 
 /* no availability file, fixed trace */
   if (!speedTrace) {
-    m_type = TRACE_FIXED;
-    m_value = value;
+    type_ = TRACE_FIXED;
+    value_ = value;
     XBT_DEBUG("No availability trace. Constant value = %f", value);
     return;
   }
@@ -328,24 +324,24 @@ CpuTiTgmr::CpuTiTgmr(tmgr_trace_t speedTrace, double value)
   /* only one point available, fixed trace */
   if (xbt_dynar_length(speedTrace->event_list) == 1) {
     xbt_dynar_get_cpy(speedTrace->event_list, 0, &val);
-    m_type = TRACE_FIXED;
-    m_value = val.value;
+    type_ = TRACE_FIXED;
+    value_ = val.value;
     return;
   }
 
-  m_type = TRACE_DYNAMIC;
-  p_speedTrace = speedTrace;
+  type_ = TRACE_DYNAMIC;
+  speedTrace_ = speedTrace;
 
   /* count the total time of trace file */
   xbt_dynar_foreach(speedTrace->event_list, cpt, val) {
     total_time += val.delta;
   }
-  p_trace = new CpuTiTrace(speedTrace);
-  m_lastTime = total_time;
-  m_total = p_trace->integrateSimple(0, total_time);
+  trace_ = new CpuTiTrace(speedTrace);
+  lastTime_ = total_time;
+  total_ = trace_->integrateSimple(0, total_time);
 
   XBT_DEBUG("Total integral %f, last_time %f ",
-            m_total, m_lastTime);
+            total_, lastTime_);
 }
 
 /**
@@ -402,21 +398,21 @@ namespace surf {
 
 CpuTiModel::CpuTiModel() : CpuModel()
 {
-  p_runningActionSetThatDoesNotNeedBeingChecked = new ActionList();
+  runningActionSetThatDoesNotNeedBeingChecked_ = new ActionList();
 
-  p_modifiedCpu = new CpuTiList();
+  modifiedCpu_ = new CpuTiList();
 
-  p_tiActionHeap = xbt_heap_new(8, NULL);
-  xbt_heap_set_update_callback(p_tiActionHeap,
+  tiActionHeap_ = xbt_heap_new(8, NULL);
+  xbt_heap_set_update_callback(tiActionHeap_,
                                cpu_ti_action_update_index_heap);
 }
 
 CpuTiModel::~CpuTiModel()
 {
   surf_cpu_model_pm = NULL;
-  delete p_runningActionSetThatDoesNotNeedBeingChecked;
-  delete p_modifiedCpu;
-  xbt_heap_free(p_tiActionHeap);
+  delete runningActionSetThatDoesNotNeedBeingChecked_;
+  delete modifiedCpu_;
+  xbt_heap_free(tiActionHeap_);
 }
 
 Cpu *CpuTiModel::createCpu(simgrid::s4u::Host *host,
@@ -441,7 +437,7 @@ double CpuTiModel::next_occuring_event(double now)
   double min_action_duration = -1;
 
 /* iterates over modified cpus to update share resources */
-  for(CpuTiList::iterator it(p_modifiedCpu->begin()), itend(p_modifiedCpu->end())
+  for(CpuTiList::iterator it(modifiedCpu_->begin()), itend(modifiedCpu_->end())
      ; it != itend ;) {
     CpuTi *ti = &*it;
     ++it;
@@ -449,8 +445,8 @@ double CpuTiModel::next_occuring_event(double now)
   }
 
 /* get the min next event if heap not empty */
-  if (xbt_heap_size(p_tiActionHeap) > 0)
-    min_action_duration = xbt_heap_maxkey(p_tiActionHeap) - now;
+  if (xbt_heap_size(tiActionHeap_) > 0)
+    min_action_duration = xbt_heap_maxkey(tiActionHeap_) - now;
 
   XBT_DEBUG("Share resources, min next event date: %f", min_action_duration);
 
@@ -459,16 +455,16 @@ double CpuTiModel::next_occuring_event(double now)
 
 void CpuTiModel::updateActionsState(double now, double /*delta*/)
 {
-  while ((xbt_heap_size(p_tiActionHeap) > 0)
-         && (xbt_heap_maxkey(p_tiActionHeap) <= now)) {
-    CpuTiAction *action = (CpuTiAction*) xbt_heap_pop(p_tiActionHeap);
+  while ((xbt_heap_size(tiActionHeap_) > 0)
+         && (xbt_heap_maxkey(tiActionHeap_) <= now)) {
+    CpuTiAction *action = (CpuTiAction*) xbt_heap_pop(tiActionHeap_);
     XBT_DEBUG("Action %p: finish", action);
     action->finish();
     /* set the remains to 0 due to precision problems when updating the remaining amount */
     action->setRemains(0);
     action->setState(SURF_ACTION_DONE);
     /* update remaining amount of all actions */
-    action->p_cpu->updateRemainingAmount(surf_get_clock());
+    action->cpu_->updateRemainingAmount(surf_get_clock());
   }
 }
 
@@ -484,9 +480,9 @@ CpuTi::CpuTi(CpuTiModel *model, simgrid::s4u::Host *host, xbt_dynar_t speedPeak,
   m_core = core;
 
   p_speed.scale = speedScale;
-  p_availTrace = new CpuTiTgmr(speedTrace, speedScale);
+  availTrace_ = new CpuTiTgmr(speedTrace, speedScale);
 
-  p_actionSet = new ActionTiList();
+  actionSet_ = new ActionTiList();
 
   xbt_dynar_get_cpy(speedPeak, 0, &p_speed.peak);
   XBT_DEBUG("CPU create: peak=%f", p_speed.peak);
@@ -501,7 +497,7 @@ CpuTi::CpuTi(CpuTiModel *model, simgrid::s4u::Host *host, xbt_dynar_t speedPeak,
                       xbt_dynar_length(speedTrace->event_list) - 1, &val);
     if (val.delta == 0) {
       p_speed.event =
-          future_evt_set->add_trace(tmgr_empty_trace_new(), p_availTrace->m_lastTime, this);
+          future_evt_set->add_trace(tmgr_empty_trace_new(), availTrace_->lastTime_, this);
     }
   }
 }
@@ -509,15 +505,15 @@ CpuTi::CpuTi(CpuTiModel *model, simgrid::s4u::Host *host, xbt_dynar_t speedPeak,
 CpuTi::~CpuTi()
 {
   modified(false);
-  delete p_availTrace;
-  delete p_actionSet;
+  delete availTrace_;
+  delete actionSet_;
 }
 void CpuTi::set_speed_trace(tmgr_trace_t trace)
 {
-  if (p_availTrace)
-    delete p_availTrace;
+  if (availTrace_)
+    delete availTrace_;
 
-  p_availTrace = new CpuTiTgmr(trace, p_speed.scale);
+  availTrace_ = new CpuTiTgmr(trace, p_speed.scale);
 
   /* add a fake trace event if periodicity == 0 */
   if (trace && xbt_dynar_length(trace->event_list) > 1) {
@@ -541,17 +537,15 @@ void CpuTi::apply_event(tmgr_trace_iterator_t event, double value)
 
     modified(true);
 
-    speedTrace = p_availTrace->p_speedTrace;
-    xbt_dynar_get_cpy(speedTrace->event_list,
-                      xbt_dynar_length(speedTrace->event_list) - 1, &val);
-    /* free old trace */
-    delete p_availTrace;
+    speedTrace = availTrace_->speedTrace_;
+    xbt_dynar_get_cpy(speedTrace->event_list, xbt_dynar_length(speedTrace->event_list) - 1, &val);
+    delete availTrace_;
     p_speed.scale = val.value;
 
     trace = new CpuTiTgmr(TRACE_FIXED, val.value);
     XBT_DEBUG("value %f", val.value);
 
-    p_availTrace = trace;
+    availTrace_ = trace;
 
     tmgr_trace_event_unref(&p_speed.event);
 
@@ -565,7 +559,7 @@ void CpuTi::apply_event(tmgr_trace_iterator_t event, double value)
       double date = surf_get_clock();
 
       /* put all action running on cpu to failed */
-      for(ActionTiList::iterator it(p_actionSet->begin()), itend(p_actionSet->end())
+      for(ActionTiList::iterator it(actionSet_->begin()), itend(actionSet_->end())
           ; it != itend ; ++it) {
 
         CpuTiAction *action = &*it;
@@ -574,9 +568,9 @@ void CpuTi::apply_event(tmgr_trace_iterator_t event, double value)
          || action->getState() == SURF_ACTION_NOT_IN_THE_SYSTEM) {
           action->setFinishTime(date);
           action->setState(SURF_ACTION_FAILED);
-          if (action->m_indexHeap >= 0) {
+          if (action->indexHeap_ >= 0) {
             CpuTiAction *heap_act = (CpuTiAction*)
-                xbt_heap_remove(static_cast<CpuTiModel*>(getModel())->p_tiActionHeap, action->m_indexHeap);
+                xbt_heap_remove(static_cast<CpuTiModel*>(getModel())->tiActionHeap_, action->indexHeap_);
             if (heap_act != action)
               DIE_IMPOSSIBLE;
           }
@@ -598,12 +592,10 @@ void CpuTi::updateActionsFinishTime(double now)
   /* update remaining amount of actions */
   updateRemainingAmount(now);
 
-  for(ActionTiList::iterator it(p_actionSet->begin()), itend(p_actionSet->end())
-      ; it != itend ; ++it) {
+  for(ActionTiList::iterator it(actionSet_->begin()), itend(actionSet_->end()) ; it != itend ; ++it) {
     action = &*it;
     /* action not running, skip it */
-    if (action->getStateSet() !=
-        surf_cpu_model_pm->getRunningActionSet())
+    if (action->getStateSet() != surf_cpu_model_pm->getRunningActionSet())
       continue;
 
     /* bogus priority, skip it */
@@ -611,15 +603,14 @@ void CpuTi::updateActionsFinishTime(double now)
       continue;
 
     /* action suspended, skip it */
-    if (action->m_suspended != 0)
+    if (action->suspended_ != 0)
       continue;
 
     sum_priority += 1.0 / action->getPriority();
   }
-  m_sumPriority = sum_priority;
+  sumPriority_ = sum_priority;
 
-  for(ActionTiList::iterator it(p_actionSet->begin()), itend(p_actionSet->end())
-     ; it != itend ; ++it) {
+  for(ActionTiList::iterator it(actionSet_->begin()), itend(actionSet_->end()) ; it != itend ; ++it) {
     action = &*it;
     min_finish = -1;
     /* action not running, skip it */
@@ -628,7 +619,7 @@ void CpuTi::updateActionsFinishTime(double now)
       continue;
 
     /* verify if the action is really running on cpu */
-    if (action->m_suspended == 0 && action->getPriority() > 0) {
+    if (action->suspended_ == 0 && action->getPriority() > 0) {
       /* total area needed to finish the action. Used in trace integration */
       total_area =
           (action->getRemains()) * sum_priority *
@@ -636,7 +627,7 @@ void CpuTi::updateActionsFinishTime(double now)
 
       total_area /= p_speed.peak;
 
-      action->setFinishTime(p_availTrace->solve(now, total_area));
+      action->setFinishTime(availTrace_->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->m_finish)
@@ -649,15 +640,15 @@ void CpuTi::updateActionsFinishTime(double now)
         min_finish = action->getStartTime() + action->getMaxDuration();
     }
     /* add in action heap */
-    XBT_DEBUG("action(%p) index %d", action, action->m_indexHeap);
-    if (action->m_indexHeap >= 0) {
+    XBT_DEBUG("action(%p) index %d", action, action->indexHeap_);
+    if (action->indexHeap_ >= 0) {
       CpuTiAction *heap_act = (CpuTiAction*)
-          xbt_heap_remove(static_cast<CpuTiModel*>(getModel())->p_tiActionHeap, action->m_indexHeap);
+          xbt_heap_remove(static_cast<CpuTiModel*>(getModel())->tiActionHeap_, action->indexHeap_);
       if (heap_act != action)
         DIE_IMPOSSIBLE;
     }
     if (min_finish != NO_MAX_DURATION)
-      xbt_heap_push(static_cast<CpuTiModel*>(getModel())->p_tiActionHeap, action, min_finish);
+      xbt_heap_push(static_cast<CpuTiModel*>(getModel())->tiActionHeap_, action, min_finish);
 
     XBT_DEBUG
         ("Update finish time: Cpu(%s) Action: %p, Start Time: %f Finish Time: %f Max duration %f",
@@ -671,36 +662,31 @@ void CpuTi::updateActionsFinishTime(double now)
 
 bool CpuTi::isUsed()
 {
-  return !p_actionSet->empty();
+  return !actionSet_->empty();
 }
 
 double CpuTi::getAvailableSpeed()
 {
-  p_speed.scale = p_availTrace->getPowerScale(surf_get_clock());
+  p_speed.scale = availTrace_->getPowerScale(surf_get_clock());
   return Cpu::getAvailableSpeed();
 }
 
 /** @brief Update the remaining amount of actions */
 void CpuTi::updateRemainingAmount(double now)
 {
-  double area_total;
-  CpuTiAction *action;
 
   /* already updated */
-  if (m_lastUpdate >= now)
+  if (lastUpdate_ >= now)
     return;
 
   /* compute the integration area */
-  area_total = p_availTrace->integrate(m_lastUpdate, now) * p_speed.peak;
-  XBT_DEBUG("Flops total: %f, Last update %f", area_total,
-         m_lastUpdate);
+  double area_total = availTrace_->integrate(lastUpdate_, now) * p_speed.peak;
+  XBT_DEBUG("Flops total: %f, Last update %f", area_total, lastUpdate_);
 
-  for(ActionTiList::iterator it(p_actionSet->begin()), itend(p_actionSet->end())
-     ; it != itend ; ++it) {
-    action = &*it;
+  for(ActionTiList::iterator it(actionSet_->begin()), itend(actionSet_->end()) ; it != itend ; ++it) {
+    CpuTiAction *action = &*it;
     /* action not running, skip it */
-    if (action->getStateSet() !=
-        getModel()->getRunningActionSet())
+    if (action->getStateSet() != getModel()->getRunningActionSet())
       continue;
 
     /* bogus priority, skip it */
@@ -708,7 +694,7 @@ void CpuTi::updateRemainingAmount(double now)
       continue;
 
     /* action suspended, skip it */
-    if (action->m_suspended != 0)
+    if (action->suspended_ != 0)
       continue;
 
     /* action don't need update */
@@ -716,16 +702,14 @@ void CpuTi::updateRemainingAmount(double now)
       continue;
 
     /* skip action that are finishing now */
-    if (action->m_finish >= 0
-        && action->m_finish <= now)
+    if (action->m_finish >= 0 && action->m_finish <= now)
       continue;
 
     /* update remaining */
-    action->updateRemains(area_total / (m_sumPriority * action->getPriority()));
-    XBT_DEBUG("Update remaining action(%p) remaining %f", action,
-           action->m_remains);
+    action->updateRemains(area_total / (sumPriority_ * action->getPriority()));
+    XBT_DEBUG("Update remaining action(%p) remaining %f", action, action->m_remains);
   }
-  m_lastUpdate = now;
+  lastUpdate_ = now;
 }
 
 CpuAction *CpuTi::execution_start(double size)
@@ -733,7 +717,7 @@ CpuAction *CpuTi::execution_start(double size)
   XBT_IN("(%s,%g)", getName(), size);
   CpuTiAction *action = new CpuTiAction(static_cast<CpuTiModel*>(getModel()), size, isOff(), this);
 
-  p_actionSet->push_back(*action);
+  actionSet_->push_back(*action);
 
   XBT_OUT();
   return action;
@@ -749,23 +733,23 @@ CpuAction *CpuTi::sleep(double duration)
   CpuTiAction *action = new CpuTiAction(static_cast<CpuTiModel*>(getModel()), 1.0, isOff(), this);
 
   action->m_maxDuration = duration;
-  action->m_suspended = 2;
+  action->suspended_ = 2;
   if (duration == NO_MAX_DURATION) {
    /* Move to the *end* of the corresponding action set. This convention
       is used to speed up update_resource_state  */
   action->getStateSet()->erase(action->getStateSet()->iterator_to(*action));
-    action->p_stateSet = static_cast<CpuTiModel*>(getModel())->p_runningActionSetThatDoesNotNeedBeingChecked;
+    action->p_stateSet = static_cast<CpuTiModel*>(getModel())->runningActionSetThatDoesNotNeedBeingChecked_;
     action->getStateSet()->push_back(*action);
   }
 
-  p_actionSet->push_back(*action);
+  actionSet_->push_back(*action);
 
   XBT_OUT();
   return action;
 }
 
 void CpuTi::modified(bool modified){
-  CpuTiList *modifiedCpu = static_cast<CpuTiModel*>(getModel())->p_modifiedCpu;
+  CpuTiList *modifiedCpu = static_cast<CpuTiModel*>(getModel())->modifiedCpu_;
   if (modified) {
     if (!cpu_ti_hook.is_linked()) {
       modifiedCpu->push_back(*this);
@@ -781,24 +765,23 @@ void CpuTi::modified(bool modified){
  * Action *
  **********/
 
-CpuTiAction::CpuTiAction(CpuTiModel *model_, double cost, bool failed,
-                     CpuTi *cpu)
+CpuTiAction::CpuTiAction(CpuTiModel *model_, double cost, bool failed, CpuTi *cpu)
  : CpuAction(model_, cost, failed)
 {
-  p_cpu = cpu;
-  m_indexHeap = -1;
-  p_cpu->modified(true);
+  cpu_ = cpu;
+  indexHeap_ = -1;
+  cpu_->modified(true);
 }
 
 void CpuTiAction::updateIndexHeap(int i)
 {
-  m_indexHeap = i;
+  indexHeap_ = i;
 }
 
 void CpuTiAction::setState(e_surf_action_state_t state)
 {
   CpuAction::setState(state);
-  p_cpu->modified(true);
+  cpu_->modified(true);
 }
 
 int CpuTiAction::unref()
@@ -809,10 +792,10 @@ int CpuTiAction::unref()
       getStateSet()->erase(getStateSet()->iterator_to(*this));
     /* remove from action_set */
     if (action_ti_hook.is_linked())
-      p_cpu->p_actionSet->erase(p_cpu->p_actionSet->iterator_to(*this));
+      cpu_->actionSet_->erase(cpu_->actionSet_->iterator_to(*this));
     /* remove from heap */
-    xbt_heap_remove(static_cast<CpuTiModel*>(getModel())->p_tiActionHeap, this->m_indexHeap);
-    p_cpu->modified(true);
+    xbt_heap_remove(static_cast<CpuTiModel*>(getModel())->tiActionHeap_, this->indexHeap_);
+    cpu_->modified(true);
     delete this;
     return 1;
   }
@@ -822,18 +805,18 @@ int CpuTiAction::unref()
 void CpuTiAction::cancel()
 {
   this->setState(SURF_ACTION_FAILED);
-  xbt_heap_remove(getModel()->getActionHeap(), this->m_indexHeap);
-  p_cpu->modified(true);
+  xbt_heap_remove(getModel()->getActionHeap(), this->indexHeap_);
+  cpu_->modified(true);
   return;
 }
 
 void CpuTiAction::suspend()
 {
   XBT_IN("(%p)", this);
-  if (m_suspended != 2) {
-    m_suspended = 1;
-    xbt_heap_remove(getModel()->getActionHeap(), m_indexHeap);
-    p_cpu->modified(true);
+  if (suspended_ != 2) {
+    suspended_ = 1;
+    xbt_heap_remove(getModel()->getActionHeap(), indexHeap_);
+    cpu_->modified(true);
   }
   XBT_OUT();
 }
@@ -841,9 +824,9 @@ void CpuTiAction::suspend()
 void CpuTiAction::resume()
 {
   XBT_IN("(%p)", this);
-  if (m_suspended != 2) {
-    m_suspended = 0;
-    p_cpu->modified(true);
+  if (suspended_ != 2) {
+    suspended_ = 0;
+    cpu_->modified(true);
   }
   XBT_OUT();
 }
@@ -863,9 +846,9 @@ void CpuTiAction::setMaxDuration(double duration)
     min_finish = getFinishTime();
 
 /* add in action heap */
-  if (m_indexHeap >= 0) {
+  if (indexHeap_ >= 0) {
     CpuTiAction *heap_act = (CpuTiAction*)
-        xbt_heap_remove(getModel()->getActionHeap(), m_indexHeap);
+        xbt_heap_remove(getModel()->getActionHeap(), indexHeap_);
     if (heap_act != this)
       DIE_IMPOSSIBLE;
   }
@@ -878,14 +861,14 @@ void CpuTiAction::setPriority(double priority)
 {
   XBT_IN("(%p,%g)", this, priority);
   m_priority = priority;
-  p_cpu->modified(true);
+  cpu_->modified(true);
   XBT_OUT();
 }
 
 double CpuTiAction::getRemains()
 {
   XBT_IN("(%p)", this);
-  p_cpu->updateRemainingAmount(surf_get_clock());
+  cpu_->updateRemainingAmount(surf_get_clock());
   XBT_OUT();
   return m_remains;
 }