Handling the case when a processor does not have any objs
authorHarshitha <gplkrsh2@illinois.edu>
Mon, 9 Apr 2012 02:30:25 +0000 (21:30 -0500)
committerHarshitha <gplkrsh2@illinois.edu>
Mon, 9 Apr 2012 02:30:25 +0000 (21:30 -0500)
src/ck-ldb/LBDatabase.C
src/ck-ldb/LBDatabase.ci
src/ck-ldb/LBDatabase.h

index 9fe4e6ed9f03c9282b49f09b70ba07a92db50eb6..1f5d253b72b23e9cfba1a50fefe982418f15d0aa 100644 (file)
@@ -24,7 +24,7 @@
 #   define DEBAD(x) /*CkPrintf x*/
 
 struct AdaptiveData {
-  int iteration;
+  double iteration;
   double max_load;
   double avg_load;
   double max_idle_load_ratio;
@@ -417,6 +417,8 @@ void LBDatabase::initnodeFn()
 
   _expectedLoad = new LBRealType[num_proc];
   for (proc=0; proc<num_proc; proc++) _expectedLoad[proc]=0.0;
+
+  //CkPrintf("Total objs in %d is %d\n", CkMyPe(), getLBDB()->ObjDataCount());
 }
 
 // called my constructor
@@ -454,6 +456,8 @@ void LBDatabase::init(void)
   adaptive_struct.total_syncs_called = 0;
   adaptive_struct.last_lb_type = -1;
 
+  lb_in_progress = false;
+
   is_prev_lb_refine = -1;
 }
 
@@ -604,11 +608,18 @@ void LBDatabase::ResumeClients() {
   max_load_vec.clear();
   total_load_vec.clear();
   total_contrib_vec.clear();
+  if (lb_in_progress) {
+    lbdb_no_obj_callback.clear();
+    lb_in_progress = false;
+  }
 
   max_load_vec.resize(VEC_SIZE, 0.0);
   total_load_vec.resize(VEC_SIZE, 0.0);
   total_contrib_vec.resize(VEC_SIZE, 0.0);
 
+  if (getLBDB()->ObjDataCount() == 0) {
+    HandleAdaptiveNoObj();
+  }
   LDResumeClients(myLDHandle);
 }
 
@@ -647,9 +658,9 @@ bool LBDatabase::AddLoad(int iteration, double load) {
       lb_data[5] = idle_time/total_load_vec[iteration];
     }
 
-   // CkPrintf("   [%d] sends total load %lf idle time %lf ratio of idle/load %lf at iter %d\n", CkMyPe(),
-   //     total_load_vec[iteration], idle_time,
-   //     idle_time/total_load_vec[iteration], adaptive_struct.lb_no_iterations);
+    //CkPrintf("   [%d] sends total load %lf idle time %lf ratio of idle/load %lf at iter %d\n", CkMyPe(),
+    //    total_load_vec[iteration], idle_time,
+    //    idle_time/total_load_vec[iteration], adaptive_struct.lb_no_iterations);
 
     CkCallback cb(CkIndex_LBDatabase::ReceiveMinStats((CkReductionMsg*)NULL), thisProxy[0]);
     contribute(6*sizeof(double), lb_data, lbDataCollectionType, cb);
@@ -666,6 +677,12 @@ void LBDatabase::ReceiveMinStats(CkReductionMsg *msg) {
   int iteration_n = load[0];
   DEBAD(("** [%d] Iteration Avg load: %lf Max load: %lf Avg Idle : %lf Max Idle : %lf for %lf procs\n",iteration_n, avg, max, avg_idle, max_idle_load_ratio, load[1]));
   delete msg;
+  
+  if (adaptive_struct.final_lb_period != iteration_n) {
+    for (int i = 0; i < lbdb_no_obj_callback.size(); i++) {
+      thisProxy[lbdb_no_obj_callback[i]].TriggerAdaptiveReduction();
+    }
+  }
  
   // Store the data for this iteration
   adaptive_struct.lb_no_iterations = iteration_n;
@@ -1020,6 +1037,49 @@ int LBDatabase::getPredictedLBPeriod(bool& is_tentative) {
    }
 }
 
