Fixed message tracing on comm thread (to trace those entry methods that need
[charm.git] / src / ck-perf / trace-bluegene.C
1 /*****************************************************************************
2  * $Source$
3  * $Author$
4  * $Date$
5  * $Revision$
6  *****************************************************************************/
7
8
9 /**
10  * \addtogroup CkPerf
11 */
12 /*@{*/
13
14
15 #include "charm++.h"
16 #include "envelope.h"
17 #include "trace-common.h"
18 #include "trace-bluegene.h"
19 #include "blue.h"
20 #include "blue_impl.h"
21
22 #undef DEBUGF
23 #define DEBUGF(x)  // CmiPrintf x
24
25 void _createTracebluegene(char** argv)
26 {
27   DEBUGF(("%d createTraceBluegene\n", CkMyPe()));
28   CkpvInitialize(TraceBluegene*, _tracebg);
29   CkpvAccess(_tracebg) = new  TraceBluegene(argv);
30   CkpvAccess(_traces)->addTrace(CkpvAccess(_tracebg));
31   traceBluegeneLinked = 1;
32 }
33
34
35 // this PE must be trace-enabled(in trace-common.C) to be able to do bgPrint()
36 static void writeData(void *data, double t, double recvT, void *ptr)
37 {
38   FILE *fp = (FILE *)ptr;
39   TraceBluegene *traceBluegene = (TraceBluegene *)ptr;
40   CmiAssert(fp && traceBluegene);
41   traceBluegene->writePrint((char*)data, t);
42 }
43
44 void TraceBluegene::writePrint(char* str, double t){
45   if (pfp == NULL)
46     creatFiles();
47   fprintf(pfp,"[%d] ", CkMyPe());
48   fprintf(pfp,str,t);
49 }
50
51 TraceBluegene::TraceBluegene(char** argv): pfp(NULL)
52 {
53 }
54
55 void TraceBluegene::traceClose() {
56   DEBUGF(("%d TraceBluegene::traceClose\n", CkMyPe()));
57   bgUpdateProj(2);
58   if(pfp != 0)  fclose(pfp);
59   pfp = NULL;
60   CkpvAccess(_traces)->removeTrace(this);
61 }
62
63 TraceBluegene::~TraceBluegene(){
64 }
65
66 CpvExtern(BGMach, bgMach);
67 void TraceBluegene::creatFiles()
68 {
69   char* fname = new char[1024];
70   sprintf(fname, "%sbgPrintFile.%d", cva(bgMach).traceroot?cva(bgMach).traceroot:"", CkMyPe()); 
71   pfp = fopen(fname,"w");     
72   if(pfp==NULL)
73     CmiAbort("Cannot open Bluegene print file for writing.\n");
74 }
75
76 void TraceBluegene::tlineEnd(void** parentLogPtr){
77   if(genTimeLog)
78     *parentLogPtr = (void*)BgLastLog(tTIMELINEREC);
79   else
80     *parentLogPtr = NULL;
81 }
82
83 void TraceBluegene::bgAddTag(const char* str){
84   if (!genTimeLog) return;
85   BgTimeLog * log = BgLastLog(tTIMELINEREC);
86   CmiAssert(log != NULL);
87   log->setName(str);
88 }
89
90 void TraceBluegene::bgDummyBeginExec(const char* name,void** parentLogPtr, int split)
91 {
92   if (genTimeLog) {
93   CmiAssert(parentLogPtr!=NULL);
94   double startTime = BgGetCurTime();
95   BgTimeLog* newLog = BgStartLogByName(tTIMELINEREC, _threadEP, name, startTime, *(BgTimeLog**)parentLogPtr);
96   // if event's mesgID is (-1:-1) and there is no backward dependence
97   // to avoid timestamp correction, set a fake recv time so that it stays here
98   if (*parentLogPtr == NULL)
99     newLog->recvTime = startTime;
100   else {
101     if (split) {
102       newLog->objId = (*(BgTimeLog**)parentLogPtr)->objId;
103       newLog->charm_ep = (*(BgTimeLog**)parentLogPtr)->charm_ep;
104     }
105   }
106   *parentLogPtr = newLog;
107   }
108   startVTimer();
109 }
110
111 void TraceBluegene::bgBeginExec(char* msg, char *name)
112 {
113   startVTimer();
114   if (!genTimeLog) return;
115   BgTimeLog* newLog = new BgTimeLog(msg, name);
116   tTIMELINEREC.logEntryStart(newLog);
117 }
118
119 // mark a new log, which depends on log
120 void TraceBluegene::bgSetInfo(char *msg, const char *name, void **logs, int count)
121 {
122   if (!genTimeLog) return;
123   BgTimeLog * curlog = BgLastLog(tTIMELINEREC);
124   if (name != NULL) curlog->setName(name);
125   for (int i=0; i<count; i++)
126       curlog->addBackwardDep((BgTimeLog*)logs[i]);
127   if (msg) curlog->addMsgBackwardDep(tTIMELINEREC, msg);
128 }
129
130 // mark a new log, which depends on log
131 void TraceBluegene::bgAmpiBeginExec(char *msg, char *name, void **logs, int count)
132 {
133   startVTimer();
134   if (!genTimeLog) return;
135   BgTimeLog * curlog = BgLastLog(tTIMELINEREC);
136   curlog->setName(name);
137   for (int i=0; i<count; i++)
138       curlog->addBackwardDep((BgTimeLog*)logs[i]);
139   if (msg) curlog->addMsgBackwardDep(tTIMELINEREC, msg);
140 }
141
142 void TraceBluegene::bgAmpiLog(unsigned short op, unsigned int dataSize)
143 {
144     if (!genTimeLog) return;
145     BgTimeLog *curlog = BgLastLog(tTIMELINEREC);
146     curlog->mpiOp = op;
147     curlog->mpiSize = dataSize;
148 }
149
150 void TraceBluegene::bgEndExec(int commit)
151 {
152   stopVTimer();
153   if (!genTimeLog) return;
154   if (commit) 
155     BgLogEntryCommit(tTIMELINEREC);
156   else
157     BgEndLastLog(tTIMELINEREC);
158 }
159
160 void TraceBluegene::beginExecute(envelope *e)
161 {
162   if (e==NULL || !genTimeLog) return;
163   BgTimeLog* log = tTIMELINE[tTIMELINE.length()-1];
164   CmiAssert(log!=NULL);
165   log->setCharmEP(e->getEpIdx());
166 }
167
168 void TraceBluegene::beginExecute(int event,int msgType,int ep,int srcPe, int mlen,CmiObjId *idx)
169 {
170   //printf("SET OBJ ID\n");
171   BgTimeLog* log;
172   if(genTimeLog)
173     log = tTIMELINE[tTIMELINE.length()-1];
174   else
175     return;
176   if (idx!=NULL) log->setObjId(idx);
177   log->setCharmEP(ep);
178 }
179
180 void TraceBluegene::getForwardDep(void* log, void** fDepPtr){
181
182   BgTimeLog* cLog = (BgTimeLog*) log;
183   
184   if(cLog->forwardDeps.length() !=1) {
185     cLog->write(stdout);
186     CkAbort("Quitting\n");
187   }
188   *fDepPtr = (void*)(cLog->forwardDeps[0]);
189 }
190
191 void TraceBluegene::getForwardDepForAll(void** logs1, void** logs2, int logsize,void* fDepPtr){
192   if(!genTimeLog) return;
193
194   CmiAssert(logsize>0);
195   BgTimeLog* cLog = (BgTimeLog*)fDepPtr;
196
197   int i=0;
198
199   // find the valid sdag overlap pointer
200   for(i=0;i< logsize+1;i++)
201     if(logs2[i])
202       break;    
203   
204   if (i<logsize+1) {
205     cLog->addBackwardDep((BgTimeLog*)logs2[i]);
206   }
207   // CmiAssert(i<logsize+1);
208   
209   cLog->objId = ((BgTimeLog*)logs1[0])->objId;    // sdag objID
210   for(int j=0;j<logsize;j++)  {
211       cLog->addBackwardDep((BgTimeLog*)(logs1[j]));
212       CmiAssert(cLog->objId == ((BgTimeLog*)logs1[j])->objId);
213   }
214 }
215
216 void TraceBluegene::addBackwardDep(void *log)
217 {
218   if(!genTimeLog || log==NULL) return;
219   BgTimeLog  *parentLogPtr = BgLastLog(tTIMELINEREC);
220   CmiAssert(parentLogPtr);
221   BgAddBackwardDep(parentLogPtr, (BgTimeLog*)log);
222 }
223
224 void TraceBluegene::userBracketEvent(const char* name, double bt, double et, void** parentLogPtr){
225
226   if (!genTimeLog) return;
227
228   BgTimeLog* newLog = new BgTimeLog(_threadEP,name,bt,et);
229   if(*parentLogPtr) {
230     newLog->addBackwardDep(*(BgTimeLog**)parentLogPtr);
231     newLog->objId = (*(BgTimeLog**)parentLogPtr)->objId;        // sdag objID
232   }
233   *parentLogPtr = newLog;
234   CmiAssert(*parentLogPtr != NULL);
235   tTIMELINEREC.logEntryInsert(newLog);
236 }
237
238
239 void TraceBluegene::userBracketEvent(const char* name, double bt, double et, void** parentLogPtr, CkVec<void*> bgLogList){
240    
241   if (!genTimeLog) return;
242
243   BgTimeLog* newLog = new BgTimeLog(_threadEP,name,bt,et);
244   newLog->addBackwardDeps(bgLogList);
245   CmiAssert(bgLogList.size()>0);
246   newLog->objId = ((BgTimeLog*)bgLogList[0])->objId;   // for sdag
247   *parentLogPtr = newLog;
248   tTIMELINEREC.logEntryInsert(newLog);
249 }
250
251 void TraceBluegene::bgPrint(const char* str){
252   if (CmiMemoryIs(CMI_MEMORY_IS_ISOMALLOC)) CmiDisableIsomalloc();
253   double curT = BgGetTime();
254   if (genTimeLog)
255     bgAddProjEvent(strdup(str), -1, curT, writeData, this, BG_EVENT_PRINT);
256   CmiPrintf(str, curT);
257   if (CmiMemoryIs(CMI_MEMORY_IS_ISOMALLOC)) CmiEnableIsomalloc();
258 }
259
260 extern "C" void BgPrintf(const char *str)
261 {
262   BgPrint(str);
263 }
264
265 void TraceBluegene::bgMark(char* str){
266   double curT = BgGetTime();
267   if (genTimeLog)
268     bgAddProjEvent(strdup(str), -1, curT, writeData, this, BG_EVENT_MARK);
269 }
270
271 extern "C" void BgMark(char *str)
272 {
273   BgMark_(str);
274 }
275
276 extern "C" void BgSetStartEvent()
277 {
278   BgTimeLog* log;
279   if(genTimeLog)
280     log = tTIMELINE[tTIMELINE.length()-1];
281   else
282     return;
283   log->setStartEvent();
284 }
285
286 /*@}*/
287