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     /* Note: no *external* stacks in parallel world */
 103     DEBUG_STRING("Marking A Stack:");
 104     if (SUBTRACT_A_STK(MAIN_SpA, stackInfo.botA) >= 0) {
 105         MRoot = (P_) MAIN_SpA;
 106         Mark = (P_) *MRoot;
 107         MStack = (P_) _PRMarking_MarkNextAStack_closure;
 108
 109         miniInterpret((StgFunPtr)_startMarkWorld);
 110     }
 111
 112     DEBUG_STRING("Marking B Stack:");
 113     if (SUBTRACT_B_STK(MAIN_SuB, stackInfo.botB) > 0) {
 114         MRoot = MAIN_SuB;
 115         Mark = GRAB_UPDATEE(MRoot);
 116         MStack = (P_) _PRMarking_MarkNextBStack_closure;
 117         miniInterpret((StgFunPtr)_startMarkWorld);
 118     }
 119 #endif /* PAR */
 120
 121     DEBUG_STRING("Marking & Updating CAFs:");
 122     if (cafs1) {
 123         MRoot  = cafs1;
 124         Mark   = (P_) IND_CLOSURE_PTR(MRoot);
 125         MStack = (P_) _PRMarking_MarkNextCAF_closure;
 126
 127         miniInterpret((StgFunPtr)_startMarkWorld);
 128     }
 129
 130     if (cafs2) {
 131         MRoot  = cafs2;
 132         Mark   = (P_) IND_CLOSURE_PTR(MRoot);
 133         MStack = (P_) _PRMarking_MarkNextCAF_closure;
 134
 135         miniInterpret((StgFunPtr)_startMarkWorld);
 136     }
 137
 138     return 0;
 139 }
 140
 141 #endif /* _INFO_MARKING */
 142 \end{code}
 143
 144
 145 CODE REQUIRED (expressed as a loop):
 146
 147 MARK ROOTS
 148
 149     MStack = _PRMarking_MarkNextRoot_closure;
 150     for (MRoot = (P_) sm->roots;
 151          MRoot < (P_) &sm->roots[sm->rootno];
 152          MRoot++) {
 153         Mark = (P_) *MRoot;
 154         (PRMARK_CODE(INFO_PTR(Mark)))();
 155 _PRMarking_MarkNextRoot:
 156         *MRoot = (W_) Mark;
 157     }
 158
 159
 160 MARK AStack
 161
 162     MStack = _PRMarking_MarkNextAStack_closure;
 163     for (MRoot = MAIN_SpA;
 164          SUBTRACT_A_STK(MRoot, stackInfo.botA) >= 0;
 165          MRoot = MRoot + AREL(1)) {
 166         Mark = (P_) *MRoot;
 167         (PRMARK_CODE(INFO_PTR(Mark)))();
 168 _PRMarking_MarkNextAStack:
 169         *MRoot = (W_) Mark;
 170     }
 171
 172
 173 MARK BStack
 174
 175     MStack = _PRMarking_MarkNextBStack_closure;
 176     for (MRoot = MAIN_SuB;  --- Topmost Update Frame
 177          SUBTRACT_B_STK(MRoot, stackInfo.botB) > 0;
 178          MRoot = GRAB_SuB(MRoot)) {
 179
 180         Mark = GRAB_UPDATEE(MRoot);
 181         (PRMARK_CODE(INFO_PTR(Mark)))();
 182 _PRMarking_MarkNextBStack:
 183         PUSH_UPDATEE(MRoot, Mark);
 184     }
 185
 186
 187 MARK CAFs
 188
 189     MStack = _PRMarking_MarkNextCAF_closure;
 190     for (MRoot = sm->CAFlist;
 191          MRoot;
 192          MRoot = (P_) IND_CLOSURE_LINK(MRoot))
 193
 194         Mark = IND_CLOSURE_PTR(MRoot);
 195         (PRMARK_CODE(INFO_PTR(Mark)))();
 196 _PRMarking_MarkNextCAF:
 197         IND_CLOSURE_PTR(MRoot) = (W_) Mark;
 198     }