free empty blocks at the end of GC

[ghc-hetmet.git] / rts / sm / GC.c

diff --git a/rts/sm/GC.c b/rts/sm/GC.c
index 1ac27f2..97b32b6 100644 (file)
--- a/rts/sm/GC.c
+++ b/rts/sm/GC.c
@@ -181,7 +181,7 @@ GarbageCollect ( rtsBool force_major_gc )
 {
   bdescr *bd;
   step *stp;
-  lnat live, allocated;
+  lnat live, allocated, max_copied, avg_copied;
   lnat oldgen_saved_blocks = 0;
   gc_thread *saved_gct;
   nat g, s, t, n;
@@ -410,7 +410,7 @@ GarbageCollect ( rtsBool force_major_gc )
   {
       gc_thread *thr;
       step_workspace *ws;
-      bdescr *prev;
+      bdescr *prev, *next;
 
       for (t = 0; t < n_gc_threads; t++) {
          thr = gc_threads[t];
@@ -418,37 +418,50 @@ GarbageCollect ( rtsBool force_major_gc )
           // not step 0
           for (s = 1; s < total_steps; s++) {
               ws = &thr->steps[s];
-              // Not true?
-              // ASSERT( ws->scan_bd == ws->todo_bd );
-              ASSERT( ws->scan_bd ? ws->scan_bd->u.scan == ws->scan_bd->free : 1 );
 
               // Push the final block
-              if (ws->scan_bd) { push_scanned_block(ws->scan_bd, ws); }
-              
+              if (ws->todo_bd) { 
+                  push_scanned_block(ws->todo_bd, ws);
+              }
+
+              ASSERT(gct->scan_bd == NULL);
               ASSERT(countBlocks(ws->scavd_list) == ws->n_scavd_blocks);
               
-              prev = ws->part_list;
-              for (bd = ws->part_list; bd != NULL; bd = bd->link) {
+              prev = NULL;
+              for (bd = ws->scavd_list; bd != NULL; bd = bd->link) {
                   bd->flags &= ~BF_EVACUATED;   // now from-space 
                   ws->step->n_words += bd->free - bd->start;
                   prev = bd;
               }
               if (prev != NULL) {
-                  prev->link = ws->scavd_list;
-              }
-              for (bd = ws->scavd_list; bd != NULL; bd = bd->link) {
-                  bd->flags &= ~BF_EVACUATED;   // now from-space 
-                  ws->step->n_words += bd->free - bd->start;
-                  prev = bd;
+                  prev->link = ws->step->blocks;
+                  ws->step->blocks = ws->scavd_list;
+              } 
+              ws->step->n_blocks += ws->n_scavd_blocks;
+
+              prev = NULL;
+              for (bd = ws->part_list; bd != NULL; bd = next) {
+                  next = bd->link;
+                  if (bd->free == bd->start) {
+                      if (prev == NULL) {
+                          ws->part_list = next;
+                      } else {
+                          prev->link = next;
+                      }
+                      freeGroup(bd);
+                      ws->n_part_blocks--;
+                  } else {
+                      bd->flags &= ~BF_EVACUATED;       // now from-space 
+                      ws->step->n_words += bd->free - bd->start;
+                      prev = bd;
+                  }
               }
-              prev->link = ws->step->blocks;
-              if (ws->part_list != NULL) {
+              if (prev != NULL) {
+                  prev->link = ws->step->blocks;
                   ws->step->blocks = ws->part_list;
-              } else {
-                  ws->step->blocks = ws->scavd_list;
               }
               ws->step->n_blocks += ws->n_part_blocks;
-              ws->step->n_blocks += ws->n_scavd_blocks;
+
               ASSERT(countBlocks(ws->step->blocks) == ws->step->n_blocks);
               ASSERT(countOccupied(ws->step->blocks) == ws->step->n_words);
          }
@@ -471,24 +484,35 @@ GarbageCollect ( rtsBool force_major_gc )
   /* run through all the generations/steps and tidy up 
    */
   copied = 0;
+  max_copied = 0;
+  avg_copied = 0;
   { 
       nat i;
       for (i=0; i < n_gc_threads; i++) {
           if (n_gc_threads > 1) {
               trace(TRACE_gc,"thread %d:", i);
               trace(TRACE_gc,"   copied           %ld", gc_threads[i]->copied * sizeof(W_));
+              trace(TRACE_gc,"   scanned          %ld", gc_threads[i]->scanned * sizeof(W_));
               trace(TRACE_gc,"   any_work         %ld", gc_threads[i]->any_work);
               trace(TRACE_gc,"   no_work          %ld", gc_threads[i]->no_work);
               trace(TRACE_gc,"   scav_find_work %ld",   gc_threads[i]->scav_find_work);
           }
           copied += gc_threads[i]->copied;
+          max_copied = stg_max(gc_threads[i]->copied, max_copied);
+      }
+      if (n_gc_threads == 1) {
+          max_copied = 0;
+          avg_copied = 0;
+      } else {
+          avg_copied = copied;
       }
   }
 
   for (g = 0; g < RtsFlags.GcFlags.generations; g++) {
 
-    if (g <= N) {
+    if (g == N) {
       generations[g].collections++; // for stats 
+      if (n_gc_threads > 1) generations[g].par_collections++;
     }
 
     // Count the mutable list as bytes "copied" for the purposes of
@@ -698,7 +722,7 @@ GarbageCollect ( rtsBool force_major_gc )
 #endif
 
   // ok, GC over: tell the stats department what happened. 
-  stat_endGC(allocated, live, copied, N);
+  stat_endGC(allocated, live, copied, N, max_copied, avg_copied);
 
 #if defined(RTS_USER_SIGNALS)
   if (RtsFlags.MiscFlags.install_signal_handlers) {
@@ -1000,8 +1024,6 @@ alloc_gc_thread (int n)
         ASSERT(s == ws->step->abs_no);
         ws->gct = t;
         
-        ws->scan_bd = NULL;
-
         ws->todo_bd = NULL;
         ws->buffer_todo_bd = NULL;
         
@@ -1330,8 +1352,6 @@ init_collected_gen (nat g, nat n_threads)
 
            ws = &gc_threads[t]->steps[g * RtsFlags.GcFlags.steps + s];
 
-           ws->scan_bd = NULL;
-
            ws->todo_large_objects = NULL;
 
             ws->part_list = NULL;
@@ -1394,19 +1414,11 @@ init_uncollected_gen (nat g, nat threads)
                stp->n_blocks -= 1;
                 stp->n_words -= ws->todo_bd->free - ws->todo_bd->start;
                ws->todo_bd->link = NULL;
-
-               // this block is also the scan block; we must scan
-               // from the current end point.
-               ws->scan_bd = ws->todo_bd;
-               ws->scan_bd->u.scan = ws->scan_bd->free;
-
-               // subtract the contents of this block from the stats,
-               // because we'll count the whole block later.
-               copied -= ws->scan_bd->free - ws->scan_bd->start;
+               // we must scan from the current end point.
+               ws->todo_bd->u.scan = ws->todo_bd->free;
            } 
            else
            {
-               ws->scan_bd = NULL;
                ws->todo_bd = NULL;
                alloc_todo_block(ws,0);
            }
@@ -1435,15 +1447,16 @@ init_gc_thread (gc_thread *t)
 {
     t->static_objects = END_OF_STATIC_LIST;
     t->scavenged_static_objects = END_OF_STATIC_LIST;
+    t->scan_bd = NULL;
     t->evac_step = 0;
     t->failed_to_evac = rtsFalse;
     t->eager_promotion = rtsTrue;
     t->thunk_selector_depth = 0;
     t->copied = 0;
+    t->scanned = 0;
     t->any_work = 0;
     t->no_work = 0;
     t->scav_find_work = 0;
-
 }
 
 /* -----------------------------------------------------------------------------