X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=rts%2FHpc.c;h=1624079dec78b6e5ed57a44ed05f0f90ea012dcf;hp=14f9d80226376a830a6aaefc1c84900c3ae17023;hb=8604da0136707cc14845d14a88c2272fe576b6d0;hpb=e119cde9caf1f2acbde7ff53feebdc27d6c35f8d diff --git a/rts/Hpc.c b/rts/Hpc.c index 14f9d80..1624079 100644 --- a/rts/Hpc.c +++ b/rts/Hpc.c @@ -7,32 +7,34 @@ #include #include #include -#include "HsFFI.h" #include "Rts.h" #include "Hpc.h" +#include "Trace.h" + +#ifdef HAVE_SYS_TYPES_H +#include +#endif + +#ifdef HAVE_SYS_STAT_H +#include +#endif + +#ifdef HAVE_UNISTD_H +#include +#endif + /* This is the runtime support for the Haskell Program Coverage (hpc) toolkit, * inside GHC. * */ -#define DEBUG_HPC 0 - static int hpc_inited = 0; // Have you started this component? +static pid_t hpc_pid = 0; // pid of this process at hpc-boot time. + // Only this pid will read or write .tix file(s). 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 - -typedef struct _Info { - char *modName; // name of module - int tickCount; // number of ticks - int tickOffset; // offset into a single large .tix Array - StgWord64 *tixArr; // tix Array from the program execution (local for this module) - struct _Info *next; -} Info; // This is a cruel hack, we should completely redesign the format specifier handling in the RTS. #if SIZEOF_LONG == 8 @@ -41,25 +43,25 @@ typedef struct _Info { #define PRIuWORD64 "llu" #endif -Info *modules = 0; -Info *nextModule = 0; -StgWord64 *tixBoxes = 0; // local copy of tixBoxes array, from file. +HpcModuleInfo *modules = 0; +HpcModuleInfo *nextModule = 0; 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"); + debugTrace(DEBUG_hpc,"hpc failure: %s\n",msg); + fprintf(stderr,"Hpc failure: %s\n",msg); + if (tixFilename) { + fprintf(stderr,"(perhaps remove %s file?)\n",tixFilename); + } else { + fprintf(stderr,"(perhaps remove .tix file?)\n"); + } exit(-1); } - -static int init_open(char *filename) -{ - tixFile = fopen(filename,"r"); +static int init_open(FILE *file) { + tixFile = file; if (tixFile == 0) { return 0; } @@ -69,8 +71,8 @@ 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); - exit(-1); + fprintf(stderr,"('%c' '%c')\n",tix_ch,c); + failure("parse error when reading .tix file"); } tix_ch = getc(tixFile); } @@ -105,56 +107,47 @@ static StgWord64 expectWord64(void) { return tmp; } -static void hpc_init(void) { - int i; - Info *tmpModule; +static void +readTix(void) { + unsigned int i; + HpcModuleInfo *tmpModule; - if (hpc_inited != 0) { - return; - } - hpc_inited = 1; + totalTixes = 0; + + ws(); + expect('T'); + expect('i'); + expect('x'); + ws(); + expect('['); + ws(); - - tixFilename = (char *) malloc(strlen(prog_name) + 6); - sprintf(tixFilename, "%s.tix", prog_name); - - if (init_open(tixFilename)) { - totalTixes = 0; - - ws(); + while(tix_ch != ']') { + tmpModule = (HpcModuleInfo *)calloc(1,sizeof(HpcModuleInfo)); expect('T'); expect('i'); expect('x'); + expect('M'); + expect('o'); + expect('d'); + expect('u'); + expect('l'); + expect('e'); + ws(); + tmpModule -> modName = expectString(); + ws(); + tmpModule -> hashNo = (unsigned int)expectWord64(); ws(); - magicTixNumber = expectWord64(); + tmpModule -> tickCount = (int)expectWord64(); + tmpModule -> tixArr = (StgWord64 *)calloc(tmpModule->tickCount,sizeof(StgWord64)); + tmpModule -> tickOffset = totalTixes; + totalTixes += tmpModule -> tickCount; ws(); expect('['); ws(); - while(tix_ch != ']') { - tmpModule = (Info *)calloc(1,sizeof(Info)); - expect('('); - ws(); - tmpModule -> modName = expectString(); - ws(); - expect(','); - ws(); - tmpModule -> tickCount = (int)expectWord64(); - ws(); - expect(')'); + for(i = 0;i < tmpModule->tickCount;i++) { + tmpModule->tixArr[i] = expectWord64(); ws(); - - tmpModule -> tickOffset = totalTixes; - totalTixes += tmpModule -> tickCount; - - tmpModule -> tixArr = 0; - - if (!modules) { - modules = tmpModule; - } else { - nextModule->next=tmpModule; - } - nextModule=tmpModule; - if (tix_ch == ',') { expect(','); ws(); @@ -162,23 +155,52 @@ static void hpc_init(void) { } expect(']'); ws(); - tixBoxes = (StgWord64 *)calloc(totalTixes,sizeof(StgWord64)); - - expect('['); - for(i = 0;i < totalTixes;i++) { - if (i != 0) { - expect(','); - ws(); - } - tixBoxes[i] = expectWord64(); - ws(); + + if (!modules) { + modules = tmpModule; + } else { + nextModule->next=tmpModule; } - expect(']'); + nextModule=tmpModule; + + if (tix_ch == ',') { + expect(','); + ws(); + } + } + expect(']'); + fclose(tixFile); +} - fclose(tixFile); +static void hpc_init(void) { + char *hpc_tixdir; + if (hpc_inited != 0) { + return; + } + hpc_inited = 1; + hpc_pid = getpid(); + hpc_tixdir = getenv("HPCTIXDIR"); + + if (hpc_tixdir != NULL) { + /* Make sure the directory is present; + * conditional code for mkdir lifted from lndir.c + */ +#ifdef WIN32 + mkdir(hpc_tixdir); +#else + mkdir(hpc_tixdir,0777); +#endif + /* Then, try open the file + */ + tixFilename = (char *) malloc(strlen(hpc_tixdir) + strlen(prog_name) + 12); + sprintf(tixFilename,"%s/%s-%d.tix",hpc_tixdir,prog_name,hpc_pid); } else { - // later, we will find a binary specific - magicTixNumber = (StgWord64)0; + tixFilename = (char *) malloc(strlen(prog_name) + 6); + sprintf(tixFilename, "%s.tix", prog_name); + } + + if (init_open(fopen(tixFilename,"r"))) { + readTix(); } } @@ -188,14 +210,15 @@ static void hpc_init(void) { */ int -hs_hpc_module(char *modName,int modCount,StgWord64 *tixArr) { - Info *tmpModule, *lastModule; - int i; +hs_hpc_module(char *modName, + StgWord32 modCount, + StgWord32 modHashNo, + StgWord64 *tixArr) { + HpcModuleInfo *tmpModule, *lastModule; + unsigned int i; int offset = 0; -#if DEBUG_HPC - printf("hs_hpc_module(%s,%d)\n",modName,modCount); -#endif + debugTrace(DEBUG_hpc,"hs_hpc_module(%s,%d)",modName,(nat)modCount); hpc_init(); @@ -207,20 +230,27 @@ hs_hpc_module(char *modName,int modCount,StgWord64 *tixArr) { if (tmpModule->tickCount != modCount) { failure("inconsistent number of tick boxes"); } - assert(tmpModule->tixArr == 0); - assert(tixBoxes != 0); - tmpModule->tixArr = tixArr; + assert(tmpModule->tixArr != 0); + if (tmpModule->hashNo != modHashNo) { + fprintf(stderr,"in module '%s'\n",tmpModule->modName); + failure("module mismatch with .tix/.mix file hash number"); + fprintf(stderr,"(perhaps remove %s ?)\n",tixFilename); + exit(-1); + + } for(i=0;i < modCount;i++) { - tixArr[i] = tixBoxes[i + tmpModule->tickOffset]; + tixArr[i] = tmpModule->tixArr[i]; } + tmpModule->tixArr = tixArr; return tmpModule->tickOffset; } lastModule = tmpModule; } // Did not find entry so add one on. - tmpModule = (Info *)calloc(1,sizeof(Info)); + tmpModule = (HpcModuleInfo *)calloc(1,sizeof(HpcModuleInfo)); tmpModule->modName = modName; tmpModule->tickCount = modCount; + tmpModule->hashNo = modHashNo; if (lastModule) { tmpModule->tickOffset = lastModule->tickOffset + lastModule->tickCount; } else { @@ -238,63 +268,11 @@ hs_hpc_module(char *modName,int modCount,StgWord64 *tixArr) { lastModule->next=tmpModule; } -#if DEBUG_HPC - printf("end: hs_hpc_module\n"); -#endif - return offset; -} - -static StgThreadID previous_tid = 0; + debugTrace(DEBUG_hpc,"end: hs_hpc_module"); -static void -send_ThreadId(StgTSO *current_tso) { - // This assumes that there is no real thread 0. - StgThreadID tid = (current_tso == 0) ? 0 : current_tso->id; - if (tid != previous_tid) { - previous_tid = current_tso->id; - // How do we print StgWord32's without a cast? - fprintf(rixFile,"Thread %d\n",(unsigned int)tid); - } -} - -/* - * Called on *every* exception thrown - */ -void -hs_hpc_throw(StgTSO *current_tso) { - // Assumes that we have had at least *one* tick first. - // All exceptions before the first tick are not reported. - // The only time this might be an issue is in bootstrapping code, - // so this is a feature. - - // This is called on *every* exception, even when Hpc is not enabled. - - if (rixFile != NULL) { - assert(hpc_inited != 0); - send_ThreadId(current_tso); - fprintf(rixFile,"Throw\n"); - } + return offset; } -/* Called on every tick, dynamically to our file record of program execution - */ - -void -hs_hpc_tick(int globIx, StgTSO *current_tso) { -#if DEBUG_HPC && DEBUG - printf("hs_hpc_tick(%d)\n",globIx); -#endif - assert(hpc_inited != 0); - if (rixFile != NULL) { - send_ThreadId(current_tso); - fprintf(rixFile,"%d\n",globIx); - } - -#if DEBUG_HPC - printf("end: hs_hpc_tick\n"); -#endif - -} /* This is called after all the modules have registered their local tixboxes, * and does a sanity check: are we good to go? @@ -302,121 +280,49 @@ hs_hpc_tick(int globIx, StgTSO *current_tso) { void startupHpc(void) { - Info *tmpModule; - char *hpcRix; -#if DEBUG_HPC - printf("startupHpc\n"); -#endif + debugTrace(DEBUG_hpc,"startupHpc"); if (hpc_inited == 0) { return; } - - tmpModule = modules; - - if (tixBoxes) { - for(;tmpModule != 0;tmpModule = tmpModule->next) { - if (!tmpModule->tixArr) { - fprintf(stderr,"error: module %s did not register any hpc tick data\n", - tmpModule->modName); - fprintf(stderr,"(perhaps remove %s ?)\n",tixFilename); - exit(-1); - } - } - } - - // HPCRIX contains the name of the file to send our dynamic runtime output to. - // This might be a real file, or perhaps a named pipe. - hpcRix = getenv("HPCRIX"); - if (hpcRix) { - int comma; - Info *tmpModule; - - assert(hpc_inited); - - rixFile = fopen(hpcRix,"w"); - - 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); - } - } -/* 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. - */ -void -exitHpc(void) { - Info *tmpModule; - int i, comma; +static void +writeTix(FILE *f) { + HpcModuleInfo *tmpModule; + unsigned int i, inner_comma, outer_comma; -#if DEBUG_HPC - printf("exitHpc\n"); -#endif + outer_comma = 0; - if (hpc_inited == 0) { + if (f == 0) { return; } - FILE *f = fopen(tixFilename,"w"); - - comma = 0; - - fprintf(f,"Tix %" PRIuWORD64 " [", magicTixNumber); + fprintf(f,"Tix ["); tmpModule = modules; for(;tmpModule != 0;tmpModule = tmpModule->next) { - if (comma) { + if (outer_comma) { fprintf(f,","); } else { - comma = 1; + outer_comma = 1; } - fprintf(f,"(\"%s\",%u)", - tmpModule->modName, - tmpModule->tickCount); -#if DEBUG_HPC - fprintf(stderr,"%s: %u (offset=%u)\n", + fprintf(f," TixModule \"%s\" %u %u [", tmpModule->modName, - tmpModule->tickCount, - tmpModule->tickOffset); -#endif - } - fprintf(f,"] ["); - - comma = 0; - tmpModule = modules; - for(;tmpModule != 0;tmpModule = tmpModule->next) { - if (!tmpModule->tixArr) { - fprintf(stderr,"warning: module %s did not register any hpc tick data\n", - tmpModule->modName); - } - + (nat)tmpModule->hashNo, + (nat)tmpModule->tickCount); + debugTrace(DEBUG_hpc,"%s: %u (offset=%u) (hash=%u)\n", + tmpModule->modName, + (nat)tmpModule->tickCount, + (nat)tmpModule->hashNo, + (nat)tmpModule->tickOffset); + + inner_comma = 0; for(i = 0;i < tmpModule->tickCount;i++) { - if (comma) { + if (inner_comma) { fprintf(f,","); } else { - comma = 1; + inner_comma = 1; } if (tmpModule->tixArr) { @@ -424,17 +330,39 @@ exitHpc(void) { } else { fprintf(f,"0"); } - } + fprintf(f,"]"); } - fprintf(f,"]\n"); + fclose(f); +} + +/* 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. + */ +void +exitHpc(void) { + debugTrace(DEBUG_hpc,"exitHpc"); - if (rixFile != NULL) { - fprintf(rixFile,"Finished\n"); - fclose(rixFile); + if (hpc_inited == 0) { + return; + } + + // Only write the tix file if you are the original process. + // Any sub-process from use of fork from inside Haskell will + // not clober the .tix file. + + if (hpc_pid == getpid()) { + FILE *f = fopen(tixFilename,"w"); + writeTix(f); } - } +////////////////////////////////////////////////////////////////////////////// +// This is the API into Hpc RTS from Haskell, allowing the tixs boxes +// to be first class. + +HpcModuleInfo *hs_hpc_rootModule(void) { + return modules; +}