X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/7cefce8d600641bb17bac4b5745b24bad143954d..baaf903efbf8a62669075e95f90419c1728ff17a:/src/kernel/lmm/maxmin.cpp diff --git a/src/kernel/lmm/maxmin.cpp b/src/kernel/lmm/maxmin.cpp index 628b69c093..08dd3efb5a 100644 --- a/src/kernel/lmm/maxmin.cpp +++ b/src/kernel/lmm/maxmin.cpp @@ -1,16 +1,15 @@ -/* Copyright (c) 2004-2019. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2004-2020. 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/kernel/lmm/maxmin.hpp" -#include "src/surf/surf_interface.hpp" #include "xbt/backtrace.hpp" XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_maxmin, surf, "Logging specific to SURF (maxmin)"); double sg_maxmin_precision = 0.00001; /* Change this with --cfg=maxmin/precision:VALUE */ -double sg_surf_precision = 0.00001; /* Change this with --cfg=surf/precision:VALUE */ +double sg_surf_precision = 0.000000001; /* Change this with --cfg=surf/precision:VALUE */ int sg_concurrency_limit = -1; /* Change this with --cfg=maxmin/concurrency-limit:VALUE */ namespace simgrid { @@ -31,7 +30,7 @@ int Element::get_concurrency() const { // 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 behaviour of the model.. + // There are other alternatives, but they will change the behavior of the model.. // So do not use it unless you want to make a new model. // If you do, remember to change the variables concurrency share to reflect it. // Potential examples are: @@ -88,9 +87,9 @@ void System::check_concurrency() const continue; const Element& elem = var.cnsts_[0]; - int belong_to_enabled = elem.enabled_element_set_hook.is_linked(); - int belong_to_disabled = elem.disabled_element_set_hook.is_linked(); - int belong_to_active = elem.active_element_set_hook.is_linked(); + bool belong_to_enabled = elem.enabled_element_set_hook.is_linked(); + bool belong_to_disabled = elem.disabled_element_set_hook.is_linked(); + bool belong_to_active = elem.active_element_set_hook.is_linked(); for (Element const& elem2 : var.cnsts_) { xbt_assert(belong_to_enabled == elem2.enabled_element_set_hook.is_linked(), @@ -169,23 +168,12 @@ void System::cnst_free(Constraint* cnst) delete cnst; } -Constraint::Constraint(void* id_value, double bound_value) : bound_(bound_value), id_(id_value) +Constraint::Constraint(resource::Resource* id_value, double bound_value) : bound_(bound_value), id_(id_value) { rank_ = next_rank_++; - - remaining_ = 0.0; - usage_ = 0.0; - concurrency_limit_ = sg_concurrency_limit; - concurrency_current_ = 0; - concurrency_maximum_ = 0; - sharing_policy_ = s4u::Link::SharingPolicy::SHARED; - - lambda_ = 0.0; - new_lambda_ = 0.0; - cnst_light_ = nullptr; } -Constraint* System::constraint_new(void* id, double bound_value) +Constraint* System::constraint_new(resource::Resource* id, double bound_value) { Constraint* cnst = new Constraint(id, bound_value); insert_constraint(cnst); @@ -224,15 +212,22 @@ void System::variable_free(Variable* var) var_free(var); } +void System::variable_free_all() +{ + Variable* var; + while ((var = extract_variable())) + variable_free(var); +} + void System::expand(Constraint* cnst, Variable* var, double consumption_weight) { modified_ = true; // Check if this variable already has an active element in this constraint - // If it does, substract it from the required slack + // If it does, subtract it from the required slack int current_share = 0; if (var->concurrency_share_ > 1) { - for (Element& elem : var->cnsts_) { + for (const Element& elem : var->cnsts_) { if (elem.constraint == cnst && elem.enabled_element_set_hook.is_linked()) current_share += elem.get_concurrency(); } @@ -401,13 +396,13 @@ static inline void saturated_constraints_update(double usage, int cnst_light_num } } -static inline void saturated_variable_set_update(ConstraintLight* cnst_light_tab, +static inline void saturated_variable_set_update(const ConstraintLight* cnst_light_tab, const dyn_light_t& saturated_constraints, System* sys) { /* Add active variables (i.e. variables that need to be set) from the set of constraints to saturate * (cnst_light_tab)*/ for (int const& saturated_cnst : saturated_constraints) { - ConstraintLight& cnst = cnst_light_tab[saturated_cnst]; + const ConstraintLight& cnst = cnst_light_tab[saturated_cnst]; for (Element const& elem : cnst.cnst->active_element_set_) { xbt_assert(elem.variable->sharing_penalty_ > 0); // All elements of active_element_set should be active if (elem.consumption_weight > 0 && not elem.variable->saturated_variable_set_hook_.is_linked()) @@ -498,17 +493,9 @@ template void System::lmm_solve(CnstList& cnst_list) double min_bound = -1; XBT_DEBUG("Active constraints : %zu", cnst_list.size()); - /* Init: Only modified code portions: reset the value of active variables */ - for (Constraint const& cnst : cnst_list) { - for (Element const& elem : cnst.enabled_element_set_) { - xbt_assert(elem.variable->sharing_penalty_ > 0.0); - elem.variable->value_ = 0.0; - } - } - - ConstraintLight* cnst_light_tab = new ConstraintLight[cnst_list.size()](); + cnst_light_vec.reserve(cnst_list.size()); + ConstraintLight* cnst_light_tab = cnst_light_vec.data(); int cnst_light_num = 0; - dyn_light_t saturated_constraints; for (Constraint& cnst : cnst_list) { /* INIT: Collect constraints that actually need to be saturated (i.e remaining and usage are strictly positive) @@ -518,7 +505,8 @@ template void System::lmm_solve(CnstList& cnst_list) continue; cnst.usage_ = 0; for (Element& elem : cnst.enabled_element_set_) { - xbt_assert(elem.variable->sharing_penalty_ > 0); + xbt_assert(elem.variable->sharing_penalty_ > 0.0); + elem.variable->value_ = 0.0; if (elem.consumption_weight > 0) { if (cnst.sharing_policy_ != s4u::Link::SharingPolicy::FATPIPE) cnst.usage_ += elem.consumption_weight / elem.variable->sharing_penalty_; @@ -590,7 +578,7 @@ template void System::lmm_solve(CnstList& cnst_list) XBT_DEBUG("Min usage: %f, Var(%d).penalty: %f, Var(%d).value: %f ", min_usage, var.rank_, var.sharing_penalty_, var.rank_, var.value_); - /* Update the usage of contraints where this variable is involved */ + /* Update the usage of constraints where this variable is involved */ for (Element& elem : var.cnsts_) { Constraint* cnst = elem.constraint; if (cnst->sharing_policy_ != s4u::Link::SharingPolicy::FATPIPE) { @@ -610,14 +598,16 @@ template void System::lmm_solve(CnstList& cnst_list) cnst->cnst_light_ = nullptr; } } else { - cnst->cnst_light_->remaining_over_usage = cnst->remaining_ / cnst->usage_; + if (cnst->cnst_light_) { + cnst->cnst_light_->remaining_over_usage = cnst->remaining_ / cnst->usage_; + } } elem.make_inactive(); } else { // Remember: non-shared constraints only require that max(elem.value * var.value) < cnst->bound cnst->usage_ = 0.0; elem.make_inactive(); - for (Element& elem2 : cnst->enabled_element_set_) { + for (const Element& elem2 : cnst->enabled_element_set_) { xbt_assert(elem2.variable->sharing_penalty_ > 0); if (elem2.variable->value_ > 0) continue; @@ -639,10 +629,12 @@ template void System::lmm_solve(CnstList& cnst_list) cnst->cnst_light_ = nullptr; } } else { - cnst->cnst_light_->remaining_over_usage = cnst->remaining_ / cnst->usage_; - xbt_assert(not cnst->active_element_set_.empty(), - "Should not keep a maximum constraint that has no active" - " element! You want to check the maxmin precision and possible rounding effects."); + if (cnst->cnst_light_) { + cnst->cnst_light_->remaining_over_usage = cnst->remaining_ / cnst->usage_; + xbt_assert(not cnst->active_element_set_.empty(), + "Should not keep a maximum constraint that has no active" + " element! You want to check the maxmin precision and possible rounding effects."); + } } } } @@ -665,7 +657,6 @@ template void System::lmm_solve(CnstList& cnst_list) } saturated_variable_set_update(cnst_light_tab, saturated_constraints, this); - } while (cnst_light_num > 0); modified_ = false; @@ -677,8 +668,6 @@ template void System::lmm_solve(CnstList& cnst_list) } check_concurrency(); - - delete[] cnst_light_tab; } /** @brief Attribute the value bound to var->bound. @@ -803,7 +792,6 @@ void System::on_disabled_var(Constraint* cnstr) // Cannot use foreach loop, because System::enable_var() will modify disabled_element_set.. within the loop while (numelem-- && elem) { - Element* nextelem; if (elem->disabled_element_set_hook.is_linked()) { auto iter = std::next(cnstr->disabled_element_set_.iterator_to(*elem)); @@ -839,8 +827,8 @@ void System::update_variable_penalty(Variable* var, double penalty) if (penalty == var->sharing_penalty_) return; - int enabling_var = (penalty > 0 && var->sharing_penalty_ <= 0); - int disabling_var = (penalty <= 0 && var->sharing_penalty_ > 0); + bool enabling_var = (penalty > 0 && var->sharing_penalty_ <= 0); + bool disabling_var = (penalty <= 0 && var->sharing_penalty_ > 0); XBT_IN("(sys=%p, var=%p, penalty=%f)", this, var, penalty); @@ -884,7 +872,7 @@ void System::update_constraint_bound(Constraint* cnst, double bound) * A recursive algorithm to optimize the system recalculation selecting only constraints that have changed. Each * constraint change is propagated to the list of constraints for each variable. */ -void System::update_modified_set_rec(Constraint* cnst) +void System::update_modified_set_rec(const Constraint* cnst) { for (Element const& elem : cnst->enabled_element_set_) { Variable* var = elem.variable; @@ -916,7 +904,7 @@ void System::remove_all_modified_set() // In effect, the var->visited value will no more be equal to visited counter // To be clean, when visited counter has wrapped around, we force these var->visited values so that variables that // were in the modified a long long time ago are not wrongly skipped here, which would lead to very nasty bugs - // (i.e. not readibily reproducible, and requiring a lot of run time before happening). + // (i.e. not readily reproducible, and requiring a lot of run time before happening). if (++visited_counter_ == 1) { /* the counter wrapped around, reset each variable->visited */ for (Variable& var : variable_set) @@ -954,6 +942,7 @@ int Constraint::get_variable_amount() const return std::count_if(std::begin(enabled_element_set_), std::end(enabled_element_set_), [](const Element& elem) { return elem.consumption_weight > 0; }); } -} -} -} + +} // namespace lmm +} // namespace kernel +} // namespace simgrid