ghc/runtime/storage/SMmarking.lc

   1 /*************************************************************************
   2                            MARKING OF ROOTS
   3 *************************************************************************/
   4
   5 [Something needed here to explain what this is doing.  KH]
   6
   7 \begin{code}
   8
   9 #define MARK_REG_MAP
  10 #include "SMinternal.h"
  11
  12 #if defined(_INFO_MARKING)
  13
  14 #if defined (__STG_GCC_REGS__) /* If we are using registers load _SAVE */
  15
  16 /* If we are using registers load _SAVE */
  17 #define Mark     SAVE_Mark
  18 #define MRoot    SAVE_MRoot
  19 #define MStack   SAVE_MStack
  20 #define BitArray SAVE_BitArray
  21 #define HeapBase SAVE_HeapBase
  22 #define HeapLim  SAVE_HeapLim
  23
  24 #endif /* registerized */
  25
  26 /* These in SMmark.lhc -- need to be in .hc file */
  27 EXTFUN(_startMarkWorld);
  28
  29 EXTFUN(_PRMarking_MarkNextRoot);
  30 EXTFUN(_PRMarking_MarkNextCAF);
  31 EXTDATA(_PRMarking_MarkNextRoot_closure);
  32 EXTDATA(_PRMarking_MarkNextCAF_closure);
  33
  34 #ifdef CONCURRENT
  35 EXTFUN(_PRMarking_MarkNextSpark);
  36 EXTDATA(_PRMarking_MarkNextSpark_closure);
  37 #endif
  38
  39 #ifdef PAR
  40 EXTFUN(_PRMarking_MarkNextGA);
  41 EXTDATA(_PRMarking_MarkNextGA_closure);
  42 #else
  43 EXTFUN(_PRMarking_MarkNextAStack);
  44 EXTFUN(_PRMarking_MarkNextBStack);
  45 EXTDATA(_PRMarking_MarkNextAStack_closure);
  46 EXTDATA(_PRMarking_MarkNextBStack_closure);
  47 #endif /* not parallel */
  48
  49 P_ sm_roots_end;
  50
  51 I_
  52 markHeapRoots(sm, cafs1, cafs2, base, lim, bit_array)
  53     smInfo *sm;
  54     P_ cafs1, cafs2;  /* Pointer to CAF lists */
  55     P_ base;          /* Heap closure in range only tested for by GCgn */
  56     P_ lim;
  57     BitWord *bit_array;
  58 {
  59 #ifdef CONCURRENT
  60     int pool;
  61 #endif
  62
  63     BitArray = bit_array;
  64     HeapBase = base;
  65     HeapLim = lim;
  66
  67     DEBUG_STRING("Marking Roots:");
  68     if (sm->rootno > 0) {
  69         sm_roots_end = (P_) &sm->roots[sm->rootno];
  70         MRoot = (P_) sm->roots;
  71         Mark = (P_) *MRoot;
  72         MStack = (P_) _PRMarking_MarkNextRoot_closure;
  73
  74         miniInterpret((StgFunPtr)_startMarkWorld);
  75     }
  76
  77 #ifdef CONCURRENT
  78     for(pool = 0; pool < SPARK_POOLS; pool++) {
  79         if (PendingSparksHd[pool] < PendingSparksTl[pool]) {
  80             sm_roots_end = (P_) PendingSparksTl[pool];
  81             MRoot = (P_) PendingSparksHd[pool];
  82             Mark = (P_) *MRoot;
  83             MStack = (P_) _PRMarking_MarkNextSpark_closure;
  84
  85             miniInterpret((StgFunPtr)_startMarkWorld);
  86         }
  87     }
  88 #endif
  89
  90 #ifdef PAR
  91     DEBUG_STRING("Marking GA Roots:");
  92     MRoot = (P_) liveIndirections;
  93     while(MRoot != NULL && ((GALA *)MRoot)->ga.weight == MAX_GA_WEIGHT)
  94         MRoot = (P_) ((GALA *)MRoot)->next;
  95     if (MRoot != NULL) {
  96         Mark = ((GALA *)MRoot)->la;
  97         MStack = (P_) _PRMarking_MarkNextGA_closure;
  98
  99         miniInterpret((StgFunPtr) _startMarkWorld);
 100     }
 101 #else
 102 # ifndef CONCURRENT
 103     /* Note: no *external* stacks in parallel/concurrent world */
 104
 105     DEBUG_STRING("Marking A Stack:");
 106     if (SUBTRACT_A_STK(MAIN_SpA, stackInfo.botA) >= 0) {
 107         MRoot = (P_) MAIN_SpA;
 108         Mark = (P_) *MRoot;
 109         MStack = (P_) _PRMarking_MarkNextAStack_closure;
 110
 111         miniInterpret((StgFunPtr)_startMarkWorld);
 112     }
 113
 114     DEBUG_STRING("Marking B Stack:");
 115     if (SUBTRACT_B_STK(MAIN_SuB, stackInfo.botB) > 0) {
 116         MRoot = MAIN_SuB;
 117         Mark = GRAB_UPDATEE(MRoot);
 118         MStack = (P_) _PRMarking_MarkNextBStack_closure;
 119         miniInterpret((StgFunPtr)_startMarkWorld);
 120     }
 121 # endif /* ! CONCURRENT */
 122 #endif /* PAR */
 123
 124     DEBUG_STRING("Marking & Updating CAFs:");
 125     if (cafs1) {
 126         MRoot  = cafs1;
 127         Mark   = (P_) IND_CLOSURE_PTR(MRoot);
 128         MStack = (P_) _PRMarking_MarkNextCAF_closure;
 129
 130         miniInterpret((StgFunPtr)_startMarkWorld);
 131     }
 132
 133     if (cafs2) {
 134         MRoot  = cafs2;
 135         Mark   = (P_) IND_CLOSURE_PTR(MRoot);
 136         MStack = (P_) _PRMarking_MarkNextCAF_closure;
 137
 138         miniInterpret((StgFunPtr)_startMarkWorld);
 139     }
 140
 141     return 0;
 142 }
 143
 144 #endif /* _INFO_MARKING */
 145 \end{code}
 146
 147
 148 CODE REQUIRED (expressed as a loop):
 149
 150 MARK ROOTS
 151
 152     MStack = _PRMarking_MarkNextRoot_closure;
 153     for (MRoot = (P_) sm->roots;
 154          MRoot < (P_) &sm->roots[sm->rootno];
 155          MRoot++) {
 156         Mark = (P_) *MRoot;
 157         (PRMARK_CODE(INFO_PTR(Mark)))();
 158 _PRMarking_MarkNextRoot:
 159         *MRoot = (W_) Mark;
 160     }
 161
 162
 163 MARK AStack
 164
 165     MStack = _PRMarking_MarkNextAStack_closure;
 166     for (MRoot = MAIN_SpA;
 167          SUBTRACT_A_STK(MRoot, stackInfo.botA) >= 0;
 168          MRoot = MRoot + AREL(1)) {
 169         Mark = (P_) *MRoot;
 170         (PRMARK_CODE(INFO_PTR(Mark)))();
 171 _PRMarking_MarkNextAStack:
 172         *MRoot = (W_) Mark;
 173     }
 174
 175
 176 MARK BStack
 177
 178     MStack = _PRMarking_MarkNextBStack_closure;
 179     for (MRoot = MAIN_SuB;  --- Topmost Update Frame
 180          SUBTRACT_B_STK(MRoot, stackInfo.botB) > 0;
 181          MRoot = GRAB_SuB(MRoot)) {
 182
 183         Mark = GRAB_UPDATEE(MRoot);
 184         (PRMARK_CODE(INFO_PTR(Mark)))();
 185 _PRMarking_MarkNextBStack:
 186         PUSH_UPDATEE(MRoot, Mark);
 187     }
 188
 189
 190 MARK CAFs
 191
 192     MStack = _PRMarking_MarkNextCAF_closure;
 193     for (MRoot = sm->CAFlist;
 194          MRoot;
 195          MRoot = (P_) IND_CLOSURE_LINK(MRoot))
 196
 197         Mark = IND_CLOSURE_PTR(MRoot);
 198         (PRMARK_CODE(INFO_PTR(Mark)))();
 199 _PRMarking_MarkNextCAF:
 200         IND_CLOSURE_PTR(MRoot) = (W_) Mark;
 201     }