many changes:
authorGengbin Zheng <gzheng@illinois.edu>
Fri, 1 Nov 2002 04:32:41 +0000 (04:32 +0000)
committerGengbin Zheng <gzheng@illinois.edu>
Fri, 1 Nov 2002 04:32:41 +0000 (04:32 +0000)
1. reorgnized Rahul's sequential load balancing code;
2. migrate message now return predicted load to each processor;
3. remove a lot of redundent data in those LB handles.
4. add printing load balancing name during load balancing;

24 files changed:
src/ck-ldb/BaseLB.C
src/ck-ldb/BaseLB.h
src/ck-ldb/CentralLB.C
src/ck-ldb/CentralLB.h
src/ck-ldb/Comm1LB.C
src/ck-ldb/CommLB.C
src/ck-ldb/GreedyRefLB.C
src/ck-ldb/HeapCentLB.C
src/ck-ldb/LBDBManager.C
src/ck-ldb/LBDatabase.C
src/ck-ldb/LBObj.C
src/ck-ldb/LBObj.h
src/ck-ldb/MetisLB.C
src/ck-ldb/NborBaseLB.C
src/ck-ldb/NeighborLB.C
src/ck-ldb/NullLB.h
src/ck-ldb/RandCentLB.C
src/ck-ldb/RandRefLB.C
src/ck-ldb/RecBisectBfLB.C
src/ck-ldb/RefineLB.C
src/ck-ldb/SimResults.C
src/ck-ldb/SimResults.h
src/ck-ldb/WSLB.C
src/ck-ldb/lbdb.h

index 49923f411c993a5957d35c416c67452df53b80bf..a9c79c8851f587c07a07ed61b69f6b1474c232c9 100644 (file)
@@ -20,6 +20,7 @@ BaseLB::BaseLB() {
 //CmiPrintf("[%d] BaseLB created!\n", CkMyPe());
   if (CkpvAccess(numLoadBalancers) - CkpvAccess(hasNullLB) > 1)
     CmiAbort("Error: try to create more than one load balancer strategies!");
+  lbname = "Unknown";
 }
 
 void BaseLB::unregister() {
@@ -36,14 +37,14 @@ void BaseLB::unregister() {}
 void* LBMigrateMsg::alloc(int msgnum, size_t size, int* array, int priobits)
 {
   int totalsize = size + array[0] * sizeof(MigrateInfo) 
-    + CkNumPes() * sizeof(char);
+    + CkNumPes() * (sizeof(char)+sizeof(double));
 
   LBMigrateMsg* ret =
     (LBMigrateMsg*)(CkAllocMsg(msgnum,totalsize,priobits));
 
   ret->moves = (MigrateInfo*) ((char*)(ret)+ size);
-
   ret->avail_vector = (char *)(ret->moves + array[0]);
+  ret->expectedLoad = (double *)(ret->avail_vector + CkNumPes()*sizeof(char));
   return (void*)(ret);
 }
 
@@ -55,6 +56,9 @@ void* LBMigrateMsg::pack(LBMigrateMsg* m)
   m->avail_vector =(char*)(m->avail_vector
       - (char*)(&m->avail_vector));
 
+  m->expectedLoad = (double*)((char *)m->expectedLoad
+      - (char*)(&m->expectedLoad));
+
   return (void*)(m);
 }
 
@@ -70,6 +74,10 @@ LBMigrateMsg* LBMigrateMsg::unpack(void *m)
     (char*)((char*)(&ret_val->avail_vector)
                            +(size_t)(ret_val->avail_vector));
 
+  ret_val->expectedLoad =
+    (double*)((char*)(&ret_val->expectedLoad)
+                           +(size_t)(ret_val->expectedLoad));
+
   return ret_val;
 }
 
index 68d88ce3c494f1cc39819293c8617a26033fb2db..c21b274e5cd13398597b788db983e281323fe78f 100644 (file)
@@ -1,3 +1,10 @@
+/*****************************************************************************
+ * $Source$
+ * $Author$
+ * $Date$
+ * $Revision$
+ *****************************************************************************/
+
 /**
  \defgroup CkLdb  Charm++ Load Balancing Framework 
 */
 class BaseLB: public Group
 {
 protected:
+  char *lbname;
   LBDatabase *theLbdb;
   LDBarrierReceiver receiver;
+
+  struct LastLBInfo {
+    double expectedLoad;
+  };
+  LastLBInfo lastLBInfo;
 public:
   BaseLB() ;
   void unregister(); 
+  inline char *lbName() { return lbname; }
+  inline double expectedLoad() { return lastLBInfo.expectedLoad; }
 };
 
 /// migration decision for an obj.
