projects / ghc-hetmet.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
[project @ 2006-01-17 16:13:18 by simonmar]
[ghc-hetmet.git] / ghc / rts / RetainerProfile.c
diff --git a/ghc/rts/RetainerProfile.c b/ghc/rts/RetainerProfile.c
index 927a734..2f93cbf 100644 (file)
--- a/ghc/rts/RetainerProfile.c
+++ b/ghc/rts/RetainerProfile.c
@@ -463,14 +463,10 @@ push( StgClosure *c, retainer c_child_r, StgClosure **first_child )
        return;
 
        // one child (fixed), no SRT
-    case MUT_VAR:
+    case MUT_VAR_CLEAN:
+    case MUT_VAR_DIRTY:
        *first_child = ((StgMutVar *)c)->var;
        return;
-    case BLACKHOLE_BQ:
-       // blocking_queue must be TSO and the head of a linked list of TSOs.
-       // Shoule it be a child? Seems to be yes.
-       *first_child = (StgClosure *)((StgBlockingQueue *)c)->blocking_queue;
-       return;
     case THUNK_SELECTOR:
        *first_child = ((StgSelector *)c)->selectee;
        return;
@@ -515,7 +511,6 @@ push( StgClosure *c, retainer c_child_r, StgClosure **first_child )
 
        // layout.payload.ptrs, no SRT
     case CONSTR:
-    case FOREIGN:
     case STABLE_NAME:
     case BCO:
     case CONSTR_STATIC:
@@ -527,8 +522,10 @@ push( StgClosure *c, retainer c_child_r, StgClosure **first_child )
        break;
 
        // StgMutArrPtr.ptrs, no SRT
-    case MUT_ARR_PTRS:
+    case MUT_ARR_PTRS_CLEAN:
+    case MUT_ARR_PTRS_DIRTY:
     case MUT_ARR_PTRS_FROZEN:
+    case MUT_ARR_PTRS_FROZEN0:
        init_ptrs(&se.info, ((StgMutArrPtrs *)c)->ptrs,
                  (StgPtr)(((StgMutArrPtrs *)c)->payload));
        *first_child = find_ptrs(&se.info);
@@ -548,7 +545,8 @@ push( StgClosure *c, retainer c_child_r, StgClosure **first_child )
 
     case THUNK:
     case THUNK_2_0:
-       init_ptrs(&se.info, get_itbl(c)->layout.payload.ptrs, (StgPtr)c->payload);
+       init_ptrs(&se.info, get_itbl(c)->layout.payload.ptrs, 
+                 (StgPtr)((StgThunk *)c)->payload);
        *first_child = find_ptrs(&se.info);
        if (*first_child == NULL)
            // no child from ptrs, so check SRT
@@ -565,7 +563,7 @@ push( StgClosure *c, retainer c_child_r, StgClosure **first_child )
 
     case THUNK_1_0:
     case THUNK_1_1:
-       *first_child = c->payload[0];
+       *first_child = ((StgThunk *)c)->payload[0];
        ASSERT(*first_child != NULL);
        init_srt_thunk(&se.info, get_thunk_itbl(c));
        break;
@@ -820,13 +818,14 @@ pop( StgClosure **c, StgClosure **cp, retainer *r )
            return;
 
        case CONSTR:
-       case FOREIGN:
        case STABLE_NAME:
        case BCO:
        case CONSTR_STATIC:
            // StgMutArrPtr.ptrs, no SRT
-       case MUT_ARR_PTRS:
+       case MUT_ARR_PTRS_CLEAN:
+       case MUT_ARR_PTRS_DIRTY:
        case MUT_ARR_PTRS_FROZEN:
+       case MUT_ARR_PTRS_FROZEN0:
            *c = find_ptrs(&se->info);
            if (*c == NULL) {
                popOff();
@@ -893,8 +892,8 @@ pop( StgClosure **c, StgClosure **cp, retainer *r )
        case SE_CAF_BLACKHOLE:
        case ARR_WORDS:
            // one child (fixed), no SRT
-       case MUT_VAR:
-       case BLACKHOLE_BQ:
+       case MUT_VAR_CLEAN:
+       case MUT_VAR_DIRTY:
        case THUNK_SELECTOR:
        case IND_PERM:
        case IND_OLDGEN_PERM:
@@ -994,9 +993,12 @@ isRetainer( StgClosure *c )
 
        // mutable objects
     case MVAR:
-    case MUT_VAR:
-    case MUT_ARR_PTRS:
+    case MUT_VAR_CLEAN:
+    case MUT_VAR_DIRTY:
+    case MUT_ARR_PTRS_CLEAN:
+    case MUT_ARR_PTRS_DIRTY:
     case MUT_ARR_PTRS_FROZEN:
+    case MUT_ARR_PTRS_FROZEN0:
 
        // thunks are retainers.
     case THUNK:
@@ -1042,7 +1044,6 @@ isRetainer( StgClosure *c )
     case BLACKHOLE:
     case SE_BLACKHOLE:
     case SE_CAF_BLACKHOLE:
-    case BLACKHOLE_BQ:
        // indirection
     case IND_PERM:
     case IND_OLDGEN_PERM:
@@ -1051,7 +1052,6 @@ isRetainer( StgClosure *c )
     case CONSTR_STATIC:
     case FUN_STATIC:
        // misc
-    case FOREIGN:
     case STABLE_NAME:
     case BCO:
     case ARR_WORDS:
@@ -1375,8 +1375,8 @@ retainStack( StgClosure *c, retainer c_child_r,
            p = (P_)&ret_fun->payload;
            switch (fun_info->f.fun_type) {
            case ARG_GEN:
-               bitmap = BITMAP_BITS(fun_info->f.bitmap);
-               size = BITMAP_SIZE(fun_info->f.bitmap);
+               bitmap = BITMAP_BITS(fun_info->f.b.bitmap);
+               size = BITMAP_SIZE(fun_info->f.b.bitmap);
                p = retain_small_bitmap(p, size, bitmap, c, c_child_r);
                break;
            case ARG_GEN_BIG:
@@ -1416,39 +1416,38 @@ retainStack( StgClosure *c, retainer c_child_r,
  * ------------------------------------------------------------------------- */
 
 static INLINE StgPtr
-retain_PAP (StgPAP *pap, retainer c_child_r)
+retain_PAP_payload (StgClosure *pap,  retainer c_child_r, StgClosure *fun, 
+                   StgClosure** payload, StgWord n_args)
 {
     StgPtr p;
-    StgWord bitmap, size;
+    StgWord bitmap;
     StgFunInfoTable *fun_info;
 
-    retainClosure(pap->fun, (StgClosure *)pap, c_child_r);
-    fun_info = get_fun_itbl(pap->fun);
+    retainClosure(fun, pap, c_child_r);
+    fun_info = get_fun_itbl(fun);
     ASSERT(fun_info->i.type != PAP);
 
-    p = (StgPtr)pap->payload;
-    size = pap->n_args;
+    p = (StgPtr)payload;
 
     switch (fun_info->f.fun_type) {
     case ARG_GEN:
-       bitmap = BITMAP_BITS(fun_info->f.bitmap);
-       p = retain_small_bitmap(p, pap->n_args, bitmap, 
-                               (StgClosure *)pap, c_child_r);
+       bitmap = BITMAP_BITS(fun_info->f.b.bitmap);
+       p = retain_small_bitmap(p, n_args, bitmap, 
+                               pap, c_child_r);
        break;
     case ARG_GEN_BIG:
        retain_large_bitmap(p, GET_FUN_LARGE_BITMAP(fun_info),
-                           size, (StgClosure *)pap, c_child_r);
-       p += size;
+                           n_args, pap, c_child_r);
+       p += n_args;
        break;
     case ARG_BCO:
-       retain_large_bitmap((StgPtr)pap->payload, BCO_BITMAP(pap->fun),
-                           size, (StgClosure *)pap, c_child_r);
-       p += size;
+       retain_large_bitmap((StgPtr)payload, BCO_BITMAP(fun),
+                           n_args, pap, c_child_r);
+       p += n_args;
        break;
     default:
        bitmap = BITMAP_BITS(stg_arg_bitmaps[fun_info->f.fun_type]);
-       p = retain_small_bitmap(p, pap->n_args, bitmap, 
-                               (StgClosure *)pap, c_child_r);
+       p = retain_small_bitmap(p, n_args, bitmap, pap, c_child_r);
        break;
     }
     return p;
@@ -1686,9 +1685,18 @@ inner_loop:
        goto loop;
 
     case PAP:
+    {
+       StgPAP *pap = (StgPAP *)c;
+       retain_PAP_payload(c, c_child_r, pap->fun, pap->payload, pap->n_args);
+       goto loop;
+    }
+
     case AP:
-       retain_PAP((StgPAP *)c, c_child_r);
+    {
+       StgAP *ap = (StgAP *)c;
+       retain_PAP_payload(c, c_child_r, ap->fun, ap->payload, ap->n_args);
        goto loop;
+    }
 
     case AP_STACK:
        retainClosure(((StgAP_STACK *)c)->fun, c, c_child_r);
@@ -1778,8 +1786,8 @@ computeRetainerSet( void )
        for (bd = generations[g].mut_list; bd != NULL; bd = bd->link) {
            for (ml = bd->start; ml < bd->free; ml++) {
 
-               maybeInitRetainerSet((StgClosure *)ml);
-               rtl = retainerSetOf((StgClosure *)ml);
+               maybeInitRetainerSet((StgClosure *)*ml);
+               rtl = retainerSetOf((StgClosure *)*ml);
 
 #ifdef DEBUG_RETAINER
                if (rtl == NULL) {
@@ -1849,19 +1857,19 @@ resetStaticObjectForRetainerProfiling( void )
            // Since we do not compute the retainer set of any
            // IND_STATIC object, we don't have to reset its retainer
            // field.
-           p = IND_STATIC_LINK(p);
+           p = (StgClosure*)*IND_STATIC_LINK(p);
            break;
        case THUNK_STATIC:
            maybeInitRetainerSet(p);
-           p = THUNK_STATIC_LINK(p);
+           p = (StgClosure*)*THUNK_STATIC_LINK(p);
            break;
        case FUN_STATIC:
            maybeInitRetainerSet(p);
-           p = FUN_STATIC_LINK(p);
+           p = (StgClosure*)*FUN_STATIC_LINK(p);
            break;
        case CONSTR_STATIC:
            maybeInitRetainerSet(p);
-           p = STATIC_LINK(get_itbl(p), p);
+           p = (StgClosure*)*STATIC_LINK(get_itbl(p), p);
            break;
        default:
            barf("resetStaticObjectForRetainerProfiling: %p (%s)",
@@ -2025,7 +2033,7 @@ retainerProfile(void)
 #ifdef DEBUG_RETAINER
 
 #define LOOKS_LIKE_PTR(r) ((LOOKS_LIKE_STATIC_CLOSURE(r) || \
-        ((HEAP_ALLOCED(r) && Bdescr((P_)r)->free != (void *)-1))) && \
+        ((HEAP_ALLOCED(r) && ((Bdescr((P_)r)->flags & BF_FREE) == 0)))) && \
         ((StgWord)(*(StgPtr)r)!=0xaaaaaaaa))
 
 static nat
@@ -2070,8 +2078,10 @@ sanityCheckHeapClosure( StgClosure *c )
     case MVAR:
        return sizeofW(StgMVar);
 
-    case MUT_ARR_PTRS:
+    case MUT_ARR_PTRS_CLEAN:
+    case MUT_ARR_PTRS_DIRTY:
     case MUT_ARR_PTRS_FROZEN:
+    case MUT_ARR_PTRS_FROZEN0:
        return mut_arr_ptrs_sizeW((StgMutArrPtrs *)c);
 
     case AP:
@@ -2097,16 +2107,15 @@ sanityCheckHeapClosure( StgClosure *c )
     case FUN_1_1:
     case FUN_0_2:
     case WEAK:
-    case MUT_VAR:
+    case MUT_VAR_CLEAN:
+    case MUT_VAR_DIRTY:
     case CAF_BLACKHOLE:
     case BLACKHOLE:
     case SE_BLACKHOLE:
     case SE_CAF_BLACKHOLE:
-    case BLACKHOLE_BQ:
     case IND_PERM:
     case IND_OLDGEN:
     case IND_OLDGEN_PERM:
-    case FOREIGN:
     case BCO:
     case STABLE_NAME:
        return sizeW_fromITBL(info);
@@ -2335,6 +2344,6 @@ belongToHeap(StgPtr p)
        }
     }
 }
-#endif // DEBUG_RETAINER
+#endif /* DEBUG_RETAINER */
 
 #endif /* PROFILING */
Glasgow Haskell Compiler with heterogeneous metaprogramming (generalized arrows and modal types)