[project @ 2005-03-27 13:41:13 by panne]

[ghc-hetmet.git] / ghc / rts / ProfHeap.c

diff --git a/ghc/rts/ProfHeap.c b/ghc/rts/ProfHeap.c
index 27a1a41..1125fd0 100644 (file)
--- a/ghc/rts/ProfHeap.c
+++ b/ghc/rts/ProfHeap.c
@@ -1,5 +1,4 @@
 /* -----------------------------------------------------------------------------
- * $Id: ProfHeap.c,v 1.48 2003/09/23 15:38:36 simonmar Exp $
  *
  * (c) The GHC Team, 1998-2003
  *
@@ -32,6 +31,7 @@
 
 #include <string.h>
 #include <stdlib.h>
+#include <math.h>
 
 /* -----------------------------------------------------------------------------
  * era stores the current time period.  It is the same as the
@@ -46,7 +46,7 @@
  * When era reaches max_era, the profiling stops because a closure can
  * store only up to (max_era - 1) as its creation or last use time.
  * -------------------------------------------------------------------------- */
-nat era;
+unsigned int era;
 static nat max_era;
 
 /* -----------------------------------------------------------------------------
@@ -72,7 +72,7 @@ typedef struct _counter {
     struct _counter *next;
 } counter;
 
-static inline void
+STATIC_INLINE void
 initLDVCtr( counter *ctr )
 {
     ctr->c.ldv.prim = 0;
@@ -177,7 +177,7 @@ static char *type_names[] = {
  * the band to which this closure's heap space is attributed in the
  * heap profile.
  * ------------------------------------------------------------------------- */
-static inline void *
+STATIC_INLINE void *
 closureIdentity( StgClosure *p )
 {
     switch (RtsFlags.ProfFlags.doHeapProfile) {
@@ -215,20 +215,20 @@ closureIdentity( StgClosure *p )
  * Profiling type predicates
  * ----------------------------------------------------------------------- */
 #ifdef PROFILING
-static inline rtsBool
+STATIC_INLINE rtsBool
 doingLDVProfiling( void )
 {
     return (RtsFlags.ProfFlags.doHeapProfile == HEAP_BY_LDV 
            || RtsFlags.ProfFlags.bioSelector != NULL);
 }
 
-static inline rtsBool
+STATIC_INLINE rtsBool
 doingRetainerProfiling( void )
 {
     return (RtsFlags.ProfFlags.doHeapProfile == HEAP_BY_RETAINER
            || RtsFlags.ProfFlags.retainerSelector != NULL);
 }
-#endif // PROFILING
+#endif /* PROFILING */
 
 // Precesses a closure 'c' being destroyed whose size is 'size'.
 // Make sure that LDV_recordDead() is not invoked on 'inherently used' closures
@@ -249,6 +249,7 @@ LDV_recordDead( StgClosure *c, nat size )
 
     if (era > 0 && closureSatisfiesConstraints(c)) {
        size -= sizeofW(StgProfHeader);
+       ASSERT(LDVW(c) != 0);
        if ((LDVW((c)) & LDV_STATE_MASK) == LDV_STATE_CREATE) {
            t = (LDVW((c)) & LDV_CREATE_MASK) >> LDV_SHIFT;
            if (t < era) {
@@ -304,7 +305,7 @@ LDV_recordDead( StgClosure *c, nat size )
 /* --------------------------------------------------------------------------
  * Initialize censuses[era];
  * ----------------------------------------------------------------------- */
-static inline void
+STATIC_INLINE void
 initEra(Census *census)
 {
     census->hash  = allocHashTable();
@@ -330,7 +331,7 @@ nextEra( void )
        era++;
 
        if (era == max_era) {
-           prog_belch("maximum number of censuses reached; use +RTS -i to reduce");
+           errorBelch("maximum number of censuses reached; use +RTS -i to reduce");
            stg_exit(EXIT_FAILURE);
        }
        
@@ -340,7 +341,7 @@ nextEra( void )
                                       "nextEra");
        }
     }
-#endif // PROFILING
+#endif /* PROFILING */
 
     initEra( &censuses[era] );
 }
@@ -351,6 +352,7 @@ nextEra( void )
 
 #ifdef DEBUG_HEAP_PROF
 FILE *hp_file;
+static char *hp_filename;
 
 void initProfiling1( void )
 {
@@ -358,6 +360,20 @@ void initProfiling1( void )
 
 void initProfiling2( void )
 {
+  if (RtsFlags.ProfFlags.doHeapProfile) {
+    /* Initialise the log file name */
+    hp_filename = stgMallocBytes(strlen(prog_name) + 6, "hpFileName");
+    sprintf(hp_filename, "%s.hp", prog_name);
+    
+    /* open the log file */
+    if ((hp_file = fopen(hp_filename, "w")) == NULL) {
+      debugBelch("Can't open profiling report file %s\n", 
+             hp_filename);
+      RtsFlags.ProfFlags.doHeapProfile = 0;
+      return;
+    }
+  }
+  
   initHeapProfiling();
 }
 
@@ -367,6 +383,16 @@ void endProfiling( void )
 }
 #endif /* DEBUG_HEAP_PROF */
 
+static void
+printSample(rtsBool beginSample, StgDouble sampleValue)
+{
+    StgDouble fractionalPart, integralPart;
+    fractionalPart = modf(sampleValue, &integralPart);
+    fprintf(hp_file, "%s %d.%02d\n",
+            (beginSample ? "BEGIN_SAMPLE" : "END_SAMPLE"),
+            (int)integralPart, (int)(fractionalPart * 100 + 0.5));
+}
+
 /* --------------------------------------------------------------------------
  * Initialize the heap profilier
  * ----------------------------------------------------------------------- */
@@ -379,7 +405,7 @@ initHeapProfiling(void)
 
 #ifdef PROFILING
     if (doingLDVProfiling() && doingRetainerProfiling()) {
-       prog_belch("cannot mix -hb and -hr");
+       errorBelch("cannot mix -hb and -hr");
        stg_exit(1);
     }
 #endif
@@ -407,6 +433,7 @@ initHeapProfiling(void)
 
     initEra( &censuses[era] );
 
+    /* initProfilingLogFile(); */
     fprintf(hp_file, "JOB \"%s", prog_name);
 
 #ifdef PROFILING
@@ -414,10 +441,9 @@ initHeapProfiling(void)
        int count;
        for(count = 1; count < prog_argc; count++)
            fprintf(hp_file, " %s", prog_argv[count]);
-       fprintf(hp_file, " +RTS ");
+       fprintf(hp_file, " +RTS");
        for(count = 0; count < rts_argc; count++)
-           fprintf(hp_file, "%s ", rts_argv[count]);
-       fprintf(hp_file, "\n");
+           fprintf(hp_file, " %s", rts_argv[count]);
     }
 #endif /* PROFILING */
 
@@ -428,8 +454,8 @@ initHeapProfiling(void)
     fprintf(hp_file, "SAMPLE_UNIT \"seconds\"\n");
     fprintf(hp_file, "VALUE_UNIT \"bytes\"\n");
 
-    fprintf(hp_file, "BEGIN_SAMPLE 0.00\n");
-    fprintf(hp_file, "END_SAMPLE 0.00\n");
+    printSample(rtsTrue, 0);
+    printSample(rtsFalse, 0);
 
 #ifdef DEBUG_HEAP_PROF
     DEBUG_LoadSymbols(prog_name);
@@ -471,8 +497,8 @@ endHeapProfiling(void)
 #endif
 
     seconds = mut_user_time();
-    fprintf(hp_file, "BEGIN_SAMPLE %0.2f\n", seconds);
-    fprintf(hp_file, "END_SAMPLE %0.2f\n", seconds);
+    printSample(rtsTrue, seconds);
+    printSample(rtsFalse, seconds);
     fclose(hp_file);
 }
 
