Charm++: Charm Source Code Documentation

00001 
00005 
00006 #ifndef LBDB_H
00007 #define LBDB_H
00008 
00009 #include "converse.h"
00010 #include "lbdb.h"
00011 #include "cklists.h"
00012 
00013 #include "LBObj.h"
00014 #include "LBOM.h"
00015 #include "LBComm.h"
00016 #include "LBMachineUtil.h"
00017 
00018 class LocalBarrier {
00019 friend class LBDB;
00020 public:
00021   LocalBarrier() { cur_refcount = 1; client_count = 0; max_client = 0;
00022                    max_receiver= 0; at_count = 0; on = CmiFalse; 
00023         #if CMK_BIGSIM_CHARM
00024         first_free_client_slot = 0;
00025         #endif
00026     };
00027   ~LocalBarrier() { };
00028 
00029   LDBarrierClient AddClient(LDResumeFn fn, void* data);
00030   void RemoveClient(LDBarrierClient h);
00031   LDBarrierReceiver AddReceiver(LDBarrierFn fn, void* data);
00032   void RemoveReceiver(LDBarrierReceiver h);
00033   void TurnOnReceiver(LDBarrierReceiver h);
00034   void TurnOffReceiver(LDBarrierReceiver h);
00035   void AtBarrier(LDBarrierClient h);
00036   void TurnOn() { on = CmiTrue; CheckBarrier(); };
00037   void TurnOff() { on = CmiFalse; };
00038 
00039 private:
00040   void CallReceivers(void);
00041   void CheckBarrier();
00042   void ResumeClients(void);
00043 
00044   struct client {
00045     void* data;
00046     LDResumeFn fn;
00047     int refcount;
00048   };
00049   struct receiver {
00050     void* data;
00051     LDBarrierFn fn;
00052     int on;
00053   };
00054 
00055   CkVec<client*> clients;
00056   CkVec<receiver*> receivers;
00057 
00058   int cur_refcount;
00059   int max_client;
00060   int client_count;
00061   int max_receiver;
00062   int at_count;
00063   CmiBool on;
00064 
00065   #if CMK_BIGSIM_CHARM
00066   int first_free_client_slot;
00067   #endif
00068 };
00069 
00070 class LBDB {
00071 public:
00072   LBDB();
00073   ~LBDB() { }
00074 
00075   void SetPeriod(double secs) {batsync.setPeriod(secs);}
00076   double GetPeriod() {return batsync.getPeriod();}
00077 
00078   void insert(LBOM *om);
00079 
00080   LDOMHandle AddOM(LDOMid _userID, void* _userData, LDCallbacks _callbacks);
00081   LDObjHandle AddObj(LDOMHandle _h, LDObjid _id, void *_userData,
00082                      CmiBool _migratable);
00083   void UnregisterObj(LDObjHandle _h);
00084 
00085   void RegisteringObjects(LDOMHandle _h);
00086   void DoneRegisteringObjects(LDOMHandle _h);
00087 
00088   inline void LocalBarrierOn() 
00089        { localBarrier.TurnOn();}
00090   inline void LocalBarrierOff() 
00091        { localBarrier.TurnOff();}
00092 
00093   inline LBOM *LbOM(LDOMHandle h) 
00094        { return oms[h.handle]; };
00095   inline LBObj *LbObj(const LDObjHandle &h) const 
00096        { return objs[h.handle]; };
00097   inline LBObj *LbObjIdx(int h) const 
00098        { return objs[h]; };
00099   void DumpDatabase(void);
00100 
00101   inline void TurnStatsOn(void) 
00102        {statsAreOn = CmiTrue; machineUtil.StatsOn();}
00103   inline void TurnStatsOff(void) 
00104        {statsAreOn = CmiFalse;machineUtil.StatsOff();}
00105   inline CmiBool StatsOn(void) const 
00106        { return statsAreOn; };
00107 
00108   void SetupPredictor(LDPredictModelFn on, LDPredictWindowFn onWin, LDPredictFn off, LDPredictModelFn change, void* data);
00109   inline void TurnPredictorOn(void *model) {
00110     if (predictCBFn!=NULL) predictCBFn->on(predictCBFn->data, model);
00111     else CmiPrintf("Predictor not supported in this load balancer\n");
00112   }
00113   inline void TurnPredictorOn(void *model, int wind) {
00114     if (predictCBFn!=NULL) predictCBFn->onWin(predictCBFn->data, model, wind);
00115     else CmiPrintf("Predictor not supported in this load balancer\n");
00116   }
00117   inline void TurnPredictorOff(void) {
00118     if (predictCBFn!=NULL) predictCBFn->off(predictCBFn->data);
00119     else CmiPrintf("Predictor not supported in this load balancer\n");
00120   }
00121   /* the parameter model is really of class LBPredictorFunction in file LBDatabase.h */
00122   inline void ChangePredictor(void *model) {
00123     if (predictCBFn!=NULL) predictCBFn->change(predictCBFn->data, model);
00124     else CmiPrintf("Predictor not supported in this load balancer");
00125   }
00126 
00127   void Send(const LDOMHandle &destOM, const LDObjid &destid, unsigned int bytes, int destObjProc);
00128   void MulticastSend(const LDOMHandle &destOM, LDObjid *destids, int ndests, unsigned int bytes, int nMsgs);
00129   int ObjDataCount();
00130   void GetObjData(LDObjData *data);
00131   inline int CommDataCount() { 
00132     if (commTable)
00133       return commTable->CommCount();
00134     else return 0;
00135   }
00136   inline void GetCommData(LDCommData *data) 
00137        { if (commTable) commTable->GetCommData(data); };
00138 
00139   int  Migrate(LDObjHandle h, int dest);
00140   void Migrated(LDObjHandle h, int waitBarrier=1);
00141   int  NotifyMigrated(LDMigratedFn fn, void* data);
00142   void TurnOnNotifyMigrated(int handle)
00143        { migrateCBList[handle]->on = 1; }
00144   void TurnOffNotifyMigrated(int handle)
00145        { migrateCBList[handle]->on = 0; }
00146   void RemoveNotifyMigrated(int handle);
00147 
00148   inline void TurnManualLBOn() 
00149        { useBarrier = CmiFalse; }
00150   inline void TurnManualLBOff() 
00151        { useBarrier = CmiTrue; }
00152 
00153   int AddStartLBFn(LDStartLBFn fn, void* data);
00154   void TurnOnStartLBFn(int handle)
00155        { startLBFnList[handle]->on = 1; }
00156   void TurnOffStartLBFn(int handle)
00157        { startLBFnList[handle]->on = 0; }
00158   void RemoveStartLBFn(LDStartLBFn fn);
00159   void StartLB();
00160 
00161   int AddMigrationDoneFn(LDMigrationDoneFn fn, void* data);
00162   void RemoveMigrationDoneFn(LDMigrationDoneFn fn);
00163   void MigrationDone();
00164 
00165   inline void IdleTime(LBRealType* walltime) 
00166        { machineUtil.IdleTime(walltime); };
00167   inline void TotalTime(LBRealType* walltime, LBRealType* cputime) 
00168        { machineUtil.TotalTime(walltime,cputime); };
00169   void BackgroundLoad(LBRealType* walltime, LBRealType* cputime);
00170   void GetTime(LBRealType *total_walltime,LBRealType *total_cputime,
00171                    LBRealType *idletime, LBRealType *bg_walltime, LBRealType *bg_cputime);
00172   void ClearLoads(void);
00173 
00180   inline void SetRunningObj(const LDObjHandle &_h) 
00181        { runningObj = _h.handle; obj_running = CmiTrue; };
00182   inline const LDObjHandle &RunningObj() const 
00183        { return objs[runningObj]->GetLDObjHandle(); };
00184   inline void NoRunningObj() 
00185        { obj_running = CmiFalse; };
00186   inline CmiBool ObjIsRunning() const 
00187        { return obj_running; };
00188   
00189   inline LDBarrierClient AddLocalBarrierClient(LDResumeFn fn, void* data) 
00190        { return localBarrier.AddClient(fn,data); };
00191   inline void RemoveLocalBarrierClient(LDBarrierClient h) 
00192        { localBarrier.RemoveClient(h); };
00193   inline LDBarrierReceiver AddLocalBarrierReceiver(LDBarrierFn fn, void* data) 
00194        { return localBarrier.AddReceiver(fn,data); };
00195   inline void RemoveLocalBarrierReceiver(LDBarrierReceiver h) 
00196        { localBarrier.RemoveReceiver(h); };
00197   inline void TurnOnBarrierReceiver(LDBarrierReceiver h) 
00198        { localBarrier.TurnOnReceiver(h); };
00199   inline void TurnOffBarrierReceiver(LDBarrierReceiver h) 
00200        { localBarrier.TurnOffReceiver(h); };
00201   inline void AtLocalBarrier(LDBarrierClient h) 
00202        { if (useBarrier) localBarrier.AtBarrier(h); };
00203   inline void ResumeClients() 
00204        { localBarrier.ResumeClients(); };
00205   inline void MeasuredObjTime(double wtime, double ctime) {
00206     if (statsAreOn) {
00207       obj_walltime += wtime;
00208 #if CMK_LB_CPUTIMER
00209       obj_cputime += ctime;
00210 #endif
00211     }
00212   };
00213 
00214   //This class controls the builtin-atsync frequency
00215   class batsyncer {
00216   private:
00217     LBDB *db; //Enclosing LBDB object
00218     double period;//Time (seconds) between builtin-atsyncs  
00219     double nextT;
00220     LDBarrierClient BH;//Handle for the builtin-atsync barrier 
00221     static void gotoSync(void *bs);
00222     static void resumeFromSync(void *bs);
00223   public:
00224     void init(LBDB *_db,double initPeriod);
00225     void setPeriod(double p) {period=p;}
00226     double getPeriod() {return period;}
00227   };
00228 
00229 private:
00230   struct MigrateCB {
00231     LDMigratedFn fn;
00232     void* data;
00233     int on;
00234   };
00235 
00236   struct StartLBCB {
00237     LDStartLBFn fn;
00238     void* data;
00239     int on;
00240   };
00241 
00242   struct MigrationDoneCB {
00243     LDMigrationDoneFn fn;
00244     void* data;
00245   };
00246 
00247   struct PredictCB {
00248     LDPredictModelFn on;
00249     LDPredictWindowFn onWin;
00250     LDPredictFn off;
00251     LDPredictModelFn change;
00252     void* data;
00253   };
00254 
00255   typedef CkVec<LBOM*> OMList;
00256   typedef CkVec<LBObj*> ObjList;
00257   typedef CkVec<MigrateCB*> MigrateCBList;
00258   typedef CkVec<StartLBCB*> StartLBCBList;
00259   typedef CkVec<MigrationDoneCB*> MigrationDoneCBList;
00260 
00261   LBCommTable* commTable;
00262   OMList oms;
00263   int omCount;
00264   int oms_registering;
00265 
00266   ObjList objs;
00267   int objCount;
00268 
00269   CmiBool statsAreOn;
00270   MigrateCBList migrateCBList;
00271 
00272   MigrationDoneCBList migrationDoneCBList;
00273 
00274   PredictCB* predictCBFn;
00275 
00276   CmiBool obj_running;
00277   int runningObj;               // index of the runningObj in ObjList
00278 
00279   batsyncer batsync;
00280 
00281   LocalBarrier localBarrier;    // local barrier to trigger LB automatically
00282   CmiBool useBarrier;           // use barrier or not
00283 
00284   LBMachineUtil machineUtil;
00285   double obj_walltime;
00286 #if CMK_LB_CPUTIMER
00287   double obj_cputime;
00288 #endif
00289 
00290   StartLBCBList  startLBFnList;
00291   int            startLBFn_count;
00292 public:
00293   int useMem();
00294 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
00295     int validObjHandle(LDObjHandle h ){
00296             if(objCount == 0)
00297                 return 0;
00298             if(h.handle > objCount)
00299                 return 0;
00300             if(objs[h.handle] == NULL)
00301                 return 0;
00302 
00303             return 1;
00304     }
00305 #endif
00306 
00307 
00308   int getObjCount() {return objCount;}
00309   const ObjList& getObjs() {return objs;}
00310 
00311 
00312 
00313 };
00314 
00315 #endif
00316
ck-ldb/LBDBManager.h
