Some instrumentation for projector
authorSayantan Chakravorty <sayantan_chak@yahoo.com>
Sun, 22 Dec 2002 13:54:29 +0000 (13:54 +0000)
committerSayantan Chakravorty <sayantan_chak@yahoo.com>
Sun, 22 Dec 2002 13:54:29 +0000 (13:54 +0000)
src/conv-core/convcore.c
src/conv-perf/charmEvents.h
src/conv-perf/charmProjections.C
src/conv-perf/charmProjections.h
src/conv-perf/converseEvents.h
src/conv-perf/converseProjections.C
src/conv-perf/converseProjections.h
src/conv-perf/traceCore.C
src/conv-perf/traceCore.h
src/conv-perf/traceCoreCommon.C

index bd7550b3cfe3ba4afbed0061ff1003ca3b7adef6..f338b24fce40a3fc3cec0da89ec965f669938e54 100644 (file)
 #include "conv-ccs.h"
 #include "ccs-server.h"
 #include "memory-isomalloc.h"
+#include "converseEvents.h"             // projector
+#include "traceCoreCommon.h"    // projector
+#include "machineEvents.h"     //projector
 
+CpvExtern(int, _traceCoreOn);   // projector
 extern void CcdModuleInit(char **);
 extern void CmiMemoryInit(char **);
 extern void CldModuleInit(void);
@@ -846,6 +850,7 @@ void (*handler)();
 void CsdBeginIdle(void)
 {
   CcdCallBacks();
+  _LOG_E_PROC_IDLE();  // projector
   CcdRaiseCondition(CcdPROCESSOR_BEGIN_IDLE) ;
 }
 
@@ -856,6 +861,7 @@ void CsdStillIdle(void)
 
 void CsdEndIdle(void)
 {
+  _LOG_E_PROC_BUSY();  // projector
   CcdRaiseCondition(CcdPROCESSOR_BEGIN_BUSY) ;
 }
 
@@ -864,8 +870,11 @@ void CmiHandleMessage(void *msg)
 /* this is wrong because it counts the Charm++ messages in sched queue
        CpvAccess(cQdState)->mProcessed++;
 */
-       CmiHandlerInfo *h=&CmiGetHandlerInfo(msg);
+        CmiHandlerInfo *h;
+       _LOG_E_HANDLER_BEGIN(CmiGetHandler(msg)); // projector
+       h=&CmiGetHandlerInfo(msg);
        (h->hdlr)(msg,h->userPtr);
+       _LOG_E_HANDLER_END(CmiGetHandler(msg));         // projector
 }
 
 #if CMK_CMIDELIVERS_USE_COMMON_CODE
@@ -1082,6 +1091,11 @@ void CthResumeNormalThread(CthThread t)
   if(CpvAccess(traceOn))
     CthTraceResume(t);
 #endif
+/*#ifndef CMK_OPTIMIZE    // projector
+    if(CpvAccess(_traceCoreOn))
+               resumeTraceCore();
+#endif*/
+    
   CthResume(t);
 }
 
@@ -1823,6 +1837,10 @@ void ConverseCommonInit(char **argv)
 #ifndef CMK_OPTIMIZE
   traceInit(argv);
 #endif
+/*#ifndef CMK_OPTIMIZE    // projector
+    initTraceCore(argv);
+#endif*/
+
 #if CMK_CCS_AVAILABLE
   CcsInit(argv);
 #endif
@@ -1850,6 +1868,10 @@ void ConverseCommonExit(void)
 #ifndef CMK_OPTIMIZE
   traceClose();
 #endif
+/*#ifndef CMK_OPTIMIZE    // projector
+    closeTraceCore();
+#endif*/
+
 }
 
 
index ebf16b8d832390e51a45523abe6509760f8d898a..f881d729c307f22cb51ea6eeaedcc14c8a69c4a4 100644 (file)
@@ -6,7 +6,7 @@
 #include "traceCoreAPI.h"
 
 /* Language ID */
-#define _CHARM_LANG_ID         2       // language ID for charm 
+#define _CHARM_LANG_ID         2       // language ID for charm
 
 /* Event IDs */
 #define  _E_CREATION                   1
@@ -27,7 +27,7 @@
 
 /* Trace Macros */
 #define REGISTER_CHARM \
