Changes to AdaptiveLB strategy
authorHarshitha <gplkrsh2@illinois.edu>
Mon, 26 Mar 2012 18:03:05 +0000 (13:03 -0500)
committerHarshitha <gplkrsh2@illinois.edu>
Mon, 26 Mar 2012 18:03:05 +0000 (13:03 -0500)
src/ck-ldb/AdaptiveLB.C
src/ck-ldb/AdaptiveLB.h
src/ck-ldb/BaseLB.h
src/ck-ldb/CentralLB.h
src/ck-ldb/GreedyLB.C
src/ck-ldb/LBDatabase.C
src/ck-ldb/LBDatabase.h
src/ck-ldb/MetisLB.C
src/ck-ldb/RefineLB.C
src/ck-ldb/Refiner.C
src/ck-ldb/Refiner.h

index 2687d4e4662da307b232db04d1dffd3daf1a55bd..c75228ac29ac1cbc005e43312cb50784b37fcc08 100644 (file)
@@ -24,7 +24,7 @@ AdaptiveLB::AdaptiveLB(const CkLBOptions &opt): CentralLB(opt)
   char *lbcopy = strdup(lbs);
   char *greedyLBString = "GreedyLB";
   char *refineLBString = "RefineLB";
-//  char *scotchLBString = "ScotchLB";
+  char *metisLBString = "MetisLB";
 
   LBAllocFn fn = getLBAllocFn(greedyLBString);
   if (fn == NULL) {
@@ -42,13 +42,13 @@ AdaptiveLB::AdaptiveLB(const CkLBOptions &opt): CentralLB(opt)
   BaseLB *rlb = fn();
   refineLB = (CentralLB*)rlb;
 
-//  fn = getLBAllocFn(scotchLBString);
-//  if (fn == NULL) {
-//    CkPrintf("LB> Invalid load balancer: %s.\n", scotchLBString);
-//    CmiAbort("");
-//  }
-//  BaseLB *slb = fn();
-//  scotchLB = (CentralLB*)slb;
+  fn = getLBAllocFn(metisLBString);
+  if (fn == NULL) {
+    CkPrintf("LB> Invalid load balancer: %s.\n", metisLBString);
+    CmiAbort("");
+  }
+  BaseLB *slb = fn();
+  metisLB = (CentralLB*)slb;
 }
 
 void AdaptiveLB::work(LDStats* stats)
@@ -58,38 +58,65 @@ void AdaptiveLB::work(LDStats* stats)
   ObjGraph *ogr = new ObjGraph(stats);
   CkPrintf("Adaptive work\n");
 
+  bool isRefine = theLbdb->isStrategyRefine();
+
   // Calculate the load and total messages
