X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=rts%2FHpc.c;h=456c8819203d3c087a1d85a1c6aaff17731ce210;hb=8ab093423360990fc108d86098fc6bfb3b555269;hp=b1b26082946f46529480d4b855624150d5b08170;hpb=0df7dbb1b98d08521f177ade22615861752f8981;p=ghc-hetmet.git diff --git a/rts/Hpc.c b/rts/Hpc.c index b1b2608..456c881 100644 --- a/rts/Hpc.c +++ b/rts/Hpc.c @@ -2,27 +2,45 @@ * (c)2006 Galois Connections, Inc. */ -// #include "HsFFI.h" - #include #include #include #include #include -#include "HsFFI.h" + #include "Rts.h" #include "Hpc.h" +#ifdef HAVE_UNISTD_H +#include +#endif + + /* This is the runtime support for the Haskell Program Coverage (hpc) toolkit, * inside GHC. * */ #define DEBUG_HPC 0 +#define WOP_SIZE 1024 + +static int hpc_inited = 0; // Have you started this component? +static int totalTickCount = 0; // How many ticks have we got to work with +static FILE *tixFile; // file being read/written +static int tix_ch; // current char +static StgWord64 magicTixNumber; // Magic/Hash number to mark .tix files + +static FILE *rixFile = NULL; // The tracer file/pipe (to debugger) +static FILE *rixCmdFile = NULL; // The tracer file/pipe (from debugger) +static StgWord64 rixCounter = 0; // The global event counter +static int debuggee_pid; + +typedef enum { + RixThreadFinishedOp = -1, + RixRaiseOp = -2, + RixFinishedOp = -3 +} HpcRixOp; -static int hpc_inited = 0; // Have you started this component? -static FILE *tixFile; // file being read/written -static int tix_ch; // current char typedef struct _Info { char *modName; // name of module @@ -32,18 +50,24 @@ typedef struct _Info { struct _Info *next; } Info; +// This is a cruel hack, we should completely redesign the format specifier handling in the RTS. +#if SIZEOF_LONG == 8 +#define PRIuWORD64 "lu" +#else +#define PRIuWORD64 "llu" +#endif + Info *modules = 0; Info *nextModule = 0; StgWord64 *tixBoxes = 0; // local copy of tixBoxes array, from file. int totalTixes = 0; // total number of tix boxes. - - static char *tixFilename; + static void failure(char *msg) { - printf("Hpc failure: %s\n",msg); - printf("(perhaps remove .tix file?)\n"); + fprintf(stderr,"Hpc failure: %s\n",msg); + fprintf(stderr,"(perhaps remove .tix file?)\n"); exit(-1); } @@ -60,7 +84,7 @@ static int init_open(char *filename) static void expect(char c) { if (tix_ch != c) { - printf("Hpc: parse failed (%c,%c)\n",tix_ch,c); + fprintf(stderr,"Hpc: parse failed (%c,%c)\n",tix_ch,c); exit(-1); } tix_ch = getc(tixFile); @@ -117,7 +141,7 @@ static void hpc_init(void) { expect('i'); expect('x'); ws(); - expectWord64(); + magicTixNumber = expectWord64(); ws(); expect('['); ws(); @@ -149,7 +173,8 @@ static void hpc_init(void) { if (tix_ch == ',') { expect(','); ws(); - }} + } + } expect(']'); ws(); tixBoxes = (StgWord64 *)calloc(totalTixes,sizeof(StgWord64)); @@ -166,6 +191,9 @@ static void hpc_init(void) { expect(']'); fclose(tixFile); + } else { + // later, we will find a binary specific + magicTixNumber = (StgWord64)0; } } @@ -174,13 +202,14 @@ static void hpc_init(void) { * of the tix file, or all zeros. */ -void +int hs_hpc_module(char *modName,int modCount,StgWord64 *tixArr) { Info *tmpModule, *lastModule; int i; + int offset = 0; #if DEBUG_HPC - printf("hs_hpc_module(%s,%d)\n",modName,modCount); + fprintf(stderr,"hs_hpc_module(%s,%d)\n",modName,modCount); #endif hpc_init(); @@ -199,7 +228,7 @@ hs_hpc_module(char *modName,int modCount,StgWord64 *tixArr) { for(i=0;i < modCount;i++) { tixArr[i] = tixBoxes[i + tmpModule->tickOffset]; } - return; + return tmpModule->tickOffset; } lastModule = tmpModule; } @@ -225,7 +254,181 @@ hs_hpc_module(char *modName,int modCount,StgWord64 *tixArr) { } #if DEBUG_HPC - printf("end: hs_hpc_module\n"); + fprintf(stderr,"end: hs_hpc_module\n"); +#endif + return offset; +} + +static void breakPointCommand(HpcRixOp rixOp, StgThreadID rixTid); + +// Breakpointing +static StgThreadID previousTid = 0; +static StgWord64 rixBPCounter = 0; // The global event breakpoint counter +static int *tixBoxBP; +static HpcRixOp rixOpBack[WOP_SIZE]; // The actual op +static HpcRixOp rixTidBack[WOP_SIZE]; // Tid's before the op + +void +hs_hpc_raise_event(StgTSO *current_tso) { + hs_hpc_tick(RixRaiseOp,current_tso); +} + +void +hs_hpc_thread_finished_event(StgTSO *current_tso) { + hs_hpc_tick(RixThreadFinishedOp,current_tso); +} + +/* Called on every tick, dynamically, sending to our + * external record of program execution. + */ + +void +hs_hpc_tick(int rixOp, StgTSO *current_tso) { +#if DEBUG_HPC + fprintf(stderr,"hs_hpc_tick(%x)\n",rixOp); +#endif + if (rixFile == NULL) { + return; + } + assert(rixCmdFile != NULL); + StgThreadID tid = (current_tso == 0) ? 0 : current_tso->id; + + // now check to see if we have met a breakpoint condition + if (rixCounter == rixBPCounter + || tid != previousTid) { + breakPointCommand(rixOp,tid); + } else { + if (rixOp >= 0) { + // Tix op + if (tixBoxBP[rixOp] == 1) { // reached a bp tixbox + breakPointCommand(rixOp,tid); + } + } else { + // record the special operation + breakPointCommand(rixOp,tid); + } + } + // update the history information. + previousTid = tid; + rixOpBack[rixCounter % WOP_SIZE] = rixOp; + rixTidBack[rixCounter % WOP_SIZE] = tid; + rixCounter++; + +#if DEBUG_HPC + fprintf(stderr,"end: hs_hpc_tick\n"); +#endif +} + +static void +printEvent(FILE *out,StgWord64 rixCounter,StgThreadID rixTid,HpcRixOp rixOp) { +#if DEBUG_HPC + if (out != stderr) { + printEvent(stderr,rixCounter,rixTid,rixOp); + } +#endif + fprintf(out,"Event %" PRIuWORD64 " %u ",rixCounter,(unsigned int)rixTid); + switch(rixOp) { + case RixThreadFinishedOp: + fprintf(out,"ThreadFinished\n"); + break; + case RixRaiseOp: + fprintf(out,"Raise\n"); + break; + case RixFinishedOp: + fprintf(out,"Finished\n"); + break; + default: + fprintf(out,"%u\n",rixOp); + } +} + +static void +breakPointCommand(HpcRixOp rixOp, StgThreadID rixTid) { + StgWord64 tmp64 = 0; + unsigned int tmp = 0; + + if (getpid() != debuggee_pid) { + // We are not the original process, to do not issue + // any events, and do not try to talk to the debugger. + return; + } + + printEvent(rixFile,rixCounter,rixTid,rixOp); + fflush(rixFile); + /* From here, you can ask some basic questions. + * + * c set the (one) counter breakpoint + * s set the (many) tickbox breakpoint + * u unset the (many) tickbox breakpoint + * h history + + * Note that you aways end up here on the first tick + * because the rixBPCounter starts equal to 0. + */ + int c = getc(rixCmdFile); + while(c != 10 && c != -1) { + switch(c) { + case 'c': // c1234 -- set counter breakpoint at 1234 + c = getc(rixCmdFile); + tmp64 = 0; + while(isdigit(c)) { + tmp64 = tmp64 * 10 + (c - '0'); + c = getc(rixCmdFile); + } +#if DEBUG_HPC + fprintf(stderr,"setting countBP = %" PRIuWORD64 "\n",tmp64); +#endif + rixBPCounter = tmp64; + break; + case 's': // s2323 -- set tick box breakpoint at 2323 + c = getc(rixCmdFile); + tmp = 0; + while(isdigit(c)) { + tmp = tmp * 10 + (c - '0'); + c = getc(rixCmdFile); + } +#if DEBUG_HPC + fprintf(stderr,"seting bp for tix %d\n",tmp); +#endif + tixBoxBP[tmp] = 1; + break; + case 'u': // u2323 -- unset tick box breakpoint at 2323 + c = getc(rixCmdFile); + tmp = 0; + while(isdigit(c)) { + tmp = tmp * 10 + (c - '0'); + c = getc(rixCmdFile); + } +#if DEBUG_HPC + fprintf(stderr,"unseting bp for tix %d\n",tmp); +#endif + tixBoxBP[tmp] = 0; + break; + case 'h': // h -- history of the last few (WOP_SIZE) steps + if (rixCounter > WOP_SIZE) { + tmp64 = rixCounter - WOP_SIZE; + } else { + tmp64 = 0; + } + for(;tmp64 < rixCounter;tmp64++) { + printEvent(rixFile,tmp64,rixTidBack[tmp64 % WOP_SIZE],rixOpBack[tmp64 % WOP_SIZE]); + } + fflush(rixFile); + c = getc(rixCmdFile); + break; + default: +#if DEBUG_HPC + fprintf(stderr,"strange command from HPCRIX (%d)\n",c); +#endif + c = getc(rixCmdFile); + } + while (c != 10) { // the end of the line + c = getc(rixCmdFile); // to the end of the line + } + c = getc(rixCmdFile); // the first char on the next command + } +#if DEBUG_HPC + fprintf(stderr,"re entering program\n"); #endif } @@ -236,8 +439,10 @@ hs_hpc_module(char *modName,int modCount,StgWord64 *tixArr) { void startupHpc(void) { Info *tmpModule; + char *hpcRix; + #if DEBUG_HPC - printf("startupHpc\n"); + fprintf(stderr,"startupHpc\n"); #endif if (hpc_inited == 0) { @@ -248,6 +453,7 @@ startupHpc(void) { if (tixBoxes) { for(;tmpModule != 0;tmpModule = tmpModule->next) { + totalTickCount += tmpModule->tickCount; if (!tmpModule->tixArr) { fprintf(stderr,"error: module %s did not register any hpc tick data\n", tmpModule->modName); @@ -256,8 +462,74 @@ startupHpc(void) { } } } + + // HPCRIX contains the name of the file to send our dynamic runtime output to (a named pipe). + + hpcRix = getenv("HPCRIX"); + if (hpcRix) { + int comma; + Info *tmpModule; + int rixFD, rixCmdFD; + + assert(hpc_inited); + + if (sscanf(hpcRix,"%d:%d",&rixFD,&rixCmdFD) != 2) { + /* Bad format for HPCRIX. + */ + fprintf(stderr,"Bad HPCRIX (%s)\n",hpcRix); + exit(0); + } + +#if DEBUG_HPC + fprintf(stderr,"found HPCRIX pipes: %d:%d\n",rixFD,rixCmdFD); +#endif + + rixFile = fdopen(rixFD,"w"); + assert(rixFile != NULL); + + rixCmdFile = fdopen(rixCmdFD,"r"); + assert(rixCmdFile != NULL); + + // If we fork a process, then we do not want ticks inside + // the sub-process to talk to the debugger. So we remember + // our pid at startup time, so we can check if we are still + // the original process. + + debuggee_pid = getpid(); + + comma = 0; + + fprintf(rixFile,"Starting %s\n",prog_name); + fprintf(rixFile,"["); + tmpModule = modules; + for(;tmpModule != 0;tmpModule = tmpModule->next) { + if (comma) { + fprintf(rixFile,","); + } else { + comma = 1; + } + fprintf(rixFile,"(\"%s\",%u)", + tmpModule->modName, + tmpModule->tickCount); +#if DEBUG_HPC + fprintf(stderr,"(tracer)%s: %u (offset=%u)\n", + tmpModule->modName, + tmpModule->tickCount, + tmpModule->tickOffset); +#endif + } + fprintf(rixFile,"]\n"); + fflush(rixFile); + + // Allocate the tixBox breakpoint array + // These are set to 1 if you want to + // stop at a specific breakpoint + tixBoxBP = (int *)calloc(1,sizeof(int)); + } + } + /* Called at the end of execution, to write out the Hpc *.tix file * for this exection. Safe to call, even if coverage is not used. */ @@ -267,7 +539,7 @@ exitHpc(void) { int i, comma; #if DEBUG_HPC - printf("exitHpc\n"); + fprintf(stderr,"exitHpc\n"); #endif if (hpc_inited == 0) { @@ -278,7 +550,7 @@ exitHpc(void) { comma = 0; - fprintf(f,"Tix 0 ["); + fprintf(f,"Tix %" PRIuWORD64 " [", magicTixNumber); tmpModule = modules; for(;tmpModule != 0;tmpModule = tmpModule->next) { if (comma) { @@ -286,11 +558,11 @@ exitHpc(void) { } else { comma = 1; } - fprintf(f,"(\"%s\",%d)", + fprintf(f,"(\"%s\",%u)", tmpModule->modName, tmpModule->tickCount); #if DEBUG_HPC - fprintf(stderr,"%s: %d (offset=%d)\n", + fprintf(stderr,"%s: %u (offset=%u)\n", tmpModule->modName, tmpModule->tickCount, tmpModule->tickOffset); @@ -314,7 +586,7 @@ exitHpc(void) { } if (tmpModule->tixArr) { - fprintf(f,"%lld",tmpModule->tixArr[i]); + fprintf(f,"%" PRIuWORD64,tmpModule->tixArr[i]); } else { fprintf(f,"0"); } @@ -324,6 +596,14 @@ exitHpc(void) { fprintf(f,"]\n"); fclose(f); + + if (rixFile != NULL) { + hs_hpc_tick(RixFinishedOp,(StgThreadID)0); + fclose(rixFile); + } + if (rixCmdFile != NULL) { + fclose(rixCmdFile); + } }