quick implementation to make projections to have object id for array elements. last...
[charm.git] / src / ck-perf / trace-projections.C
1 /*****************************************************************************
2  * $Source$
3  * $Author$
4  * $Date$
5  * $Revision$
6  *****************************************************************************/
7
8
9 /**
10  * \addtogroup CkPerf
11 */
12 /*@{*/
13
14 #include "charm++.h"
15 #include "trace-projections.h"
16
17 #define DEBUGF(x)           // CmiPrintf x
18
19 CkpvStaticDeclare(Trace*, _trace);
20 CtvStaticDeclare(int,curThreadEvent);
21
22 CkpvStaticDeclare(CkVec<char *>, usrEventlist);
23 class UsrEvent {
24 public:
25   int e;
26   char *str;
27   UsrEvent(int _e, char* _s): e(_e),str(_s) {}
28 };
29 CkpvStaticDeclare(CkVec<UsrEvent *>*, usrEvents);
30
31 #ifdef CMK_OPTIMIZE
32 static int warned=0;
33 #define OPTIMIZED_VERSION       \
34         if (!warned) { warned=1;        \
35         CmiPrintf("\n\n!!!! Warning: traceUserEvent not available in optimized version!!!!\n\n\n"); }
36 #else
37 #define OPTIMIZED_VERSION /*empty*/
38 #endif
39
40 /*
41 On T3E, we need to have file number control by open/close files only when needed.
42 */
43 #if CMK_TRACE_LOGFILE_NUM_CONTROL
44   #define OPEN_LOG openLog("a");
45   #define CLOSE_LOG closeLog();
46 #else
47   #define OPEN_LOG
48   #define CLOSE_LOG
49 #endif
50
51
52 void LogPool::openLog(const char *mode)
53 {
54 #if CMK_PROJECTIONS_USE_ZLIB
55   if(compressed) {
56     do {
57       zfp = gzopen(fname, mode);
58     } while (!zfp && (errno == EINTR || errno == EMFILE));
59     if(!zfp) CmiAbort("Cannot open Projections Trace File for writing...\n");
60   } else {
61     do {
62       fp = fopen(fname, mode);
63     } while (!fp && (errno == EINTR || errno == EMFILE));
64     if(!fp) CmiAbort("Cannot open Projections Trace File for writing...\n");
65   }
66 #else
67   do {
68     fp = fopen(fname, mode);
69   } while (!fp && (errno == EINTR || errno == EMFILE));
70   if(!fp) CmiAbort("Cannot open Projections Trace File for writing...\n");
71 #endif
72 }
73
74 void LogPool::closeLog(void)
75 {
76 #if CMK_PROJECTIONS_USE_ZLIB
77   if(compressed)
78     gzclose(zfp);
79   else
80     fclose(fp);
81 #else
82     fclose(fp);
83 #endif
84 }
85 /**
86   For each TraceFoo module, _createTraceFoo() must be defined.
87   This function is called in _createTraces() generated in moduleInit.C
88 */
89 void _createTraceprojections(char **argv)
90 {
91   DEBUGF(("%d createTraceProjections\n", CkMyPe()));
92   CkpvInitialize(CkVec<char *>, usrEventlist);
93   CkpvInitialize(CkVec<UsrEvent *>*, usrEvents);
94   CkpvAccess(usrEvents) = new CkVec<UsrEvent *>();
95 #if CMK_BLUEGENE_CHARM
96   // CthRegister does not call the constructor
97 //  CkpvAccess(usrEvents) = CkVec<UsrEvent *>();
98 #endif
99   CkpvInitialize(Trace*, _trace);
100   CkpvAccess(_trace) = new  TraceProjections(argv);
101   CkpvAccess(_traces)->addTrace(CkpvAccess(_trace));
102 }
103
104 extern "C"
105 void traceProjectionsBeginIdle(void)
106 {
107   CkpvAccess(_trace)->beginIdle();
108 }
109
110 extern "C"
111 void traceProjectionsEndIdle(void)
112 {
113   CkpvAccess(_trace)->endIdle();
114 }
115
116 LogPool::LogPool(char *pgm) {
117   pool = new LogEntry[CkpvAccess(CtrLogBufSize)];
118   numEntries = 0;
119   poolSize = CkpvAccess(CtrLogBufSize);
120   pgmname = new char[strlen(pgm)+1];
121   strcpy(pgmname, pgm);
122 }
123
124 void LogPool::creatFiles(char *fix)
125 {
126   char pestr[10];
127   sprintf(pestr, "%d", CkMyPe());
128 #if CMK_PROJECTIONS_USE_ZLIB
129   int len;
130   if(compressed)
131     len = strlen(pgmname)+strlen(fix)+strlen(".log")+strlen(pestr)+strlen(".gz")+3;
132   else
133     len = strlen(pgmname)+strlen(fix)+strlen(".log")+strlen(pestr)+3;
134 #else
135   int len = strlen(pgmname)+strlen(fix)+strlen(".log")+strlen(pestr)+3;
136 #endif
137   fname = new char[len];
138 #if CMK_PROJECTIONS_USE_ZLIB
139   if(compressed)
140     sprintf(fname, "%s%s.%s.log.gz", pgmname, fix, pestr);
141   else
142     sprintf(fname, "%s%s.%s.log", pgmname, fix, pestr);
143 #else
144   sprintf(fname, "%s%s.%s.log", pgmname, fix, pestr);
145 #endif
146   openLog("w+");
147   if(!binary) {
148 #if CMK_PROJECTIONS_USE_ZLIB
149     if(compressed)
150       gzprintf(zfp, "PROJECTIONS-RECORD\n");
151     else
152 #endif
153       fprintf(fp, "PROJECTIONS-RECORD\n");
154   }
155   CLOSE_LOG 
156
157   if (CkMyPe() == 0) 
158   {
159     char *fname = new char[strlen(CkpvAccess(traceRoot))+strlen(fix)+strlen(".sts")+2];
160     sprintf(fname, "%s%s.sts", CkpvAccess(traceRoot), fix);
161     do
162     {
163       stsfp = fopen(fname, "w");
164     } while (!stsfp && (errno == EINTR || errno == EMFILE));
165     if(stsfp==0)
166       CmiAbort("Cannot open projections sts file for writing.\n");
167     delete[] fname;
168   }
169 }
170
171 LogPool::~LogPool() 
172 {
173   writeLog();
174
175 #if CMK_BLUEGENE_CHARM
176   extern int correctTimeLog;
177   if (correctTimeLog) {
178     creatFiles("-bg");                  // create *-bg.log and *-bg.sts
179     if (CkMyPe() == 0) writeSts();      // write "*-bg.sts"
180     postProcessLog();
181   }
182 #endif
183
184 #if !CMK_TRACE_LOGFILE_NUM_CONTROL
185   closeLog();
186 #endif
187   delete[] pool;
188   delete [] fname;
189 }
190
191 void LogPool::writeLog(void)
192 {
193   OPEN_LOG
194   if(binary) writeBinary();
195 #if CMK_PROJECTIONS_USE_ZLIB
196   else if(compressed) writeCompressed();
197 #endif
198   else write();
199   CLOSE_LOG
200 }
201
202 void LogPool::write(void) 
203 {
204   for(UInt i=0; i<numEntries; i++)
205     pool[i].write(fp);
206 }
207
208 void LogPool::writeBinary(void) {
209   for(UInt i=0; i<numEntries; i++)
210     pool[i].writeBinary(fp);
211 }
212
213 #if CMK_PROJECTIONS_USE_ZLIB
214 void LogPool::writeCompressed(void) {
215   for(UInt i=0; i<numEntries; i++)
216     pool[i].writeCompressed(zfp);
217 }
218 #endif
219
220 void LogPool::writeSts(void)
221 {
222   fprintf(stsfp, "VERSION %s\n", PROJECTION_VERSION);
223   traceWriteSTS(stsfp,CkpvAccess(usrEvents)->length());
224   for(int i=0;i<CkpvAccess(usrEvents)->length();i++)
225     fprintf(stsfp, "EVENT %d %s\n", (*CkpvAccess(usrEvents))[i]->e, (*CkpvAccess(usrEvents))[i]->str);
226   fprintf(stsfp, "END\n");
227   fclose(stsfp);
228 }
229
230 #if CMK_BLUEGENE_CHARM
231 static void updateProjLog(void *data, double t, double recvT, void *ptr)
232 {
233   LogEntry *log = (LogEntry *)data;
234   FILE *fp = (FILE *)ptr;
235   log->time = t;
236   log->recvTime = recvT;
237   log->write(fp);
238 }
239 #endif
240
241 void LogPool::add(UChar type,UShort mIdx,UShort eIdx,double time,int event,int pe, int ml, CmiObjId *id, double recvT) 
242 {
243   new (&pool[numEntries++])
244     LogEntry(time, type, mIdx, eIdx, event, pe, ml, id, recvT);
245   if(poolSize==numEntries) {
246     double writeTime = TraceTimer();
247     writeLog();
248     numEntries = 0;
249     new (&pool[numEntries++]) LogEntry(writeTime, BEGIN_INTERRUPT);
250     new (&pool[numEntries++]) LogEntry(TraceTimer(), END_INTERRUPT);
251 #if CMK_BLUEGENE_CHARM
252     extern int correctTimeLog;
253     if (correctTimeLog) CmiAbort("I/O interrupt!\n");
254 #endif
255   }
256 #if CMK_BLUEGENE_CHARM
257   switch (type) {
258     case BEGIN_PROCESSING:
259       pool[numEntries-1].recvTime = BgGetRecvTime();
260     case END_PROCESSING:
261     case BEGIN_COMPUTATION:
262     case END_COMPUTATION:
263     case CREATION:
264     case BEGIN_PACK:
265     case END_PACK:
266     case BEGIN_UNPACK:
267     case END_UNPACK:
268     case USER_EVENT_PAIR:
269       bgAddProjEvent(&pool[numEntries-1], time, updateProjLog);
270   }
271 #endif
272 }
273
274 void LogPool::postProcessLog()
275 {
276 #if CMK_BLUEGENE_CHARM
277   bgUpdateProj(fp);
278 #endif
279 }
280
281 void LogEntry::write(FILE* fp)
282 {
283   fprintf(fp, "%d ", type);
284
285   switch (type) {
286     case USER_EVENT:
287     case USER_EVENT_PAIR:
288       fprintf(fp, "%d %u %d %d\n", mIdx, (UInt) (time*1.0e6), event, pe);
289       break;
290
291     case BEGIN_IDLE:
292     case END_IDLE:
293     case BEGIN_PACK:
294     case END_PACK:
295     case BEGIN_UNPACK:
296     case END_UNPACK:
297       fprintf(fp, "%u %d\n", (UInt) (time*1.0e6), pe);
298       break;
299
300     case BEGIN_PROCESSING:
301       fprintf(fp, "%d %d %u %d %d %d %d %d %d %d\n", mIdx, eIdx, (UInt) (time*1.0e6), event, pe, msglen, (UInt)(recvTime*1.e6), id.id[0], id.id[1], id.id[2]);
302       break;
303     case CREATION:
304       fprintf(fp, "%d %d %u %d %d %d %d\n", mIdx, eIdx, (UInt) (time*1.0e6), event, pe, msglen, (UInt)(recvTime*1.e6));
305       break;
306     case END_PROCESSING:
307     case MESSAGE_RECV:
308       fprintf(fp, "%d %d %u %d %d %d\n", mIdx, eIdx, (UInt) (time*1.0e6), event, pe, msglen);
309       break;
310
311     case ENQUEUE:
312     case DEQUEUE:
313       fprintf(fp, "%d %u %d %d\n", mIdx, (UInt) (time*1.0e6), event, pe);
314       break;
315
316     case BEGIN_INTERRUPT:
317     case END_INTERRUPT:
318       fprintf(fp, "%u %d %d\n", (UInt) (time*1.0e6), event, pe);
319       break;
320
321     case BEGIN_COMPUTATION:
322     case END_COMPUTATION:
323     fprintf(fp, "%u\n", (UInt) (time*1.0e6));
324       break;
325
326     default:
327       CmiError("***Internal Error*** Wierd Event %d.\n", type);
328       break;
329   }
330 }
331
332 #if CMK_PROJECTIONS_USE_ZLIB
333 void LogEntry::writeCompressed(gzFile zfp)
334 {
335   gzprintf(zfp, "%d ", type);
336
337   switch (type) {
338     case USER_EVENT:
339     case USER_EVENT_PAIR:
340       gzprintf(zfp, "%d %u %d %d\n", mIdx, (UInt) (time*1.0e6), event, pe);
341       break;
342
343     case BEGIN_IDLE:
344     case END_IDLE:
345     case BEGIN_PACK:
346     case END_PACK:
347     case BEGIN_UNPACK:
348     case END_UNPACK:
349       gzprintf(zfp, "%u %d\n", (UInt) (time*1.0e6), pe);
350       break;
351
352     case CREATION:
353       gzprintf(zfp, "%d %d %u %d %d %d %d\n", mIdx, eIdx, (UInt) (time*1.0e6), event, pe, msglen, (UInt)(recvTime*1.e6));
354       break;
355
356     case BEGIN_PROCESSING:
357     case END_PROCESSING:
358     case MESSAGE_RECV:
359       gzprintf(zfp, "%d %d %u %d %d %d\n", mIdx, eIdx, (UInt) (time*1.0e6), event, pe, msglen);
360       break;
361
362     case ENQUEUE:
363     case DEQUEUE:
364       gzprintf(zfp, "%d %u %d %d\n", mIdx, (UInt) (time*1.0e6), event, pe);
365       break;
366
367     case BEGIN_INTERRUPT:
368     case END_INTERRUPT:
369       gzprintf(zfp, "%u %d %d\n", (UInt) (time*1.0e6), event, pe);
370       break;
371
372     case BEGIN_COMPUTATION:
373     case END_COMPUTATION:
374       gzprintf(zfp, "%u\n", (UInt) (time*1.0e6));
375       break;
376
377     default:
378       CmiError("***Internal Error*** Wierd Event %d.\n", type);
379       break;
380   }
381 }
382 #endif
383
384 void LogEntry::writeBinary(FILE* fp)
385 {
386   UInt ttime = (UInt) (time*1.0e6);
387
388   fwrite(&type,sizeof(UChar),1,fp);
389
390   switch (type) {
391     case USER_EVENT:
392     case USER_EVENT_PAIR:
393       fwrite(&mIdx,sizeof(UShort),1,fp);
394       fwrite(&ttime,sizeof(UInt),1,fp);
395       fwrite(&event,sizeof(int),1,fp);
396       fwrite(&pe,sizeof(int),1,fp);
397       break;
398
399     case BEGIN_IDLE:
400     case END_IDLE:
401     case BEGIN_PACK:
402     case END_PACK:
403     case BEGIN_UNPACK:
404     case END_UNPACK:
405       fwrite(&ttime,sizeof(UInt),1,fp);
406       fwrite(&pe,sizeof(int),1,fp);
407       break;
408
409     case CREATION: {
410       fwrite(&mIdx,sizeof(UShort),1,fp);
411       fwrite(&eIdx,sizeof(UShort),1,fp);
412       fwrite(&ttime,sizeof(UInt),1,fp);
413       fwrite(&event,sizeof(int),1,fp);
414       fwrite(&pe,sizeof(int),1,fp);
415       fwrite(&msglen,sizeof(int),1,fp);
416       
417       double duration = (UInt)(recvTime*1.e6);
418       fwrite(&duration,sizeof(UInt),1,fp);
419       break;
420     }
421     case BEGIN_PROCESSING:
422     case END_PROCESSING:
423       fwrite(&mIdx,sizeof(UShort),1,fp);
424       fwrite(&eIdx,sizeof(UShort),1,fp);
425       fwrite(&ttime,sizeof(UInt),1,fp);
426       fwrite(&event,sizeof(int),1,fp);
427       fwrite(&pe,sizeof(int),1,fp);
428       fwrite(&msglen,sizeof(int),1,fp);
429       break;
430
431     case ENQUEUE:
432     case DEQUEUE:
433       fwrite(&mIdx,sizeof(UShort),1,fp);
434       fwrite(&ttime,sizeof(UInt),1,fp);
435       fwrite(&event,sizeof(int),1,fp);
436       fwrite(&pe,sizeof(int),1,fp);
437       break;
438
439     case BEGIN_INTERRUPT:
440     case END_INTERRUPT:
441       fwrite(&ttime,sizeof(UInt),1,fp);
442       fwrite(&event,sizeof(int),1,fp);
443       fwrite(&pe,sizeof(int),1,fp);
444       break;
445
446     case BEGIN_COMPUTATION:
447     case END_COMPUTATION:
448       fwrite(&ttime,sizeof(UInt),1,fp);
449       break;
450
451     default:
452       CmiError("***Internal Error*** Wierd Event %d.\n", type);
453       break;
454   }
455 }
456
457 TraceProjections::TraceProjections(char **argv): curevent(0), isIdle(0)
458 {
459   if (TRACE_CHARM_PE() == 0) return;
460
461   CtvInitialize(int,curThreadEvent);
462   CtvAccess(curThreadEvent)=0;
463   int binary = CmiGetArgFlagDesc(argv,"+binary-trace","Write log files in (unreadable) binary format");
464 #if CMK_PROJECTIONS_USE_ZLIB
465   int compressed = CmiGetArgFlagDesc(argv,"+gz-trace","Write log files pre-compressed with gzip");
466 #endif
467   _logPool = new LogPool(CkpvAccess(traceRoot));
468   _logPool->setBinary(binary);
469 #if CMK_PROJECTIONS_USE_ZLIB
470   _logPool->setCompressed(compressed);
471 #endif
472   _logPool->creatFiles();
473 }
474
475 /*
476 old version
477 int TraceProjections::traceRegisterUserEvent(const char* evt, int e=-1)
478 {
479   OPTIMIZED_VERSION
480   if(CkMyPe()==0) {
481     CkAssert(evt != NULL);
482     CkAssert(CkpvAccess(usrEventlist).length() ==  _numEvents);
483     CkpvAccess(usrEventlist).push_back((char *)evt);
484     return _numEvents++;
485   }
486   else
487     return 0;
488 }
489 */
490
491 int TraceProjections::traceRegisterUserEvent(const char* evt, int e)
492 {
493   OPTIMIZED_VERSION
494   CkAssert(e==-1 || e>=0);
495   CkAssert(evt != NULL);
496   int event;
497   int biggest = 0;
498   for (int i=0; i<CkpvAccess(usrEvents)->length(); i++) {
499     int cur = (*CkpvAccess(usrEvents))[i]->e;
500     if (cur == e) 
501       CmiAbort("UserEvent double registered!");
502     if (cur > biggest) biggest = cur;
503   }
504   if (e==-1) event = biggest;
505   else event = e;
506   CkpvAccess(usrEvents)->push_back(new UsrEvent(event,(char *)evt));
507   return event;
508 }
509
510 void TraceProjections::traceClearEps(void)
511 {
512   // In trace-summary, this zeros out the EP bins, to eliminate noise
513   // from startup.  Here, this isn't useful, since we can do that in
514   // post-processing
515 }
516
517 void TraceProjections::traceWriteSts(void)
518 {
519   if(CkMyPe()==0)
520     _logPool->writeSts();
521 }
522
523 void TraceProjections::traceClose(void)
524 {
525   
526   if(CkMyPe()==0){
527     _logPool->writeSts();
528   }
529   if (TRACE_CHARM_PE()) {
530     CkpvAccess(_trace)->endComputation();
531     delete _logPool;            // will write
532     // remove myself from traceArray so that no tracing will be called.
533     CkpvAccess(_traces)->removeTrace(this);
534 //    delete CkpvAccess(_trace);
535   }
536 //  free(CkpvAccess(traceRoot));
537 }
538
539 void TraceProjections::traceBegin(void)
540 {
541 #if ! CMK_TRACE_IN_CHARM
542   cancel_beginIdle = CcdCallOnConditionKeep(CcdPROCESSOR_BEGIN_IDLE,(CcdVoidFn)traceProjectionsBeginIdle,0);
543   cancel_endIdle = CcdCallOnConditionKeep(CcdPROCESSOR_BEGIN_BUSY,(CcdVoidFn)traceProjectionsEndIdle,0);
544 #endif
545 }
546
547 void TraceProjections::traceEnd(void) 
548 {
549 #if ! CMK_TRACE_IN_CHARM
550   CcdCancelCallOnConditionKeep(CcdPROCESSOR_BEGIN_IDLE, cancel_beginIdle);
551   CcdCancelCallOnConditionKeep(CcdPROCESSOR_BEGIN_BUSY, cancel_endIdle);
552 #endif
553 }
554
555 void TraceProjections::userEvent(int e)
556 {
557   _logPool->add(USER_EVENT, e, 0, TraceTimer(),curevent++,CkMyPe());
558 }
559
560 void TraceProjections::userBracketEvent(int e, double bt, double et)
561 {
562   // two events record Begin/End of event e.
563   _logPool->add(USER_EVENT_PAIR, e, 0, TraceTimer(bt), curevent, CkMyPe());
564   _logPool->add(USER_EVENT_PAIR, e, 0, TraceTimer(et), curevent++, CkMyPe());
565 }
566
567 void TraceProjections::creation(envelope *e, int ep, int num)
568 {
569   double curTime = TraceTimer();
570   if(e==0) {
571     CtvAccess(curThreadEvent)=curevent;
572     _logPool->add(CREATION,ForChareMsg,ep,curTime,
573                     curevent++,CkMyPe(), 0, 0, 0.0);
574   } else {
575     int type=e->getMsgtype();
576     e->setEvent(curevent);
577     for(int i=0; i<num; i++) {
578       _logPool->add(CREATION,type,ep, curTime,
579                     curevent+i,CkMyPe(),e->getTotalsize(), 0, 0.0);
580     }
581     curevent += num;
582   }
583 }
584
585 void TraceProjections::creationDone(int num)
586 {
587   // modified the creation done time of the last num log entries
588   // FIXME: totally a hack
589   double curTime = TraceTimer();
590   int idx = _logPool->numEntries-1;
591   while (idx >=0 && num >0 ) {
592     LogEntry &log = _logPool->pool[idx];
593     if (log.type == CREATION) {
594       log.recvTime = curTime - log.time;
595       num --;
596     }
597     idx--;
598   }
599 }
600
601 void TraceProjections::beginExecute(CmiObjId *tid)
602 {
603   execEvent = CtvAccess(curThreadEvent);
604   execEp = (-1);
605   _logPool->add(BEGIN_PROCESSING,ForChareMsg,_threadEP,TraceTimer(),
606                              execEvent,CkMyPe(), 0, tid);
607 }
608
609 void TraceProjections::beginExecute(envelope *e)
610 {
611   if(e==0) {
612     execEvent = CtvAccess(curThreadEvent);
613     execEp = (-1);
614     _logPool->add(BEGIN_PROCESSING,ForChareMsg,_threadEP,TraceTimer(),
615                              execEvent,CkMyPe());
616   } else {
617     beginExecute(e->getEvent(),e->getMsgtype(),e->getEpIdx(),e->getSrcPe(),e->getTotalsize());
618   }
619 }
620
621 void TraceProjections::beginExecute(int event,int msgType,int ep,int srcPe, int mlen,CmiObjId *idx)
622 {
623   execEvent=event;
624   execEp=ep;
625   execPe=srcPe;
626   _logPool->add(BEGIN_PROCESSING,msgType,ep,TraceTimer(),
627                              event,srcPe, mlen, idx);
628 }
629
630 void TraceProjections::endExecute(void)
631 {
632   if(execEp == (-1)) {
633     _logPool->add(END_PROCESSING,0,_threadEP,TraceTimer(),
634                              execEvent,CkMyPe());
635   } else {
636     _logPool->add(END_PROCESSING,0,execEp,TraceTimer(),
637                              execEvent,execPe);
638   }
639 }
640
641 void TraceProjections::messageRecv(char *env, int pe)
642 {
643 #if 0
644   envelope *e = (envelope *)env;
645   int msgType = e->getMsgtype();
646   int ep = e->getEpIdx();
647 #if 0
648   if (msgType==NewChareMsg || msgType==NewVChareMsg
649           || msgType==ForChareMsg || msgType==ForVidMsg
650           || msgType==BocInitMsg || msgType==NodeBocInitMsg
651           || msgType==ForBocMsg || msgType==ForNodeBocMsg)
652     ep = e->getEpIdx();
653   else
654     ep = _threadEP;
655 #endif
656   _logPool->add(MESSAGE_RECV,msgType,ep,TraceTimer(),
657                              curevent++,e->getSrcPe(), e->getTotalsize());
658 #endif
659 }
660
661 void TraceProjections::beginIdle(void)
662 {
663   if (isIdle == 0) {
664     _logPool->add(BEGIN_IDLE, 0, 0, TraceTimer(), 0, CkMyPe());
665     isIdle = 1;
666   }
667 }
668
669 void TraceProjections::endIdle(void)
670 {
671   if (isIdle) {
672     _logPool->add(END_IDLE, 0, 0, TraceTimer(), 0, CkMyPe());
673     isIdle = 0;
674   }
675 }
676
677 void TraceProjections::beginPack(void)
678 {
679   _logPool->add(BEGIN_PACK, 0, 0, TraceTimer(), 0, CkMyPe());
680 }
681
682 void TraceProjections::endPack(void)
683 {
684   _logPool->add(END_PACK, 0, 0, TraceTimer(), 0, CkMyPe());
685 }
686
687 void TraceProjections::beginUnpack(void)
688 {
689   _logPool->add(BEGIN_UNPACK, 0, 0, TraceTimer(), 0, CkMyPe());
690 }
691
692 void TraceProjections::endUnpack(void)
693 {
694   _logPool->add(END_UNPACK, 0, 0, TraceTimer(), 0, CkMyPe());
695 }
696
697 void TraceProjections::enqueue(envelope *) {}
698
699 void TraceProjections::dequeue(envelope *) {}
700
701 void TraceProjections::beginComputation(void)
702 {
703   _logPool->add(BEGIN_COMPUTATION, 0, 0, TraceTimer(), -1, -1);
704 }
705
706 void TraceProjections::endComputation(void)
707 {
708   _logPool->add(END_COMPUTATION, 0, 0, TraceTimer(), -1, -1);
709 }
710
711 /*@}*/