static int lmm_can_enable_var(lmm_variable_t var);
static int lmm_cnstrs_min_concurrency_slack(lmm_variable_t var);
-static inline int lmm_element_concurrency(lmm_element_t elem)
+int s_lmm_element_t::get_concurrency() const
{
//Ignore element with weight less than one (e.g. cross-traffic)
- return (elem->consumption_weight >= 1) ? 1 : 0;
+ return (consumption_weight >= 1) ? 1 : 0;
//There are other alternatives, but they will change the behaviour 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.
//return (int)ceil(elem->weight);//Include element as the rounded-up integer value of the element weight
}
-static inline void lmm_decrease_concurrency(lmm_element_t elem)
+void s_lmm_element_t::decrease_concurrency()
{
- xbt_assert(elem->constraint->concurrency_current>=lmm_element_concurrency(elem));
- elem->constraint->concurrency_current-=lmm_element_concurrency(elem);
+ xbt_assert(constraint->concurrency_current >= get_concurrency());
+ constraint->concurrency_current -= get_concurrency();
}
-static inline void lmm_increase_concurrency(lmm_element_t elem)
+void s_lmm_element_t::increase_concurrency()
{
- elem->constraint->concurrency_current+= lmm_element_concurrency(elem);
+ constraint->concurrency_current += get_concurrency();
- lmm_constraint_t cnstr=elem->constraint;
+ if (constraint->concurrency_current > constraint->concurrency_maximum)
+ constraint->concurrency_maximum = constraint->concurrency_current;
- if(cnstr->concurrency_current > cnstr->concurrency_maximum)
- cnstr->concurrency_maximum= cnstr->concurrency_current;
-
- xbt_assert(cnstr->get_concurrency_limit() < 0 || cnstr->concurrency_current <= cnstr->get_concurrency_limit(),
+ xbt_assert(constraint->get_concurrency_limit() < 0 ||
+ constraint->concurrency_current <= constraint->get_concurrency_limit(),
"Concurrency limit overflow!");
}
{
lmm_element_t elem = (lmm_element_t)elemIt;
xbt_assert(elem->variable->sharing_weight > 0);
- concurrency += lmm_element_concurrency(elem);
+ concurrency += elem->get_concurrency();
}
xbt_swag_foreach(elemIt, &(cnst->disabled_element_set))
for (s_lmm_element_t& elem : var->cnsts) {
if (var->sharing_weight > 0)
- lmm_decrease_concurrency(&elem);
+ elem.decrease_concurrency();
xbt_swag_remove(&elem, &(elem.constraint->enabled_element_set));
xbt_swag_remove(&elem, &(elem.constraint->disabled_element_set));
xbt_swag_remove(&elem, &(elem.constraint->active_element_set));
if(var->concurrency_share>1){
for (s_lmm_element_t& elem : var->cnsts) {
if (elem.constraint == cnst && xbt_swag_belongs(&elem, &(elem.constraint->enabled_element_set)))
- current_share += lmm_element_concurrency(&elem);
+ current_share += elem.get_concurrency();
}
}
if (var->sharing_weight) {
xbt_swag_insert_at_head(&elem, &(elem.constraint->enabled_element_set));
- lmm_increase_concurrency(&elem);
+ elem.increase_concurrency();
} else
xbt_swag_insert_at_tail(&elem, &(elem.constraint->disabled_element_set));
if (elem_it != end(var->cnsts)) {
s_lmm_element_t& elem = *elem_it;
if (var->sharing_weight)
- lmm_decrease_concurrency(&elem);
+ elem.decrease_concurrency();
if (cnst->sharing_policy)
elem.consumption_weight += value;
//We need to check that increasing value of the element does not cross the concurrency limit
if (var->sharing_weight) {
- if (cnst->get_concurrency_slack() < lmm_element_concurrency(&elem)) {
+ if (cnst->get_concurrency_slack() < elem.get_concurrency()) {
double weight = var->sharing_weight;
disable_var(var);
for (s_lmm_element_t const& elem2 : var->cnsts)
var->staged_weight=weight;
xbt_assert(not var->sharing_weight);
}
- lmm_increase_concurrency(&elem);
+ elem.increase_concurrency();
}
update_modified_set(cnst);
} else
else if (cnst->usage < elem->consumption_weight / elem->variable->sharing_weight)
cnst->usage = elem->consumption_weight / elem->variable->sharing_weight;
- make_elem_active(elem);
+ elem->make_active();
simgrid::surf::Action *action = static_cast<simgrid::surf::Action*>(elem->variable->id);
if (keep_track && not action->is_linked())
keep_track->push_back(*action);
} else {
cnst->cnst_light->remaining_over_usage = cnst->remaining / cnst->usage;
}
- make_elem_inactive(&elem);
+ elem.make_inactive();
} else {
// Remember: non-shared constraints only require that max(elem.value * var->value) < cnst->bound
cnst->usage = 0.0;
- make_elem_inactive(&elem);
+ elem.make_inactive();
xbt_swag_t elem_list = &(cnst->enabled_element_set);
xbt_swag_foreach(_elem, elem_list) {
lmm_element_t elem2 = static_cast<lmm_element_t>(_elem);
for (s_lmm_element_t& elem : var->cnsts) {
xbt_swag_remove(&elem, &(elem.constraint->disabled_element_set));
xbt_swag_insert_at_head(&elem, &(elem.constraint->enabled_element_set));
- lmm_increase_concurrency(&elem);
+ elem.increase_concurrency();
}
if (not var->cnsts.empty())
update_modified_set(var->cnsts[0].constraint);
xbt_swag_remove(&elem, &(elem.constraint->active_element_set));
- lmm_decrease_concurrency(&elem);
+ elem.decrease_concurrency();
}
var->sharing_weight = 0.0;
* @brief LMM element
* Elements can be seen as glue between constraint objects and variable objects.
* Basically, each variable will have a set of elements, one for each constraint where it is involved.
- * Then, it is used to list all variables involved in constraint through constraint's xxx_element_set lists, or vice-versa list all constraints for a given variable.
+ * Then, it is used to list all variables involved in constraint through constraint's xxx_element_set lists, or
+ * vice-versa list all constraints for a given variable.
*/
-struct s_lmm_element_t {
+class s_lmm_element_t {
+public:
+ int get_concurrency() const;
+ void decrease_concurrency();
+ void increase_concurrency();
+
+ void make_active();
+ void make_inactive();
+
/* hookup to constraint */
s_xbt_swag_hookup_t enabled_element_set_hookup;
s_xbt_swag_hookup_t disabled_element_set_hookup;
// - If network, then 1 in forward direction and 0.05 backward for the ACKs
double consumption_weight;
};
-#define make_elem_active(elem) xbt_swag_insert_at_head((elem), &((elem)->constraint->active_element_set))
-#define make_elem_inactive(elem) xbt_swag_remove((elem), &((elem)->constraint->active_element_set))
struct s_lmm_constraint_light_t {
double remaining_over_usage;
/* \end{For Lagrange only} */
};
+inline void s_lmm_element_t::make_active()
+{
+ xbt_swag_insert_at_head(this, &constraint->active_element_set);
+}
+inline void s_lmm_element_t::make_inactive()
+{
+ xbt_swag_remove(this, &constraint->active_element_set);
+}
+
/** @ingroup SURF_lmm
* @brief LMM system
*/