using separate group for max iteration reduction
authorHarshitha <gplkrsh2@illinois.edu>
Sun, 14 Oct 2012 01:41:48 +0000 (20:41 -0500)
committerHarshitha <gplkrsh2@illinois.edu>
Sun, 14 Oct 2012 01:41:48 +0000 (20:41 -0500)
src/ck-ldb/MetaBalancer.C
src/ck-ldb/MetaBalancer.ci
src/ck-ldb/MetaBalancer.h

index 078dafa72452c3885ff4284089eae8d62f2f7fcc..96a2dadc3fc55a8f090f296143d409bc3751e681 100644 (file)
@@ -75,6 +75,7 @@ CkReductionMsg* lbDataCollection(int nMsg, CkReductionMsg** msgs) {
 }
 
 CkGroupID _metalb;
+CkGroupID _metalbred;
 
 CkpvDeclare(int, metalbInited);  /**< true if metabalancer is inited */
 
@@ -82,6 +83,7 @@ CkpvDeclare(int, metalbInited);  /**< true if metabalancer is inited */
 MetaLBInit::MetaLBInit(CkArgMsg *m) {
 #if CMK_LBDB_ON
   _metalb = CProxy_MetaBalancer::ckNew();
+  _metalbred = CProxy_MetaBalancerRedn::ckNew();
 #endif
   delete m;
 }
