ck-ldb: the API for the virtual work function changed
authorAbhinav S Bhatele <bhatele@illinois.edu>
Sun, 24 Oct 2010 00:11:31 +0000 (19:11 -0500)
committerAbhinav S Bhatele <bhatele@illinois.edu>
Sat, 6 Nov 2010 22:50:14 +0000 (17:50 -0500)
the argument 'int count' is no longer needed. It is already
available through stats->count. megatest and lb_test still work.

25 files changed:
src/ck-ldb/ComboCentLB.C
src/ck-ldb/CommLB.C
src/ck-ldb/CommLB.h
src/ck-ldb/DummyLB.h
src/ck-ldb/GraphPartLB.C
src/ck-ldb/GraphPartLB.h
src/ck-ldb/GreedyAgentLB.C
src/ck-ldb/GreedyAgentLB.h
src/ck-ldb/GreedyLB.C
src/ck-ldb/MetisLB.C
src/ck-ldb/MetisLB.h
src/ck-ldb/OrbLB.C
src/ck-ldb/OrbLB.h
src/ck-ldb/PhasebyArrayLB.C
src/ck-ldb/PhasebyArrayLB.h
src/ck-ldb/RandCentLB.C
src/ck-ldb/RandCentLB.h
src/ck-ldb/RecBisectBfLB.C
src/ck-ldb/RecBisectBfLB.h
src/ck-ldb/RefineCommLB.C
src/ck-ldb/RefineCommLB.h
src/ck-ldb/RefineKLB.C
src/ck-ldb/RefineKLB.h
src/ck-ldb/RefineLB.C
src/ck-ldb/RefineLB.h

index 3bcf4b9298454503a410260fba086c0e60d5d9f3..a6eed13f346bafda09739dc46d73d7a6c3af39ce 100644 (file)
@@ -47,7 +47,7 @@ ComboCentLB::ComboCentLB(const CkLBOptions &opt): CentralLB(opt)
   }
 }
 
-void ComboCentLB::work(BaseLB::LDStats* stats)
+void ComboCentLB::work(LDStats* stats)
 {
   int nlbs = clbs.length();
   int n_objs = stats->n_objs;
index f2cad5402c646dcf862bea405fdc10e76cb9b67c..74d1cda66d54b9d1e4d80dfb84482d6713ed2dbe 100644 (file)
@@ -135,7 +135,7 @@ void init(alloc_struct **a, graph * object_graph, int l, int b){
   }
 }
 
-void CommLB::work(BaseLB::LDStats* stats, int count)
+void CommLB::work(LDStats* stats)
 {
   int pe,obj,com;
   double mean_load =0.0;
@@ -144,15 +144,15 @@ void CommLB::work(BaseLB::LDStats* stats, int count)
   //  CkPrintf("[%d] CommLB strategy\n",CkMyPe());
 
   nobj = stats->n_objs;
-  npe = count;
+  npe = stats->count;
 
   stats->makeCommHash();
 
-  alloc_array = new alloc_struct *[count+1];
+  alloc_array = new alloc_struct *[npe + 1];
 
   object_graph = new graph[nobj];
   
-  for(pe=0;pe <= count;pe++)
+  for(pe = 0; pe <= npe; pe++)
     alloc_array[pe] = new alloc_struct[nobj +1];
 
   init(alloc_array,object_graph,npe,nobj);
@@ -169,7 +169,7 @@ void CommLB::work(BaseLB::LDStats* stats, int count)
       maxh.insert(x);
       mean_load += objData.wallTime;
   }
-  mean_load /= count;
+  mean_load /= npe;
 
   int xcoord=0,ycoord=0;
 
@@ -220,10 +220,10 @@ void CommLB::work(BaseLB::LDStats* stats, int count)
       continue;
     }
 
-    for(pe =0; pe < count; pe++)
+    for(pe =0; pe < npe; pe++)
       if((alloc_array[pe][nobj].load <= mean_load)||(id >= UPPER_FACTOR*nobj))
        break;
-    CmiAssert(pe < count);
+    CmiAssert(pe < npe);
 
     temp_cost = compute_cost(maxid,pe,id,out_msg,out_byte);
     min_cost = temp_cost;
