Use message-passing to implement throwTo in the RTS

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

diff --git a/rts/sm/Sanity.c b/rts/sm/Sanity.c
index b6edba8..11d5424 100644 (file)
--- a/rts/sm/Sanity.c
+++ b/rts/sm/Sanity.c
@@ -307,7 +307,8 @@ checkClosure( StgClosure* p )
     case IND_OLDGEN_PERM:
     case BLACKHOLE:
     case CAF_BLACKHOLE:
-    case STABLE_NAME:
+    case PRIM:
+    case MUT_PRIM:
     case MUT_VAR_CLEAN:
     case MUT_VAR_DIRTY:
     case CONSTR_STATIC:
@@ -416,39 +417,6 @@ checkClosure( StgClosure* p )
         checkTSO((StgTSO *)p);
         return tso_sizeW((StgTSO *)p);
 
-    case TVAR_WATCH_QUEUE:
-      {
-        StgTVarWatchQueue *wq = (StgTVarWatchQueue *)p;
-        ASSERT(LOOKS_LIKE_CLOSURE_PTR(wq->next_queue_entry));
-        ASSERT(LOOKS_LIKE_CLOSURE_PTR(wq->prev_queue_entry));
-        return sizeofW(StgTVarWatchQueue);
-      }
-
-    case INVARIANT_CHECK_QUEUE:
-      {
-        StgInvariantCheckQueue *q = (StgInvariantCheckQueue *)p;
-        ASSERT(LOOKS_LIKE_CLOSURE_PTR(q->invariant));
-        ASSERT(LOOKS_LIKE_CLOSURE_PTR(q->my_execution));
-        ASSERT(LOOKS_LIKE_CLOSURE_PTR(q->next_queue_entry));
-        return sizeofW(StgInvariantCheckQueue);
-      }
-
-    case ATOMIC_INVARIANT:
-      {
-        StgAtomicInvariant *invariant = (StgAtomicInvariant *)p;
-        ASSERT(LOOKS_LIKE_CLOSURE_PTR(invariant->code));
-        ASSERT(LOOKS_LIKE_CLOSURE_PTR(invariant->last_execution));
-        return sizeofW(StgAtomicInvariant);
-      }
-
-    case TVAR:
-      {
-        StgTVar *tv = (StgTVar *)p;
-        ASSERT(LOOKS_LIKE_CLOSURE_PTR(tv->current_value));
-        ASSERT(LOOKS_LIKE_CLOSURE_PTR(tv->first_watch_queue_entry));
-        return sizeofW(StgTVar);
-      }
-
     case TREC_CHUNK:
       {
         nat i;
@@ -461,14 +429,6 @@ checkClosure( StgClosure* p )
         }
         return sizeofW(StgTRecChunk);
       }
-
-    case TREC_HEADER:
-      {
-        StgTRecHeader *trec = (StgTRecHeader *)p;
-        ASSERT(LOOKS_LIKE_CLOSURE_PTR(trec -> enclosing_trec));
-        ASSERT(LOOKS_LIKE_CLOSURE_PTR(trec -> current_chunk));
-        return sizeofW(StgTRecHeader);
-      }
       
     default:
            barf("checkClosure (closure type %d)", info->type);
