Charm++: Charm Source Code Documentation

00001 
00005 
00006 #ifndef LBDBH_H
00007 #define LBDBH_H
00008 
00009 #include "converse.h"
00010 #include "charm.h"
00011 #include "middle.h"
00012 
00013 class LBDatabase;//Forward declaration
00014 
00015 //typedef float floatType;
00016 // type defined by build option
00017 #ifndef CMK_LBTIME_TYPE
00018 #define CMK_LBTIME_TYPE double
00019 #endif
00020 typedef CMK_LBTIME_TYPE LBRealType;
00021 
00022 #define COMPRESS_LDB    1
00023 
00024 extern int _lb_version;
00025 
00026 #ifdef __cplusplus
00027 extern "C" {
00028 #endif
00029 
00030 typedef void* cvoid; /* To eliminate warnings, because a C void* is not
00031                         the same as a C++ void* */
00032 
00033   /*  User-defined object ID is 4 ints long (as defined in converse.h) */
00034   /*  as OBJ_ID_SZ */
00035 
00036 #if CMK_LBDB_ON
00037 typedef struct {
00038   void *handle;            // pointer to LBDB
00039 } LDHandle;
00040 #else
00041 typedef int LDHandle;
00042 #endif
00043 
00044 typedef struct _LDOMid {
00045   CkGroupID id;
00046   CmiBool operator==(const struct _LDOMid& omId) const {
00047     return id == omId.id?CmiTrue:CmiFalse;
00048   }
00049   CmiBool operator<(const struct _LDOMid& omId) const {
00050     return id < omId.id?CmiTrue:CmiFalse;
00051   }
00052   CmiBool operator!=(const struct _LDOMid& omId) const {
00053     return id == omId.id?CmiFalse:CmiTrue;
00054   }
00055   inline void pup(PUP::er &p);
00056 } LDOMid;
00057 
00058 typedef struct {
00059   LDHandle ldb;
00060 //  void *user_ptr;
00061   LDOMid id;
00062   int handle;           // index to LBOM
00063   inline void pup(PUP::er &p);
00064 } LDOMHandle;
00065 
00066 typedef struct _LDObjid {
00067   int id[OBJ_ID_SZ];
00068   CmiBool operator==(const struct _LDObjid& objid) const {
00069     for (int i=0; i<OBJ_ID_SZ; i++) if (id[i] != objid.id[i]) return CmiFalse;
00070     return CmiTrue;
00071   }
00072   CmiBool operator<(const struct _LDObjid& objid) const {
00073     for (int i=0; i<OBJ_ID_SZ; i++) {
00074       if (id[i] < objid.id[i]) return CmiTrue;
00075       else if (id[i] > objid.id[i]) return CmiFalse;
00076     }
00077     return CmiFalse;
00078   }
00079   inline void pup(PUP::er &p);
00080 } LDObjid;
00081 
00082 /* LDObjKey uniquely identify one object */
00083 typedef struct _LDObjKey {
00085   LDOMid omId;
00086   LDObjid objId;
00087 public:
00088   CmiBool operator==(const _LDObjKey& obj) const {
00089     return (CmiBool)(omId == obj.omId && objId == obj.objId);
00090   }
00091   CmiBool operator<(const _LDObjKey& obj) const {
00092     if (omId < obj.omId) return CmiTrue;
00093     else if (omId == obj.omId) return objId < obj.objId;
00094     else return CmiFalse;
00095   }
00096   inline LDOMid &omID() { return omId; }
00097   inline LDObjid &objID() { return objId; }
00098   inline const LDOMid &omID() const { return omId; }
00099   inline const LDObjid &objID() const { return objId; }
00100   inline void pup(PUP::er &p);
00101 } LDObjKey;
00102 
00103 typedef int LDObjIndex;
00104 typedef int LDOMIndex;
00105 
00106 typedef struct {
00107   LDOMHandle omhandle;
00108   LDObjid id;
00109   LDObjIndex  handle;
00110   inline const LDOMid &omID() const { return omhandle.id; }
00111   inline const LDObjid &objID() const { return id; }
00112   inline void pup(PUP::er &p);
00113 } LDObjHandle;
00114 
00115 typedef struct {
00116   LDObjHandle handle;
00117   LBRealType wallTime;
00118 #if CMK_LB_CPUTIMER
00119   LBRealType cpuTime;
00120 #endif
00121 #if ! COMPRESS_LDB
00122   LBRealType minWall, maxWall;
00123 #endif
00124   CmiBool migratable;
00125   CmiBool asyncArrival;
00126   inline const LDOMHandle &omHandle() const { return handle.omhandle; }
00127   inline const LDOMid &omID() const { return handle.omhandle.id; }
00128   inline const LDObjid &objID() const { return handle.id; }
00129   inline const LDObjid &id() const { return handle.id; }
00130   inline void pup(PUP::er &p);
00131 } LDObjData;
00132 
00133 /* used by load balancer */
00134 typedef struct {
00135   int index;
00136   LDObjData data;
00137   int from_proc;
00138   int to_proc;
00139   inline void pup(PUP::er &p);
00140 } LDObjStats;
00141 
00142 #define LD_PROC_MSG      1
00143 #define LD_OBJ_MSG       2
00144 #define LD_OBJLIST_MSG   3
00145 
00146 typedef struct _LDCommDesc {
00147   char type;
00148   union {
00149     int destProc;               /* 1:   processor level message */
00150     struct{
00151       LDObjKey  destObj;                /* 2:   object based message    */
00152       int destObjProc;
00153     } destObj;
00154     struct {
00155       LDObjKey  *objs;
00156       int len;
00157     } destObjs;                 /* 3:   one to many message     */
00158   } dest;
00159   char &get_type() { return type; }
00160   char get_type() const { return type; }
00161   int proc() const { return type==LD_PROC_MSG?dest.destProc:-1; }
00162   void setProc(int pe) { CmiAssert(type==LD_PROC_MSG); dest.destProc = pe; }
00163   int lastKnown() const { 
00164     if (type==LD_OBJ_MSG) return dest.destObj.destObjProc;
00165     if (type==LD_PROC_MSG) return dest.destProc;
00166     return -1;
00167   }
00168   LDObjKey &get_destObj() 
00169         { CmiAssert(type==LD_OBJ_MSG); return dest.destObj.destObj; }
00170   LDObjKey const &get_destObj() const 
00171         { CmiAssert(type==LD_OBJ_MSG); return dest.destObj.destObj; }
00172   LDObjKey * get_destObjs(int &len) 
00173         { CmiAssert(type==LD_OBJLIST_MSG); len=dest.destObjs.len; return dest.destObjs.objs; }
00174   void init_objmsg(LDOMid &omid, LDObjid &objid, int destObjProc) { 
00175         type=LD_OBJ_MSG; 
00176         dest.destObj.destObj.omID()=omid;
00177         dest.destObj.destObj.objID() =objid;
00178         dest.destObj.destObjProc = destObjProc;
00179   }
00180   void init_mcastmsg(LDOMid &omid, LDObjid *objid, int len) { 
00181         type=LD_OBJLIST_MSG; 
00182         dest.destObjs.len = len;
00183         dest.destObjs.objs = new LDObjKey[len];
00184         for (int i=0; i<len; i++) {
00185           dest.destObjs.objs[i].omID()=omid;
00186           dest.destObjs.objs[i].objID() =objid[i];
00187         }
00188   }
00189   inline CmiBool operator==(const _LDCommDesc &obj) const;
00190   inline _LDCommDesc &operator=(const _LDCommDesc &c);
00191   inline void pup(PUP::er &p);
00192 } LDCommDesc;
00193 
00194 typedef struct {
00195   int src_proc;                 // sender can either be a proc or an obj
00196   LDObjKey  sender;             // 
00197   LDCommDesc   receiver;
00198   int  sendHash, recvHash;
00199   int messages;
00200   int bytes;
00201   inline int from_proc() const { return (src_proc != -1); }
00202   inline int recv_type() const { return receiver.get_type(); }
00203   inline void pup(PUP::er &p);
00204   inline void clearHash() { sendHash = recvHash = -1; }
00205 } LDCommData;
00206 
00207 /*
00208  * Requests to load balancer
00209  *   FIXME: these routines don't seem to exist anywhere-- are they obsolete?
00210  *   Are the official versions now in LBDatabase.h?
00211  */
00212 void LBBalance(void *param);
00213 void LBCollectStatsOn(void);
00214 void LBCollectStatsOff(void);
00215 
00216 /*
00217  * Callbacks from database to object managers
00218  */
00219 typedef void (*LDMigrateFn)(LDObjHandle handle, int dest);
00220 typedef void (*LDStatsFn)(LDOMHandle h, int state);
00221 typedef void (*LDQueryEstLoadFn)(LDOMHandle h);
00222 
00223 typedef struct {
00224   LDMigrateFn migrate;
00225   LDStatsFn setStats;
00226   LDQueryEstLoadFn queryEstLoad;
00227 } LDCallbacks;
00228 
00229 /*
00230  * Calls from object managers to load database
00231  */
00232 #if CMK_LBDB_ON
00233 LDHandle LDCreate(void);
00234 #else
00235 #define LDCreate() 0
00236 #endif
00237 
00238 LDOMHandle LDRegisterOM(LDHandle _lbdb, LDOMid userID, 
00239                         void *userptr, LDCallbacks cb);
00240 void * LDOMUserData(LDOMHandle &_h);
00241 void LDRegisteringObjects(LDOMHandle _h);
00242 void LDDoneRegisteringObjects(LDOMHandle _h);
00243 
00244 LDObjHandle LDRegisterObj(LDOMHandle h, LDObjid id, void *userptr,
00245                           int migratable);
00246 void LDUnregisterObj(LDObjHandle h);
00247 const LDObjHandle &LDGetObjHandle(LDHandle h, int idx);
00248 
00249 void * LDObjUserData(LDObjHandle &_h);
00250 void LDObjTime(LDObjHandle &h, LBRealType walltime, LBRealType cputime);
00251 int  CLDRunningObject(LDHandle _h, LDObjHandle* _o );
00252 void LDObjectStart(const LDObjHandle &_h);
00253 void LDObjectStop(const LDObjHandle &_h);
00254 void LDSend(const LDOMHandle &destOM, const LDObjid &destid, unsigned int bytes, int destObjProc, int force);
00255 void LDMulticastSend(const LDOMHandle &destOM, LDObjid *destids, int ndests, unsigned int bytes, int nMsgs);
00256 
00257 void LDMessage(LDObjHandle from, 
00258                LDOMid toOM, LDObjid *toID, int bytes);
00259 
00260 void LDEstObjLoad(LDObjHandle h, double load);
00261 void LDNonMigratable(const LDObjHandle &h);
00262 void LDMigratable(const LDObjHandle &h);
00263 void LDAsyncMigrate(const LDObjHandle &h, CmiBool);
00264 void LDDumpDatabase(LDHandle _lbdb);
00265 
00266 /*
00267  * Calls from load balancer to load database
00268  */  
00269 typedef void (*LDMigratedFn)(void* data, LDObjHandle handle, int waitBarrier);
00270 void LDNotifyMigrated(LDHandle _lbdb, LDMigratedFn fn, void* data);
00271 
00272 typedef void (*LDStartLBFn)(void *user_ptr);
00273 void LDAddStartLBFn(LDHandle _lbdb, LDStartLBFn fn, void* data);
00274 void LDRemoveStartLBFn(LDHandle _lbdb, LDStartLBFn fn);
00275 void LDStartLB(LDHandle _db);
00276 void LDTurnManualLBOn(LDHandle _lbdb);
00277 void LDTurnManualLBOff(LDHandle _lbdb);
00278 
00279 typedef void (*LDMigrationDoneFn)(void *user_ptr);
00280 int LDAddMigrationDoneFn(LDHandle _lbdb, LDMigrationDoneFn fn,  void* data);
00281 void  LDRemoveMigrationDoneFn(LDHandle _lbdb, LDMigrationDoneFn fn);
00282 void LDMigrationDone(LDHandle _lbdb);
00283 
00284 typedef void (*LDPredictFn)(void* user_ptr);
00285 typedef void (*LDPredictModelFn)(void* user_ptr, void* model);
00286 typedef void (*LDPredictWindowFn)(void* user_ptr, void* model, int wind);
00287 void LDTurnPredictorOn(LDHandle _lbdb, void *model);
00288 void LDTurnPredictorOnWin(LDHandle _lbdb, void *model, int wind);
00289 void LDTurnPredictorOff(LDHandle _lbdb);
00290 void LDChangePredictor(LDHandle _lbdb, void *model);
00291 void LDCollectStatsOn(LDHandle _lbdb);
00292 void LDCollectStatsOff(LDHandle _lbdb);
00293 int  CLDCollectingStats(LDHandle _lbdb);
00294 void LDQueryEstLoad(LDHandle bdb);
00295 void LDGetObjLoad(LDObjHandle &h, LBRealType *wallT, LBRealType *cpuT);
00296 void LDQueryKnownObjLoad(LDObjHandle &h, LBRealType *wallT, LBRealType *cpuT);
00297 
00298 int LDGetObjDataSz(LDHandle _lbdb);
00299 void LDGetObjData(LDHandle _lbdb, LDObjData *data);
00300 
00301 int LDGetCommDataSz(LDHandle _lbdb);
00302 void LDGetCommData(LDHandle _lbdb, LDCommData *data);
00303 
00304 void LDBackgroundLoad(LDHandle _lbdb, LBRealType *walltime, LBRealType *cputime);
00305 void LDIdleTime(LDHandle _lbdb, LBRealType *walltime);
00306 void LDTotalTime(LDHandle _lbdb, LBRealType *walltime, LBRealType *cputime);
00307 void LDGetTime(LDHandle _db, LBRealType *total_walltime,LBRealType *total_cputime,
00308                    LBRealType *idletime, LBRealType *bg_walltime, LBRealType *bg_cputime);
00309 
00310 void LDClearLoads(LDHandle _lbdb);
00311 int  LDMigrate(LDObjHandle h, int dest);
00312 void LDMigrated(LDObjHandle h, int waitBarrier);
00313 
00314 /*
00315  * Local Barrier calls
00316  */
00317 typedef void (*LDBarrierFn)(void *user_ptr);
00318 typedef void (*LDResumeFn)(void *user_ptr);
00319 
00320 typedef struct {
00321   int serial;
00322 } LDBarrierClient;
00323 
00324 typedef struct {
00325   int serial;
00326 } LDBarrierReceiver;
00327 
00328 LDBarrierClient LDAddLocalBarrierClient(LDHandle _lbdb,LDResumeFn fn,
00329                                         void* data);
00330 void LDRemoveLocalBarrierClient(LDHandle _lbdb, LDBarrierClient h);
00331 LDBarrierReceiver LDAddLocalBarrierReceiver(LDHandle _lbdb,LDBarrierFn fn,
00332                                             void* data);
00333 void LDRemoveLocalBarrierReceiver(LDHandle _lbdb,LDBarrierReceiver h);
00334 void LDAtLocalBarrier(LDHandle _lbdb, LDBarrierClient h);
00335 void LDLocalBarrierOn(LDHandle _db);
00336 void LDLocalBarrierOff(LDHandle _db);
00337 void LDResumeClients(LDHandle _lbdb);
00338 int LDProcessorSpeed();
00339 CmiBool LDOMidEqual(const LDOMid &i1, const LDOMid &i2);
00340 CmiBool LDObjIDEqual(const LDObjid &i1, const LDObjid &i2);
00341 
00342 /*
00343  *  LBDB Configuration calls
00344  */
00345 void LDSetLBPeriod(LDHandle _db, double s);
00346 double LDGetLBPeriod(LDHandle _db);
00347 
00348 int LDMemusage(LDHandle _db);
00349 
00350 #ifdef __cplusplus
00351 }
00352 #endif /* _cplusplus */
00353 
00354 #if CMK_LBDB_ON
00355 PUPbytes(LDHandle)
00356 #endif
00357 
00358 inline void LDOMid::pup(PUP::er &p) {
00359   id.pup(p);
00360 }
00361 PUPmarshall(LDOMid)
00362 
00363 inline void LDObjid::pup(PUP::er &p) {
00364   for (int i=0; i<OBJ_ID_SZ; i++) p|id[i];
00365 }
00366 PUPmarshall(LDObjid)
00367 
00368 inline void LDObjKey::pup(PUP::er &p) {
00369   p|omId;
00370   p|objId;
00371 }
00372 PUPmarshall(LDObjKey)
00373 
00374 inline void LDObjStats::pup(PUP::er &p) {
00375   p|index;
00376   p|data;
00377   p|from_proc;
00378   p|to_proc;
00379 }
00380 PUPmarshall(LDObjStats)
00381 inline void LDOMHandle::pup(PUP::er &p) {
00382   // skip ldb since it is a pointer
00383   int ptrSize = sizeof(void *);
00384   p|ptrSize;
00385   // if pointer size is not expected, must be in simulation mode
00386   // ignore this field
00387   if (p.isUnpacking() && ptrSize != sizeof(void *)) {  
00388     char dummy;
00389     for (int i=0; i<ptrSize; i++) p|dummy;
00390   }
00391   else
00392     p|ldb;
00393   p|id;
00394   p|handle;
00395 }
00396 PUPmarshall(LDOMHandle)
00397 
00398 inline void LDObjHandle::pup(PUP::er &p) {
00399   p|omhandle;
00400   p|id;
00401   p|handle;
00402 }
00403 PUPmarshall(LDObjHandle)
00404 
00405 inline void LDObjData::pup(PUP::er &p) {
00406   p|handle;
00407   p|wallTime;
00408 #if CMK_LB_CPUTIMER
00409   p|cpuTime;
00410 #endif
00411 #if ! COMPRESS_LDB
00412   p|minWall;
00413   p|maxWall;
00414 #endif
00415   p|migratable;
00416   if (_lb_version > -1) p|asyncArrival;
00417 }
00418 PUPmarshall(LDObjData)
00419 
00420 inline CmiBool LDCommDesc::operator==(const LDCommDesc &obj) const {
00421     if (type != obj.type) return CmiFalse;
00422     switch (type) {
00423     case LD_PROC_MSG: return (CmiBool)(dest.destProc == obj.dest.destProc);
00424     case LD_OBJ_MSG:  return (CmiBool)(dest.destObj.destObj == obj.dest.destObj.destObj);
00425     case LD_OBJLIST_MSG: { if (dest.destObjs.len != obj.dest.destObjs.len) 
00426                                return CmiFalse;
00427                            for (int i=0; i<dest.destObjs.len; i++)
00428                              if (!(dest.destObjs.objs[i] == obj.dest.destObjs.objs[i])) return CmiFalse;
00429                            return CmiTrue; }
00430     }
00431     return CmiFalse;
00432 }
00433 inline LDCommDesc & LDCommDesc::operator=(const LDCommDesc &c) {
00434     type = c.type;
00435     switch (type) {
00436     case LD_PROC_MSG: dest.destProc = c.dest.destProc; break;
00437     case LD_OBJ_MSG:  dest.destObj.destObj = c.dest.destObj.destObj; break;
00438     case LD_OBJLIST_MSG: { dest.destObjs.len = c.dest.destObjs.len;
00439                            dest.destObjs.objs = new LDObjKey[dest.destObjs.len];
00440                            for (int i=0; i<dest.destObjs.len; i++)
00441                              dest.destObjs.objs[i] = c.dest.destObjs.objs[i]; 
00442                            break; }
00443     }
00444     return *this;
00445 }
00446 inline void LDCommDesc::pup(PUP::er &p) {
00447   p|type;
00448   switch (type) {
00449   case LD_PROC_MSG:  p|dest.destProc; break;
00450   case LD_OBJ_MSG:   p|dest.destObj.destObj; 
00451                      if (_lb_version == -1 && p.isUnpacking()) 
00452                        dest.destObj.destObjProc = -1;
00453                      else
00454                        p|dest.destObj.destObjProc; 
00455                      break;
00456   case LD_OBJLIST_MSG:  {  p|dest.destObjs.len; 
00457                            if (p.isUnpacking()) 
00458                                dest.destObjs.objs = new LDObjKey[dest.destObjs.len];
00459                            for (int i=0; i<dest.destObjs.len; i++) p|dest.destObjs.objs[i];
00460                            break; }
00461   }   // end of switch
00462 }
00463 PUPmarshall(LDCommDesc)
00464 
00465 inline void LDCommData::pup(PUP::er &p) {
00466     p|src_proc;
00467     p|sender;
00468     p|receiver;
00469     p|messages;
00470     p|bytes;
00471     if (p.isUnpacking()) {
00472       sendHash = recvHash = -1;
00473     }
00474 }
00475 PUPmarshall(LDCommData)
00476 
00477 #endif /* LBDBH_H */
00478
ck-ldb/lbdb.h