-//  double totalLoad = 0.0;
-//  long totalMsgs = 0;
-//  long long totalBytes = 0;
-//  int vertnbr = ogr->vertices.size();
-//
-//  /** the object load is normalized to an integer between 0 and 256 */
-//  for(int i = 0; i < vertnbr; i++) {
-//    totalLoad += ogr->vertices[i].getVertexLoad();
-//  }
-//
-//  for(int i = 0; i < vertnbr; i++) {
-//    for(int j = 0; j < ogr->vertices[i].sendToList.size(); j++) {
-//      totalMsgs += ogr->vertices[i].sendToList[j].getNumMsgs();
-//      totalBytes += ogr->vertices[i].sendToList[j].getNumBytes();
-//    }
-//  }
-//  double commOverhead = (totalMsgs * alpha) + (totalBytes * beta);
-//
-//  CkPrintf("AdaptiveLB> Total load %E\n", totalLoad);
-//  CkPrintf("AdaptiveLB> Total Msgs %d\n", totalMsgs);
-//  CkPrintf("AdaptiveLB> Total Bytes %ld\n", totalBytes);
-//  CkPrintf("AdaptiveLB> Total Comm %E\n", commOverhead);
-//
-//  // Choose the right LB
-//  //
-//  // If communication overhead is 10% computation, then choose Scotch LB
-//  if (commOverhead > (totalLoad * percent_overhead / 100)) {
-//    scotchLB->work(stats);
-//  } else {
-//    refineLB->work(stats);
-//  }
+  double totalLoad = 0.0;
+  long totalMsgs = 0;
+  long long totalBytes = 0;
+  int vertnbr = ogr->vertices.size();
+
+  /** the object load is normalized to an integer between 0 and 256 */
+  for(int i = 0; i < vertnbr; i++) {
+    totalLoad += ogr->vertices[i].getVertexLoad();
+  }
+
+  for(int i = 0; i < vertnbr; i++) {
+    for(int j = 0; j < ogr->vertices[i].sendToList.size(); j++) {
+      totalMsgs += ogr->vertices[i].sendToList[j].getNumMsgs();
+      totalBytes += ogr->vertices[i].sendToList[j].getNumBytes();
+    }
+  }
+  double commOverhead = (totalMsgs * alpha) + (totalBytes * beta);
+
+  CkPrintf("AdaptiveLB> Total load %E\n", totalLoad);
+  CkPrintf("AdaptiveLB> Total Msgs %d\n", totalMsgs);
+  CkPrintf("AdaptiveLB> Total Bytes %ld\n", totalBytes);
+  CkPrintf("AdaptiveLB> Total Comm Overhead %E Total Load %E\n", commOverhead, totalLoad);
+
+  double after_lb_max;
+  double after_lb_avg;
+  int is_prev_lb_refine;
+  GetPrevLBData(is_prev_lb_refine, after_lb_max, after_lb_avg);
+
+  CkPrintf("AdaptiveLB> Previous LB %d\n", is_prev_lb_refine);
+
+  // Choose the right LB
+  //
+  // If communication overhead is 10% computation, then choose Scotch LB
+  if (commOverhead > (totalLoad * percent_overhead / 100)) {
+    metisLB->work(stats);
+    CkPrintf("---METIS LB\n");
+  } else {
+    if (is_prev_lb_refine == 1) {
+      if (after_lb_max/after_lb_avg < 1.01) {
+        refineLB->work(stats);
+        CkPrintf("---REFINE LB\n");
+      } else {
+        greedyLB->work(stats);
+        CkPrintf("---GREEDY LB\n");
+      }
+    } else if (is_prev_lb_refine == -1) {
+      greedyLB->work(stats);
+      CkPrintf("---GREEDY LB\n");
+    } else {
+      refineLB->work(stats);
+      CkPrintf("---REFINE LB\n");
+    }
+  }
+  UpdateLBDBWithData(stats->is_prev_lb_refine, stats->after_lb_max,
+      stats->after_lb_avg);
+
   delete parr;
   delete ogr;
 
index e48036a39640065d16d76f50e7a659965c68c957..98d2d7a4695fb62c4e61cb773ae1006c3f5c9375 100644 (file)
@@ -29,7 +29,7 @@ private:
 //  CProxy_CentralLB thisProxy;
   CentralLB *greedyLB;
   CentralLB *refineLB;
-  CentralLB *scotchLB;
+  CentralLB *metisLB;
 };
 
 #endif /* CENTRAL_ADAPTIVE_LB_H */
index 36456dc750116c7dac1e95bdac18fcbd482d990a..08159134fad53e74be3225eef29239ba0c1864a8 100644 (file)
@@ -102,6 +102,10 @@ public:
     int complete_flag;         // if this ocg is complete, eg in HybridLB,
                                // this LDStats may not be complete
 
+    int is_prev_lb_refine;
+    double after_lb_max;
+    double after_lb_avg;
+
     LDStats(int c=0, int complete_flag=1);
     /// the functions below should be used to obtain the number of processors
     /// instead of accessing count directly