+
+void LBDatabase::HandleAdaptiveNoObj() {
+  adaptive_struct.lb_no_iterations++;
+  thisProxy[0].RegisterNoObjCallback(CkMyPe());
+  TriggerAdaptiveReduction();
+}
+
+void LBDatabase::RegisterNoObjCallback(int index) {
+  if (lb_in_progress) {
+    lbdb_no_obj_callback.clear();
+    lb_in_progress = false;
+  }
+  lbdb_no_obj_callback.push_back(index);
+  CkPrintf("Registered %d to have no objs.\n", index);
+
+  // If collection has already happened and this is second iteration, then
+  // trigger reduction.
+  if (adaptive_struct.lb_no_iterations != -1) {
+    thisProxy[index].TriggerAdaptiveReduction();
+  }
+}
+
+void LBDatabase::TriggerAdaptiveReduction() {
+  adaptive_struct.lb_no_iterations++;
+  double lb_data[6];
+  lb_data[0] = adaptive_struct.lb_no_iterations;
+  lb_data[1] = 1;
+  lb_data[2] = 0.0;
+  //lb_data[2] = max_load_vec[iteration];
+  lb_data[3] = 0.0;
+  //lb_data[3] = getLBDB()->ObjDataCount();
+  lb_data[4] = 0.0;
+  lb_data[5] = 0.0;
+
+  // CkPrintf("   [%d] sends total load %lf idle time %lf ratio of idle/load %lf at iter %d\n", CkMyPe(),
+  //     total_load_vec[iteration], idle_time,
+  //     idle_time/total_load_vec[iteration], adaptive_struct.lb_no_iterations);
+
+  CkCallback cb(CkIndex_LBDatabase::ReceiveMinStats((CkReductionMsg*)NULL), thisProxy[0]);
+  contribute(6*sizeof(double), lb_data, lbDataCollectionType, cb);
+}
+
+
 bool LBDatabase::isStrategyComm() {
   return adaptive_struct.doCommStrategy;
 }
index b597a8d050a3f9ebf6d78dbb3473aa8f3aabfdeb..d19c170e910e6f37b00273266be0f008841b7896 100644 (file)
@@ -17,6 +17,8 @@ module LBDatabase {
     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 RegisterNoObjCallback(int);
+    entry [immediate] void TriggerAdaptiveReduction();
   }
 
 };
index 030e0f4e2d7188a39cf68f11ae5634c43994df7a..56be6a9c6d4b0ded1dcd4058f3e41b9cc8f0ad4d 100644 (file)
@@ -348,7 +348,10 @@ public:
     LDRemoveLocalBarrierReceiver(myLDHandle,h);
   };
 
-  inline void AtLocalBarrier(LDBarrierClient h) { LDAtLocalBarrier(myLDHandle,h); }
+  inline void AtLocalBarrier(LDBarrierClient h) {
+    lb_in_progress = true;
+    LDAtLocalBarrier(myLDHandle,h);
+  }
   inline void LocalBarrierOn(void) { LDLocalBarrierOn(myLDHandle); };
   inline void LocalBarrierOff(void) { LDLocalBarrierOn(myLDHandle); };
   void ResumeClients();
@@ -361,6 +364,9 @@ public:
   void LoadBalanceDecision(int, int);
   void LoadBalanceDecisionFinal(int, int);
   void ReceiveIterationNo(int, int); // Receives the current iter no
+  void HandleAdaptiveNoObj();
+  void RegisterNoObjCallback(int index);
+  void TriggerAdaptiveReduction();
 
   bool generatePlan(int& period);
   bool getLineEq(double new_load_percent, double& aslope, double& ac, double& mslope, double& mc);
@@ -393,7 +399,9 @@ private:
   std::vector<double> total_contrib_vec;
   std::vector<int> total_msg_vec;
   std::vector<int> total_bytes_vec;
+  std::vector<int> lbdb_no_obj_callback;
   int max_iteration;
+  bool lb_in_progress;
 
   double after_lb_max;
   double after_lb_avg;