lmm::System: rename some fields, and initialize them at declaration, not in ctor

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

diff --git a/src/kernel/lmm/maxmin.hpp b/src/kernel/lmm/maxmin.hpp
index f5006fc..c67f8c4 100644 (file)
--- a/src/kernel/lmm/maxmin.hpp
+++ b/src/kernel/lmm/maxmin.hpp
@@ -135,21 +135,8 @@ namespace lmm {
 
 /** @{ @ingroup SURF_lmm */
 
-/**
- * @brief Solve the lmm system
- * @param sys The lmm system to solve
- */
-XBT_PUBLIC void lmm_solve(lmm::System* sys);
-
-XBT_PUBLIC void lagrange_solve(lmm::System* sys);
-XBT_PUBLIC void bottleneck_solve(lmm::System* sys);
-
 /** Default functions associated to the chosen protocol. When using the lagrangian approach. */
 
-XBT_PUBLIC void set_default_protocol_function(double (*func_f)(const Variable& var, double x),
-                                              double (*func_fp)(const Variable& var, double x),
-                                              double (*func_fpi)(const Variable& var, double x));
-
 XBT_PUBLIC double func_reno_f(const Variable& var, double x);
 XBT_PUBLIC double func_reno_fp(const Variable& var, double x);
 XBT_PUBLIC double func_reno_fpi(const Variable& var, double x);
@@ -418,9 +405,6 @@ public:
   /* \begin{For Lagrange only} */
   double mu;
   double new_mu;
-  double (*func_f)(const Variable& var, double x);   /* (f)    */
-  double (*func_fp)(const Variable& var, double x);  /* (f')    */
-  double (*func_fpi)(const Variable& var, double x); /* (f')^{-1}    */
   /* \end{For Lagrange only} */
 
 private:
@@ -448,7 +432,7 @@ public:
    */
   explicit System(bool selective_update);
   /** @brief Free an existing Linear MaxMin system */
-  ~System();
+  virtual ~System();
 
   /**
    * @brief Create a new Linear MaxMin constraint
@@ -521,7 +505,10 @@ public:
   void print() const;
 
   /** @brief Solve the lmm system */
-  void solve();
+  void lmm_solve();
+
+  /** @brief Solve the lmm system. May be specialized in subclasses. */
+  virtual void solve() { lmm_solve(); }
 
 private:
   static void* variable_mallocator_new_f();
@@ -585,9 +572,10 @@ private:
   void remove_all_modified_set();
   void check_concurrency() const;
 
-  template <class CnstList> void solve(CnstList& cnst_list);
+  template <class CnstList> void lmm_solve(CnstList& cnst_list);
+
 public:
-  bool modified;
+  bool modified_ = false;
   boost::intrusive::list<Variable, boost::intrusive::member_hook<Variable, boost::intrusive::list_member_hook<>,
                                                                  &Variable::variable_set_hook>>
       variable_set;
@@ -603,24 +591,65 @@ public:
 
   simgrid::kernel::resource::Action::ModifiedSet* modified_set_ = nullptr;
 
-  void (*solve_fun)(lmm::System* self);
-
 private:
   bool selective_update_active; /* flag to update partially the system only selecting changed portions */
-  unsigned visited_counter;     /* used by System::update_modified_set() and System::remove_all_modified_set() to
-                                 * cleverly (un-)flag the constraints (more details in these functions) */
+  unsigned visited_counter_ = 1; /* used by System::update_modified_set() and System::remove_all_modified_set() to
+                                  * cleverly (un-)flag the constraints (more details in these functions) */
   boost::intrusive::list<Constraint, boost::intrusive::member_hook<Constraint, boost::intrusive::list_member_hook<>,
                                                                    &Constraint::constraint_set_hook>>
       constraint_set;
   boost::intrusive::list<Constraint, boost::intrusive::member_hook<Constraint, boost::intrusive::list_member_hook<>,
                                                                    &Constraint::modified_constraint_set_hook>>
       modified_constraint_set;
-  xbt_mallocator_t variable_mallocator;
+  xbt_mallocator_t variable_mallocator_ =
+      xbt_mallocator_new(65536, System::variable_mallocator_new_f, System::variable_mallocator_free_f, nullptr);
+  ;
+};
+
+class XBT_PUBLIC FairBottleneck : public System {
+public:
+  explicit FairBottleneck(bool selective_update) : System(selective_update) {}
+  void solve() final { bottleneck_solve(); }
+
+private:
+  void bottleneck_solve();
+};
+
+class XBT_PUBLIC Lagrange : public System {
+public:
+  explicit Lagrange(bool selective_update) : System(selective_update) {}
+  void solve() final { lagrange_solve(); }
+
+  static void set_default_protocol_function(double (*func_f)(const Variable& var, double x),
+                                            double (*func_fp)(const Variable& var, double x),
+                                            double (*func_fpi)(const Variable& var, double x));
+
+private:
+  void lagrange_solve();
+
+  bool check_feasible(bool warn);
+  double dual_objective();
+
+  static double (*func_f)(const Variable& var, double x);   /* (f)    */
+  static double (*func_fp)(const Variable& var, double x);  /* (f')    */
+  static double (*func_fpi)(const Variable& var, double x); /* (f')^{-1}    */
+
+  /*
+   * Local prototypes to implement the Lagrangian optimization with optimal step, also called dichotomy.
+   */
+  // computes the value of the dichotomy using a initial values, init, with a specific variable or constraint
+  static double dichotomy(double init, double diff(double, const Constraint&), const Constraint& cnst,
+                          double min_error);
+  // computes the value of the differential of constraint cnst applied to lambda
+  static double partial_diff_lambda(double lambda, const Constraint& cnst);
+
+  static double new_value(const Variable& var);
+  static double new_mu(const Variable& var);
 };
 
-extern XBT_PRIVATE double (*func_f_def)(const Variable&, double);
-extern XBT_PRIVATE double (*func_fp_def)(const Variable&, double);
-extern XBT_PRIVATE double (*func_fpi_def)(const Variable&, double);
+XBT_PUBLIC System* make_new_maxmin_system(bool selective_update);
+XBT_PUBLIC System* make_new_fair_bottleneck_system(bool selective_update);
+XBT_PUBLIC System* make_new_lagrange_system(bool selective_update);
 
 /** @} */
 }