index 854f5e4bdce1e98656cd200d9be46a1d3c679f7c..b0dbd5f3a2f6fe3b44b8d4c1e4eae7390da34732 100644 (file)
@@ -239,6 +239,17 @@ protected:
                       LBMigrateMsg* msg, LBSimulation* simResults);
   void removeNonMigratable(LDStats* statsDataList, int count);
 
+  virtual void UpdateLBDBWithData(int is_prev_lb_refine, double lb_max,
+      double lb_avg) {
+    theLbdb->UpdateAfterLBData(is_prev_lb_refine, lb_max, lb_avg);
+  }
+
+  virtual void GetPrevLBData(int& is_prev_lb_refine, double& lb_max,
+      double& lb_avg) {
+    theLbdb->GetPrevLBData(is_prev_lb_refine, lb_max, lb_avg);
+  }
+
+
 private:  
   CProxy_CentralLB thisProxy;
   int myspeed;
@@ -254,6 +265,7 @@ private:
   LBMigrateMsg   *storedMigrateMsg;
   int  reduction_started;
 
+
   FutureModel *predicted_model;
 
   void BuildStatsMsg();
index 74c85a374e795c37710c868ea21438bc05053b78..aba514543cba5615a3ebb722929885760f73314e 100644 (file)
@@ -58,6 +58,7 @@ void GreedyLB::work(LDStats* stats)
   int *map = new int[n_pes];
 
   ProcArray *parr = new ProcArray(stats);
+  double bg_load = 0.0;
 
   std::vector<ProcInfo>  procs;
   for(pe = 0; pe < n_pes; pe++) {
@@ -65,6 +66,7 @@ void GreedyLB::work(LDStats* stats)
     if (stats->procs[pe].available) {
       map[pe] = procs.size();
       procs.push_back(ProcInfo(pe, stats->procs[pe].bg_walltime, 0.0, stats->procs[pe].pe_speed, true));
+      bg_load = stats->procs[pe].bg_walltime;
     }
   }
 
@@ -96,7 +98,7 @@ void GreedyLB::work(LDStats* stats)
     }
     avg_load += parr->procs[pe].totalLoad();
   }
-  CkPrintf("Before GreedyLB max load: %lf avg load: %lf\n", max_load, avg_load/procs.size());
+  CkPrintf("Before GreedyLB max load: %lf avg load: %lf bg load: %lf\n", max_load, avg_load/procs.size(), bg_load/procs.size());
 
   // build object array
   std::vector<Vertex> objs;
@@ -160,7 +162,7 @@ void GreedyLB::work(LDStats* stats)
     }
     avg_load += procs[pe].totalLoad();
   }
-  CkPrintf("GreedyLB max load: %lf avg load: %lf\n", max_load, avg_load/procs.size());
+  CkPrintf("GreedyLB> After lb max load: %lf avg load: %lf\n", max_load, avg_load/procs.size());
 
   if (_lb_args.debug()>1)  {
     CkPrintf("CharmLB> Min obj: %f  Max obj: %f\n", objs[objs.size()-1].getVertexLoad(), objs[0].getVertexLoad());
@@ -174,6 +176,10 @@ void GreedyLB::work(LDStats* stats)
     CkPrintf("\n");
   }
 
+  stats->after_lb_max = max_load;
+  stats->after_lb_avg = avg_load/procs.size();
+  stats->is_prev_lb_refine = 0;
+
 }
 
 #include "GreedyLB.def.h"
