From: Arnaud Giersch <arnaud.giersch@univ-fcomte.fr>
Date: Tue, 14 Nov 2017 17:01:35 +0000 (+0100)
Subject: Use std::vector for s_lmm_element_t::cnsts.
X-Git-Tag: v3.18~242^2~33
X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/commitdiff_plain/bd76919be169a04d524d59aaad0698411793a410

Use std::vector for s_lmm_element_t::cnsts.
---

diff --git a/src/include/surf/maxmin.hpp b/src/include/surf/maxmin.hpp
index bdf2977e50..51b0da0b57 100644
--- a/src/include/surf/maxmin.hpp
+++ b/src/include/surf/maxmin.hpp
@@ -299,7 +299,7 @@ XBT_PUBLIC(void) lmm_expand_add(lmm_system_t sys, lmm_constraint_t cnst, lmm_var
  * @param num The rank of constraint we want to get
  * @return The numth constraint
  */
-XBT_PUBLIC(lmm_constraint_t) lmm_get_cnst_from_var(lmm_system_t sys, lmm_variable_t var, int num);
+XBT_PUBLIC(lmm_constraint_t) lmm_get_cnst_from_var(lmm_system_t sys, lmm_variable_t var, unsigned num);
 
 /**
  * @brief Get the weigth of the numth constraint associated to the variable
@@ -308,7 +308,7 @@ XBT_PUBLIC(lmm_constraint_t) lmm_get_cnst_from_var(lmm_system_t sys, lmm_variabl
  * @param num The rank of constraint we want to get
  * @return The numth constraint
  */
-XBT_PUBLIC(double) lmm_get_cnst_weight_from_var(lmm_system_t sys, lmm_variable_t var, int num);
+XBT_PUBLIC(double) lmm_get_cnst_weight_from_var(lmm_system_t sys, lmm_variable_t var, unsigned num);
 
 /**
  * @brief Get the number of constraint associated to a variable
diff --git a/src/surf/fair_bottleneck.cpp b/src/surf/fair_bottleneck.cpp
index 2a0fcb7c8f..a61385c690 100644
--- a/src/surf/fair_bottleneck.cpp
+++ b/src/surf/fair_bottleneck.cpp
@@ -7,6 +7,7 @@
 #include "maxmin_private.hpp"
 #include "xbt/log.h"
 #include "xbt/sysdep.h"
+#include <algorithm>
 #include <cfloat>
 #include <cmath>
 #include <cstdlib>
@@ -43,15 +44,12 @@ void bottleneck_solve(lmm_system_t sys)
   XBT_DEBUG("Variable set : %d", xbt_swag_size(var_list));
   xbt_swag_foreach(_var, var_list) {
     var = static_cast<lmm_variable_t>(_var);
-    int nb = 0;
     var->value = 0.0;
     XBT_DEBUG("Handling variable %p", var);
     xbt_swag_insert(var, &(sys->saturated_variable_set));
-    for (int i = 0; i < var->cnsts_number; i++) {
-      if (var->cnsts[i].consumption_weight == 0.0)
-        nb++;
-    }
-    if ((nb == var->cnsts_number) && (var->sharing_weight > 0.0)) {
+    auto weighted = std::find_if(begin(var->cnsts), end(var->cnsts),
+                                 [](s_lmm_element_t const& x) { return x.consumption_weight != 0.0; });
+    if (weighted == end(var->cnsts) && var->sharing_weight > 0.0) {
       XBT_DEBUG("Err, finally, there is no need to take care of variable %p", var);
       xbt_swag_remove(var, &(sys->saturated_variable_set));
       var->value = 1.0;
@@ -115,10 +113,9 @@ void bottleneck_solve(lmm_system_t sys)
     xbt_swag_foreach_safe(_var, _var_next, var_list) {
       var = static_cast<lmm_variable_t>(_var);
       double min_inc = DBL_MAX;
-      for (int i = 0; i < var->cnsts_number; i++) {
-        lmm_element_t elm = &var->cnsts[i];
-        if (elm->consumption_weight > 0)
-          min_inc = MIN(min_inc, elm->constraint->usage / elm->consumption_weight);
+      for (s_lmm_element_t const& elm : var->cnsts) {
+        if (elm.consumption_weight > 0)
+          min_inc = MIN(min_inc, elm.constraint->usage / elm.consumption_weight);
       }
       if (var->bound > 0)
         min_inc = MIN(min_inc, var->bound - var->value);
diff --git a/src/surf/lagrange.cpp b/src/surf/lagrange.cpp
index 91073c0949..2a25fdc3d3 100644
--- a/src/surf/lagrange.cpp
+++ b/src/surf/lagrange.cpp
@@ -11,6 +11,7 @@
 #include "xbt/sysdep.h"
 #include "maxmin_private.hpp"
 
+#include <algorithm>
 #include <cstdlib>
 #ifndef MATH
 #include <cmath>
@@ -86,8 +87,8 @@ static double new_value(lmm_variable_t var)
 {
   double tmp = 0;
 
-  for (int i = 0; i < var->cnsts_number; i++) {
-    tmp += (var->cnsts[i].constraint)->lambda;
+  for (s_lmm_element_t const& elem : var->cnsts) {
+    tmp += elem.constraint->lambda;
   }
   if (var->bound > 0)
     tmp += var->mu;
@@ -101,8 +102,8 @@ static double new_mu(lmm_variable_t var)
   double mu_i = 0.0;
   double sigma_i = 0.0;
 
-  for (int j = 0; j < var->cnsts_number; j++) {
-    sigma_i += (var->cnsts[j].constraint)->lambda;
+  for (s_lmm_element_t const& elem : var->cnsts) {
+    sigma_i += elem.constraint->lambda;
   }
   mu_i = var->func_fp(var, var->bound) - sigma_i;
   if (mu_i < 0.0)
@@ -126,8 +127,8 @@ static double dual_objective(xbt_swag_t var_list, xbt_swag_t cnst_list)
     if (not var->sharing_weight)
       break;
 
-    for (int j = 0; j < var->cnsts_number; j++)
-      sigma_i += (var->cnsts[j].constraint)->lambda;
+    for (s_lmm_element_t const& elem : var->cnsts)
+      sigma_i += elem.constraint->lambda;
 
     if (var->bound > 0)
       sigma_i += var->mu;
@@ -200,30 +201,27 @@ void lagrange_solve(lmm_system_t sys)
   var_list = &(sys->variable_set);
   i = 0;
   xbt_swag_foreach(_var, var_list) {
-  var = static_cast<lmm_variable_t>(_var);
-  if (not var->sharing_weight)
-    var->value = 0.0;
-  else {
-    int nb = 0;
-    if (var->bound < 0.0) {
-      XBT_DEBUG("#### NOTE var(%d) is a boundless variable", i);
-      var->mu    = -1.0;
-      var->value = new_value(var);
-    } else {
-      var->mu     = 1.0;
-      var->new_mu = 2.0;
-      var->value  = new_value(var);
-    }
-    XBT_DEBUG("#### var(%p) ->weight :  %e", var, var->sharing_weight);
-    XBT_DEBUG("#### var(%p) ->mu :  %e", var, var->mu);
-    XBT_DEBUG("#### var(%p) ->weight: %e", var, var->sharing_weight);
-    XBT_DEBUG("#### var(%p) ->bound: %e", var, var->bound);
-    for (i = 0; i < var->cnsts_number; i++) {
-      if (var->cnsts[i].consumption_weight == 0.0)
-        nb++;
-    }
-    if (nb == var->cnsts_number)
-      var->value = 1.0;
+    var = static_cast<lmm_variable_t>(_var);
+    if (not var->sharing_weight)
+      var->value = 0.0;
+    else {
+      if (var->bound < 0.0) {
+        XBT_DEBUG("#### NOTE var(%d) is a boundless variable", i);
+        var->mu    = -1.0;
+        var->value = new_value(var);
+      } else {
+        var->mu     = 1.0;
+        var->new_mu = 2.0;
+        var->value  = new_value(var);
+      }
+      XBT_DEBUG("#### var(%p) ->weight :  %e", var, var->sharing_weight);
+      XBT_DEBUG("#### var(%p) ->mu :  %e", var, var->mu);
+      XBT_DEBUG("#### var(%p) ->weight: %e", var, var->sharing_weight);
+      XBT_DEBUG("#### var(%p) ->bound: %e", var, var->bound);
+      auto weighted = std::find_if(begin(var->cnsts), end(var->cnsts),
+                                   [](s_lmm_element_t const& x) { return x.consumption_weight != 0.0; });
+      if (weighted == end(var->cnsts))
+        var->value = 1.0;
     }
   }
 
@@ -435,8 +433,8 @@ static double partial_diff_lambda(double lambda, void *param_cnst)
     double sigma_i = 0.0;
 
     // Compute sigma_i
-    for (int j = 0; j < var->cnsts_number; j++) {
-      sigma_i += (var->cnsts[j].constraint)->lambda;
+    for (s_lmm_element_t const& elem : var->cnsts) {
+      sigma_i += elem.constraint->lambda;
     }
 
     //add mu_i if this flow has a RTT constraint associated
diff --git a/src/surf/maxmin.cpp b/src/surf/maxmin.cpp
index f65e4e96c9..cb02c9cbe9 100644
--- a/src/surf/maxmin.cpp
+++ b/src/surf/maxmin.cpp
@@ -9,6 +9,7 @@
 #include "xbt/log.h"
 #include "xbt/mallocator.h"
 #include "xbt/sysdep.h"
+#include <algorithm>
 #include <cmath>
 #include <cstdlib>
 #include <cxxabi.h>
@@ -106,7 +107,7 @@ static void lmm_check_concurrency(lmm_system_t sys)
   {
     lmm_variable_t var = (lmm_variable_t)varIt;
 
-    if (not var->cnsts_number)
+    if (var->cnsts.empty())
       continue;
 
     lmm_element_t elem     = &var->cnsts[0];
@@ -114,13 +115,12 @@ static void lmm_check_concurrency(lmm_system_t sys)
     int belong_to_disabled = xbt_swag_belongs(elem, &(elem->constraint->disabled_element_set));
     int belong_to_active   = xbt_swag_belongs(elem, &(elem->constraint->active_element_set));
 
-    for (int i = 1; i < var->cnsts_number; i++) {
-      elem = &var->cnsts[i];
-      xbt_assert(belong_to_enabled == xbt_swag_belongs(elem, &(elem->constraint->enabled_element_set)),
+    for (s_lmm_element_t const& elem : var->cnsts) {
+      xbt_assert(belong_to_enabled == xbt_swag_belongs(&elem, &(elem.constraint->enabled_element_set)),
                  "Variable inconsistency (1): enabled_element_set");
-      xbt_assert(belong_to_disabled == xbt_swag_belongs(elem, &(elem->constraint->disabled_element_set)),
+      xbt_assert(belong_to_disabled == xbt_swag_belongs(&elem, &(elem.constraint->disabled_element_set)),
                  "Variable inconsistency (2): disabled_element_set");
-      xbt_assert(belong_to_active == xbt_swag_belongs(elem, &(elem->constraint->active_element_set)),
+      xbt_assert(belong_to_active == xbt_swag_belongs(&elem, &(elem.constraint->active_element_set)),
                  "Variable inconsistency (3): active_element_set");
     }
   }
@@ -133,33 +133,31 @@ static inline void lmm_variable_remove(lmm_system_t sys, lmm_variable_t var)
 
   // TODOLATER Can do better than that by leaving only the variable in only one enabled_element_set, call
   // lmm_update_modified_set, and then remove it..
-  if (var->cnsts_number)
+  if (not var->cnsts.empty())
     lmm_update_modified_set(sys, var->cnsts[0].constraint);
 
-  for (int i = 0; i < var->cnsts_number; i++) {
-    lmm_element_t elem = &var->cnsts[i];
+  for (s_lmm_element_t& elem : var->cnsts) {
     if (var->sharing_weight > 0)
-      lmm_decrease_concurrency(elem);
-    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));
-    int nelements = xbt_swag_size(&(elem->constraint->enabled_element_set)) +
-                    xbt_swag_size(&(elem->constraint->disabled_element_set));
+      lmm_decrease_concurrency(&elem);
+    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));
+    int nelements = xbt_swag_size(&(elem.constraint->enabled_element_set)) +
+                    xbt_swag_size(&(elem.constraint->disabled_element_set));
     if (nelements == 0)
-      make_constraint_inactive(sys, elem->constraint);
+      make_constraint_inactive(sys, elem.constraint);
     else
-      lmm_on_disabled_var(sys, elem->constraint);
+      lmm_on_disabled_var(sys, elem.constraint);
   }
 
   // Check if we can enable new variables going through the constraints where var was.
-  // Do it after removing all elements, so he first disabled variables get priority over those with smaller requirement
-  for (int i = 0; i < var->cnsts_number; i++) {
-    lmm_element_t elem = &var->cnsts[i];
-    if (xbt_swag_size(&(elem->constraint->disabled_element_set)))
-      lmm_on_disabled_var(sys, elem->constraint);
+  // Do it after removing all elements, so the first disabled variables get priority over those with smaller requirement
+  for (s_lmm_element_t& elem : var->cnsts) {
+    if (xbt_swag_size(&(elem.constraint->disabled_element_set)))
+      lmm_on_disabled_var(sys, elem.constraint);
   }
 
-  var->cnsts_number = 0;
+  var->cnsts.clear();
 
   lmm_check_concurrency(sys);
 
@@ -310,14 +308,11 @@ inline void lmm_constraint_free(lmm_system_t sys,lmm_constraint_t cnst)
 
 static void *lmm_variable_mallocator_new_f()
 {
-  lmm_variable_t var = new s_lmm_variable_t;
-  var->cnsts = nullptr; /* will be created by realloc */
-  return var;
+  return new s_lmm_variable_t;
 }
 
 static void lmm_variable_mallocator_free_f(void *var)
 {
-  xbt_free(((lmm_variable_t) var)->cnsts);
   delete static_cast<lmm_variable_t>(var);
 }
 
