X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;ds=sidebyside;f=ghc%2Frts%2FProfHeap.c;h=9ef9a11614078e4516801690991fbe5a52c6cc89;hb=03b0ad1099f0d17bd8ac26fef9dff82d2dfbdf85;hp=9bb10aec16c0b727fc0f4a83fdd33b9befd6e196;hpb=88740ad379e77efc892ecbef82cde626ee9a6bd9;p=ghc-hetmet.git

diff --git a/ghc/rts/ProfHeap.c b/ghc/rts/ProfHeap.c
index 9bb10ae..9ef9a11 100644
--- a/ghc/rts/ProfHeap.c
+++ b/ghc/rts/ProfHeap.c
@@ -1,5 +1,5 @@
 /* -----------------------------------------------------------------------------
- * $Id: ProfHeap.c,v 1.4 2000/03/07 11:53:12 simonmar Exp $
+ * $Id: ProfHeap.c,v 1.12 2000/04/19 12:42:48 simonmar Exp $
  *
  * (c) The GHC Team, 1998-2000
  *
@@ -18,11 +18,13 @@
 #include "Rts.h"
 #include "RtsUtils.h"
 #include "RtsFlags.h"
-#include "ProfRts.h"
+#include "Profiling.h"
 #include "Storage.h"
 #include "ProfHeap.h"
 #include "Stats.h"
-#include "ProfRts.h"
+#include "Hash.h"
+#include "StrHash.h"
+
 #ifdef DEBUG_HEAP_PROF
 #include "Printer.h"
 static void initSymbolHash(void);
@@ -30,10 +32,127 @@ static void clear_table_data(void);
 static void fprint_data(FILE *fp);
 #endif
 
-char prof_filename[128];	/* urk */
+/* -----------------------------------------------------------------------------
+ * Hash tables.
+ *
+ * For profiling by module, constructor or closure type we need to be
+ * able to get from a string describing the category to a structure
+ * containing the counters for that category.  The strings aren't
+ * unique (although gcc will do a fairly good job of commoning them up
+ * where possible), so we have a many->one mapping.
+ *
+ * We represent the many->one mapping with a hash table.  In order to
+ * find the unique counter associated with a string the first time we
+ * encounter a particular string, we need another hash table, mapping
+ * hashed strings to buckets of counters.  The string is hashed, then
+ * the bucket is searched for an existing counter for the same
+ * string. 
+ *
+ * -------------------------------------------------------------------------- */
+
+typedef struct _ctr {
+    const char *str;
+    unsigned long mem_resid;
+    struct _ctr *next;
+    struct _ctr *next_bucket;
+} prof_ctr;
+
+/* Linked list of all existing ctr structs */
+prof_ctr *all_ctrs;
+
+/* Hash table mapping (char *) -> (struct _ctr) */
+HashTable *str_to_ctr;
+
+/* Hash table mapping hash_t (hashed string) -> (struct _ctr) */
+HashTable *hashstr_to_ctrs;
+
+static void
+initHashTables( void )
+{
+    str_to_ctr      = allocHashTable();
+    hashstr_to_ctrs = allocHashTable();
+    all_ctrs = NULL;
+}
+
+static prof_ctr *
+strToCtr(const char *str)
+{
+    prof_ctr *ctr;
+
+    ctr = lookupHashTable( str_to_ctr, (W_)str );
+
+    if (ctr != NULL) { return ctr; }
+
+    else {
+	hash_t str_hash = hash_str((char *)str);
+	prof_ctr *prev;
+
+	ctr = lookupHashTable( hashstr_to_ctrs, (W_)str_hash );
+	prev = NULL;
+
+	for (; ctr != NULL; prev = ctr, ctr = ctr->next_bucket ) {
+	    if (!strcmp(ctr->str, str)) {
+		insertHashTable( str_to_ctr, (W_)str, ctr );
+#ifdef DEBUG
+		fprintf(stderr,"strToCtr: existing ctr for `%s'\n",str);
+#endif
+		return ctr;
+	    }
+	}
+
+	ctr = stgMallocBytes(sizeof(prof_ctr), "strToCtr");
+	ctr->mem_resid = 0;
+	ctr->str = str;
+	ctr->next_bucket = NULL;
+	ctr->next = all_ctrs;
+	all_ctrs = ctr;
+
+#ifdef DEBUG
+	fprintf(stderr,"strToCtr: new ctr for `%s'\n",str);
+#endif
+
+	if (prev != NULL) {
+	    prev->next_bucket = ctr;
+	} else {
+	    insertHashTable( hashstr_to_ctrs, str_hash, ctr );
+	}
+	insertHashTable( str_to_ctr, (W_)str, ctr);
+	return ctr;
+    }
+}
+
+static void
+clearCtrResid( void )
+{
+    prof_ctr *ctr;
+    
+    for (ctr = all_ctrs; ctr != NULL; ctr = ctr->next) {
+	ctr->mem_resid = 0;
+    }
+}
+
+static void
+reportCtrResid(FILE *fp)
+{
+    prof_ctr *ctr;
+    
+    for (ctr = all_ctrs; ctr != NULL; ctr = ctr->next) {
+	if (ctr->mem_resid != 0) {
+	    fprintf(fp,"   %s %ld\n", ctr->str, ctr->mem_resid * sizeof(W_));
+	}
+    }
+}
+
+/* -------------------------------------------------------------------------- */
 
 #ifdef DEBUG_HEAP_PROF