@@ -534,13 +560,13 @@ fprint_ccs(FILE *fp, CostCentreStack *ccs, nat max_length)
     }
     fprintf(fp, "%s", buf);
 }
-#endif // PROFILING
+#endif /* PROFILING */
 
 rtsBool
 strMatchesSelector( char* str, char* sel )
 {
    char* p;
-   // fprintf(stderr, "str_matches_selector %s %s\n", str, sel);
+   // debugBelch("str_matches_selector %s %s\n", str, sel);
    while (1) {
        // Compare str against wherever we've got to in sel.
        p = str;
@@ -568,6 +594,7 @@ rtsBool
 closureSatisfiesConstraints( StgClosure* p )
 {
 #ifdef DEBUG_HEAP_PROF
+    (void)p;   /* keep gcc -Wall happy */
     return rtsTrue;
 #else
    rtsBool b;
@@ -668,8 +695,8 @@ aggregateCensusInfo( void )
                // totals *must* be zero.
                ASSERT(c->c.ldv.void_total == 0 && c->c.ldv.drag_total == 0);
 
-               // fprintCCS(stderr,c->identity);
-               // fprintf(stderr," census=%d void_total=%d drag_total=%d\n",
+               // debugCCS(c->identity);
+               // debugBelch(" census=%d void_total=%d drag_total=%d\n",
                //         t, c->c.ldv.void_total, c->c.ldv.drag_total);
            } else {
                d->c.ldv.void_total += c->c.ldv.void_total;
@@ -714,7 +741,7 @@ dumpCensus( Census *census )
     counter *ctr;
     int count;
 
-    fprintf(hp_file, "BEGIN_SAMPLE %0.2f\n", census->time);
+    printSample(rtsTrue, census->time);
 
 #ifdef PROFILING
     if (RtsFlags.ProfFlags.doHeapProfile == HEAP_BY_LDV) {
@@ -727,7 +754,7 @@ dumpCensus( Census *census )
                census->prim * sizeof(W_));
        fprintf(hp_file, "DRAG\t%u\n", census->drag_total *
                sizeof(W_));
-       fprintf(hp_file, "END_SAMPLE %0.2f\n", census->time);
+       printSample(rtsFalse, census->time);
        return;
     }
 #endif
@@ -807,7 +834,7 @@ dumpCensus( Census *census )
        fprintf(hp_file, "\t%d\n", count * sizeof(W_));
     }
 
-    fprintf(hp_file, "END_SAMPLE %0.2f\n", census->time);
+    printSample(rtsFalse, census->time);
 }
 
 /* -----------------------------------------------------------------------------
@@ -880,7 +907,6 @@ heapCensusChain( Census *census, bdescr *bd )
            case FOREIGN:
            case STABLE_NAME:
            case MUT_VAR:
-           case MUT_CONS:
                prim = rtsTrue;
                size = sizeW_fromITBL(info);
                break;