[project @ 2005-03-10 14:03:28 by simonmar]

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

diff --git a/ghc/rts/GCCompact.c b/ghc/rts/GCCompact.c
index 0e2129f..30836e3 100644 (file)
--- a/ghc/rts/GCCompact.c
+++ b/ghc/rts/GCCompact.c
@@ -113,19 +113,19 @@ obj_sizeW( StgClosure *p, StgInfoTable *info )
     case CONSTR_0_1:
     case FUN_1_0:
     case CONSTR_1_0:
-       return sizeofW(StgHeader) + 1;
     case THUNK_0_1:
+    case THUNK_1_0:
+       return sizeofW(StgHeader) + 1;
     case THUNK_0_2:
     case FUN_0_2:
     case CONSTR_0_2:
-    case THUNK_1_0:
     case THUNK_1_1:
     case FUN_1_1:
     case CONSTR_1_1:
     case THUNK_2_0:
     case FUN_2_0:
     case CONSTR_2_0:
-       return sizeofW(StgHeader) + 2; // MIN_UPD_SIZE
+       return sizeofW(StgHeader) + 2;
     case THUNK_SELECTOR:
        return THUNK_SELECTOR_sizeW();
     case AP_STACK:
@@ -137,11 +137,20 @@ obj_sizeW( StgClosure *p, StgInfoTable *info )
        return arr_words_sizeW((StgArrWords *)p);
     case MUT_ARR_PTRS:
     case MUT_ARR_PTRS_FROZEN:
+    case MUT_ARR_PTRS_FROZEN0:
        return mut_arr_ptrs_sizeW((StgMutArrPtrs*)p);
     case TSO:
        return tso_sizeW((StgTSO *)p);
     case BCO:
        return bco_sizeW((StgBCO *)p);
+    case TVAR_WAIT_QUEUE:
+        return sizeofW(StgTVarWaitQueue);
+    case TVAR:
+        return sizeofW(StgTVar);
+    case TREC_CHUNK:
+        return sizeofW(StgTRecChunk);
+    case TREC_HEADER:
+        return sizeofW(StgTRecHeader);
     default:
        return sizeW_fromITBL(info);
     }
@@ -218,8 +227,8 @@ thread_arg_block (StgFunInfoTable *fun_info, StgClosure **args)
        size = BITMAP_SIZE(fun_info->f.bitmap);
        goto small_bitmap;
     case ARG_GEN_BIG:
-       size = ((StgLargeBitmap *)fun_info->f.bitmap)->size;
-       thread_large_bitmap(p, (StgLargeBitmap *)fun_info->f.bitmap, size);
+       size = GET_FUN_LARGE_BITMAP(fun_info)->size;
+       thread_large_bitmap(p, GET_FUN_LARGE_BITMAP(fun_info), size);
        p += size;
        break;
     default:
@@ -289,6 +298,9 @@ thread_stack(StgPtr p, StgPtr stack_end)
        }
            
            // small bitmap (<= 32 entries, or 64 on a 64-bit machine) 
+        case CATCH_RETRY_FRAME:
+        case CATCH_STM_FRAME:
+        case ATOMICALLY_FRAME:
        case UPDATE_FRAME:
        case STOP_FRAME:
        case CATCH_FRAME:
@@ -327,8 +339,8 @@ thread_stack(StgPtr p, StgPtr stack_end)
        case RET_BIG:
        case RET_VEC_BIG:
            p++;
-           size = info->i.layout.large_bitmap->size;
-           thread_large_bitmap(p, info->i.layout.large_bitmap, size);
+           size = GET_LARGE_BITMAP(&info->i)->size;
+           thread_large_bitmap(p, GET_LARGE_BITMAP(&info->i), size);
            p += size;
            continue;
 
@@ -370,7 +382,7 @@ thread_PAP (StgPAP *pap)
        bitmap = BITMAP_BITS(fun_info->f.bitmap);
        goto small_bitmap;
     case ARG_GEN_BIG:
-       thread_large_bitmap(p, (StgLargeBitmap *)fun_info->f.bitmap, size);
+       thread_large_bitmap(p, GET_FUN_LARGE_BITMAP(fun_info), size);
        p += size;
        break;
     case ARG_BCO:
@@ -424,6 +436,8 @@ thread_TSO (StgTSO *tso)
        thread((StgPtr)&tso->blocked_exceptions);
     }
     
+    thread((StgPtr)&tso->trec);
+
     thread_stack(tso->sp, &(tso->stack[tso->stack_size]));
     return (StgPtr)tso + tso_sizeW(tso);
 }
@@ -448,6 +462,7 @@ update_fwd_large( bdescr *bd )
 
     case MUT_ARR_PTRS:
     case MUT_ARR_PTRS_FROZEN:
