Charm++: Charm Source Code Documentation

00001 
00005 
00006 #include "charm.h"
00007 #include "middle.h"
00008 #include "cklists.h"
00009 #include "ckliststring.h"
00010 
00011 #include "trace.h"
00012 #include "trace-common.h"
00013 #include "allEvents.h"          //projector
00014 #include "register.h" // for _entryTable
00015 
00016 CpvCExtern(int, _traceCoreOn);   // projector
00017 
00018 #if ! CMK_TRACE_ENABLED
00019 static int warned = 0;
00020 #define OPTIMIZE_WARNING if (!warned) { warned=1;  CmiPrintf("\n\n!!!! Warning: tracing not available without CMK_TRACE_ENABLED!\n");  return;  }
00021 #else
00022 #define OPTIMIZE_WARNING /*empty*/
00023 #endif
00024 
00025 #define DEBUGF(x)          // CmiPrintf x
00026 
00027 CkpvDeclare(TraceArray*, _traces);              // lists of all trace modules
00028 
00029 /* trace for bluegene */
00030 class TraceBluegene;
00031 CkpvDeclare(TraceBluegene*, _tracebg);
00032 int traceBluegeneLinked=0;                      // if trace-bluegene is linked
00033 
00034 CkpvDeclare(double, traceInitTime);
00035 CkpvDeclare(double, traceInitCpuTime);
00036 CpvDeclare(int, traceOn);
00037 CkpvDeclare(int, traceOnPe);
00038 CkpvDeclare(char*, traceRoot);
00039 CkpvDeclare(int, traceRootBaseLength);
00040 CkpvDeclare(char*, selective);
00041 CkpvDeclare(bool, verbose);
00042 
00043 typedef void (*mTFP)();                   // function pointer for
00044 CpvStaticDeclare(mTFP, machineTraceFuncPtr);    // machine user event
00045                                           // registration
00046 
00047 int _threadMsg, _threadChare, _threadEP;
00048 int _packMsg, _packChare, _packEP;
00049 int _unpackMsg, _unpackChare, _unpackEP;
00050 int _dummyMsg, _dummyChare, _dummyEP;
00051 
00053 static void traceCommonInit(char **argv)
00054 {
00055   CmiArgGroup("Charm++","Tracing");
00056   DEBUGF(("[%d] in traceCommonInit.\n", CkMyPe()));
00057   CkpvInitialize(double, traceInitTime);
00058   CkpvAccess(traceInitTime) = CmiStartTimer();
00059   CkpvInitialize(double, traceInitCpuTime);
00060   CkpvAccess(traceInitCpuTime) = TRACE_CPUTIMER();
00061   CpvInitialize(int, traceOn);
00062   CpvAccess(traceOn) = 0;
00063   CpvInitialize(int, _traceCoreOn); //projector
00064   CpvAccess(_traceCoreOn)=0; //projector
00065   CpvInitialize(mTFP, machineTraceFuncPtr);
00066   CpvAccess(machineTraceFuncPtr) = NULL;
00067   CkpvInitialize(int, traceOnPe);
00068   CkpvAccess(traceOnPe) = 1;
00069 
00070   CkpvInitialize(bool, verbose);
00071   if (CmiGetArgFlag(argv, "+traceWarn")) {
00072     CkpvAccess(verbose) = true;
00073   } else {
00074     CkpvAccess(verbose) = false;
00075   }
00076 
00077   char *root;
00078   char *temproot;
00079   char *temproot2;
00080   CkpvInitialize(char*, traceRoot);
00081   CkpvInitialize(int, traceRootBaseLength);
00082   if (CmiGetArgStringDesc(argv, "+traceroot", &temproot, "Directory to write trace files to")) {
00083     int i;
00084     // Trying to decide if the traceroot path is absolute or not. If it is not
00085     // then create an absolute pathname for it.
00086     if (temproot[0] != PATHSEP) {
00087       temproot2 = GETCWD(NULL,0);
00088       root = (char *)malloc(strlen(temproot2)+1+strlen(temproot)+1);
00089       strcpy(root, temproot2);
00090       strcat(root, PATHSEPSTR);
00091       strcat(root, temproot);
00092     } else {
00093       root = (char *)malloc(strlen(temproot)+1);
00094       strcpy(root,temproot);
00095     }
00096     for (i=strlen(argv[0])-1; i>=0; i--) if (argv[0][i] == PATHSEP) break;
00097     i++;
00098     CkpvAccess(traceRootBaseLength) = strlen(root)+1;
00099     CkpvAccess(traceRoot) = (char *)malloc(strlen(argv[0]+i) + strlen(root) + 2);    _MEMCHECK(CkpvAccess(traceRoot));
00100     strcpy(CkpvAccess(traceRoot), root);
00101     strcat(CkpvAccess(traceRoot), PATHSEPSTR);
00102     strcat(CkpvAccess(traceRoot), argv[0]+i);
00103     if (CkMyPe() == 0) 
00104       CmiPrintf("Trace: traceroot: %s\n", CkpvAccess(traceRoot));
00105   }
00106   else {
00107     CkpvAccess(traceRoot) = (char *) malloc(strlen(argv[0])+1);
00108     _MEMCHECK(CkpvAccess(traceRoot));
00109     strcpy(CkpvAccess(traceRoot), argv[0]);
00110   }
00111         /* added for TAU trace module. */
00112         char *cwd;
00113   CkpvInitialize(char*, selective);
00114   if (CmiGetArgStringDesc(argv, "+selective", &temproot, "TAU's selective instrumentation file")) {
00115     // Trying to decide if the traceroot path is absolute or not. If it is not
00116     // then create an absolute pathname for it.
00117     if (temproot[0] != PATHSEP) {
00118       cwd = GETCWD(NULL,0);
00119       root = (char *)malloc(strlen(cwd)+strlen(temproot)+2);
00120       strcpy(root, cwd);
00121       strcat(root, PATHSEPSTR);
00122       strcat(root, temproot);
00123     } else {
00124       root = (char *)malloc(strlen(temproot)+1);
00125       strcpy(root,temproot);
00126     }
00127     CkpvAccess(selective) = (char *) malloc(strlen(root)+1);
00128     _MEMCHECK(CkpvAccess(selective));
00129     strcpy(CkpvAccess(selective), root);
00130     if (CkMyPe() == 0) 
00131       CmiPrintf("Trace: selective: %s\n", CkpvAccess(selective));
00132   }
00133   else {
00134     CkpvAccess(selective) = (char *) malloc(3);
00135     _MEMCHECK(CkpvAccess(selective));
00136     strcpy(CkpvAccess(selective), "");
00137   }
00138   
00139 #ifdef __BIGSIM__
00140   if(BgNodeRank()==0) {
00141 #else
00142   if(CkMyRank()==0) {
00143 #endif
00144     _threadMsg = CkRegisterMsg("dummy_thread_msg", 0, 0, 0, 0);
00145     _threadChare = CkRegisterChare("dummy_thread_chare", 0, TypeInvalid);
00146     CkRegisterChareInCharm(_threadChare);
00147     _threadEP = CkRegisterEp("dummy_thread_ep", 0, _threadMsg,_threadChare, 0+CK_EP_INTRINSIC);
00148 
00149     _packMsg = CkRegisterMsg("dummy_pack_msg", 0, 0, 0, 0);
00150     _packChare = CkRegisterChare("dummy_pack_chare", 0, TypeInvalid);
00151     CkRegisterChareInCharm(_packChare);
00152     _packEP = CkRegisterEp("dummy_pack_ep", 0, _packMsg,_packChare, 0+CK_EP_INTRINSIC);
00153 
00154     _unpackMsg = CkRegisterMsg("dummy_unpack_msg", 0, 0, 0, 0);
00155     _unpackChare = CkRegisterChare("dummy_unpack_chare", 0, TypeInvalid);
00156     CkRegisterChareInCharm(_unpackChare);
00157     _unpackEP = CkRegisterEp("dummy_unpack_ep", 0, _unpackMsg,_unpackChare, 0+CK_EP_INTRINSIC);
00158 
00159     _dummyMsg = CkRegisterMsg("dummy_msg", 0, 0, 0, 0);
00160     _dummyChare = CkRegisterChare("dummy_chare", 0, TypeInvalid);
00161     CkRegisterChareInCharm(_dummyChare);
00162     _dummyEP = CkRegisterEp("dummy_ep", 0, _dummyMsg,_dummyChare, 0+CK_EP_INTRINSIC);
00163   }
00164 }
00165 
00167 void traceWriteSTS(FILE *stsfp,int nUserEvents) {
00168   fprintf(stsfp, "MACHINE %s\n",CMK_MACHINE_NAME);
00169 #if CMK_SMP_TRACE_COMMTHREAD
00170   //Assuming there's only 1 comm thread now! --Chao Mei
00171   //considering the extra comm thread per node
00172   fprintf(stsfp, "PROCESSORS %d\n", CkNumPes()+CkNumNodes());  
00173   fprintf(stsfp, "SMPMODE %d %d\n", CkMyNodeSize(), CkNumNodes());
00174 #else   
00175   fprintf(stsfp, "PROCESSORS %d\n", CkNumPes());
00176 #endif  
00177   fprintf(stsfp, "TOTAL_CHARES %d\n", (int)_chareTable.size());
00178   fprintf(stsfp, "TOTAL_EPS %d\n", (int)_entryTable.size());
00179   fprintf(stsfp, "TOTAL_MSGS %d\n", (int)_msgTable.size());
00180   fprintf(stsfp, "TOTAL_PSEUDOS %d\n", (int)0);
00181   fprintf(stsfp, "TOTAL_EVENTS %d\n", (int)nUserEvents);
00182   size_t i;
00183   for(i=0;i<_chareTable.size();i++)
00184     fprintf(stsfp, "CHARE %d %s\n", (int)i, _chareTable[i]->name);
00185   for(i=0;i<_entryTable.size();i++)
00186     fprintf(stsfp, "ENTRY CHARE %d %s %d %d\n", (int)i, _entryTable[i]->name,
00187                  (int)_entryTable[i]->chareIdx, (int)_entryTable[i]->msgIdx);
00188   for(i=0;i<_msgTable.size();i++)
00189     fprintf(stsfp, "MESSAGE %d %u\n", (int)i, (int)_msgTable[i]->size);
00190 }
00191 
00192 extern "C"
00193 void traceCommonBeginIdle(void *proj,double curWallTime)
00194 {
00195   ((TraceArray *)proj)->beginIdle(curWallTime);
00196 }
00197  
00198 extern "C"
00199 void traceCommonEndIdle(void *proj,double curWallTime)
00200 {
00201   ((TraceArray *)proj)->endIdle(curWallTime);
00202 }
00203 
00204 void TraceArray::traceBegin() {
00205   if (n==0) return; // No tracing modules registered.
00206 #if ! CMK_TRACE_IN_CHARM
00207   cancel_beginIdle = CcdCallOnConditionKeep(CcdPROCESSOR_BEGIN_IDLE,(CcdVoidFn)traceCommonBeginIdle,this);
00208   cancel_endIdle = CcdCallOnConditionKeep(CcdPROCESSOR_BEGIN_BUSY,(CcdVoidFn)traceCommonEndIdle,this);
00209 #endif
00210   ALLDO(traceBegin());
00211 }
00212 
00213 void TraceArray::traceBeginOnCommThread() {
00214 #if CMK_SMP_TRACE_COMMTHREAD
00215   if (n==0) return; // No tracing modules registered.
00216 /*#if ! CMK_TRACE_IN_CHARM      
00217   cancel_beginIdle = CcdCallOnConditionKeep(CcdPROCESSOR_BEGIN_IDLE,(CcdVoidFn)traceCommonBeginIdle,this);
00218   cancel_endIdle = CcdCallOnConditionKeep(CcdPROCESSOR_BEGIN_BUSY,(CcdVoidFn)traceCommonEndIdle,this);
00219 #endif*/
00220   ALLDO(traceBeginOnCommThread());
00221 #endif
00222 }
00223 
00224 void TraceArray::traceEnd() {
00225   if (n==0) return; // No tracing modules registered.
00226   ALLDO(traceEnd());
00227 #if ! CMK_TRACE_IN_CHARM
00228   CcdCancelCallOnConditionKeep(CcdPROCESSOR_BEGIN_IDLE, cancel_beginIdle);
00229   CcdCancelCallOnConditionKeep(CcdPROCESSOR_BEGIN_BUSY, cancel_endIdle);
00230 #endif
00231 }
00232 
00233 void TraceArray::traceEndOnCommThread() {
00234 #if CMK_SMP_TRACE_COMMTHREAD
00235   if (n==0) return; // No tracing modules registered.
00236   ALLDO(traceEndOnCommThread());
00237 /*#if ! CMK_TRACE_IN_CHARM
00238   CcdCancelCallOnConditionKeep(CcdPROCESSOR_BEGIN_IDLE, cancel_beginIdle);
00239   CcdCancelCallOnConditionKeep(CcdPROCESSOR_BEGIN_BUSY, cancel_endIdle);
00240 #endif*/
00241 #endif
00242 }
00243 
00244 #if CMK_MULTICORE
00245 extern int Cmi_commthread;
00246 #endif
00247 
00248 /*Install the beginIdle/endIdle condition handlers.*/
00249 extern "C" void traceBegin(void) {
00250 #if CMK_TRACE_ENABLED
00251   DEBUGF(("[%d] traceBegin called with %d at %f\n", CkMyPe(), CpvAccess(traceOn), TraceTimer()));
00252   
00253 #if CMK_SMP_TRACE_COMMTHREAD
00254   //the first core of this node controls the condition of comm thread
00255 #if CMK_MULTICORE
00256   if (Cmi_commthread)
00257 #endif
00258   if(CmiMyRank()==0){
00259         if(CpvAccessOther(traceOn, CmiMyNodeSize())!=1){
00260                 CkpvAccessOther(_traces, CmiMyNodeSize())->traceBeginOnCommThread();            
00261                 CpvAccessOther(traceOn, CmiMyNodeSize()) = 1;
00262         }
00263   }
00264 #endif
00265   if (CpvAccess(traceOn)==1) return;
00266   CkpvAccess(_traces)->traceBegin();
00267   CpvAccess(traceOn) = 1;
00268 #endif
00269 }
00270 
00271 /*Cancel the beginIdle/endIdle condition handlers.*/
00272 extern "C" void traceEnd(void) {
00273 #if CMK_TRACE_ENABLED
00274   DEBUGF(("[%d] traceEnd called with %d at %f\n", CkMyPe(), CpvAccess(traceOn), TraceTimer()));
00275 
00276 #if CMK_SMP_TRACE_COMMTHREAD
00277 //the first core of this node controls the condition of comm thread
00278 #if CMK_MULTICORE
00279   if (Cmi_commthread)
00280 #endif
00281   if(CmiMyRank()==0){
00282         if(CkpvAccessOther(traceOn, CmiMyNodeSize())!=0){
00283                 CkpvAccessOther(_traces, CmiMyNodeSize())->traceEndOnCommThread();
00284                 CkpvAccessOther(traceOn, CmiMyNodeSize()) = 0;
00285         }
00286 }
00287 #endif
00288         
00289         
00290   if (CpvAccess(traceOn)==0) return;
00291   if (CkpvAccess(_traces) == NULL) {
00292     CmiPrintf("Warning: did you mix compilation with and without -DCMK_TRACE_ENABLED? \n");
00293   }
00294   CkpvAccess(_traces)->traceEnd();
00295   CpvAccess(traceOn) = 0;
00296 #endif
00297 }
00298 
00299 static int checkTraceOnPe(char **argv)
00300 {
00301   int traceOnPE = 1;
00302   char *procs = NULL;
00303 #if CMK_BIGSIM_CHARM
00304   // check bgconfig file for settings
00305   traceOnPE=0;
00306   if (BgTraceProjectionOn(CkMyPe())) traceOnPE = 1;
00307 #endif
00308   if (CmiGetArgStringDesc(argv, "+traceprocessors", &procs, "A list of processors to trace, e.g. 0,10,20-30"))
00309   {
00310     CkListString procList(procs);
00311     traceOnPE = procList.includes(CkMyPe());
00312   }
00313   // must include pe 0, otherwise sts file is not generated
00314   if (CkMyPe()==0) traceOnPE = 1;
00315 #if !CMK_TRACE_IN_CHARM
00316 #if !CMK_SMP_TRACE_COMMTHREAD
00317   /* skip communication thread */
00318   traceOnPE = traceOnPE && (CkMyRank() != CkMyNodeSize());
00319 #endif
00320 #endif
00321   return traceOnPE;
00322 }
00323 
00325 void _createTraces(char **argv);
00326 
00327 
00328 bool enableCPTracing; // A global variable specifying whether or not the control point tracing module should be active in the run
00329 extern void _registerTraceControlPoints();
00330 extern void _createTracecontrolPoints(char **argv);
00331 
00332 
00337 
00338 static inline void _traceInit(char **argv) 
00339 {
00340   CkpvInitialize(TraceArray *, _traces);
00341   CkpvAccess(_traces) = new TraceArray;
00342 
00343   // common init
00344   traceCommonInit(argv);
00345 
00346   // check if trace is turned on/off for this pe
00347   CkpvAccess(traceOnPe) = checkTraceOnPe(argv);
00348 
00349   // defined in moduleInit.C
00350   _createTraces(argv);
00351 
00352   // Now setup the control point tracing module if desired. It is always compiled/linked in, but is not always enabled
00353   // FIXME: make sure it is safe to use argv in SMP version 
00354   // because CmiGetArgFlagDesc is destructive and this is called on all PEs.
00355   if( CmiGetArgFlagDesc(argv,"+CPEnableMeasurements","Enable recording of measurements for Control Points") ){
00356     enableCPTracing = true;
00357     _createTracecontrolPoints(argv);   
00358   } else {
00359     enableCPTracing = false;
00360   }
00361   
00362 
00363   // set trace on/off
00364   CkpvAccess(_traces)->setTraceOnPE(CkpvAccess(traceOnPe));
00365 
00366 #if CMK_SMP_TRACE_COMMTHREAD
00367 
00376    CmiBarrier();
00377 #endif
00378 
00379   if (CkpvAccess(_traces)->length() && !CmiGetArgFlagDesc(argv,"+traceoff","Disable tracing"))
00380     traceBegin();
00381 }
00382 
00384 extern "C" void traceInit(char **argv) 
00385 {
00386 #if ! CMK_TRACE_IN_CHARM
00387   _traceInit(argv);
00388   initTraceCore(argv);
00389 #endif
00390 }
00391 
00393 extern "C" void traceCharmInit(char **argv) 
00394 {
00395 #if CMK_TRACE_IN_CHARM
00396   _traceInit(argv);
00397 #endif
00398 }
00399 
00400 // CMK_TRACE_ENABLED is already guarded in convcore.c
00401 extern "C"
00402 void traceMessageRecv(char *msg, int pe)
00403 {
00404 #if ! CMK_TRACE_IN_CHARM
00405   CkpvAccessOther(_traces, CmiRankOf(pe))->messageRecv(msg, pe);
00406 #endif
00407 }
00408 
00409 extern "C" 
00410 void traceBeginIdle()
00411 {
00412     _TRACE_ONLY(CkpvAccess(_traces)->beginIdle(CmiWallTimer()));
00413 }
00414 
00415 extern "C" 
00416 void traceEndIdle()
00417 {
00418     _TRACE_ONLY(CkpvAccess(_traces)->endIdle(CmiWallTimer()));
00419 }
00420 
00421 // CMK_TRACE_ENABLED is already guarded in convcore.c
00422 // converse thread tracing is not supported in blue gene simulator
00423 // in BigSim, threads need to be traced manually (because virtual processors
00424 // themselves are implemented as threads and we don't want them to be traced
00425 // In BigSim, so far, only AMPI threads are traced.
00426 extern "C"
00427 void traceResume(CmiObjId *tid)
00428 {
00429     _TRACE_ONLY(CkpvAccess(_traces)->beginExecute(tid));
00430     if(CpvAccess(_traceCoreOn))
00431             resumeTraceCore();
00432 }
00433 
00434 extern "C"
00435 void traceSuspend(void)
00436 {
00437   _TRACE_ONLY(CkpvAccess(_traces)->endExecute());
00438 }
00439 
00440 extern "C"
00441 void traceAwaken(CthThread t)
00442 {
00443   CkpvAccess(_traces)->creation(0, _threadEP);
00444 }
00445 
00446 extern "C"
00447 void traceUserEvent(int e)
00448 {
00449 #if CMK_TRACE_ENABLED
00450   if (CpvAccess(traceOn))
00451     CkpvAccess(_traces)->userEvent(e);
00452 #endif
00453 }
00454 
00455 extern "C"
00456 void traceUserBracketEvent(int e, double beginT, double endT)
00457 {
00458 #if CMK_TRACE_ENABLED
00459   if (CpvAccess(traceOn) && CkpvAccess(_traces))
00460     CkpvAccess(_traces)->userBracketEvent(e, beginT, endT);
00461 #endif
00462 }
00463 
00464 extern "C"
00465 void traceUserSuppliedData(int d)
00466 {
00467 #if CMK_TRACE_ENABLED
00468   if (CpvAccess(traceOn) && CkpvAccess(_traces))
00469     CkpvAccess(_traces)->userSuppliedData(d);
00470 #endif
00471 }
00472 
00473 extern "C"
00474 void traceUserSuppliedNote(char * note)
00475 {
00476 #if CMK_TRACE_ENABLED
00477   if (CpvAccess(traceOn) && CkpvAccess(_traces))
00478     CkpvAccess(_traces)->userSuppliedNote(note);
00479 #endif
00480 }
00481 
00482 
00483 extern "C"
00484 void traceUserSuppliedBracketedNote(char *note, int eventID, double bt, double et)
00485 {
00486   //CkPrintf("traceUserSuppliedBracketedNote(char *note, int eventID, double bt, double et)\n");
00487 #if CMK_TRACE_ENABLED
00488   if (CpvAccess(traceOn) && CkpvAccess(_traces))
00489     CkpvAccess(_traces)->userSuppliedBracketedNote(note, eventID, bt, et);
00490 #endif
00491 }
00492 
00493 
00494 extern "C"
00495 void traceMemoryUsage()
00496 {
00497 #if CMK_TRACE_ENABLED
00498   double d = CmiMemoryUsage()*1.0;
00499 
00500   if (CpvAccess(traceOn) && CkpvAccess(_traces))
00501     CkpvAccess(_traces)->memoryUsage(d);
00502 #endif
00503 }
00504 
00505 extern "C"
00506 void tracePhaseEnd()
00507 {
00508   _TRACE_ONLY(CkpvAccess(_traces)->endPhase());
00509 }
00510 
00511 extern "C"
00512 void registerMachineUserEventsFunction(void (*eventRegistrationFunc)()) {
00513   CmiAssert(CpvInitialized(machineTraceFuncPtr));
00514   CpvAccess(machineTraceFuncPtr) = eventRegistrationFunc;
00515 }
00516 
00517 extern "C"
00518 void (*registerMachineUserEvents())() {
00519   CmiAssert(CpvInitialized(machineTraceFuncPtr));
00520   if (CpvAccess(machineTraceFuncPtr) != NULL) {
00521     return CpvAccess(machineTraceFuncPtr);
00522   } else {
00523     return NULL;
00524   }
00525 }
00526 
00527 extern "C"
00528 int traceRegisterUserEvent(const char*x, int e)
00529 {
00530 #if CMK_TRACE_ENABLED
00531   return CkpvAccess(_traces)->traceRegisterUserEvent(x, e);
00532 #else
00533   return 0;
00534 #endif
00535 }
00536 
00537 extern "C"
00538 void traceClearEps(void)
00539 {
00540   OPTIMIZE_WARNING
00541   CkpvAccess(_traces)->traceClearEps();
00542 }
00543 
00544 extern "C"
00545 void traceWriteSts(void)
00546 {
00547   OPTIMIZE_WARNING
00548   CkpvAccess(_traces)->traceWriteSts();
00549 }
00550 
00551 extern "C"
00552 void traceFlushLog(void)
00553 {
00554   OPTIMIZE_WARNING
00555   CkpvAccess(_traces)->traceFlushLog();
00556 }
00557 
00562 extern "C"
00563 void traceClose(void)
00564 {
00565 #if ! CMK_BIGSIM_CHARM
00566   OPTIMIZE_WARNING
00567   CkpvAccess(_traces)->traceClose();
00568 #endif   
00569 }
00570 
00571 extern "C"
00572 void traceCharmClose(void)
00573 {
00574 #if CMK_BIGSIM_CHARM
00575   OPTIMIZE_WARNING
00576   CkpvAccess(_traces)->traceClose();
00577 #endif
00578 }
00579 
00580 /* **CW** This is the API called from user code to support CCS operations 
00581    if supported by the underlying trace module.
00582  */
00583 extern "C"
00584 void traceEnableCCS(void)
00585 {
00586   OPTIMIZE_WARNING
00587   CkpvAccess(_traces)->traceEnableCCS();  
00588 }
00589 
00590 /* **CW** Support for thread listeners. This makes a call to each
00591    trace module which must support the call.
00592 */
00593 extern "C"
00594 void traceAddThreadListeners(CthThread tid, envelope *e) {
00595   _TRACE_ONLY(CkpvAccess(_traces)->traceAddThreadListeners(tid, e));
00596 }
00597 
00598 #if 1
00599 // helper functions
00600 extern int _charmHandlerIdx;
00601 class CkCoreState;
00602 extern void _processHandler(void *, CkCoreState*);
00603 extern "C" int isCharmEnvelope(void *msg);
00604 int CkIsCharmMessage(char *msg)
00605 {
00606 //CmiPrintf("[%d] CkIsCharmMessage: %d %p %d %p\n", CkMyPe(),CmiGetHandler(msg), CmiGetHandlerFunction(msg), _charmHandlerIdx, _processHandler);
00607   if ((CmiGetHandler(msg) == _charmHandlerIdx) &&
00608          (CmiGetHandlerFunction(msg) == (CmiHandlerEx)_processHandler))
00609     return 1;
00610   if (CmiGetXHandler(msg) == _charmHandlerIdx) return isCharmEnvelope(msg);
00611   return 0;
00612 }
00613 #endif
00614 
00615 // return 1 if any one of tracing modules is linked.
00616 int  traceAvailable()
00617 {
00618 #if ! CMK_TRACE_ENABLED
00619   return 0;
00620 #else
00621   return CkpvAccess(_traces)->length()>0;
00622 #endif
00623 }
00624 
00625 double CmiTraceTimer()
00626 {
00627   return TraceTimer();
00628 }
00629 
00630 void TraceArray::creation(envelope *env, int ep, int num)
00631 { 
00632     if (_entryTable[ep]->traceEnabled)
00633         ALLDO(creation(env, ep, num));
00634 }
00635 
00636 void TraceArray::creationMulticast(envelope *env, int ep, int num,
00637                                    int *pelist)
00638 {
00639   if (_entryTable[ep]->traceEnabled)
00640     ALLDO(creationMulticast(env, ep, num, pelist));
00641 }
00642 
00643 /*
00644 extern "C" 
00645 void registerFunction(char *name){
00646         _TRACE_ONLY(CkpvAccess(_traces)->regFunc(name));
00647 }
00648 */
00649 
00650 extern "C"
00651 int traceRegisterFunction(const char* name, int idx) {
00652 #if CMK_TRACE_ENABLED
00653   if(idx==-999){
00654     CkpvAccess(_traces)->regFunc(name, idx);
00655   } else {
00656     CkpvAccess(_traces)->regFunc(name, idx, 1);
00657   }
00658   return idx;
00659 #else
00660   return 0;
00661 #endif
00662 }
00663 
00664 extern "C" 
00665 void traceBeginFuncProj(char *name,char *file,int line){
00666          _TRACE_ONLY(CkpvAccess(_traces)->beginFunc(name,file,line));
00667 }
00668 
00669 extern "C"
00670 void traceBeginFuncIndexProj(int idx,char *file,int line){
00671          _TRACE_ONLY(CkpvAccess(_traces)->beginFunc(idx,file,line));
00672 }
00673 
00674 extern "C" 
00675 void traceEndFuncProj(char *name){
00676          _TRACE_ONLY(CkpvAccess(_traces)->endFunc(name));
00677 }
00678 
00679 extern "C" 
00680 void traceEndFuncIndexProj(int idx){
00681          _TRACE_ONLY(CkpvAccess(_traces)->endFunc(idx));
00682 }
00683 
00684 #if CMK_SMP_TRACE_COMMTHREAD
00685 extern "C"
00686 int traceBeginCommOp(char *msg){
00687 #if CMK_TRACE_ENABLED
00688   if (CpvAccess(traceOn) && CkpvAccess(_traces) && CkIsCharmMessage(msg)) {
00689     CkpvAccess(_traces)->beginExecute(msg);
00690     return 1;
00691   }
00692   return 0;
00693 #endif
00694 }
00695 
00696 extern "C"
00697 void traceEndCommOp(char *msg){
00698 #if CMK_TRACE_ENABLED
00699   if (CpvAccess(traceOn) && CkpvAccess(_traces) && CkIsCharmMessage(msg))
00700     CkpvAccess(_traces)->endExecute(msg);
00701 #endif
00702 }
00703 
00704 extern "C"
00705 void traceSendMsgComm(char *msg){
00706 #if CMK_TRACE_ENABLED
00707   if (CpvAccess(traceOn) && CkpvAccess(_traces) && CkIsCharmMessage(msg))
00708     CkpvAccess(_traces)->creation(msg);
00709 #endif
00710 }
00711 
00712 extern "C"
00713 void traceCommSetMsgID(char *msg){
00714 #if CMK_TRACE_ENABLED
00715   if (CpvAccess(traceOn) && CkpvAccess(_traces) && CkIsCharmMessage(msg))
00716     CkpvAccess(_traces)->traceCommSetMsgID(msg);
00717 #endif
00718 }
00719 
00720 #endif
00721 
00722 extern "C"
00723 void traceGetMsgID(char *msg, int *pe, int *event)
00724 {
00725 #if CMK_TRACE_ENABLED
00726   if (CpvAccess(traceOn) && CkpvAccess(_traces) && CkIsCharmMessage(msg))
00727     CkpvAccess(_traces)->traceGetMsgID(msg, pe, event);
00728 #endif
00729 }
00730 
00731 extern "C"
00732 void traceSetMsgID(char *msg, int pe, int event)
00733 {
00734 #if CMK_TRACE_ENABLED
00735   if (CpvAccess(traceOn) && CkpvAccess(_traces) && CkIsCharmMessage(msg))
00736     CkpvAccess(_traces)->traceSetMsgID(msg, pe, event);
00737 #endif
00738 }
00739 
00740 
00741 extern "C"
00742 void traceChangeLastTimestamp(double ts){
00743 #if CMK_TRACE_ENABLED
00744   if (CpvAccess(traceOn) && CkpvAccess(_traces))
00745     CkpvAccess(_traces)->changeLastEntryTimestamp(ts);
00746 #endif
00747 }
00748
ck-perf/trace-common.C
