-/* Copyright (c) 2004-2017. The SimGrid Team. All rights reserved. */
+/* Copyright (c) 2004-2018. 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. */
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)
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..
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()
while ((cnst = extract_constraint()))
cnst_free(cnst);
- xbt_mallocator_free(variable_mallocator);
+ xbt_mallocator_free(variable_mallocator_);
+ delete modified_set_;
}
void System::cnst_free(Constraint* cnst)
delete static_cast<Variable*>(var);
}
-Variable* System::variable_new(simgrid::surf::Action* id, double sharing_weight, double bound,
+Variable* System::variable_new(simgrid::kernel::resource::Action* id, double sharing_weight, double bound,
int number_of_constraints)
{
XBT_IN("(sys=%p, id=%p, weight=%f, bound=%f, num_cons =%d)", this, id, sharing_weight, bound, number_of_constraints);
- Variable* var = static_cast<Variable*>(xbt_mallocator_get(variable_mallocator));
- var->initialize(id, sharing_weight, bound, number_of_constraints, visited_counter - 1);
+ Variable* var = static_cast<Variable*>(xbt_mallocator_get(variable_mallocator_));
+ var->initialize(id, sharing_weight, bound, number_of_constraints, visited_counter_ - 1);
if (sharing_weight)
variable_set.push_front(*var);
else
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
void System::expand_add(Constraint* cnst, Variable* var, double value)
{
- modified = true;
+ modified_ = true;
check_concurrency();
}
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)*/
}
}
-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 <class CnstList> void System::solve(CnstList& cnst_list)
+template <class CnstList> void System::lmm_solve(CnstList& cnst_list)
{
double min_usage = -1;
double min_bound = -1;
cnst.usage = elem.consumption_weight / elem.variable->sharing_weight;
elem.make_active();
- simgrid::surf::Action* action = static_cast<simgrid::surf::Action*>(elem.variable->id);
- if (keep_track && not action->isLinkedModifiedSet())
- keep_track->push_back(*action);
+ simgrid::kernel::resource::Action* action = static_cast<simgrid::kernel::resource::Action*>(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,
} while (cnst_light_num > 0);
- modified = false;
+ modified_ = false;
if (selective_update_active)
remove_all_modified_set();
delete[] cnst_light_tab;
}
-void lmm_solve(lmm_system_t sys)
-{
- sys->solve();
-}
-
/** \brief Attribute the value bound to var->bound.
*
* \param var the Variable*
*/
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(simgrid::kernel::resource::Action* id_value, double sharing_weight_value, double bound_value,
int number_of_constraints, unsigned visited_value)
{
id = id_value;
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());
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;
XBT_IN("(sys=%p, var=%p, weight=%f)", this, var, weight);
- modified = true;
+ modified_ = true;
// Are we enabling this variable?
if (enabling_var) {
void System::update_constraint_bound(Constraint* cnst, double bound)
{
- modified = true;
+ modified_ = true;
update_modified_set(cnst);
cnst->bound = bound;
}
for (Element const& elem : cnst->enabled_element_set) {
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);
}
}
// var will be ignored in later visits as long as sys->visited_counter does not move
- var->visited = visited_counter;
+ var->visited = 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).
- if (++visited_counter == 1) {
+ if (++visited_counter_ == 1) {
/* the counter wrapped around, reset each variable->visited */
for (Variable& var : variable_set)
var.visited = 0;