@@ -329,20 +324,7 @@ lmm_variable_t lmm_variable_new(lmm_system_t sys, simgrid::surf::Action* id, dou
   lmm_variable_t var = (lmm_variable_t)xbt_mallocator_get(sys->variable_mallocator);
   var->id = id;
   var->id_int = Global_debug_id++;
-  var->cnsts = static_cast<s_lmm_element_t*>(xbt_realloc(var->cnsts, number_of_constraints * sizeof(s_lmm_element_t)));
-  for (int i = 0; i < number_of_constraints; i++) {
-    var->cnsts[i].enabled_element_set_hookup.next = nullptr;
-    var->cnsts[i].enabled_element_set_hookup.prev = nullptr;
-    var->cnsts[i].disabled_element_set_hookup.next = nullptr;
-    var->cnsts[i].disabled_element_set_hookup.prev = nullptr;
-    var->cnsts[i].active_element_set_hookup.next = nullptr;
-    var->cnsts[i].active_element_set_hookup.prev = nullptr;
-    var->cnsts[i].constraint = nullptr;
-    var->cnsts[i].variable = nullptr;
-    var->cnsts[i].consumption_weight               = 0.0;
-  }
-  var->cnsts_size = number_of_constraints;
-  var->cnsts_number = 0;
+  var->cnsts.reserve(number_of_constraints);
   var->sharing_weight    = sharing_weight;
   var->staged_weight = 0.0;
   var->bound = bound;
@@ -392,26 +374,18 @@ double lmm_variable_getbound(lmm_variable_t var)
 
 void lmm_shrink(lmm_system_t sys, lmm_constraint_t cnst, lmm_variable_t var)
 {
-  lmm_element_t elem = nullptr;
-  int found = 0;
-
-  for (int i = 0; i < var->cnsts_number; i++) {
-    elem = &(var->cnsts[i]);
-    if (elem->constraint == cnst) {
-      found = 1;
-      break;
-    }
-  }
-
-  if (not found) {
+  auto elem_it = std::find_if(begin(var->cnsts), end(var->cnsts),
+                              [&cnst](s_lmm_element_t const& x) { return x.constraint == cnst; });
+  if (elem_it == end(var->cnsts)) {
     XBT_DEBUG("cnst %p is not found in var %p", cnst, var);
     return;
   }
+  s_lmm_element_t& elem = *elem_it;
 
   sys->modified = 1;
 
-  XBT_DEBUG("remove elem(value %f, cnst %p, var %p) in var %p", elem->consumption_weight, elem->constraint,
-            elem->variable, var);
+  XBT_DEBUG("remove elem(value %f, cnst %p, var %p) in var %p", elem.consumption_weight, elem.constraint, elem.variable,
+            var);
 
   /* We are going to change the constraint object and the variable object.
    * Propagate this change to other objects. Calling here before removing variable from not active elements
@@ -422,22 +396,22 @@ void lmm_shrink(lmm_system_t sys, lmm_constraint_t cnst, lmm_variable_t var)
   lmm_update_modified_set(sys, var->cnsts[0].constraint); // will look up enabled_element_set of this constraint, and
                                                      //then each var in the enabled_element_set, and each var->cnsts[i].
 
-  if(xbt_swag_remove(elem, &(elem->constraint->enabled_element_set)))
-    lmm_decrease_concurrency(elem);
+  if (xbt_swag_remove(&elem, &(elem.constraint->enabled_element_set)))
+    lmm_decrease_concurrency(&elem);
 
-  xbt_swag_remove(elem, &(elem->constraint->active_element_set));
-  elem->constraint = nullptr;
-  elem->variable = nullptr;
-  elem->consumption_weight = 0;
+  xbt_swag_remove(&elem, &(elem.constraint->active_element_set));
+  elem.constraint         = nullptr;
+  elem.variable           = nullptr;
+  elem.consumption_weight = 0;
 
-  var->cnsts_number -= 1;
+  var->cnsts.pop_back();
 
   //No variable in this constraint -> make it inactive
   if (xbt_swag_size(&(cnst->enabled_element_set))+xbt_swag_size(&(cnst->disabled_element_set)) == 0)
     make_constraint_inactive(sys, cnst);
   else {
     //Check maxconcurrency to see if we can enable new variables
-    lmm_on_disabled_var(sys,elem->constraint);
+    lmm_on_disabled_var(sys, elem.constraint);
   }
 
   lmm_check_concurrency(sys);
@@ -451,10 +425,9 @@ void lmm_expand(lmm_system_t sys, lmm_constraint_t cnst, lmm_variable_t var, dou
   //If it does, substract it from the required slack
   int current_share = 0;
   if(var->concurrency_share>1){
-    for (int i = 0; i < var->cnsts_number; i++) {
-      if(var->cnsts[i].constraint==cnst &&
-         xbt_swag_belongs(&var->cnsts[i],&(var->cnsts[i].constraint->enabled_element_set)))
-         current_share+=lmm_element_concurrency(&(var->cnsts[i]));
+    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);
     }
   }
 
@@ -462,34 +435,35 @@ void lmm_expand(lmm_system_t sys, lmm_constraint_t cnst, lmm_variable_t var, dou
   if (var->sharing_weight > 0 && var->concurrency_share - current_share > lmm_concurrency_slack(cnst)) {
     double weight = var->sharing_weight;
     lmm_disable_var(sys,var);
-    for (int i = 0; i < var->cnsts_number; i++)
-      lmm_on_disabled_var(sys,var->cnsts[i].constraint);
+    for (s_lmm_element_t const& elem : var->cnsts)
+      lmm_on_disabled_var(sys, elem.constraint);
     consumption_weight = 0;
     var->staged_weight=weight;
     xbt_assert(not var->sharing_weight);
   }
 
-  xbt_assert(var->cnsts_number < var->cnsts_size, "Too much constraints");
+  xbt_assert(var->cnsts.size() < var->cnsts.capacity(), "Too much constraints");
 
-  lmm_element_t elem = &(var->cnsts[var->cnsts_number++]);
+  var->cnsts.resize(var->cnsts.size() + 1);
+  s_lmm_element_t& elem = var->cnsts.back();
 
-  elem->consumption_weight = consumption_weight;
-  elem->constraint = cnst;
-  elem->variable = var;
+  elem.consumption_weight = consumption_weight;
+  elem.constraint         = cnst;
+  elem.variable           = var;
 
   if (var->sharing_weight) {
-    xbt_swag_insert_at_head(elem, &(elem->constraint->enabled_element_set));
-    lmm_increase_concurrency(elem);
+    xbt_swag_insert_at_head(&elem, &(elem.constraint->enabled_element_set));
+    lmm_increase_concurrency(&elem);
   } else
-    xbt_swag_insert_at_tail(elem, &(elem->constraint->disabled_element_set));
+    xbt_swag_insert_at_tail(&elem, &(elem.constraint->disabled_element_set));
 
   if (not sys->selective_update_active) {
     make_constraint_active(sys, cnst);
-  } else if (elem->consumption_weight > 0 || var->sharing_weight > 0) {
+  } else if (elem.consumption_weight > 0 || var->sharing_weight > 0) {
     make_constraint_active(sys, cnst);
     lmm_update_modified_set(sys, cnst);
     //TODOLATER: Why do we need this second call?
-    if (var->cnsts_number > 1)
+    if (var->cnsts.size() > 1)
       lmm_update_modified_set(sys, var->cnsts[0].constraint);
   }
 
@@ -498,36 +472,34 @@ void lmm_expand(lmm_system_t sys, lmm_constraint_t cnst, lmm_variable_t var, dou
 
 void lmm_expand_add(lmm_system_t sys, lmm_constraint_t cnst, lmm_variable_t var, double value)
 {
-  int i;
   sys->modified = 1;
 
   lmm_check_concurrency(sys);
 
   //BEWARE: In case you have multiple elements in one constraint, this will always add value to the first element.
-  for (i = 0; i < var->cnsts_number; i++)
-    if (var->cnsts[i].constraint == cnst)
-      break;
-
-  if (i < var->cnsts_number) {
+  auto elem_it = std::find_if(begin(var->cnsts), end(var->cnsts),
+                              [&cnst](s_lmm_element_t const& x) { return x.constraint == cnst; });
+  if (elem_it != end(var->cnsts)) {
+    s_lmm_element_t& elem = *elem_it;
     if (var->sharing_weight)
-      lmm_decrease_concurrency(&var->cnsts[i]);
+      lmm_decrease_concurrency(&elem);
 
     if (cnst->sharing_policy)
-      var->cnsts[i].consumption_weight += value;
+      elem.consumption_weight += value;
     else
-      var->cnsts[i].consumption_weight = MAX(var->cnsts[i].consumption_weight, value);
+      elem.consumption_weight = MAX(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(lmm_concurrency_slack(cnst)<lmm_element_concurrency(&var->cnsts[i])){
+      if (lmm_concurrency_slack(cnst) < lmm_element_concurrency(&elem)) {
         double weight = var->sharing_weight;
         lmm_disable_var(sys,var);
-        for (int j = 0; j < var->cnsts_number; j++)
-          lmm_on_disabled_var(sys,var->cnsts[j].constraint);
+        for (s_lmm_element_t const& elem2 : var->cnsts)
+          lmm_on_disabled_var(sys, elem2.constraint);
         var->staged_weight=weight;
         xbt_assert(not var->sharing_weight);
       }
-      lmm_increase_concurrency(&var->cnsts[i]);
+      lmm_increase_concurrency(&elem);
     }
     lmm_update_modified_set(sys, cnst);
   } else
@@ -536,17 +508,17 @@ void lmm_expand_add(lmm_system_t sys, lmm_constraint_t cnst, lmm_variable_t var,
   lmm_check_concurrency(sys);
 }
 
-lmm_constraint_t lmm_get_cnst_from_var(lmm_system_t /*sys*/, lmm_variable_t var, int num)
+lmm_constraint_t lmm_get_cnst_from_var(lmm_system_t /*sys*/, lmm_variable_t var, unsigned num)
 {
-  if (num < var->cnsts_number)
+  if (num < var->cnsts.size())
     return (var->cnsts[num].constraint);
   else
     return nullptr;
 }
 
-double lmm_get_cnst_weight_from_var(lmm_system_t /*sys*/, lmm_variable_t var, int num)
+double lmm_get_cnst_weight_from_var(lmm_system_t /*sys*/, lmm_variable_t var, unsigned num)
 {
-  if (num < var->cnsts_number)
+  if (num < var->cnsts.size())
     return (var->cnsts[num].consumption_weight);
   else
     return 0.0;
@@ -554,7 +526,7 @@ double lmm_get_cnst_weight_from_var(lmm_system_t /*sys*/, lmm_variable_t var, in
 
 int lmm_get_number_of_cnst_from_var(lmm_system_t /*sys*/, lmm_variable_t var)
 {
-  return (var->cnsts_number);
+  return (var->cnsts.size());
 }
 
 lmm_variable_t lmm_get_var_from_cnst(lmm_system_t /*sys*/, lmm_constraint_t cnst, lmm_element_t * elem)
@@ -827,8 +799,6 @@ void lmm_solve(lmm_system_t sys)
     }
 
     while ((var = (lmm_variable_t)xbt_swag_getFirst(var_list))) {
-      int i;
-
       if (min_bound < 0) {
         //If no variable could reach its bound, deal iteratively the constraints usage ( at worst one constraint is
         // saturated at each cycle)
@@ -850,14 +820,13 @@ void lmm_solve(lmm_system_t sys)
                 var->id_int, var->value);
 
       /* Update the usage of contraints where this variable is involved */
-      for (i = 0; i < var->cnsts_number; i++) {
-        lmm_element_t elem    = &var->cnsts[i];
-        lmm_constraint_t cnst = elem->constraint;
+      for (s_lmm_element_t& elem : var->cnsts) {
+        lmm_constraint_t cnst = elem.constraint;
         if (cnst->sharing_policy) {
-          //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);
-          //If the constraint is saturated, remove it from the set of active constraints (light_tab)
+          // 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);
+          // If the constraint is saturated, remove it from the set of active constraints (light_tab)
           if (not double_positive(cnst->usage, sg_maxmin_precision) ||
               not double_positive(cnst->remaining, cnst->bound * sg_maxmin_precision)) {
             if (cnst->cnst_light) {
@@ -872,18 +841,19 @@ void lmm_solve(lmm_system_t sys)
           } else {
             cnst->cnst_light->remaining_over_usage = cnst->remaining / cnst->usage;
           }
-          make_elem_inactive(elem);
+          make_elem_inactive(&elem);
         } else {
-          //Remember: non-shared constraints only require that max(elem->value * var->value) < cnst->bound
+          // Remember: non-shared constraints only require that max(elem.value * var->value) < cnst->bound
           cnst->usage = 0.0;
-          make_elem_inactive(elem);
+          make_elem_inactive(&elem);
           xbt_swag_t elem_list = &(cnst->enabled_element_set);
           xbt_swag_foreach(_elem, elem_list) {
-            elem = (lmm_element_t)_elem;
-            xbt_assert(elem->variable->sharing_weight > 0);
-            if (elem->variable->value > 0) continue;
-            if (elem->consumption_weight > 0)
-              cnst->usage = MAX(cnst->usage, elem->consumption_weight / elem->variable->sharing_weight);
+            lmm_element_t elem2 = static_cast<lmm_element_t>(_elem);
+            xbt_assert(elem2->variable->sharing_weight > 0);
+            if (elem2->variable->value > 0)
+              continue;
+            if (elem2->consumption_weight > 0)
+              cnst->usage = MAX(cnst->usage, elem2->consumption_weight / elem2->variable->sharing_weight);
           }
           //If the constraint is saturated, remove it from the set of active constraints (light_tab)
           if (not double_positive(cnst->usage, sg_maxmin_precision) ||
@@ -955,7 +925,7 @@ void lmm_update_variable_bound(lmm_system_t sys, lmm_variable_t var, double boun
   sys->modified = 1;
   var->bound = bound;
 
-  if (var->cnsts_number)
+  if (not var->cnsts.empty())
     lmm_update_modified_set(sys, var->cnsts[0].constraint);
 }
 
@@ -970,8 +940,8 @@ int lmm_concurrency_slack(lmm_constraint_t cnstr){
 /** \brief Measure the minimum concurrency slack across all constraints where the given var is involved */
 int lmm_cnstrs_min_concurrency_slack(lmm_variable_t var){
   int minslack = std::numeric_limits<int>::max();
-  for (int i = 0; i < var->cnsts_number; i++) {
-    int slack = lmm_concurrency_slack(var->cnsts[i].constraint);
+  for (s_lmm_element_t const& elem : var->cnsts) {
+    int slack = lmm_concurrency_slack(elem.constraint);
 
     //This is only an optimization, to avoid looking at more constraints when slack is already zero
     //Disable it when debugging to let lmm_concurrency_slack catch nasty things
@@ -1008,13 +978,12 @@ void lmm_enable_var(lmm_system_t sys, lmm_variable_t var){
 
   xbt_swag_remove(var, &(sys->variable_set));
   xbt_swag_insert_at_head(var, &(sys->variable_set));
-  for (int i = 0; i < var->cnsts_number; i++) {
-    lmm_element_t elem = &var->cnsts[i];
-    xbt_swag_remove(elem, &(elem->constraint->disabled_element_set));
-    xbt_swag_insert_at_head(elem, &(elem->constraint->enabled_element_set));
-    lmm_increase_concurrency(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);
   }
-  if (var->cnsts_number)
+  if (not var->cnsts.empty())
     lmm_update_modified_set(sys, var->cnsts[0].constraint);
 
   //When used within lmm_on_disabled_var, we would get an assertion fail, because transiently there can be variables
@@ -1028,16 +997,15 @@ void lmm_disable_var(lmm_system_t sys, lmm_variable_t var){
   // moving the last element of var.
   xbt_swag_remove(var, &(sys->variable_set));
   xbt_swag_insert_at_tail(var, &(sys->variable_set));
-  if (var->cnsts_number)
+  if (not var->cnsts.empty())
     lmm_update_modified_set(sys, var->cnsts[0].constraint);
-  for (int i = 0; i < var->cnsts_number; i++) {
-    lmm_element_t elem = &var->cnsts[i];
-    xbt_swag_remove(elem, &(elem->constraint->enabled_element_set));
-    xbt_swag_insert_at_tail(elem, &(elem->constraint->disabled_element_set));
+  for (s_lmm_element_t& elem : var->cnsts) {
+    xbt_swag_remove(&elem, &(elem.constraint->enabled_element_set));
+    xbt_swag_insert_at_tail(&elem, &(elem.constraint->disabled_element_set));
 
-    xbt_swag_remove(elem, &(elem->constraint->active_element_set));
+    xbt_swag_remove(&elem, &(elem.constraint->active_element_set));
 
-    lmm_decrease_concurrency(elem);
+    lmm_decrease_concurrency(&elem);
   }
 
   var->sharing_weight = 0.0;
@@ -1173,12 +1141,12 @@ static void lmm_update_modified_set_rec(lmm_system_t sys, lmm_constraint_t cnst)
   //TODOLATER: Why lmm_modified_set has been changed in git version 2392B5157...? Looks equivalent logically and less obvious..
   xbt_swag_foreach(_elem, &cnst->enabled_element_set) {
     lmm_variable_t var = ((lmm_element_t)_elem)->variable;
-    s_lmm_element_t *cnsts = var->cnsts;
-    int i;
-    for (i = 0; var->visited != sys->visited_counter && i < var->cnsts_number ; i++) {
-      if (cnsts[i].constraint != cnst && not xbt_swag_belongs(cnsts[i].constraint, &sys->modified_constraint_set)) {
-        xbt_swag_insert(cnsts[i].constraint, &sys->modified_constraint_set);
-        lmm_update_modified_set_rec(sys, cnsts[i].constraint);
+    for (s_lmm_element_t const& elem : var->cnsts) {
+      if (var->visited == sys->visited_counter)
+        break;
+      if (elem.constraint != cnst && not xbt_swag_belongs(elem.constraint, &sys->modified_constraint_set)) {
+        xbt_swag_insert(elem.constraint, &sys->modified_constraint_set);
+        lmm_update_modified_set_rec(sys, elem.constraint);
       }
     }
     //var will be ignored in later visits as long as sys->visited_counter does not move
diff --git a/src/surf/maxmin_private.hpp b/src/surf/maxmin_private.hpp
index 10a1d0f58f..03505578a2 100644
--- a/src/surf/maxmin_private.hpp
+++ b/src/surf/maxmin_private.hpp
@@ -11,6 +11,8 @@
 #include "xbt/mallocator.h"
 #include "xbt/swag.h"
 
+#include <vector>
+
 /** @ingroup SURF_lmm
  * @brief LMM element
  * Elements can be seen as glue between constraint objects and variable objects.
@@ -83,9 +85,7 @@ struct s_lmm_variable_t {
   s_xbt_swag_hookup_t variable_set_hookup;
   s_xbt_swag_hookup_t saturated_variable_set_hookup;
 
-  s_lmm_element_t *cnsts;
-  int cnsts_size;
-  int cnsts_number;
+  std::vector<s_lmm_element_t> cnsts;
 
   // sharing_weight: variable's impact on the resource during the sharing
   //   if == 0, the variable is not considered by LMM