@@ -569,10 +529,10 @@ void
 checkGlobalTSOList (rtsBool checkTSOs)
 {
   StgTSO *tso;
-  nat s;
+  nat g;
 
-  for (s = 0; s < total_steps; s++) {
-      for (tso=all_steps[s].threads; tso != END_TSO_QUEUE; 
+  for (g = 0; g < RtsFlags.GcFlags.generations; g++) {
+      for (tso=generations[g].threads; tso != END_TSO_QUEUE; 
            tso = tso->global_link) {
           ASSERT(LOOKS_LIKE_CLOSURE_PTR(tso));
           ASSERT(get_itbl(tso)->type == TSO);
@@ -673,20 +633,19 @@ checkStaticObjects ( StgClosure* static_objects )
 
 /* Nursery sanity check */
 void
-checkNurserySanity( step *stp )
+checkNurserySanity (nursery *nursery)
 {
     bdescr *bd, *prev;
     nat blocks = 0;
 
     prev = NULL;
-    for (bd = stp->blocks; bd != NULL; bd = bd->link) {
+    for (bd = nursery->blocks; bd != NULL; bd = bd->link) {
        ASSERT(bd->u.back == prev);
        prev = bd;
        blocks += bd->blocks;
     }
 
-    ASSERT(blocks == stp->n_blocks);
-    ASSERT(countBlocks(stp->large_objects) == stp->n_large_blocks);
+    ASSERT(blocks == nursery->n_blocks);
 }
 
 
@@ -694,26 +653,21 @@ checkNurserySanity( step *stp )
 void
 checkSanity( rtsBool check_heap )
 {
-    nat g, s;
+    nat g, n;
 
     for (g = 0; g < RtsFlags.GcFlags.generations; g++) {
-        for (s = 0; s < generations[g].n_steps; s++) {
-            if (g == 0 && s == 0 && RtsFlags.GcFlags.generations > 1) { 
-                continue;
-            }
-            ASSERT(countBlocks(generations[g].steps[s].blocks)
-                   == generations[g].steps[s].n_blocks);
-            ASSERT(countBlocks(generations[g].steps[s].large_objects)
-                   == generations[g].steps[s].n_large_blocks);
-            if (check_heap) {
-                checkHeap(generations[g].steps[s].blocks);
-            }
-            checkLargeObjects(generations[g].steps[s].large_objects);
+        ASSERT(countBlocks(generations[g].blocks)
+               == generations[g].n_blocks);
+        ASSERT(countBlocks(generations[g].large_objects)
+                   == generations[g].n_large_blocks);
+        if (check_heap) {
+            checkHeap(generations[g].blocks);
         }
+        checkLargeObjects(generations[g].large_objects);
     }
     
-    for (s = 0; s < n_capabilities; s++) {
-        checkNurserySanity(&nurseries[s]);
+    for (n = 0; n < n_capabilities; n++) {
+        checkNurserySanity(&nurseries[n]);
     }
     
     checkFreeListSanity();
@@ -741,21 +695,18 @@ checkSanity( rtsBool check_heap )
 static void
 findMemoryLeak (void)
 {
-  nat g, s, i;
+  nat g, i;
   for (g = 0; g < RtsFlags.GcFlags.generations; g++) {
       for (i = 0; i < n_capabilities; i++) {
          markBlocks(capabilities[i].mut_lists[g]);
       }
       markBlocks(generations[g].mut_list);
-      for (s = 0; s < generations[g].n_steps; s++) {
-         markBlocks(generations[g].steps[s].blocks);
-         markBlocks(generations[g].steps[s].large_objects);
-      }
+      markBlocks(generations[g].blocks);
+      markBlocks(generations[g].large_objects);
   }
 
   for (i = 0; i < n_capabilities; i++) {
       markBlocks(nurseries[i].blocks);
-      markBlocks(nurseries[i].large_objects);
   }
 
 #ifdef PROFILING
@@ -800,19 +751,18 @@ void findSlop(bdescr *bd)
 }
 
 static lnat
-stepBlocks (step *stp)
+genBlocks (generation *gen)
 {
-    ASSERT(countBlocks(stp->blocks) == stp->n_blocks);
-    ASSERT(countBlocks(stp->large_objects) == stp->n_large_blocks);
-    return stp->n_blocks + stp->n_old_blocks + 
-           countAllocdBlocks(stp->large_objects);
+    ASSERT(countBlocks(gen->blocks) == gen->n_blocks);
+    ASSERT(countBlocks(gen->large_objects) == gen->n_large_blocks);
+    return gen->n_blocks + gen->n_old_blocks + 
+           countAllocdBlocks(gen->large_objects);
 }
 
 void
 memInventory (rtsBool show)
 {
-  nat g, s, i;
-  step *stp;
+  nat g, i;
   lnat gen_blocks[RtsFlags.GcFlags.generations];
   lnat nursery_blocks, retainer_blocks,
        arena_blocks, exec_blocks;
@@ -827,15 +777,13 @@ memInventory (rtsBool show)
          gen_blocks[g] += countBlocks(capabilities[i].mut_lists[g]);
       }          
       gen_blocks[g] += countAllocdBlocks(generations[g].mut_list);
-      for (s = 0; s < generations[g].n_steps; s++) {
-         stp = &generations[g].steps[s];
-         gen_blocks[g] += stepBlocks(stp);
-      }
+      gen_blocks[g] += genBlocks(&generations[g]);
   }
 
   nursery_blocks = 0;
   for (i = 0; i < n_capabilities; i++) {
-      nursery_blocks += stepBlocks(&nurseries[i]);
+      ASSERT(countBlocks(nurseries[i].blocks) == nurseries[i].n_blocks);
+      nursery_blocks += nurseries[i].n_blocks;
   }
 
   retainer_blocks = 0;