rts/Updates.h

   1 /* -----------------------------------------------------------------------------
   2  *
   3  * (c) The GHC Team, 1998-2004
   4  *
   5  * Performing updates.
   6  *
   7  * ---------------------------------------------------------------------------*/
   8
   9 #ifndef UPDATES_H
  10 #define UPDATES_H
  11
  12 /* -----------------------------------------------------------------------------
  13    Updates
  14
  15    We have two layers of update macros.  The top layer, UPD_IND() and
  16    friends perform all the work of an update.  In detail:
  17
  18       - if the closure being updated is a blocking queue, then all the
  19         threads waiting on the blocking queue are updated.
  20
  21       - then the lower level updateWithIndirection() macro is invoked
  22         to actually replace the closure with an indirection (see below).
  23
  24    -------------------------------------------------------------------------- */
  25
  26 #  define SEMI ;
  27 # define UPD_IND(updclosure, heapptr) \
  28    UPD_REAL_IND(updclosure,INFO_PTR(stg_IND_info),heapptr,SEMI)
  29 # define UPD_SPEC_IND(updclosure, ind_info, heapptr, and_then) \
  30    UPD_REAL_IND(updclosure,ind_info,heapptr,and_then)
  31
  32 /* These macros have to work in both C and C--, so here's the
  33  * impedance matching:
  34  */
  35 #ifdef CMINUSMINUS
  36 #define BLOCK_BEGIN
  37 #define BLOCK_END
  38 #define INFO_PTR(info)      info
  39 #else
  40 #define BLOCK_BEGIN         {
  41 #define BLOCK_END           }
  42 #define INFO_PTR(info)      &info
  43 #define StgBlockingQueue_blocking_queue(closure) \
  44     (((StgBlockingQueue *)closure)->blocking_queue)
  45 #endif
  46
  47 /* krc: there used to be an UPD_REAL_IND and an
  48    UPD_PERM_IND, the latter of which was used for
  49    ticky and cost-centre profiling.
  50    for now, we just have UPD_REAL_IND. */
  51 #define UPD_REAL_IND(updclosure, ind_info, heapptr, and_then)   \
  52         BLOCK_BEGIN                                             \
  53         updateWithIndirection(ind_info,                         \
  54                               updclosure,                       \
  55                               heapptr,                          \
  56                               and_then);                        \
  57         BLOCK_END
  58
  59 /* -----------------------------------------------------------------------------
  60    Awaken any threads waiting on a blocking queue (BLACKHOLE_BQ).
  61    -------------------------------------------------------------------------- */
  62
  63 #if defined(PAR)
  64
  65 /*
  66    In a parallel setup several types of closures might have a blocking queue:
  67      BLACKHOLE_BQ ... same as in the default concurrent setup; it will be
  68                       reawakened via calling UPD_IND on that closure after
  69                       having finished the computation of the graph
  70      FETCH_ME_BQ  ... a global indirection (FETCH_ME) may be entered by a
  71                       local TSO, turning it into a FETCH_ME_BQ; it will be
  72                       reawakened via calling processResume
  73      RBH          ... a revertible black hole may be entered by another
  74                       local TSO, putting it onto its blocking queue; since
  75                       RBHs only exist while the corresponding closure is in
  76                       transit, they will be reawakened via calling
  77                       convertToFetchMe (upon processing an ACK message)
  78
  79    In a parallel setup a blocking queue may contain 3 types of closures:
  80      TSO           ... as in the default concurrent setup
  81      BLOCKED_FETCH ... indicating that a TSO on another PE is waiting for
  82                        the result of the current computation
  83      CONSTR        ... an RBHSave closure (which contains data ripped out of
  84                        the closure to make room for a blocking queue; since
  85                        it only contains data we use the exisiting type of
  86                        a CONSTR closure); this closure is the end of a
  87                        blocking queue for an RBH closure; it only exists in
  88                        this kind of blocking queue and must be at the end
  89                        of the queue
  90 */
  91 extern void awakenBlockedQueue(StgBlockingQueueElement *q, StgClosure *node);
  92 #define DO_AWAKEN_BQ(bqe, node)  STGCALL2(awakenBlockedQueue, bqe, node);
  93
  94 #define AWAKEN_BQ(info,closure)                                         \
  95         if (info == &stg_BLACKHOLE_BQ_info ||               \
  96             info == &stg_FETCH_ME_BQ_info ||                \
  97             get_itbl(closure)->type == RBH) {                           \
  98                 DO_AWAKEN_BQ(((StgBlockingQueue *)closure)->blocking_queue, closure);                           \
  99         }
 100
 101 #elif defined(GRAN)
 102
 103 extern void awakenBlockedQueue(StgBlockingQueueElement *q, StgClosure *node);
 104 #define DO_AWAKEN_BQ(bq, node)  STGCALL2(awakenBlockedQueue, bq, node);
 105
 106 /* In GranSim we don't have FETCH_ME or FETCH_ME_BQ closures, so they are
 107    not checked. The rest of the code is the same as for GUM.
 108 */
 109 #define AWAKEN_BQ(info,closure)                                         \
 110         if (info == &stg_BLACKHOLE_BQ_info ||               \
 111             get_itbl(closure)->type == RBH) {                           \
 112                 DO_AWAKEN_BQ(((StgBlockingQueue *)closure)->blocking_queue, closure);                           \
 113         }
 114
 115 #endif /* GRAN || PAR */
 116
 117
 118 /* -----------------------------------------------------------------------------
 119    Updates: lower-level macros which update a closure with an
 120    indirection to another closure.
 121
 122    There are several variants of this code.
 123
 124        PROFILING:
 125    -------------------------------------------------------------------------- */
 126
 127 /* LDV profiling:
 128  * We call LDV_recordDead_FILL_SLOP_DYNAMIC(p1) regardless of the generation in
 129  * which p1 resides.
 130  *
 131  * Note:
 132  *   After all, we do *NOT* need to call LDV_RECORD_CREATE() for both IND and
 133  *   IND_OLDGEN closures because they are inherently used. But, it corrupts
 134  *   the invariants that every closure keeps its creation time in the profiling
 135  *  field. So, we call LDV_RECORD_CREATE().
 136  */
 137
 138 /* In the DEBUG case, we also zero out the slop of the old closure,
 139  * so that the sanity checker can tell where the next closure is.
 140  *
 141  * Two important invariants: we should never try to update a closure
 142  * to point to itself, and the closure being updated should not
 143  * already have been updated (the mutable list will get messed up
 144  * otherwise).
 145  *
 146  * NB. We do *not* do this in THREADED_RTS mode, because when we have the
 147  * possibility of multiple threads entering the same closure, zeroing
 148  * the slop in one of the threads would have a disastrous effect on
 149  * the other (seen in the wild!).
 150  */
 151 #ifdef CMINUSMINUS
 152
 153 #define FILL_SLOP(p)                                                    \
 154   W_ inf;                                                               \
 155   W_ sz;                                                                \
 156   W_ i;                                                                 \
 157   inf = %GET_STD_INFO(p);                                               \
 158   if (%INFO_TYPE(inf) != HALF_W_(BLACKHOLE)                             \
 159         && %INFO_TYPE(inf) != HALF_W_(CAF_BLACKHOLE)) {                 \
 160       if (%INFO_TYPE(inf) == HALF_W_(THUNK_SELECTOR)) {                 \
 161           sz = BYTES_TO_WDS(SIZEOF_StgSelector_NoThunkHdr);             \
 162      } else {                                                           \
 163           if (%INFO_TYPE(inf) == HALF_W_(AP_STACK)) {                   \
 164               sz = StgAP_STACK_size(p) + BYTES_TO_WDS(SIZEOF_StgAP_STACK_NoThunkHdr); \
 165           } else {                                                      \
 166               if (%INFO_TYPE(inf) == HALF_W_(AP)) {                     \
 167                   sz = TO_W_(StgAP_n_args(p)) +  BYTES_TO_WDS(SIZEOF_StgAP_NoThunkHdr); \
 168               } else {                                                  \
 169                   sz = TO_W_(%INFO_PTRS(inf)) + TO_W_(%INFO_NPTRS(inf)); \
 170               }                                                         \
 171           }                                                             \
 172       }                                                                 \
 173       i = 0;                                                            \
 174       for:                                                              \
 175         if (i < sz) {                                                   \
 176           StgThunk_payload(p,i) = 0;                                    \
 177           i = i + 1;                                                    \
 178           goto for;                                                     \
 179         }                                                               \
 180   }
 181
 182 #else /* !CMINUSMINUS */
 183
 184 INLINE_HEADER void
 185 FILL_SLOP(StgClosure *p)
 186 {
 187     StgInfoTable *inf = get_itbl(p);
 188     nat i, sz;
 189
 190     switch (inf->type) {
 191     case BLACKHOLE:
 192     case CAF_BLACKHOLE:
 193         goto no_slop;
 194         // we already filled in the slop when we overwrote the thunk
 195         // with BLACKHOLE, and also an evacuated BLACKHOLE is only the
 196         // size of an IND.
 197     case THUNK_SELECTOR:
 198         sz = sizeofW(StgSelector) - sizeofW(StgThunkHeader);
 199         break;
 200     case AP:
 201         sz = ((StgAP *)p)->n_args + sizeofW(StgAP) - sizeofW(StgThunkHeader);
 202         break;
 203     case AP_STACK:
 204         sz = ((StgAP_STACK *)p)->size + sizeofW(StgAP_STACK) - sizeofW(StgThunkHeader);
 205         break;
 206     default:
 207         sz = inf->layout.payload.ptrs + inf->layout.payload.nptrs;
 208         break;
 209     }
 210     for (i = 0; i < sz; i++) {
 211         ((StgThunk *)p)->payload[i] = 0;
 212     }
 213 no_slop:
 214     ;
 215 }
 216
 217 #endif /* CMINUSMINUS */
 218
 219 #if !defined(DEBUG) || defined(THREADED_RTS)
 220 #define DEBUG_FILL_SLOP(p) /* do nothing */
 221 #else
 222 #define DEBUG_FILL_SLOP(p) FILL_SLOP(p)
 223 #endif
 224
 225 /* We have two versions of this macro (sadly), one for use in C-- code,
 226  * and the other for C.
 227  *
 228  * The and_then argument is a performance hack so that we can paste in
 229  * the continuation code directly.  It helps shave a couple of
 230  * instructions off the common case in the update code, which is
 231  * worthwhile (the update code is often part of the inner loop).
 232  * (except that gcc now appears to common up this code again and
 233  * invert the optimisation.  Grrrr --SDM).
 234  */
 235 #ifdef CMINUSMINUS
 236 #define generation(n) (W_[generations] + n*SIZEOF_generation)
 237 #define updateWithIndirection(ind_info, p1, p2, and_then)       \
 238     W_ bd;                                                      \
 239                                                                 \
 240     DEBUG_FILL_SLOP(p1);                                        \
 241     LDV_RECORD_DEAD_FILL_SLOP_DYNAMIC(p1);                      \
 242     StgInd_indirectee(p1) = p2;                                 \
 243     prim %write_barrier() [];                                   \
 244     bd = Bdescr(p1);                                            \
 245     if (bdescr_gen_no(bd) != 0 :: CInt) {                       \
 246       recordMutableCap(p1, TO_W_(bdescr_gen_no(bd)), R1);       \
 247       SET_INFO(p1, stg_IND_OLDGEN_info);                        \
 248       LDV_RECORD_CREATE(p1);                                    \
 249       TICK_UPD_OLD_IND();                                       \
 250       and_then;                                                 \
 251     } else {                                                    \
 252       SET_INFO(p1, ind_info);                                   \
 253       LDV_RECORD_CREATE(p1);                                    \
 254       TICK_UPD_NEW_IND();                                       \
 255       and_then;                                                 \
 256   }
 257 #else
 258 #define updateWithIndirection(ind_info, p1, p2, and_then)       \
 259   {                                                             \
 260     bdescr *bd;                                                 \
 261                                                                 \
 262     ASSERT( (P_)p1 != (P_)p2 );                                 \
 263     /* not necessarily true: ASSERT( !closure_IND(p1) ); */     \
 264     /* occurs in RaiseAsync.c:raiseAsync() */                   \
 265     DEBUG_FILL_SLOP(p1);                                        \
 266     LDV_RECORD_DEAD_FILL_SLOP_DYNAMIC(p1);                      \
 267     ((StgInd *)p1)->indirectee = p2;                            \
 268     write_barrier();                                            \
 269     bd = Bdescr((P_)p1);                                        \
 270     if (bd->gen_no != 0) {                                      \
 271       recordMutableGenLock(p1, bd->gen_no);                     \
 272       SET_INFO(p1, &stg_IND_OLDGEN_info);                       \
 273       TICK_UPD_OLD_IND();                                       \
 274       and_then;                                                 \
 275     } else {                                                    \
 276       SET_INFO(p1, ind_info);                                   \
 277       LDV_RECORD_CREATE(p1);                                    \
 278       TICK_UPD_NEW_IND();                                       \
 279       and_then;                                                 \
 280     }                                                           \
 281   }
 282 #endif /* CMINUSMINUS */
 283 #endif /* UPDATES_H */