added new features and bug fixes:
authorGengbin Zheng <gzheng@illinois.edu>
Wed, 20 Aug 2003 05:23:02 +0000 (05:23 +0000)
committerGengbin Zheng <gzheng@illinois.edu>
Wed, 20 Aug 2003 05:23:02 +0000 (05:23 +0000)
1. allow users to specify multiple load balancers at compile time or runtime
by using multiple "-balancer" at compile time and "+balancer" at runtime.
For example, if foo1LB, foo2LB amd foo3LB are specified, the first
load balancing phase will invoke foo1LB, second phase uses foo2LB,
all afterwards load balancing phases will use foo3LB.

2. bug fixes and improvements in NullLB: when no real load balancer exists,
NullLB now doesnot bother clearing the LB database, also it disables the
builtin batsyncer which original calls atSync in every second.
These reduce unnecessary overhead of NullLB.

3. batsyncer itself is not strictly needed in the AtSync mode load balancing
(useful only when there is no object on one processor to call AtSync),
however, it is very important in automatic (non atSync) mode to set the
load balancing interval time. For AtSync mode, batsyncer should call
AtSync immediately to avoid any delay; for non AtSync mode however, the
period time is the interval between load balancing phases, it still can be
set to 0 second but better to be some larger value. Thus, for the default
batsync period time for both cases, 0 second is a better choice which means
the batsyncer barrier is always ready. In the case of non atSync
mode, users should use +LBPeriod to set the load balancing interval anyway.

55 files changed:
src/ck-ldb/BaseLB.C
src/ck-ldb/BaseLB.ci
src/ck-ldb/BaseLB.h
src/ck-ldb/CentralLB.C
src/ck-ldb/CentralLB.ci
src/ck-ldb/CentralLB.h
src/ck-ldb/Comm1LB.C
src/ck-ldb/Comm1LB.ci
src/ck-ldb/Comm1LB.h
src/ck-ldb/CommLB.C
src/ck-ldb/CommLB.ci
src/ck-ldb/CommLB.h
src/ck-ldb/DummyLB.C
src/ck-ldb/DummyLB.ci
src/ck-ldb/DummyLB.h
src/ck-ldb/GreedyLB.C
src/ck-ldb/GreedyLB.ci
src/ck-ldb/GreedyLB.h
src/ck-ldb/GreedyRefLB.C
src/ck-ldb/GreedyRefLB.ci
src/ck-ldb/GreedyRefLB.h
src/ck-ldb/LBDBManager.C
src/ck-ldb/LBDBManager.h
src/ck-ldb/LBDatabase.C
src/ck-ldb/LBDatabase.h
src/ck-ldb/MetisLB.C
src/ck-ldb/MetisLB.ci
src/ck-ldb/MetisLB.h
src/ck-ldb/NborBaseLB.C
src/ck-ldb/NborBaseLB.ci
src/ck-ldb/NborBaseLB.h
src/ck-ldb/NeighborLB.C
src/ck-ldb/NeighborLB.ci
src/ck-ldb/NeighborLB.h
src/ck-ldb/NullLB.C
src/ck-ldb/NullLB.ci
src/ck-ldb/NullLB.h
src/ck-ldb/OrbLB.C
src/ck-ldb/OrbLB.ci
src/ck-ldb/OrbLB.h
src/ck-ldb/RandCentLB.C
src/ck-ldb/RandCentLB.ci
src/ck-ldb/RandCentLB.h
src/ck-ldb/RandRefLB.C
src/ck-ldb/RandRefLB.ci
src/ck-ldb/RandRefLB.h
src/ck-ldb/RecBisectBfLB.C
src/ck-ldb/RecBisectBfLB.ci
src/ck-ldb/RecBisectBfLB.h
src/ck-ldb/RefineLB.C
src/ck-ldb/RefineLB.ci
src/ck-ldb/RefineLB.h
src/ck-ldb/WSLB.C
src/ck-ldb/WSLB.ci
src/ck-ldb/WSLB.h

index aa0457b401dff84eb13c537c2019c17389974ab2..207d916040a0ed59fa2fa3f348fc31797294517a 100644 (file)
 
 #if CMK_LBDB_ON
 
-BaseLB::BaseLB() {
+BaseLB::BaseLB(const CkLBOptions &opt) {
+  seqno = opt.getSeqNo();
   CkpvAccess(numLoadBalancers) ++;
+/*
   if (CkpvAccess(numLoadBalancers) - CkpvAccess(hasNullLB) > 1)
     CmiAbort("Error: try to create more than one load balancer strategies!");
+*/
   theLbdb = CProxy_LBDatabase(lbdb).ckLocalBranch();
   lbname = "Unknown";
+  theLbdb->addLoadbalancer(this, seqno);
 }
 
 void BaseLB::unregister() {
@@ -30,7 +34,7 @@ void BaseLB::unregister() {
 }
 
 #else
-BaseLB::BaseLB() {}
+BaseLB::BaseLB(int seq) {}
 void BaseLB::unregister() {}
 #endif
 
index 70c4da7212d331f46816ae9cbd1b0659d3f7e168..8ecd774af512a3551f94fcbc62cd1ed40b5a8888 100644 (file)
@@ -5,7 +5,7 @@ extern module LBDatabase;
 message LBMigrateMsg;
 
 group [migratable] BaseLB {
-  entry void BaseLB(void);  
+  entry void BaseLB(const CkLBOptions &);  
   entry void unregister(void);
 };
 
index f2baa32a9a4dd19b885ea4b92c269f7313bcb634..cc9992ec4e41426414cf3f89f4af3a64007567fc 100644 (file)
 class BaseLB: public IrrGroup
 {
 protected:
+  int  seqno;
   char *lbname;
   LBDatabase *theLbdb;
   LDBarrierReceiver receiver;
   int  notifier;
   int  startLbFnHdl;
 public:
-  BaseLB() ;
+  BaseLB(const CkLBOptions &) ;
   BaseLB(CkMigrateMessage *m):IrrGroup(m) { /* empty */ }
   void unregister(); 
   inline char *lbName() { return lbname; }
+  virtual void turnOff() { CmiAbort("turnOff not implemented"); }
+  virtual void turnOn()  { CmiAbort("turnOn not implemented"); }
 };
 
 /// migration decision for an obj.
@@ -64,6 +67,12 @@ public:
   static LBMigrateMsg* unpack(void* in);
 };
 
+#define CreateLBFunc_Def(x)            \
+void Create##x(void) {         \
+  int seqno = LBDatabaseObj()->getLoadbalancerTicket();        \
+  CProxy_##x::ckNew(CkLBOptions(seqno));       \
+}
+
 #endif
 
 /*@}*/
index 4b09aefb0166be7b3ad218024bb9864cd683eca3..b51f0ae3c79e06acb445156ecbafec2414d4ecf1 100644 (file)
@@ -30,7 +30,7 @@ static void getPredictedLoad(CentralLB::LDStats* stats, int count,
 
 void CreateCentralLB()
 {
-  loadbalancer = CProxy_CentralLB::ckNew();
+  CProxy_CentralLB::ckNew(0);
 }
 
 void CentralLB::staticStartLB(void* data)
@@ -51,10 +51,10 @@ void CentralLB::staticAtSync(void* data)
   me->AtSync();
 }
 
-CentralLB::CentralLB()
+CentralLB::CentralLB(const CkLBOptions &opt): BaseLB(opt)
 {
   lbname = "CentralLB";
-  mystep = 0;
+  thisProxy = CProxy_CentralLB(thisgroup);
   //  CkPrintf("Construct in %d\n",CkMyPe());
 
   // create and turn on by default
@@ -65,7 +65,8 @@ CentralLB::CentralLB()
   startLbFnHdl = theLbdb->getLBDB()->
     AddStartLBFn((LDStartLBFn)(staticStartLB),(void*)(this));
 
-//  turnOff();
+  // CkPrintf("[%d] CentralLB seq %d\n",CkMyPe(), seq);
+  if (opt.getSeqNo()) turnOff();
 
   stats_msg_count = 0;
   statsMsgsList = new CLBStatsMsg*[CkNumPes()];
@@ -422,14 +423,15 @@ void CentralLB::MigrationDone(int balancing)
   // clear load stats
   if (balancing) theLbdb->ClearLoads();
   // Increment to next step
-  mystep++;
-  thisProxy [CkMyPe()].ResumeClients();
+  theLbdb->incStep();
+  thisProxy [CkMyPe()].ResumeClients(balancing);
 }
 
