src/kernel/resource/models/cpu_cas01.cpp

   1 /* Copyright (c) 2009-2023. The SimGrid Team. All rights reserved.          */
   2
   3 /* This program is free software; you can redistribute it and/or modify it
   4  * under the terms of the license (GNU LGPL) which comes with this package. */
   5
   6 #include <simgrid/kernel/routing/NetZoneImpl.hpp>
   7 #include <simgrid/s4u/Engine.hpp>
   8
   9 #include "simgrid/sg_config.hpp"
  10 #include "src/kernel/EngineImpl.hpp"
  11 #include "src/kernel/resource/models/cpu_cas01.hpp"
  12 #include "src/kernel/resource/models/cpu_ti.hpp"
  13 #include "src/kernel/resource/profile/Event.hpp"
  14
  15 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(cpu_cas, res_cpu, "CPU resource, CAS01 model (used by default)");
  16
  17 /***********
  18  * Options *
  19  ***********/
  20
  21 static simgrid::config::Flag<std::string>
  22     cpu_optim_opt("cpu/optim", "Optimization algorithm to use for CPU resources. ", "Lazy",
  23
  24                   std::map<std::string, std::string, std::less<>>({
  25                       {"Lazy", "Lazy action management (partial invalidation in lmm + heap in action remaining)."},
  26                       {"TI", "Trace integration. Highly optimized mode when using availability traces (only available "
  27                              "for the Cas01 CPU model for now)."},
  28                       {"Full", "Full update of remaining and variables. Slow but may be useful when debugging."},
  29                   }),
  30
  31                   [](std::string const&) {
  32                     xbt_assert(_sg_cfg_init_status < 2,
  33                                "Cannot change the optimization algorithm after the initialization");
  34                   });
  35
  36 static simgrid::config::Flag<std::string> cfg_cpu_solver("cpu/solver", "Set linear equations solver used by CPU model",
  37                                                          "maxmin", &simgrid::kernel::lmm::System::validate_solver);
  38
  39 /*********
  40  * Model *
  41  *********/
  42 SIMGRID_REGISTER_CPU_MODEL(Cas01, "Simplistic CPU model (time=size/speed)", []() {
  43   if (cpu_optim_opt == "TI") {
  44     simgrid::kernel::resource::CpuTiModel::create_pm_models();
  45     return;
  46   }
  47
  48   auto cpu_model_pm = std::make_shared<simgrid::kernel::resource::CpuCas01Model>("Cpu_Cas01");
  49   auto* engine      = simgrid::kernel::EngineImpl::get_instance();
  50   engine->add_model(cpu_model_pm);
  51   engine->get_netzone_root()->set_cpu_pm_model(cpu_model_pm);
  52 });
  53
  54 namespace simgrid::kernel::resource {
  55
  56 CpuCas01Model::CpuCas01Model(const std::string& name) : CpuModel(name)
  57 {
  58   if (config::get_value<std::string>("cpu/optim") == "Lazy")
  59     set_update_algorithm(Model::UpdateAlgo::LAZY);
  60
  61   bool select = config::get_value<bool>("cpu/maxmin-selective-update");
  62
  63   if (is_update_lazy()) {
  64     xbt_assert(select || config::is_default("cpu/maxmin-selective-update"),
  65                "You cannot disable cpu selective update when using the lazy update mechanism");
  66     select = true;
  67   }
  68
  69   set_maxmin_system(lmm::System::build(cfg_cpu_solver.get(), select));
  70 }
  71
  72 CpuImpl* CpuCas01Model::create_cpu(s4u::Host* host, const std::vector<double>& speed_per_pstate)
  73 {
  74   return (new CpuCas01(host, speed_per_pstate))->set_model(this);
  75 }
  76
  77 /************
  78  * Resource *
  79  ************/
  80 /** @brief take into account changes of speed (either load or max) */
  81 void CpuCas01::on_speed_change()
  82 {
  83   const lmm::Element* elem = nullptr;
  84
  85   get_model()->get_maxmin_system()->update_constraint_bound(get_constraint(),
  86                                                             get_core_count() * speed_.scale * speed_.peak);
  87
  88   while (const auto* var = get_constraint()->get_variable(&elem)) {
  89     const auto* action = static_cast<CpuCas01Action*>(var->get_id());
  90     double bound       = action->requested_core() * speed_.scale * speed_.peak;
  91     if (action->get_user_bound() > 0) {
  92       bound = std::min(bound, action->get_user_bound());
  93     }
  94
  95     get_model()->get_maxmin_system()->update_variable_bound(action->get_variable(), bound);
  96   }
  97
  98   CpuImpl::on_speed_change();
  99 }
 100
 101 void CpuCas01::apply_event(profile::Event* event, double value)
 102 {
 103   if (event == speed_.event) {
 104     speed_.scale = value;
 105     on_speed_change();
 106
 107     tmgr_trace_event_unref(&speed_.event);
 108   } else if (event == get_state_event()) {
 109     if (value > 0) {
 110       if (not is_on()) {
 111         XBT_VERB("Restart actors on host %s", get_iface()->get_cname());
 112         get_iface()->turn_on();
 113       }
 114     } else {
 115       const lmm::Element* elem = nullptr;
 116       double date              = EngineImpl::get_clock();
 117
 118       get_iface()->turn_off();
 119
 120       while (const auto* var = get_constraint()->get_variable(&elem)) {
 121         Action* action = var->get_id();
 122
 123         if (action->get_state() == Action::State::INITED || action->get_state() == Action::State::STARTED ||
 124             action->get_state() == Action::State::IGNORED) {
 125           action->set_finish_time(date);
 126           action->set_state(Action::State::FAILED);
 127         }
 128       }
 129     }
 130     unref_state_event();
 131
 132   } else {
 133     xbt_die("Unknown event!\n");
 134   }
 135 }
 136
 137 /** @brief Start a new execution on this CPU lasting @param size flops and using one core */
 138 CpuAction* CpuCas01::execution_start(double size, double user_bound)
 139 {
 140   return execution_start(size, 1, user_bound);
 141 }
 142
 143 CpuAction* CpuCas01::execution_start(double size, int requested_cores, double user_bound)
 144 {
 145   auto* action =
 146       new CpuCas01Action(get_model(), size, not is_on(), speed_.scale * speed_.peak, get_constraint(), requested_cores);
 147   action->set_user_bound(user_bound);
 148   if (user_bound > 0 && user_bound < action->get_bound()) {
 149     get_model()->get_maxmin_system()->update_variable_bound(action->get_variable(), user_bound);
 150   }
 151   if (factor_cb_) {
 152     action->set_rate_factor(factor_cb_(size));
 153   }
 154
 155   return action;
 156 }
 157
 158 CpuAction* CpuCas01::sleep(double duration)
 159 {
 160   if (duration > 0)
 161     duration = std::max(duration, sg_precision_timing);
 162
 163   XBT_IN("(%s, %g)", get_cname(), duration);
 164   auto* action = new CpuCas01Action(get_model(), 1.0, not is_on(), speed_.scale * speed_.peak, get_constraint(), 1);
 165
 166   // FIXME: sleep variables should not consume 1.0 in System::expand()
 167   action->set_max_duration(duration);
 168   action->set_suspend_state(Action::SuspendStates::SLEEPING);
 169   if (duration == NO_MAX_DURATION)
 170     action->set_state(Action::State::IGNORED);
 171
 172   get_model()->get_maxmin_system()->update_variable_penalty(action->get_variable(), 0.0);
 173   if (get_model()->is_update_lazy()) { // remove action from the heap
 174     get_model()->get_action_heap().remove(action);
 175     // this is necessary for a variable with weight 0 since such variables are ignored in lmm and we need to set its
 176     // max_duration correctly at the next call to share_resources
 177     get_model()->get_modified_set()->push_front(*action);
 178   }
 179
 180   XBT_OUT();
 181   return action;
 182 }
 183
 184 void CpuCas01::set_factor_cb(const std::function<s4u::Host::CpuFactorCb>& cb)
 185 {
 186   xbt_assert(not is_sealed(), "Cannot set CPU factor callback in an already sealed CPU(%s)", get_cname());
 187   factor_cb_ = cb;
 188 }
 189
 190 /**********
 191  * Action *
 192  **********/
 193 CpuCas01Action::CpuCas01Action(Model* model, double cost, bool failed, double speed, lmm::Constraint* constraint,
 194                                int requested_core)
 195     : CpuAction(model, cost, failed,
 196                 model->get_maxmin_system()->variable_new(this, 1.0 / requested_core, requested_core * speed, 1))
 197     , requested_core_(requested_core)
 198 {
 199   if (model->is_update_lazy())
 200     set_last_update();
 201   model->get_maxmin_system()->expand(constraint, get_variable(), 1.0);
 202 }
 203
 204 } // namespace simgrid::kernel::resource