src/ck-ldb/lbdb.C

   1 /**
   2  * \addtogroup CkLdb
   3 */
   4 /*@{*/
   5
   6 #include <converse.h>
   7
   8 #include <math.h>
   9
  10 #include "lbdb.h"
  11 #include "LBObj.h"
  12 #include "LBOM.h"
  13 #include "LBDatabase.h"
  14 #include "LBDBManager.h"
  15
  16 #if CMK_LBDB_ON
  17
  18 extern "C" LDHandle LDCreate(void)
  19 {
  20   LDHandle h;
  21   h.handle = (void*)(new LBDB);
  22   return h;
  23 }
  24
  25 extern "C" LDOMHandle LDRegisterOM(LDHandle _db, LDOMid _userID,
  26                                    void *_userptr, LDCallbacks _callbacks)
  27 {
  28   LBDB *const db = (LBDB*)(_db.handle);
  29   return db->AddOM(_userID, _userptr, _callbacks);
  30 }
  31
  32 extern "C" void LDUnregisterOM(LDHandle _db, LDOMHandle om)
  33 {
  34   LBDB *const db = (LBDB*)(_db.handle);
  35   db->RemoveOM(om);
  36 }
  37
  38 extern "C" void LDOMMetaLBResumeWaitingChares(LDHandle _db, int lb_ideal_period) {
  39   LBDB *const db = (LBDB*)(_db.handle);
  40   db->MetaLBResumeWaitingChares(lb_ideal_period);
  41 }
  42
  43 extern "C" void LDOMMetaLBCallLBOnChares(LDHandle _db) {
  44   LBDB *const db = (LBDB*)(_db.handle);
  45   db->MetaLBCallLBOnChares();
  46 }
  47
  48 extern "C" void * LDOMUserData(LDOMHandle &_h)
  49 {
  50   LBDB *const db = (LBDB*)(_h.ldb.handle);
  51   return db->LbOM(_h)->getUserData();
  52 }
  53
  54 extern "C" void LDRegisteringObjects(LDOMHandle _h)
  55 {
  56   LBDB *const db = (LBDB*)(_h.ldb.handle);
  57   db->RegisteringObjects(_h);
  58 }
  59
  60 extern "C" void LDDoneRegisteringObjects(LDOMHandle _h)
  61 {
  62   LBDB *const db = (LBDB*)(_h.ldb.handle);
  63   db->DoneRegisteringObjects(_h);
  64 }
  65
  66 extern "C" LDObjHandle LDRegisterObj(LDOMHandle _h, LDObjid _id,
  67                                        void *_userData, int _migratable)
  68 {
  69   LBDB *const db = (LBDB*)(_h.ldb.handle);
  70   return db->AddObj(_h, _id, _userData, (bool)(_migratable));
  71 }
  72
  73 extern "C" void LDUnregisterObj(LDObjHandle _h)
  74 {
  75   LBDB *const db = (LBDB*)(_h.omhandle.ldb.handle);
  76   db->UnregisterObj(_h);
  77   return;
  78 }
  79
  80 const LDObjHandle &LDGetObjHandle(LDHandle h, int oh)
  81 {
  82   LBDB *const db = (LBDB*)(h.handle);
  83   LBObj *const obj = db->LbObjIdx(oh);
  84   return obj->GetLDObjHandle();
  85 }
  86
  87 extern "C" void LDObjTime(LDObjHandle &_h,
  88                             LBRealType walltime, LBRealType cputime)
  89 {
  90   LBDB *const db = (LBDB*)(_h.omhandle.ldb.handle);
  91   LBObj *const obj = db->LbObj(_h);
  92   obj->IncrementTime(walltime,cputime);
  93   db->MeasuredObjTime(walltime,cputime);
  94 }
  95
  96 extern "C" void LDGetObjLoad(LDObjHandle &_h, LBRealType *wallT, LBRealType *cpuT)
  97 {
  98   LBDB *const db = (LBDB*)(_h.omhandle.ldb.handle);
  99   LBObj *const obj = db->LbObj(_h);
 100   obj->getTime(wallT, cpuT);
 101 }
 102
 103 extern "C" void LDQueryKnownObjLoad(LDObjHandle &_h, LBRealType *wallT, LBRealType *cpuT)
 104 {
 105   LBDB *const db = (LBDB*)(_h.omhandle.ldb.handle);
 106   LBObj *const obj = db->LbObj(_h);
 107   obj->lastKnownLoad(wallT, cpuT);
 108 }
 109
 110 extern "C" void * LDObjUserData(LDObjHandle &_h)
 111 {
 112   LBDB *const db = (LBDB*)(_h.omhandle.ldb.handle);
 113   LBObj *const obj = db->LbObj(_h);
 114   return obj->getLocalUserData();
 115 }
 116
 117 #if CMK_LB_USER_DATA
 118 extern "C" void * LDDBObjUserData(LDObjHandle &_h, int idx)
 119 {
 120   LBDB *const db = (LBDB*)(_h.omhandle.ldb.handle);
 121   LBObj *const obj = db->LbObj(_h);
 122   return obj->getDBUserData(idx);
 123 }
 124 #endif
 125
 126 extern "C" void LDDumpDatabase(LDHandle _db)
 127 {
 128   LBDB *const db = (LBDB*)(_db.handle);
 129   db->DumpDatabase();
 130 }
 131
 132 extern "C" void LDNotifyMigrated(LDHandle _db, LDMigratedFn fn, void* data)
 133 {
 134   LBDB *const db = (LBDB*)(_db.handle);
 135   db->NotifyMigrated(fn,data);
 136 }
 137
 138 extern "C" void LDAddStartLBFn(LDHandle _db, LDStartLBFn fn, void* data)
 139 {
 140   LBDB *const db = (LBDB*)(_db.handle);
 141   db->AddStartLBFn(fn,data);
 142 }
 143
 144 extern "C" void LDRemoveStartLBFn(LDHandle _db, LDStartLBFn fn)
 145 {
 146   LBDB *const db = (LBDB*)(_db.handle);
 147   db->RemoveStartLBFn(fn);
 148 }
 149
 150 extern "C" void LDStartLB(LDHandle _db)
 151 {
 152   LBDB *const db = (LBDB*)(_db.handle);
 153   db->StartLB();
 154 }
 155
 156 extern "C" void LDTurnManualLBOn(LDHandle _db)
 157 {
 158   LBDB *const db = (LBDB*)(_db.handle);
 159   db->TurnManualLBOn();
 160 }
 161
 162 extern "C" void LDTurnManualLBOff(LDHandle _db)
 163 {
 164   LBDB *const db = (LBDB*)(_db.handle);
 165   db->TurnManualLBOff();
 166 }
 167
 168 extern "C" int LDAddMigrationDoneFn(LDHandle _db, LDMigrationDoneFn fn,  void* data)
 169 {
 170   LBDB *const db = (LBDB*)(_db.handle);
 171   return db->AddMigrationDoneFn(fn,data);
 172 }
 173
 174 extern "C" void  LDRemoveMigrationDoneFn(LDHandle _db, LDMigrationDoneFn fn)
 175 {
 176   LBDB *const db = (LBDB*)(_db.handle);
 177   db->RemoveMigrationDoneFn(fn);
 178 }
 179
 180 extern "C" void LDMigrationDone(LDHandle _db)
 181 {
 182   LBDB *const db = (LBDB*)(_db.handle);
 183   db->MigrationDone();
 184 }
 185
 186 extern "C" void LDTurnPredictorOn(LDHandle _db, void *model)
 187 {
 188   LBDB *const db = (LBDB*)(_db.handle);
 189   db->TurnPredictorOn(model);
 190 }
 191
 192 extern "C" void LDTurnPredictorOnWin(LDHandle _db, void *model, int wind)
 193 {
 194   LBDB *const db = (LBDB*)(_db.handle);
 195   db->TurnPredictorOn(model, wind);
 196 }
 197
 198 extern "C" void LDTurnPredictorOff(LDHandle _db)
 199 {
 200   LBDB *const db = (LBDB*)(_db.handle);
 201   db->TurnPredictorOff();
 202 }
 203
 204 /* the parameter model is really of class LBPredictorFunction in file LBDatabase.h */
 205 extern "C" void LDChangePredictor(LDHandle _db, void *model)
 206 {
 207   LBDB *const db = (LBDB*)(_db.handle);
 208   db->ChangePredictor(model);
 209 }
 210
 211 extern "C" void LDCollectStatsOn(LDHandle _db)
 212 {
 213   LBDB *const db = (LBDB*)(_db.handle);
 214
 215   if (!db->StatsOn()) {
 216     if (db->ObjIsRunning()) {
 217        // stats on in the middle of an entry, start timer
 218       const LDObjHandle &oh = db->RunningObj();
 219       LBObj *obj = db->LbObj(oh);
 220       obj->StartTimer();
 221     }
 222     db->TurnStatsOn();
 223   }
 224 }
 225
 226 extern "C" void LDCollectStatsOff(LDHandle _db)
 227 {
 228   LBDB *const db = (LBDB*)(_db.handle);
 229   db->TurnStatsOff();
 230 }
 231
 232 extern "C" int CLDCollectingStats(LDHandle _db)
 233 {
 234 //  LBDB *const db = (LBDB*)(_db.handle);
 235 //
 236 //  return db->StatsOn();
 237   return LDCollectingStats(_db);
 238 }
 239
 240 extern "C" int CLDRunningObject(LDHandle _h, LDObjHandle* _o)
 241 {
 242   return LDRunningObject(_h, _o);
 243 }
 244
 245 extern "C" void LDObjectStart(const LDObjHandle &_h)
 246 {
 247   LBDB *const db = (LBDB*)(_h.omhandle.ldb.handle);
 248
 249   if (db->ObjIsRunning()) LDObjectStop(db->RunningObj());
 250
 251   db->SetRunningObj(_h);
 252
 253   if (db->StatsOn()) {
 254     LBObj *const obj = db->LbObj(_h);
 255     obj->StartTimer();
 256   }
 257 }
 258
 259 extern "C" void LDObjectStop(const LDObjHandle &_h)
 260 {
 261   LBDB *const db = (LBDB*)(_h.omhandle.ldb.handle);
 262   LBObj *const obj = db->LbObj(_h);
 263
 264   if (db->StatsOn()) {
 265     LBRealType walltime, cputime;
 266     obj->StopTimer(&walltime,&cputime);
 267     obj->IncrementTime(walltime,cputime);
 268     db->MeasuredObjTime(walltime,cputime);
 269   }
 270   db->NoRunningObj();
 271 }
 272
 273 extern "C" void LDSend(const LDOMHandle &destOM, const LDObjid &destid, unsigned int bytes, int destObjProc, int force)
 274 {
 275   LBDB *const db = (LBDB*)(destOM.ldb.handle);
 276   if (force || db->StatsOn() && _lb_args.traceComm())
 277     db->Send(destOM,destid,bytes, destObjProc);
 278 }
 279
 280 extern "C" void LDMulticastSend(const LDOMHandle &destOM, LDObjid *destids, int ndests, unsigned int bytes, int nMsgs)
 281 {
 282   LBDB *const db = (LBDB*)(destOM.ldb.handle);
 283   if (db->StatsOn() && _lb_args.traceComm())
 284     db->MulticastSend(destOM,destids,ndests,bytes,nMsgs);
 285 }
 286
 287 extern "C" void LDBackgroundLoad(LDHandle _db,
 288                                  LBRealType* walltime, LBRealType* cputime)
 289 {
 290   LBDB *const db = (LBDB*)(_db.handle);
 291   db->BackgroundLoad(walltime,cputime);
 292
 293   return;
 294 }
 295
 296 extern "C" void LDIdleTime(LDHandle _db,LBRealType* walltime)
 297 {
 298   LBDB *const db = (LBDB*)(_db.handle);
 299   db->IdleTime(walltime);
 300
 301   return;
 302 }
 303
 304 extern "C" void LDTotalTime(LDHandle _db,LBRealType* walltime, LBRealType* cputime)
 305 {
 306   LBDB *const db = (LBDB*)(_db.handle);
 307   db->TotalTime(walltime,cputime);
 308
 309   return;
 310 }
 311
 312 extern "C" void LDGetTime(LDHandle _db, LBRealType *total_walltime,
 313                    LBRealType *total_cputime,
 314                    LBRealType *idletime, LBRealType *bg_walltime, LBRealType *bg_cputime)
 315 {
 316   LBDB *const db = (LBDB*)(_db.handle);
 317   db->GetTime(total_walltime, total_cputime, idletime, bg_walltime, bg_cputime);
 318 }
 319
 320 extern "C" void LDNonMigratable(const LDObjHandle &h)
 321 {
 322   LBDB *const db = (LBDB*)(h.omhandle.ldb.handle);
 323   LBObj *const obj = db->LbObj(h);
 324
 325   obj->SetMigratable(false);
 326 }
 327
 328 extern "C" void LDMigratable(const LDObjHandle &h)
 329 {
 330   LBDB *const db = (LBDB*)(h.omhandle.ldb.handle);
 331   LBObj *const obj = db->LbObj(h);
 332
 333   obj->SetMigratable(true);
 334 }
 335
 336 extern "C" void LDSetPupSize(const LDObjHandle &h, size_t obj_pup_size)
 337 {
 338   LBDB *const db = (LBDB*)(h.omhandle.ldb.handle);
 339   LBObj *const obj = db->LbObj(h);
 340
 341   obj->setPupSize(obj_pup_size);
 342 }
 343
 344 extern "C" void LDAsyncMigrate(const LDObjHandle &h, bool async)
 345 {
 346   LBDB *const db = (LBDB*)(h.omhandle.ldb.handle);
 347   LBObj *const obj = db->LbObj(h);
 348
 349   obj->UseAsyncMigrate(async);
 350 }
 351
 352 extern "C" void LDClearLoads(LDHandle _db)
 353 {
 354   LBDB *const db = (LBDB*)(_db.handle);
 355
 356   db->ClearLoads();
 357 }
 358
 359 extern "C" int LDGetObjDataSz(LDHandle _db)
 360 {
 361   LBDB *const db = (LBDB*)(_db.handle);
 362
 363   return db->ObjDataCount();
 364 }
 365
 366 extern "C" void LDGetObjData(LDHandle _db, LDObjData *data)
 367 {
 368   LBDB *const db = (LBDB*)(_db.handle);
 369
 370   db->GetObjData(data);
 371 }
 372
 373 extern "C" int LDGetCommDataSz(LDHandle _db)
 374 {
 375   LBDB *const db = (LBDB*)(_db.handle);
 376
 377   return db->CommDataCount();
 378 }
 379
 380 extern "C" void LDGetCommData(LDHandle _db, LDCommData *data)
 381 {
 382   LBDB *const db = (LBDB*)(_db.handle);
 383
 384   db->GetCommData(data);
 385   return;
 386 }
 387
 388 extern "C" int LDMigrate(LDObjHandle _h, int dest)
 389 {
 390   LBDB *const db = (LBDB*)(_h.omhandle.ldb.handle);
 391
 392   return db->Migrate(_h,dest);
 393 }
 394
 395 extern "C" void LDMigrated(LDObjHandle _h, int waitBarrier)
 396 {
 397   LBDB *const db = (LBDB*)(_h.omhandle.ldb.handle);
 398
 399   db->Migrated(_h, waitBarrier);
 400 }
 401
 402 LDBarrierClient LDAddLocalBarrierClient(LDHandle _db, LDResumeFn fn, void* data)
 403 {
 404   LBDB *const db = (LBDB*)(_db.handle);
 405
 406   return db->AddLocalBarrierClient(fn,data);
 407 }
 408
 409 void LDRemoveLocalBarrierClient(LDHandle _db, LDBarrierClient h)
 410 {
 411   LBDB *const db = (LBDB*)(_db.handle);
 412
 413   db->RemoveLocalBarrierClient(h);
 414 }
 415
 416 LDBarrierReceiver LDAddLocalBarrierReceiver(LDHandle _db,LDBarrierFn fn, void* data)
 417 {
 418   LBDB *const db = (LBDB*)(_db.handle);
 419
 420   return db->AddLocalBarrierReceiver(fn,data);
 421 }
 422
 423 void LDRemoveLocalBarrierReceiver(LDHandle _db,LDBarrierReceiver h)
 424 {
 425   LBDB *const db = (LBDB*)(_db.handle);
 426
 427   db->RemoveLocalBarrierReceiver(h);
 428 }
 429
 430 extern "C" void LDAtLocalBarrier(LDHandle _db, LDBarrierClient h)
 431 {
 432   LBDB *const db = (LBDB*)(_db.handle);
 433
 434   db->AtLocalBarrier(h);
 435 }
 436
 437 extern "C" void LDDecreaseLocalBarrier(LDHandle _db, LDBarrierClient h, int c)
 438 {
 439   LBDB *const db = (LBDB*)(_db.handle);
 440
 441   db->DecreaseLocalBarrier(h, c);
 442 }
 443
 444 extern "C" void LDLocalBarrierOn(LDHandle _db)
 445 {
 446   LBDB *const db = (LBDB*)(_db.handle);
 447
 448   db->LocalBarrierOn();
 449 }
 450
 451 extern "C" void LDLocalBarrierOff(LDHandle _db)
 452 {
 453   LBDB *const db = (LBDB*)(_db.handle);
 454
 455   db->LocalBarrierOff();
 456 }
 457
 458
 459 extern "C" void LDResumeClients(LDHandle _db)
 460 {
 461   LBDB *const db = (LBDB*)(_db.handle);
 462
 463   db->ResumeClients();
 464 }
 465
 466 static void work(int iter_block, int* result) {
 467   int i;
 468   *result = 1;
 469   for(i=0; i < iter_block; i++) {
 470     double b=0.1 + 0.1 * *result;
 471     *result=(int)(sqrt(1+cos(b * 1.57)));
 472   }
 473 }
 474
 475 extern "C" int LDProcessorSpeed()
 476 {
 477   // for SMP version, if one processor have done this testing,
 478   // we can skip the other processors by remember the number here
 479   static int thisProcessorSpeed = -1;
 480
 481   if (_lb_args.samePeSpeed() || CkNumPes() == 1)  // I think it is safe to assume that we can
 482     return 1;            // skip this if we are only using 1 PE
 483
 484   if (thisProcessorSpeed != -1) return thisProcessorSpeed;
 485
 486   //if (CkMyPe()==0) CkPrintf("Measuring processor speeds...");
 487
 488   static int result=0;  // I don't care what this is, its just for
 489                         // timing, so this is thread safe.
 490   int wps = 0;
 491   const double elapse = 0.4;
 492   // First, count how many iterations for .2 second.
 493   // Since we are doing lots of function calls, this will be rough
 494   const double end_time = CmiCpuTimer()+elapse;
 495   wps = 0;
 496   while(CmiCpuTimer() < end_time) {
 497     work(1000,&result);
 498     wps+=1000;
 499   }
 500
 501   // Now we have a rough idea of how many iterations there are per
 502   // second, so just perform a few cycles of correction by
 503   // running for what we think is 1 second.  Then correct
 504   // the number of iterations per second to make it closer
 505   // to the correct value
 506
 507   for(int i=0; i < 2; i++) {
 508     const double start_time = CmiCpuTimer();
 509     work(wps,&result);
 510     const double end_time = CmiCpuTimer();
 511     const double correction = elapse / (end_time-start_time);
 512     wps = (int)((double)wps * correction + 0.5);
 513   }
 514
 515   // If necessary, do a check now
 516   //    const double start_time3 = CmiWallTimer();
 517   //    work(msec * 1e-3 * wps);
 518   //    const double end_time3 = CmiWallTimer();
 519   //    CkPrintf("[%d] Work block size is %d %d %f\n",
 520   //         thisIndex,wps,msec,1.e3*(end_time3-start_time3));
 521   thisProcessorSpeed = wps;
 522
 523   //if (CkMyPe()==0) CkPrintf(" Done.\n");
 524
 525   return wps;
 526 }
 527
 528 extern "C" void LDSetLBPeriod(LDHandle _db, double s)   // s is in seconds
 529 {
 530   LBDB *const db = (LBDB*)(_db.handle);
 531   db->SetPeriod(s);
 532 }
 533
 534 extern "C" double LDGetLBPeriod(LDHandle _db)   // s is in seconds
 535 {
 536   LBDB *const db = (LBDB*)(_db.handle);
 537   return db->GetPeriod();
 538 }
 539
 540 /*
 541 // to be implemented
 542 extern "C" void LDEstObjLoad(LDObjHandle h, double load)
 543 {
 544 }
 545 */
 546
 547 // to be implemented
 548 extern "C" void LDQueryEstLoad(LDHandle bdb)
 549 {
 550 }
 551
 552 extern "C" int LDMemusage(LDHandle _db)
 553 {
 554   LBDB *const db = (LBDB*)(_db.handle);
 555   return db->useMem();
 556 }
 557
 558 #else
 559 extern "C" int LDProcessorSpeed() { return 1; }
 560 #endif // CMK_LBDB_ON
 561
 562 bool LDOMidEqual(const LDOMid &i1, const LDOMid &i2)
 563 {
 564  return i1.id == i2.id?true:false;
 565 }
 566
 567 bool LDObjIDEqual(const LDObjid &i1, const LDObjid &i2)
 568 {
 569   return (i1.id[0] == i2.id[0]
 570          && i1.id[1] == i2.id[1] && i1.id[2] == i2.id[2]
 571          && i1.id[3] == i2.id[3]);
 572 }
 573
 574 /*@}*/