@@ -231,7 +231,7 @@ void CommLB::work(BaseLB::LDStats* stats, int count)
     min_msg = out_msg;
     min_byte = out_byte;
     pe++;
-    for(; pe < count;pe++){
+    for(; pe < npe; pe++) {
       if((alloc_array[pe][nobj].load > mean_load) && (id < UPPER_FACTOR*nobj))
        continue;
       temp_cost = compute_cost(maxid,pe,id,out_msg,out_byte);
index 81715e0238652e6d8865bf46ba59b9475f492a15..a75b1fb800add9647497959dcd9ab8d3856c1850 100644 (file)
@@ -31,7 +31,7 @@ public:
   CommLB(CkMigrateMessage *m):CentralLB(m) {}
 private:
   CmiBool QueryBalanceNow(int step);
-  void work(BaseLB::LDStats* stats, int count);
+  void work(LDStats* stats);
   void alloc(int pe, int id, double load, int nmsg, int nbyte);
   double compute_cost(int id, int pe, int n_alloc, int &out_msg, int &out_byte); 
   void add_graph(int x, int y, int data, int nmsg);
index 94eda6a129e3263d6e0f60c202eb47be0828e75f..7e82d7702ecfe8fd5358cb10f5a3ecee36f08910 100644 (file)
@@ -24,7 +24,7 @@ public:
   DummyLB(CkMigrateMessage *m):CentralLB(m) {}
 private:
   CmiBool QueryBalanceNow(int step);
-  void work(BaseLB::LDStats* stats, int count) {}
+  void work(LDStats* stats) {}
 };
 
 #endif /* _DUMMYLB_H_ */
index beaec1fb153c18292efbd93a0456ce061bebff16..c580d66bc245a75952d846051acc3e6bfb83f21b 100644 (file)
@@ -24,7 +24,7 @@ CmiBool GraphPartLB::QueryBalanceNow(int _step) {
   return CmiTrue;
 }
 
-void GraphPartLB::work(BaseLB::LDStats *stats, int count) {
+void GraphPartLB::work(LDStats *stats) {
 
 }
 
index 7efbbb7d56adf1439b2ef36d7646bf159f915043..b707c454436491b23f97c6a3d1b351c1338cafc5 100644 (file)
@@ -23,7 +23,7 @@ class GraphPartLB : public CentralLB {
     GraphPartLB(const CkLBOptions &opt);
     GraphPartLB(CkMigrateMessage *m) : CentralLB (m) { };
 
-    void work(BaseLB::LDStats *stats, int count);
+    void work(LDStats *stats);
     void pup(PUP::er &p) { CentralLB::pup(p); }
 
   private:
index 9675ec3dc5febcc42bc922d9991d400db0d3b21c..fcea08b070f93e223dfc7aa3dda3fdc6338ad61d 100644 (file)
@@ -192,12 +192,14 @@ GreedyAgentLB::BuildCpuArray(CentralLB::LDStats* stats,
   return data;
 }
 
-void GreedyAgentLB::work(CentralLB::LDStats* stats, int count)
+void GreedyAgentLB::work(LDStats* stats)
 {
   int  i, obj, heapSize, objCount;
-  int *pemap = new int [count];
-  HeapData *cpuData = BuildCpuArray(stats, count, &heapSize);
-  HeapData *objData = BuildObjectArray(stats, count, &objCount);
+  int n_pes = stats->count;
+
+  int *pemap = new int [n_pes];
+  HeapData *cpuData = BuildCpuArray(stats, n_pes, &heapSize);
+  HeapData *objData = BuildObjectArray(stats, n_pes, &objCount);
        
        int max_neighbors=0;
  
@@ -205,8 +207,8 @@ void GreedyAgentLB::work(CentralLB::LDStats* stats, int count)
        //CkPrintf("\nnum of procs:%d\n",simprocs);
        
 
-       CkPrintf("num procs in stats:%d\n",count);
-       topologyAgent = new TopologyAgent(stats,count);
+       CkPrintf("num procs in stats:%d\n", n_pes);
+       topologyAgent = new TopologyAgent(stats, n_pes);
 
        max_neighbors = topologyAgent->topo->max_neighbors();
        
@@ -214,11 +216,11 @@ void GreedyAgentLB::work(CentralLB::LDStats* stats, int count)
 
   heapSize--;
        
-       HeapData *minCpu = new HeapData[count];
+       HeapData *minCpu = new HeapData[n_pes];
        double minLoad = 0.0;
        double loadThreshold = 0.0;
-       int *trialpes = new int[count+1];
-       int *trialmap = new int[count];
+       int *trialpes = new int[n_pes + 1];
+       int *trialmap = new int[n_pes];
        int *existing_map = new int[objCount];
        Agent::Elem *preferList;
        
@@ -237,7 +239,7 @@ void GreedyAgentLB::work(CentralLB::LDStats* stats, int count)
     //int extractIndex=0;
                
                        CkPrintf("obj count:%d\n",obj);
-               for(i=0;i<=count;i++)
+               for(i = 0; i <= n_pes; i++)
                        trialpes[i]=-1;
 
                if(extractIndex==0)
index df1d65852168912831d08e57b95149045fec4988..12daf153077fba617fb2f43db71a7c872b0358dc 100644 (file)
@@ -29,7 +29,7 @@ public:
 
   GreedyAgentLB(const CkLBOptions &);
   GreedyAgentLB(CkMigrateMessage *m):CentralLB(m) { lbname = "GreedyAgentLB"; }
-  void work(LDStats* stats,int count);
+  void work(LDStats* stats);
 private:
        TopologyAgent                           *topologyAgent;
        enum           HeapCmp {GT = '>', LT = '<'};
index 114784d2881c654afd5e155fe5eb47b66d2ca2a2..0790bc4efec06a80c398dbf608b53ebb5ddb5ddd 100644 (file)
@@ -184,7 +184,7 @@ GreedyLB::BuildCpuArray(BaseLB::LDStats* stats,
   return data;
 }
 
-void GreedyLB::work(BaseLB::LDStats* stats, int count)
+void GreedyLB::work(LDStats* stats, int count)
 {
   int  obj, heapSize, objCount;
   HeapData *cpuData = BuildCpuArray(stats, count, &heapSize);
index da49b1a866d073bc1c362a5883b520abbc8878cb..b2178401a86bb2ed26fd55c254a884d6234377ba 100644 (file)
@@ -84,7 +84,7 @@ extern "C" void METIS_mCPartGraphKway(int*, int*, int*, int*, int*, int*,
                                     int*, int*, int*, int*, int*,
                                     int*, int*);
 
-void MetisLB::work(BaseLB::LDStats* stats, int count)
+void MetisLB::work(LDStats* stats)
 {
   if (_lb_args.debug() >= 2) {
     CkPrintf("[%d] In MetisLB Strategy...\n", CkMyPe());
@@ -94,10 +94,11 @@ void MetisLB::work(BaseLB::LDStats* stats, int count)
 
   stats->makeCommHash();
 
-  removeNonMigratable(stats, count);
-
+  int n_pes = stats->count;
   int numobjs = stats->n_objs;
 
+  removeNonMigratable(stats, n_pes);
+
   // allocate space for the computing data
   double *objtime = new double[numobjs];
   int *objwt = new int[numobjs];
@@ -199,7 +200,7 @@ void MetisLB::work(BaseLB::LDStats* stats, int count)
 
   if (_lb_args.debug() >= 2) {
   CkPrintf("Pre-LDB Statistics step %d\n", step());
-  printStats(count, numobjs, objtime, comm, origmap);
+  printStats(n_pes, numobjs, objtime, comm, origmap);
   }
 
   int wgtflag = 3; // Weights both on vertices and edges
@@ -210,10 +211,10 @@ void MetisLB::work(BaseLB::LDStats* stats, int count)
   int *newmap;
   int sameMapFlag = 1;
 
-  if (count < 1) {
+  if (n_pes < 1) {
     CkPrintf("error: Number of Pe less than 1!");
   }
-  else if (count == 1) {
+  else if (n_pes == 1) {
     newmap = origmap;
     sameMapFlag = 1;
   }
@@ -236,19 +237,19 @@ void MetisLB::work(BaseLB::LDStats* stats, int count)
     So right now I just comment that function out and always use the other one.
 */
 /*
-      if (count > 8)
+      if (n_pes > 8)
        METIS_PartGraphKway(&numobjs, xadj, adjncy, objwt, edgewt, 
-                           &wgtflag, &numflag, &count, options, 
+                           &wgtflag, &numflag, &n_pes, options,
                            &edgecut, newmap);
       else
        METIS_PartGraphRecursive(&numobjs, xadj, adjncy, objwt, edgewt, 
-                                &wgtflag, &numflag, &count, options, 
+                                &wgtflag, &numflag, &n_pes, options,
                                 &edgecut, newmap);
 */
       if (_lb_args.debug() >= 1)
         CkPrintf("[%d] calling METIS_PartGraphRecursive.\n", CkMyPe());
       METIS_PartGraphRecursive(&numobjs, xadj, adjncy, objwt, edgewt,
-                                 &wgtflag, &numflag, &count, options,
+                                 &wgtflag, &numflag, &n_pes, options,
                                  &edgecut, newmap);
       if (_lb_args.debug() >= 1)
         CkPrintf("[%d] after calling Metis functions.\n", CkMyPe());
@@ -256,28 +257,28 @@ void MetisLB::work(BaseLB::LDStats* stats, int count)
     else if (WEIGHTED == option) {
       CkPrintf("unepected\n");
       float maxtotal_walltime = stats->procs[0].total_walltime;
-      for (m=1; m<count; m++) {
+      for (m = 1; m < n_pes; m++) {
        if (maxtotal_walltime < stats->procs[m].total_walltime)
          maxtotal_walltime = stats->procs[m].total_walltime;
       }
       float totaltimeAllPe = 0.0;
-      for (m=0; m<count; m++) {
+      for (m = 0; m < n_pes; m++) {
        totaltimeAllPe += stats->procs[m].pe_speed * 
          (maxtotal_walltime-stats->procs[m].bg_walltime);
       }
       // set up the different weights
-      float *tpwgts = new float[count];
-      for (m=0; m<count; m++) {
+      float *tpwgts = new float[n_pes];
+      for (m = 0; m < n_pes; m++) {
        tpwgts[m] = stats->procs[m].pe_speed * 
          (maxtotal_walltime-stats->procs[m].bg_walltime) / totaltimeAllPe;
       }
-      if (count > 8)
+      if (n_pes > 8)
        METIS_WPartGraphKway(&numobjs, xadj, adjncy, objwt, edgewt, 
-                            &wgtflag, &numflag, &count, tpwgts, options, 
+                            &wgtflag, &numflag, &n_pes, tpwgts, options,
                             &edgecut, newmap);
       else
        METIS_WPartGraphRecursive(&numobjs, xadj, adjncy, objwt, edgewt, 
-                                 &wgtflag, &numflag, &count, tpwgts, options, 
+                                 &wgtflag, &numflag, &n_pes, tpwgts, options,
                                  &edgecut, newmap);
       delete[] tpwgts;
     }
@@ -288,7 +289,7 @@ void MetisLB::work(BaseLB::LDStats* stats, int count)
   }
   if (_lb_args.debug() >= 2) {
   CkPrintf("Post-LDB Statistics step %d\n", step());
-  printStats(count, numobjs, objtime, comm, newmap);
+  printStats(n_pes, numobjs, objtime, comm, newmap);
   }
 
   for(i=0;i<numobjs;i++)
@@ -319,8 +320,8 @@ void MetisLB::work(BaseLB::LDStats* stats, int count)
 
 /*
        int avg=0;
-       int *chkwt = new int[count];
-       for(i=0;i<count;i++)
+       int *chkwt = new int[n_pes];
+       for(i=0; i<n_pes; i++)
                chkwt[i]=0;
        //totalwt=0;
        for(i=0;i<numobjs;i++){
@@ -330,7 +331,7 @@ void MetisLB::work(BaseLB::LDStats* stats, int count)
        }
        
        
-       for(i=0;i<count;i++)
+       for(i=0; i<n_pes; i++)
                CkPrintf("%d -- %d\n",i,chkwt[i]);
 */
   delete[] origmap;
index 03ca8da5c355d2dffc4bfd7504669b0d06ae36ca..14d589e78d76e363dd44aaf99af88f5383d3af02 100644 (file)
@@ -25,7 +25,7 @@ public:
   MetisLB(CkMigrateMessage *m):CentralLB(m) { lbname = "MetisLB"; }
 private:
   CmiBool QueryBalanceNow(int step) { return CmiTrue; }
-  void work(BaseLB::LDStats* stats, int count);
+  void work(LDStats* stats);
 };
 
 #define WEIGHTED 1
index 6537de09c617b2bc796e6219be5c0341b81a857d..d1bc324e516459137c808a3d29ba7fc401692bf3 100644 (file)
@@ -304,14 +304,14 @@ void OrbLB::mapPartitionsToNodes()
 
 }
 
-void OrbLB::work(BaseLB::LDStats* stats, int count)
+void OrbLB::work(LDStats* stats)
 {
 #if CMK_LBDB_ON
   int i,j;
 
   statsData = stats;
 
-  P = count;
+  P = stats->count;
 
   // calculate total number of migratable objects
   nObjs = stats->n_migrateobjs;
index 79a494ac5259a03904de78c65d1a7fd2fd3816e8..b6e119ac545bde829c8594080987dcc5f18538c3 100644 (file)
@@ -78,7 +78,7 @@ public:
   OrbLB(const CkLBOptions &);
   OrbLB(CkMigrateMessage *m):CentralLB(m) { lbname = "OrbLB"; }
 
-  void work(BaseLB::LDStats* stats, int count);
+  void work(LDStats* stats);
   CmiBool QueryBalanceNow(int step);
 };
 
index d2f4f9c02106e089223de19ba5ef2299132ebc5b..7541971b455b4b7b3978284d4394d8371bd5a6c6 100644 (file)
@@ -91,7 +91,7 @@ void PhasebyArrayLB::updateStats(BaseLB::LDStats *stats,BaseLB::LDStats *tempSta
        
 }
 
-void PhasebyArrayLB::work(BaseLB::LDStats *stats){
+void PhasebyArrayLB::work(LDStats *stats){
        //It is assumed that statically placed arrays are set non-migratable in the application
        tempStats = new BaseLB::LDStats;
 
index 7fc9ed466ca01a9975d8e4755300ecec86c5b781..ebacfc23a8a1bd81db0992fcb8158c61d11a81b7 100644 (file)
@@ -31,7 +31,7 @@ private:
        CmiBool QueryBalanceNow(int step);
        void copyStats(BaseLB::LDStats *stats,BaseLB::LDStats *tempStats);
        void updateStats(BaseLB::LDStats *stats,BaseLB::LDStats *tempStats);
-       void work(BaseLB::LDStats* stats);
+       void work(LDStats* stats);
 };
 
 #endif /* _PHASEBYARRAYLB_H_ */
index 7dd4d99f136049adbdc64e1461455f63b6e6155f..70526ddfd9f3c425db5485f436c9632ede812c0d 100644 (file)
@@ -41,22 +41,23 @@ inline int chooseProc(int count)
   return (int)(CrnDrand()*(count-1) + 0.5);
 }
 
-void RandCentLB::work(BaseLB::LDStats* stats, int count)
+void RandCentLB::work(LDStats* stats)
 {
   if (_lb_args.debug()) CkPrintf("Calling RandCentLB strategy\n",CkMyPe());
 
-  int proc;
-  for (proc=0; proc<count; proc++) {
+  int proc, n_pes = stats->count;
+
+  for (proc=0; proc<n_pes; proc++) {
     if (stats->procs[proc].available) break;
   }
-  if (proc == count) CmiAbort("RandCentLB> no available processor!");
+  if (proc == n_pes) CmiAbort("RandCentLB> no available processor!");
 
   int nmigrated = 0;
   for(int obj=0; obj < stats->n_objs; obj++) {
       LDObjData &odata = stats->objData[obj];
       if (odata.migratable) {
-       int dest = chooseProc(count);
-       while (!stats->procs[dest].available) dest = chooseProc(count);
+       int dest = chooseProc(n_pes);
+       while (!stats->procs[dest].available) dest = chooseProc(n_pes);
        if (dest != stats->from_proc[obj]) {
           if (_lb_args.debug() >= 2)
             CkPrintf("[%d] Obj %d migrating from %d to %d\n", CkMyPe(),obj,stats->from_proc[obj],dest);
index 9c751dbce03fd721fce14732482f3875336b3b77..f966d2b7eb4c412b5f7f65f2e7c40ccd21ba0028 100644 (file)
@@ -24,7 +24,7 @@ public:
   RandCentLB(CkMigrateMessage *m):CentralLB(m) { lbname = "RandCentLB"; }
   void pup(PUP::er &p){ CentralLB::pup(p); }
 
-  void work(BaseLB::LDStats* stats, int count);
+  void work(LDStats* stats);
 private:
   CmiBool QueryBalanceNow(int step);
 };
index b574e12f9ab9c62df9088ee71daf1e9a9cf66064..798a743820a5100bc04bb55e81ffb06162effe88 100644 (file)
@@ -61,10 +61,11 @@ CmiBool RecBisectBfLB::QueryBalanceNow(int _step)
   return CmiTrue;
 }
 
-void RecBisectBfLB::work(BaseLB::LDStats* stats, 
-                                      int numPartitions)
+void RecBisectBfLB::work(LDStats* stats)
 {
   int i;
+  int numPartitions = stats->count;
+
   PartitionList *partitions;
 
   CkPrintf("[%d] RecBisectBfLB strategy\n",CkMyPe());
index 7526e514cc8c779e5fcce53ad769cc28250a320f..2a216a605fb3ef5e40522b2a3e4ffd8438454187 100644 (file)
@@ -45,7 +45,7 @@ public:
   RecBisectBfLB(CkMigrateMessage *m):CentralLB(m) {}
 private:
   CmiBool QueryBalanceNow(int step);
-  void work(BaseLB::LDStats* stats, int count);
+  void work(LDStats* stats);
 
   Graph * convertGraph(ObjGraph *og);
   
index d04630a3e899a8acfabe0515a6e9758d07529176..499a2ef4e890ff6665cc1c529ae258a75e31db04 100644 (file)
@@ -30,27 +30,29 @@ CmiBool RefineCommLB::QueryBalanceNow(int _step)
   return CmiTrue;
 }
 
-void RefineCommLB::work(BaseLB::LDStats* stats, int count)
+void RefineCommLB::work(LDStats* stats)
 {
 #if CMK_LBDB_ON
   int obj;
+  int n_pes = stats->count;
+
   //  CkPrintf("[%d] RefineLB strategy\n",CkMyPe());
 
-  // RemoveNonMigratable(stats, count);
+  // RemoveNonMigratable(stats, n_pes);
 
   // get original object mapping
-  int* from_procs = RefinerComm::AllocProcs(count, stats);
+  int* from_procs = RefinerComm::AllocProcs(n_pes, stats);
   for(obj=0;obj<stats->n_objs;obj++)  {
     int pe = stats->from_proc[obj];
     from_procs[obj] = pe;
   }
 
   // Get a new buffer to refine into
-  int* to_procs = RefinerComm::AllocProcs(count,stats);
+  int* to_procs = RefinerComm::AllocProcs(n_pes, stats);
 
   RefinerComm refiner(1.003);  // overload tolerance=1.05
 
-  refiner.Refine(count,stats,from_procs,to_procs);
+  refiner.Refine(n_pes, stats, from_procs, to_procs);
 
   // Save output
   for(obj=0;obj<stats->n_objs;obj++) {
index 0cd67906c10aa50f21096512cdd0c698b0e2dda8..1520eee965d3d3dbe0babaa8ca95099ceef49bff 100644 (file)
@@ -33,7 +33,7 @@ public:
   RefineCommLB(CkMigrateMessage *m):RefineLB(m) {}
 private:
   CmiBool QueryBalanceNow(int step);
-  void work(BaseLB::LDStats* stats, int count);
+  void work(LDStats* stats);
 
 protected:
 };
index 8fd2318f372bb9958dd75254dcaf96291efd50cf..2c4acb4fdba0e586e86a3f3a4cf7295e26cf83ca 100644 (file)
@@ -28,28 +28,30 @@ RefineKLB::RefineKLB(const CkLBOptions &opt): CentralLB(opt)
     CkPrintf("[%d] RefineKLB created\n",CkMyPe());
 }
 
-void RefineKLB::work(BaseLB::LDStats* stats, int count)
+void RefineKLB::work(LDStats* stats)
 {
   int obj;
+  int n_pes = stats->count;
+
   //  CkPrintf("[%d] RefineKLB strategy\n",CkMyPe());
 
-  // RemoveNonMigratable(stats, count);
+  // RemoveNonMigratable(stats, n_pes);
 
   // get original object mapping
-  int* from_procs = RefinerApprox::AllocProcs(count, stats);
+  int* from_procs = RefinerApprox::AllocProcs(n_pes, stats);
   for(obj=0;obj<stats->n_objs;obj++)  {
     int pe = stats->from_proc[obj];
     from_procs[obj] = pe;
   }
 
   // Get a new buffer to refine into
-  int* to_procs = RefinerApprox::AllocProcs(count,stats);
+  int* to_procs = RefinerApprox::AllocProcs(n_pes, stats);
 
   RefinerApprox refiner(1.003);  // overload tolerance=1.003
 
   if(_lb_args.percentMovesAllowed()>0 && _USE_APPROX_ALGO_)
   {
-    refiner.Refine(count,stats,from_procs,to_procs,_lb_args.percentMovesAllowed());
+    refiner.Refine(n_pes, stats, from_procs, to_procs, _lb_args.percentMovesAllowed());
   }
   else
   {
@@ -79,7 +81,7 @@ void RefineKLB::work(BaseLB::LDStats* stats, int count)
   if(availableMoves>0 && _USE_RESIDUAL_MOVES_)
   {
     int *to_procs2=new int[stats->n_objs];
-    performGreedyMoves(count,stats,to_procs,to_procs2,availableMoves);
+    performGreedyMoves(n_pes, stats, to_procs, to_procs2, availableMoves);
 
     int nmoves2=0;
     for(obj=0;obj<stats->n_objs;obj++)
index d3d28c4c1d1aaa01cc73d179424d20bbd6a7633e..237538ed0a451558dd9ba626aedd4ac9a792fd7d 100644 (file)
@@ -42,7 +42,7 @@ protected:
 public:
   RefineKLB(const CkLBOptions &);
   RefineKLB(CkMigrateMessage *m):CentralLB(m) { lbname = (char *)"RefineKLB"; }
-  void work(BaseLB::LDStats* stats, int count);
+  void work(LDStats* stats);
 private:
   CmiBool QueryBalanceNow(int step) { return CmiTrue; }
 
index ac3efcb2341f16ef5ca6f5d039b307ebb1afe55a..2d9eb54f5488ac1d56088ed2ebaf3e2291f98488 100644 (file)
@@ -25,26 +25,28 @@ RefineLB::RefineLB(const CkLBOptions &opt): CentralLB(opt)
     CkPrintf("[%d] RefineLB created\n",CkMyPe());
 }
 
-void RefineLB::work(BaseLB::LDStats* stats, int count)
+void RefineLB::work(LDStats* stats)
 {
   int obj;
+  int n_pes = stats->count;
+
   //  CkPrintf("[%d] RefineLB strategy\n",CkMyPe());
 
-  // RemoveNonMigratable(stats, count);
+  // RemoveNonMigratable(stats, n_pes);
 
   // get original object mapping
-  int* from_procs = Refiner::AllocProcs(count, stats);
+  int* from_procs = Refiner::AllocProcs(n_pes, stats);
   for(obj=0;obj<stats->n_objs;obj++)  {
     int pe = stats->from_proc[obj];
     from_procs[obj] = pe;
   }
 
   // Get a new buffer to refine into
-  int* to_procs = Refiner::AllocProcs(count,stats);
+  int* to_procs = Refiner::AllocProcs(n_pes, stats);
 
   Refiner refiner(1.003);  // overload tolerance=1.05
 
-  refiner.Refine(count,stats,from_procs,to_procs);
+  refiner.Refine(n_pes, stats, from_procs, to_procs);
 
   // Save output
   for(obj=0;obj<stats->n_objs;obj++) {
index 2923300fbd255772943d991d45730ec9e04cb742..84cd4c72ffe0aa509b616e55f97583b46f664531 100644 (file)
@@ -41,7 +41,7 @@ protected:
 public:
   RefineLB(const CkLBOptions &);
   RefineLB(CkMigrateMessage *m):CentralLB(m) { lbname = (char *)"RefineLB"; }
-  void work(BaseLB::LDStats* stats, int count);
+  void work(LDStats* stats);
 private:
   CmiBool QueryBalanceNow(int step) { return CmiTrue; }