X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/0617119206ff65bfdad4e484f653638abbc3c747..c773c39f8623155553cfba2919317250e003adb4:/src/surf/cpu_ti.cpp diff --git a/src/surf/cpu_ti.cpp b/src/surf/cpu_ti.cpp index c1c9ec471f..d1d7d749b7 100644 --- a/src/surf/cpu_ti.cpp +++ b/src/surf/cpu_ti.cpp @@ -4,12 +4,11 @@ * 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_ +#define EPSILON 0.000000001 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_cpu_ti, surf_cpu, "Logging specific to the SURF CPU TRACE INTEGRATION module"); @@ -45,10 +44,9 @@ CpuTiTrace::~CpuTiTrace() delete [] integral_; } -CpuTiTgmr::~CpuTiTgmr() +CpuTiTmgr::~CpuTiTmgr() { - if (trace_) - delete trace_; + delete trace_; } /** @@ -61,21 +59,20 @@ 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; - if ((a < 0.0) || (a > b)) { xbt_die("Error, invalid integration interval [%.2f,%.2f]. " "You probably have a task executing with negative computation amount. Check your code.", a, b); } - if (fabs(a -b) < EPSILON) + if (fabs(a - b) < EPSILON) return 0.0; - if (type_ == TRACE_FIXED) { - return ((b - a) * value_); + if (type_ == Type::FIXED) { + return (b - a) * value_; } + int a_index; if (fabs(ceil(a / last_time_) - a / last_time_) < EPSILON) a_index = 1 + static_cast(ceil(a / last_time_)); else @@ -138,7 +135,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)) { @@ -160,7 +157,7 @@ double CpuTiTgmr::solve(double a, double amount) return a; /* Is the trace fixed ? */ - if (type_ == TRACE_FIXED) { + if (type_ == Type::FIXED) { return (a + (amount / value_)); } @@ -212,7 +209,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,42 +218,41 @@ 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) { - type_ = TRACE_FIXED; + /* no availability file, fixed trace */ + if (not speed_trace) { + type_ = Type::FIXED; value_ = value; XBT_DEBUG("No availability trace. Constant value = %f", value); return; } /* 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_ = Type::FIXED; + value_ = speed_trace->event_list.front().value_; return; } - type_ = TRACE_DYNAMIC; + type_ = Type::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_); } @@ -294,30 +290,31 @@ int CpuTiTrace::binary_search(double* array, double a, int low, int high) /********* * Model * *********/ +namespace simgrid { +namespace surf { -void surf_cpu_model_init_ti() +void CpuTiModel::create_pm_vm_models() { - xbt_assert(not surf_cpu_model_pm, "CPU model already initialized. This should not happen."); - xbt_assert(not surf_cpu_model_vm, "CPU model already initialized. This should not happen."); + xbt_assert(surf_cpu_model_pm == nullptr, "CPU model already initialized. This should not happen."); + xbt_assert(surf_cpu_model_vm == nullptr, "CPU model already initialized. This should not happen."); surf_cpu_model_pm = new simgrid::surf::CpuTiModel(); - all_existing_models->push_back(surf_cpu_model_pm); - surf_cpu_model_vm = new simgrid::surf::CpuTiModel(); - all_existing_models->push_back(surf_cpu_model_vm); } -namespace simgrid { -namespace surf { +CpuTiModel::CpuTiModel() : CpuModel(Model::UpdateAlgo::FULL) +{ + all_existing_models.push_back(this); +} CpuTiModel::~CpuTiModel() { surf_cpu_model_pm = nullptr; } -Cpu *CpuTiModel::createCpu(simgrid::s4u::Host *host, std::vector* speedPerPstate, int core) +Cpu* CpuTiModel::create_cpu(simgrid::s4u::Host* host, std::vector* speed_per_pstate, int core) { - return new CpuTi(this, host, speedPerPstate, core); + return new CpuTi(this, host, speed_per_pstate, core); } double CpuTiModel::next_occuring_event(double now) @@ -326,9 +323,9 @@ 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 */ @@ -345,7 +342,7 @@ void CpuTiModel::update_actions_state(double now, double /*delta*/) 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 +359,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,47 +369,37 @@ 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) { 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); + speed_.event = future_evt_set.add_trace(new simgrid::trace_mgr::trace(), this); } } void CpuTi::apply_event(tmgr_trace_event_t event, double value) { if (event == speed_.event) { - tmgr_trace_t speedTrace; - CpuTiTgmr *trace; + XBT_DEBUG("Speed changed in trace! New fixed value: %f", value); - 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_; - trace_mgr::DatedValue val = speedTrace->event_list.back(); delete speed_integrated_trace_; - speed_.scale = val.value_; - - trace = new CpuTiTgmr(TRACE_FIXED, val.value_); - XBT_DEBUG("value %f", val.value_); - - speed_integrated_trace_ = trace; + speed_integrated_trace_ = new CpuTiTmgr(value); + speed_.scale = value; tmgr_trace_event_unref(&speed_.event); - } else if (event == stateEvent_) { + } else if (event == state_event_) { if (value > 0) { if (is_off()) - host_that_restart.push_back(getHost()); + host_that_restart.push_back(get_host()); turn_on(); } else { turn_off(); @@ -420,16 +407,16 @@ void CpuTi::apply_event(tmgr_trace_event_t event, double value) /* 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.set_state(kernel::resource::Action::State::FAILED); get_model()->get_action_heap().remove(&action); } } } - tmgr_trace_event_unref(&stateEvent_); + tmgr_trace_event_unref(&state_event_); } else { xbt_die("Unknown event!\n"); @@ -446,7 +433,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 +450,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 */ @@ -501,17 +488,16 @@ bool CpuTi::is_used() return not action_set_.empty(); } -double CpuTi::get_available_speed() +double CpuTi::get_speed_ratio() { speed_.scale = speed_integrated_trace_->get_power_scale(surf_get_clock()); - return Cpu::get_available_speed(); + return Cpu::get_speed_ratio(); } /** @brief Update the remaining amount of actions */ void CpuTi::update_remaining_amount(double now) { - - /* already updated */ + /* already up to date */ if (last_update_ >= now) return; @@ -520,7 +506,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() != get_model()->get_running_action_set()) + if (action.get_state_set() != get_model()->get_started_action_set()) continue; /* bogus priority, skip it */ @@ -549,9 +535,9 @@ void CpuTi::update_remaining_amount(double now) CpuAction *CpuTi::execution_start(double size) { XBT_IN("(%s,%g)", get_cname(), size); - CpuTiAction* action = new CpuTiAction(static_cast(get_model()), size, is_off(), this); + CpuTiAction* action = new CpuTiAction(this, size); - action_set_.push_back(*action); + action_set_.push_back(*action); // Actually start the action XBT_OUT(); return action; @@ -564,16 +550,12 @@ CpuAction *CpuTi::sleep(double duration) duration = std::max(duration, sg_surf_precision); XBT_IN("(%s,%g)", get_cname(), duration); - CpuTiAction* action = new CpuTiAction(static_cast(get_model()), 1.0, is_off(), this); + 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(get_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 +565,14 @@ CpuAction *CpuTi::sleep(double duration) void CpuTi::set_modified(bool modified) { - CpuTiList& modifiedCpu = static_cast(get_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 +580,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); } @@ -622,7 +602,7 @@ void CpuTiAction::set_state(Action::State state) void CpuTiAction::cancel() { - this->set_state(Action::State::failed); + this->set_state(Action::State::FAILED); get_model()->get_action_heap().remove(this); cpu_->set_modified(true); } @@ -686,5 +666,3 @@ double CpuTiAction::get_remains() } } - -#endif /* SURF_MODEL_CPUTI_H_ */