Avoid allocation inside lmm_solve

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

diff --git a/src/kernel/lmm/maxmin.cpp b/src/kernel/lmm/maxmin.cpp
index 25a5f24..0eac307 100644 (file)
--- a/src/kernel/lmm/maxmin.cpp
+++ b/src/kernel/lmm/maxmin.cpp
@@ -31,7 +31,7 @@ int Element::get_concurrency() const
 {
   // Ignore element with weight less than one (e.g. cross-traffic)
   return (consumption_weight >= 1) ? 1 : 0;
-  // There are other alternatives, but they will change the behaviour of the model..
+  // There are other alternatives, but they will change the behavior 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.
   // Potential examples are:
@@ -137,7 +137,8 @@ void System::var_free(Variable* var)
   XBT_OUT();
 }
 
-System::System(bool selective_update) : selective_update_active(selective_update)
+System::System(bool selective_update) : cnst_light_tab(NULL),cnst_light_max_size(0),
+   selective_update_active(selective_update)
 {
   XBT_DEBUG("Setting selective_update_active flag to %d", selective_update_active);
 
@@ -151,7 +152,7 @@ System::~System()
   Constraint* cnst;
 
   while ((var = extract_variable())) {
-    auto demangled = simgrid::xbt::demangle(typeid(*var->id_).name());
+    auto demangled = simgrid::xbt::demangle(var->id_ ? typeid(*var->id_).name() : "(unidentified)");
     XBT_WARN("Probable bug: a %s variable (#%d) not removed before the LMM system destruction.", demangled.get(),
              var->rank_);
     var_free(var);
@@ -159,6 +160,9 @@ System::~System()
   while ((cnst = extract_constraint()))
     cnst_free(cnst);
 
+  if(cnst_light_tab)
+    delete[] cnst_light_tab;
+
   xbt_mallocator_free(variable_mallocator_);
   delete modified_set_;
 }
@@ -169,7 +173,7 @@ void System::cnst_free(Constraint* cnst)
   delete cnst;
 }
 
-Constraint::Constraint(void* id_value, double bound_value) : bound_(bound_value), id_(id_value)
+Constraint::Constraint(resource::Resource* id_value, double bound_value) : bound_(bound_value), id_(id_value)
 {
   rank_ = next_rank_++;
 
@@ -185,7 +189,7 @@ Constraint::Constraint(void* id_value, double bound_value) : bound_(bound_value)
   cnst_light_ = nullptr;
 }
 
-Constraint* System::constraint_new(void* id, double bound_value)
+Constraint* System::constraint_new(resource::Resource* id, double bound_value)
 {
   Constraint* cnst = new Constraint(id, bound_value);
   insert_constraint(cnst);
@@ -224,12 +228,19 @@ void System::variable_free(Variable* var)
   var_free(var);
 }
 
