rts/RetainerProfile: Dump closure type if push() fails
[ghc.git] / rts / Proftimer.c
index 7ee32f8..eb4a932 100644 (file)
 #include "Proftimer.h"
 #include "Capability.h"
 
-#ifdef PROFILING
-static rtsBool do_prof_ticks = rtsFalse;       // enable profiling ticks
+#if defined(PROFILING)
+static bool do_prof_ticks = false;       // enable profiling ticks
 #endif
 
-static rtsBool do_heap_prof_ticks = rtsFalse;  // enable heap profiling ticks
+static bool do_heap_prof_ticks = false;  // enable heap profiling ticks
 
 // Number of ticks until next heap census
 static int ticks_to_heap_profile;
 
 // Time for a heap profile on the next context switch
-rtsBool performHeapProfile;
+bool performHeapProfile;
 
 void
 stopProfTimer( void )
 {
-#ifdef PROFILING
-    do_prof_ticks = rtsFalse;
+#if defined(PROFILING)
+    do_prof_ticks = false;
 #endif
 }
 
 void
 startProfTimer( void )
 {
-#ifdef PROFILING
-    do_prof_ticks = rtsTrue;
+#if defined(PROFILING)
+    do_prof_ticks = true;
 #endif
 }
 
 void
 stopHeapProfTimer( void )
 {
-    do_heap_prof_ticks = rtsFalse;
+    do_heap_prof_ticks = false;
 }
 
 void
 startHeapProfTimer( void )
 {
-    if (RtsFlags.ProfFlags.doHeapProfile && 
+    if (RtsFlags.ProfFlags.doHeapProfile &&
         RtsFlags.ProfFlags.heapProfileIntervalTicks > 0) {
-       do_heap_prof_ticks = rtsTrue;
+        do_heap_prof_ticks = true;
     }
 }
 
 void
 initProfTimer( void )
 {
-    performHeapProfile = rtsFalse;
+    performHeapProfile = false;
 
     ticks_to_heap_profile = RtsFlags.ProfFlags.heapProfileIntervalTicks;
 
     startHeapProfTimer();
 }
 
-nat total_ticks = 0;
+uint32_t total_ticks = 0;
 
 void
 handleProfTick(void)
 {
-#ifdef PROFILING
+#if defined(PROFILING)
     total_ticks++;
     if (do_prof_ticks) {
-        nat n;
+        uint32_t n;
         for (n=0; n < n_capabilities; n++) {
-            capabilities[n].r.rCCCS->time_ticks++;
+            capabilities[n]->r.rCCCS->time_ticks++;
         }
     }
 #endif
 
     if (do_heap_prof_ticks) {
-       ticks_to_heap_profile--;
-       if (ticks_to_heap_profile <= 0) {
+        ticks_to_heap_profile--;
+        if (ticks_to_heap_profile <= 0) {
             ticks_to_heap_profile = RtsFlags.ProfFlags.heapProfileIntervalTicks;
-           performHeapProfile = rtsTrue;
-       }
+            performHeapProfile = true;
+        }
     }
 }