/* -----------------------------------------------------------------------------
- * $Id: Updates.h,v 1.26 2001/11/22 14:25:12 simonmar Exp $
*
- * (c) The GHC Team, 1998-1999
+ * (c) The GHC Team, 1998-2004
*
- * Definitions related to updates.
+ * Performing updates.
*
* ---------------------------------------------------------------------------*/
#define UPDATES_H
/* -----------------------------------------------------------------------------
- Update a closure with an indirection. This may also involve waking
- up a queue of blocked threads waiting on the result of this
- computation.
- -------------------------------------------------------------------------- */
+ Updates
-/* ToDo: overwrite slop words with something safe in case sanity checking
- * is turned on.
- * (I think the fancy version of the GC is supposed to do this too.)
- */
+ We have two layers of update macros. The top layer, UPD_IND() and
+ friends perform all the work of an update. In detail:
-/* This expands to a fair chunk of code, what with waking up threads
- * and checking whether we're updating something in a old generation.
- * preferably don't use this macro inline in compiled code.
- */
+ - if the closure being updated is a blocking queue, then all the
+ threads waiting on the blocking queue are updated.
+
+ - then the lower level updateWithIndirection() macro is invoked
+ to actually replace the closure with an indirection (see below).
+
+ -------------------------------------------------------------------------- */
#ifdef TICKY_TICKY
-# define UPD_IND(updclosure, heapptr) UPD_PERM_IND(updclosure,heapptr)
+# define UPD_IND(updclosure, heapptr) \
+ UPD_PERM_IND(updclosure,heapptr)
+# define UPD_SPEC_IND(updclosure, ind_info, heapptr, and_then) \
+ UPD_PERM_IND(updclosure,heapptr); and_then
#else
-# define UPD_IND(updclosure, heapptr) UPD_REAL_IND(updclosure,heapptr)
+# define SEMI ;
+# define UPD_IND(updclosure, heapptr) \
+ UPD_REAL_IND(updclosure,INFO_PTR(stg_IND_info),heapptr,SEMI)
+# define UPD_SPEC_IND(updclosure, ind_info, heapptr, and_then) \
+ UPD_REAL_IND(updclosure,ind_info,heapptr,and_then)
#endif
-/* UPD_IND actually does a PERM_IND if TICKY_TICKY is on;
- if you *really* need an IND use UPD_REAL_IND
+/* These macros have to work in both C and C--, so here's the
+ * impedence matching:
*/
-#ifdef SMP
-#define UPD_REAL_IND(updclosure, heapptr) \
- { \
- const StgInfoTable *info; \
- if (Bdescr((P_)updclosure)->back != (bdescr *)BaseReg) { \
- info = LOCK_CLOSURE(updclosure); \
- } else { \
- info = updclosure->header.info; \
- } \
- AWAKEN_BQ(info,updclosure); \
- updateWithIndirection(info, \
- (StgClosure *)updclosure, \
- (StgClosure *)heapptr); \
- }
+#ifdef CMINUSMINUS
+#define BLOCK_BEGIN
+#define BLOCK_END
+#define DECLARE_IPTR(info) W_ info
+#define FCALL foreign "C"
+#define INFO_PTR(info) info
+#define ARG_PTR "ptr"
#else
-#define UPD_REAL_IND(updclosure, heapptr) \
- { \
- const StgInfoTable *info; \
- info = ((StgClosure *)updclosure)->header.info; \
- AWAKEN_BQ(info,updclosure); \
- updateWithIndirection(info, \
- (StgClosure *)updclosure, \
- (StgClosure *)heapptr); \
- }
+#define BLOCK_BEGIN {
+#define BLOCK_END }
+#define DECLARE_IPTR(info) const StgInfoTable *(info)
+#define FCALL /* nothing */
+#define INFO_PTR(info) &info
+#define StgBlockingQueue_blocking_queue(closure) \
+ (((StgBlockingQueue *)closure)->blocking_queue)
+#define ARG_PTR /* nothing */
#endif
-#define UPD_STATIC_IND(updclosure, heapptr) \
- { \
- const StgInfoTable *info; \
- info = ((StgClosure *)updclosure)->header.info; \
- AWAKEN_STATIC_BQ(info,updclosure); \
- updateWithStaticIndirection(info, \
- (StgClosure *)updclosure, \
- (StgClosure *)heapptr); \
- }
+/* UPD_IND actually does a PERM_IND if TICKY_TICKY is on;
+ if you *really* need an IND use UPD_REAL_IND
+ */
+#define UPD_REAL_IND(updclosure, ind_info, heapptr, and_then) \
+ BLOCK_BEGIN \
+ DECLARE_IPTR(info); \
+ info = GET_INFO(updclosure); \
+ updateWithIndirection(ind_info, \
+ updclosure, \
+ heapptr, \
+ and_then); \
+ BLOCK_END
#if defined(PROFILING) || defined(TICKY_TICKY)
-#define UPD_PERM_IND(updclosure, heapptr) \
- { \
- const StgInfoTable *info; \
- info = ((StgClosure *)updclosure)->header.info; \
- AWAKEN_BQ(info,updclosure); \
- updateWithPermIndirection(info, \
- (StgClosure *)updclosure, \
- (StgClosure *)heapptr); \
- }
+#define UPD_PERM_IND(updclosure, heapptr) \
+ BLOCK_BEGIN \
+ updateWithPermIndirection(updclosure, \
+ heapptr); \
+ BLOCK_END
#endif
-#ifdef SMP
-#define UPD_IND_NOLOCK(updclosure, heapptr) \
- { \
- const StgInfoTable *info; \
- info = updclosure->header.info; \
- AWAKEN_BQ(info,updclosure); \
- updateWithIndirection(info, \
- (StgClosure *)updclosure, \
- (StgClosure *)heapptr); \
- }
+#if defined(RTS_SUPPORTS_THREADS)
+
+# ifdef TICKY_TICKY
+# define UPD_IND_NOLOCK(updclosure, heapptr) \
+ BLOCK_BEGIN \
+ updateWithPermIndirection(updclosure, \
+ heapptr); \
+ BLOCK_END
+# else
+# define UPD_IND_NOLOCK(updclosure, heapptr) \
+ BLOCK_BEGIN \
+ updateWithIndirection(INFO_PTR(stg_IND_info), \
+ updclosure, \
+ heapptr,); \
+ BLOCK_END
+# endif
+
#else
#define UPD_IND_NOLOCK(updclosure,heapptr) UPD_IND(updclosure,heapptr)
#endif
/* -----------------------------------------------------------------------------
- Awaken any threads waiting on this computation
+ Awaken any threads waiting on a blocking queue (BLACKHOLE_BQ).
-------------------------------------------------------------------------- */
#if defined(PAR)
DO_AWAKEN_BQ(((StgBlockingQueue *)closure)->blocking_queue, closure); \
}
-
-#else /* !GRAN && !PAR */
-
-extern void awakenBlockedQueue(StgTSO *q);
-#define DO_AWAKEN_BQ(closure) \
- STGCALL1(awakenBlockedQueue, \
- ((StgBlockingQueue *)closure)->blocking_queue);
-
-#define AWAKEN_BQ(info,closure) \
- if (info == &stg_BLACKHOLE_BQ_info) { \
- DO_AWAKEN_BQ(closure); \
- }
-
-#define AWAKEN_STATIC_BQ(info,closure) \
- if (info == &stg_BLACKHOLE_BQ_STATIC_info) { \
- DO_AWAKEN_BQ(closure); \
- }
-
#endif /* GRAN || PAR */
-/* -------------------------------------------------------------------------
- Push an update frame on the stack.
- ------------------------------------------------------------------------- */
-
-#if defined(PROFILING)
-// frame->header.prof.hp.rs = NULL (or frame-header.prof.hp.ldvw = 0) is unnecessary
-// because it is not used anyhow.
-#define PUSH_STD_CCCS(frame) (frame->header.prof.ccs = CCCS)
-#else
-#define PUSH_STD_CCCS(frame)
-#endif
-
-extern DLL_IMPORT_RTS const StgPolyInfoTable stg_upd_frame_info;
-
-#define PUSH_UPD_FRAME(target, Sp_offset) \
- { \
- StgUpdateFrame *__frame; \
- TICK_UPDF_PUSHED(target, GET_INFO((StgClosure*)target)); \
- __frame = (StgUpdateFrame *)(Sp + (Sp_offset)) - 1; \
- SET_INFO(__frame, (StgInfoTable *)&stg_upd_frame_info); \
- __frame->link = Su; \
- __frame->updatee = (StgClosure *)(target); \
- PUSH_STD_CCCS(__frame); \
- Su = __frame; \
- }
/* -----------------------------------------------------------------------------
- Entering CAFs
+ Updates: lower-level macros which update a closure with an
+ indirection to another closure.
- When a CAF is first entered, it creates a black hole in the heap,
- and updates itself with an indirection to this new black hole.
+ There are several variants of this code.
- We update the CAF with an indirection to a newly-allocated black
- hole in the heap. We also set the blocking queue on the newly
- allocated black hole to be empty.
-
- Why do we make a black hole in the heap when we enter a CAF?
-
- - for a generational garbage collector, which needs a fast
- test for whether an updatee is in an old generation or not
-
- - for the parallel system, which can implement updates more
- easily if the updatee is always in the heap. (allegedly).
-
- When debugging, we maintain a separate CAF list so we can tell when
- a CAF has been garbage collected.
+ PROFILING:
-------------------------------------------------------------------------- */
-
-/* ToDo: only call newCAF when debugging. */
-extern void newCAF(StgClosure*);
+/* LDV profiling:
+ * We call LDV_recordDead_FILL_SLOP_DYNAMIC(p1) regardless of the generation in
+ * which p1 resides.
+ *
+ * Note:
+ * After all, we do *NOT* need to call LDV_RECORD_CREATE() for both IND and
+ * IND_OLDGEN closures because they are inherently used. But, it corrupts
+ * the invariants that every closure keeps its creation time in the profiling
+ * field. So, we call LDV_RECORD_CREATE().
+ */
-/* newCAF must be called before the itbl ptr is overwritten, since
- newCAF records the old itbl ptr in order to do CAF reverting
- (which Hugs needs to do in order that combined mode works right.)
-*/
-#define UPD_CAF(cafptr, bhptr) \
+/* In the DEBUG case, we also zero out the slop of the old closure,
+ * so that the sanity checker can tell where the next closure is.
+ *
+ * Two important invariants: we should never try to update a closure
+ * to point to itself, and the closure being updated should not
+ * already have been updated (the mutable list will get messed up
+ * otherwise).
+ *
+ * NB. We do *not* do this in SMP mode, because when we have the
+ * possibility of multiple threads entering the same closure, zeroing
+ * the slop in one of the threads would have a disastrous effect on
+ * the other (seen in the wild!).
+ */
+#if !defined(DEBUG) || defined(SMP)
+
+#define DEBUG_FILL_SLOP(p) /* nothing */
+
+#else /* DEBUG */
+
+#ifdef CMINUSMINUS
+
+#define DEBUG_FILL_SLOP(p) \
+ W_ inf; \
+ W_ sz; \
+ W_ i; \
+ inf = %GET_STD_INFO(p); \
+ if (%INFO_TYPE(inf) == HALF_W_(THUNK_SELECTOR)) { \
+ StgThunk_payload(p,0) = 0; \
+ } else { \
+ if (%INFO_TYPE(inf) != HALF_W_(BLACKHOLE)) { \
+ if (%INFO_TYPE(inf) == HALF_W_(AP_STACK)) { \
+ sz = StgAP_STACK_size(p) + BYTES_TO_WDS(SIZEOF_StgAP_STACK_NoHdr); \
+ } else { \
+ sz = TO_W_(%INFO_PTRS(inf)) + TO_W_(%INFO_NPTRS(inf)); \
+ } \
+ i = 0; \
+ for: \
+ if (i < sz) { \
+ StgThunk_payload(p,i) = 0; \
+ i = i + 1; \
+ goto for; \
+ } \
+ } }
+
+#else /* !CMINUSMINUS */
+
+INLINE_HEADER void
+DEBUG_FILL_SLOP(StgClosure *p)
+{
+ StgInfoTable *inf = get_itbl(p);
+ nat i, sz;
+
+ switch (inf->type) {
+ case BLACKHOLE:
+ return;
+ case AP_STACK:
+ sz = ((StgAP_STACK *)p)->size + sizeofW(StgAP_STACK) - sizeofW(StgHeader);
+ break;
+ case THUNK_SELECTOR:
+#ifdef SMP
+ ((StgSelector *)p)->selectee = 0;
+#endif
+ return;
+ default:
+ sz = inf->layout.payload.ptrs + inf->layout.payload.nptrs;
+ break;
+ }
+ for (i = 0; i < sz; i++) {
+ ((StgThunk *)p)->payload[i] = 0;
+ }
+}
+
+#endif /* CMINUSMINUS */
+#endif /* DEBUG */
+
+/* We have two versions of this macro (sadly), one for use in C-- code,
+ * and the other for C.
+ *
+ * The and_then argument is a performance hack so that we can paste in
+ * the continuation code directly. It helps shave a couple of
+ * instructions off the common case in the update code, which is
+ * worthwhile (the update code is often part of the inner loop).
+ * (except that gcc now appears to common up this code again and
+ * invert the optimisation. Grrrr --SDM).
+ */
+#ifdef CMINUSMINUS
+#define generation(n) (W_[generations] + n*SIZEOF_generation)
+#define updateWithIndirection(ind_info, p1, p2, and_then) \
+ W_ bd; \
+ \
+/* ASSERT( p1 != p2 && !closure_IND(p1) ); \
+ */ LDV_RECORD_DEAD_FILL_SLOP_DYNAMIC(p1); \
+/* foreign "C" cas(p1 "ptr", 0, stg_WHITEHOLE_info); \
+ */ bd = Bdescr(p1); \
+ if (bdescr_gen_no(bd) == 0 :: CInt) { \
+ StgInd_indirectee(p1) = p2; \
+ SET_INFO(p1, ind_info); \
+ LDV_RECORD_CREATE(p1); \
+ TICK_UPD_NEW_IND(); \
+ and_then; \
+ } else { \
+ DEBUG_FILL_SLOP(p1); \
+ foreign "C" recordMutableGenLock(p1 "ptr", \
+ generation(TO_W_(bdescr_gen_no(bd))) "ptr"); \
+ StgInd_indirectee(p1) = p2; \
+ SET_INFO(p1, stg_IND_OLDGEN_info); \
+ LDV_RECORD_CREATE(p1); \
+ TICK_UPD_OLD_IND(); \
+ and_then; \
+ }
+#else
+#define updateWithIndirection(ind_info, p1, p2, and_then) \
{ \
- LOCK_CLOSURE(cafptr); \
- STGCALL1(newCAF,(StgClosure *)cafptr); \
- ((StgInd *)cafptr)->indirectee = (StgClosure *)(bhptr); \
- SET_INFO((StgInd *)cafptr,(const StgInfoTable*)&stg_IND_STATIC_info);\
+ bdescr *bd; \
+ \
+ /* cas(p1, 0, &stg_WHITEHOLE_info); */ \
+ ASSERT( (P_)p1 != (P_)p2 && !closure_IND(p1) ); \
+ LDV_RECORD_DEAD_FILL_SLOP_DYNAMIC(p1); \
+ bd = Bdescr((P_)p1); \
+ if (bd->gen_no == 0) { \
+ ((StgInd *)p1)->indirectee = p2; \
+ SET_INFO(p1, ind_info); \
+ LDV_RECORD_CREATE(p1); \
+ TICK_UPD_NEW_IND(); \
+ and_then; \
+ } else { \
+ DEBUG_FILL_SLOP(p1); \
+ recordMutableGenLock(p1, &generations[bd->gen_no]); \
+ ((StgInd *)p1)->indirectee = p2; \
+ SET_INFO(p1, &stg_IND_OLDGEN_info); \
+ TICK_UPD_OLD_IND(); \
+ and_then; \
+ } \
}
+#endif
-/* -----------------------------------------------------------------------------
- Update-related prototypes
- -------------------------------------------------------------------------- */
-
-EXTFUN_RTS(__stg_update_PAP);
-
-DLL_IMPORT_RTS extern STGFUN(stg_upd_frame_entry);
-
-extern DLL_IMPORT_RTS const StgInfoTable stg_PAP_info;
-DLL_IMPORT_RTS STGFUN(stg_PAP_entry);
-
-extern DLL_IMPORT_RTS const StgInfoTable stg_AP_UPD_info;
-DLL_IMPORT_RTS STGFUN(stg_AP_UPD_entry);
-
-extern DLL_IMPORT_RTS const StgInfoTable stg_raise_info;
+/* The permanent indirection version isn't performance critical. We
+ * therefore use an inline C function instead of the C-- macro.
+ */
+#ifndef CMINUSMINUS
+INLINE_HEADER void
+updateWithPermIndirection(StgClosure *p1,
+ StgClosure *p2)
+{
+ bdescr *bd;
+
+ ASSERT( p1 != p2 && !closure_IND(p1) );
+
+ /*
+ * @LDV profiling
+ * Destroy the old closure.
+ * Nb: LDV_* stuff cannot mix with ticky-ticky
+ */
+ LDV_RECORD_DEAD_FILL_SLOP_DYNAMIC(p1);
+
+ bd = Bdescr((P_)p1);
+ if (bd->gen_no == 0) {
+ ((StgInd *)p1)->indirectee = p2;
+ SET_INFO(p1, &stg_IND_PERM_info);
+ /*
+ * @LDV profiling
+ * We have just created a new closure.
+ */
+ LDV_RECORD_CREATE(p1);
+ TICK_UPD_NEW_PERM_IND(p1);
+ } else {
+ recordMutableGenLock(p1, &generations[bd->gen_no]);
+ ((StgInd *)p1)->indirectee = p2;
+ SET_INFO(p1, &stg_IND_OLDGEN_PERM_info);
+ /*
+ * @LDV profiling
+ * We have just created a new closure.
+ */
+ LDV_RECORD_CREATE(p1);
+ TICK_UPD_OLD_PERM_IND();
+ }
+}
+#endif
#endif /* UPDATES_H */
projects / ghc-hetmet.git / blobdiff