index 8b7853bbe9845ffcf9f95b4833c35b9df1667fa1..0949dd23c5ab58ac4340bb8465eaf35f51d7c4c5 100644 (file)
@@ -21,6 +21,8 @@ struct AdaptiveData {
   int iteration;
   double max_load;
   double avg_load;
+  double max_idle_time;
+  double idle_time;
 };
 
 struct AdaptiveLBDatabase {
@@ -41,29 +43,34 @@ struct AdaptiveLBStructure {
   bool isRefine;
   int lb_msg_send_no;
   int lb_msg_recv_no;
+  int total_syncs_called;
 } adaptive_struct;
 
 
 CkReductionMsg* lbDataCollection(int nMsg, CkReductionMsg** msgs) {
-  double lb_data[4];
-  lb_data[0] = 0;
-  lb_data[1] = 0;
-  lb_data[2] = 0;
+  double lb_data[6];
+  lb_data[1] = 0.0;
+  lb_data[2] = 0.0;
+  lb_data[3] = 0.0;
+  lb_data[4] = 0.0;
+  lb_data[5] = 0.0;
   for (int i = 0; i < nMsg; i++) {
     CkAssert(msgs[i]->getSize() == 4*sizeof(double));
     double* m = (double *)msgs[i]->getData();
-    lb_data[0] += m[0];
-    lb_data[1] = ((m[1] > lb_data[1])? m[1] : lb_data[1]);
-    lb_data[2] += m[2];
+    lb_data[1] += m[1];
+    lb_data[2] = ((m[2] > lb_data[2])? m[2] : lb_data[2]);
+    lb_data[3] += m[3];
+    lb_data[4] = ((m[4] > lb_data[4]) ? m[4] : lb_data[4]);
+    lb_data[5] += m[5];
     if (i == 0) {
-      lb_data[3] = m[3];
+      lb_data[0] = m[0];
     }
-    if (m[3] != lb_data[3]) {
+    if (m[0] != lb_data[0]) {
       CkPrintf("Error!!! Reduction is intermingled between iteration %lf and\
-      %lf\n", lb_data[3], m[3]);
+      %lf\n", lb_data[0], m[0]);
     }
   }
-  return CkReductionMsg::buildNew(4*sizeof(double), lb_data);
+  return CkReductionMsg::buildNew(6*sizeof(double), lb_data);
 }
 
 /*global*/ CkReduction::reducerType lbDataCollectionType;
@@ -403,9 +410,9 @@ void LBDatabase::init(void)
   if (manualOn) TurnManualLBOn();
 #endif
   
-  max_load_vec.resize(100, 0);
-  total_load_vec.resize(100, 0);
-  total_contrib_vec.resize(100, 0);
+  max_load_vec.resize(100, 0.0);
+  total_load_vec.resize(100, 0.0);
+  total_contrib_vec.resize(100, 0.0);
   max_iteration = -1;
 
   // If metabalancer enabled, initialize the variables
@@ -420,7 +427,9 @@ void LBDatabase::init(void)
   adaptive_struct.lb_migration_cost = 0.0;
   adaptive_struct.lb_msg_send_no = 0;
   adaptive_struct.lb_msg_recv_no = 0;
+  adaptive_struct.total_syncs_called = 0;
 
+  is_prev_lb_refine = -1;
 }
 
 LBDatabase::LastLBInfo::LastLBInfo()
@@ -551,6 +560,8 @@ void LBDatabase::EstObjLoad(const LDObjHandle &_h, double cputime)
 
 void LBDatabase::ResumeClients() {
   // If metabalancer enabled, initialize the variables
+  adaptive_lbdb.history_data.clear();
+
   adaptive_struct.lb_ideal_period =  INT_MAX;
   adaptive_struct.lb_calculated_period = INT_MAX;
   adaptive_struct.lb_no_iterations = -1;
@@ -562,6 +573,7 @@ void LBDatabase::ResumeClients() {
   adaptive_struct.lb_migration_cost = 0.0;
   adaptive_struct.lb_msg_send_no = 0;
   adaptive_struct.lb_msg_recv_no = 0;
+  adaptive_struct.total_syncs_called = 0;
   
   max_load_vec.clear();
   total_load_vec.clear();
@@ -576,6 +588,7 @@ void LBDatabase::ResumeClients() {
 
 bool LBDatabase::AddLoad(int iteration, double load) {
   total_contrib_vec[iteration]++;
+  adaptive_struct.total_syncs_called++;
   //CkPrintf("At PE %d Total contribution for iteration %d is %lf total objs %d\n", CkMyPe(), iteration,
   //total_contrib_vec[iteration], getLBDB()->ObjDataCount());
 
@@ -587,25 +600,37 @@ bool LBDatabase::AddLoad(int iteration, double load) {
     max_load_vec[iteration] = load;
   }
   if (total_contrib_vec[iteration] == getLBDB()->ObjDataCount()) {
-    double lb_data[4];
-    lb_data[0] = total_load_vec[iteration];
-    lb_data[1] = max_load_vec[iteration];
-    lb_data[2] = getLBDB()->ObjDataCount();
-    lb_data[3] = iteration;
-    //CkPrintf("[%d] sends total load %lf at iter %d\n", CkMyPe(), total_load_vec[iteration], adaptive_struct.lb_no_iterations);
+    double idle_time;
+    double tmp;
+    GetTime(&tmp, &tmp, &idle_time, &tmp, &tmp);
+    idle_time = idle_time * iteration * getLBDB()->ObjDataCount() /
+      adaptive_struct.total_syncs_called;
+
+    double lb_data[6];
+    lb_data[0] = iteration;
+    lb_data[1] = total_load_vec[iteration];
+    lb_data[2] = max_load_vec[iteration];
+    lb_data[3] = getLBDB()->ObjDataCount();
+    lb_data[4] = idle_time;
+    lb_data[5] = idle_time;
+
+    CkPrintf("[%d] sends total load %lf idle time %lf at iter %d\n", CkMyPe(),
+        total_load_vec[iteration], idle_time, adaptive_struct.lb_no_iterations);
 
     CkCallback cb(CkIndex_LBDatabase::ReceiveMinStats((CkReductionMsg*)NULL), thisProxy[0]);
-    contribute(4*sizeof(double), lb_data, lbDataCollectionType, cb);
+    contribute(6*sizeof(double), lb_data, lbDataCollectionType, cb);
   }
   return true;
 }
 
 void LBDatabase::ReceiveMinStats(CkReductionMsg *msg) {
   double* load = (double *) msg->getData();
-  double max = load[1];
-  double avg = load[0]/load[2];
-  int iteration_n = load[3];
-  CkPrintf("** [%d] Iteration Total load : %lf Avg load: %lf Max load: %lf for %lf procs\n",iteration_n, load[0], load[0]/load[2], load[1], load[2]);
+  double max = load[2];
+  double avg = load[1]/load[3];
+  double max_idle = load[5];
+  double avg_idle = load[4]/load[3];
+  int iteration_n = load[0];
+  CkPrintf("** [%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[3]);
   delete msg;
  
   // Store the data for this iteration
@@ -614,6 +639,8 @@ void LBDatabase::ReceiveMinStats(CkReductionMsg *msg) {
   data.iteration = adaptive_struct.lb_no_iterations;
   data.max_load = max;
   data.avg_load = avg;
+  data.max_idle_time = max_idle;
+  data.idle_time = avg_idle;
   adaptive_lbdb.history_data.push_back(data);
 
   // If lb period inform is in progress, dont inform again
@@ -628,8 +655,8 @@ void LBDatabase::ReceiveMinStats(CkReductionMsg *msg) {
   // If the max/avg ratio is greater than the threshold and also this is not the
   // step immediately after load balancing, carry out load balancing
   //if (max/avg >= 1.1 && adaptive_lbdb.history_data.size() > 4) {
-  if (max/avg >= 1.5 && adaptive_lbdb.history_data.size() > 4) {
-    CkPrintf("Carry out load balancing step at iter max/avg(%lf) > 1.1\n", max/avg);
+  if ((avg_idle >= 0.1*avg || max/avg >= 1.5) && adaptive_lbdb.history_data.size() > 4) {
+    CkPrintf("Carry out load balancing step at iter max/avg(%lf) and avg_idle/avg_load (%lf)\n", max/avg, avg_idle/avg);
 //    if (!adaptive_struct.lb_period_informed) {
 //      // Just for testing
 //      adaptive_struct.lb_calculated_period = 40;
@@ -698,33 +725,37 @@ bool LBDatabase::generatePlan(int& period) {
   // If we can attain perfect balance, then the new load is close to the
   // average. Hence we pass 1, else pass in some other value which would be the
   // new max_load after load balancing.
-  int refine_period, scratch_period;
-  bool obtained_refine, obtained_scratch;
-  obtained_refine = getPeriodForStrategy(1, 1, refine_period);
-  obtained_scratch = getPeriodForStrategy(1, 1, scratch_period);
-
-  if (obtained_refine) {
-    if (!obtained_scratch) {
-      period = refine_period;
-      adaptive_struct.isRefine = true;
-      return true;
-    }
-    if (scratch_period < 1.1*refine_period) {
-      adaptive_struct.isRefine = false;
-      period = scratch_period;
-      return true;
-    }
-    period = refine_period;
-    adaptive_struct.isRefine = true;
-    return true;
-  }
 
-  if (obtained_scratch) {
-    period = scratch_period;
-    adaptive_struct.isRefine = false;
-    return true;
-  }
-  return false;
+
+  return getPeriodForStrategy(1, 1, period);
+
+//  int refine_period, scratch_period;
+//  bool obtained_refine, obtained_scratch;
+//  obtained_refine = getPeriodForStrategy(1, 1, refine_period);
+//  obtained_scratch = getPeriodForStrategy(1, 1, scratch_period);
+//
+//  if (obtained_refine) {
+//    if (!obtained_scratch) {
+//      period = refine_period;
+//      adaptive_struct.isRefine = true;
+//      return true;
+//    }
+//    if (scratch_period < 1.1*refine_period) {
+//      adaptive_struct.isRefine = false;
+//      period = scratch_period;
+//      return true;
+//    }
+//    period = refine_period;
+//    adaptive_struct.isRefine = true;
+//    return true;
+//  }
+//
+//  if (obtained_scratch) {
+//    period = scratch_period;
+//    adaptive_struct.isRefine = false;
+//    return true;
+//  }
+//  return false;
 }
 
 bool LBDatabase::getPeriodForStrategy(double new_load_percent, double overhead_percent, int& period) {
index cafc44245cd8232d561149caa0e033ca6cfa0f9b..0a1cd90c9726179b35fac0e70f4403c733c1610e 100644 (file)
@@ -369,6 +369,17 @@ public:
   int getPredictedLBPeriod();
 
   bool isStrategyRefine();
+  void UpdateAfterLBData(int is_lb_refine, double lb_max, double lb_avg) {
+    is_prev_lb_refine = is_lb_refine;
+    after_lb_avg = lb_avg;
+    after_lb_max = lb_max;
+  }
+
+  void GetPrevLBData(int& is_lb_refine, double& lb_max, double& lb_avg) {
+    is_lb_refine = is_prev_lb_refine;
+    lb_max = after_lb_max;
+    lb_avg = after_lb_avg;
+  }
 
 private:
   //CProxy_LBDatabase thisProxy;
@@ -381,8 +392,14 @@ private:
   std::vector<double> max_load_vec;
   std::vector<double> total_load_vec;
   std::vector<double> total_contrib_vec;
+  std::vector<int> total_msg_vec;
+  std::vector<int> total_bytes_vec;
   int max_iteration;
 
+  double after_lb_max;
+  double after_lb_avg;
+  int is_prev_lb_refine;
+
 public:
   BaseLB** getLoadBalancers() {return loadbalancers.getVec();}
   int getNLoadBalancers() {return nloadbalancers;}
index eb57e86a47193e9d156ea5b800b450a9929e85f6..8caca2fffee42d2fd45d0ec0a1523588882cbe24 100644 (file)
 
 #include "MetisLB.h"
 #include "ckgraph.h"
-#include "metis.h"
+//#include "metis.h"
 
-/*extern "C" void METIS_PartGraphRecursive(int*, int*, int*, int*, int*,
+typedef int idxtype;
+
+extern "C" void METIS_PartGraphRecursive(int*, int*, int*, int*, int*,
                              int*, int*, int*, int*, int*, int*);
 extern "C" void METIS_PartGraphKway(int*, int*, int*, int*, int*,
                               int*, int*, int*, int*, int*, int*);
@@ -31,7 +33,7 @@ extern "C" void METIS_mCPartGraphRecursive(int*, int*, int*, int*, int*, int*,
                              int*, int*, int*, int*, int*, int*);
 extern "C" void METIS_mCPartGraphKway(int*, int*, int*, int*, int*, int*,
                               int*, int*, int*, int*, int*, int*, int*);
-*/
+
 
 CreateLBFunc_Def(MetisLB, "Use Metis(tm) to partition object graph")
 
@@ -170,6 +172,9 @@ void MetisLB::work(LDStats* stats)
     if(pemap[i] != ogr->vertices[i].getCurrentPe())
       ogr->vertices[i].setNewPe(pemap[i]);
   }
+  stats->is_prev_lb_refine = 3;
+  stats->after_lb_max = 0;
+  stats->after_lb_avg = 0;
 
   delete[] pemap;
 
index ca41be6667bd8a96875d9e45ee15e0ec1507c26c..9a1da5ded1e38ed2dd5e146b0feeb5c2a220b794 100644 (file)
@@ -12,7 +12,7 @@ CreateLBFunc_Def(RefineLB, "Move objects away from overloaded processor to reach
 RefineLB::RefineLB(const CkLBOptions &opt): CentralLB(opt)
 {
   lbname = (char *)"RefineLB";
-  if (CkMyPe() == 0)
+//  if (CkMyPe() == 0)
     CkPrintf("[%d] RefineLB created\n",CkMyPe());
 }
 
@@ -51,6 +51,12 @@ void RefineLB::work(LDStats* stats)
       }
   }
 
+  stats->is_prev_lb_refine = 1;
+  stats->after_lb_avg = refiner.computeAverageLoad();
+  stats->after_lb_max = refiner.computeMax();
+
+  CkPrintf("RefineLB> Max load %lf Avg load %lf\n", stats->after_lb_max, stats->after_lb_avg);
+
   // Free the refine buffers
   Refiner::FreeProcs(from_procs);
   Refiner::FreeProcs(to_procs);
index e8079a7489c43e881a42afd8e81c7e1a25984249..e78b0be560a353d3268fa091d15caa395afd9d95 100644 (file)
@@ -83,6 +83,11 @@ void  Refiner::deAssign(computeInfo *c, processorInfo *p)
    p->load = p->computeLoad + p->backgroundLoad;
 }
 
+double Refiner::computeAverageLoad() {
+  computeAverage();
+  return averageLoad;
+}
+
 void Refiner::computeAverage()
 {
   int i;
index 388a0632bc3445fd5927d86018e9252db22629ea..7cf23762e0efaec04b82e1a50a00380916885744 100644 (file)
@@ -21,6 +21,9 @@ public:
   static void FreeProcs(int* bufs);
   void Refine(int count, BaseLB::LDStats* stats, int* cur_p, int* new_p);
 
+  double computeAverageLoad();
+  double computeMax();
+
 protected:
   void create(int count, BaseLB::LDStats* stats, int* cur_p);
   virtual int refine();
@@ -29,7 +32,6 @@ protected:
   void assign(computeInfo *c, processorInfo *p);
   void deAssign(computeInfo *c, processorInfo *pRec);
   virtual void computeAverage();
-  double computeMax();
   int isHeavy(processorInfo *p);
   int isLight(processorInfo *p);
   void removeComputes();