-void CentralLB::ResumeClients()
+void CentralLB::ResumeClients(int balancing)
 {
   DEBUGF(("Resuming clients on PE %d\n",CkMyPe()));
   theLbdb->ResumeClients();
+  if (balancing) theLbdb->nextLoadbalancer(seqno);
 }
 
 // default load balancing strategy
index 7f284f3e8db1750e1b4ff1c308221af8bfd088a8..a1bef54805e302d26e982a9fed037713ba641b33 100644 (file)
@@ -10,10 +10,10 @@ readonly CkGroupID loadbalancer;
 //message CLBStatsMsg;
 
 group [migratable] CentralLB : BaseLB {
-  entry void CentralLB(void);  
+  entry void CentralLB(const CkLBOptions &);  
   entry void ProcessAtSync(void);
   entry void ReceiveStats(CkMarshalledCLBStatsMessage data);
-  entry void ResumeClients(void);
+  entry void ResumeClients(int);
   entry void ReceiveMigration(LBMigrateMsg*);  
 };
 
index eeab58eb5f649f1a9b60606bfdfd0bc22dc2abf6..eecbe4c336d7e0554c7923d02fb9bde664a14261 100644 (file)
@@ -32,23 +32,25 @@ class LBSimulation;
 /// for backward compatibility
 typedef LBMigrateMsg  CLBMigrateMsg;
 