-       { RegisterLanguage(_CHARM_LANG_ID, "charm"); \
+       { RegisterLanguage(_CHARM_LANG_ID, "charm\0"); \
          RegisterEvent(_CHARM_LANG_ID, _E_CREATION         ); \
          RegisterEvent(_CHARM_LANG_ID, _E_BEGIN_PROCESSING ); \
          RegisterEvent(_CHARM_LANG_ID, _E_END_PROCESSING   ); \
          RegisterEvent(_CHARM_LANG_ID, _E_END_PACK         ); \
          RegisterEvent(_CHARM_LANG_ID, _E_BEGIN_UNPACK     ); \
          RegisterEvent(_CHARM_LANG_ID, _E_END_UNPACK       ); \
+         \
        }
-#define _LOG_E_CREATION_1(env)                 { creation(env); }
-#define _LOG_E_CREATION_N(env, n)      { creation(env, n); }
-#define _LOG_E_BEGIN_EXECUTE(env)      { beginExecute(env); }
+#define _LOG_E_CREATION_1(env)                 { charm_creation(env); }
+#define _LOG_E_CREATION_N(env, n)      { charm_creation(env, n); }
+#define _LOG_E_BEGIN_EXECUTE(env)      { charm_beginExecute(env); }
 #define _LOG_E_BEGIN_EXECUTE_DETAILED(event, msgType, ep, srcPe, ml) \
-       { beginExecuteDetailed(event, msgType, ep, srcPe, ml); }
-#define _LOG_E_END_EXECUTE()           { endExecute(); }
-//TODO#define _LOG_E_BEGIN_PROCESSING() 
-//TODO#define _LOG_E_END_PROCESSING() 
-#define _LOG_E_ENQUEUE(env)            { enqueue(env); }
-#define _LOG_E_DEQUEUE(env)            { dequeue(env); }
-#define _LOG_E_BEGIN_COMPUTATION()     { beginComputation(); }
-#define _LOG_E_END_COMPUTATION()       { endComputation(); }
-//#define _LOG_E_BEGIN_INTERRUPT()
-//#define _LOG_E_END_INTERRUPT() 
-#define _LOG_E_MSG_RECV_CHARM(env, pe)         { messageRecv(env, pe); }
-#define _LOG_E_USER_EVENT_CHARM(x)             { userEvent(x); }
-#define _LOG_E_BEGIN_PACK()                    { beginPack(); }
-#define _LOG_E_END_PACK()                              { endPack(); }
-#define _LOG_E_BEGIN_UNPACK()                  { beginUnpack(); }
-#define _LOG_E_END_UNPACK()                    { endUnpack(); }
+       { charm_beginExecuteDetailed(event, msgType, ep, srcPe, ml); }
+#define _LOG_E_END_EXECUTE()           { charm_endExecute(); }
+//what is EXECUTE ? isn't it the same as processing --- schak
+//TODO#define _LOG_E_BEGIN_PROCESSING()
+//TODO#define _LOG_E_END_PROCESSING()
+#define _LOG_E_ENQUEUE(env)            { charm_enqueueMsg(env); }
+#define _LOG_E_DEQUEUE(env)            { charm_dequeueMsg(env); }
+#define _LOG_E_BEGIN_COMPUTATION()     { charm_beginComputation(); }
+#define _LOG_E_END_COMPUTATION()       { charm_endComputation(); }
+//even projection actually doesn't use these  two
+#define _LOG_E_BEGIN_INTERRUPT()
+#define _LOG_E_END_INTERRUPT()
+
+
+#define _LOG_E_MSG_RECV_CHARM(env, pe)         { charm_messageRecv(env, pe); }
+#define _LOG_E_USER_EVENT_CHARM(x)             { charm_userEvent(x); }
+#define _LOG_E_BEGIN_PACK()                    { charm_beginPack(); }
+#define _LOG_E_END_PACK()                              { charm_endPack(); }
+#define _LOG_E_BEGIN_UNPACK()                  { charm_beginUnpack(); }
+#define _LOG_E_END_UNPACK()                    { charm_endUnpack(); }
 
 #endif
index 008fe028e33b6b0758521904410108e4f7b35277..79eac41de22188db1ff9651dc07508a565169645 100644 (file)
@@ -28,7 +28,7 @@ extern "C" void initCharmProjections()
 //extern "C" int  traceRegisterUserEvent(const char*) 
 //{return -1;} 
 
-extern "C" void creation(envelope *e, int num)
+extern "C" void charm_creation(envelope *e, int num)
 {
   if(e==0) {
     CtvAccess(curThreadEvent)=curEvent;
@@ -53,7 +53,7 @@ extern "C" void creation(envelope *e, int num)
   }
 }
 
-extern "C" void beginExecute(envelope *e)
+extern "C" void charm_beginExecute(envelope *e)
 {
   if(e==0) {
     execEvent = CtvAccess(curThreadEvent);
@@ -65,11 +65,11 @@ extern "C" void beginExecute(envelope *e)
        iData[3] = CkMyPe();
        LogEvent1(_CHARM_LANG_ID, _E_BEGIN_PROCESSING, 4, iData); 
   } else {
-    beginExecuteDetailed(e->getEvent(),e->getMsgtype(),e->getEpIdx(),e->getSrcPe(),e->getTotalsize());
+    charm_beginExecuteDetailed(e->getEvent(),e->getMsgtype(),e->getEpIdx(),e->getSrcPe(),e->getTotalsize());
   }
 }
 
-extern "C" void beginExecuteDetailed(int event,int msgType,int ep,int srcPe,int ml)
+extern "C" void charm_beginExecuteDetailed(int event,int msgType,int ep,int srcPe,int ml)
 {
   execEvent=event;
   execEp=ep;
@@ -80,10 +80,11 @@ extern "C" void beginExecuteDetailed(int event,int msgType,int ep,int srcPe,int
   iData[2] = event;
   iData[3] = srcPe;
   iData[4] = ml;
+ // CkPrintf("iData in beginExecuteDetailed %d %d \n",event,srcPe);
   LogEvent1(_CHARM_LANG_ID, _E_BEGIN_PROCESSING, 5, iData); 
 }
 
-extern "C" void endExecute(void)
+extern "C" void charm_endExecute(void)
 {
   if(execEp == (-1)) {
        int* iData = (int*)malloc(sizeof(int)*4); 
@@ -102,11 +103,28 @@ extern "C" void endExecute(void)
   }
 }
 
-extern "C" void enqueue(envelope *e) {}        //TODO
+// implementing enqueue and dequeue --schak 
+// however these type of events are not generated by anyone
 
-extern "C" void dequeue(envelope *e) {}        //TODO
+extern "C" void charm_enqueueMsg(envelope *e) {
+       
+       int *iData = (int *)malloc(sizeof(int )*3);
+       iData[0] = e->getMsgtype();
+       iData[1] = e->getEvent();
+       iData[2] = e->getSrcPe();
+       LogEvent1(_CHARM_LANG_ID,_E_ENQUEUE,3,iData);
+}      
 
-extern "C" void beginComputation(void)
+extern "C" void charm_dequeueMsg(envelope *e) {
+       int *iData = (int *)malloc(sizeof(int )*3);
+       iData[0] = e->getMsgtype();
+       iData[1] = e->getEvent();
+       iData[2] = e->getSrcPe();
+       LogEvent1(_CHARM_LANG_ID,_E_DEQUEUE,3,iData);
+
+}      
+
+extern "C" void charm_beginComputation(void)
 {
        if(CkMyRank()==0) {
                //DOUBT: what are these registrations ? ... cocurrently running with projections => problem 
@@ -117,37 +135,37 @@ extern "C" void beginComputation(void)
        LogEvent1(_CHARM_LANG_ID, _E_BEGIN_COMPUTATION, 0, NULL); 
 }
 
-extern "C" void endComputation(void)
+extern "C" void charm_endComputation(void)
 {
        LogEvent1(_CHARM_LANG_ID, _E_END_COMPUTATION, 0, NULL); 
 }
 
-extern "C" void messageRecv(char *env, int pe) {} //TODO
+extern "C" void charm_messageRecv(char *env, int pe) {} //TODO
 
-extern "C" void userEvent(int e) {}    //TODO
+extern "C" void charm_userEvent(int e) {}      //TODO
 
-extern "C" void beginPack(void)
+extern "C" void charm_beginPack(void)
 {
        int* iData = (int*)malloc(sizeof(int)); 
        iData[0] = CkMyPe();
        LogEvent1(_CHARM_LANG_ID, _E_BEGIN_PACK, 1, iData); 
 }
 
-extern "C" void endPack(void)
+extern "C" void charm_endPack(void)
 {
        int* iData = (int*)malloc(sizeof(int)); 
        iData[0] = CkMyPe();
        LogEvent1(_CHARM_LANG_ID, _E_END_PACK, 1, iData); 
 }
 
-extern "C" void beginUnpack(void)
+extern "C" void charm_beginUnpack(void)
 {
        int* iData = (int*)malloc(sizeof(int)); 
        iData[0] = CkMyPe();
        LogEvent1(_CHARM_LANG_ID, _E_BEGIN_UNPACK, 1, iData); 
 }
 
-extern "C" void endUnpack(void)
+extern "C" void charm_endUnpack(void)
 {
        int* iData = (int*)malloc(sizeof(int)); 
        iData[0] = CkMyPe();
index 8b30667fd8f557f9611b75dd0cc117a306a6a7c1..51ca40f26fea7c7335f19a98bb2a862fb9ae99fc 100644 (file)
@@ -1,4 +1,3 @@
-
 #ifndef __CHARM_PROJECTIONS_H__
 #define __CHARM_PROJECTIONS_H__
 
@@ -12,20 +11,20 @@ extern "C" {
 void initCharmProjections();
 //int  traceRegisterUserEvent(const char*);    //TODO
 
-void creation(envelope *e, int num=1);
-void beginExecute(envelope *e);
-void beginExecuteDetailed(int event,int msgType,int ep,int srcPe,int ml);
-void endExecute(void);
-void enqueue(envelope *e);
-void dequeue(envelope *e);
-void beginComputation(void);
-void endComputation(void);
-void messageRecv(char *env, int pe);
-void userEvent(int e);
-void beginPack(void);
-void endPack(void);
-void beginUnpack(void);
-void endUnpack(void);
+void charm_creation(envelope *e, int num=1);
+void charm_beginExecute(envelope *e);
+void charm_beginExecuteDetailed(int event,int msgType,int ep,int srcPe,int ml);
+void charm_endExecute(void);
+void charm_enqueueMsg(envelope *e);
+void charm_dequeueMsg(envelope *e);
+void charm_beginComputation(void);
+void charm_endComputation(void);
+void charm_messageRecv(char *env, int pe);
+void charm_userEvent(int e);
+void charm_beginPack(void);
+void charm_endPack(void);
+void charm_beginUnpack(void);
+void charm_endUnpack(void);
 
 #ifdef __cplusplus
 }
index 68545b998e5772482b656dfef42537058c4c39be..7fee37616e59e66bfab2739f06c5f94472be0d59 100644 (file)
 #define _E_MSG_QUEUED          1       // DOUBT: Queued where ?
 #define _E_MSG_RECV_MC         2       // Message received in machine layer
 #define _E_MSG_RECV_SC         3       // Message received in scheduler
-#define _E_HANDLER_BEGIN       4 
+#define _E_HANDLER_BEGIN       4
 #define _E_HANDLER_END         5 
-#define _E_PROC_IDLE           6       // Processor goes idle 
-#define _E_PROC_BUSY           7       // Processor goes busy 
 
 /* Trace Macros */
 #define REGISTER_CONVERSE \
-       { RegisterLanguage(_CONVERSE_LANG_ID, "converse"); \
+       { RegisterLanguage(_CONVERSE_LANG_ID, "converse\0"); \
          RegisterEvent(_CONVERSE_LANG_ID, _E_MSG_SENT     ); \
          RegisterEvent(_CONVERSE_LANG_ID, _E_MSG_QUEUED   ); \
          RegisterEvent(_CONVERSE_LANG_ID, _E_MSG_RECV_MC  ); \
          RegisterEvent(_CONVERSE_LANG_ID, _E_MSG_RECV_SC  ); \
          RegisterEvent(_CONVERSE_LANG_ID, _E_HANDLER_BEGIN); \
          RegisterEvent(_CONVERSE_LANG_ID, _E_HANDLER_END  ); \
-         RegisterEvent(_CONVERSE_LANG_ID, _E_PROC_IDLE    ); \
-         RegisterEvent(_CONVERSE_LANG_ID, _E_PROC_BUSY    ); \
+         \
        }
 #define _LOG_E_MSG_SENT(destPE, size) \
-       { msgSent(destPE, size); }
+       { converse_msgSent(destPE, size); }
 #define _LOG_E_MSG_QUEUED() \
        { LogEvent(_CONVERSE_LANG_ID, _E_MSG_QUEUED); }         //TODO
 #define _LOG_E_MSG_RECV_MC() \
 #define _LOG_E_MSG_RECV_SC() \
        { LogEvent(_CONVERSE_LANG_ID, _E_MSG_RECV_SC); }        //TODO
 #define _LOG_E_HANDLER_BEGIN(handlerIdx) \
-       { handlerBegin(handlerIdx); }
+       { converse_handlerBegin(handlerIdx); }
 #define _LOG_E_HANDLER_END(handlerIdx) \
-       { handlerEnd(handlerIdx); }
-#define _LOG_E_PROC_IDLE() \
-       { procIdle(); }
-#define _LOG_E_PROC_BUSY() \
-       { procBusy(); }
+       { converse_handlerEnd(handlerIdx); }
 
 #endif
index 545d057080954e2636281250f660b7f65ffae16c..1b953ca97d9c687fe265fa6011a53b3b9be6210e 100644 (file)
@@ -6,7 +6,7 @@
 #include "traceCoreCommon.h"
 #include "converseProjections.h"
 
-extern "C" void msgSent(int destPE, int size)
+extern "C" void converse_msgSent(int destPE, int size)
 {
        int* iData = (int*)malloc(sizeof(int)*2); 
        iData[0] = destPE;
@@ -15,13 +15,13 @@ extern "C" void msgSent(int destPE, int size)
 }
 
 //TODO
-extern "C" void msgQueued();
+extern "C" void converse_msgQueued();
 //TODO
-extern "C" void msgRecvMC();
+extern "C" void converse_msgRecvMC();
 //TODO
-extern "C" void msgRecvSC();
+extern "C" void converse_msgRecvSC();
 
-extern "C" void handlerBegin(int handlerIdx)
+extern "C" void converse_handlerBegin(int handlerIdx)
 {      
        int* iData = (int*)malloc(sizeof(int)*2); 
        iData[0] = handlerIdx;
@@ -29,7 +29,7 @@ extern "C" void handlerBegin(int handlerIdx)
        LogEvent1(_CONVERSE_LANG_ID, _E_HANDLER_BEGIN, 2, iData); 
 }
 
-extern "C" void handlerEnd(int handlerIdx)
+extern "C" void converse_handlerEnd(int handlerIdx)
 {      
        int* iData = (int*)malloc(sizeof(int)*2); 
        iData[0] = handlerIdx;
@@ -37,16 +37,3 @@ extern "C" void handlerEnd(int handlerIdx)
        LogEvent1(_CONVERSE_LANG_ID, _E_HANDLER_END, 2, iData); 
 }
 
-extern "C" void procIdle()
-{      
-       int* iData = (int*)malloc(sizeof(int)); 
-       iData[0] = CmiMyPe();
-       LogEvent1(_CONVERSE_LANG_ID, _E_PROC_IDLE, 1, iData); 
-}
-
-extern "C" void procBusy()
-{      
-       int* iData = (int*)malloc(sizeof(int)); 
-       iData[0] = CmiMyPe();
-       LogEvent1(_CONVERSE_LANG_ID, _E_PROC_BUSY, 1, iData); 
-}
index 314d8576f7c8acf94e27d0de7bcb060a5effe892..09114431e40ed9707f28ec457e8cdbc25a6577b3 100644 (file)
@@ -6,14 +6,13 @@
 extern "C" {
 #endif
 
-void msgSent(int destPE, int size);
-void msgQueued();              //TODO
-void msgRecvMC();              //TODO
-void msgRecvSC();              //TODO
-void handlerBegin(int handlerIdx);
-void handlerEnd  (int handlerIdx);
-void procIdle();
-void procBusy();
+void converse_msgSent(int destPE, int size);
+void converse_msgQueued();             //TODO
+void converse_msgRecvMC();             //TODO
+void converse_msgRecvSC();             //TODO
+void converse_handlerBegin(int handlerIdx);
+void converse_handlerEnd  (int handlerIdx);
+
 
 #ifdef __cplusplus
 }
index df134b35e8c35952f5e445ebe777662ceeeacecc..3d388e94a127321b5f52eaded15cd4196d2cb850 100644 (file)
@@ -2,6 +2,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
+#include <string.h>
+#include <assert.h>
 
 #include "converse.h"
 #include "traceCore.h"
 
 #include "converseEvents.h"    //TODO: remove this hack for REGISTER_CONVESE
 #include "charmEvents.h"       //TODO: remove this hack for REGISTER_CHARM
+#include "machineEvents.h"     // for machine events
 
-CpvExtern(int, _traceCoreOn);
 CpvExtern(double, _traceCoreInitTime);
 CpvExtern(char*, _traceCoreRoot);
 CpvExtern(int, _traceCoreBufferSize);
 CpvExtern(TraceCore*, _traceCore);
+CpvStaticDeclare(int ,staticNumEntries);
 
 /* Trace Timer */
 #define  TRACE_CORE_TIMER   CmiWallTimer
@@ -25,45 +28,178 @@ TraceCore::TraceCore(char** argv)
 {
        int binary = CmiGetArgFlag(argv,"+binary-trace");
        traceLogger = new TraceLogger(CpvAccess(_traceCoreRoot), binary);
-
+       CpvInitialize(int ,staticNumEntries);
+       CpvAccess(staticNumEntries)=0;
+       if(CpvAccess(_traceCoreOn) == 0){
+               traceCoreOn=0;
+               return;
+       }
+       traceCoreOn=1;
+       //CmiPrintf("[%d]In TraceCore Constructor\n",CmiMyPe());
+       startPtc();
        REGISTER_CONVERSE
        REGISTER_CHARM
+       REGISTER_MACHINE
+       closePtc();
 }
 
 TraceCore::~TraceCore()
 { if(traceLogger) delete traceLogger; }
 
 void TraceCore::RegisterLanguage(int lID, char* ln)
-{ traceLogger->RegisterLanguage(lID, ln); }    
+{
+       //CmiPrintf("Register Language called for %s at %d \n",ln,lID);
+  if(traceCoreOn == 0){
+               return;
+  }
+  traceLogger->RegisterLanguage(lID, ln);
+
+  // code for ptc file generation
+  if(maxlID < lID){
+       maxlID = lID;
+  }
+  lIDList[numLangs] = lID;
+  lNames[numLangs] = new char[strlen(ln)+1];
+  sprintf(lNames[numLangs],"%s",ln);
+  numLangs++;
+
+ }
+
+struct TraceCoreEvent *insert_TraceCoreEvent(struct TraceCoreEvent *root,int eID){
+       struct TraceCoreEvent *p;
+       
+       if(root == NULL){
+               p = (struct TraceCoreEvent *)malloc(sizeof(struct TraceCoreEvent));
+               p->next = NULL;
+               p->eID = eID;
+               return p;
+       }
+       p = root;
+       while(p->next != NULL)
+               p = p->next;
+       p->next = (struct TraceCoreEvent *)malloc(sizeof(struct TraceCoreEvent));
+       p->next->next = NULL;
+       p->next->eID = eID;
+       return root;
+}
+
+
+void print_TraceCoreEvent(FILE *fpPtc,struct TraceCoreEvent *root,char *lang){
+       struct TraceCoreEvent *p;
+       
+       p = root;
+       while(p!=NULL){
+               fprintf(fpPtc,"%d %s%d ",p->eID,lang,p->eID);
+               p = p->next;
+
+       }
+}
 
 //TODO: currently these are dummy definitions
 void TraceCore::RegisterEvent(int lID, int eID)
-{ CmiPrintf("registering event (%d, %d)\n", lID, eID); }       
+{
+       //CmiPrintf("registering event (%d, %d)\n", lID, eID);
+       if(traceCoreOn == 0){
+               return;
+       }
+       // code for ptc file generation
+       for(int i=0;i<numLangs;i++){
+               if(lIDList[i] == lID){
+                       if(maxeID[i] < eID){
+                               maxeID[i] = eID;
+                       }
+                       numEvents[i]++;
+                       eventLists[i] = insert_TraceCoreEvent(eventLists[i],eID);
+                       break;
+               }
+       }
+}
+
+void TraceCore::startPtc(){
+       if(traceCoreOn ==0){
+               return;
+       }
+       char *str = new char[strlen(CpvAccess(_traceCoreRoot))+strlen(".ptc")+1];
+       sprintf(str,"%s.ptc",CpvAccess(_traceCoreRoot));
+       fpPtc = fopen(str,"w");
+       if(fpPtc == NULL){
+               CmiAbort("Can't generate Ptc file");
+       }
+       fprintf(fpPtc,"%d\n",CmiNumPes());
+       for(int i=0;i<MAX_NUM_LANGUAGES;i++){
+               eventLists[i] = NULL;
+               maxeID[i] = 0;
+               numEvents[i] = 0;
+       }
+       maxlID = 0;
+       numLangs = 0;
+}
+
+
+void TraceCore::closePtc(){
+       if(traceCoreOn ==0){
+               return;
+       }
+       fprintf(fpPtc,"%d %d ",maxlID,numLangs);
+       for(int i=0;i<numLangs;i++){
+               fprintf(fpPtc,"%d %s ",lIDList[i],lNames[i]);
+       }
+       fprintf(fpPtc,"\n");
+       for(int i=0;i<numLangs;i++){
+               fprintf(fpPtc,"%d %d %d ",lIDList[i],maxeID[i],numEvents[i]);
+               print_TraceCoreEvent(fpPtc,eventLists[i],lNames[i]);
+               fprintf(fpPtc,"\n");
+       }
+       fclose(fpPtc);
+}
+
+
+
 
 //TODO: only for compatibility with incomplete converse instrumentation
 void TraceCore::LogEvent(int lID, int eID)
-{ LogEvent(lID, eID, 0, NULL, 0, NULL); }
+{ 
+       if(traceCoreOn == 0){
+               return;
+       }
+       LogEvent(lID, eID, 0, NULL, 0, NULL); 
+}
 
 void TraceCore::LogEvent(int lID, int eID, int iLen, int* iData)
-{ LogEvent(lID, eID, iLen, iData, 0, NULL); }
+{ 
+       if(traceCoreOn == 0){
+               return;
+       }
+       LogEvent(lID, eID, iLen, iData, 0, NULL); 
+}
 
 void TraceCore::LogEvent(int lID, int eID, int sLen, char* sData)
-{ LogEvent(lID, eID, 0, NULL, sLen, sData); }
+{ 
+       if(traceCoreOn == 0){
+               return;
+       }
+       LogEvent(lID, eID, 0, NULL, sLen, sData); 
+}
 
 void TraceCore::LogEvent(int lID, int eID, int iLen, int* iData, int sLen, char* sData)
 {
-       CmiPrintf("lID: %d, eID: %d", lID, eID);
+       //CmiPrintf("lID: %d, eID: %d", lID, eID);
+       if(traceCoreOn == 0){
+               return;
+       }
        if(iData != NULL) {
-               CmiPrintf(" iData: ");
-               for(int i=0; i<iLen; i++) { CmiPrintf("%d ", iData[i]); }
+       //      CmiPrintf(" iData(%d): ",iLen);
+               for(int i=0; i<iLen; i++) { //CmiPrintf("%d ", iData[i]);
+               }
        }
        if(sData != NULL) {
-               CmiPrintf("sData: %s", sData);
+//             CmiPrintf("sData: %s", sData);
        }
-       CmiPrintf("\n");
-
+//     CmiPrintf("\n");
 
-       traceLogger->add(lID, eID, TraceCoreTimer(), iLen, iData, sLen, sData); 
+#ifndef CMK_OPTIMIZE
+       traceLogger->add(lID, eID, TraceCoreTimer(), iLen, iData, sLen, sData);
+#endif
 }
 
 /***************** Class TraceEntry Definition *****************/
@@ -91,48 +227,63 @@ void TraceEntry::write(FILE* fp, int prevLID, int prevSeek, int nextLID, int nex
 {
        //NOTE: no need to write languageID to file
        if(prevLID == 0 && nextLID ==0)
-               fprintf(fp, "%d %f %d %d", eventID, timestamp, 0, 0); 
+               fprintf(fp, "%d %f %d %d ", eventID, timestamp, 0, 0);
        else if(prevLID == 0 && nextLID !=0)
-               fprintf(fp, "%d %f %d %d %d", eventID, timestamp, 0, nextLID, nextSeek); 
+               fprintf(fp, "%d %f %d %d %d", eventID, timestamp, 0, nextLID, nextSeek);
        else if(prevLID != 0 && nextLID ==0)
-               fprintf(fp, "%d %f %d %d %d", eventID, timestamp, prevLID, prevSeek, 0); 
+               fprintf(fp, "%d %f %d %d %d", eventID, timestamp, prevLID, prevSeek, 0);
        else // if(prevLID != 0 && nextLID !=0)
                fprintf(fp, "%d %f %d %d %d %d", eventID, timestamp, prevLID, prevSeek, nextLID, nextSeek);
 
        fprintf(fp, " %d", eLen);
        if(eLen != 0) {
-         for(int i=0; i<eLen; i++) fprintf(fp, " %d", entity[i]);  
+         for(int i=0; i<eLen; i++) fprintf(fp, " %d", entity[i]);
        }
 
        fprintf(fp, " %d", iLen);
        if(iLen != 0) {
-         for(int i=0; i<iLen; i++) fprintf(fp, " %d", iData[i]);  
+         for(int i=0; i<iLen; i++) fprintf(fp, " %d", iData[i]);
        }
 
        if(sLen !=0) fprintf(fp, " %s\n", sData);
        else fprintf(fp, "\n");
 
-       // free memory 
-       if(entity) delete [] entity;
+       // free memory
+/*     if(entity) delete [] entity;
+       //entity = NULL;
        if(iData)  delete [] iData;
-       if(sData)  delete [] sData;
+       //iData = NULL;
+       if(sData)  delete [] sData;*/
+       //sData=NULL;
 }
 
 /***************** Class TraceLogger Definition *****************/
-TraceLogger::TraceLogger(char* program, int b): 
-       numLangs(1), numEntries(0), lastWriteFlag(0), prevLID(0), prevSeek(0) 
+TraceLogger::TraceLogger(char* program, int b):
+       numLangs(1), numEntries(0), lastWriteFlag(0), prevLID(0), prevSeek(0)
 {
   binary = b;
-  pool = new TraceEntry[CpvAccess(_traceCoreBufferSize)];
+//  CmiPrintf("Size of the pool %d \n",CpvAccess(_traceCoreBufferSize));
+  pool = new TraceEntry[5*CpvAccess(_traceCoreBufferSize)];
+ // pool = new TraceEntry[500];
   poolSize = CpvAccess(_traceCoreBufferSize);
+  
 
-  pgm = new char[strlen(program)];
+  pgm = new char[strlen(program)+1];
   sprintf(pgm, "%s", program);
-  openLogFiles();
-  closeLogFiles();
+  numEntries = 0;
+
+  //CmiPrintf("In TraceLogger Constructor %s %d",pgm,strlen(program)+1);
+  //initlogfiles();
+
+}
+
+ void TraceLogger::initlogfiles(){
+       openLogFiles();
+       closeLogFiles();
 }
 
-TraceLogger::~TraceLogger() 
+
+TraceLogger::~TraceLogger()
 {
   if(binary)
   { lastWriteFlag = 1; writeBinary(); }
@@ -146,13 +297,19 @@ void TraceLogger::RegisterLanguage(int lID, char* ln)
 {
        numLangs++;
 
-       lName[lID] = new char[strlen(ln)];
+       lName[lID] = new char[strlen(ln)+1];
        sprintf(lName[lID], "%s", ln);
 
-       char pestr[10]; sprintf(pestr, "%d", CmiMyPe());
-       fName[lID] = new char[strlen(pgm)+1+strlen(pestr)+1+strlen(ln)+strlen(".log")];
+       char pestr[10]; sprintf(pestr, "%d\0", CmiMyPe());
+       fName[lID] = new char[strlen(pgm)+1+strlen(pestr)+1+strlen(ln)+strlen(".log")+10];
        sprintf(fName[lID], "%s.%s.%s.log", pgm, pestr, ln);
 
+       // my debug code - schak
+       //CmiPrintf("%s at %d in %d \n",fName[lID],lID,fName[lID]);
+       if(CpvAccess(_traceCoreOn) == 0){
+               CmiPrintf("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1_traceCoreOn = 0 in RegisterLanguage \n");
+                return;
+       }
        FILE* fp = NULL;
        do
        {
@@ -164,21 +321,36 @@ void TraceLogger::RegisterLanguage(int lID, char* ln)
        if(!binary) {
        fprintf(fp, "PROJECTOR-RECORD: %s.%s\n", pestr, lName[lID]);
        }
-       fclose(fp);
+       //fclose(fp);
+       fptrs[lID] = fp;
+}
+
+void TraceLogger::verifyFptrs(){
+       
+  for(int i=1; i<numLangs; i++){
+               if(!fptrs[i]){
+                       CmiPrintf("Null File Pointer Found after Open\n");
+               }
+  }
 }
 
 void TraceLogger::write(void)
 {
-       openLogFiles();
-
+       if(CpvAccess(_traceCoreOn) == 0){
+               return;
+       }
+       //openLogFiles();
+       verifyFptrs();
        int currLID=0, nextLID=0;
        int pLID=0, nLID=0;
        int currSeek=0, nextSeek=0;
        int i;
-       for(i=0; i<numEntries-1; i++) {
+       for(i=0; i<CpvAccess(staticNumEntries)-1; i++) {
                currLID  = pool[i].languageID;
                FILE* fp = fptrs[currLID];
-               currSeek = ftell(fp); 
+               if(fp ==  NULL)
+                       return;
+               currSeek = ftell(fp);
                nextLID  = pool[i+1].languageID;
                nextSeek = ftell(fptrs[nextLID]);
 
@@ -186,20 +358,24 @@ void TraceLogger::write(void)
                nLID = ((nextLID==currLID)?0:nextLID);
                pool[i].write(fp, pLID, prevSeek, nLID, nextSeek);
 
-               prevSeek = currSeek; prevLID = currLID; 
+               prevSeek = currSeek; prevLID = currLID;
+               flushLogFiles();
        }
        if(lastWriteFlag==1) {
                currLID  = pool[i].languageID;
                FILE* fp = fptrs[currLID];
-               currSeek = ftell(fp); 
+               if(fp == NULL)
+                       return;
+               currSeek = ftell(fp);
                nextLID  = nextSeek = 0;
 
                pLID = ((prevLID==currLID)?0:prevLID);
                nLID = ((nextLID==currLID)?0:nextLID);
                pool[i].write(fp, pLID, prevSeek, nLID, nextSeek);
+               closeLogFiles();
        }
 
-       closeLogFiles();
+       
 }
 
 //TODO
@@ -209,16 +385,23 @@ void TraceLogger::writeSts(void) {};
 
 void TraceLogger::add(int lID, int eID, double timestamp, int iLen, int* iData, int sLen, char* sData)
 {
-  new (&pool[numEntries++]) TraceEntry(lID, eID, timestamp, iLen, iData, sLen, sData); 
-  if(poolSize==numEntries) {
+  
+  new (&pool[CpvAccess(staticNumEntries)]) TraceEntry(lID, eID, timestamp, iLen, iData, sLen, sData);
+  CpvAccess(staticNumEntries) = CpvAccess(staticNumEntries)+1;
+if(CpvAccess(staticNumEntries)>= poolSize) {
+  //  if(numEntries>= poolSize) {
     double writeTime = TraceCoreTimer();
 
-    if(binary) writeBinary(); 
+    if(binary) writeBinary();
        else       write();
 
        // move the last entry of pool to first position
-    new (&pool[0]) TraceEntry(pool[numEntries-1]); 
-    numEntries = 1;
+ /*   for(int i=0;i<numEntries;i++){
+           delete pool[i];
+    }*/
+    new (&pool[0]) TraceEntry(pool[CpvAccess(staticNumEntries-1)]);
+    //numEntries = 1;
+    CpvAccess(staticNumEntries)=1;
        //TODO
     //new (&pool[numEntries++]) TraceEntry(0, BEGIN_INTERRUPT, writeTime);
     //new (&pool[numEntries++]) TraceEntry(0, END_INTERRUPT, TraceCoreTimer());
@@ -227,22 +410,58 @@ void TraceLogger::add(int lID, int eID, double timestamp, int iLen, int* iData,
 
 void TraceLogger::openLogFiles()
 {
+  CmiPrintf("[%d]Entering openLogFile \n",CmiMyPe());
   for(int i=1; i<numLangs; i++) {
+
        FILE* fp = NULL;
        do
        {
-       fp = fopen(fName[i], "a");
+
+                       fp = fopen(fName[i], "a");
+
        } while (!fp && (errno == EINTR || errno == EMFILE));
        if(!fp) {
-       CmiAbort("Cannot open Projector Trace File for writing ... \n");
+       //      CmiPrintf("FILE NAME %s at %d \n",fName[i],i);
+               CmiAbort("Cannot open Projector Trace File for writing ... \n");
        }
+       CmiPrintf("[%d]Iteration %d : fp %d \n",CmiMyPe(),i,fp);
        fptrs[i] = fp;
+
+       if(i == 1)
+               assert(fptrs[1]);
+       else if(i == 2)
+       {
+               assert(fptrs[1]);
+               assert(fptrs[2]);
+       }
+       else if(i>= 3)
+       {
+               assert(fptrs[1]);
+               assert(fptrs[2]);
+               assert(fptrs[3]);
+       }
   }
+  CmiAssert(fptrs[1]);
+    CmiAssert(fptrs[2]);
+      CmiAssert(fptrs[3]);
+  CmiPrintf("[%d]In Open log files ........\n",CmiMyPe());
+  verifyFptrs();
+  CmiPrintf("[%d].....................\n",CmiMyPe());
 }
 
 void TraceLogger::closeLogFiles()
 {
-  for(int i=1; i<numLangs; i++)
-       fclose(fptrs[i]);
+  for(int i=1; i<numLangs; i++){
+               if(fptrs[i])
+                       fclose(fptrs[i]);
+               fptrs[i]=NULL;
+               
+  }
+}
+
+void TraceLogger::flushLogFiles(){
+       for(int i=1;i<numLangs;i++){
+               fflush(fptrs[i]);
+       }
 }
 
index 9a3507c277e715f103b900c7debd6d0932ca03d1..8b72d0e77f8b013c2297710d7b60abb2142cb90a 100644 (file)
@@ -8,29 +8,52 @@
 
 #include "converse.h"
 
+#define        MAX_NUM_LANGUAGES  32                   //NOTE: fixed temporarily
+
+
+
 /* Prototype Declarations */
-class TraceCore; 
-class TraceLogger; 
+class TraceCore;
+class TraceLogger;
 class TraceEntry;
 
+CpvExtern(int, _traceCoreOn);
+/*** structure of events ***/
+
+struct TraceCoreEvent {
+       int eID;
+       struct TraceCoreEvent *next;
+};
+
 /* Class Declarations */
-class TraceCore 
+class TraceCore
 {
   private:
        TraceLogger* traceLogger;
-
+       void startPtc();
+       void closePtc();
+       FILE *fpPtc;    // File pointer for the ptc file
+       struct TraceCoreEvent  *eventLists[MAX_NUM_LANGUAGES];
+       int maxlID;
+       int maxeID[MAX_NUM_LANGUAGES];
+       int numLangs;
+       int numEvents[MAX_NUM_LANGUAGES];
+       int lIDList[MAX_NUM_LANGUAGES];
+       char *lNames[MAX_NUM_LANGUAGES];
+       int traceCoreOn;
   public:
        TraceCore(char** argv);
        ~TraceCore();
 
        //TODO: some of these methods are for temporary use only
-       void RegisterLanguage(int lID); 
+       void RegisterLanguage(int lID);
        void RegisterLanguage(int lID, char* lName);
        void RegisterEvent(int lID, int eID);
        void LogEvent(int lID, int eID);
        void LogEvent(int lID, int eID, int iLen, int* iData);
        void LogEvent(int lID, int eID, int sLen, char* sData);
        void LogEvent(int lID, int eID, int iLen, int* iData, int sLen, char* sData);
+
 };
 
 class TraceEntry
@@ -47,13 +70,13 @@ class TraceEntry
        char*  sData;
 
        TraceEntry() {}
-       TraceEntry(int lID, int eID, double ts, int el, int* e, 
-                        int il, int* i, int sl, char* s): 
-                        languageID(lID), eventID(eID), timestamp(ts), 
+       TraceEntry(int lID, int eID, double ts, int el, int* e,
+                        int il, int* i, int sl, char* s):
+                        languageID(lID), eventID(eID), timestamp(ts),
                         eLen(el), entity(e), iLen(il), iData(i), sLen(sl), sData(s) {}
        TraceEntry(int lID, int eID, double ts,
-                        int il, int* i, int sl, char* s): 
-                        languageID(lID), eventID(eID), timestamp(ts), 
+                        int il, int* i, int sl, char* s):
+                        languageID(lID), eventID(eID), timestamp(ts),
                         eLen(0), entity(NULL), iLen(il), iData(i), sLen(sl), sData(s) {}
        TraceEntry(TraceEntry& te);
        ~TraceEntry();
@@ -74,13 +97,12 @@ class TraceLogger
     int poolSize;
     int numEntries;
     TraceEntry *pool;
-       
-#define        MAX_NUM_LANGUAGES  10                   //NOTE: fixed temporarily
 
        int   numLangs;
-       char *lName[MAX_NUM_LANGUAGES];         // Language Name 
+ char *lName[MAX_NUM_LANGUAGES];               // Language Name
     char *fName[MAX_NUM_LANGUAGES];            // File name
     FILE *fptrs[MAX_NUM_LANGUAGES];            // File pointer
+
     int   binary;
 
        int lastWriteFlag;              // set when writing log to file at end of program
@@ -97,10 +119,14 @@ class TraceLogger
        void writeSts(void);
 
     void add(int lID, int eID, double timestamp, int iLen, int* iData, int sLen, char* sData);
+    void initlogfiles();
+
 
   private:
        void openLogFiles();
        void closeLogFiles();
+       void verifyFptrs();
+       void flushLogFiles();
 
        char* pgm;
 };
index 65ba059be1a3892ce16fd3442c7709b83ca95949..a54a997795a0f2466d67019f7914e5410eda63c0 100644 (file)
@@ -1,8 +1,10 @@
 
 #include "traceCore.h"
 #include "traceCoreCommon.h"
+#include "charmProjections.h"
 #include "converse.h"
 
+
 /* Trace Module Constants (Default Values) */
 #define TRACE_CORE_BUFFER_SIZE 10
 
@@ -26,8 +28,8 @@ inline double TraceCoreTimer() { return TRACE_CORE_TIMER() - CpvAccess(_traceCor
 //TODO - trace-common.C
 extern "C" void initTraceCore(char** argv)
 {
-  CpvInitialize(int, _traceCoreOn);
-       CpvAccess(_traceCoreOn) = 0;
+  /*CpvInitialize(int, _traceCoreOn);
+       CpvAccess(_traceCoreOn) = 0;*/
 
   CpvInitialize(char*, _traceCoreRoot);
        CpvAccess(_traceCoreRoot) = (char *) malloc(strlen(argv[0])+1);
@@ -42,6 +44,7 @@ extern "C" void initTraceCore(char** argv)
 
   CpvInitialize(TraceCore*, _traceCore);
        CpvAccess(_traceCore) = new TraceCore(argv);
+  initCharmProjections();
 }
 
 /* End Core Trace Module */