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(),
// 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();
}
}
}
-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())
// 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;
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);
* 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;