-class CentralLB : public CBase_CentralLB
+class CentralLB : public BaseLB
 {
 public:
-  CentralLB();
+  CentralLB(const CkLBOptions &);
   virtual ~CentralLB();
-  CentralLB(CkMigrateMessage *m):CBase_CentralLB(m) {}
+  CentralLB(CkMigrateMessage *m):BaseLB(m) {}
 
   void turnOn();
   void turnOff();
+  inline int step() { return theLbdb->step(); }
   int useDefCtor(void){ return 1; }
+
   static void staticAtSync(void*);
   void AtSync(void); // Everything is at the PE barrier
   void ProcessAtSync(void); // Receive a message from AtSync to avoid
                             // making projections output look funny
 
   void ReceiveStats(CkMarshalledCLBStatsMessage &msg); // Receive stats on PE 0
-  void ResumeClients(void);                     // Resuming clients needs
+  void ResumeClients(int);                     // Resuming clients needs
                                                // to be resumed via message
   void ReceiveMigration(LBMigrateMsg *);       // Receive migration data
 
@@ -61,7 +63,6 @@ public:
   void Migrated(LDObjHandle h);
 
   void MigrationDone(int balancing);  // Call when migration is complete
-  int step() { return mystep; };
 
   struct ProcStats {  // per processor data
     double total_walltime;
@@ -135,8 +136,7 @@ protected:
 //  void removeNonMigratable(LDStats* statsDataList, int count);
 
 private:  
-
-  int mystep;
+  CProxy_CentralLB thisProxy;
   int myspeed;
   int stats_msg_count;
   CLBStatsMsg **statsMsgsList;
index 77c6379c8456dde18e037715e2c84cc63ec01a0b..628fc72e2621175c50523437886c179316ea90a8 100644 (file)
 #define UPPER_FACTOR 0.67
 #define MAX_WEIGHT 5.0
 
-void CreateComm1LB()
-{
-  loadbalancer = CProxy_Comm1LB::ckNew();
-}
+CreateLBFunc_Def(Comm1LB);
 
 static void lbinit(void) {
-//        LBSetDefaultCreate(CreateComm1LB);        
   LBRegisterBalancer("Comm1LB", CreateComm1LB, "another variation of CommLB");
 }
 
 #include "Comm1LB.def.h"
 
-Comm1LB::Comm1LB()
+Comm1LB::Comm1LB(const CkLBOptions &opt): CentralLB(opt)
 {
   if (CkMyPe() == 0)
     CkPrintf("[%d] Comm1LB created\n",CkMyPe());
index ab0c1263a434ac268ca4e6906b8f46290ab2b6a2..dd23131cea7e6c8f955a976218c585b87091a4ba 100644 (file)
@@ -3,7 +3,7 @@ module Comm1LB {
 extern module CentralLB;
 initnode void lbinit(void);
 group [migratable] Comm1LB : CentralLB {
-  entry void Comm1LB(void);  
+  entry void Comm1LB(CkLBOptions &);  
 };
 
 };
index 50aa938a907af957c363486eb26fbaacdc2d34cb..7d3d443cb5c8d8f07ffae14126aeb23c690f556f 100644 (file)
 
 #define CUT_OFF_FACTOR 1.200
 
+void CreateComm1LB();
+
 struct alloc_struct{
   double load;
   int nbyte;
   int nmsg;
 };
 
-void CreateComm1LB();
-
 class Comm1LB : public CentralLB {
 public:
   int nobj,npe;
   alloc_struct ** alloc_array;
   graph * object_graph;
-  Comm1LB();
+  Comm1LB(const CkLBOptions &);
   Comm1LB(CkMigrateMessage *m):CentralLB(m) {}
 private:
   CmiBool QueryBalanceNow(int step);
index cf9d6731226bdc055ce964f2976db22ea13c394e..15351fe42d144a3895f49e1806daa7bfa9b7b446 100644 (file)
@@ -32,13 +32,9 @@ Status:
 #define alpha PER_MESSAGE_SEND_OVERHEAD  /*Startup time per message, seconds*/
 #define beeta PER_BYTE_SEND_OVERHEAD     /*Long-message time per byte, seconds*/
 
-void CreateCommLB()
-{
-    loadbalancer = CProxy_CommLB::ckNew();
-}
+CreateLBFunc_Def(CommLB);
 
 static void lbinit(void) {
-//        LBSetDefaultCreate(CreateCommLB);        
   LBRegisterBalancer("CommLB", CreateCommLB, "Greedy algorithm which takes communication graph into account");
 }
 
@@ -46,7 +42,7 @@ static void lbinit(void) {
 
 #include "manager.h"
 
-CommLB::CommLB()
+CommLB::CommLB(const CkLBOptions &opt): CentralLB(opt)
 {
     lbname = "CommLB";
     if (CkMyPe() == 0)
index 242adafbe978d9ebe566df49b80216fecab57dd0..9707423a7e92bac4176e47ed837b31b6f7181214 100644 (file)
@@ -3,7 +3,7 @@ module CommLB {
 extern module CentralLB;
 initnode void lbinit(void);
 group [migratable] CommLB : CentralLB {
-  entry void CommLB(void);  
+  entry void CommLB(const CkLBOptions &);  
 };
 
 };
index c723c8079f1ba798e7d2c4e510ec7463c8a54415..f7be742c0650236a7bd121fd69f1d36bdf605373 100644 (file)
@@ -19,6 +19,8 @@
 #include "CommLBHeap.h"
 #define CUT_OFF_FACTOR 1.200
 
+void CreateCommLB();
+
 struct graph{
   int id;
   int data;
@@ -26,14 +28,12 @@ struct graph{
   struct graph * next;
 };
 
-void CreateCommLB();
-
 class CommLB : public CentralLB {
 public:
   int nobj,npe, nmigobj;
   double ** alloc_array;
   graph * object_graph;
-  CommLB();
+  CommLB(const CkLBOptions &);
   CommLB(CkMigrateMessage *m);
 private:
   CentralLB::LDStats* stats;
index 0c7bea211ea266269ee3c38071b91e406be38eed..df09ac693a6a1be852eb31cf9b099c452f7a6327 100644 (file)
 
 #include "DummyLB.h"
 
-void CreateDummyLB()
-{
-  loadbalancer = CProxy_DummyLB::ckNew();
-  //  CkPrintf("[%d] created DummyLB %d\n",CkMyPe(),loadbalancer);
-}
+
+CreateLBFunc_Def(DummyLB);
 
 static void lbinit(void) {
   LBRegisterBalancer("DummyLB", CreateDummyLB, "Dummy load balancer, like a normal one but with empty strategy");
@@ -28,7 +25,7 @@ static void lbinit(void) {
 
 #include "DummyLB.def.h"
 
-DummyLB::DummyLB()
+DummyLB::DummyLB(const CkLBOptions &opt): CentralLB(opt)
 {
   lbname = "DummyLB";
   if (CkMyPe() == 0)
index 0da44b95f2ab28b2a9117e18882c90d889df0bfc..1a670b1c62376a956a90c48168dc0dc887d8cbf4 100644 (file)
@@ -3,7 +3,7 @@ module DummyLB {
 extern module CentralLB;
 initnode void lbinit(void);
 group [migratable] DummyLB : CentralLB {
-  entry void DummyLB(void);  
+  entry void DummyLB(const CkLBOptions &);  
 };
 
 };
index d3226f45e281fcdc046a99f1827b1ae6892d34c3..c96b1589c5abbaf0d6b0cb7a7a5ab8878ab10082 100644 (file)
@@ -20,7 +20,7 @@ void CreateDummyLB();
 
 class DummyLB : public CentralLB {
 public:
-  DummyLB();
+  DummyLB(const CkLBOptions &);
   DummyLB(CkMigrateMessage *m):CentralLB(m) {}
 private:
   CmiBool QueryBalanceNow(int step);
index 3bfe0385b0687e7a6cac47d6ba5a40a056a001ca..1112be9a704932f726714e278a0b00c25a5a91db 100644 (file)
 #include "cklists.h"
 #include "GreedyLB.h"
 
-void CreateGreedyLB()
-{
-  //  CkPrintf("[%d] creating GreedyLB %d\n",CkMyPe(),loadbalancer);
-  loadbalancer = CProxy_GreedyLB::ckNew();
-  //  CkPrintf("[%d] created GreedyLB %d\n",CkMyPe(),loadbalancer);
-}
+CreateLBFunc_Def(GreedyLB);
 
 static void lbinit(void) {
-//        LBSetDefaultCreate(CreateGreedyLB);        
   LBRegisterBalancer("GreedyLB", CreateGreedyLB, "always assign the heaviest obj onto lightest loaded processor.");
 }
 
 #include "GreedyLB.def.h"
 
-GreedyLB::GreedyLB()
+GreedyLB::GreedyLB(const CkLBOptions &opt): CentralLB(opt)
 {
   lbname = "GreedyLB";
   if (CkMyPe()==0)
index b48f21d49e71fc39774037d14f5980a5823179a4..9471c6d29eebb300c69e97732639551d1492be7c 100644 (file)
@@ -3,7 +3,7 @@ module GreedyLB {
 extern module CentralLB;
 initnode void lbinit(void);
 group [migratable] GreedyLB : CentralLB {
-  entry void GreedyLB(void);  
+  entry void GreedyLB(const CkLBOptions &);  
 };
 
 };
index 696328040f136c3f3ae050074df31b09f294d8fa..362f8ae0a1794346a72d3d6e592ed6627cc4d1f8 100644 (file)
@@ -27,7 +27,7 @@ public:
     int    id;
   };
 
-  GreedyLB();
+  GreedyLB(const CkLBOptions &);
   GreedyLB(CkMigrateMessage *m):CentralLB(m) {}
   void work(LDStats* stats,int count);
 private:
index 65d883fdadfcc784de67517dc90277ba0432d220..702b36f8c0b1d6aba26966372cc3815f3168a4bd 100644 (file)
 #include "cklists.h"
 #include "GreedyRefLB.h"
 
-void CreateGreedyRefLB()
-{
-  //  CkPrintf("[%d] creating GreedyRefLB %d\n",CkMyPe(),loadbalancer);
-  loadbalancer = CProxy_GreedyRefLB::ckNew();
-  //  CkPrintf("[%d] created GreedyRefLB %d\n",CkMyPe(),loadbalancer);
-}
+CreateLBFunc_Def(GreedyRefLB);
 
 static void lbinit(void) {
 //        LBSetDefaultCreate(CreateGreedyRefLB);        
@@ -31,7 +26,7 @@ static void lbinit(void) {
 
 #include "GreedyRefLB.def.h"
 
-GreedyRefLB::GreedyRefLB()
+GreedyRefLB::GreedyRefLB(const CkLBOptions &opt): GreedyLB(opt)
 {
   lbname = "GreedyRefLB";
   if (CkMyPe()==0)
index 21d3ef62b1503128f41438b8991b04603bb9c070..b29ed1d00590f2e07be56849fd4c1d770addce2b 100644 (file)
@@ -3,7 +3,7 @@ module GreedyRefLB {
 extern module CentralLB;
 initnode void lbinit(void);
 group [migratable] GreedyRefLB : CentralLB {
-  entry void GreedyRefLB(void);  
+  entry void GreedyRefLB(const CkLBOptions &);  
 };
 
 };
index 185861bdc41410819d1f010f28112a8445116b41..f56b15689203f4885a23b2fb22479c8a159cb9a6 100644 (file)
@@ -22,7 +22,7 @@ void CreateGreedyRefLB();
 
 class GreedyRefLB : public GreedyLB {
 public:
-  GreedyRefLB();
+  GreedyRefLB(const CkLBOptions &);
   GreedyRefLB(CkMigrateMessage *m):GreedyLB(m) {}
 private:
   void work(CentralLB::LDStats* stats, int count);
index 07a38736b32d35ca34e6bfd067624d2a339978b8..e211782c72a53560e609aced6b971f2250047f65 100644 (file)
@@ -34,10 +34,11 @@ void LBDB::batsyncer::gotoSync(void *bs)
 void LBDB::batsyncer::resumeFromSync(void *bs)
 {
   LBDB::batsyncer *s=(LBDB::batsyncer *)bs;
-  // CmiPrintf("[%d] with PERIOD: %f\n", CkMyPe(), s->period);
+//  CmiPrintf("[%d] LBDB::batsyncer::resumeFromSync with %gs\n", CkMyPe(), s->period);
   CcdCallFnAfterOnPE((CcdVoidFn)gotoSync,(void *)s,(int)(1000*s->period), CkMyPe());
 }
 
+// initPeriod in seconds
 void LBDB::batsyncer::init(LBDB *_db,double initPeriod)
 {
   db=_db;
@@ -59,8 +60,8 @@ LBDB::LBDB(): useBarrier(CmiTrue)
     obj_running = CmiFalse;
     commTable = new LBCommTable;
     obj_walltime = obj_cputime = 0;
-    batsync.init(this, autoLbPeriod);          // original 1.0
     startLBFn_count = 0;
+    batsync.init(this, autoLbPeriod);          // original 1.0 second
 }
 
 LDOMHandle LBDB::AddOM(LDOMid _userID, void* _userData, 
@@ -242,7 +243,7 @@ void LBDB::Migrated(LDObjHandle h)
 
   for(int i=0; i < migrateCBList.length(); i++) {
     MigrateCB* cb = (MigrateCB*)migrateCBList[i];
-    if (cb) (cb->fn)(cb->data,h);
+    if (cb && cb->on) (cb->fn)(cb->data,h);
   }
   
 }
@@ -299,7 +300,7 @@ void LBDB::StartLB()
   }
   for (int i=0; i<startLBFnList.length(); i++) {
     StartLBCB *startLBFn = startLBFnList[i];
-    if (startLBFn) startLBFn->fn(startLBFn->data);
+    if (startLBFn && startLBFn->on) startLBFn->fn(startLBFn->data);
   }
 }
 
@@ -438,11 +439,13 @@ void LocalBarrier::CallReceivers(void)
   CmiBool called_receiver=CmiFalse;
 
 //  for(int i=0; i < max_receiver; i++)
-    for (int i=max_receiver-1; i>=0; i--)
-      if (receivers[i] != 0) {
-        ((receiver*)receivers[i])->fn(((receiver*)receivers[i])->data);
+   for (int i=max_receiver-1; i>=0; i--) {
+      receiver *recv = receivers[i];
+      if (recv != 0 && recv->on) {
+        recv->fn(recv->data);
         called_receiver = CmiTrue;
       }
+  }
 
   if (!called_receiver)
     ResumeClients();
index 3b9c3282a1b19fce6fdcda9b3347a121a35d2a84..510ea4495d2bebc9a286c0012751e064d46cb1bb 100644 (file)
@@ -49,7 +49,7 @@ private:
     LDResumeFn fn;
     int refcount;
   };
-   struct receiver {
+  struct receiver {
     void* data;
     LDBarrierFn fn;
     int on;
@@ -84,17 +84,24 @@ public:
   void RegisteringObjects(LDOMHandle _h);
   void DoneRegisteringObjects(LDOMHandle _h);
 
-  inline void LocalBarrierOn() { localBarrier.TurnOn();}
-  inline void LocalBarrierOff() { localBarrier.TurnOff();}
+  inline void LocalBarrierOn() 
+       { localBarrier.TurnOn();}
+  inline void LocalBarrierOff() 
+       { localBarrier.TurnOff();}
 
-  inline LBOM *LbOM(LDOMHandle h) { return oms[h.handle]; };
-  inline LBObj *LbObj(const LDObjHandle &h) const { return objs[h.handle]; };
+  inline LBOM *LbOM(LDOMHandle h) 
+       { return oms[h.handle]; };
+  inline LBObj *LbObj(const LDObjHandle &h) const 
+       { return objs[h.handle]; };
   void DumpDatabase(void);
+
   inline void TurnStatsOn(void) 
        {statsAreOn = CmiTrue; machineUtil.StatsOn();}
   inline void TurnStatsOff(void) 
        {statsAreOn = CmiFalse;machineUtil.StatsOff();}
-  inline CmiBool StatsOn(void) const { return statsAreOn; };
+  inline CmiBool StatsOn(void) const 
+       { return statsAreOn; };
+
   void Send(const LDOMHandle &destOM, const LDObjid &destid, unsigned int bytes);
   int ObjDataCount();
   void GetObjData(LDObjData *data);
@@ -115,8 +122,11 @@ public:
        { migrateCBList[handle]->on = 0; }
   void RemoveNotifyMigrated(int handle);
 
-  inline void TurnManualLBOn() { useBarrier = CmiFalse; }
-  inline void TurnManualLBOff() { useBarrier = CmiTrue; }
+  inline void TurnManualLBOn() 
+       { useBarrier = CmiFalse; }
+  inline void TurnManualLBOff() 
+       { useBarrier = CmiTrue; }
+
   int AddStartLBFn(LDStartLBFn fn, void* data);
   void TurnOnStartLBFn(int handle)
        { startLBFnList[handle]->on = 1; }
index c386beedfea45574d7debb170210d611f41de688..2f17eb5aa7d366e91cb39a38fbc01808ef2e130b 100644 (file)
@@ -28,82 +28,104 @@ CkpvDeclare(int, numLoadBalancers);  /**< num of lb created */
 CkpvDeclare(int, hasNullLB);         /**< true if NullLB is created */
 CkpvDeclare(int, lbdatabaseInited);  /**< true if lbdatabase is inited */
 
-double autoLbPeriod = 1.0;
+// command line options
+double autoLbPeriod = 0.0;             // in seconds
 int lb_debug=0;
 int lb_ignoreBgLoad=0;
 
-static LBDefaultCreateFn defaultCreate=NULL;
-void LBSetDefaultCreate(LBDefaultCreateFn f)
-{
-  if (defaultCreate) CmiAbort("Error: try to create multiple load balancer strategies!");
-  defaultCreate=f;
-}
-
 class LBDBResgistry {
+friend class LBDBInit;
 private:
-  class LBDBEntry {
-  public:
+  // table for all available LBs linked in
+  struct LBDBEntry {
     const char *name;
-    LBDefaultCreateFn  fn;
+    LBCreateFn  fn;
     const char *help;
-
-    LBDBEntry(): name(0), fn(0), help(0) {}
+    int        shown;          // if 0, donot show in help page
+    LBDBEntry(): name(0), fn(0), help(0), shown(1) {}
     LBDBEntry(int) {}
-    LBDBEntry(const char *n, LBDefaultCreateFn f, const char *h):
-      name(n), fn(f), help(h) {};
+    LBDBEntry(const char *n, LBCreateFn f, const char *h, int show=1):
+      name(n), fn(f), help(h), shown(show) {};
   };
-  CkVec<LBDBEntry> lbtables;    // a list of available LBs
-  char *defaultBalancer;
+  CkVec<LBDBEntry> lbtables;           // a list of available LBs linked
+  CkVec<const char *>   compile_lbs;   // load balancers at compile time
+  CkVec<const char *>   runtime_lbs;   // load balancers at run time
 public:
-  LBDBResgistry() { defaultBalancer=NULL; }
+  LBDBResgistry() {}
   void displayLBs()
   {
     CmiPrintf("\nAvailable load balancers:\n");
     for (int i=0; i<lbtables.length(); i++) {
-      CmiPrintf("* %s: %s\n", lbtables[i].name, lbtables[i].help);
+      LBDBEntry &entry = lbtables[i];
+      if (entry.shown) CmiPrintf("* %s:        %s\n", entry.name, entry.help);
     }
     CmiPrintf("\n");
   }
-  void add(const char *name, LBDefaultCreateFn fn, const char *help) {
-    lbtables.push_back(LBDBEntry(name, fn, help));
+  void addEntry(const char *name, LBCreateFn fn, const char *help, int shown) {
+    lbtables.push_back(LBDBEntry(name, fn, help, shown));
+  }
+  void addCompiletimeBalancer(const char *name) {
+    compile_lbs.push_back(name); 
   }
-  LBDefaultCreateFn search(const char *name) {
+  void addRuntimeBalancer(const char *name) {
+    runtime_lbs.push_back(name); 
+  }
+  LBCreateFn search(const char *name) {
     for (int i=0; i<lbtables.length(); i++)
       if (0==strcmp(name, lbtables[i].name)) return lbtables[i].fn;
     return NULL;
   }
-  char *& defaultLB() { return defaultBalancer; };
 };
 
-static LBDBResgistry  lbRegistry;
+static LBDBResgistry lbRegistry;
 
-void LBRegisterBalancer(const char *name, LBDefaultCreateFn fn, const char *help)
+void LBDefaultCreate(const char *lbname)
 {
-  lbRegistry.add(name, fn, help);
+  lbRegistry.addCompiletimeBalancer(lbname);
 }
 
-LBDBInit::LBDBInit(CkArgMsg *m)
+// default is to show the helper
+void LBRegisterBalancer(const char *name, LBCreateFn fn, const char *help, int shown)
 {
-#if CMK_LBDB_ON
-  lbdb = CProxy_LBDatabase::ckNew();
-
-  LBDefaultCreateFn lbFn = defaultCreate;
+  lbRegistry.addEntry(name, fn, help, shown);
+}
 
-  char *balancer = lbRegistry.defaultLB();
-  if (balancer) {
-    LBDefaultCreateFn fn = lbRegistry.search(balancer);
+// create a load balancer group using the strategy name
+static void createLoadBalancer(const char *lbname)
+{
+    LBCreateFn fn = lbRegistry.search(lbname);
     if (!fn) {
+      CmiPrintf("Abort: Unknown load balancer: '%s'!\n", lbname);
       lbRegistry.displayLBs();
-      CmiPrintf("Abort: Unknown load balancer: '%s'!\n", balancer);
       CkExit();
     }
-    else  // overwrite defaultCreate.
-      lbFn = fn;
-  }
+    fn();
+}
 
-  // NullLB is the default
-  if (!lbFn) lbFn = CreateNullLB;
-  (lbFn)();
+LBDBInit::LBDBInit(CkArgMsg *m)
+{
+#if CMK_LBDB_ON
+  lbdb = CProxy_LBDatabase::ckNew();
+
+  // runtime specified load balancer
+  if (lbRegistry.runtime_lbs.size() > 0) {
+    for (int i=0; i<lbRegistry.runtime_lbs.size(); i++) {
+      const char *balancer = lbRegistry.runtime_lbs[i];
+      createLoadBalancer(balancer);
+    }
+  }
+  else if (lbRegistry.compile_lbs.size() > 0) {
+    for (int i=0; i<lbRegistry.compile_lbs.size(); i++) {
+      const char* balancer = lbRegistry.compile_lbs[i];
+      createLoadBalancer(balancer);
+    }
+  }
+  else {
+    // NullLB is the default
+    // user may create his own load balancer in his code, but never mind
+    // NullLB can disable itself if there is a non NULL LB.
+    createLoadBalancer("NullLB");
+  }
 
   if (LBSimulation::doSimulation) {
     CmiPrintf("Charm++> Entering Load Balancer Simulation Mode ... \n");
@@ -126,13 +148,13 @@ void _loadbalancerInit()
   char **argv = CkGetArgv();
   char *balancer = NULL;
   CmiArgGroup("Charm++","Load Balancer");
-  if (CmiGetArgStringDesc(argv, "+balancer", &balancer, "Use this load balancer")) {
-    lbRegistry.defaultLB() = balancer;
+  while (CmiGetArgStringDesc(argv, "+balancer", &balancer, "Use this load balancer")) {
+    lbRegistry.addRuntimeBalancer(balancer);
   }
 
-  // set up init value for LBPeriod time in milliseconds
+  // set up init value for LBPeriod time in seconds
   // it can also be set calling LDSetLBPeriod()
-  CmiGetArgDoubleDesc(argv,"+LBPeriod", &autoLbPeriod,"specify the period for automatic load balancing (non atSync mode)");
+  CmiGetArgDoubleDesc(argv,"+LBPeriod", &autoLbPeriod,"specify the period for automatic load balancing in seconds (for non atSync mode)");
 
   /******************* SIMULATION *******************/
   // get the step number at which to dump the LB database
@@ -147,7 +169,7 @@ void _loadbalancerInit()
   lb_ignoreBgLoad = CmiGetArgFlagDesc(argv, "+LBObjOnly", "Load balancer only balance migratable object without considering the background load, etc");
   if (CkMyPe() == 0) {
     if (lb_debug) {
-      CmiPrintf("LB> Load balancer running with verbose mode, period time: %gms.\n", autoLbPeriod);
+      CmiPrintf("LB> Load balancer running with verbose mode, period time: %gs.\n", autoLbPeriod);
     }
     if (lb_ignoreBgLoad)
       CmiPrintf("LB> Load balancer only balance migratable object.\n");
@@ -162,6 +184,9 @@ void LBDatabase::init(void)
 {
   myLDHandle = LDCreate();
 
+  mystep = 0;
+  nloadbalancers = 0;
+
   int num_proc = CkNumPes();
   avail_vector = new char[num_proc];
   for(int proc = 0; proc < num_proc; proc++)
@@ -202,6 +227,44 @@ void LBDatabase::set_avail_vector(char * bitmap, int new_ld){
     }
 }
 
+int LBDatabase::getLoadbalancerTicket()  { 
+  int seq = nloadbalancers;
+  nloadbalancers ++;
+  loadbalancers.growAtLeast(nloadbalancers); 
+  loadbalancers[seq] = NULL;
+  return seq; 
+}
+
+void LBDatabase::addLoadbalancer(BaseLB *lb, int seq) {
+//  CmiPrintf("[%d] addLoadbalancer for seq %d\n", CkMyPe(), seq);
+  if (seq == -1) return;
+  if (CkMyPe() == 0) {
+    CmiAssert(seq < nloadbalancers);
+    if (loadbalancers[seq]) {
+      CmiPrintf("Duplicate load balancer created at %d\n", seq);
+      CmiAbort("LBDatabase");
+    }
+  }
+  else
+    nloadbalancers ++;
+  loadbalancers.growAtLeast(seq); 
+  loadbalancers[seq] = lb;
+}
+
+void LBDatabase::nextLoadbalancer(int seq) {
+  if (seq == -1) return;               // -1 means this is the only LB
+  int next = seq+1;
+  if (next == nloadbalancers) next --;
+  CmiAssert(loadbalancers[next]);
+  if (seq != next) {
+    loadbalancers[seq]->turnOff();
+    loadbalancers[next]->turnOn();
+  }
+}
+
+/*
+  callable from user's code
+*/
 void TurnManualLBOn()
 {
 #if CMK_LBDB_ON
index 66d73c5a695c821300e686c8c063abd2e796dde9..157ad175f4badbf2ee03e502faa7726de26ddd5c 100644 (file)
 #define LBDATABASE_H
 
 #include "lbdb.h"
+
+class CkLBOptions
+{
+private:
+  int seqno;
+public:
+  CkLBOptions(): seqno(-1) {}
+  CkLBOptions(int s): seqno(s) {}
+  int getSeqNo() const { return seqno; }
+};
+PUPbytes(CkLBOptions);
+                                                                                
 #include "LBDatabase.decl.h"
 
 extern CkGroupID lbdb;
@@ -28,10 +40,10 @@ extern double autoLbPeriod;
 extern int lb_debug;
 extern int lb_ignoreBgLoad;
 
-typedef void (*LBDefaultCreateFn)(void);
-void LBSetDefaultCreate(LBDefaultCreateFn f);
+typedef void (*LBCreateFn)();
+void LBDefaultCreate(LBCreateFn f);
 
-void LBRegisterBalancer(const char *, LBDefaultCreateFn, const char *);
+void LBRegisterBalancer(const char *, LBCreateFn, const char *, int shown=1);
 
 void _LBDBInit();
 
@@ -43,8 +55,6 @@ class LBDBInit : public Chare {
 
 
 class LBDatabase : public IrrGroup {
-public:
-  static int manualOn;
 public:
   LBDatabase(void)  { init(); }
   LBDatabase(CkMigrateMessage *m)  { init(); }
@@ -118,6 +128,7 @@ public:
     LDRemoveStartLBFn(myLDHandle,fn);
   };
 
+public:
   inline void StartLB() { LDStartLB(myLDHandle); }
   inline void TurnManualLBOn() { LDTurnManualLBOn(myLDHandle); }
   inline void TurnManualLBOff() { LDTurnManualLBOff(myLDHandle); }
@@ -172,16 +183,24 @@ public:
   inline int ProcessorSpeed() { return LDProcessorSpeed(); };
   inline void SetLBPeriod(double s) { LDSetLBPeriod(myLDHandle, s);}
   inline double GetLBPeriod() { return LDGetLBPeriod(myLDHandle);}
+
 private:
+  int mystep;
   LDHandle myLDHandle;
   char *avail_vector;                  // processor bit vector
   int new_ld_balancer;         // for Node 0
+  CkVec<BaseLB *>   loadbalancers;
+  int nloadbalancers;
+
+public:
+  static int manualOn;
+
 public:
   char *availVector() { return avail_vector; }
   void get_avail_vector(char * bitmap);
   void set_avail_vector(char * bitmap, int new_ld=-1);
   int & new_lbbalancer() { return new_ld_balancer; }
-public:
+
   struct LastLBInfo {
     double *expectedLoad;
     LastLBInfo() { expectedLoad=new double[CkNumPes()]; 
@@ -191,6 +210,13 @@ public:
   inline double myExpectedLoad() { return lastLBInfo.expectedLoad[CkMyPe()]; }
   inline double* expectedLoad() { return lastLBInfo.expectedLoad; }
   inline int useMem() { return LDMemusage(myLDHandle); }
+
+  int getLoadbalancerTicket();
+  void addLoadbalancer(BaseLB *lb, int seq);
+  void nextLoadbalancer(int seq);
+
+  inline int step() { return mystep; }
+  inline void incStep() { mystep++; }
 };
 
 void TurnManualLBOn();
index 53dfc1da92c62f72493903c20a4fb7372afc19f5..50616e7336dad718191dfd140593f5b5ca8bf2cd 100644 (file)
 
 #include "MetisLB.h"
 
-void CreateMetisLB()
-{
-  // CkPrintf("[%d] creating MetisLB %d\n",CkMyPe(),loadbalancer);
-  loadbalancer = CProxy_MetisLB::ckNew();
-  // CkPrintf("[%d] created MetisLB %d\n",CkMyPe(),loadbalancer);
-}
+CreateLBFunc_Def(MetisLB);
 
 static void lbinit(void) {
 //        LBSetDefaultCreate(CreateMetisLB);
@@ -32,7 +27,7 @@ static void lbinit(void) {
 
 #include "MetisLB.def.h"
 
-MetisLB::MetisLB()
+MetisLB::MetisLB(const CkLBOptions &opt): CentralLB(opt)
 {
   lbname = "MetisLB";
   if (CkMyPe() == 0)
index c48a72a79362644ca0d0e19f26249c1553878ad8..f0ba23fc7d9cc98cde86cdaad17f0dc3e33939bb 100644 (file)
@@ -3,7 +3,7 @@ module MetisLB {
 extern module CentralLB;
 initnode void lbinit(void);
 group [migratable] MetisLB : CentralLB {
-  entry void MetisLB(void);  
+  entry void MetisLB(const CkLBOptions &);  
 };
 
 };
index d19a3d32fabcbbaff38bf4f0ba65e5bc9c252742..ad43c2002b0b90b63eba83e1f13ecf307b8515b4 100644 (file)
@@ -20,7 +20,7 @@ void CreateMetisLB();
 
 class MetisLB : public CentralLB {
 public:
-  MetisLB();
+  MetisLB(const CkLBOptions &);
   MetisLB(CkMigrateMessage *m):CentralLB(m) {}
 private:
   CmiBool QueryBalanceNow(int step);
index f8d5a438becf6b975cb327c8d46abedbe5821654..739d6f64db27315a29defde8ff1d7bc4227d85ea 100644 (file)
 #include "NborBaseLB.h"
 #include "NborBaseLB.def.h"
 
-CkGroupID nborBaselb;
-
 #if CMK_LBDB_ON
 
-void CreateNborBaseLB()
-{
-  nborBaselb = CProxy_NborBaseLB::ckNew();
-}
+//CreateLBFunc_Def(NborBaseLB);
 
 void NborBaseLB::staticMigrated(void* data, LDObjHandle h)
 {
@@ -41,10 +36,11 @@ void NborBaseLB::staticAtSync(void* data)
   me->AtSync();
 }
 
-NborBaseLB::NborBaseLB()
+NborBaseLB::NborBaseLB(const CkLBOptions &opt): BaseLB(opt)
 {
   lbname = "NborBaseLB";
   mystep = 0;
+  thisProxy = CProxy_NborBaseLB(thisgroup);
   theLbdb->
     AddLocalBarrierReceiver((LDBarrierFn)(staticAtSync),
                            (void*)(this));
index b3b475921614f43b769d024618b3e150f1d8b04c..a5d0863108d30daf27ea7e320f04e4e80bf5e4b8 100644 (file)
@@ -3,15 +3,13 @@ module NborBaseLB {
 extern module LBDatabase;
 extern module BaseLB;
 
-readonly CkGroupID nborBaselb;
-
 message NLBStatsMsg {
   LDObjData objData[];
   LDCommData commData[];
 };
 
 group [migratable] NborBaseLB: BaseLB {
-  entry void NborBaseLB(void);  
+  entry void NborBaseLB(const CkLBOptions &);  
   entry void ReceiveStats(NLBStatsMsg*);
   entry void ResumeClients(void);
   entry void ReceiveMigration(LBMigrateMsg*);  
index d5460040303cdabaacadd1db6ba46dd75f129187..a24403cae51cda9b35136f6c248c8ededaee79d2 100644 (file)
@@ -16,8 +16,6 @@
 #include <BaseLB.h>
 #include "NborBaseLB.decl.h"
 
-extern CkGroupID nborBaselb;
-
 void CreateNborBaseLB();
 
 /// for backward compatibility
@@ -25,11 +23,13 @@ typedef LBMigrateMsg NLBMigrateMsg;
 
 class NLBStatsMsg;
 
-class NborBaseLB : public CBase_NborBaseLB
+class NborBaseLB : public BaseLB
 {
+private:
+  CProxy_NborBaseLB  thisProxy;
 public:
-  NborBaseLB();
-  NborBaseLB(CkMigrateMessage *m):CBase_NborBaseLB(m) {}
+  NborBaseLB(const CkLBOptions &);
+  NborBaseLB(CkMigrateMessage *m):BaseLB(m) {}
   ~NborBaseLB();
 
   int useDefCtor(void){ return 1; }
index 5d970bb54f7527148f828243c39b81cc6c90d8c2..0cd1481329895b3032d8ba74ab15cfa99fa52fec 100644 (file)
 #include "heap.h"
 #include "NeighborLB.h"
 
-void CreateNeighborLB()
-{
-  nborBaselb = CProxy_NeighborLB::ckNew();
-}
+CreateLBFunc_Def(NeighborLB);
 
 static void lbinit(void) {
 //  LBSetDefaultCreate(CreateNeighborLB);        
@@ -31,7 +28,7 @@ static void lbinit(void) {
 
 #include "NeighborLB.def.h"
 
-NeighborLB::NeighborLB()
+NeighborLB::NeighborLB(const CkLBOptions &opt):NborBaseLB(opt)
 {
   lbname = "NeighborLB";
   if (CkMyPe() == 0)
index 37546792b8eb7d36b8c56b60aeafc83d62d9339b..22d7b3a02cd58a2fd655ec317c135f0b608456e9 100644 (file)
@@ -3,7 +3,7 @@ module NeighborLB {
 extern module NborBaseLB;
 initnode void lbinit(void);
 group [migratable] NeighborLB : NborBaseLB {
-  entry void NeighborLB(void);  
+  entry void NeighborLB(const CkLBOptions &);  
 };
 
 };
index c16b17de1c9495c6a65b8bba7cebe507f359bf6b..0548025dc6bc7b88495e5853cea1b3f368092026 100644 (file)
@@ -22,7 +22,7 @@ void CreateNeighborLB();
 
 class NeighborLB : public NborBaseLB {
 public:
-  NeighborLB();
+  NeighborLB(const CkLBOptions &);
   NeighborLB(CkMigrateMessage *m):NborBaseLB(m) {}
 private:
   CmiBool QueryBalanceNow(int step) { return CmiTrue; };
index 45ba67a0690311bf6bda384f05f9b56bdd8cf2ca..759a287bbdf90b4ea7425589d44a34c5771c352b 100644 (file)
@@ -7,22 +7,24 @@
 
 /**
  * \addtogroup CkLdb
+
+NullLB is a place holder load balancer, it does nothing but resume from 
+atSync so that application won't hang in the case where there is no other
+load balancer around.
 */
 /*@{*/
 
 #include <charm++.h>
 #include <BaseLB.h>
 #include "NullLB.h"
+#include "ck.h"
 
-void CreateNullLB(void)
-{
-  CProxy_NullLB::ckNew();
+void CreateNullLB(void) {
+  CProxy_NullLB::ckNew(-1);
 }
 
-static void initNullLB(void) {
-#if CMK_LBDB_ON
-//  LBSetDefaultCreate(CreateNullLB);
-#endif
+static void lbinit(void) {
+  LBRegisterBalancer("NullLB", CreateNullLB, "should not be shown", 0);
 }
 
 #if CMK_LBDB_ON
@@ -31,11 +33,11 @@ static void staticStartLB(void* data)
   CmiPrintf("[%d] LB Info: StartLB called in NullLB.\n", CkMyPe());
 }
 
-void NullLB::init(void)
+void NullLB::init()
 {
   // if (CkMyPe() == 0) CkPrintf("[%d] NullLB created\n",CkMyPe());
+  thisProxy = CProxy_NullLB(thisgroup);
   CkpvAccess(hasNullLB) = 1;
-  theLbdb=CProxy_LBDatabase(lbdb).ckLocalBranch();
   receiver = theLbdb->
     AddLocalBarrierReceiver((LDBarrierFn)(staticAtSync),
                            (void*)(this));
@@ -45,7 +47,6 @@ void NullLB::init(void)
 
 NullLB::~NullLB()
 {
-  theLbdb=CProxy_LBDatabase(lbdb).ckLocalBranch();
   theLbdb->RemoveLocalBarrierReceiver(receiver);
   theLbdb->RemoveStartLBFn((LDStartLBFn)(staticStartLB));
 }
@@ -63,14 +64,21 @@ void NullLB::staticAtSync(void* data)
 void NullLB::AtSync()
 {
   //Reset the database so it doesn't waste memory
-  theLbdb->ClearLoads();
+  // if nobody else is here, the stat collection is not even turned on
+  // so I should not have to clear loads.
+//  theLbdb->ClearLoads();
   
+  // disable the batsyncer if no balancer exists
+  theLbdb->SetLBPeriod(1e10);
+
   //We don't *do* any migrations, so they're already done!
+  CpvAccess(_qd)->create(-1);
   thisProxy[CkMyPe()].migrationsDone();
 }
 
 void NullLB::migrationsDone(void)
 {
+  CpvAccess(_qd)->process(-1);
   theLbdb->ResumeClients();
 }
 #else
index 20aed611c53215d3331ef8511bcfc152190df851..db2edd36cd96e68401370f5eee1c218071344a04 100644 (file)
@@ -2,10 +2,11 @@ module NullLB {
 
 extern module LBDatabase;
 extern module BaseLB;
-initnode void initNullLB(void);
+
+initnode void lbinit(void);
 
 group [migratable] NullLB: BaseLB {
-  entry void NullLB(void);  
+  entry void NullLB(const CkLBOptions &);  
   entry void migrationsDone(void);
 };
 
index 21dfe94a9405f969655e1db88522122a1d26298a..199ea7946d485092bca11e9f06b48722c06f040a 100644 (file)
 #include <BaseLB.h>
 #include "NullLB.decl.h"
 
-void CreateNullLB(void);
-
 /**
  NullLB is inherited from BaseLB. It has all the strategy's API, 
  but doing nothing but resume from sync
  NullLB only is functioning when there is no other strategy created.
 */
-class NullLB : public CBase_NullLB
+class NullLB : public BaseLB
 {
-  void init(void);
 public:
-  NullLB() {init(); lbname="NullLB";}
-  NullLB(CkMigrateMessage *m):CBase_NullLB(m) {init(); lbname="NullLB";}
+  NullLB(const CkLBOptions &opt): BaseLB(opt) 
+       {init(); lbname="NullLB";}
+  NullLB(CkMigrateMessage *m):BaseLB(m) 
+       {init(); lbname="NullLB";}
   ~NullLB();
 
   static void staticAtSync(void*);
   void AtSync(void); // Everything is at the PE barrier
 
   void migrationsDone(void);
+private:
+  CProxy_NullLB   thisProxy;
+  void init();
 };
 
 #endif /* def(thisHeader) */
index 78d9159f2dd9c0d8c6e471a04e168187b6d58bfd..1c0421aa58ed9e21b5f934cb4f2b7712e1cfd00f 100644 (file)
 
 //#define DEBUG
 
-void CreateOrbLB()
-{
-  loadbalancer = CProxy_OrbLB::ckNew();
-}
+CreateLBFunc_Def(OrbLB);
 
 static void lbinit(void) {
   LBRegisterBalancer("OrbLB", CreateOrbLB, "partition objects based on coordinates");
@@ -34,7 +31,7 @@ static void lbinit(void) {
 
 #include "OrbLB.def.h"
 
-OrbLB::OrbLB()
+OrbLB::OrbLB(const CkLBOptions &opt): CentralLB(opt)
 {
   lbname = "OrbLB";
   if (CkMyPe() == 0)
index 4bf397aa065d2e1dc18997bc39aad2562e7a854a..be95f628cb56aac0017e4543541e0a02f9067fd6 100644 (file)
@@ -3,7 +3,7 @@ module OrbLB {
 extern module CentralLB;
 initnode void lbinit(void);
 group [migratable] OrbLB : CentralLB {
-  entry void OrbLB(void);  
+  entry void OrbLB(const CkLBOptions &);  
 };
 
 };
index 0a5c6d33adfcae8584ef5e94a01156fc7ed42e8e..99273f3585db7573889844721f040e5af5bab21e 100644 (file)
@@ -72,7 +72,7 @@ public:
   double overLoad;
 
 public:
-  OrbLB();
+  OrbLB(const CkLBOptions &);
   OrbLB(CkMigrateMessage *m):CentralLB(m) {}
 private:
   CmiBool QueryBalanceNow(int step);
index 1428cdda7238ff5bb3ea3dcff606568c08744188..5614f79ffe1e5bc0ca117274323b7a6d45bbfa21 100644 (file)
@@ -24,20 +24,14 @@ Status:
 
 #include "RandCentLB.h"
 
-void CreateRandCentLB()
-{
-  //  CkPrintf("[%d] creating RandCentLB %d\n",CkMyPe(),loadbalancer);
-  loadbalancer = CProxy_RandCentLB::ckNew();
-  //  CkPrintf("[%d] created RandCentLB %d\n",CkMyPe(),loadbalancer);
-}
+CreateLBFunc_Def(RandCentLB);
 
 static void lbinit(void) {
-//     LBSetDefaultCreate(CreateRandCentLB);
   LBRegisterBalancer("RandCentLB", CreateRandCentLB, "Assign objects to processors randomly");
 }
 #include "RandCentLB.def.h"
 
-RandCentLB::RandCentLB()
+RandCentLB::RandCentLB(const CkLBOptions &opt): CentralLB(opt)
 {
   lbname = "RandCentLB";
   if (CkMyPe() == 0)
index 18a844cc911755d0ad5d76b928132cb9a7dc344b..6d7212c2e5677d6ac446cafe3e4b3559e500d39a 100644 (file)
@@ -3,7 +3,7 @@ module RandCentLB {
 extern module CentralLB;
 initnode void lbinit(void);
 group [migratable] RandCentLB : CentralLB {
-  entry void RandCentLB(void);  
+  entry void RandCentLB(const CkLBOptions &);  
 };
 
 };
index 6f445dc421d1e7eac2f6b2944399fda8e8f1690e..2206b41312e435fed26d2886a273199a82dfa744 100644 (file)
@@ -20,7 +20,7 @@ void CreateRandCentLB();
 
 class RandCentLB : public CentralLB {
 public:
-  RandCentLB();
+  RandCentLB(const CkLBOptions &);
   RandCentLB(CkMigrateMessage *m):CentralLB(m) {}
   void work(CentralLB::LDStats* stats, int count);
 private:
index 84a3af1247196edecdb8b7c4f57e508919d3aa79..0365c821a31133b11e931499d45f5e9768cceb26 100644 (file)
 
 #include "RandRefLB.h"
 
-void CreateRandRefLB()
-{
-  //  CkPrintf("[%d] creating RandRefLB %d\n",CkMyPe(),loadbalancer);
-  loadbalancer = CProxy_RandRefLB::ckNew();
-  //  CkPrintf("[%d] created RandRefLB %d\n",CkMyPe(),loadbalancer);
-}
+CreateLBFunc_Def(RandRefLB);
 
 static void lbinit(void) {
 //        LBSetDefaultCreate(CreateRandRefLB);
@@ -33,7 +28,7 @@ static void lbinit(void) {
 
 #include "RandRefLB.def.h"
 
-RandRefLB::RandRefLB()
+RandRefLB::RandRefLB(const CkLBOptions &opt): RandCentLB(opt)
 {
   lbname = "RandRefLB";
   if (CkMyPe() == 0)
index 8f42447f12edfaac4b2103809c8787d60d3c7fde..0c3bb3b3757daec9be8ad597cb55970fcb943136 100644 (file)
@@ -3,7 +3,7 @@ module RandRefLB {
 extern module CentralLB;
 initnode void lbinit(void);
 group [migratable] RandRefLB : CentralLB {
-  entry void RandRefLB(void);  
+  entry void RandRefLB(const CkLBOptions &);  
 };
 
 };
index 992f2b9f2eaeb8f1778ec078b99995fc378ca9aa..b6b701ba3a344a15165c16757ee421dfb0d0692e 100644 (file)
@@ -21,7 +21,7 @@ void CreateRandRefLB();
 
 class RandRefLB : public RandCentLB {
 public:
-  RandRefLB();
+  RandRefLB(const CkLBOptions &);
   RandRefLB(CkMigrateMessage *m):RandCentLB(m) {}
   void work(CentralLB::LDStats* stats, int count);
 };
index 0249c0cb0779426c2ecb58a8cc43c0ee724a9574..6abc481573a42f4a07a2c12f12f687166b9f36ad 100644 (file)
@@ -48,12 +48,7 @@ extern "C" {
 
 
 
-void CreateRecBisectBfLB()
-{
-  //  CkPrintf("[%d] creating RecBisectBfLB %d\n",CkMyPe(),loadbalancer);
-  loadbalancer = CProxy_RecBisectBfLB::ckNew();
-  //  CkPrintf("[%d] created RecBisectBfLB %d\n",CkMyPe(),loadbalancer);
-}
+CreateLBFunc_Def(RecBisectBfLB);
 
 static void lbinit(void) {
 //        LBSetDefaultCreate(CreateRecBisectBfLB);
@@ -62,7 +57,7 @@ static void lbinit(void) {
 
 #include "RecBisectBfLB.def.h"
 
-RecBisectBfLB::RecBisectBfLB()
+RecBisectBfLB::RecBisectBfLB(const CkLBOptions &opt): CentralLB(opt)
 {
   lbname = "RecBisectBfLB";
   if (CkMyPe() == 0)
index 725e762544c05ec25d73894bfa984103a253da6f..349ad7dc5b798720e397d59324a805351001301f 100644 (file)
@@ -3,7 +3,7 @@ module RecBisectBfLB {
 extern module CentralLB;
 initnode void lbinit(void);
 group [migratable] RecBisectBfLB : CentralLB {
-  entry void RecBisectBfLB(void);  
+  entry void RecBisectBfLB(const CkLBOptions &);  
 };
 
 };
index f7ce332393e604de21c14cede83ec5ed2911fa63..bb134fa4d59cd9d9213ad7d2ac94990969dbdeb2 100644 (file)
@@ -40,7 +40,7 @@ typedef struct {
 
 class RecBisectBfLB : public CentralLB {
 public:
-  RecBisectBfLB();
+  RecBisectBfLB(const CkLBOptions &);
   RecBisectBfLB(CkMigrateMessage *m):CentralLB(m) {}
 private:
   CmiBool QueryBalanceNow(int step);
index eba6f2e74492637f0d39179c14825cd9ee83bdc4..53a8a20206c0e19089fee66836607f542fb68841 100644 (file)
 
 #include "RefineLB.h"
 
-void CreateRefineLB()
-{
-  loadbalancer = CProxy_RefineLB::ckNew();
-  //  CkPrintf("[%d] created RefineLB %d\n",CkMyPe(),loadbalancer);
-}
+CreateLBFunc_Def(RefineLB);
 
 static void lbinit(void) {
-//  LBSetDefaultCreate(CreateRefineLB);        
   LBRegisterBalancer("RefineLB", CreateRefineLB, "Move objects away from overloaded processor to reach average");
 }
 
 #include "RefineLB.def.h"
 
-RefineLB::RefineLB()
+RefineLB::RefineLB(const CkLBOptions &opt): CentralLB(opt)
 {
   lbname = "RefineLB";
   if (CkMyPe() == 0)
index ffe2ecb48db8de03bbc937c473a0128a3d0ca36f..4c1a9038f55ee6fab2dea30efa23ee9a4dabf252 100644 (file)
@@ -3,7 +3,7 @@ module RefineLB {
 extern module CentralLB;
 initnode void lbinit(void);
 group [migratable] RefineLB : CentralLB {
-  entry void RefineLB(void);  
+  entry void RefineLB(const CkLBOptions &);  
 };
 
 };
index 2f5f48520f4b11bf8ab9939f91781ab47af70860..626f72ff2453455bc692967eeed82e01393a8f8b 100644 (file)
@@ -39,7 +39,7 @@ public:
   double overLoad;
 
 public:
-  RefineLB();
+  RefineLB(const CkLBOptions &);
   RefineLB(CkMigrateMessage *m):CentralLB(m) {}
 private:
   CmiBool QueryBalanceNow(int step);
index 42aea92adea6706cef47892bb9a25fb67f256846..04942a0b663283514dceb564b7f3217bd00a6da1 100644 (file)
@@ -19,8 +19,6 @@
 #include "heap.h"
 #include "WSLB.h"
 
-CkGroupID wslb;
-
 #if CMK_LBDB_ON
 
 // Temporary vacating flags
@@ -31,10 +29,7 @@ CkGroupID wslb;
 #define VACATE_AFTER 30
 #define UNVACATE_AFTER 15
 
-void CreateWSLB()
-{
-  wslb = CProxy_WSLB::ckNew();
-}
+CreateLBFunc_Def(WSLB);
 
 void WSLB::staticMigrated(void* data, LDObjHandle h)
 {
@@ -50,8 +45,9 @@ void WSLB::staticAtSync(void* data)
   me->AtSync();
 }
 
-WSLB::WSLB( 
+WSLB::WSLB(const CkLBOptions &opt) : BaseLB(opt) 
 {
+  thisProxy = CProxy_WSLB(thisgroup);
   lbname = "WSLB";
   if (CkMyPe() == 0)
     CkPrintf("[%d] WSLB created\n",CkMyPe());
index da50a18881dd6a385bbdc64a439f31da69d5d725..0f40621317ded196f424a552cbb25ea8cf02c343 100644 (file)
@@ -3,12 +3,10 @@ module WSLB {
 extern module LBDatabase;
 extern module BaseLB;
 
-readonly CkGroupID wslb;
-
 message WSLBStatsMsg;
 
 group [migratable] WSLB: BaseLB {
-  entry void WSLB(void);  
+  entry void WSLB(const CkLBOptions&);  
   entry void ReceiveStats(WSLBStatsMsg*);
   entry void ResumeClients(void);
   entry void ReceiveMigration(LBMigrateMsg*);  
index b94c089bd8f01579836670a2b14a0e883ffe3562..bfabfce4504ebd9919a8c87ac421d175259b6b04 100644 (file)
@@ -20,11 +20,11 @@ void CreateWSLB();
 
 class WSLBStatsMsg;
 
-class WSLB : public CBase_WSLB
+class WSLB : public BaseLB
 {
 public:
-  WSLB();
-  WSLB(CkMigrateMessage *m):CBase_WSLB(m) {}
+  WSLB(const CkLBOptions &);
+  WSLB(CkMigrateMessage *m):BaseLB(m) {}
   ~WSLB();
   static void staticAtSync(void*);
   void AtSync(void); // Everything is at the PE barrier
@@ -97,6 +97,7 @@ private:
   void FindNeighbors();
   WSLBStatsMsg* AssembleStats();
 
+  CProxy_WSLB   thisProxy;
   int mystep;
   int stats_msg_count;
   WSLBStatsMsg** statsMsgsList;