+    case MUT_ARR_PTRS_FROZEN0:
       // follow everything 
       {
        StgPtr next;
@@ -483,6 +498,7 @@ thread_obj (StgInfoTable *info, StgPtr p)
     switch (info->type) {
     case FUN_0_1:
     case CONSTR_0_1:
+    case THUNK_0_1:
        return p + sizeofW(StgHeader) + 1;
        
     case FUN_1_0:
@@ -492,9 +508,8 @@ thread_obj (StgInfoTable *info, StgPtr p)
        
     case THUNK_1_0:
        thread((StgPtr)&((StgClosure *)p)->payload[0]);
-       return p + sizeofW(StgHeader) + 2; // MIN_UPD_SIZE
+       return p + sizeofW(StgHeader) + 1;
        
-    case THUNK_0_1: // MIN_UPD_SIZE
     case THUNK_0_2:
     case FUN_0_2:
     case CONSTR_0_2:
@@ -529,7 +544,6 @@ thread_obj (StgInfoTable *info, StgPtr p)
     case STABLE_NAME:
     case IND_PERM:
     case MUT_VAR:
-    case MUT_CONS:
     case CAF_BLACKHOLE:
     case SE_CAF_BLACKHOLE:
     case SE_BLACKHOLE:
@@ -569,8 +583,8 @@ thread_obj (StgInfoTable *info, StgPtr p)
     
     case IND_OLDGEN:
     case IND_OLDGEN_PERM:
-       thread((StgPtr)&((StgIndOldGen *)p)->indirectee);
-       return p + sizeofW(StgIndOldGen);
+       thread((StgPtr)&((StgInd *)p)->indirectee);
+       return p + sizeofW(StgInd);
 
     case THUNK_SELECTOR:
     { 
@@ -591,6 +605,7 @@ thread_obj (StgInfoTable *info, StgPtr p)
        
     case MUT_ARR_PTRS:
     case MUT_ARR_PTRS_FROZEN:
+    case MUT_ARR_PTRS_FROZEN0:
        // follow everything 
     {
        StgPtr next;
@@ -605,6 +620,45 @@ thread_obj (StgInfoTable *info, StgPtr p)
     case TSO:
        return thread_TSO((StgTSO *)p);
     
+    case TVAR_WAIT_QUEUE:
+    {
+        StgTVarWaitQueue *wq = (StgTVarWaitQueue *)p;
+       thread((StgPtr)&wq->waiting_tso);
+       thread((StgPtr)&wq->next_queue_entry);
+       thread((StgPtr)&wq->prev_queue_entry);
+       return p + sizeofW(StgTVarWaitQueue);
+    }
+    
+    case TVAR:
+    {
+        StgTVar *tvar = (StgTVar *)p;
+       thread((StgPtr)&tvar->current_value);
+       thread((StgPtr)&tvar->first_wait_queue_entry);
+       return p + sizeofW(StgTVar);
+    }
+    
+    case TREC_HEADER:
+    {
+        StgTRecHeader *trec = (StgTRecHeader *)p;
+       thread((StgPtr)&trec->enclosing_trec);
+       thread((StgPtr)&trec->current_chunk);
+       return p + sizeofW(StgTRecHeader);
+    }
+
+    case TREC_CHUNK:
+    {
+        StgWord i;
+        StgTRecChunk *tc = (StgTRecChunk *)p;
+       TRecEntry *e = &(tc -> entries[0]);
+       thread((StgPtr)&tc->prev_chunk);
+       for (i = 0; i < tc -> next_entry_idx; i ++, e++ ) {
+         thread((StgPtr)&e->tvar);
+         thread((StgPtr)&e->expected_value);
+         thread((StgPtr)&e->new_value);
+       }
+       return p + sizeofW(StgTRecChunk);
+    }
+
     default:
        barf("update_fwd: unknown/strange object  %d", (int)(info->type));
        return NULL;
@@ -789,7 +843,7 @@ update_bkwd_compact( step *stp )
 
            // Rebuild the mutable list for the old generation.
            if (ip_MUTABLE(info)) {
-               recordMutable((StgMutClosure *)free);
+               recordMutable((StgClosure *)free);
            }
 
            // relocate TSOs
@@ -816,19 +870,6 @@ update_bkwd_compact( step *stp )
     return free_blocks;
 }
 
-static void
-thread_mut_once_list( generation *g )
-{
-    StgMutClosure *p, *next;
-
-    for (p = g->mut_once_list; p != END_MUT_LIST; p = next) {
-       next = p->mut_link;
-       thread((StgPtr)&p->mut_link);
-    }
-    
-    thread((StgPtr)&g->mut_once_list);
-}
-
 void
 compact( void (*get_roots)(evac_fn) )
 {
@@ -848,8 +889,13 @@ compact( void (*get_roots)(evac_fn) )
 
     // mutable lists
     for (g = 1; g < RtsFlags.GcFlags.generations; g++) {
-       thread((StgPtr)&generations[g].mut_list);
-       thread_mut_once_list(&generations[g]);
+       bdescr *bd;
+       StgPtr p;
+       for (bd = generations[g].mut_list; bd != NULL; bd = bd->link) {
+           for (p = bd->start; p < bd->free; p++) {
+               thread(p);
+           }
+       }
     }
 
     // the global thread list