rts/RetainerProfile: Dump closure type if push() fails
[ghc.git] / rts / Proftimer.c
index ce20c49..eb4a932 100644 (file)
@@ -6,77 +6,86 @@
  *
  * ---------------------------------------------------------------------------*/
 
-#if defined (PROFILING)
-
 #include "PosixSource.h"
-
 #include "Rts.h"
+
 #include "Profiling.h"
-#include "Timer.h"
 #include "Proftimer.h"
-#include "RtsFlags.h"
+#include "Capability.h"
 
-static rtsBool do_prof_ticks = rtsFalse;       // enable profiling ticks
-static rtsBool do_heap_prof_ticks = rtsFalse;  // enable heap profiling ticks
+#if defined(PROFILING)
+static bool do_prof_ticks = false;       // enable profiling ticks
+#endif
+
+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 )
 {
-    do_prof_ticks = rtsFalse;
+#if defined(PROFILING)
+    do_prof_ticks = false;
+#endif
 }
 
 void
 startProfTimer( void )
 {
-    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 && 
-       RtsFlags.ProfFlags.profileIntervalTicks > 0) {
-       do_heap_prof_ticks = rtsTrue;
+    if (RtsFlags.ProfFlags.doHeapProfile &&
+        RtsFlags.ProfFlags.heapProfileIntervalTicks > 0) {
+        do_heap_prof_ticks = true;
     }
 }
 
 void
 initProfTimer( void )
 {
-    performHeapProfile = rtsFalse;
+    performHeapProfile = false;
 
-    ticks_to_heap_profile = RtsFlags.ProfFlags.profileIntervalTicks;
+    ticks_to_heap_profile = RtsFlags.ProfFlags.heapProfileIntervalTicks;
 
     startHeapProfTimer();
 }
 
+uint32_t total_ticks = 0;
 
 void
 handleProfTick(void)
 {
+#if defined(PROFILING)
+    total_ticks++;
     if (do_prof_ticks) {
-       CCCS->time_ticks++;
+        uint32_t n;
+        for (n=0; n < n_capabilities; n++) {
+            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 = RtsFlags.ProfFlags.profileIntervalTicks;
-           performHeapProfile = rtsTrue;
-       }
+        ticks_to_heap_profile--;
+        if (ticks_to_heap_profile <= 0) {
+            ticks_to_heap_profile = RtsFlags.ProfFlags.heapProfileIntervalTicks;
+            performHeapProfile = true;
+        }
     }
 }
-
-#endif /* PROFILING */