cleanup
[charm.git] / src / ck-ldb / MetaBalancer.h
index 3db3de46190d220fc5ceb1b9e13ecab9af65148f..378fa9817d1100d453618bbc0cfab7fcc95db135 100644 (file)
@@ -1,18 +1,32 @@
 /**
- * \addtogroup CkLdb
+* Meta-Balancer is for automating the load balancing decisions based on the
+* application characteristics. The decision of when to call the load balancer is
+* handled by the MetaBalancer if +MetaLB flag is set when launching the
+* application. AtSync should be called very often (every couple of iterations).
+*
+* Meta-Balancer is not aware of the application iteration so it depends on
+* AtSync calls to count the iterations. At every AtSync call, if +MetaLB is
+* set, the chare sends its object load to the MetaBalancer on its local
+* processor and resumes its work. Once all the chares residing on the processor
+* has contributed their load information, this information is collected at the
+* central processor(root) using reduction. The root calculates the ideal period
+* based on linear extrapolation and informs a tentative lb period to all the
+* processors via broadcast. The Meta-Balancer residing on each processor then
+* informs the root about the maximum iteration of any chare on their processor.
+* The root then informs the final lb period, which is the max of calculated and
+* max. Meanwhile, chares can be in various states. Chare goes to LOAD_BALANCE
+* state when it enters load balancing phase. It goes to PAUSE state when the
+* chare has reached the tentative period and is waiting for the final period to
+* be announced.
+*
+* To handle the case of no objects on a particular processor, a timer call is
+* set which checks for the number of objects and if found to be == 0,
+* contributes to the reduction which collects minimum statistics.
 */
-/*@{*/
 
 #ifndef METABALANCER_H
 #define METABALANCER_H
 
-
-//#include <charm++.h>
-//#include "ckreduction.h" 
-
-//#include "lbdb.h"
-//#include "LBDBManager.h"
-//#include "lbdb++.h"
 #include "LBDatabase.h"
 
 #include <vector>
@@ -20,6 +34,7 @@
 #include "MetaBalancer.decl.h"
 
 extern CkGroupID _metalb;
+extern CkGroupID _metalbred;
 
 CkpvExtern(int, metalbInited);
 
@@ -34,14 +49,18 @@ class MetaLBInit : public Chare {
 
 class MetaBalancer : public CBase_MetaBalancer {
 public:
-  MetaBalancer(void)  { init(); }
-  MetaBalancer(CkMigrateMessage *m)  { init(); }
+  MetaBalancer(void) { init(); }
+  MetaBalancer(CkMigrateMessage *m) : CBase_MetaBalancer(m) { init(); }
   ~MetaBalancer()  {}
-  
 private:
   void init();
+  MetaBalancerRedn* metaRdnGroup;
+
 public:
-  inline static MetaBalancer * Object() { return CkpvAccess(metalbInited)?(MetaBalancer *)CkLocalBranch(_metalb):NULL; }
+  inline static MetaBalancer * Object() {
+    return CkpvAccess(metalbInited)?(MetaBalancer *)CkLocalBranch(_metalb):NULL;
+  }
 
   static void initnodeFn(void);
 
@@ -49,17 +68,16 @@ public:
 
   void ResumeClients();
 
-/*  inline void SetLBPeriod(double s) { LDSetLBPeriod(myLDHandle, s);}
-  inline double GetLBPeriod() { return LDGetLBPeriod(myLDHandle);}*/ //NOTE
-
   void ResetAdaptive();
   int get_iteration();
+  int get_finished_iteration();
   bool AddLoad(int iteration, double load);
   void ReceiveMinStats(CkReductionMsg *);
   void TriggerSoon(int iteration_no, double imbalance_ratio, double tolerate_imb);
   void LoadBalanceDecision(int, int);
   void LoadBalanceDecisionFinal(int, int);
-  void ReceiveIterationNo(int, int); // Receives the current iter no
+  void MetaLBCallLBOnChares();
+  void ReceiveIterationNo(int); // Receives the current iter no
   static void periodicCall(void *ad);
   static void checkForNoObj(void *ad);
   void HandleAdaptiveNoObj();
@@ -67,9 +85,11 @@ public:
   void TriggerAdaptiveReduction();
 
   bool generatePlan(int& period, double& ratio_at_t);
-  bool getLineEq(double new_load_percent, double& aslope, double& ac, double& mslope, double& mc);
+  bool getLineEq(double new_load_percent, double& aslope, double& ac,
+      double& mslope, double& mc);
   bool getPeriodForLinear(double a, double b, double c, int& period);
-  bool getPeriodForStrategy(double new_load, double overhead_percent, int& period, double& ratio_at_t);
+  bool getPeriodForStrategy(double new_load, double overhead_percent,
+      int& period, double& ratio_at_t);
   int getPredictedLBPeriod(bool& is_tentative);
 
   bool isStrategyComm();
@@ -90,16 +110,11 @@ public:
 private:
   //CProxy_MetaBalancer thisProxy;
   LBDatabase* lbdatabase;
-  int mystep;
   std::vector<double> total_load_vec;
   // Keeps track of how many local chares contributed
   std::vector<int> total_count_vec;
   std::vector<int> lbdb_no_obj_callback;
 
-  int max_iteration;
-
-  double after_lb_max;
-  double after_lb_avg;
   double prev_idle;
   double alpha_beta_cost_to_load;
   int is_prev_lb_refine;
@@ -133,15 +148,15 @@ private:
     int final_lb_period;
     // This is based on the linear extrapolation
     int lb_calculated_period;
+    // Current maximum iteration no of any chare on this processor
     int lb_iteration_no;
+    // This corresponds to the last iteration that was contributed
+    int finished_iteration_no;
     // This is set when all the processor sends the maximum iteration no
     int global_max_iter_no;
     // This keeps track of what was the max iteration no we had previously
     // received. TODO: Mostly global_max_iter_no should be sufficied.
     int tentative_max_iter_no;
-    // TODO: Use reduction to collect max iteration. Then we don't need this
-    // counter.
-    int global_recv_iter_counter;
     // true indicates it is in Inform->ReceiveMaxIter->FinalLBPeriod stage.
     bool in_progress;
     double lb_strategy_cost;
@@ -156,12 +171,26 @@ private:
     AdaptiveLBInfo refine_info;
     AdaptiveLBInfo comm_info;
     AdaptiveLBInfo comm_refine_info;
+    AdaptiveLBInfo info_first_iter;
   } adaptive_struct;
 
 public:
   bool lb_in_progress;
 
-public:
+};
+
+class MetaBalancerRedn : public CBase_MetaBalancerRedn {
+  public:
+    MetaBalancerRedn(void) {init();}
+    MetaBalancerRedn(CkMigrateMessage *m) : CBase_MetaBalancerRedn(m)  {init();}
+    ~MetaBalancerRedn()  {}
+    void pup(PUP::er& p);
+    void ReceiveIterNo(int max_iter);
+    void getMaxIter(int);
+
+  private:
+    MetaBalancer* metabalancer;
+    void init();
 };
 
 inline MetaBalancer* MetaBalancerObj() { return MetaBalancer::Object(); }