-void initProfiling( void )
+FILE *hp_file;
+
+void initProfiling1( void )
+{
+}
+
+void initProfiling2( void )
 {
   initHeapProfiling();
 }
@@ -51,20 +170,24 @@ initHeapProfiling(void)
         return 0;
     }
 
-    fprintf(prof_file, "JOB \"%s\"\n", prog_argv[0]);
-    fprintf(prof_file, "DATE \"%s\"\n", time_str());
+    fprintf(hp_file, "JOB \"%s\"\n", prog_argv[0]);
+    fprintf(hp_file, "DATE \"%s\"\n", time_str());
 
-    fprintf(prof_file, "SAMPLE_UNIT \"seconds\"\n");
-    fprintf(prof_file, "VALUE_UNIT \"bytes\"\n");
+    fprintf(hp_file, "SAMPLE_UNIT \"seconds\"\n");
+    fprintf(hp_file, "VALUE_UNIT \"bytes\"\n");
 
-    fprintf(prof_file, "BEGIN_SAMPLE 0.00\n");
-    fprintf(prof_file, "END_SAMPLE 0.00\n");
+    fprintf(hp_file, "BEGIN_SAMPLE 0.00\n");
+    fprintf(hp_file, "END_SAMPLE 0.00\n");
 
 #ifdef DEBUG_HEAP_PROF
     DEBUG_LoadSymbols(prog_argv[0]);
     initSymbolHash();
 #endif
 
+#ifdef PROFILING
+    initHashTables();
+#endif
+
     return 0;
 }
 
@@ -78,9 +201,9 @@ endHeapProfiling(void)
     }
 
     seconds = mut_user_time();
-    fprintf(prof_file, "BEGIN_SAMPLE %0.2f\n", seconds);
-    fprintf(prof_file, "END_SAMPLE %0.2f\n", seconds);
-    fclose(prof_file);
+    fprintf(hp_file, "BEGIN_SAMPLE %0.2f\n", seconds);
+    fprintf(hp_file, "END_SAMPLE %0.2f\n", seconds);
+    fclose(hp_file);
 }
 
 #ifdef DEBUG_HEAP_PROF
@@ -264,7 +387,9 @@ clearCCSResid(CostCentreStack *ccs)
   ccs->mem_resid = 0;
 
   for (i = ccs->indexTable; i != 0; i = i->next) {
-    clearCCSResid(i->ccs);
+    if (!i->back_edge) {
+      clearCCSResid(i->ccs);
+    }
   }
 }
 
@@ -278,7 +403,7 @@ fprint_ccs(FILE *fp, CostCentreStack *ccs, nat components)
   prev = ccs->prevStack;
 
   if (prev == NULL
-      || prev->cc->is_subsumed != CC_IS_BORING
+      || prev->cc->is_caf != CC_IS_BORING
       || components == 1) { 
     fprintf(fp,"%s",cc->label);
     return; 
@@ -301,7 +426,9 @@ reportCCSResid(FILE *fp, CostCentreStack *ccs)
   }
 
   for (i = ccs->indexTable; i != 0; i = i->next) {
-    reportCCSResid(fp,i->ccs);
+    if (!i->back_edge) {
+      reportCCSResid(fp,i->ccs);
+    }
   }
 }
 #endif
@@ -321,7 +448,10 @@ heapCensus(void)
     clear_table_data();
     break;
   case HEAP_BY_CLOSURE_TYPE:
