Fixing an issue when there are no chares on a processor
authorHarshitha <gplkrsh2@illinois.edu>
Tue, 16 Oct 2012 03:17:22 +0000 (22:17 -0500)
committerHarshitha <gplkrsh2@illinois.edu>
Tue, 16 Oct 2012 03:17:22 +0000 (22:17 -0500)
12 files changed:
examples/charm++/load_balancing/kNeighbor/kNeighbor.C
src/ck-core/cklocation.C
src/ck-core/cklocation.h
src/ck-ldb/LBDBManager.C
src/ck-ldb/LBDBManager.h
src/ck-ldb/LBDatabase.h
src/ck-ldb/LBOM.h
src/ck-ldb/MetaBalancer.C
src/ck-ldb/MetaBalancer.ci
src/ck-ldb/MetaBalancer.h
src/ck-ldb/lbdb.C
src/ck-ldb/lbdb.h

index 6d3ad974ca6cf9dfd839d375f6af554f2c417848..98a3267612c44bec6981e5635080cdb06df0a4b1 100644 (file)
@@ -72,10 +72,10 @@ class Main: public CBase_Main {
       }
 
       num_chares = atoi(m->argv[1]);
-      if(num_chares < CkNumPes()) {
-       printf("Warning: #elements is forced to be equal to #pes\n");
-       num_chares = CkNumPes();
-      }
+//      if(num_chares < CkNumPes()) {
+//     printf("Warning: #elements is forced to be equal to #pes\n");
+//     num_chares = CkNumPes();
+//      }
 
       numSteps = atoi(m->argv[2]);
       currentMsgSize = atoi(m->argv[3]);
index 472e87a19fc9bfd4642431e1ce8071e1aa6bffc0..05a1ef2db5084047e48bde1b57e0876124c36035 100644 (file)
@@ -1165,6 +1165,7 @@ void CkMigratable::clearMetaLBData() {
     atsync_iteration = -1;
     prev_load = 0.0;
     can_reset = false;
+    myRec->getMetaBalancer()->ResumeClients();
 //  }
 }
 
@@ -1191,12 +1192,16 @@ void CkMigratable::recvLBPeriod(void *data) {
     local_state = LOAD_BALANCE;
 
     can_reset = true;
-    myRec->getLBDB()->AtLocalBarrier(ldBarrierHandle);
+    //myRec->getLBDB()->AtLocalBarrier(ldBarrierHandle);
     return;
   }
   local_state = DECIDED;
 }
 
+void CkMigratable::metaLBCallLB() {
+       myRec->getLBDB()->AtLocalBarrier(ldBarrierHandle);
+}
+
 void CkMigratable::ckFinishConstruction(void)
 {
 //     if ((!usesAtSync) || barrierRegistered) return;
@@ -1240,9 +1245,9 @@ void CkMigratable::AtSync(int waitForMigration)
   }
 
   atsync_iteration++;
-  // CkPrintf("[pe %s] atsync_iter %d && predicted period %d state: %d\n",
-  //     idx2str(thisIndexMax), atsync_iteration,
-  //     myRec->getMetaBalancer()->getPredictedLBPeriod(), local_state);
+  //CkPrintf("[pe %s] atsync_iter %d && predicted period %d state: %d\n",
+  //    idx2str(thisIndexMax), atsync_iteration,
+  //    myRec->getMetaBalancer()->getPredictedLBPeriod(), local_state);
   double tmp = prev_load;
   prev_load = myRec->getObjTime();
   double current_load = prev_load - tmp;
@@ -1266,7 +1271,7 @@ void CkMigratable::AtSync(int waitForMigration)
     DEBAD(("[%d:%s] Went to load balance iter %d\n", CkMyPe(), idx2str(thisIndexMax), atsync_iteration));
     local_state = LOAD_BALANCE;
     can_reset = true;
