1 /* -----------------------------------------------------------------------------
3 * (c) The GHC Team, 2001
6 * Lag/Drag/Void profiling.
8 * ---------------------------------------------------------------------------*/
12 #include "PosixSource.h"
15 #include "Profiling.h"
16 #include "LdvProfile.h"
21 /* --------------------------------------------------------------------------
22 * Fills in the slop when a *dynamic* closure changes its type.
23 * First calls LDV_recordDead() to declare the closure is dead, and then
27 * 1) blackholing, UPD_BH_UPDATABLE() and UPD_BH_SINGLE_ENTRY (in
28 * includes/StgMacros.h), threadLazyBlackHole() and
29 * threadSqueezeStack() (in GC.c).
30 * 2) updating with indirection closures, updateWithIndirection()
31 * and updateWithPermIndirection() (in Storage.h).
33 * LDV_recordDead_FILL_SLOP_DYNAMIC() is not called on 'inherently used'
34 * closures such as TSO. It is not called on PAP because PAP is not updatable.
35 * ----------------------------------------------------------------------- */
37 LDV_recordDead_FILL_SLOP_DYNAMIC( StgClosure *p )
41 #if defined(__GNUC__) && __GNUC__ < 3 && defined(DEBUG)
42 #error Please use gcc 3.0+ to compile this file with DEBUG; gcc < 3.0 miscompiles it
46 // very like FILL_SLOP(), except that we call LDV_recordDead().
47 size = closure_sizeW(p);
49 LDV_recordDead((StgClosure *)(p), size);
51 if (size > sizeofW(StgThunkHeader)) {
52 for (i = 0; i < size - sizeofW(StgThunkHeader); i++) {
53 ((StgThunk *)(p))->payload[i] = 0;
59 /* --------------------------------------------------------------------------
60 * This function is called eventually on every object destroyed during
61 * a garbage collection, whether it is a major garbage collection or
62 * not. If c is an 'inherently used' closure, nothing happens. If c
63 * is an ordinary closure, LDV_recordDead() is called on c with its
64 * proper size which excludes the profiling header portion in the
65 * closure. Returns the size of the closure, including the profiling
66 * header portion, so that the caller can find the next closure.
67 * ----------------------------------------------------------------------- */
69 processHeapClosureForDead( StgClosure *c )
72 const StgInfoTable *info;
76 info = c->header.info;
77 if (IS_FORWARDING_PTR(info)) {
78 // The size of the evacuated closure is currently stored in
79 // the LDV field. See SET_EVACUAEE_FOR_LDV() in
80 // includes/StgLdvProf.h.
83 info = INFO_PTR_TO_STRUCT(info);
85 ASSERT(((LDVW(c) & LDV_CREATE_MASK) >> LDV_SHIFT) <= era &&
86 ((LDVW(c) & LDV_CREATE_MASK) >> LDV_SHIFT) > 0);
87 ASSERT(((LDVW(c) & LDV_STATE_MASK) == LDV_STATE_CREATE) ||
89 (LDVW(c) & LDV_LAST_MASK) <= era &&
90 (LDVW(c) & LDV_LAST_MASK) > 0
94 size = closure_sizeW(c);
98 'inherently used' cases: do nothing.
103 case MUT_ARR_PTRS_CLEAN:
104 case MUT_ARR_PTRS_DIRTY:
105 case MUT_ARR_PTRS_FROZEN:
106 case MUT_ARR_PTRS_FROZEN0:
113 case TVAR_WATCH_QUEUE:
117 case INVARIANT_CHECK_QUEUE:
118 case ATOMIC_INVARIANT:
122 ordinary cases: call LDV_recordDead().
149 case IND_OLDGEN_PERM:
153 // Why can we ignore IND/IND_OLDGEN closures? We assume that
154 // any census is preceded by a major garbage collection, which
155 // IND/IND_OLDGEN closures cannot survive. Therefore, it is no
156 // use considering IND/IND_OLDGEN closures in the meanwhile
157 // because they will perish before the next census at any
161 // Found a dead closure: record its size
162 LDV_recordDead(c, size);
173 case CONSTR_NOCAF_STATIC:
185 barf("Invalid object in processHeapClosureForDead(): %d", info->type);
190 /* --------------------------------------------------------------------------
191 * Calls processHeapClosureForDead() on every *dead* closures in the
192 * heap blocks starting at bd.
193 * ----------------------------------------------------------------------- */
195 processHeapForDead( bdescr *bd )
201 while (p < bd->free) {
202 p += processHeapClosureForDead((StgClosure *)p);
203 while (p < bd->free && !*p) // skip slop
206 ASSERT(p == bd->free);
211 /* --------------------------------------------------------------------------
212 * Calls processHeapClosureForDead() on every *dead* closures in the nursery.
213 * ----------------------------------------------------------------------- */
215 processNurseryForDead( void )
220 bd = MainCapability.r.rNursery->blocks;
221 while (bd->start < bd->free) {
223 bdLimit = bd->start + BLOCK_SIZE_W;
224 while (p < bd->free && p < bdLimit) {
225 p += processHeapClosureForDead((StgClosure *)p);
226 while (p < bd->free && p < bdLimit && !*p) // skip slop
235 /* --------------------------------------------------------------------------
236 * Calls processHeapClosureForDead() on every *dead* closures in the closure
238 * ----------------------------------------------------------------------- */
240 processChainForDead( bdescr *bd )
242 // Any object still in the chain is dead!
244 if (!(bd->flags & BF_PINNED)) {
245 processHeapClosureForDead((StgClosure *)bd->start);
251 /* --------------------------------------------------------------------------
252 * Start a census for *dead* closures, and calls
253 * processHeapClosureForDead() on every closure which died in the
254 * current garbage collection. This function is called from a garbage
255 * collector right before tidying up, when all dead closures are still
256 * stored in the heap and easy to identify. Generations 0 through N
257 * have just beed garbage collected.
258 * ----------------------------------------------------------------------- */
260 LdvCensusForDead( nat N )
264 // ldvTime == 0 means that LDV profiling is currently turned off.
268 if (RtsFlags.GcFlags.generations == 1) {
270 // Todo: support LDV for two-space garbage collection.
272 barf("Lag/Drag/Void profiling not supported with -G1");
274 for (g = 0; g <= N; g++)
275 for (s = 0; s < generations[g].n_steps; s++) {
276 if (g == 0 && s == 0) {
277 processNurseryForDead();
278 processChainForDead(generations[g].steps[s].large_objects);
280 processHeapForDead(generations[g].steps[s].old_blocks);
281 processChainForDead(generations[g].steps[s].large_objects);
287 /* --------------------------------------------------------------------------
288 * Regard any closure in the current heap as dead or moribund and update
289 * LDV statistics accordingly.
290 * Called from shutdownHaskell() in RtsStartup.c.
291 * Also, stops LDV profiling by resetting ldvTime to 0.
292 * ----------------------------------------------------------------------- */
294 LdvCensusKillAll( void )
296 LdvCensusForDead(RtsFlags.GcFlags.generations - 1);
299 #endif /* PROFILING */