-/* 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. */
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());
}
/* 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();
}
}
}
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);
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;
}
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);
{
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 (action_hook.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);
}
XBT_IN("(%p)", this);
if (suspended_ != Action::SuspendStates::sleeping) {
suspended_ = Action::SuspendStates::suspended;
- heapRemove(getModel()->getActionHeap());
+ heapRemove();
cpu_->modified(true);
}
XBT_OUT();
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();
}
}