@@ -104,6 +106,8 @@ void MetaBalancer::init(void) {
   prev_idle = 0.0;
   alpha_beta_cost_to_load = 1.0; // Some random value. TODO: Find the actual
 
+  metaRdnGroup = (MetaBalancerRedn*)CkLocalBranch(_metalbred);
+
   adaptive_lbdb.lb_iter_no = -1;
 
   // If metabalancer enabled, initialize the variables
@@ -114,7 +118,6 @@ void MetaBalancer::init(void) {
   adaptive_struct.finished_iteration_no = -1;
   adaptive_struct.global_max_iter_no = 0;
   adaptive_struct.tentative_max_iter_no = -1;
-  adaptive_struct.global_recv_iter_counter = 0;
   adaptive_struct.in_progress = false;
   adaptive_struct.lb_strategy_cost = 0.0;
   adaptive_struct.lb_migration_cost = 0.0;
@@ -141,6 +144,7 @@ void MetaBalancer::pup(PUP::er& p) {
        IrrGroup::pup(p);
   if (p.isUnpacking()) {
     lbdatabase = (LBDatabase *)CkLocalBranch(_lbdb);
+    metaRdnGroup = (MetaBalancerRedn*)CkLocalBranch(_metalbred);
   }
   p|prev_idle;
   p|alpha_beta_cost_to_load;
@@ -160,7 +164,6 @@ void MetaBalancer::ResumeClients() {
   adaptive_struct.finished_iteration_no = -1;
   adaptive_struct.global_max_iter_no = 0;
   adaptive_struct.tentative_max_iter_no = -1;
-  adaptive_struct.global_recv_iter_counter = 0;
   adaptive_struct.in_progress = false;
   adaptive_struct.lb_strategy_cost = 0.0;
   adaptive_struct.lb_migration_cost = 0.0;
@@ -600,7 +603,12 @@ void MetaBalancer::LoadBalanceDecision(int req_no, int period) {
                        CkMyPe(), adaptive_struct.lb_iteration_no, period));
   adaptive_struct.tentative_period = period;
   adaptive_struct.lb_msg_recv_no = req_no;
-  thisProxy[0].ReceiveIterationNo(req_no, adaptive_struct.lb_iteration_no);
+  if (metaRdnGroup == NULL) {
+    metaRdnGroup = (MetaBalancerRedn*)CkLocalBranch(_metalbred);
+  }
+  if (metaRdnGroup != NULL) {
+    metaRdnGroup->getMaxIter(adaptive_struct.lb_iteration_no);
+  }
 }
 
 void MetaBalancer::LoadBalanceDecisionFinal(int req_no, int period) {
@@ -615,16 +623,14 @@ void MetaBalancer::LoadBalanceDecisionFinal(int req_no, int period) {
 }
 
 
-void MetaBalancer::ReceiveIterationNo(int req_no, int local_iter_no) {
+void MetaBalancer::ReceiveIterationNo(int local_iter_no) {
   CmiAssert(CkMyPe() == 0);
 
-  adaptive_struct.global_recv_iter_counter++;
   if (local_iter_no > adaptive_struct.global_max_iter_no) {
     adaptive_struct.global_max_iter_no = local_iter_no;
   }
 
   int period;
-  if (CkNumPes() == adaptive_struct.global_recv_iter_counter) {
 
     if (adaptive_struct.global_max_iter_no > adaptive_struct.tentative_max_iter_no) {
       adaptive_struct.tentative_max_iter_no = adaptive_struct.global_max_iter_no;
@@ -640,10 +646,8 @@ void MetaBalancer::ReceiveIterationNo(int req_no, int local_iter_no) {
       adaptive_struct.tentative_period = adaptive_struct.final_lb_period;
       DEBAD(("Final lb_period NOT CHANGED!%d\n", adaptive_struct.tentative_period));
     }
-    thisProxy.LoadBalanceDecisionFinal(req_no, adaptive_struct.tentative_period);
+    thisProxy.LoadBalanceDecisionFinal(adaptive_struct.lb_msg_recv_no, adaptive_struct.tentative_period);
     adaptive_struct.in_progress = false;
-    adaptive_struct.global_recv_iter_counter = 0;
-  }
 }
 
 int MetaBalancer::getPredictedLBPeriod(bool& is_tentative) {
@@ -807,6 +811,25 @@ void MetaBalancer::GetLBDataForLB(int lb_type, double& lb_max_avg_ratio,
   }
 }
 
+void MetaBalancerRedn::init() {
+  metabalancer = (MetaBalancer *)CkLocalBranch(_metalb);
+}
+
+void MetaBalancerRedn::ReceiveIterNo(int max_iter) {
+  CkAssert(CkMyPe() == 0);
+  if (metabalancer == NULL) {
+    metabalancer = (MetaBalancer*)CkLocalBranch(_metalb);
+  }
+  if (metabalancer != NULL) {
+    metabalancer->ReceiveIterationNo(max_iter);
+  }
+}
+
+void MetaBalancerRedn::getMaxIter(int max_iter) {
+  CkCallback cb(CkReductionTarget(MetaBalancerRedn, ReceiveIterNo), thisProxy[0]);
+  contribute(sizeof(int), &max_iter, CkReduction::max_int, cb);
+}
+
 #include "MetaBalancer.def.h"
 
 /*@}*/
index 431b3986f17f3b84a24e3828e7cabbb51df3165e..8d87d2eec7fcbc194512724579236dbf502f3732 100644 (file)
@@ -1,5 +1,6 @@
 module MetaBalancer {
   readonly CkGroupID _metalb;
+  readonly CkGroupID _metalbred;
 
   mainchare MetaLBInit {
     entry MetaLBInit(CkArgMsg *m);
@@ -13,9 +14,19 @@ module MetaBalancer {
     entry [immediate] void ReceiveMinStats(CkReductionMsg *msg);
     entry [immediate] void LoadBalanceDecision(int req_no, int period);
     entry [immediate] void LoadBalanceDecisionFinal(int req_no, int period);
-    entry [immediate] void ReceiveIterationNo(int, int);
+    entry [immediate] void ReceiveIterationNo(int);
     entry [immediate] void RegisterNoObjCallback(int);
     entry [immediate] void TriggerAdaptiveReduction();
   }
 
+  // This group is used only to handle reduction to obtain the maximum
+  // iteration. This reduction cannot incorporated in MetaBalancer class because
+  // there exists a reduction to collect minimum stats and this would overlap
+  // with that as there is no specific order.
+  group [migratable] MetaBalancerRedn {
+    entry void MetaBalancerRedn(void);
+    entry [immediate, reductiontarget] void ReceiveIterNo(int max_iter);
+    entry void getMaxIter(int);
+  }
+
 };
index d53777b4022aa3a7f59441c38908c7cc97a2dfb9..1c51fe3c6b2ed46f07593875e4e841253d8983df 100644 (file)
@@ -13,6 +13,7 @@
 #include "MetaBalancer.decl.h"
 
 extern CkGroupID _metalb;
+extern CkGroupID _metalbred;
 
 CkpvExtern(int, metalbInited);
 
@@ -33,6 +34,8 @@ public:
   
 private:
   void init();
+  MetaBalancerRedn* metaRdnGroup;
+
 public:
   inline static MetaBalancer * Object() { return CkpvAccess(metalbInited)?(MetaBalancer *)CkLocalBranch(_metalb):NULL; }
 
@@ -50,7 +53,7 @@ public:
   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 ReceiveIterationNo(int); // Receives the current iter no
   static void periodicCall(void *ad);
   static void checkForNoObj(void *ad);
   void HandleAdaptiveNoObj();
@@ -130,9 +133,6 @@ private:
     // 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;
@@ -152,7 +152,19 @@ private:
 public:
   bool lb_in_progress;
 
-public:
+};
+
+class MetaBalancerRedn : public CBase_MetaBalancerRedn {
+  public:
+    MetaBalancerRedn(void) {init();}
+    MetaBalancerRedn(CkMigrateMessage *m)  {init();}
+    ~MetaBalancerRedn()  {}
+    void ReceiveIterNo(int max_iter);
+    void getMaxIter(int);
+
+  private:
+    MetaBalancer* metabalancer;
+    void init();
 };
 
 inline MetaBalancer* MetaBalancerObj() { return MetaBalancer::Object(); }