cleanup
[charm.git] / src / ck-ldb / MetaBalancer.h
index 403604e65153c6cfa9b5c20db4e084d988224047..378fa9817d1100d453618bbc0cfab7fcc95db135 100644 (file)
@@ -1,7 +1,28 @@
 /**
- * \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
@@ -13,6 +34,7 @@
 #include "MetaBalancer.decl.h"
 
 extern CkGroupID _metalb;
+extern CkGroupID _metalbred;
 
 CkpvExtern(int, metalbInited);
 
@@ -27,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);
 
@@ -44,12 +70,14 @@ public:
 
   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();
@@ -120,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;
@@ -143,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(); }