# define evacuate(a) evacuate1(a)
# define recordMutableGen_GC(a,b) recordMutableGen(a,b)
# define scavenge_loop(a) scavenge_loop1(a)
+# define scavenge_block(a) scavenge_block1(a)
# define scavenge_mutable_list(bd,g) scavenge_mutable_list1(bd,g)
# define scavenge_capability_mut_lists(cap) scavenge_capability_mut_Lists1(cap)
#endif
/* -----------------------------------------------------------------------------
Scavenge a block from the given scan pointer up to bd->free.
- evac_step is set by the caller to be either zero (for a step in a
+ evac_gen is set by the caller to be either zero (for a step in a
generation < N) or G where G is the generation of the step being
scavenged.
- We sometimes temporarily change evac_step back to zero if we're
+ We sometimes temporarily change evac_gen back to zero if we're
scavenging a mutable object where eager promotion isn't such a good
idea.
-------------------------------------------------------------------------- */
{
StgPtr p, q;
StgInfoTable *info;
- step *saved_evac_step;
+ generation *saved_evac_gen;
rtsBool saved_eager_promotion;
- step_workspace *ws;
+ gen_workspace *ws;
- debugTrace(DEBUG_gc, "scavenging block %p (gen %d, step %d) @ %p",
- bd->start, bd->gen_no, bd->step->no, bd->u.scan);
+ debugTrace(DEBUG_gc, "scavenging block %p (gen %d) @ %p",
+ bd->start, bd->gen_no, bd->u.scan);
gct->scan_bd = bd;
- gct->evac_step = bd->step;
- saved_evac_step = gct->evac_step;
+ gct->evac_gen = bd->gen;
+ saved_evac_gen = gct->evac_gen;
saved_eager_promotion = gct->eager_promotion;
gct->failed_to_evac = rtsFalse;
- ws = &gct->steps[bd->step->abs_no];
+ ws = &gct->gens[bd->gen->no];
p = bd->u.scan;
case TVAR_WATCH_QUEUE:
{
StgTVarWatchQueue *wq = ((StgTVarWatchQueue *) p);
- gct->evac_step = 0;
+ gct->evac_gen = 0;
evacuate((StgClosure **)&wq->closure);
evacuate((StgClosure **)&wq->next_queue_entry);
evacuate((StgClosure **)&wq->prev_queue_entry);
- gct->evac_step = saved_evac_step;
+ gct->evac_gen = saved_evac_gen;
gct->failed_to_evac = rtsTrue; // mutable
p += sizeofW(StgTVarWatchQueue);
break;
case TVAR:
{
StgTVar *tvar = ((StgTVar *) p);
- gct->evac_step = 0;
+ gct->evac_gen = 0;
evacuate((StgClosure **)&tvar->current_value);
evacuate((StgClosure **)&tvar->first_watch_queue_entry);
- gct->evac_step = saved_evac_step;
+ gct->evac_gen = saved_evac_gen;
gct->failed_to_evac = rtsTrue; // mutable
p += sizeofW(StgTVar);
break;
case TREC_HEADER:
{
StgTRecHeader *trec = ((StgTRecHeader *) p);
- gct->evac_step = 0;
+ gct->evac_gen = 0;
evacuate((StgClosure **)&trec->enclosing_trec);
evacuate((StgClosure **)&trec->current_chunk);
evacuate((StgClosure **)&trec->invariants_to_check);
- gct->evac_step = saved_evac_step;
+ gct->evac_gen = saved_evac_gen;
gct->failed_to_evac = rtsTrue; // mutable
p += sizeofW(StgTRecHeader);
break;
StgWord i;
StgTRecChunk *tc = ((StgTRecChunk *) p);
TRecEntry *e = &(tc -> entries[0]);
- gct->evac_step = 0;
+ gct->evac_gen = 0;
evacuate((StgClosure **)&tc->prev_chunk);
for (i = 0; i < tc -> next_entry_idx; i ++, e++ ) {
evacuate((StgClosure **)&e->tvar);
evacuate((StgClosure **)&e->expected_value);
evacuate((StgClosure **)&e->new_value);
}
- gct->evac_step = saved_evac_step;
+ gct->evac_gen = saved_evac_gen;
gct->failed_to_evac = rtsTrue; // mutable
p += sizeofW(StgTRecChunk);
break;
case ATOMIC_INVARIANT:
{
StgAtomicInvariant *invariant = ((StgAtomicInvariant *) p);
- gct->evac_step = 0;
+ gct->evac_gen = 0;
evacuate(&invariant->code);
evacuate((StgClosure **)&invariant->last_execution);
- gct->evac_step = saved_evac_step;
+ gct->evac_gen = saved_evac_gen;
gct->failed_to_evac = rtsTrue; // mutable
p += sizeofW(StgAtomicInvariant);
break;
case INVARIANT_CHECK_QUEUE:
{
StgInvariantCheckQueue *queue = ((StgInvariantCheckQueue *) p);
- gct->evac_step = 0;
+ gct->evac_gen = 0;
evacuate((StgClosure **)&queue->invariant);
evacuate((StgClosure **)&queue->my_execution);
evacuate((StgClosure **)&queue->next_queue_entry);
- gct->evac_step = saved_evac_step;
+ gct->evac_gen = saved_evac_gen;
gct->failed_to_evac = rtsTrue; // mutable
p += sizeofW(StgInvariantCheckQueue);
break;
{
StgPtr p, q;
StgInfoTable *info;
- step *saved_evac_step;
+ generation *saved_evac_gen;
- gct->evac_step = &oldest_gen->steps[0];
- saved_evac_step = gct->evac_step;
+ gct->evac_gen = oldest_gen;
+ saved_evac_gen = gct->evac_gen;
while ((p = pop_mark_stack())) {
case TVAR_WATCH_QUEUE:
{
StgTVarWatchQueue *wq = ((StgTVarWatchQueue *) p);
- gct->evac_step = 0;
+ gct->evac_gen = 0;
evacuate((StgClosure **)&wq->closure);
evacuate((StgClosure **)&wq->next_queue_entry);
evacuate((StgClosure **)&wq->prev_queue_entry);
- gct->evac_step = saved_evac_step;
+ gct->evac_gen = saved_evac_gen;
gct->failed_to_evac = rtsTrue; // mutable
break;
}
case TVAR:
{
StgTVar *tvar = ((StgTVar *) p);
- gct->evac_step = 0;
+ gct->evac_gen = 0;
evacuate((StgClosure **)&tvar->current_value);
evacuate((StgClosure **)&tvar->first_watch_queue_entry);
- gct->evac_step = saved_evac_step;
+ gct->evac_gen = saved_evac_gen;
gct->failed_to_evac = rtsTrue; // mutable
break;
}
StgWord i;
StgTRecChunk *tc = ((StgTRecChunk *) p);
TRecEntry *e = &(tc -> entries[0]);
- gct->evac_step = 0;
+ gct->evac_gen = 0;
evacuate((StgClosure **)&tc->prev_chunk);
for (i = 0; i < tc -> next_entry_idx; i ++, e++ ) {
evacuate((StgClosure **)&e->tvar);
evacuate((StgClosure **)&e->expected_value);
evacuate((StgClosure **)&e->new_value);
}
- gct->evac_step = saved_evac_step;
+ gct->evac_gen = saved_evac_gen;
gct->failed_to_evac = rtsTrue; // mutable
break;
}
case TREC_HEADER:
{
StgTRecHeader *trec = ((StgTRecHeader *) p);
- gct->evac_step = 0;
+ gct->evac_gen = 0;
evacuate((StgClosure **)&trec->enclosing_trec);
evacuate((StgClosure **)&trec->current_chunk);
evacuate((StgClosure **)&trec->invariants_to_check);
- gct->evac_step = saved_evac_step;
+ gct->evac_gen = saved_evac_gen;
gct->failed_to_evac = rtsTrue; // mutable
break;
}
case ATOMIC_INVARIANT:
{
StgAtomicInvariant *invariant = ((StgAtomicInvariant *) p);
- gct->evac_step = 0;
+ gct->evac_gen = 0;
evacuate(&invariant->code);
evacuate((StgClosure **)&invariant->last_execution);
- gct->evac_step = saved_evac_step;
+ gct->evac_gen = saved_evac_gen;
gct->failed_to_evac = rtsTrue; // mutable
break;
}
case INVARIANT_CHECK_QUEUE:
{
StgInvariantCheckQueue *queue = ((StgInvariantCheckQueue *) p);
- gct->evac_step = 0;
+ gct->evac_gen = 0;
evacuate((StgClosure **)&queue->invariant);
evacuate((StgClosure **)&queue->my_execution);
evacuate((StgClosure **)&queue->next_queue_entry);
- gct->evac_step = saved_evac_step;
+ gct->evac_gen = saved_evac_gen;
gct->failed_to_evac = rtsTrue; // mutable
break;
}
if (gct->failed_to_evac) {
gct->failed_to_evac = rtsFalse;
- if (gct->evac_step) {
- recordMutableGen_GC((StgClosure *)q, gct->evac_step->gen_no);
+ if (gct->evac_gen) {
+ recordMutableGen_GC((StgClosure *)q, gct->evac_gen->no);
}
}
} // while (p = pop_mark_stack())
scavenge_one(StgPtr p)
{
const StgInfoTable *info;
- step *saved_evac_step = gct->evac_step;
+ generation *saved_evac_gen = gct->evac_gen;
rtsBool no_luck;
ASSERT(LOOKS_LIKE_CLOSURE_PTR(p));
case TVAR_WATCH_QUEUE:
{
StgTVarWatchQueue *wq = ((StgTVarWatchQueue *) p);
- gct->evac_step = 0;
+ gct->evac_gen = 0;
evacuate((StgClosure **)&wq->closure);
evacuate((StgClosure **)&wq->next_queue_entry);
evacuate((StgClosure **)&wq->prev_queue_entry);
- gct->evac_step = saved_evac_step;
+ gct->evac_gen = saved_evac_gen;
gct->failed_to_evac = rtsTrue; // mutable
break;
}
case TVAR:
{
StgTVar *tvar = ((StgTVar *) p);
- gct->evac_step = 0;
+ gct->evac_gen = 0;
evacuate((StgClosure **)&tvar->current_value);
evacuate((StgClosure **)&tvar->first_watch_queue_entry);
- gct->evac_step = saved_evac_step;
+ gct->evac_gen = saved_evac_gen;
gct->failed_to_evac = rtsTrue; // mutable
break;
}
case TREC_HEADER:
{
StgTRecHeader *trec = ((StgTRecHeader *) p);
- gct->evac_step = 0;
+ gct->evac_gen = 0;
evacuate((StgClosure **)&trec->enclosing_trec);
evacuate((StgClosure **)&trec->current_chunk);
evacuate((StgClosure **)&trec->invariants_to_check);
- gct->evac_step = saved_evac_step;
+ gct->evac_gen = saved_evac_gen;
gct->failed_to_evac = rtsTrue; // mutable
break;
}
StgWord i;
StgTRecChunk *tc = ((StgTRecChunk *) p);
TRecEntry *e = &(tc -> entries[0]);
- gct->evac_step = 0;
+ gct->evac_gen = 0;
evacuate((StgClosure **)&tc->prev_chunk);
for (i = 0; i < tc -> next_entry_idx; i ++, e++ ) {
evacuate((StgClosure **)&e->tvar);
evacuate((StgClosure **)&e->expected_value);
evacuate((StgClosure **)&e->new_value);
}
- gct->evac_step = saved_evac_step;
+ gct->evac_gen = saved_evac_gen;
gct->failed_to_evac = rtsTrue; // mutable
break;
}
case ATOMIC_INVARIANT:
{
StgAtomicInvariant *invariant = ((StgAtomicInvariant *) p);
- gct->evac_step = 0;
+ gct->evac_gen = 0;
evacuate(&invariant->code);
evacuate((StgClosure **)&invariant->last_execution);
- gct->evac_step = saved_evac_step;
+ gct->evac_gen = saved_evac_gen;
gct->failed_to_evac = rtsTrue; // mutable
break;
}
case INVARIANT_CHECK_QUEUE:
{
StgInvariantCheckQueue *queue = ((StgInvariantCheckQueue *) p);
- gct->evac_step = 0;
+ gct->evac_gen = 0;
evacuate((StgClosure **)&queue->invariant);
evacuate((StgClosure **)&queue->my_execution);
evacuate((StgClosure **)&queue->next_queue_entry);
- gct->evac_step = saved_evac_step;
+ gct->evac_gen = saved_evac_gen;
gct->failed_to_evac = rtsTrue; // mutable
break;
}
* promoted
*/
{
- StgPtr start = gen->steps[0].scan;
- bdescr *start_bd = gen->steps[0].scan_bd;
+ StgPtr start = gen->scan;
+ bdescr *start_bd = gen->scan_bd;
nat size = 0;
- scavenge(&gen->steps[0]);
- if (start_bd != gen->steps[0].scan_bd) {
+ scavenge(&gen);
+ if (start_bd != gen->scan_bd) {
size += (P_)BLOCK_ROUND_UP(start) - start;
start_bd = start_bd->link;
- while (start_bd != gen->steps[0].scan_bd) {
+ while (start_bd != gen->scan_bd) {
size += BLOCK_SIZE_W;
start_bd = start_bd->link;
}
- size += gen->steps[0].scan -
- (P_)BLOCK_ROUND_DOWN(gen->steps[0].scan);
+ size += gen->scan -
+ (P_)BLOCK_ROUND_DOWN(gen->scan);
} else {
- size = gen->steps[0].scan - start;
+ size = gen->scan - start;
}
debugBelch("evac IND_OLDGEN: %ld bytes", size * sizeof(W_));
}
{
StgPtr p, q;
- gct->evac_step = &gen->steps[0];
+ gct->evac_gen = gen;
for (; bd != NULL; bd = bd->link) {
for (q = bd->start; q < bd->free; q++) {
p = (StgPtr)*q;
/* Always evacuate straight to the oldest generation for static
* objects */
- gct->evac_step = &oldest_gen->steps[0];
+ gct->evac_gen = oldest_gen;
/* keep going until we've scavenged all the objects on the linked
list... */
/*-----------------------------------------------------------------------------
scavenge the large object list.
- evac_step set by caller; similar games played with evac_step as with
+ evac_gen set by caller; similar games played with evac_gen as with
scavenge() - see comment at the top of scavenge(). Most large
- objects are (repeatedly) mutable, so most of the time evac_step will
+ objects are (repeatedly) mutable, so most of the time evac_gen will
be zero.
--------------------------------------------------------------------------- */
static void
-scavenge_large (step_workspace *ws)
+scavenge_large (gen_workspace *ws)
{
bdescr *bd;
StgPtr p;
- gct->evac_step = ws->step;
+ gct->evac_gen = ws->gen;
bd = ws->todo_large_objects;
// the front when evacuating.
ws->todo_large_objects = bd->link;
- ACQUIRE_SPIN_LOCK(&ws->step->sync_large_objects);
- dbl_link_onto(bd, &ws->step->scavenged_large_objects);
- ws->step->n_scavenged_large_blocks += bd->blocks;
- RELEASE_SPIN_LOCK(&ws->step->sync_large_objects);
+ ACQUIRE_SPIN_LOCK(&ws->gen->sync_large_objects);
+ dbl_link_onto(bd, &ws->gen->scavenged_large_objects);
+ ws->gen->n_scavenged_large_blocks += bd->blocks;
+ RELEASE_SPIN_LOCK(&ws->gen->sync_large_objects);
p = bd->start;
if (scavenge_one(p)) {
- if (ws->step->gen_no > 0) {
- recordMutableGen_GC((StgClosure *)p, ws->step->gen_no);
+ if (ws->gen->no > 0) {
+ recordMutableGen_GC((StgClosure *)p, ws->gen->no);
}
}
/* ----------------------------------------------------------------------------
Look for work to do.
- We look for the oldest step that has either a todo block that can
+ We look for the oldest gen that has either a todo block that can
be scanned, or a block of work on the global queue that we can
scan.
static rtsBool
scavenge_find_work (void)
{
- int s;
- step_workspace *ws;
+ int g;
+ gen_workspace *ws;
rtsBool did_something, did_anything;
bdescr *bd;
loop:
did_something = rtsFalse;
- for (s = total_steps-1; s >= 0; s--) {
- if (s == 0 && RtsFlags.GcFlags.generations > 1) {
- continue;
- }
- ws = &gct->steps[s];
+ for (g = RtsFlags.GcFlags.generations-1; g >= 0; g--) {
+ ws = &gct->gens[g];
gct->scan_bd = NULL;
#if defined(THREADED_RTS)
if (work_stealing) {
// look for work to steal
- for (s = total_steps-1; s >= 0; s--) {
- if (s == 0 && RtsFlags.GcFlags.generations > 1) {
- continue;
- }
- if ((bd = steal_todo_block(s)) != NULL) {
+ for (g = RtsFlags.GcFlags.generations-1; g >= 0; g--) {
+ if ((bd = steal_todo_block(g)) != NULL) {
scavenge_block(bd);
did_something = rtsTrue;
break;
projects / ghc-hetmet.git / blobdiff