+void System::variable_free_all()
+{
+  Variable* var;
+  while ((var = extract_variable()))
+    variable_free(var);
+}
+
 void System::expand(Constraint* cnst, Variable* var, double consumption_weight)
 {
   modified_ = true;
 
   // Check if this variable already has an active element in this constraint
-  // If it does, substract it from the required slack
+  // If it does, subtract it from the required slack
   int current_share = 0;
   if (var->concurrency_share_ > 1) {
     for (Element& elem : var->cnsts_) {
@@ -497,18 +508,14 @@ template <class CnstList> void System::lmm_solve(CnstList& cnst_list)
   double min_usage = -1;
   double min_bound = -1;
 
-  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 (Element const& elem : cnst.enabled_element_set_) {
-      xbt_assert(elem.variable->sharing_penalty_ > 0.0);
-      elem.variable->value_ = 0.0;
-    }
+  if(cnst_list.size()>cnst_light_max_size){
+    cnst_light_max_size=cnst_list.size()*2;
+    if(cnst_light_tab)
+      delete [] cnst_light_tab;
+    cnst_light_tab=new ConstraintLight[cnst_light_max_size]();
   }
 
-  ConstraintLight* cnst_light_tab = new ConstraintLight[cnst_list.size()]();
   int cnst_light_num              = 0;
-  dyn_light_t saturated_constraints;
 
   for (Constraint& cnst : cnst_list) {
     /* INIT: Collect constraints that actually need to be saturated (i.e remaining  and usage are strictly positive)
@@ -519,6 +526,7 @@ template <class CnstList> void System::lmm_solve(CnstList& cnst_list)
     cnst.usage_ = 0;
     for (Element& elem : cnst.enabled_element_set_) {
       xbt_assert(elem.variable->sharing_penalty_ > 0);
+      elem.variable->value_ = 0.0;
       if (elem.consumption_weight > 0) {
         if (cnst.sharing_policy_ != s4u::Link::SharingPolicy::FATPIPE)
           cnst.usage_ += elem.consumption_weight / elem.variable->sharing_penalty_;
@@ -547,10 +555,31 @@ template <class CnstList> void System::lmm_solve(CnstList& cnst_list)
     }
   }
 
+#if MAXMIN_PROF==CSV_PROF
+  start_init2 = high_resolution_clock::now();//FABIENDBG
+#endif
+
   saturated_variable_set_update(cnst_light_tab, saturated_constraints, this);
+  
+
+#if MAXMIN_PROF==CSV_PROF
+  high_resolution_clock::time_point start_main = high_resolution_clock::now();//FABIENDBG
+  int NVars=saturated_variable_set.size();//FABIENDBG
+  float init_duration1=duration_cast<duration<float> >(start_init2 - start_init).count();//FABIENDBG
+  float init_duration2=duration_cast<duration<float> >(start_main - start_init2).count();//FABIENDBG
+  float loop_duration;//FABIENDBG
+  float loop_max=0;//FABIENDBG
+  float loop_min=1E9;//FABIENDBG
+  float loop_avg=0;//FABIENDBG
+  float loop_std=0;//FABIENDBG
+  int loop_count=0;//FABIENDBG
+  high_resolution_clock::time_point start_loop,end_loop;//FABIENDBG
+#endif
 
   /* Saturated variables update */
   do {
+    high_resolution_clock::time_point start_loop = high_resolution_clock::now();//FABIENDBG
+
     /* Fix the variables that have to be */
     auto& var_list = saturated_variable_set;
     for (Variable const& var : var_list) {
@@ -590,7 +619,7 @@ template <class CnstList> void System::lmm_solve(CnstList& cnst_list)
       XBT_DEBUG("Min usage: %f, Var(%d).penalty: %f, Var(%d).value: %f ", min_usage, var.rank_, var.sharing_penalty_,
                 var.rank_, var.value_);
 
-      /* Update the usage of contraints where this variable is involved */
+      /* Update the usage of constraints where this variable is involved */
       for (Element& elem : var.cnsts_) {
         Constraint* cnst = elem.constraint;
         if (cnst->sharing_policy_ != s4u::Link::SharingPolicy::FATPIPE) {
@@ -610,7 +639,9 @@ template <class CnstList> void System::lmm_solve(CnstList& cnst_list)
               cnst->cnst_light_ = nullptr;
             }
           } else {
-            cnst->cnst_light_->remaining_over_usage = cnst->remaining_ / cnst->usage_;
+            if (cnst->cnst_light_) {
+              cnst->cnst_light_->remaining_over_usage = cnst->remaining_ / cnst->usage_;
+            }
           }
           elem.make_inactive();
         } else {
@@ -639,10 +670,12 @@ template <class CnstList> void System::lmm_solve(CnstList& cnst_list)
               cnst->cnst_light_ = nullptr;
             }
           } else {
-            cnst->cnst_light_->remaining_over_usage = cnst->remaining_ / cnst->usage_;
-            xbt_assert(not cnst->active_element_set_.empty(),
-                       "Should not keep a maximum constraint that has no active"
-                       " element! You want to check the maxmin precision and possible rounding effects.");
+            if (cnst->cnst_light_) {
+              cnst->cnst_light_->remaining_over_usage = cnst->remaining_ / cnst->usage_;
+              xbt_assert(not cnst->active_element_set_.empty(),
+                         "Should not keep a maximum constraint that has no active"
+                         " element! You want to check the maxmin precision and possible rounding effects.");
+            }
           }
         }
       }
@@ -678,7 +711,6 @@ template <class CnstList> void System::lmm_solve(CnstList& cnst_list)
 
   check_concurrency();
 
-  delete[] cnst_light_tab;
 }
 
 /** @brief Attribute the value bound to var->bound.
@@ -916,7 +948,7 @@ void System::remove_all_modified_set()
   // In effect, the var->visited value will no more be equal to visited counter
   // To be clean, when visited counter has wrapped around, we force these var->visited values so that variables that
   // were in the modified a long long time ago are not wrongly skipped here, which would lead to very nasty bugs
-  // (i.e. not readibily reproducible, and requiring a lot of run time before happening).
+  // (i.e. not readily reproducible, and requiring a lot of run time before happening).
   if (++visited_counter_ == 1) {
     /* the counter wrapped around, reset each variable->visited */
     for (Variable& var : variable_set)