[sonar] Constify pointer and reference parameters in src/kernel/.

[simgrid.git] / src / kernel / lmm / maxmin.cpp

diff --git a/src/kernel/lmm/maxmin.cpp b/src/kernel/lmm/maxmin.cpp
index 4168178..bf87775 100644 (file)
--- a/src/kernel/lmm/maxmin.cpp
+++ b/src/kernel/lmm/maxmin.cpp
@@ -4,7 +4,6 @@
  * under the terms of the license (GNU LGPL) which comes with this package. */
 
 #include "src/kernel/lmm/maxmin.hpp"
-#include "src/surf/surf_interface.hpp"
 #include "xbt/backtrace.hpp"
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_maxmin, surf, "Logging specific to SURF (maxmin)");
@@ -88,9 +87,9 @@ void System::check_concurrency() const
       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(),
@@ -172,17 +171,6 @@ void System::cnst_free(Constraint* cnst)
 Constraint::Constraint(resource::Resource* id_value, double bound_value) : bound_(bound_value), id_(id_value)
 {
   rank_ = next_rank_++;
-
-  remaining_           = 0.0;
-  usage_               = 0.0;
-  concurrency_limit_   = sg_concurrency_limit;
-  concurrency_current_ = 0;
-  concurrency_maximum_ = 0;
-  sharing_policy_      = s4u::Link::SharingPolicy::SHARED;
-
-  lambda_     = 0.0;
-  new_lambda_ = 0.0;
-  cnst_light_ = nullptr;
 }
 
 Constraint* System::constraint_new(resource::Resource* id, double bound_value)
@@ -239,7 +227,7 @@ void System::expand(Constraint* cnst, Variable* var, double consumption_weight)
   // 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();
     }
@@ -408,13 +396,13 @@ static inline void saturated_constraints_update(double usage, int cnst_light_num
   }
 }
 
-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())
@@ -619,7 +607,7 @@ template <class CnstList> void System::lmm_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();
-          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;
@@ -669,7 +657,6 @@ template <class CnstList> void System::lmm_solve(CnstList& cnst_list)
     }
 
     saturated_variable_set_update(cnst_light_tab, saturated_constraints, this);
-
   } while (cnst_light_num > 0);
 
   modified_ = false;
@@ -681,7 +668,6 @@ template <class CnstList> void System::lmm_solve(CnstList& cnst_list)
   }
 
   check_concurrency();
-
 }
 
 /** @brief Attribute the value bound to var->bound.
@@ -806,7 +792,6 @@ void System::on_disabled_var(Constraint* cnstr)
 
   // Cannot use foreach loop, because System::enable_var() will modify disabled_element_set.. within the loop
   while (numelem-- && elem) {
-
     Element* nextelem;
     if (elem->disabled_element_set_hook.is_linked()) {
       auto iter = std::next(cnstr->disabled_element_set_.iterator_to(*elem));
@@ -842,8 +827,8 @@ void System::update_variable_penalty(Variable* var, double penalty)
   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);
 
@@ -887,7 +872,7 @@ void System::update_constraint_bound(Constraint* cnst, double bound)
  *  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;
@@ -957,6 +942,7 @@ int Constraint::get_variable_amount() const
   return std::count_if(std::begin(enabled_element_set_), std::end(enabled_element_set_),
                        [](const Element& elem) { return elem.consumption_weight > 0; });
 }
-}
-}
-}
+
+} // namespace lmm
+} // namespace kernel
+} // namespace simgrid