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