X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/499ee6ecf7dd2ec57ed57613da3ea947d42de781..eecf563b3a3a0333dac9f754fe11f047c99cd27d:/src/surf/cpu_ti.cpp diff --git a/src/surf/cpu_ti.cpp b/src/surf/cpu_ti.cpp index 7df39bf75d..d15f1d2d58 100644 --- a/src/surf/cpu_ti.cpp +++ b/src/surf/cpu_ti.cpp @@ -4,9 +4,9 @@ * under the terms of the license (GNU LGPL) which comes with this package. */ #include "cpu_ti.hpp" +#include "src/surf/surf_interface.hpp" #include "src/surf/trace_mgr.hpp" -#include "xbt/utility.hpp" -#include +#include "surf/surf.hpp" #ifndef SURF_MODEL_CPUTI_H_ #define SURF_MODEL_CPUTI_H_ @@ -45,10 +45,9 @@ CpuTiTrace::~CpuTiTrace() delete [] integral_; } -CpuTiTgmr::~CpuTiTgmr() +CpuTiTmgr::~CpuTiTmgr() { - if (trace_) - delete trace_; + delete trace_; } /** @@ -61,7 +60,7 @@ CpuTiTgmr::~CpuTiTgmr() * \param b End of interval * \return the integrate value. -1 if an error occurs. */ -double CpuTiTgmr::integrate(double a, double b) +double CpuTiTmgr::integrate(double a, double b) { int a_index; @@ -138,7 +137,7 @@ double CpuTiTrace::integrate_simple_point(double a) * \param amount Amount to be executed * \return End time */ -double CpuTiTgmr::solve(double a, double amount) +double CpuTiTmgr::solve(double a, double amount) { /* Fix very small negative numbers */ if ((a < 0.0) && (a > -EPSILON)) { @@ -212,7 +211,7 @@ double CpuTiTrace::solve_simple(double a, double amount) * \param a Time * \return CPU speed scale */ -double CpuTiTgmr::get_power_scale(double a) +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); @@ -221,19 +220,19 @@ double CpuTiTgmr::get_power_scale(double a) } /** -* \brief Creates a new integration trace from a tmgr_trace_t -* -* \param speedTrace CPU availability trace -* \param value Percentage of CPU speed available (useful to fixed tracing) -* \return Integration trace structure -*/ -CpuTiTgmr::CpuTiTgmr(tmgr_trace_t speedTrace, double value) : speed_trace_(speedTrace) + * \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 + */ +CpuTiTmgr::CpuTiTmgr(tmgr_trace_t speed_trace, double value) : speed_trace_(speed_trace) { double total_time = 0.0; trace_ = 0; -/* no availability file, fixed trace */ - if (not speedTrace) { + /* no availability file, fixed trace */ + if (not speed_trace) { type_ = TRACE_FIXED; value_ = value; XBT_DEBUG("No availability trace. Constant value = %f", value); @@ -241,22 +240,21 @@ CpuTiTgmr::CpuTiTgmr(tmgr_trace_t speedTrace, double value) : speed_trace_(speed } /* only one point available, fixed trace */ - if (speedTrace->event_list.size() == 1) { - trace_mgr::DatedValue val = speedTrace->event_list.front(); - type_ = TRACE_FIXED; - value_ = val.value_; + if (speed_trace->event_list.size() == 1) { + type_ = TRACE_FIXED; + value_ = speed_trace->event_list.front().value_; return; } type_ = TRACE_DYNAMIC; /* count the total time of trace file */ - for (auto const& val : speedTrace->event_list) + for (auto const& val : speed_trace->event_list) total_time += val.date_; - trace_ = new CpuTiTrace(speedTrace); + trace_ = new CpuTiTrace(speed_trace); last_time_ = total_time; - total_ = trace_->integrate_simple(0, total_time); + total_ = trace_->integrate_simple(0, total_time); XBT_DEBUG("Total integral %f, last_time %f ", total_, last_time_); } @@ -326,14 +324,14 @@ double CpuTiModel::next_occuring_event(double now) /* iterates over modified cpus to update share resources */ for (auto it = std::begin(modified_cpus_); it != std::end(modified_cpus_);) { - CpuTi& ti = *it; - ++it; // increment iterator here since the following call to ti.updateActionsFinishTime() may invalidate it - ti.update_actions_finish_time(now); + CpuTi& cpu = *it; + ++it; // increment iterator here since the following call to ti.update_actions_finish_time() may invalidate it + cpu.update_actions_finish_time(now); } /* get the min next event if heap not empty */ if (not get_action_heap().empty()) - min_action_duration = actionHeapTopDate() - now; + min_action_duration = get_action_heap().top_date() - now; XBT_DEBUG("Share resources, min next event date: %f", min_action_duration); @@ -342,10 +340,10 @@ double CpuTiModel::next_occuring_event(double now) void CpuTiModel::update_actions_state(double now, double /*delta*/) { - while (not get_action_heap().empty() && actionHeapTopDate() <= now) { - CpuTiAction* action = static_cast(actionHeapPop()); + while (not get_action_heap().empty() && double_equals(get_action_heap().top_date(), now, sg_surf_precision)) { + CpuTiAction* action = static_cast(get_action_heap().pop()); XBT_DEBUG("Action %p: finish", action); - action->finish(kernel::resource::Action::State::done); + action->finish(kernel::resource::Action::State::FINISHED); /* update remaining amount of all actions */ action->cpu_->update_remaining_amount(surf_get_clock()); } @@ -362,7 +360,7 @@ CpuTi::CpuTi(CpuTiModel *model, simgrid::s4u::Host *host, std::vector *s speed_.peak = speedPerPstate->front(); XBT_DEBUG("CPU create: peak=%f", speed_.peak); - speed_integrated_trace_ = new CpuTiTgmr(nullptr, 1 /*scale*/); + speed_integrated_trace_ = new CpuTiTmgr(nullptr, 1 /*scale*/); } CpuTi::~CpuTi() @@ -372,10 +370,8 @@ CpuTi::~CpuTi() } void CpuTi::set_speed_trace(tmgr_trace_t trace) { - if (speed_integrated_trace_) - delete speed_integrated_trace_; - - speed_integrated_trace_ = new CpuTiTgmr(trace, speed_.scale); + delete speed_integrated_trace_; + speed_integrated_trace_ = new CpuTiTmgr(trace, speed_.scale); /* add a fake trace event if periodicity == 0 */ if (trace && trace->event_list.size() > 1) { @@ -388,21 +384,18 @@ void CpuTi::set_speed_trace(tmgr_trace_t trace) void CpuTi::apply_event(tmgr_trace_event_t event, double value) { if (event == speed_.event) { - tmgr_trace_t speedTrace; - CpuTiTgmr *trace; - XBT_DEBUG("Finish trace date: value %f", value); /* update remaining of actions and put in modified cpu list */ update_remaining_amount(surf_get_clock()); set_modified(true); - speedTrace = speed_integrated_trace_->speed_trace_; + tmgr_trace_t speedTrace = speed_integrated_trace_->speed_trace_; trace_mgr::DatedValue val = speedTrace->event_list.back(); delete speed_integrated_trace_; speed_.scale = val.value_; - trace = new CpuTiTgmr(TRACE_FIXED, val.value_); + CpuTiTmgr* trace = new CpuTiTmgr(TRACE_FIXED, val.value_); XBT_DEBUG("value %f", val.value_); speed_integrated_trace_ = trace; @@ -411,21 +404,21 @@ void CpuTi::apply_event(tmgr_trace_event_t event, double value) } else if (event == stateEvent_) { if (value > 0) { - if(isOff()) + if (is_off()) host_that_restart.push_back(getHost()); - turnOn(); + turn_on(); } else { - turnOff(); + turn_off(); double date = surf_get_clock(); /* put all action running on cpu to failed */ for (CpuTiAction& action : action_set_) { - 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) { + 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) { action.set_finish_time(date); - action.set_state(kernel::resource::Action::State::failed); - action.heapRemove(); + action.set_state(kernel::resource::Action::State::FAILED); + get_model()->get_action_heap().remove(&action); } } } @@ -446,7 +439,7 @@ void CpuTi::update_actions_finish_time(double now) sum_priority_ = 0.0; for (CpuTiAction const& action : action_set_) { /* action not running, skip it */ - if (action.get_state_set() != surf_cpu_model_pm->get_running_action_set()) + if (action.get_state_set() != surf_cpu_model_pm->get_started_action_set()) continue; /* bogus priority, skip it */ @@ -463,7 +456,7 @@ void CpuTi::update_actions_finish_time(double now) for (CpuTiAction& action : action_set_) { double min_finish = -1; /* action not running, skip it */ - if (action.get_state_set() != surf_cpu_model_pm->get_running_action_set()) + if (action.get_state_set() != surf_cpu_model_pm->get_started_action_set()) continue; /* verify if the action is really running on cpu */ @@ -485,11 +478,11 @@ void CpuTi::update_actions_finish_time(double now) } /* add in action heap */ if (min_finish > NO_MAX_DURATION) - action.heapUpdate(min_finish, kernel::resource::Action::Type::unset); + get_model()->get_action_heap().update(&action, min_finish, kernel::resource::ActionHeap::Type::unset); else - action.heapRemove(); + get_model()->get_action_heap().remove(&action); - XBT_DEBUG("Update finish time: Cpu(%s) Action: %p, Start Time: %f Finish Time: %f Max duration %f", getCname(), + XBT_DEBUG("Update finish time: Cpu(%s) Action: %p, Start Time: %f Finish Time: %f Max duration %f", get_cname(), &action, action.get_start_time(), action.get_finish_time(), action.get_max_duration()); } /* remove from modified cpu */ @@ -520,7 +513,7 @@ void CpuTi::update_remaining_amount(double now) XBT_DEBUG("Flops total: %f, Last update %f", area_total, last_update_); for (CpuTiAction& action : action_set_) { /* action not running, skip it */ - if (action.get_state_set() != model()->get_running_action_set()) + if (action.get_state_set() != get_model()->get_started_action_set()) continue; /* bogus priority, skip it */ @@ -548,10 +541,10 @@ void CpuTi::update_remaining_amount(double now) CpuAction *CpuTi::execution_start(double size) { - XBT_IN("(%s,%g)", getCname(), size); - CpuTiAction* action = new CpuTiAction(static_cast(model()), size, isOff(), this); + XBT_IN("(%s,%g)", get_cname(), size); + CpuTiAction* action = new CpuTiAction(this, size); - action_set_.push_back(*action); + action_set_.push_back(*action); // Actually start the action XBT_OUT(); return action; @@ -563,17 +556,13 @@ CpuAction *CpuTi::sleep(double duration) if (duration > 0) duration = std::max(duration, sg_surf_precision); - XBT_IN("(%s,%g)", getCname(), duration); - CpuTiAction* action = new CpuTiAction(static_cast(model()), 1.0, isOff(), this); + XBT_IN("(%s,%g)", get_cname(), duration); + CpuTiAction* action = new CpuTiAction(this, 1.0); 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->get_state_set(), *action); - action->state_set_ = &static_cast(model())->runningActionSetThatDoesNotNeedBeingChecked_; - action->get_state_set()->push_back(*action); - } + if (duration < 0) // NO_MAX_DURATION + action->set_state(simgrid::kernel::resource::Action::State::IGNORED); action_set_.push_back(*action); @@ -583,14 +572,14 @@ CpuAction *CpuTi::sleep(double duration) void CpuTi::set_modified(bool modified) { - CpuTiList& modifiedCpu = static_cast(model())->modified_cpus_; + CpuTiList& modified_cpus = static_cast(get_model())->modified_cpus_; if (modified) { if (not cpu_ti_hook.is_linked()) { - modifiedCpu.push_back(*this); + modified_cpus.push_back(*this); } } else { if (cpu_ti_hook.is_linked()) - simgrid::xbt::intrusive_erase(modifiedCpu, *this); + simgrid::xbt::intrusive_erase(modified_cpus, *this); } } @@ -598,9 +587,7 @@ void CpuTi::set_modified(bool modified) * Action * **********/ -CpuTiAction::CpuTiAction(CpuTiModel *model_, double cost, bool failed, CpuTi *cpu) - : CpuAction(model_, cost, failed) - , cpu_(cpu) +CpuTiAction::CpuTiAction(CpuTi* cpu, double cost) : CpuAction(cpu->get_model(), cost, cpu->is_off()), cpu_(cpu) { cpu_->set_modified(true); } @@ -610,7 +597,7 @@ CpuTiAction::~CpuTiAction() if (action_ti_hook.is_linked()) simgrid::xbt::intrusive_erase(cpu_->action_set_, *this); /* remove from heap */ - heapRemove(); + get_model()->get_action_heap().remove(this); cpu_->set_modified(true); } @@ -622,8 +609,8 @@ void CpuTiAction::set_state(Action::State state) void CpuTiAction::cancel() { - this->set_state(Action::State::failed); - heapRemove(); + this->set_state(Action::State::FAILED); + get_model()->get_action_heap().remove(this); cpu_->set_modified(true); } @@ -632,7 +619,7 @@ void CpuTiAction::suspend() XBT_IN("(%p)", this); if (suspended_ != Action::SuspendStates::sleeping) { suspended_ = Action::SuspendStates::suspended; - heapRemove(); + get_model()->get_action_heap().remove(this); cpu_->set_modified(true); } XBT_OUT(); @@ -663,7 +650,7 @@ void CpuTiAction::set_max_duration(double duration) min_finish = get_finish_time(); /* add in action heap */ - heapUpdate(min_finish, Action::Type::unset); + get_model()->get_action_heap().update(this, min_finish, kernel::resource::ActionHeap::Type::unset); XBT_OUT(); }