X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/5c1a6059a5e825600a240878638311aa572746ad..b903641143d708b08064fcb86676d46d147a3970:/src/surf/cpu_ti.cpp diff --git a/src/surf/cpu_ti.cpp b/src/surf/cpu_ti.cpp index 0e1e208ccf..54756761f5 100644 --- a/src/surf/cpu_ti.cpp +++ b/src/surf/cpu_ti.cpp @@ -1,19 +1,21 @@ -/* Copyright (c) 2013-2020. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2013-2021. 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. */ #include "cpu_ti.hpp" +#include "src/kernel/EngineImpl.hpp" #include "src/kernel/resource/profile/Event.hpp" #include "src/kernel/resource/profile/Profile.hpp" #include "src/surf/surf_interface.hpp" #include "surf/surf.hpp" #include +#include constexpr double EPSILON = 0.000000001; -XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_cpu_ti, surf_cpu, "Logging specific to the SURF CPU TRACE INTEGRATION module"); +XBT_LOG_NEW_DEFAULT_SUBCATEGORY(cpu_ti, res_cpu, "CPU resource, Trace Integration model"); namespace simgrid { namespace kernel { @@ -25,8 +27,8 @@ namespace resource { CpuTiProfile::CpuTiProfile(const profile::Profile* profile) { - double integral = 0; - double time = 0; + double integral = 0; + double time = 0; unsigned nb_points = profile->event_list.size() + 1; time_points_.reserve(nb_points); integral_.reserve(nb_points); @@ -50,11 +52,12 @@ CpuTiProfile::CpuTiProfile(const profile::Profile* profile) * @param b End of interval * @return the integrate value. -1 if an error occurs. */ -double CpuTiTmgr::integrate(double a, double b) +double CpuTiTmgr::integrate(double a, double b) const { 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); + "You probably have a task executing with negative computation amount. Check your code.", + a, b); } if (fabs(a - b) < EPSILON) return 0.0; @@ -63,21 +66,20 @@ double CpuTiTmgr::integrate(double a, double b) return (b - a) * value_; } - int a_index; + double a_index; if (fabs(ceil(a / last_time_) - a / last_time_) < EPSILON) - a_index = 1 + static_cast(ceil(a / last_time_)); + a_index = 1 + ceil(a / last_time_); else - a_index = static_cast(ceil(a / last_time_)); - - int b_index = static_cast(floor(b / last_time_)); + a_index = ceil(a / last_time_); + double b_index = floor(b / last_time_); - if (a_index > b_index) { /* Same chunk */ - return profile_->integrate_simple(a - (a_index - 1) * last_time_, b - (b_index)*last_time_); + if (a_index > b_index) { /* Same chunk */ + return profile_->integrate_simple(a - (a_index - 1) * last_time_, b - b_index * last_time_); } double first_chunk = profile_->integrate_simple(a - (a_index - 1) * last_time_, last_time_); double middle_chunk = (b_index - a_index) * total_; - double last_chunk = profile_->integrate_simple(0.0, b - (b_index)*last_time_); + double last_chunk = profile_->integrate_simple(0.0, b - b_index * last_time_); XBT_DEBUG("first_chunk=%.2f middle_chunk=%.2f last_chunk=%.2f\n", first_chunk, middle_chunk, last_chunk); @@ -90,7 +92,7 @@ double CpuTiTmgr::integrate(double a, double b) * @param a Initial point * @param b Final point */ -double CpuTiProfile::integrate_simple(double a, double b) +double CpuTiProfile::integrate_simple(double a, double b) const { return integrate_simple_point(b) - integrate_simple_point(a); } @@ -99,10 +101,10 @@ double CpuTiProfile::integrate_simple(double a, double b) * @brief Auxiliary function to compute the integral at point a. * @param a point */ -double CpuTiProfile::integrate_simple_point(double a) +double CpuTiProfile::integrate_simple_point(double a) const { double integral = 0; - double a_aux = a; + double a_aux = a; int ind = binary_search(time_points_, a); integral += integral_[ind]; @@ -126,7 +128,7 @@ double CpuTiProfile::integrate_simple_point(double a) * @param amount Amount to be executed * @return End time */ -double CpuTiTmgr::solve(double a, double amount) +double CpuTiTmgr::solve(double a, double amount) const { /* Fix very small negative numbers */ if ((a < 0.0) && (a > -EPSILON)) { @@ -137,11 +139,10 @@ double CpuTiTmgr::solve(double a, double amount) } /* Sanity checks */ - if ((a < 0.0) || (amount < 0.0)) { - XBT_CRITICAL ("Error, invalid parameters [a = %.2f, amount = %.2f]. " - "You probably have a task executing with negative computation amount. Check your code.", a, amount); - xbt_abort(); - } + xbt_assert(a >= 0.0 && amount >= 0.0, + "Error, invalid parameters [a = %.2f, amount = %.2f]. " + "You probably have a task executing with negative computation amount. Check your code.", + a, amount); /* At this point, a and amount are positive */ if (amount < EPSILON) @@ -154,11 +155,11 @@ double CpuTiTmgr::solve(double a, double amount) XBT_DEBUG("amount %f total %f", amount, total_); /* Reduce the problem to one where amount <= trace_total */ - int quotient = static_cast(floor(amount / total_)); + double quotient = floor(amount / total_); double reduced_amount = (total_) * ((amount / total_) - floor(amount / total_)); double reduced_a = a - (last_time_) * static_cast(floor(a / last_time_)); - XBT_DEBUG("Quotient: %d reduced_amount: %f reduced_a: %f", quotient, reduced_amount, reduced_a); + XBT_DEBUG("Quotient: %g reduced_amount: %f reduced_a: %f", quotient, reduced_amount, reduced_a); /* Now solve for new_amount which is <= trace_total */ double reduced_b; @@ -172,7 +173,7 @@ double CpuTiTmgr::solve(double a, double amount) } /* Re-map to the original b and amount */ - return (last_time_) * static_cast(floor(a / last_time_)) + (quotient * last_time_) + reduced_b; + return last_time_ * floor(a / last_time_) + (quotient * last_time_) + reduced_b; } /** @@ -182,7 +183,7 @@ double CpuTiTmgr::solve(double a, double amount) * @param amount Amount of flops * @return The date when amount is available. */ -double CpuTiProfile::solve_simple(double a, double amount) +double CpuTiProfile::solve_simple(double a, double amount) const { double integral_a = integrate_simple_point(a); int ind = binary_search(integral_, integral_a + amount); @@ -200,9 +201,9 @@ double CpuTiProfile::solve_simple(double a, double amount) * @param a Time * @return CPU speed scale */ -double CpuTiTmgr::get_power_scale(double a) +double CpuTiTmgr::get_power_scale(double a) const { - double reduced_a = a - floor(a / last_time_) * last_time_; + double reduced_a = a - floor(a / last_time_) * last_time_; int point = CpuTiProfile::binary_search(profile_->time_points_, reduced_a); kernel::profile::DatedValue val = speed_profile_->event_list.at(point); return val.value_; @@ -239,7 +240,7 @@ CpuTiTmgr::CpuTiTmgr(kernel::profile::Profile* speed_profile, double value) : sp for (auto const& val : speed_profile->event_list) total_time += val.date_; - profile_.reset(new CpuTiProfile(speed_profile)); + profile_ = std::make_unique(speed_profile); last_time_ = total_time; total_ = profile_->integrate_simple(0, total_time); @@ -267,26 +268,23 @@ int CpuTiProfile::binary_search(const std::vector& array, double a) void CpuTiModel::create_pm_vm_models() { - 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 CpuTiModel(); - surf_cpu_model_vm = new CpuTiModel(); + auto cpu_model_pm = std::make_shared(); + simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::CPU_PM, + std::move(cpu_model_pm), true); + auto cpu_model_vm = std::make_shared(); + simgrid::kernel::EngineImpl::get_instance()->add_model(simgrid::kernel::resource::Model::Type::CPU_VM, + std::move(cpu_model_vm), true); } CpuTiModel::CpuTiModel() : CpuModel(Model::UpdateAlgo::FULL) { - all_existing_models.push_back(this); } -CpuTiModel::~CpuTiModel() -{ - surf_cpu_model_pm = nullptr; -} +CpuTiModel::~CpuTiModel() {} -Cpu* CpuTiModel::create_cpu(s4u::Host* host, const std::vector& speed_per_pstate, int core) +Cpu* CpuTiModel::create_cpu(s4u::Host* host, const std::vector& speed_per_pstate) { - return new CpuTi(this, host, speed_per_pstate, core); + return (new CpuTi(host, speed_per_pstate))->set_model(this); } double CpuTiModel::next_occurring_event(double now) @@ -323,11 +321,8 @@ void CpuTiModel::update_actions_state(double now, double /*delta*/) /************ * Resource * ************/ -CpuTi::CpuTi(CpuTiModel* model, s4u::Host* host, const std::vector& speed_per_pstate, int core) - : Cpu(model, host, speed_per_pstate, core) +CpuTi::CpuTi(s4u::Host* host, const std::vector& speed_per_pstate) : Cpu(host, speed_per_pstate) { - xbt_assert(core == 1, "Multi-core not handled by this model yet"); - speed_.peak = speed_per_pstate.front(); XBT_DEBUG("CPU create: peak=%f", speed_.peak); @@ -374,11 +369,11 @@ void CpuTi::apply_event(kernel::profile::Event* event, double value) } else if (event == state_event_) { if (value > 0) { if (not is_on()) { - XBT_VERB("Restart actors on host %s", get_host()->get_cname()); - get_host()->turn_on(); + XBT_VERB("Restart actors on host %s", get_iface()->get_cname()); + get_iface()->turn_on(); } } else { - get_host()->turn_off(); + get_iface()->turn_off(); double date = surf_get_clock(); /* put all action running on cpu to failed */ @@ -408,7 +403,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_started_action_set()) + if (action.get_state_set() != get_model()->get_started_action_set()) continue; /* bogus priority, skip it */ @@ -425,7 +420,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_started_action_set()) + if (action.get_state_set() != get_model()->get_started_action_set()) continue; /* verify if the action is really running on cpu */ @@ -458,7 +453,7 @@ void CpuTi::update_actions_finish_time(double now) set_modified(false); } -bool CpuTi::is_used() +bool CpuTi::is_used() const { return not action_set_.empty(); }