X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/fa534df82cd3c349ac38f25096850568fdcf1e9d..2d37e348a09783cda723c7019640ee69de168324:/src/kernel/lmm/maxmin.cpp diff --git a/src/kernel/lmm/maxmin.cpp b/src/kernel/lmm/maxmin.cpp index 633dc21b66..a39eaa646b 100644 --- a/src/kernel/lmm/maxmin.cpp +++ b/src/kernel/lmm/maxmin.cpp @@ -1,22 +1,11 @@ -/* Copyright (c) 2004-2017. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2004-2019. 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. */ -/* \file callbacks.h */ - #include "src/kernel/lmm/maxmin.hpp" +#include "src/surf/surf_interface.hpp" #include "xbt/backtrace.hpp" -#include "xbt/log.h" -#include "xbt/mallocator.h" -#include "xbt/sysdep.h" -#include "xbt/utility.hpp" -#include -#include -#include -#include -#include -#include XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_maxmin, surf, "Logging specific to SURF (maxmin)"); @@ -33,6 +22,11 @@ typedef std::vector dyn_light_t; int Variable::Global_debug_id = 1; int Constraint::Global_debug_id = 1; +System* make_new_maxmin_system(bool selective_update) +{ + return new System(selective_update); +} + int Element::get_concurrency() const { // Ignore element with weight less than one (e.g. cross-traffic) @@ -109,10 +103,10 @@ void System::check_concurrency() const } } -void System::var_free(lmm_variable_t var) +void System::var_free(Variable* var) { XBT_IN("(sys=%p, var=%p)", this, var); - modified = true; + modified_ = true; // TODOLATER Can do better than that by leaving only the variable in only one enabled_element_set, call // update_modified_set, and then remove it.. @@ -139,27 +133,22 @@ void System::var_free(lmm_variable_t var) check_concurrency(); - xbt_mallocator_release(variable_mallocator, var); + xbt_mallocator_release(variable_mallocator_, var); XBT_OUT(); } System::System(bool selective_update) : selective_update_active(selective_update) { - modified = false; - visited_counter = 1; - XBT_DEBUG("Setting selective_update_active flag to %d", selective_update_active); - keep_track = nullptr; - variable_mallocator = - xbt_mallocator_new(65536, System::variable_mallocator_new_f, System::variable_mallocator_free_f, nullptr); - solve_fun = &lmm_solve; + if (selective_update) + modified_set_ = new kernel::resource::Action::ModifiedSet(); } System::~System() { - lmm_variable_t var; - lmm_constraint_t cnst; + Variable* var; + Constraint* cnst; while ((var = extract_variable())) { auto demangled = simgrid::xbt::demangle(typeid(*var->id).name()); @@ -170,10 +159,11 @@ System::~System() while ((cnst = extract_constraint())) cnst_free(cnst); - xbt_mallocator_free(variable_mallocator); + xbt_mallocator_free(variable_mallocator_); + delete modified_set_; } -void System::cnst_free(lmm_constraint_t cnst) +void System::cnst_free(Constraint* cnst) { make_constraint_inactive(cnst); delete cnst; @@ -188,16 +178,16 @@ Constraint::Constraint(void* id_value, double bound_value) : bound(bound_value), concurrency_limit = sg_concurrency_limit; concurrency_current = 0; concurrency_maximum = 0; - sharing_policy = 1; /* FIXME: don't hardcode the value */ + sharing_policy = s4u::Link::SharingPolicy::SHARED; lambda = 0.0; new_lambda = 0.0; cnst_light = nullptr; } -lmm_constraint_t System::constraint_new(void* id, double bound_value) +Constraint* System::constraint_new(void* id, double bound_value) { - lmm_constraint_t cnst = new Constraint(id, bound_value); + Constraint* cnst = new Constraint(id, bound_value); insert_constraint(cnst); return cnst; } @@ -209,17 +199,16 @@ void* System::variable_mallocator_new_f() void System::variable_mallocator_free_f(void* var) { - delete static_cast(var); + delete static_cast(var); } -lmm_variable_t System::variable_new(simgrid::surf::Action* id, double sharing_weight, double bound, - int number_of_constraints) +Variable* System::variable_new(resource::Action* id, double sharing_weight, double bound, size_t number_of_constraints) { - XBT_IN("(sys=%p, id=%p, weight=%f, bound=%f, num_cons =%d)", this, id, sharing_weight, bound, number_of_constraints); + XBT_IN("(sys=%p, id=%p, weight=%f, bound=%f, num_cons =%zu)", this, id, sharing_weight, bound, number_of_constraints); - lmm_variable_t var = static_cast(xbt_mallocator_get(variable_mallocator)); - var->initialize(id, sharing_weight, bound, number_of_constraints, visited_counter - 1); - if (sharing_weight) + Variable* var = static_cast(xbt_mallocator_get(variable_mallocator_)); + var->initialize(id, sharing_weight, bound, number_of_constraints, visited_counter_ - 1); + if (sharing_weight > 0) variable_set.push_front(*var); else variable_set.push_back(*var); @@ -228,15 +217,15 @@ lmm_variable_t System::variable_new(simgrid::surf::Action* id, double sharing_we return var; } -void System::variable_free(lmm_variable_t var) +void System::variable_free(Variable* var) { remove_variable(var); var_free(var); } -void System::expand(lmm_constraint_t cnst, lmm_variable_t var, double consumption_weight) +void System::expand(Constraint* cnst, Variable* var, double consumption_weight) { - modified = true; + modified_ = true; // Check if this variable already has an active element in this constraint // If it does, substract it from the required slack @@ -287,9 +276,9 @@ void System::expand(lmm_constraint_t cnst, lmm_variable_t var, double consumptio check_concurrency(); } -void System::expand_add(lmm_constraint_t cnst, lmm_variable_t var, double value) +void System::expand_add(Constraint* cnst, Variable* var, double value) { - modified = true; + modified_ = true; check_concurrency(); @@ -301,7 +290,7 @@ void System::expand_add(lmm_constraint_t cnst, lmm_variable_t var, double value) if (var->sharing_weight) elem.decrease_concurrency(); - if (cnst->sharing_policy) + if (cnst->sharing_policy != s4u::Link::SharingPolicy::FATPIPE) elem.consumption_weight += value; else elem.consumption_weight = std::max(elem.consumption_weight, value); @@ -325,7 +314,7 @@ void System::expand_add(lmm_constraint_t cnst, lmm_variable_t var, double value) check_concurrency(); } -lmm_variable_t Constraint::get_variable(const_lmm_element_t* elem) const +Variable* Constraint::get_variable(const Element** elem) const { if (*elem == nullptr) { // That is the first call, pick the first element among enabled_element_set (or disabled_element_set if @@ -360,8 +349,7 @@ lmm_variable_t Constraint::get_variable(const_lmm_element_t* elem) const // if we modify the list between calls, normal version may loop forever // this safe version ensures that we browse the list elements only once -lmm_variable_t Constraint::get_variable_safe(const_lmm_element_t* elem, const_lmm_element_t* nextelem, - int* numelem) const +Variable* Constraint::get_variable_safe(const Element** elem, const Element** nextelem, int* numelem) const { if (*elem == nullptr) { *numelem = enabled_element_set.size() + disabled_element_set.size() - 1; @@ -413,7 +401,7 @@ static inline void saturated_constraints_update(double usage, int cnst_light_num } static inline void saturated_variable_set_update(ConstraintLight* cnst_light_tab, - const dyn_light_t& saturated_constraints, lmm_system_t sys) + 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)*/ @@ -429,12 +417,14 @@ static inline void saturated_variable_set_update(ConstraintLight* cnst_light_tab } template -static void format_element_list(const ElemList& elem_list, int sharing_policy, double& sum, std::string& buf) +static void format_element_list(const ElemList& elem_list, s4u::Link::SharingPolicy sharing_policy, double& sum, + std::string& buf) { for (Element const& elem : elem_list) { buf += std::to_string(elem.consumption_weight) + ".'" + std::to_string(elem.variable->id_int) + "'(" + - std::to_string(elem.variable->value) + ")" + (sharing_policy ? " + " : " , "); - if (sharing_policy) + std::to_string(elem.variable->value) + ")" + + (sharing_policy != s4u::Link::SharingPolicy::FATPIPE ? " + " : " , "); + if (sharing_policy != s4u::Link::SharingPolicy::FATPIPE) sum += elem.consumption_weight * elem.variable->value; else sum = std::max(sum, elem.consumption_weight * elem.variable->value); @@ -458,14 +448,14 @@ void System::print() const double sum = 0.0; // Show the enabled variables buf += "\t"; - buf += cnst.sharing_policy ? "(" : "max("; + buf += cnst.sharing_policy != s4u::Link::SharingPolicy::FATPIPE ? "(" : "max("; format_element_list(cnst.enabled_element_set, cnst.sharing_policy, sum, buf); // TODO: Adding disabled elements only for test compatibility, but do we really want them to be printed? format_element_list(cnst.disabled_element_set, cnst.sharing_policy, sum, buf); buf += "0) <= " + std::to_string(cnst.bound) + " ('" + std::to_string(cnst.id_int) + "')"; - if (not cnst.sharing_policy) { + if (cnst.sharing_policy == s4u::Link::SharingPolicy::FATPIPE) { buf += " [MAX-Constraint]"; } XBT_DEBUG("%s", buf.c_str()); @@ -487,22 +477,22 @@ void System::print() const } } -void System::solve() +void System::lmm_solve() { - if (modified) { + if (modified_) { XBT_IN("(sys=%p)", this); /* Compute Usage and store the variables that reach the maximum. If selective_update_active is true, only * constraints that changed are considered. Otherwise all constraints with active actions are considered. */ if (selective_update_active) - solve(modified_constraint_set); + lmm_solve(modified_constraint_set); else - solve(active_constraint_set); + lmm_solve(active_constraint_set); XBT_OUT(); } } -template void System::solve(CnstList& cnst_list) +template void System::lmm_solve(CnstList& cnst_list) { double min_usage = -1; double min_bound = -1; @@ -530,15 +520,15 @@ template void System::solve(CnstList& cnst_list) for (Element& elem : cnst.enabled_element_set) { xbt_assert(elem.variable->sharing_weight > 0); if (elem.consumption_weight > 0) { - if (cnst.sharing_policy) + if (cnst.sharing_policy != s4u::Link::SharingPolicy::FATPIPE) cnst.usage += elem.consumption_weight / elem.variable->sharing_weight; else if (cnst.usage < elem.consumption_weight / elem.variable->sharing_weight) cnst.usage = elem.consumption_weight / elem.variable->sharing_weight; elem.make_active(); - simgrid::surf::Action* action = static_cast(elem.variable->id); - if (keep_track && not action->is_linked()) - keep_track->push_back(*action); + resource::Action* action = static_cast(elem.variable->id); + if (modified_set_ && not action->is_within_modified_set()) + modified_set_->push_back(*action); } } XBT_DEBUG("Constraint '%d' usage: %f remaining: %f concurrency: %i<=%i<=%i", cnst.id_int, cnst.usage, @@ -602,8 +592,8 @@ template void System::solve(CnstList& cnst_list) /* Update the usage of contraints where this variable is involved */ for (Element& elem : var.cnsts) { - lmm_constraint_t cnst = elem.constraint; - if (cnst->sharing_policy) { + Constraint* cnst = elem.constraint; + if (cnst->sharing_policy != s4u::Link::SharingPolicy::FATPIPE) { // Remember: shared constraints require that sum(elem.value * var.value) < cnst->bound double_update(&(cnst->remaining), elem.consumption_weight * var.value, cnst->bound * sg_maxmin_precision); double_update(&(cnst->usage), elem.consumption_weight / var.sharing_weight, sg_maxmin_precision); @@ -678,7 +668,7 @@ template void System::solve(CnstList& cnst_list) } while (cnst_light_num > 0); - modified = false; + modified_ = false; if (selective_update_active) remove_all_modified_set(); @@ -691,29 +681,24 @@ template void System::solve(CnstList& cnst_list) delete[] cnst_light_tab; } -void lmm_solve(lmm_system_t sys) -{ - sys->solve(); -} - -/** \brief Attribute the value bound to var->bound. +/** @brief Attribute the value bound to var->bound. * - * \param var the lmm_variable_t - * \param bound the new bound to associate with var + * @param var the Variable* + * @param bound the new bound to associate with var * * Makes var->bound equal to bound. Whenever this function is called a change is signed in the system. To * avoid false system changing detection it is a good idea to test (bound != 0) before calling it. */ -void System::update_variable_bound(lmm_variable_t var, double bound) +void System::update_variable_bound(Variable* var, double bound) { - modified = true; + modified_ = true; var->bound = bound; if (not var->cnsts.empty()) update_modified_set(var->cnsts[0].constraint); } -void Variable::initialize(simgrid::surf::Action* id_value, double sharing_weight_value, double bound_value, +void Variable::initialize(resource::Action* id_value, double sharing_weight_value, double bound_value, int number_of_constraints, unsigned visited_value) { id = id_value; @@ -727,9 +712,6 @@ void Variable::initialize(simgrid::surf::Action* id_value, double sharing_weight visited = visited_value; mu = 0.0; new_mu = 0.0; - func_f = func_f_def; - func_fp = func_fp_def; - func_fpi = func_fpi_def; xbt_assert(not variable_set_hook.is_linked()); xbt_assert(not saturated_variable_set_hook.is_linked()); @@ -754,7 +736,7 @@ int Variable::get_min_concurrency_slack() const // with var when running System::update_modified_set(). // A priori not a big performance issue, but we might do better by calling System::update_modified_set() within the for // loops (after doing the first for enabling==1, and before doing the last for disabling==1) -void System::enable_var(lmm_variable_t var) +void System::enable_var(Variable* var) { xbt_assert(not XBT_LOG_ISENABLED(surf_maxmin, xbt_log_priority_debug) || var->can_enable()); @@ -779,7 +761,7 @@ void System::enable_var(lmm_variable_t var) // Anyway, caller functions all call check_concurrency() in the end. } -void System::disable_var(lmm_variable_t var) +void System::disable_var(Variable* var) { xbt_assert(not var->staged_weight, "Staged weight should have been cleared"); // Disabling the variable, move to var to list tail. Subtlety is: here, we need to call update_modified_set @@ -809,7 +791,7 @@ void System::disable_var(lmm_variable_t var) * If yes, check that none of the constraints that this variable is involved in is at the limit of its concurrency * And then add it to enabled variables */ -void System::on_disabled_var(lmm_constraint_t cnstr) +void System::on_disabled_var(Constraint* cnstr) { if (cnstr->get_concurrency_limit() < 0) return; @@ -818,12 +800,12 @@ void System::on_disabled_var(lmm_constraint_t cnstr) if (not numelem) return; - lmm_element_t elem = &cnstr->disabled_element_set.front(); + Element* elem = &cnstr->disabled_element_set.front(); // Cannot use foreach loop, because System::enable_var() will modify disabled_element_set.. within the loop while (numelem-- && elem) { - lmm_element_t nextelem; + Element* nextelem; if (elem->disabled_element_set_hook.is_linked()) { auto iter = std::next(cnstr->disabled_element_set.iterator_to(*elem)); nextelem = iter != std::end(cnstr->disabled_element_set) ? &*iter : nullptr; @@ -850,10 +832,10 @@ void System::on_disabled_var(lmm_constraint_t cnstr) // Anyway, caller functions all call check_concurrency() in the end. } -/* \brief update the weight of a variable, and enable/disable it. +/* @brief update the weight of a variable, and enable/disable it. * @return Returns whether a change was made */ -void System::update_variable_weight(lmm_variable_t var, double weight) +void System::update_variable_weight(Variable* var, double weight) { xbt_assert(weight >= 0, "Variable weight should not be negative!"); @@ -865,7 +847,7 @@ void System::update_variable_weight(lmm_variable_t var, double weight) XBT_IN("(sys=%p, var=%p, weight=%f)", this, var, weight); - modified = true; + modified_ = true; // Are we enabling this variable? if (enabling_var) { @@ -891,27 +873,27 @@ void System::update_variable_weight(lmm_variable_t var, double weight) XBT_OUT(); } -void System::update_constraint_bound(lmm_constraint_t cnst, double bound) +void System::update_constraint_bound(Constraint* cnst, double bound) { - modified = true; + modified_ = true; update_modified_set(cnst); cnst->bound = bound; } -/** \brief Update the constraint set propagating recursively to other constraints so the system should not be entirely +/** @brief Update the constraint set propagating recursively to other constraints so the system should not be entirely * computed. * - * \param cnst the lmm_constraint_t affected by the change + * @param cnst the Constraint* affected by the change * * 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(lmm_constraint_t cnst) +void System::update_modified_set_rec(Constraint* cnst) { for (Element const& elem : cnst->enabled_element_set) { - lmm_variable_t var = elem.variable; + Variable* var = elem.variable; for (Element const& elem2 : var->cnsts) { - if (var->visited == visited_counter) + if (var->visited == visited_counter_) break; if (elem2.constraint != cnst && not elem2.constraint->modified_constraint_set_hook.is_linked()) { modified_constraint_set.push_back(*elem2.constraint); @@ -919,11 +901,11 @@ void System::update_modified_set_rec(lmm_constraint_t cnst) } } // var will be ignored in later visits as long as sys->visited_counter does not move - var->visited = visited_counter; + var->visited = visited_counter_; } } -void System::update_modified_set(lmm_constraint_t cnst) +void System::update_modified_set(Constraint* cnst) { /* nothing to do if selective update isn't active */ if (selective_update_active && not cnst->modified_constraint_set_hook.is_linked()) { @@ -939,7 +921,7 @@ void System::remove_all_modified_set() // 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). - if (++visited_counter == 1) { + if (++visited_counter_ == 1) { /* the counter wrapped around, reset each variable->visited */ for (Variable& var : variable_set) var.visited = 0; @@ -950,16 +932,16 @@ void System::remove_all_modified_set() /** * Returns resource load (in flop per second, or byte per second, or similar) * - * If the resource is shared (the default case), the load is sum of resource usage made by every variables located on - * this resource. + * If the resource is shared (the default case), the load is sum of resource usage made by + * every variables located on this resource. * - * 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. + * 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 result = 0.0; - if (sharing_policy) { + if (sharing_policy != s4u::Link::SharingPolicy::FATPIPE) { for (Element const& elem : enabled_element_set) if (elem.consumption_weight > 0) result += elem.consumption_weight * elem.variable->value;