merge upstream HEAD

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

diff --git a/rts/ProfHeap.c b/rts/ProfHeap.c
index 8d98438..f7fbd32 100644 (file)
--- a/rts/ProfHeap.c
+++ b/rts/ProfHeap.c
@@ -15,6 +15,7 @@
 #include "Stats.h"
 #include "Hash.h"
 #include "RetainerProfile.h"
+#include "LdvProfile.h"
 #include "Arena.h"
 #include "Printer.h"
 
@@ -95,86 +96,6 @@ static void dumpCensus( Census *census );
 static rtsBool closureSatisfiesConstraints( StgClosure* p );
 
 /* ----------------------------------------------------------------------------
-   Closure Type Profiling;
-   ------------------------------------------------------------------------- */
-
-#ifndef PROFILING
-static char *type_names[] = {
-    "INVALID_OBJECT",
-    "CONSTR",
-    "CONSTR_1_0",
-    "CONSTR_0_1",
-    "CONSTR_2_0",
-    "CONSTR_1_1",
-    "CONSTR_0_2",
-    "CONSTR_STATIC",
-    "CONSTR_NOCAF_STATIC",
-    "FUN",
-    "FUN_1_0",
-    "FUN_0_1",
-    "FUN_2_0",
-    "FUN_1_1",
-    "FUN_0_2",
-    "FUN_STATIC",
-    "THUNK",
-    "THUNK_1_0",
-    "THUNK_0_1",
-    "THUNK_2_0",
-    "THUNK_1_1",
-    "THUNK_0_2",
-    "THUNK_STATIC",
-    "THUNK_SELECTOR",
-    "BCO",
-    "AP",
-    "PAP",
-    "AP_STACK",
-    "IND",
-    "IND_OLDGEN",
-    "IND_PERM",
-    "IND_OLDGEN_PERM",
-    "IND_STATIC",
-    "RET_BCO",
-    "RET_SMALL",
-    "RET_BIG",
-    "RET_DYN",
-    "RET_FUN",
-    "UPDATE_FRAME",
-    "CATCH_FRAME",
-    "STOP_FRAME",
-    "CAF_BLACKHOLE",
-    "BLACKHOLE",
-    "MVAR_CLEAN",
-    "MVAR_DIRTY",
-    "ARR_WORDS",
-    "MUT_ARR_PTRS_CLEAN",
-    "MUT_ARR_PTRS_DIRTY",
-    "MUT_ARR_PTRS_FROZEN0",
-    "MUT_ARR_PTRS_FROZEN",
-    "MUT_VAR_CLEAN",
-    "MUT_VAR_DIRTY",
-    "WEAK",
-    "STABLE_NAME",
-    "TSO",
-    "BLOCKED_FETCH",
-    "FETCH_ME",
-    "FETCH_ME_BQ",
-    "RBH",
-    "REMOTE_REF",
-    "TVAR_WATCH_QUEUE",
-    "INVARIANT_CHECK_QUEUE",
-    "ATOMIC_INVARIANT",
-    "TVAR",
-    "TREC_CHUNK",
-    "TREC_HEADER",
-    "ATOMICALLY_FRAME",
-    "CATCH_RETRY_FRAME",
-    "CATCH_STM_FRAME",
-    "WHITEHOLE",
-    "N_CLOSURE_TYPES"
-  };
-#endif
-
-/* ----------------------------------------------------------------------------
  * Find the "closure identity", which is a unique pointer reresenting
  * the band to which this closure's heap space is attributed in the
  * heap profile.
@@ -217,7 +138,7 @@ closureIdentity( StgClosure *p )
         case CONSTR_NOCAF_STATIC:
             return GET_CON_DESC(itbl_to_con_itbl(info));
         default:
-            return type_names[info->type];
+            return closure_type_names[info->type];
         }
     }
 
@@ -388,7 +309,7 @@ void initProfiling1 (void)
 {
 }
 
-void freeProfiling1 (void)
+void freeProfiling (void)
 {
 }
 
@@ -955,10 +876,8 @@ heapCensusChain( Census *census, bdescr *bd )
            case CONSTR:
            case FUN:
            case IND_PERM:
-           case IND_OLDGEN:
-           case IND_OLDGEN_PERM:
-           case CAF_BLACKHOLE:
            case BLACKHOLE:
+           case BLOCKING_QUEUE:
            case FUN_1_0:
            case FUN_0_1:
            case FUN_1_1:
@@ -991,7 +910,8 @@ heapCensusChain( Census *census, bdescr *bd )
             case MVAR_CLEAN:
             case MVAR_DIRTY:
            case WEAK:
-           case STABLE_NAME:
+           case PRIM:
+           case MUT_PRIM:
            case MUT_VAR_CLEAN:
            case MUT_VAR_DIRTY:
                prim = rtsTrue;
@@ -1027,44 +947,35 @@ heapCensusChain( Census *census, bdescr *bd )
                prim = rtsTrue;
 #ifdef PROFILING
                if (RtsFlags.ProfFlags.includeTSOs) {
-                   size = tso_sizeW((StgTSO *)p);
+                    size = sizeofW(StgTSO);
                    break;
                } else {
                    // Skip this TSO and move on to the next object
-                   p += tso_sizeW((StgTSO *)p);
+                    p += sizeofW(StgTSO);
                    continue;
                }
 #else
-               size = tso_sizeW((StgTSO *)p);
+                size = sizeofW(StgTSO);
                break;
 #endif
 
-           case TREC_HEADER: 
+            case STACK:
                prim = rtsTrue;
-               size = sizeofW(StgTRecHeader);
+#ifdef PROFILING
+               if (RtsFlags.ProfFlags.includeTSOs) {
+                    size = stack_sizeW((StgStack*)p);
+                    break;
+               } else {
+                   // Skip this TSO and move on to the next object
+                    p += stack_sizeW((StgStack*)p);
+                   continue;
+               }
+#else
+                size = stack_sizeW((StgStack*)p);
                break;
+#endif
 
-           case TVAR_WATCH_QUEUE:
-               prim = rtsTrue;
-               size = sizeofW(StgTVarWatchQueue);
-               break;
-               
-           case INVARIANT_CHECK_QUEUE:
-               prim = rtsTrue;
-               size = sizeofW(StgInvariantCheckQueue);
-               break;
-               
-           case ATOMIC_INVARIANT:
-               prim = rtsTrue;
-               size = sizeofW(StgAtomicInvariant);
-               break;
-               
-           case TVAR:
-               prim = rtsTrue;
-               size = sizeofW(StgTVar);
-               break;
-               
-           case TREC_CHUNK:
+            case TREC_CHUNK:
                prim = rtsTrue;
                size = sizeofW(StgTRecChunk);
                break;
@@ -1146,7 +1057,7 @@ heapCensusChain( Census *census, bdescr *bd )
 void
 heapCensus( void )
 {
-  nat g, s;
+  nat g;
   Census *census;
 
   census = &censuses[era];
@@ -1164,17 +1075,11 @@ heapCensus( void )
 #endif
 
   // Traverse the heap, collecting the census info
-  if (RtsFlags.GcFlags.generations == 1) {
-      heapCensusChain( census, g0s0->blocks );
-  } else {
-      for (g = 0; g < RtsFlags.GcFlags.generations; g++) {
-         for (s = 0; s < generations[g].n_steps; s++) {
-             heapCensusChain( census, generations[g].steps[s].blocks );
-             // Are we interested in large objects?  might be
-             // confusing to include the stack in a heap profile.
-             heapCensusChain( census, generations[g].steps[s].large_objects );
-         }
-      }
+  for (g = 0; g < RtsFlags.GcFlags.generations; g++) {
+      heapCensusChain( census, generations[g].blocks );
+      // Are we interested in large objects?  might be
+      // confusing to include the stack in a heap profile.
+      heapCensusChain( census, generations[g].large_objects );
   }
 
   // dump out the census info