Rename simgrid::kernel::lmm::s_lmm_element_t -> Element.

diff --git a/include/simgrid/forward.h b/include/simgrid/forward.h
index 83bb7b1..317c70f 100644 (file)
--- a/include/simgrid/forward.h
+++ b/include/simgrid/forward.h
@@ -38,7 +38,7 @@ namespace activity {
   class MailboxImpl;
 }
 namespace lmm {
   class MailboxImpl;
 }
 namespace lmm {

-class s_lmm_element_t;
+class Element;

 class Variable;
 class Constraint;
 class ConstraintLight;
 class Variable;
 class Constraint;
 class ConstraintLight;


@@ -87,8 +87,8 @@ typedef simgrid::simix::MutexImpl* smx_mutex_t;
 typedef simgrid::kernel::activity::MailboxImpl* smx_mailbox_t;
 typedef simgrid::surf::StorageImpl* surf_storage_t;
 
 typedef simgrid::kernel::activity::MailboxImpl* smx_mailbox_t;
 typedef simgrid::surf::StorageImpl* surf_storage_t;
 

-typedef simgrid::kernel::lmm::s_lmm_element_t* lmm_element_t;
-typedef const simgrid::kernel::lmm::s_lmm_element_t* const_lmm_element_t;
+typedef simgrid::kernel::lmm::Element* lmm_element_t;
+typedef const simgrid::kernel::lmm::Element* const_lmm_element_t;

 typedef simgrid::kernel::lmm::Variable* lmm_variable_t;
 typedef simgrid::kernel::lmm::Constraint* lmm_constraint_t;
 typedef simgrid::kernel::lmm::ConstraintLight* lmm_constraint_light_t;
 typedef simgrid::kernel::lmm::Variable* lmm_variable_t;
 typedef simgrid::kernel::lmm::Constraint* lmm_constraint_t;
 typedef simgrid::kernel::lmm::ConstraintLight* lmm_constraint_light_t;

diff --git a/src/kernel/lmm/fair_bottleneck.cpp b/src/kernel/lmm/fair_bottleneck.cpp
index c368001..83bd007 100644 (file)
--- a/src/kernel/lmm/fair_bottleneck.cpp
+++ b/src/kernel/lmm/fair_bottleneck.cpp
@@ -27,7 +27,7 @@ void simgrid::kernel::lmm::bottleneck_solve(lmm_system_t sys)
   for (Variable& var : sys->variable_set) {
     var.value = 0.0;
     XBT_DEBUG("Handling variable %p", &var);
   for (Variable& var : sys->variable_set) {
     var.value = 0.0;
     XBT_DEBUG("Handling variable %p", &var);

-    if (var.sharing_weight > 0.0 && std::find_if(begin(var.cnsts), end(var.cnsts), [](s_lmm_element_t const& x) {
+    if (var.sharing_weight > 0.0 && std::find_if(begin(var.cnsts), end(var.cnsts), [](Element const& x) {

                                       return x.consumption_weight != 0.0;
                                     }) != end(var.cnsts)) {
       sys->saturated_variable_set.push_back(var);
                                       return x.consumption_weight != 0.0;
                                     }) != end(var.cnsts)) {
       sys->saturated_variable_set.push_back(var);


@@ -65,7 +65,7 @@ void simgrid::kernel::lmm::bottleneck_solve(lmm_system_t sys)
       int nb = 0;
       XBT_DEBUG("Processing cnst %p ", &cnst);
       cnst.usage = 0.0;
       int nb = 0;
       XBT_DEBUG("Processing cnst %p ", &cnst);
       cnst.usage = 0.0;

-      for (s_lmm_element_t& elem : cnst.enabled_element_set) {
+      for (Element& elem : cnst.enabled_element_set) {

         xbt_assert(elem.variable->sharing_weight > 0);
         if (elem.consumption_weight > 0 && elem.variable->saturated_variable_set_hook.is_linked())
           nb++;
         xbt_assert(elem.variable->sharing_weight > 0);
         if (elem.consumption_weight > 0 && elem.variable->saturated_variable_set_hook.is_linked())
           nb++;


@@ -87,7 +87,7 @@ void simgrid::kernel::lmm::bottleneck_solve(lmm_system_t sys)
     for (auto iter = std::begin(var_list); iter != std::end(var_list);) {
       Variable& var  = *iter;
       double min_inc = DBL_MAX;
     for (auto iter = std::begin(var_list); iter != std::end(var_list);) {
       Variable& var  = *iter;
       double min_inc = DBL_MAX;

-      for (s_lmm_element_t const& elm : var.cnsts) {
+      for (Element const& elm : var.cnsts) {

         if (elm.consumption_weight > 0)
           min_inc = std::min(min_inc, elm.constraint->usage / elm.consumption_weight);
       }
         if (elm.consumption_weight > 0)
           min_inc = std::min(min_inc, elm.constraint->usage / elm.consumption_weight);
       }


@@ -106,14 +106,14 @@ void simgrid::kernel::lmm::bottleneck_solve(lmm_system_t sys)
       Constraint& cnst = *iter;
       XBT_DEBUG("Updating cnst %p ", &cnst);
       if (cnst.sharing_policy) {
       Constraint& cnst = *iter;
       XBT_DEBUG("Updating cnst %p ", &cnst);
       if (cnst.sharing_policy) {

-        for (s_lmm_element_t& elem : cnst.enabled_element_set) {
+        for (Element& elem : cnst.enabled_element_set) {

           xbt_assert(elem.variable->sharing_weight > 0);
           XBT_DEBUG("\tUpdate constraint %p (%g) with variable %p by %g", &cnst, cnst.remaining, elem.variable,
                     elem.variable->mu);
           double_update(&cnst.remaining, elem.consumption_weight * elem.variable->mu, sg_maxmin_precision);
         }
       } else {
           xbt_assert(elem.variable->sharing_weight > 0);
           XBT_DEBUG("\tUpdate constraint %p (%g) with variable %p by %g", &cnst, cnst.remaining, elem.variable,
                     elem.variable->mu);
           double_update(&cnst.remaining, elem.consumption_weight * elem.variable->mu, sg_maxmin_precision);
         }
       } else {

-        for (s_lmm_element_t& elem : cnst.enabled_element_set) {
+        for (Element& elem : cnst.enabled_element_set) {

           xbt_assert(elem.variable->sharing_weight > 0);
           XBT_DEBUG("\tNon-Shared variable. Update constraint usage of %p (%g) with variable %p by %g", &cnst,
                     cnst.usage, elem.variable, elem.variable->mu);
           xbt_assert(elem.variable->sharing_weight > 0);
           XBT_DEBUG("\tNon-Shared variable. Update constraint usage of %p (%g) with variable %p by %g", &cnst,
                     cnst.usage, elem.variable, elem.variable->mu);


@@ -128,7 +128,7 @@ void simgrid::kernel::lmm::bottleneck_solve(lmm_system_t sys)
         XBT_DEBUG("\tGet rid of constraint %p", &cnst);
 
         iter = cnst_list.erase(iter);
         XBT_DEBUG("\tGet rid of constraint %p", &cnst);
 
         iter = cnst_list.erase(iter);

-        for (s_lmm_element_t& elem : cnst.enabled_element_set) {
+        for (Element& elem : cnst.enabled_element_set) {

           if (elem.variable->sharing_weight <= 0)
             break;
           if (elem.consumption_weight > 0 && elem.variable->saturated_variable_set_hook.is_linked()) {
           if (elem.variable->sharing_weight <= 0)
             break;
           if (elem.consumption_weight > 0 && elem.variable->saturated_variable_set_hook.is_linked()) {

diff --git a/src/kernel/lmm/lagrange.cpp b/src/kernel/lmm/lagrange.cpp
index 7bef962..c244c67 100644 (file)
--- a/src/kernel/lmm/lagrange.cpp
+++ b/src/kernel/lmm/lagrange.cpp
@@ -48,7 +48,7 @@ static int __check_feasible(const CnstList& cnst_list, const VarList& var_list,
 {
   for (Constraint const& cnst : cnst_list) {
     double tmp = 0;
 {
   for (Constraint const& cnst : cnst_list) {
     double tmp = 0;

-    for (s_lmm_element_t const& elem : cnst.enabled_element_set) {
+    for (Element const& elem : cnst.enabled_element_set) {

       lmm_variable_t var = elem.variable;
       xbt_assert(var->sharing_weight > 0);
       tmp += var->value;
       lmm_variable_t var = elem.variable;
       xbt_assert(var->sharing_weight > 0);
       tmp += var->value;


@@ -82,7 +82,7 @@ static double new_value(const Variable& var)
 {
   double tmp = 0;
 
 {
   double tmp = 0;
 

-  for (s_lmm_element_t const& elem : var.cnsts) {
+  for (Element const& elem : var.cnsts) {

     tmp += elem.constraint->lambda;
   }
   if (var.bound > 0)
     tmp += elem.constraint->lambda;
   }
   if (var.bound > 0)


@@ -97,7 +97,7 @@ static double new_mu(const Variable& var)
   double mu_i    = 0.0;
   double sigma_i = 0.0;
 
   double mu_i    = 0.0;
   double sigma_i = 0.0;
 

-  for (s_lmm_element_t const& elem : var.cnsts) {
+  for (Element const& elem : var.cnsts) {

     sigma_i += elem.constraint->lambda;
   }
   mu_i = var.func_fp(var, var.bound) - sigma_i;
     sigma_i += elem.constraint->lambda;
   }
   mu_i = var.func_fp(var, var.bound) - sigma_i;


@@ -117,7 +117,7 @@ static double dual_objective(const VarList& var_list, const CnstList& cnst_list)
     if (not var.sharing_weight)
       break;
 
     if (not var.sharing_weight)
       break;
 

-    for (s_lmm_element_t const& elem : var.cnsts)
+    for (Element const& elem : var.cnsts)

       sigma_i += elem.constraint->lambda;
 
     if (var.bound > 0)
       sigma_i += elem.constraint->lambda;
 
     if (var.bound > 0)


@@ -186,8 +186,8 @@ void lagrange_solve(lmm_system_t sys)
       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);
       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; });
+      auto weighted =
+          std::find_if(begin(var.cnsts), end(var.cnsts), [](Element const& x) { return x.consumption_weight != 0.0; });

       if (weighted == end(var.cnsts))
         var.value = 1.0;
     }
       if (weighted == end(var.cnsts))
         var.value = 1.0;
     }


@@ -386,7 +386,7 @@ static double partial_diff_lambda(double lambda, const Constraint& cnst)
 
   XBT_CDEBUG(surf_lagrange_dichotomy, "Computing diff of cnst (%p)", &cnst);
 
 
   XBT_CDEBUG(surf_lagrange_dichotomy, "Computing diff of cnst (%p)", &cnst);
 

-  for (s_lmm_element_t const& elem : cnst.enabled_element_set) {
+  for (Element const& elem : cnst.enabled_element_set) {

     Variable& var = *elem.variable;
     xbt_assert(var.sharing_weight > 0);
     XBT_CDEBUG(surf_lagrange_dichotomy, "Computing sigma_i for var (%p)", &var);
     Variable& var = *elem.variable;
     xbt_assert(var.sharing_weight > 0);
     XBT_CDEBUG(surf_lagrange_dichotomy, "Computing sigma_i for var (%p)", &var);


@@ -394,7 +394,7 @@ static double partial_diff_lambda(double lambda, const Constraint& cnst)
     double sigma_i = 0.0;
 
     // Compute sigma_i
     double sigma_i = 0.0;
 
     // Compute sigma_i

-    for (s_lmm_element_t const& elem2 : var.cnsts)
+    for (Element const& elem2 : var.cnsts)

       sigma_i += elem2.constraint->lambda;
 
     // add mu_i if this flow has a RTT constraint associated
       sigma_i += elem2.constraint->lambda;
 
     // add mu_i if this flow has a RTT constraint associated

diff --git a/src/kernel/lmm/maxmin.cpp b/src/kernel/lmm/maxmin.cpp
index 8c1928d..eaa1f1b 100644 (file)
--- a/src/kernel/lmm/maxmin.cpp
+++ b/src/kernel/lmm/maxmin.cpp
@@ -33,7 +33,7 @@ typedef std::vector<int> dyn_light_t;
 int Variable::Global_debug_id   = 1;
 int Constraint::Global_debug_id = 1;
 
 int Variable::Global_debug_id   = 1;
 int Constraint::Global_debug_id = 1;
 

-int s_lmm_element_t::get_concurrency() const
+int Element::get_concurrency() const

 {
   // Ignore element with weight less than one (e.g. cross-traffic)
   return (consumption_weight >= 1) ? 1 : 0;
 {
   // Ignore element with weight less than one (e.g. cross-traffic)
   return (consumption_weight >= 1) ? 1 : 0;


@@ -45,13 +45,13 @@ int s_lmm_element_t::get_concurrency() const
   // return (int)ceil(elem->weight);//Include element as the rounded-up integer value of the element weight
 }
 
   // return (int)ceil(elem->weight);//Include element as the rounded-up integer value of the element weight
 }
 

-void s_lmm_element_t::decrease_concurrency()
+void Element::decrease_concurrency()

 {
   xbt_assert(constraint->concurrency_current >= get_concurrency());
   constraint->concurrency_current -= get_concurrency();
 }
 
 {
   xbt_assert(constraint->concurrency_current >= get_concurrency());
   constraint->concurrency_current -= get_concurrency();
 }
 

-void s_lmm_element_t::increase_concurrency()
+void Element::increase_concurrency()

 {
   constraint->concurrency_current += get_concurrency();
 
 {
   constraint->concurrency_current += get_concurrency();
 


@@ -71,12 +71,12 @@ void s_lmm_system_t::check_concurrency() const
 
   for (Constraint const& cnst : constraint_set) {
     int concurrency       = 0;
 
   for (Constraint const& cnst : constraint_set) {
     int concurrency       = 0;

-    for (s_lmm_element_t const& elem : cnst.enabled_element_set) {
+    for (Element const& elem : cnst.enabled_element_set) {

       xbt_assert(elem.variable->sharing_weight > 0);
       concurrency += elem.get_concurrency();
     }
 
       xbt_assert(elem.variable->sharing_weight > 0);
       concurrency += elem.get_concurrency();
     }
 

-    for (s_lmm_element_t const& elem : cnst.disabled_element_set) {
+    for (Element const& elem : cnst.disabled_element_set) {

       // We should have staged variables only if concurrency is reached in some constraint
       xbt_assert(cnst.get_concurrency_limit() < 0 || elem.variable->staged_weight == 0 ||
                      elem.variable->get_min_concurrency_slack() < elem.variable->concurrency_share,
       // We should have staged variables only if concurrency is reached in some constraint
       xbt_assert(cnst.get_concurrency_limit() < 0 || elem.variable->staged_weight == 0 ||
                      elem.variable->get_min_concurrency_slack() < elem.variable->concurrency_share,


@@ -93,12 +93,12 @@ void s_lmm_system_t::check_concurrency() const
     if (var.cnsts.empty())
       continue;
 
     if (var.cnsts.empty())
       continue;
 

-    const s_lmm_element_t& 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();
+    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();

 
 

-    for (s_lmm_element_t const& elem2 : var.cnsts) {
+    for (Element const& elem2 : var.cnsts) {

       xbt_assert(belong_to_enabled == elem2.enabled_element_set_hook.is_linked(),
                  "Variable inconsistency (1): enabled_element_set");
       xbt_assert(belong_to_disabled == elem2.disabled_element_set_hook.is_linked(),
       xbt_assert(belong_to_enabled == elem2.enabled_element_set_hook.is_linked(),
                  "Variable inconsistency (1): enabled_element_set");
       xbt_assert(belong_to_disabled == elem2.disabled_element_set_hook.is_linked(),


@@ -119,7 +119,7 @@ void s_lmm_system_t::var_free(lmm_variable_t var)
   if (not var->cnsts.empty())
     update_modified_set(var->cnsts[0].constraint);
 
   if (not var->cnsts.empty())
     update_modified_set(var->cnsts[0].constraint);
 

-  for (s_lmm_element_t& elem : var->cnsts) {
+  for (Element& elem : var->cnsts) {

     if (var->sharing_weight > 0)
       elem.decrease_concurrency();
     if (elem.enabled_element_set_hook.is_linked())
     if (var->sharing_weight > 0)
       elem.decrease_concurrency();
     if (elem.enabled_element_set_hook.is_linked())


@@ -242,7 +242,7 @@ void s_lmm_system_t::expand(lmm_constraint_t cnst, lmm_variable_t var, double co
   // If it does, substract it from the required slack
   int current_share = 0;
   if (var->concurrency_share > 1) {
   // If it does, substract it from the required slack
   int current_share = 0;
   if (var->concurrency_share > 1) {

-    for (s_lmm_element_t& elem : var->cnsts) {
+    for (Element& elem : var->cnsts) {

       if (elem.constraint == cnst && elem.enabled_element_set_hook.is_linked())
         current_share += elem.get_concurrency();
     }
       if (elem.constraint == cnst && elem.enabled_element_set_hook.is_linked())
         current_share += elem.get_concurrency();
     }


@@ -252,7 +252,7 @@ void s_lmm_system_t::expand(lmm_constraint_t cnst, lmm_variable_t var, double co
   if (var->sharing_weight > 0 && var->concurrency_share - current_share > cnst->get_concurrency_slack()) {
     double weight = var->sharing_weight;
     disable_var(var);
   if (var->sharing_weight > 0 && var->concurrency_share - current_share > cnst->get_concurrency_slack()) {
     double weight = var->sharing_weight;
     disable_var(var);

-    for (s_lmm_element_t const& elem : var->cnsts)
+    for (Element const& elem : var->cnsts)

       on_disabled_var(elem.constraint);
     consumption_weight = 0;
     var->staged_weight = weight;
       on_disabled_var(elem.constraint);
     consumption_weight = 0;
     var->staged_weight = weight;


@@ -262,7 +262,7 @@ void s_lmm_system_t::expand(lmm_constraint_t cnst, lmm_variable_t var, double co
   xbt_assert(var->cnsts.size() < var->cnsts.capacity(), "Too much constraints");
 
   var->cnsts.resize(var->cnsts.size() + 1);
   xbt_assert(var->cnsts.size() < var->cnsts.capacity(), "Too much constraints");
 
   var->cnsts.resize(var->cnsts.size() + 1);

-  s_lmm_element_t& elem = var->cnsts.back();
+  Element& elem = var->cnsts.back();

 
   elem.consumption_weight = consumption_weight;
   elem.constraint         = cnst;
 
   elem.consumption_weight = consumption_weight;
   elem.constraint         = cnst;


@@ -294,10 +294,10 @@ void s_lmm_system_t::expand_add(lmm_constraint_t cnst, lmm_variable_t var, doubl
   check_concurrency();
 
   // BEWARE: In case you have multiple elements in one constraint, this will always add value to the first element.
   check_concurrency();
 
   // BEWARE: In case you have multiple elements in one constraint, this will always add value to the first element.

-  auto elem_it = std::find_if(begin(var->cnsts), end(var->cnsts),
-                              [&cnst](s_lmm_element_t const& x) { return x.constraint == cnst; });
+  auto elem_it =
+      std::find_if(begin(var->cnsts), end(var->cnsts), [&cnst](Element const& x) { return x.constraint == cnst; });

   if (elem_it != end(var->cnsts)) {
   if (elem_it != end(var->cnsts)) {

-    s_lmm_element_t& elem = *elem_it;
+    Element& elem = *elem_it;

     if (var->sharing_weight)
       elem.decrease_concurrency();
 
     if (var->sharing_weight)
       elem.decrease_concurrency();
 


@@ -311,7 +311,7 @@ void s_lmm_system_t::expand_add(lmm_constraint_t cnst, lmm_variable_t var, doubl
       if (cnst->get_concurrency_slack() < elem.get_concurrency()) {
         double weight = var->sharing_weight;
         disable_var(var);
       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)
+        for (Element const& elem2 : var->cnsts)

           on_disabled_var(elem2.constraint);
         var->staged_weight = weight;
         xbt_assert(not var->sharing_weight);
           on_disabled_var(elem2.constraint);
         var->staged_weight = weight;
         xbt_assert(not var->sharing_weight);


@@ -419,7 +419,7 @@ static inline void saturated_variable_set_update(ConstraintLight* cnst_light_tab
    * (cnst_light_tab)*/
   for (int const& saturated_cnst : saturated_constraints) {
     ConstraintLight& cnst = cnst_light_tab[saturated_cnst];
    * (cnst_light_tab)*/
   for (int const& saturated_cnst : saturated_constraints) {
     ConstraintLight& cnst = cnst_light_tab[saturated_cnst];

-    for (s_lmm_element_t const& elem : cnst.cnst->active_element_set) {
+    for (Element const& elem : cnst.cnst->active_element_set) {

       // Visiting active_element_set, so, by construction, should never get a zero weight, correct?
       xbt_assert(elem.variable->sharing_weight > 0);
       if (elem.consumption_weight > 0 && not elem.variable->saturated_variable_set_hook.is_linked())
       // Visiting active_element_set, so, by construction, should never get a zero weight, correct?
       xbt_assert(elem.variable->sharing_weight > 0);
       if (elem.consumption_weight > 0 && not elem.variable->saturated_variable_set_hook.is_linked())


@@ -429,9 +429,9 @@ static inline void saturated_variable_set_update(ConstraintLight* cnst_light_tab
 }
 
 template <class ElemList>
 }
 
 template <class ElemList>

-static void format_lmm_element_list(const ElemList& elem_list, int sharing_policy, double& sum, std::string& buf)
+static void format_element_list(const ElemList& elem_list, int sharing_policy, double& sum, std::string& buf)

 {
 {

-  for (s_lmm_element_t const& elem : elem_list) {
+  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)
     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)


@@ -459,9 +459,9 @@ void s_lmm_system_t::print() const
     // Show  the enabled variables
     buf += "\t";
     buf += cnst.sharing_policy ? "(" : "max(";
     // Show  the enabled variables
     buf += "\t";
     buf += cnst.sharing_policy ? "(" : "max(";

-    format_lmm_element_list(cnst.enabled_element_set, cnst.sharing_policy, sum, buf);
+    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?
     // TODO: Adding disabled elements only for test compatibility, but do we really want them to be printed?

-    format_lmm_element_list(cnst.disabled_element_set, cnst.sharing_policy, sum, buf);
+    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) + "')";
 
 
     buf += "0) <= " + std::to_string(cnst.bound) + " ('" + std::to_string(cnst.id_int) + "')";
 


@@ -510,7 +510,7 @@ template <class CnstList> void s_lmm_system_t::solve(CnstList& cnst_list)
   XBT_DEBUG("Active constraints : %zu", cnst_list.size());
   /* Init: Only modified code portions: reset the value of active variables */
   for (Constraint const& cnst : cnst_list) {
   XBT_DEBUG("Active constraints : %zu", cnst_list.size());
   /* Init: Only modified code portions: reset the value of active variables */
   for (Constraint const& cnst : cnst_list) {

-    for (s_lmm_element_t const& elem : cnst.enabled_element_set) {
+    for (Element const& elem : cnst.enabled_element_set) {

       xbt_assert(elem.variable->sharing_weight > 0.0);
       elem.variable->value = 0.0;
     }
       xbt_assert(elem.variable->sharing_weight > 0.0);
       elem.variable->value = 0.0;
     }


@@ -527,7 +527,7 @@ template <class CnstList> void s_lmm_system_t::solve(CnstList& cnst_list)
     if (not double_positive(cnst.remaining, cnst.bound * sg_maxmin_precision))
       continue;
     cnst.usage = 0;
     if (not double_positive(cnst.remaining, cnst.bound * sg_maxmin_precision))
       continue;
     cnst.usage = 0;

-    for (s_lmm_element_t& elem : cnst.enabled_element_set) {
+    for (Element& elem : cnst.enabled_element_set) {

       xbt_assert(elem.variable->sharing_weight > 0);
       if (elem.consumption_weight > 0) {
         if (cnst.sharing_policy)
       xbt_assert(elem.variable->sharing_weight > 0);
       if (elem.consumption_weight > 0) {
         if (cnst.sharing_policy)


@@ -601,7 +601,7 @@ template <class CnstList> void s_lmm_system_t::solve(CnstList& cnst_list)
                 var.id_int, var.value);
 
       /* Update the usage of contraints where this variable is involved */
                 var.id_int, var.value);
 
       /* Update the usage of contraints where this variable is involved */

-      for (s_lmm_element_t& elem : var.cnsts) {
+      for (Element& 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
         lmm_constraint_t cnst = elem.constraint;
         if (cnst->sharing_policy) {
           // Remember: shared constraints require that sum(elem.value * var.value) < cnst->bound


@@ -627,7 +627,7 @@ template <class CnstList> void s_lmm_system_t::solve(CnstList& cnst_list)
           // Remember: non-shared constraints only require that max(elem.value * var.value) < cnst->bound
           cnst->usage = 0.0;
           elem.make_inactive();
           // Remember: non-shared constraints only require that max(elem.value * var.value) < cnst->bound
           cnst->usage = 0.0;
           elem.make_inactive();

-          for (s_lmm_element_t& elem2 : cnst->enabled_element_set) {
+          for (Element& elem2 : cnst->enabled_element_set) {

             xbt_assert(elem2.variable->sharing_weight > 0);
             if (elem2.variable->value > 0)
               continue;
             xbt_assert(elem2.variable->sharing_weight > 0);
             if (elem2.variable->value > 0)
               continue;


@@ -739,7 +739,7 @@ void Variable::initialize(simgrid::surf::Action* id_value, double sharing_weight
 int Variable::get_min_concurrency_slack() const
 {
   int minslack = std::numeric_limits<int>::max();
 int Variable::get_min_concurrency_slack() const
 {
   int minslack = std::numeric_limits<int>::max();

-  for (s_lmm_element_t const& elem : cnsts) {
+  for (Element const& elem : cnsts) {

     int slack = elem.constraint->get_concurrency_slack();
     if (slack < minslack) {
       // This is only an optimization, to avoid looking at more constraints when slack is already zero
     int slack = elem.constraint->get_concurrency_slack();
     if (slack < minslack) {
       // This is only an optimization, to avoid looking at more constraints when slack is already zero


@@ -767,7 +767,7 @@ void s_lmm_system_t::enable_var(lmm_variable_t var)
 
   simgrid::xbt::intrusive_erase(variable_set, *var);
   variable_set.push_front(*var);
 
   simgrid::xbt::intrusive_erase(variable_set, *var);
   variable_set.push_front(*var);

-  for (s_lmm_element_t& elem : var->cnsts) {
+  for (Element& elem : var->cnsts) {

     simgrid::xbt::intrusive_erase(elem.constraint->disabled_element_set, elem);
     elem.constraint->enabled_element_set.push_front(elem);
     elem.increase_concurrency();
     simgrid::xbt::intrusive_erase(elem.constraint->disabled_element_set, elem);
     elem.constraint->enabled_element_set.push_front(elem);
     elem.increase_concurrency();


@@ -789,7 +789,7 @@ void s_lmm_system_t::disable_var(lmm_variable_t var)
   variable_set.push_back(*var);
   if (not var->cnsts.empty())
     update_modified_set(var->cnsts[0].constraint);
   variable_set.push_back(*var);
   if (not var->cnsts.empty())
     update_modified_set(var->cnsts[0].constraint);

-  for (s_lmm_element_t& elem : var->cnsts) {
+  for (Element& elem : var->cnsts) {

     simgrid::xbt::intrusive_erase(elem.constraint->enabled_element_set, elem);
     elem.constraint->disabled_element_set.push_back(elem);
     if (elem.active_element_set_hook.is_linked())
     simgrid::xbt::intrusive_erase(elem.constraint->enabled_element_set, elem);
     elem.constraint->disabled_element_set.push_back(elem);
     if (elem.active_element_set_hook.is_linked())


@@ -910,9 +910,9 @@ void s_lmm_system_t::update_constraint_bound(lmm_constraint_t cnst, double bound
  */
 void s_lmm_system_t::update_modified_set_rec(lmm_constraint_t cnst)
 {
  */
 void s_lmm_system_t::update_modified_set_rec(lmm_constraint_t cnst)
 {

-  for (s_lmm_element_t const& elem : cnst->enabled_element_set) {
+  for (Element const& elem : cnst->enabled_element_set) {

     lmm_variable_t var = elem.variable;
     lmm_variable_t var = elem.variable;

-    for (s_lmm_element_t const& elem2 : var->cnsts) {
+    for (Element const& elem2 : var->cnsts) {

       if (var->visited == visited_counter)
         break;
       if (elem2.constraint != cnst && not elem2.constraint->modified_constraint_set_hook.is_linked()) {
       if (var->visited == visited_counter)
         break;
       if (elem2.constraint != cnst && not elem2.constraint->modified_constraint_set_hook.is_linked()) {


@@ -964,11 +964,11 @@ double Constraint::get_usage() const
 {
   double result              = 0.0;
   if (sharing_policy) {
 {
   double result              = 0.0;
   if (sharing_policy) {

-    for (s_lmm_element_t const& elem : enabled_element_set)
+    for (Element const& elem : enabled_element_set)

       if (elem.consumption_weight > 0)
         result += elem.consumption_weight * elem.variable->value;
   } else {
       if (elem.consumption_weight > 0)
         result += elem.consumption_weight * elem.variable->value;
   } else {

-    for (s_lmm_element_t const& elem : enabled_element_set)
+    for (Element const& elem : enabled_element_set)

       if (elem.consumption_weight > 0)
         result = std::max(result, elem.consumption_weight * elem.variable->value);
   }
       if (elem.consumption_weight > 0)
         result = std::max(result, elem.consumption_weight * elem.variable->value);
   }


@@ -978,7 +978,7 @@ double Constraint::get_usage() const
 int Constraint::get_variable_amount() const
 {
   return std::count_if(std::begin(enabled_element_set), std::end(enabled_element_set),
 int Constraint::get_variable_amount() const
 {
   return std::count_if(std::begin(enabled_element_set), std::end(enabled_element_set),

-                       [](const s_lmm_element_t& elem) { return elem.consumption_weight > 0; });
+                       [](const Element& elem) { return elem.consumption_weight > 0; });

 }
 }
 }
 }
 }
 }

diff --git a/src/kernel/lmm/maxmin.hpp b/src/kernel/lmm/maxmin.hpp
index 6ddbb97..be288f2 100644 (file)
--- a/src/kernel/lmm/maxmin.hpp
+++ b/src/kernel/lmm/maxmin.hpp
@@ -168,7 +168,7 @@ XBT_PUBLIC(double) func_vegas_fpi(const Variable& var, double x);
  * 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.
  */

-XBT_PUBLIC_CLASS s_lmm_element_t
+XBT_PUBLIC_CLASS Element

 {
 public:
   int get_concurrency() const;
 {
 public:
   int get_concurrency() const;


@@ -297,17 +297,14 @@ public:
   boost::intrusive::list_member_hook<> active_constraint_set_hook;
   boost::intrusive::list_member_hook<> modified_constraint_set_hook;
   boost::intrusive::list_member_hook<> saturated_constraint_set_hook;
   boost::intrusive::list_member_hook<> active_constraint_set_hook;
   boost::intrusive::list_member_hook<> modified_constraint_set_hook;
   boost::intrusive::list_member_hook<> saturated_constraint_set_hook;

-  boost::intrusive::list<s_lmm_element_t,
-                         boost::intrusive::member_hook<s_lmm_element_t, boost::intrusive::list_member_hook<>,
-                                                       &s_lmm_element_t::enabled_element_set_hook>>
+  boost::intrusive::list<Element, boost::intrusive::member_hook<Element, boost::intrusive::list_member_hook<>,
+                                                                &Element::enabled_element_set_hook>>

       enabled_element_set;
       enabled_element_set;

-  boost::intrusive::list<s_lmm_element_t,
-                         boost::intrusive::member_hook<s_lmm_element_t, boost::intrusive::list_member_hook<>,
-                                                       &s_lmm_element_t::disabled_element_set_hook>>
+  boost::intrusive::list<Element, boost::intrusive::member_hook<Element, boost::intrusive::list_member_hook<>,
+                                                                &Element::disabled_element_set_hook>>

       disabled_element_set;
       disabled_element_set;

-  boost::intrusive::list<s_lmm_element_t,
-                         boost::intrusive::member_hook<s_lmm_element_t, boost::intrusive::list_member_hook<>,
-                                                       &s_lmm_element_t::active_element_set_hook>>
+  boost::intrusive::list<Element, boost::intrusive::member_hook<Element, boost::intrusive::list_member_hook<>,
+                                                                &Element::active_element_set_hook>>

       active_element_set;
   double remaining;
   double usage;
       active_element_set;
   double remaining;
   double usage;


@@ -404,7 +401,7 @@ public:
   boost::intrusive::list_member_hook<> variable_set_hook;
   boost::intrusive::list_member_hook<> saturated_variable_set_hook;
 
   boost::intrusive::list_member_hook<> variable_set_hook;
   boost::intrusive::list_member_hook<> saturated_variable_set_hook;
 

-  std::vector<s_lmm_element_t> cnsts;
+  std::vector<Element> cnsts;

 
   // sharing_weight: variable's impact on the resource during the sharing
   //   if == 0, the variable is not considered by LMM
 
   // sharing_weight: variable's impact on the resource during the sharing
   //   if == 0, the variable is not considered by LMM


@@ -432,11 +429,11 @@ private:
   static int Global_debug_id;
 };
 
   static int Global_debug_id;
 };
 

-inline void s_lmm_element_t::make_active()
+inline void Element::make_active()

 {
   constraint->active_element_set.push_front(*this);
 }
 {
   constraint->active_element_set.push_front(*this);
 }

-inline void s_lmm_element_t::make_inactive()
+inline void Element::make_inactive()

 {
   if (active_element_set_hook.is_linked())
     simgrid::xbt::intrusive_erase(constraint->active_element_set, *this);
 {
   if (active_element_set_hook.is_linked())
     simgrid::xbt::intrusive_erase(constraint->active_element_set, *this);

diff --git a/src/surf/network_cm02.cpp b/src/surf/network_cm02.cpp
index 434960f..43bc60e 100644 (file)
--- a/src/surf/network_cm02.cpp
+++ b/src/surf/network_cm02.cpp
@@ -335,9 +335,9 @@ Action* NetworkCm02Model::communicate(s4u::Host* src, s4u::Host* dst, double siz
     for (auto const& link : back_route)
       maxminSystem_->expand(link->constraint(), action->getVariable(), .05);
 
     for (auto const& link : back_route)
       maxminSystem_->expand(link->constraint(), action->getVariable(), .05);
 

-    //Change concurrency_share here, if you want that cross-traffic is included in the SURF concurrency
-    //(You would also have to change lmm_element_concurrency())
-    //lmm_variable_concurrency_share_set(action->getVariable(),2);
+    // Change concurrency_share here, if you want that cross-traffic is included in the SURF concurrency
+    // (You would also have to change simgrid::kernel::lmm::Element::get_concurrency())
+    // action->getVariable()->set_concurrency_share(2)

   }
   XBT_OUT();
 
   }
   XBT_OUT();
 


@@ -416,7 +416,7 @@ void NetworkCm02Link::setBandwidth(double value)
     lmm_variable_t var;
     const_lmm_element_t elem     = nullptr;
     const_lmm_element_t nextelem = nullptr;
     lmm_variable_t var;
     const_lmm_element_t elem     = nullptr;
     const_lmm_element_t nextelem = nullptr;

-    int numelem = 0;
+    int numelem                  = 0;

     while ((var = constraint()->get_variable_safe(&elem, &nextelem, &numelem))) {
       NetworkCm02Action* action = static_cast<NetworkCm02Action*>(var->get_id());
       action->weight_ += delta;
     while ((var = constraint()->get_variable_safe(&elem, &nextelem, &numelem))) {
       NetworkCm02Action* action = static_cast<NetworkCm02Action*>(var->get_id());
       action->weight_ += delta;