X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=rts%2FHpc.c;h=1624079dec78b6e5ed57a44ed05f0f90ea012dcf;hp=bfbbf67c8f730a75d280e340b6079a2735bbcadb;hb=8604da0136707cc14845d14a88c2272fe576b6d0;hpb=71e810db51fb7f874f11f561303bd0bcb5e6d3d0 diff --git a/rts/Hpc.c b/rts/Hpc.c index bfbbf67..1624079 100644 --- a/rts/Hpc.c +++ b/rts/Hpc.c @@ -2,36 +2,39 @@ * (c)2006 Galois Connections, Inc. */ -// #include "HsFFI.h" - #include #include #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 - -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 @@ -40,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; } @@ -68,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); } @@ -104,56 +107,47 @@ static StgWord64 expectWord64(void) { return tmp; } -static void hpc_init(void) { - int i; - Info *tmpModule; - - if (hpc_inited != 0) { - return; - } - hpc_inited = 1; +static void +readTix(void) { + unsigned int i; + HpcModuleInfo *tmpModule; + + 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(); - magicTixNumber = expectWord64(); + tmpModule -> modName = expectString(); + ws(); + tmpModule -> hashNo = (unsigned int)expectWord64(); + ws(); + 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(); @@ -161,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(); } } @@ -186,14 +209,16 @@ static void hpc_init(void) { * of the tix file, or all zeros. */ -void -hs_hpc_module(char *modName,int modCount,StgWord64 *tixArr) { - Info *tmpModule, *lastModule; - int i; +int +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(); @@ -205,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]; } - return; + 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 { @@ -236,93 +268,61 @@ hs_hpc_module(char *modName,int modCount,StgWord64 *tixArr) { lastModule->next=tmpModule; } -#if DEBUG_HPC - printf("end: hs_hpc_module\n"); -#endif + debugTrace(DEBUG_hpc,"end: hs_hpc_module"); + + return offset; } + /* This is called after all the modules have registered their local tixboxes, * and does a sanity check: are we good to go? */ void startupHpc(void) { - Info *tmpModule; -#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); - } - } - } } -/* 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; -#if DEBUG_HPC - printf("exitHpc\n"); -#endif +static void +writeTix(FILE *f) { + HpcModuleInfo *tmpModule; + unsigned int i, inner_comma, outer_comma; - if (hpc_inited == 0) { + outer_comma = 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) { @@ -330,12 +330,39 @@ exitHpc(void) { } else { fprintf(f,"0"); } - } + fprintf(f,"]"); } - fprintf(f,"]\n"); - fclose(f); + 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 (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; +}