-    myRec->getLBDB()->AtLocalBarrier(ldBarrierHandle);
+    //myRec->getLBDB()->AtLocalBarrier(ldBarrierHandle);
   } else {
     DEBAD(("[%d:%s] Went to pause state iter %d\n", CkMyPe(), idx2str(thisIndexMax), atsync_iteration));
     local_state = PAUSE;
@@ -1450,6 +1455,10 @@ void CkLocRec_local::informIdealLBPeriod(int lb_ideal_period) {
   myLocMgr->informLBPeriod(this, lb_ideal_period);
 }
 
+void CkLocRec_local::metaLBCallLB() {
+       myLocMgr->metaLBCallLB(this);
+}
+
 #if CMK_LBDB_ON
 void CkLocRec_local::startTiming(int ignore_running) {
        if (!ignore_running) running=CmiTrue;
@@ -1671,7 +1680,7 @@ CmiBool CkLocRec_local::deliver(CkArrayMessage *msg,CkDeliver_t type,int opts)
 
 void CkLocRec_local::staticMetaLBResumeWaitingChares(LDObjHandle h, int lb_ideal_period) {
        CkLocRec_local *el=(CkLocRec_local *)LDObjUserData(h);
-       DEBL((AA"Load balancer wants to migrate %s to %d\n"AB,idx2str(el->idx),dest));
+       DEBL((AA"MetaBalancer wants to resume waiting chare %s\n"AB,idx2str(el->idx)));
        el->metaLBResumeWaitingChares(lb_ideal_period);
 }
 
@@ -1679,6 +1688,16 @@ void CkLocRec_local::metaLBResumeWaitingChares(int lb_ideal_period) {
   informIdealLBPeriod(lb_ideal_period);
 }
 
+void CkLocRec_local::staticMetaLBCallLBOnChares(LDObjHandle h) {
+       CkLocRec_local *el=(CkLocRec_local *)LDObjUserData(h);
+       DEBL((AA"MetaBalancer wants to call LoadBalance on chare %s\n"AB,idx2str(el->idx)));
+       el->metaLBCallLBOnChares();
+}
+
+void CkLocRec_local::metaLBCallLBOnChares() {
+  metaLBCallLB();
+}
+
 void CkLocRec_local::staticMigrate(LDObjHandle h, int dest)
 {
        CkLocRec_local *el=(CkLocRec_local *)LDObjUserData(h);
@@ -2892,6 +2911,10 @@ void CkLocMgr::informLBPeriod(CkLocRec_local *rec, int lb_ideal_period) {
        callMethod(rec,&CkMigratable::recvLBPeriod, (void *)&lb_ideal_period);
 }
 
+void CkLocMgr::metaLBCallLB(CkLocRec_local *rec) {
+       callMethod(rec, &CkMigratable::metaLBCallLB);
+}
+
 /**
   Migrating array element is arriving on this processor.
 */
@@ -3189,6 +3212,8 @@ void CkLocMgr::initLB(CkGroupID lbdbID_, CkGroupID metalbID_)
        myCallbacks.queryEstLoad = NULL;
   myCallbacks.metaLBResumeWaitingChares =
       (LDMetaLBResumeWaitingCharesFn)CkLocRec_local::staticMetaLBResumeWaitingChares;
+  myCallbacks.metaLBCallLBOnChares =
+      (LDMetaLBCallLBOnCharesFn)CkLocRec_local::staticMetaLBCallLBOnChares;
        myLBHandle = the_lbdb->RegisterOM(myId,this,myCallbacks);
 
        // Tell the lbdb that I'm registering objects
index 7b6be1ef41c50409195bade10c82cd39d4fb7f92..f09764166df743b49ef06c48706acdb2c9bc2b05 100644 (file)
@@ -175,6 +175,7 @@ public:
        const CkArrayIndex &idx_,int localIdx_);
   void migrateMe(int toPe); //Leave this processor
   void informIdealLBPeriod(int lb_ideal_period);
+  void metaLBCallLB();
   void destroy(void); //User called destructor
   virtual ~CkLocRec_local();
 
@@ -219,7 +220,9 @@ public:
   inline LDObjHandle getLdHandle() const{return ldHandle;}
   static void staticMigrate(LDObjHandle h, int dest);
   static void staticMetaLBResumeWaitingChares(LDObjHandle h, int lb_ideal_period);
+  static void staticMetaLBCallLBOnChares(LDObjHandle h);
   void metaLBResumeWaitingChares(int lb_ideal_period);
+  void metaLBCallLBOnChares();
   void recvMigrate(int dest);
   void setMigratable(int migratable);  /// set migratable
   void AsyncMigrate(CmiBool use);
@@ -325,6 +328,7 @@ public:
   virtual void ckJustMigrated(void); /*default is empty*/
 
   void recvLBPeriod(void *data);
+  void metaLBCallLB();
   void clearMetaLBData(void);
 
   //used for out-of-core emulation
@@ -604,6 +608,7 @@ public:
        //Migrate us to another processor
        void emigrate(CkLocRec_local *rec,int toPe);
   void informLBPeriod(CkLocRec_local *rec, int lb_ideal_period);
+  void metaLBCallLB(CkLocRec_local *rec);
 
 #if CMK_LBDB_ON
        LBDatabase *getLBDB(void) const { return the_lbdb; }
index 5f5c490f45365ce20e2bd2446de0e4c1f0838e37..9c65d729bbe59db325b8ea8971a63f4eafe195ef 100644 (file)
@@ -335,6 +335,17 @@ void LBDB::MetaLBResumeWaitingChares(int lb_ideal_period) {
   }
 }
 
+void LBDB::MetaLBCallLBOnChares() {
+  for (int i = 0; i < objs.length(); i++) {
+    LBObj* obj = objs[i];
+    if (obj) {
+      LBOM *om = oms[obj->parentOM().handle];
+      LDObjHandle h = obj->GetLDObjHandle();
+      om->MetaLBCallLBOnChares(h);
+    }
+  }
+}
+
 void LBDB::Migrated(LDObjHandle h, int waitBarrier)
 {
   // Object migrated, inform load balancers
index d85fd2200289119bf535c4727cb67751f549bb6e..eedeba4587e276cd27e72f556f6f9900640df20a 100644 (file)
@@ -137,6 +137,7 @@ public:
        { if (commTable) commTable->GetCommData(data); };
 
   void MetaLBResumeWaitingChares(int lb_ideal_period);
+  void MetaLBCallLBOnChares();
   int  Migrate(LDObjHandle h, int dest);
   void Migrated(LDObjHandle h, int waitBarrier=1);
   int  NotifyMigrated(LDMigratedFn fn, void* data);
index e9d9ff3c03ac45db3c5bc836727b0ac1b52869e8..030c3512efbc8dbabcf241ca024a2a41841527bd 100644 (file)
@@ -360,6 +360,11 @@ public:
   inline void MetaLBResumeWaitingChares(int lb_period) {
     LDOMMetaLBResumeWaitingChares(myLDHandle, lb_period);
   }
+
+  inline void MetaLBCallLBOnChares() {
+    LDOMMetaLBCallLBOnChares(myLDHandle);
+  }
+
   void SetMigrationCost(double cost);
   void SetStrategyCost(double cost);
        void UpdateDataAfterLB(double mLoad, double mCpuLoad, double avgLoad);
index d549fbc627560a48ac3af80c2bcc31ab9761f135..e1d4e49029de96f27c5985e00ccbbd93de6fe3ba 100644 (file)
@@ -38,6 +38,9 @@ private:
   void MetaLBResumeWaitingChares(LDObjHandle _h, int lb_ideal_period) {
     callbacks.metaLBResumeWaitingChares(_h, lb_ideal_period);
   }
+  void MetaLBCallLBOnChares(LDObjHandle _h) {
+    callbacks.metaLBCallLBOnChares(_h);
+  }
   CmiBool RegisteringObjs() { return registering_objs; };
   void SetRegisteringObjs(CmiBool _set) { registering_objs = _set; };
 
index 856bf12b8bbc82b917f00cc39fb6e630459a9e6f..1c8c2b7299e7527ade0e3b9c3076ef80fb2737b9 100644 (file)
@@ -155,6 +155,9 @@ void MetaBalancer::pup(PUP::er& p) {
 
 void MetaBalancer::ResumeClients() {
   // If metabalancer enabled, initialize the variables
+  if (!resume_client_called) {
+    resume_client_called = true;
+  CkPrintf("[%d] Metabalancer ResumeClient\n", CkMyPe());
   adaptive_lbdb.history_data.clear();
 
   adaptive_struct.tentative_period =  INT_MAX;
@@ -177,6 +180,7 @@ void MetaBalancer::ResumeClients() {
     lb_in_progress = false;
   }
   HandleAdaptiveNoObj();
+  }
 }
 
 int MetaBalancer::get_iteration() {
@@ -254,6 +258,7 @@ bool MetaBalancer::AddLoad(int it_n, double load) {
 
     CkCallback cb(CkIndex_MetaBalancer::ReceiveMinStats((CkReductionMsg*)NULL), thisProxy[0]);
     contribute(STATS_COUNT*sizeof(double), lb_data, lbDataCollectionType, cb);
+    resume_client_called = false;
   }
   return true;
 }
@@ -293,6 +298,11 @@ void MetaBalancer::ReceiveMinStats(CkReductionMsg *msg) {
     adaptive_struct.info_first_iter.max_avg_ratio = max/avg;
   }
 
+
+  if (adaptive_struct.final_lb_period == iteration_n) {
+    thisProxy.MetaLBCallLBOnChares();
+  }
+
   // If lb period inform is in progress, dont inform again.
   // If this is the lb data corresponding to the final lb period informed, then
   // don't recalculate as some of the processors might have already gone into
@@ -628,6 +638,9 @@ void MetaBalancer::LoadBalanceDecisionFinal(int req_no, int period) {
   lbdatabase->MetaLBResumeWaitingChares(period);
 }
 
+void MetaBalancer::MetaLBCallLBOnChares() {
+  lbdatabase->MetaLBCallLBOnChares();
+}
 
 void MetaBalancer::ReceiveIterationNo(int local_iter_no) {
   CmiAssert(CkMyPe() == 0);
@@ -677,6 +690,7 @@ int MetaBalancer::getPredictedLBPeriod(bool& is_tentative) {
 void MetaBalancer::ResetAdaptive() {
   adaptive_lbdb.lb_iter_no = -1;
   lb_in_progress = true;
+  CkPrintf("[%d] In Meta Reset Adapt\n", CkMyPe());
 }
 
 // This is required for PEs with no objs
@@ -693,7 +707,9 @@ void MetaBalancer::checkForNoObj(void *ad) {
 // Called by LBDatabase to indicate that no objs are there in this processor
 void MetaBalancer::HandleAdaptiveNoObj() {
   if (lbdatabase->getLBDB()->ObjDataCount() == 0) {
+    resume_client_called = false;
     adaptive_struct.finished_iteration_no++;
+    adaptive_struct.lb_iteration_no++;
     DEBAD(("(%d) --HandleAdaptiveNoObj %d\n", CkMyPe(),
           adaptive_struct.finished_iteration_no));
     thisProxy[0].RegisterNoObjCallback(CkMyPe());
@@ -718,13 +734,14 @@ void MetaBalancer::RegisterNoObjCallback(int index) {
   if (adaptive_lbdb.lb_iter_no != -1) {
     DEBAD(("Collection already started now %d so kick in\n",
         adaptive_struct.finished_iteration_no));
-    thisProxy[index].TriggerAdaptiveReduction();
+    //thisProxy[index].TriggerAdaptiveReduction();
   }
 }
 
 void MetaBalancer::TriggerAdaptiveReduction() {
   if (lbdatabase->getLBDB()->ObjDataCount() == 0) {
     adaptive_struct.finished_iteration_no++;
+    adaptive_struct.lb_iteration_no++;
     double lb_data[STATS_COUNT];
     lb_data[0] = adaptive_struct.finished_iteration_no;
     lb_data[1] = 1;
index 8d87d2eec7fcbc194512724579236dbf502f3732..f067fa9a82674eb4be18d2f2caebf9c0b577d3d6 100644 (file)
@@ -17,6 +17,7 @@ module MetaBalancer {
     entry [immediate] void ReceiveIterationNo(int);
     entry [immediate] void RegisterNoObjCallback(int);
     entry [immediate] void TriggerAdaptiveReduction();
+    entry [immediate] void MetaLBCallLBOnChares();
   }
 
   // This group is used only to handle reduction to obtain the maximum
index eb5c8ffe3ea6b9cdf0b2e8183d50f78ee62aaa83..a4113964da99570e0410d18d3d5510a0f8422e2d 100644 (file)
@@ -76,6 +76,7 @@ public:
   void TriggerSoon(int iteration_no, double imbalance_ratio, double tolerate_imb);
   void LoadBalanceDecision(int, int);
   void LoadBalanceDecisionFinal(int, int);
+  void MetaLBCallLBOnChares();
   void ReceiveIterationNo(int); // Receives the current iter no
   static void periodicCall(void *ad);
   static void checkForNoObj(void *ad);
@@ -117,6 +118,7 @@ private:
   double prev_idle;
   double alpha_beta_cost_to_load;
   int is_prev_lb_refine;
+  bool resume_client_called;
 
   struct AdaptiveData {
     double iteration;
index 31fa656f6139cc152a0ff4dcba1e49a379b81c84..abc23438d08992cc0176a9549220f227159fcaa8 100644 (file)
@@ -34,6 +34,11 @@ extern "C" void LDOMMetaLBResumeWaitingChares(LDHandle _db, int lb_ideal_period)
   db->MetaLBResumeWaitingChares(lb_ideal_period);
 }
 
+extern "C" void LDOMMetaLBCallLBOnChares(LDHandle _db) {
+  LBDB *const db = (LBDB*)(_db.handle);
+  db->MetaLBCallLBOnChares();
+}
+
 extern "C" void * LDOMUserData(LDOMHandle &_h)
 {
   LBDB *const db = (LBDB*)(_h.ldb.handle);
index 04ef6bca3f235288a175c5a2c61c76fe34fce5cb..2b8fbcd7d8443359012c9a94793c48cb41d185db 100644 (file)
@@ -226,12 +226,14 @@ typedef void (*LDMigrateFn)(LDObjHandle handle, int dest);
 typedef void (*LDStatsFn)(LDOMHandle h, int state);
 typedef void (*LDQueryEstLoadFn)(LDOMHandle h);
 typedef void (*LDMetaLBResumeWaitingCharesFn) (LDObjHandle handle, int lb_ideal_period);
+typedef void (*LDMetaLBCallLBOnCharesFn) (LDObjHandle handle);
 
 typedef struct {
   LDMigrateFn migrate;
   LDStatsFn setStats;
   LDQueryEstLoadFn queryEstLoad;
   LDMetaLBResumeWaitingCharesFn metaLBResumeWaitingChares;
+  LDMetaLBCallLBOnCharesFn metaLBCallLBOnChares;
 } LDCallbacks;
 
 /*
@@ -247,6 +249,7 @@ LDOMHandle LDRegisterOM(LDHandle _lbdb, LDOMid userID,
                        void *userptr, LDCallbacks cb);
 
 void LDOMMetaLBResumeWaitingChares(LDHandle _h, int lb_ideal_period);
+void LDOMMetaLBCallLBOnChares(LDHandle _h);
 void * LDOMUserData(LDOMHandle &_h);
 void LDRegisteringObjects(LDOMHandle _h);
 void LDDoneRegisteringObjects(LDOMHandle _h);