+#if 0
+#   error fix me      
     memset(closure_types, 0, N_CLOSURE_TYPES * sizeof(nat));
+#endif
     break;
   default:
     return;
@@ -331,14 +461,19 @@ heapCensus(void)
 #ifdef PROFILING
   switch (RtsFlags.ProfFlags.doHeapProfile) {
   case NO_HEAP_PROFILING:
-    return;
+      return;
   case HEAP_BY_CCS:
-    break;
+      /* zero all the residency counters */
+      clearCCSResid(CCS_MAIN);
+      break;
+  case HEAP_BY_MOD:
+  case HEAP_BY_DESCR:
+  case HEAP_BY_TYPE:
+      clearCtrResid();
+      break;
   default:
-    barf("heapCensus; doHeapProfile");
+      barf("heapCensus; doHeapProfile");
   }
-  /* zero all the residency counters */
-  clearCCSResid(CCS_MAIN);
 #endif
 
   /* Only do heap profiling in a two-space heap */
@@ -346,7 +481,7 @@ heapCensus(void)
   bd = g0s0->to_space;
 
   time = mut_user_time_during_GC();
-  fprintf(prof_file, "BEGIN_SAMPLE %0.2f\n", time);
+  fprintf(hp_file, "BEGIN_SAMPLE %0.2f\n", time);
   
   while (bd != NULL) {
     p = bd->start;
@@ -386,8 +521,6 @@ heapCensus(void)
       case FUN_1_1:
       case FUN_0_2:
       case FUN_2_0:
-      case THUNK_1_0:
-      case THUNK_0_1:
       case THUNK_1_1:
       case THUNK_0_2:
       case THUNK_2_0:
@@ -399,6 +532,8 @@ heapCensus(void)
 	size = sizeW_fromITBL(info);
 	break;
 	
+      case THUNK_1_0:		/* ToDo - shouldn't be here */
+      case THUNK_0_1:		/* "  ditto  " */
       case THUNK_SELECTOR:
 	size = sizeofW(StgHeader) + MIN_UPD_SIZE;
 	break;
@@ -437,7 +572,25 @@ heapCensus(void)
 #endif
 
 #ifdef PROFILING      
-      ((StgClosure *)p)->header.prof.ccs->mem_resid += size;
+      switch (RtsFlags.ProfFlags.doHeapProfile) {
+      case HEAP_BY_CCS:
+	  ((StgClosure *)p)->header.prof.ccs->mem_resid += size;
+	  break;
+      case HEAP_BY_MOD:
+	  strToCtr(((StgClosure *)p)->header.prof.ccs->cc->module)
+	      ->mem_resid += size;
+	  break;
+      case HEAP_BY_DESCR:
+	  strToCtr(get_itbl(((StgClosure *)p))->prof.closure_desc)->mem_resid 
+	      += size;
+	  break;
+      case HEAP_BY_TYPE:
+	  strToCtr(get_itbl(((StgClosure *)p))->prof.closure_type)->mem_resid
+	      += size;
+	  break;
+      default:
+	  barf("heapCensus; doHeapProfile");
+  }
 #endif
       p += size;
     }
@@ -447,19 +600,30 @@ heapCensus(void)
 #ifdef DEBUG_HEAP_PROF
   switch (RtsFlags.ProfFlags.doHeapProfile) {
   case HEAP_BY_INFOPTR:
-    fprint_data(prof_file);
+    fprint_data(hp_file);
     break;
   case HEAP_BY_CLOSURE_TYPE:
-    fprint_closure_types(prof_file);
+    fprint_closure_types(hp_file);
     break;
   }
 #endif
     
 #ifdef PROFILING
-  reportCCSResid(prof_file,CCS_MAIN);
+  switch (RtsFlags.ProfFlags.doHeapProfile) {
+  case HEAP_BY_CCS:
+      reportCCSResid(hp_file,CCS_MAIN);
+      break;
+  case HEAP_BY_MOD:
+  case HEAP_BY_DESCR:
+  case HEAP_BY_TYPE:
+      reportCtrResid(hp_file);
+      break;
+  default:
+      barf("heapCensus; doHeapProfile");
+  }
 #endif
 
-  fprintf(prof_file, "END_SAMPLE %0.2f\n", time);
+  fprintf(hp_file, "END_SAMPLE %0.2f\n", time);
 }    
 
 #endif /* PROFILING || DEBUG_HEAP_PROF */