@@ -42,12 +57,13 @@ public:
   char * avail_vector;
   int next_lb;
 
+  double * expectedLoad;
+
   // Other methods & data members
 
   static void* alloc(int msgnum, size_t size, int* array, int priobits);
   static void* pack(LBMigrateMsg* in);
   static LBMigrateMsg* unpack(void* in);
-  static void print(LBMigrateMsg* in);
 };
 
 #endif
index 0bd687f0441dd00da3633111d26b860030a0d378..4dc99f07c5b246ec766c744f202e30b87c48058d 100644 (file)
@@ -21,11 +21,11 @@ char ** avail_vector_address;
 int * lb_ptr;
 int load_balancer_created;
 
-// the default file in which the load balancing data will be dumped
-const char defaultDumpFileName[] = "lbdata.dat";
-
 #if CMK_LBDB_ON
 
+static void getPredictedLoad(CentralLB::LDStats* stats, int count, 
+                             LBMigrateMsg* msg, double *peLoads);
+
 void CreateCentralLB()
 {
   loadbalancer = CProxy_CentralLB::ckNew();
@@ -121,8 +121,8 @@ void CentralLB::ProcessAtSync()
 {
   if (CkMyPe() == cur_ld_balancer) {
     start_lb_time = CmiWallTimer();
-    CmiPrintf("Load balancing step %d starting at %f in %d\n",
-    step(),start_lb_time, cur_ld_balancer);
+    CmiPrintf("[%s] Load balancing step %d starting at %f in PE%d\n",
+    lbName(), step(),start_lb_time, cur_ld_balancer);
   }
   // Send stats
   const int osz = theLbdb->GetObjDataSz();
@@ -218,39 +218,10 @@ void CentralLB::ReceiveStats(CLBStatsMsg *m)
     for(proc = 0; proc < clients; proc++)
       statsDataList[proc].available = (CmiBool)avail_vector[proc];
 
-//    CkPrintf("Before Calling Strategy\n");
-
-       // if this is the step at which we need to dump the database
-       if(step() == CkpvAccess(dumpStep))
-       {
-               // here we are supposed to dump the database
-               writeStatsMsgs((CkpvAccess(dumpFile) != NULL) ? CkpvAccess(dumpFile) : defaultDumpFileName);
-               CmiPrintf("LBDump: Dumped the load balancing data.\n");
-               CkExit();
-               return;
-       }
-       else if(CkpvAccess(doSimulation))
-       {
-               // here we are supposed to read the data from the dump database
-               readStatsMsgs((CkpvAccess(dumpFile) != NULL) ? CkpvAccess(dumpFile) : defaultDumpFileName);
-
-               CLBSimResults simResults(stats_msg_count);
-
-               // now pass it to the strategy routine
-               LBMigrateMsg* migrateMsg = Strategy(statsDataList, stats_msg_count);
-
-               // now calculate the results of the load balancing simulation
-               FindSimResults(statsDataList, stats_msg_count, migrateMsg, &simResults);
-
-               // now we have the simulation data, so print it and exit
-               CmiPrintf("LBSim: Simulation of one load balancing step done.\n");
-               simResults.PrintSimulationResults();
-
-               delete migrateMsg;
+    // if this is the step at which we need to dump the database
+    simulation();
 
-               CkExit();
-               return;
-       }
+//    CkPrintf("Before Calling Strategy\n");
 
     LBMigrateMsg* migrateMsg = Strategy(statsDataList,clients);
 
@@ -261,6 +232,8 @@ void CentralLB::ReceiveStats(CLBStatsMsg *m)
        migrateMsg->avail_vector[proc] = avail_vector[proc];
     migrateMsg->next_lb = new_ld_balancer;
 
+    getPredictedLoad(statsDataList, clients, migrateMsg, migrateMsg->expectedLoad);
+
 //  CkPrintf("calling recv migration\n");
     thisProxy.ReceiveMigration(migrateMsg);
 
@@ -377,6 +350,8 @@ void CentralLB::ReceiveMigration(LBMigrateMsg *m)
     theLbdb->SetLBPeriod(theLbdb->GetLBPeriod()*2);
   }
 #endif
+
+  lastLBInfo.expectedLoad = m->expectedLoad[CkMyPe()];
   
   cur_ld_balancer = m->next_lb;
   if((CkMyPe() == cur_ld_balancer) && (cur_ld_balancer != 0)){
@@ -395,8 +370,8 @@ void CentralLB::MigrationDone(int balancing)
 {
   if (balancing && CkMyPe() == cur_ld_balancer) {
     double end_lb_time = CmiWallTimer();
-    CkPrintf("Load balancing step %d finished at %f duration %f\n",
-            step(),end_lb_time,end_lb_time - start_lb_time);
+    CkPrintf("[%s] Load balancing step %d finished at %f duration %f\n",
+            lbName(), step(),end_lb_time,end_lb_time - start_lb_time);
   }
   migrates_completed = 0;
   migrates_expected = -1;
@@ -465,6 +440,36 @@ LBMigrateMsg* CentralLB::Strategy(LDStats* stats,int count)
   return msg;
 }
 
+void CentralLB::simulation() {
+  if(step() == CkpvAccess(dumpStep))
+  {
+    // here we are supposed to dump the database
+    writeStatsMsgs(CkpvAccess(dumpFile));
+    CkExit();
+    return;
+  }
+  else if(CkpvAccess(doSimulation))
+  {
+    // here we are supposed to read the data from the dump database
+    readStatsMsgs(CkpvAccess(dumpFile));
+
+    CLBSimResults simResults(stats_msg_count);
+
+    // now pass it to the strategy routine
+    LBMigrateMsg* migrateMsg = Strategy(statsDataList, stats_msg_count);
+
+    // now calculate the results of the load balancing simulation
+    FindSimResults(statsDataList, stats_msg_count, migrateMsg, &simResults);
+
+    // now we have the simulation data, so print it and exit
+    CmiPrintf("LBSim: Simulation of one load balancing step done.\n");
+               simResults.PrintSimulationResults();
+
+    delete migrateMsg;
+    CkExit();
+  }
+}
+
 void CentralLB::readStatsMsgs(const char* filename) {
 
   int i;
@@ -480,7 +485,7 @@ void CentralLB::readStatsMsgs(const char* filename) {
   PUP::fromDisk p(f);
   p|stats_msg_count;
 
-  // now resbuild new structures
+  // now rebuild new structures
   statsMsgsList = new CLBStatsMsg*[stats_msg_count];
   statsDataList = new LDStats[stats_msg_count];
 
@@ -521,6 +526,40 @@ void CentralLB::writeStatsMsgs(const char* filename) {
     CkPupMessage(p, (void **)&statsMsgsList[i], 1);
   }
   CmiPrintf("writeStatsMsgs to %s\n", filename);
+  CmiPrintf("LBDump: Dumped the load balancing data.\n");
+}
+
+static void getPredictedLoad(CentralLB::LDStats* stats, int count, LBMigrateMsg* msg, double *peLoads)
+{
+  for(int pe = 0; pe < count; pe++)
+  {
+    peLoads[pe] = stats[pe].bg_walltime;
+    for(int obj = 0; obj < stats[pe].n_objs; obj++)
+    {
+       peLoads[pe] += stats[pe].objData[obj].wallTime;
+    }
+  }
+
+  // now for each migration, substract the load of the migrating object from the source pe
+  // and add it to the destination pe
+  for(int mig = 0; mig < msg->n_moves; mig++)
+  {
+       int from = msg->moves[mig].from_pe;
+       int to = msg->moves[mig].to_pe;
+       double wallTime;
+       int oidx;
+
+       // find the cpu time for the object that is migrating
+       for(oidx = 0; oidx < stats[from].n_objs; oidx++)
+         if(stats[from].objData[oidx].handle.id == msg->moves[mig].obj.id)
+         {
+               wallTime = stats[from].objData[oidx].wallTime;
+               break;
+         }
+       CkAssert(oidx != stats[from].n_objs);
+       peLoads[from] -= wallTime;
+       peLoads[to] += wallTime;
+  }
 }
 
 void CentralLB::FindSimResults(LDStats* stats, int count, LBMigrateMsg* msg, CLBSimResults* simResults)
@@ -528,37 +567,8 @@ void CentralLB::FindSimResults(LDStats* stats, int count, LBMigrateMsg* msg, CLB
        CkAssert(simResults != NULL && count == simResults->numPes);
        // estimate the new loads of the processors. As a first approximation, this is the
        // sum of the cpu times of the objects on that processor
+        getPredictedLoad(stats, count, msg, simResults->peLoads);
 
-       // first find the load before the migration
-       for(int pe = 0; pe < count; pe++)
-       {
-               simResults->peLoads[pe] = 0.0;
-               for(int obj = 0; obj < stats[pe].n_objs; obj++)
-               {
-                       simResults->peLoads[pe] += stats[pe].objData[obj].cpuTime;
-               }
-       }
-
-       // now for each migration, substract the load of the migrating object from the source pe
-       // and add it to the destination pe
-       for(int mig = 0; mig < msg->n_moves; mig++)
-       {
-               int from = msg->moves[mig].from_pe;
-               int to = msg->moves[mig].to_pe;
-               double cpuTime;
-               int oidx;
-
-               // find the cpu time for the object that is migrating
-               for(oidx = 0; oidx < stats[from].n_objs; oidx++)
-                       if(stats[from].objData[oidx].handle.id == msg->moves[mig].obj.id)
-                       {
-                               cpuTime = stats[from].objData[oidx].cpuTime;
-                               break;
-                       }
-               CkAssert(oidx != stats[from].n_objs);
-               simResults->peLoads[from] -= cpuTime;
-               simResults->peLoads[to] += cpuTime;
-       }
 }
 
 #endif
index 2f02e64f40d1866c4c59e27ab672d6257dc1a188..1466e5bba380e49a7df895df82dfcd1b0172d6ce 100644 (file)
@@ -90,6 +90,7 @@ protected:
   virtual CmiBool QueryDumpData() { return CmiFalse; };  
   virtual LBMigrateMsg* Strategy(LDStats* stats,int count);
 
+  void simulation();
   void FindSimResults(LDStats* stats, int count, LBMigrateMsg* msg, CLBSimResults* simResults);
   void RemoveNonMigratable(LDStats* statsDataList, int count);
 
index 92f739efbe0a8b1c167f4263e73033530b478d07..ae49e3859e090ef071d90a74a1720412fb984365 100644 (file)
@@ -42,6 +42,7 @@ Comm1LB::Comm1LB()
 {
   if (CkMyPe() == 0)
     CkPrintf("[%d] Comm1LB created\n",CkMyPe());
+  lbname = "Comm1LB";
 }
 
 CmiBool Comm1LB::QueryBalanceNow(int _step)
index 91abfef987d12f5100fa0ef59d64a553894bb99a..d1eacb337fba0f9a2eb606472ff9680b33df8fbf 100644 (file)
@@ -38,6 +38,7 @@ static void lbinit(void) {
 
 CommLB::CommLB()
 {
+    lbname = "CommLB";
     if (CkMyPe() == 0)
        CkPrintf("[%d] CommLB created\n",CkMyPe());
     manager_init();
index 2a3cf0bf73d34df3b15aa9d6d32b9cacdb53e575..6c338eeb4f3034b9d6f96a28cc02f49aaeb62a7b 100644 (file)
@@ -33,6 +33,7 @@ static void lbinit(void) {
 
 GreedyRefLB::GreedyRefLB()
 {
+  lbname = "GreedyRefLB";
   if (CkMyPe()==0)
     CkPrintf("[%d] GreedyRefLB created\n",CkMyPe());
 }
index aba2769aaf579cc9f7093ed6f42f22e9f5947737..9474113cc848a1e4d5d6a21bf5367fd78c9f1f83 100644 (file)
@@ -33,6 +33,7 @@ static void lbinit(void) {
 
 HeapCentLB::HeapCentLB()
 {
+  lbname = "HeapCentLB";
   if (CkMyPe()==0)
     CkPrintf("[%d] HeapCentLB created\n",CkMyPe());
 }
index 50ed10e8a0ee91ed88fdbc5cb011f2254c69cafe..7e208c693e81c21f4334bd104c46f9a90ece865c 100644 (file)
@@ -82,16 +82,21 @@ LDOMHandle LBDB::AddOM(LDOMid _userID, void* _userData,
   return newhandle;
 }
 
-LDObjHandle LBDB::AddObj(LDOMHandle _h, LDObjid _id,
+LDObjHandle LBDB::AddObj(LDOMHandle _omh, LDObjid _id,
                         void *_userData, CmiBool _migratable)
 {
   LDObjHandle newhandle;
 
-  newhandle.omhandle = _h;
+  newhandle.omhandle = _omh;
   newhandle.user_ptr = _userData;
   newhandle.id = _id;
   
-  LBObj *obj = new LBObj(this,_h,_id,_userData,_migratable);
+#if 1
+  newhandle.handle = objs.length();
+  LBObj *obj = new LBObj(this, newhandle, _migratable);
+  objs.insertAtEnd(obj);
+#else
+  LBObj *obj = new LBObj(this,_omh,_id,_userData,_migratable);
   if (obj != NULL) {
     newhandle.handle = objs.length();
     objs.insertAtEnd(obj);
@@ -99,6 +104,7 @@ LDObjHandle LBDB::AddObj(LDOMHandle _h, LDObjid _id,
     newhandle.handle = -1;
   }
   obj->DepositHandle(newhandle);
+#endif
   objCount++;
   return newhandle;
 }
@@ -198,7 +204,7 @@ void LBDB::Migrate(LDObjHandle h, int dest)
            CkMyPe(),h.handle,objCount);
 
   if ((h.handle < objCount) && ((objs[h.handle])->registered)) {
-    LBOM *const om = oms[(objs[h.handle])->parentOM.handle];
+    LBOM *const om = oms[(objs[h.handle])->parentOM().handle];
     om->Migrate(h, dest);
   }
   return;
index 44139bbb43c4f9d650f4522ded0460a731d221e9..467a36da9dc43418547b8d6d27c50c4b8e3c11cd 100644 (file)
@@ -29,6 +29,7 @@ CkpvDeclare(int, lbdatabaseInited);  /**< true if lbdatabase is inited */
 CkpvDeclare(int, dumpStep);                     /**< the load balancing step at which to dump data */
 CkpvDeclare(char*, dumpFile);           /**< the name of the file in which the data will be dumped */
 CkpvDeclare(int, doSimulation);                 /**< true if the program is running under "simulation" mode for load balancing */
+const char defaultDumpFileName[] = "lbdata.dat";   //default fname for dumping
 
 static LBDefaultCreateFn defaultCreate=NULL;
 void LBSetDefaultCreate(LBDefaultCreateFn f)
@@ -117,7 +118,7 @@ void _loadbalancerInit()
   CkpvInitialize(int, dumpStep);
   CkpvAccess(dumpStep) = -1;
   CkpvInitialize(char*, dumpFile);
-  CkpvAccess(dumpFile) = NULL;
+  CkpvAccess(dumpFile) = (char *)defaultDumpFileName;
   CkpvInitialize(int, doSimulation);
   CkpvAccess(doSimulation) = 0;
 
index b3fab7f63736aac6ae7368b96ef22130b7165dc0..23d616a97aeef943dd0b785b2dcf16a187061383 100644 (file)
@@ -24,9 +24,9 @@
 
 void LBObj::Clear(void)
 {
-  data.handle = myhandle;
+//  data.handle = myhandle;
 //  data.id = myid;
-  data.omHandle = parentOM;
+//  data.omHandle = parentOM;
 //  data.omID = parentDB->LbOM(parentOM)->id();
   data.cpuTime = 0.;
   data.wallTime = 0.;
index 62f5d8ccb5dfc0b1c300af8dbb3afa1d0d053d60..635d1b14d393c8fb12b13ceb36b58fb257c77211 100644 (file)
@@ -22,28 +22,40 @@ class LBObj
 friend class LBDB;
 
 public:
+  LBObj(LBDB *_parentDB, const LDObjHandle &_h, CmiBool _migratable=CmiTrue) {
+    data.handle = _h;
+    data.migratable = _migratable;
+    data.cpuTime = 0.;
+    data.wallTime = 0.;
+    parentDB = _parentDB;
+    migratable = _migratable;
+    registered = CmiTrue;
+  }
+
+  ~LBObj() { };
+
+#if 0
   LBObj(LBDB *_parentDB, LDOMHandle _omhandle, LDObjid _id,
        void *_userData = 0, CmiBool _migratable=CmiTrue) {
     parentDB = _parentDB;
-    parentOM = _omhandle;
-    myhandle.id = _id;
-    userData = _userData;
+//    parentOM = _omhandle;
+//    myhandle.id = _id;
+//    userData = _userData;
     migratable = _migratable;
     registered = CmiFalse;
   };
 
-  ~LBObj() { };
-
   void DepositHandle(const LDObjHandle &_h) {
-    CkAssert(_h.id == myhandle.id);
-    myhandle = _h;
-    data.handle = myhandle;
-    data.omHandle = _h.omhandle;
+//    CkAssert(_h.id == myhandle.id);
+//    myhandle = _h;
+    data.handle = _h;
+//    data.omHandle = _h.omhandle;
     data.migratable = migratable;
     data.cpuTime = 0.;
     data.wallTime = 0.;
     registered = CmiTrue;
   };
+#endif
 
   void Clear(void);
 
@@ -51,16 +63,17 @@ public:
   void StartTimer(void);
   void StopTimer(double* walltime, double* cputime);
 
-  inline const LDObjHandle &GetLDObjHandle() const { return myhandle; }
+  inline LDOMHandle &parentOM() { return data.handle.omhandle; }
+  inline const LDObjHandle &GetLDObjHandle() const { return data.handle; }
   inline void SetMigratable(int mig) { data.migratable = mig; }
 private:
   inline LDObjData ObjData() { return data; };
 
   LBDB* parentDB;
-  LDOMHandle parentOM;
-  LDObjHandle myhandle;
+//  LDOMHandle parentOM;
+//  LDObjHandle myhandle;
   LDObjData data;
-  void *userData;
+//  void *userData;
   double startWTime;
   double startCTime;
   CmiBool migratable;   // temp
index 80d9ad75b75e1059a90d90734f5d33857895557f..293ddfc260f0e51f1854b929d01ff03ed644bc65 100644 (file)
@@ -34,6 +34,7 @@ static void lbinit(void) {
 
 MetisLB::MetisLB()
 {
+  lbname = "MetisLB";
   if (CkMyPe() == 0)
     CkPrintf("[%d] MetisLB created\n",CkMyPe());
 }
index dcebc68756a6e18abfa38244d209438950782361..d7ba3527013fc0a338784319af0546839ed8b680 100644 (file)
@@ -43,6 +43,7 @@ void NborBaseLB::staticAtSync(void* data)
 
 NborBaseLB::NborBaseLB()
 {
+  lbname = "NborBaseLB";
   mystep = 0;
   theLbdb = CProxy_LBDatabase(lbdb).ckLocalBranch();
   theLbdb->
index c1c572082d1371c248e145548c3aa166c7289a6f..5d970bb54f7527148f828243c39b81cc6c90d8c2 100644 (file)
@@ -33,6 +33,7 @@ static void lbinit(void) {
 
 NeighborLB::NeighborLB()
 {
+  lbname = "NeighborLB";
   if (CkMyPe() == 0)
     CkPrintf("[%d] NeighborLB created\n",CkMyPe());
 }
index 6b44d3bc3bcea9c2a4f615a3816d765a3eba6789..adb6b1efeb4db607076c374c13217999febfe1d5 100644 (file)
@@ -27,7 +27,7 @@ class NullLB : public CBase_NullLB
 {
   void init(void);
 public:
-  NullLB() {init();}
+  NullLB() {init(); lbname="NullLB";}
   NullLB(CkMigrateMessage *m) {init();}
   ~NullLB();
 
index 2ad1f94935804078525f5dc9dd10eeba817c690a..e9a33bb8a64691d2f858a0ee5e838325edb57d9c 100644 (file)
@@ -33,6 +33,7 @@ static void lbinit(void) {
 
 RandCentLB::RandCentLB()
 {
+  lbname = "RandCentLB";
   if (CkMyPe() == 0)
     CkPrintf("[%d] RandCentLB created\n",CkMyPe());
 }
index 6864c250180226d9108efc8c3a58ec3c6f6784a0..2f8f35b5f78cc3f9aedf40d3ca07ccd3fc3c1915 100644 (file)
@@ -35,6 +35,7 @@ static void lbinit(void) {
 
 RandRefLB::RandRefLB()
 {
+  lbname = "RandRefLB";
   if (CkMyPe() == 0)
     CkPrintf("[%d] RandRefLB created\n",CkMyPe());
 }
index ebd2a00b56eb5588a0cf1eb22d8180f1e418c2a4..41b317e578a024c38c7ddf49ea544af8c1bb98ff 100644 (file)
@@ -54,6 +54,7 @@ static void lbinit(void) {
 
 RecBisectBfLB::RecBisectBfLB()
 {
+  lbname = "RecBisectBfLB";
   if (CkMyPe() == 0)
     CkPrintf("[%d] RecBisectBfLB created\n",CkMyPe());
 }
index 05f3b7858cb528c46ad19f2f508f16551cf73f4f..715da7e59b83efd0a296303b89dfb371fcbbc965 100644 (file)
@@ -33,6 +33,7 @@ static void lbinit(void) {
 
 RefineLB::RefineLB()
 {
+  lbname = "RefineLB";
   if (CkMyPe() == 0)
     CkPrintf("[%d] RefineLB created\n",CkMyPe());
 }
@@ -42,158 +43,6 @@ CmiBool RefineLB::QueryBalanceNow(int _step)
   return CmiTrue;
 }
 
-/*
-void RefineLB::create(CentralLB::LDStats* stats, int count)
-{
-  int i,j;
-
-  P = count;
-
-  numComputes = 0;
-  for(j=0; j < P; j++) numComputes+= stats[j].n_objs;
-  computes = new computeInfo[numComputes];
-
-  processors = new processorInfo[count];
-
-  int index = 0;
-  for(j=0; j < count; j++) {
-    processors[j].Id = j;
-    processors[j].backgroundLoad = 0;
-    processors[j].load = processors[j].backgroundLoad;
-    processors[j].computeLoad = 0;
-    processors[j].computeSet = new Set();
-
-    LDObjData *odata = stats[j].objData;
-    const int osz = stats[j].n_objs;  
-    for(i=0; i < osz; i++) {
-//      computes[index].omID = odata[i].omID;
-//      computes[index].id = odata[i].id;
-      computes[index].id = odata[i].id;
-      computes[index].handle = odata[i].handle;
-      computes[index].load = odata[i].cpuTime;
-      computes[index].processor = -1;
-      computes[index].oldProcessor = j;
-      index ++;
-    }
-  }
-
-//  for (i=0; i < numComputes; i++)
-//      processors[computes[i].oldProcessor].computeLoad += computes[i].load;
-}
-*/
-
-/*
-void RefineLB::assign(computeInfo *c, int processor)
-{
-   assign(c, &(processors[processor]));
-}
-
-void RefineLB::assign(computeInfo *c, processorInfo *p)
-{
-   c->processor = p->Id;
-   p->computeSet->insert((InfoRecord *) c);
-   p->computeLoad += c->load;
-   p->load = p->computeLoad + p->backgroundLoad;
-}
-
-void  RefineLB::deAssign(computeInfo *c, processorInfo *p)
-{
-   c->processor = -1;
-   p->computeSet->remove(c);
-   p->computeLoad -= c->load;
-   p->load = p->computeLoad + p->backgroundLoad;
-}
-
-int RefineLB::refine()
-{
-   int finish = 1;
-   maxHeap *heavyProcessors = new maxHeap(P);
-
-   Set *lightProcessors = new Set();
-   int i;
-   for (i=0; i<P; i++)
-   {
-      if (processors[i].load > overLoad*averageLoad)
-      {
-//CkPrintf("Processor %d is HEAVY: load:%f averageLoad:%f!\n", i, processors[i].load, averageLoad);
-         heavyProcessors->insert((InfoRecord *) &(processors[i]));
-      }
-      else if (processors[i].load < averageLoad)
-      {
-//CkPrintf("Processor %d is LIGHT: load:%f averageLoad:%f!\n", i, processors[i].load, averageLoad);
-             lightProcessors->insert((InfoRecord *) &(processors[i]));
-      }
-   }
-   int done = 0;
-
-   while (!done)
-   {
-      double bestSize;
-      computeInfo *bestCompute;
-      processorInfo *bestP;
-    
-      processorInfo *donor = (processorInfo *) heavyProcessors->deleteMax();
-      if (!donor) break;
-
-      //find the best pair (c,receiver)
-      Iterator nextProcessor;
-      processorInfo *p = (processorInfo *) 
-             lightProcessors->iterator((Iterator *) &nextProcessor);
-      bestSize = 0;
-      bestP = 0;
-      bestCompute = 0;
-
-      while (p)
-      {
-         Iterator nextCompute;
-         nextCompute.id = 0;
-         computeInfo *c = (computeInfo *) 
-            donor->computeSet->iterator((Iterator *)&nextCompute);
-         // iout << iINFO << "Considering Procsessor : " << p->Id << "\n" << endi;
-         while (c)
-         {
-//CkPrintf("c->load: %f p->load:%f overLoad*averageLoad:%f \n", c->load, p->load, overLoad*averageLoad);
-            if ( c->load + p->load < overLoad*averageLoad) 
-            {
-               // iout << iINFO << "Considering Compute : " << c->Id << " with load " 
-               //      << c->load << "\n" << endi;
-               if(c->load > bestSize) 
-               {
-                  bestSize = c->load;
-                  bestCompute = c;
-                  bestP = p;
-               }
-            }
-            nextCompute.id++;
-            c = (computeInfo *) donor->computeSet->next((Iterator *)&nextCompute);
-         }
-         p = (processorInfo *) 
-         lightProcessors->next((Iterator *) &nextProcessor);
-      }
-
-      if (bestCompute)
-      {
-//CkPrintf("Assign: [%d] with load: %f from %d to %d \n", bestCompute->id.id[0], bestCompute->load, donor->Id, bestP->Id);
-        deAssign(bestCompute, donor);      
-        assign(bestCompute, bestP);
-      }
-      else {
-       finish = 0;
-       break;
-      }
-
-      if (bestP->load > averageLoad)
-         lightProcessors->remove(bestP);
-    
-      if (donor->load > overLoad*averageLoad)
-         heavyProcessors->insert((InfoRecord *) donor);
-      else if (donor->load < averageLoad)
-         lightProcessors->insert((InfoRecord *) donor);
-   }  
-   return finish;
-}
-*/
-
 LBMigrateMsg* RefineLB::Strategy(CentralLB::LDStats* stats, int count)
 {
   int obj, pe;
@@ -203,20 +52,6 @@ LBMigrateMsg* RefineLB::Strategy(CentralLB::LDStats* stats, int count)
   // remove non-migratable objects
   RemoveNonMigratable(stats, count);
 
-/*
-  create(stats, count);
-
-  int i;
-  for (i=0; i<numComputes; i++)
-    assign((computeInfo *) &(computes[i]),
-           (processorInfo *) &(processors[computes[i].oldProcessor]));
-
-  computeAverage();
-  overLoad = 1.02;
-
-  refine();
-*/
-
   // get original object mapping
   int** from_procs = Refiner::AllocProcs(count, stats);
   for(pe=0;pe < count; pe++) 
@@ -232,28 +67,6 @@ LBMigrateMsg* RefineLB::Strategy(CentralLB::LDStats* stats, int count)
 
   CkVec<MigrateInfo*> migrateInfo;
 
-/*
-  for (int pe=0; pe < P; pe++) {
-    Iterator nextCompute;
-    nextCompute.id = 0;
-    computeInfo *c = (computeInfo *)
-         processors[pe].computeSet->iterator((Iterator *)&nextCompute);
-    while(c) {
-      if (c->oldProcessor != c->processor)  {
-       //      CkPrintf("Migrate: from %d to %d\n",c->oldProcessor, c->processor);
-       MigrateInfo* migrateMe = new MigrateInfo;
-       migrateMe->obj = c->handle;
-       migrateMe->from_pe = c->oldProcessor;
-       migrateMe->to_pe = c->processor;
-       migrateInfo.insertAtEnd(migrateMe);
-      }
-      nextCompute.id++;
-      c = (computeInfo *) processors[pe].computeSet->
-                    next((Iterator *)&nextCompute);
-    }
-  }
-*/
-
   // Save output
   for(pe=0;pe < count; pe++) {
     for(obj=0;obj<stats[pe].n_objs;obj++) {
index 27f9c4945a8e6d2b4ed0c413125fbda249bd9036..2e311e10e26cd4790260bc68337a9c25e5f47a0d 100644 (file)
@@ -13,6 +13,11 @@ CLBSimResults::CLBSimResults(int numPes_) : numPes(numPes_)
                peLoads[i] = 0.0;
 }
 
+CLBSimResults::~CLBSimResults()
+{
+       delete [] peLoads;
+}
+
 void CLBSimResults::SetProcessorLoad(int pe, double load)
 {
        CkAssert(0 <= pe && pe < numPes);
index 0247b2a68c1072e6418cd3fe340d7cd9c9181598..feefb745037edf0d440fb423d8018455568a1d79 100644 (file)
@@ -16,6 +16,7 @@ class CLBSimResults
 {
 public:
        CLBSimResults(int numPes_);
+       ~CLBSimResults();
        void SetProcessorLoad(int pe, double load);
        void PrintSimulationResults();
 private:
index e7e1300ff8e6fe32ce56eb9540669912a8ea166d..be65deab691bf991dcb1f2d3440658ed3d844d05 100644 (file)
@@ -52,6 +52,7 @@ void WSLB::staticAtSync(void* data)
 
 WSLB::WSLB()  
 {
+  lbname = "WSLB";
   if (CkMyPe() == 0)
     CkPrintf("[%d] WSLB created\n",CkMyPe());
 
index 6fcad7f2f76da069b68ee602c9a6516a1b179f63..45aac6afb2022d12863cfc95850eca3e18ce5d3d 100644 (file)
@@ -28,7 +28,7 @@ typedef void* cvoid; /* To eliminate warnings, because a C void* is not
 
 #if CMK_LBDB_ON
 typedef struct {
-  void *handle;
+  void *handle;            // pointer to LBDB
 } LDHandle;
 #else
 typedef int LDHandle;
@@ -42,7 +42,7 @@ typedef struct {
   LDHandle ldb;
   void *user_ptr;
   LDOMid id;
-  int handle;
+  int handle;          // index to LBOM
 } LDOMHandle;
 
 typedef struct _LDObjid {
@@ -55,21 +55,24 @@ typedef struct _LDObjid {
 #endif
 } LDObjid;
 
+typedef int LDObjIndex;
+
 typedef struct {
   LDOMHandle omhandle;
   void *user_ptr;
   LDObjid id;
-  int handle;
+  LDObjIndex  handle;
 } LDObjHandle;
 
 typedef struct {
   LDObjHandle handle;
-  LDOMHandle omHandle;
+//  LDOMHandle omHandle;
   double cpuTime;
   double wallTime;
   CmiBool migratable;
 #ifdef __cplusplus
-  inline const LDOMid &omID() const { return omHandle.id; }
+  inline const LDOMHandle &omHandle() const { return handle.omhandle; }
+  inline const LDOMid &omID() const { return handle.omhandle.id; }
   inline const LDObjid &id() const { return handle.id; }
 #endif
 } LDObjData;