X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/97e2219ed6c0e511f6165460cec79afadf42f589..eaa2bc1889c7f720405ee27f7b9962801c155d78:/src/kernel/lmm/System.cpp diff --git a/src/kernel/lmm/System.cpp b/src/kernel/lmm/System.cpp index 97e4c27037..cebcb9632d 100644 --- a/src/kernel/lmm/System.cpp +++ b/src/kernel/lmm/System.cpp @@ -1,25 +1,26 @@ -/* Copyright (c) 2004-2022. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2004-2023. 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 "src/internal_config.h" #include "src/kernel/lmm/fair_bottleneck.hpp" #include "src/kernel/lmm/maxmin.hpp" +#include "src/simgrid/math_utils.h" #if SIMGRID_HAVE_EIGEN3 #include "src/kernel/lmm/bmf.hpp" #endif + #include #include XBT_LOG_NEW_DEFAULT_SUBCATEGORY(ker_lmm, kernel, "Kernel Linear Max-Min solver"); -double sg_maxmin_precision = 1E-5; /* Change this with --cfg=maxmin/precision:VALUE */ -double sg_surf_precision = 1E-9; /* Change this with --cfg=surf/precision:VALUE */ +double sg_precision_workamount = 1E-5; /* Change this with --cfg=precision/work-amount:VALUE */ +double sg_precision_timing = 1E-9; /* Change this with --cfg=precision/timing:VALUE */ int sg_concurrency_limit = -1; /* Change this with --cfg=maxmin/concurrency-limit:VALUE */ -namespace simgrid { -namespace kernel { -namespace lmm { +namespace simgrid::kernel::lmm { int Variable::next_rank_ = 1; int Constraint::next_rank_ = 1; @@ -31,6 +32,11 @@ Element::Element(Constraint* constraint, Variable* variable, double cweight) int Element::get_concurrency() const { + // just to try having the computation of the concurrency + if (constraint->get_sharing_policy() == Constraint::SharingPolicy::WIFI) { + return 1; + } + // Ignore element with weight less than one (e.g. cross-traffic) return (consumption_weight >= 1) ? 1 : 0; // There are other alternatives, but they will change the behavior of the model.. @@ -59,7 +65,7 @@ void Element::increase_concurrency(bool check_limit) "Concurrency limit overflow!"); } -System* System::build(const std::string& solver_name, bool selective_update) +System* System::build(std::string_view solver_name, bool selective_update) { System* system = nullptr; if (solver_name == "bmf") { @@ -89,7 +95,7 @@ void System::validate_solver(const std::string& solver_name) void System::check_concurrency() const { - // These checks are very expensive, so do them only if we want to debug SURF LMM + // These checks are very expensive, so do them only if we want to debug the LMM if (not XBT_LOG_ISENABLED(ker_lmm, xbt_log_priority_debug)) return; @@ -102,7 +108,7 @@ void System::check_concurrency() const for (Element const& elem : cnst.disabled_element_set_) { // We should have staged variables only if concurrency is reached in some constraint - xbt_assert(cnst.get_concurrency_limit() < 0 || elem.variable->staged_penalty_ == 0 || + xbt_assert(cnst.get_concurrency_limit() < 0 || elem.variable->staged_sharing_penalty_ == 0 || elem.variable->get_min_concurrency_slack() == 0, "should not have staged variable!"); } @@ -176,9 +182,10 @@ System::System(bool selective_update) : selective_update_active(selective_update System::~System() { while (Variable* var = extract_variable()) { - std::string demangled = boost::core::demangle(var->id_ ? typeid(*var->id_).name() : "(unidentified)"); - XBT_WARN("Probable bug: a %s variable (#%d) not removed before the LMM system destruction.", demangled.c_str(), - var->rank_); + const char* name = var->id_ ? typeid(*var->id_).name() : "(unidentified)"; + boost::core::scoped_demangled_name demangled(name); + XBT_WARN("Probable bug: a %s variable (#%d) not removed before the LMM system destruction.", + demangled.get() ? demangled.get() : name, var->rank_); var_free(var); } while (Constraint* cnst = extract_constraint()) @@ -271,19 +278,20 @@ Element& System::expand_add_to_elem(Element& elem, const Constraint* cnst, doubl return elem; } -void System::expand(Constraint* cnst, Variable* var, double consumption_weight) +void System::expand(Constraint* cnst, Variable* var, double consumption_weight, bool force_creation) { modified_ = true; auto elem_it = std::find_if(begin(var->cnsts_), end(var->cnsts_), [&cnst](Element const& x) { return x.constraint == cnst; }); - if (elem_it != end(var->cnsts_)) { + + bool reuse_elem = elem_it != end(var->cnsts_) && not force_creation; + if (reuse_elem && var->sharing_penalty_ != 0.0) { /* before changing it, decreases concurrency on constraint, it'll be added back later */ - if (var->sharing_penalty_ != 0.0) - elem_it->decrease_concurrency(); + elem_it->decrease_concurrency(); } - Element& elem = elem_it != end(var->cnsts_) ? expand_add_to_elem(*elem_it, cnst, consumption_weight) - : expand_create_elem(cnst, var, consumption_weight); + Element& elem = reuse_elem ? expand_add_to_elem(*elem_it, cnst, consumption_weight) + : expand_create_elem(cnst, var, consumption_weight); // Check if we need to disable the variable if (var->sharing_penalty_ != 0) { @@ -297,7 +305,7 @@ void System::expand(Constraint* cnst, Variable* var, double consumption_weight) disable_var(var); for (Element const& elem2 : var->cnsts_) on_disabled_var(elem2.constraint); - var->staged_penalty_ = penalty; + var->staged_sharing_penalty_ = penalty; xbt_assert(not var->sharing_penalty_); } } @@ -318,8 +326,6 @@ Variable* Constraint::get_variable(const Element** elem) const *elem = &enabled_element_set_.front(); else if (not disabled_element_set_.empty()) *elem = &disabled_element_set_.front(); - else - *elem = nullptr; } else { // elem is not null, so we carry on if ((*elem)->enabled_element_set_hook.is_linked()) { @@ -352,8 +358,6 @@ Variable* Constraint::get_variable_safe(const Element** elem, const Element** ne *elem = &enabled_element_set_.front(); else if (not disabled_element_set_.empty()) *elem = &disabled_element_set_.front(); - else - *elem = nullptr; } else { *elem = *nextelem; if (*numelem > 0) { @@ -425,7 +429,7 @@ void System::print() const } XBT_DEBUG("%s", buf.c_str()); buf.clear(); - xbt_assert(not double_positive(sum - cnst.bound_, cnst.bound_ * sg_maxmin_precision), + xbt_assert(not double_positive(sum - cnst.bound_, cnst.bound_ * sg_precision_workamount), "Incorrect value (%f is not smaller than %f): %g", sum, cnst.bound_, sum - cnst.bound_); } @@ -434,7 +438,7 @@ void System::print() const for (Variable const& var : variable_set) { if (var.bound_ > 0) { XBT_DEBUG("'%d'(%f) : %f (<=%f)", var.rank_, var.sharing_penalty_, var.value_, var.bound_); - xbt_assert(not double_positive(var.value_ - var.bound_, var.bound_ * sg_maxmin_precision), + xbt_assert(not double_positive(var.value_ - var.bound_, var.bound_ * sg_precision_workamount), "Incorrect value (%f is not smaller than %f", var.value_, var.bound_); } else { XBT_DEBUG("'%d'(%f) : %f", var.rank_, var.sharing_penalty_, var.value_); @@ -504,7 +508,7 @@ void Variable::initialize(resource::Action* id_value, double sharing_penalty, do rank_ = next_rank_++; cnsts_.reserve(number_of_constraints); sharing_penalty_ = sharing_penalty; - staged_penalty_ = 0.0; + staged_sharing_penalty_ = 0.0; bound_ = bound_value; value_ = 0.0; visited_ = visited_value; @@ -537,8 +541,8 @@ void System::enable_var(Variable* var) { xbt_assert(not XBT_LOG_ISENABLED(ker_lmm, xbt_log_priority_debug) || var->can_enable()); - var->sharing_penalty_ = var->staged_penalty_; - var->staged_penalty_ = 0; + var->sharing_penalty_ = var->staged_sharing_penalty_; + var->staged_sharing_penalty_ = 0; // Enabling the variable, move var to list head. Subtlety is: here, we need to call update_modified_cnst_set AFTER // moving at least one element of var. @@ -559,7 +563,7 @@ void System::enable_var(Variable* var) void System::disable_var(Variable* var) { - xbt_assert(not var->staged_penalty_, "Staged penalty should have been cleared"); + xbt_assert(not var->staged_sharing_penalty_, "Staged penalty should have been cleared"); // Disabling the variable, move to var to list tail. Subtlety is: here, we need to call update_modified_cnst_set // BEFORE moving the last element of var. simgrid::xbt::intrusive_erase(variable_set, *var); @@ -574,7 +578,7 @@ void System::disable_var(Variable* var) } var->sharing_penalty_ = 0.0; - var->staged_penalty_ = 0.0; + var->staged_sharing_penalty_ = 0.0; var->value_ = 0.0; check_concurrency(); } @@ -607,7 +611,7 @@ void System::on_disabled_var(Constraint* cnstr) nextelem = nullptr; } - if (elem->variable->staged_penalty_ > 0 && elem->variable->can_enable()) { + if (elem->variable->staged_sharing_penalty_ > 0 && elem->variable->can_enable()) { // Found a staged variable // TODOLATER: Add random timing function to model reservation protocol fuzziness? Then how to make sure that // staged variables will eventually be called? @@ -642,7 +646,7 @@ void System::update_variable_penalty(Variable* var, double penalty) // Are we enabling this variable? if (enabling_var) { - var->staged_penalty_ = penalty; + var->staged_sharing_penalty_ = penalty; int minslack = var->get_min_concurrency_slack(); if (minslack == 0) { XBT_DEBUG("Staging var (instead of enabling) because min concurrency slack is 0"); @@ -743,7 +747,7 @@ void System::remove_all_modified_cnst_set() * If the resource is not shared (ie in FATPIPE mode), then the load is the max (not the sum) * of all resource usages located on this resource. */ -double Constraint::get_usage() const +double Constraint::get_load() const { double result = 0.0; if (sharing_policy_ != SharingPolicy::FATPIPE) { @@ -758,20 +762,12 @@ double Constraint::get_usage() const return result; } -int Constraint::get_variable_amount() const -{ - return static_cast(std::count_if(std::begin(enabled_element_set_), std::end(enabled_element_set_), - [](const Element& elem) { return elem.consumption_weight > 0; })); -} - void Constraint::set_sharing_policy(SharingPolicy policy, const s4u::NonLinearResourceCb& cb) { - xbt_assert(policy == SharingPolicy::NONLINEAR || not cb, + xbt_assert(policy == SharingPolicy::NONLINEAR || policy == SharingPolicy::WIFI || not cb, "Invalid sharing policy for constraint. Callback should be used with NONLINEAR sharing policy"); sharing_policy_ = policy; dyn_constraint_cb_ = cb; } -} // namespace lmm -} // namespace kernel -} // namespace simgrid \ No newline at end of file +} // namespace simgrid::kernel::lmm