statDescribeGens(void)
{
nat g, s, mut, lge;
- lnat live;
+ lnat live, slop;
+ lnat tot_live, tot_slop;
bdescr *bd;
step *step;
debugBelch(
-" Gen Steps Max Mut-list Step Blocks Live Large\n"
-" Blocks Bytes Objects\n");
+"-----------------------------------------------------------------\n"
+" Gen Max Mut-list Step Blocks Large Live Slop\n"
+" Blocks Bytes Objects \n"
+"-----------------------------------------------------------------\n");
- mut = 0;
+ tot_live = 0;
+ tot_slop = 0;
for (g = 0; g < RtsFlags.GcFlags.generations; g++) {
+ mut = 0;
for (bd = generations[g].mut_list; bd != NULL; bd = bd->link) {
mut += (bd->free - bd->start) * sizeof(W_);
}
- debugBelch("%8d %8d %8d %9d", g, generations[g].n_steps,
- generations[g].max_blocks, mut);
+ debugBelch("%5d %7d %9d", g, generations[g].max_blocks, mut);
for (s = 0; s < generations[g].n_steps; s++) {
step = &generations[g].steps[s];
- live = 0;
for (bd = step->large_objects, lge = 0; bd; bd = bd->link) {
lge++;
}
- // This live figure will be slightly less that the "live" figure
- // given by +RTS -Sstderr, because we take don't count the
- // slop at the end of each block.
- live += countOccupied(step->blocks) + countOccupied(step->large_objects);
+ live = step->n_words + countOccupied(step->large_objects);
if (s != 0) {
- debugBelch("%36s","");
+ debugBelch("%23s","");
}
- debugBelch("%6d %8d %8ld %8d\n", s, step->n_blocks,
- live, lge);
+ slop = (step->n_blocks + step->n_large_blocks) * BLOCK_SIZE_W - live;
+ debugBelch("%6d %8d %8d %8ld %8ld\n", s, step->n_blocks, lge,
+ live*sizeof(W_), slop*sizeof(W_));
+ tot_live += live;
+ tot_slop += slop;
}
}
+ debugBelch("-----------------------------------------------------------------\n");
+ debugBelch("%48s%8ld %8ld\n","",tot_live*sizeof(W_),tot_slop*sizeof(W_));
+ debugBelch("-----------------------------------------------------------------\n");
debugBelch("\n");
}
ACQUIRE_SM_LOCK;
- debugTrace(DEBUG_gc, "starting GC");
-
#if defined(RTS_USER_SIGNALS)
if (RtsFlags.MiscFlags.install_signal_handlers) {
// block signals
} else {
n_gc_threads = RtsFlags.ParFlags.gcThreads;
}
- trace(TRACE_gc|DEBUG_gc, "GC (gen %d): %dKB to collect, using %d thread(s)",
- N, n * (BLOCK_SIZE / 1024), n_gc_threads);
#else
n_gc_threads = 1;
#endif
+ trace(TRACE_gc|DEBUG_gc, "GC (gen %d): %dKB to collect, using %d thread(s)",
+ N, n * (BLOCK_SIZE / 1024), n_gc_threads);
#ifdef RTS_GTK_FRONTPANEL
if (RtsFlags.GcFlags.frontpanel) {
prev = ws->part_list;
for (bd = ws->part_list; bd != NULL; bd = bd->link) {
bd->flags &= ~BF_EVACUATED; // now from-space
+ ws->step->n_words += bd->free - bd->start;
prev = bd;
}
if (prev != NULL) {
}
for (bd = ws->scavd_list; bd != NULL; bd = bd->link) {
bd->flags &= ~BF_EVACUATED; // now from-space
+ ws->step->n_words += bd->free - bd->start;
prev = bd;
}
prev->link = ws->step->blocks;
ws->step->n_blocks += ws->n_part_blocks;
ws->step->n_blocks += ws->n_scavd_blocks;
ASSERT(countBlocks(ws->step->blocks) == ws->step->n_blocks);
+ ASSERT(countOccupied(ws->step->blocks) == ws->step->n_words);
}
}
}
// onto the front of the now-compacted existing blocks.
for (bd = stp->blocks; bd != NULL; bd = bd->link) {
bd->flags &= ~BF_EVACUATED; // now from-space
+ stp->n_words += bd->free - bd->start;
}
// tack the new blocks on the end of the existing blocks
if (stp->old_blocks != NULL) {
// add the new blocks to the block tally
stp->n_blocks += stp->n_old_blocks;
ASSERT(countBlocks(stp->blocks) == stp->n_blocks);
+ ASSERT(countOccupied(stp->blocks) == stp->n_words);
}
else // not copacted
{
// update the max size of older generations after a major GC
resize_generations();
- // Guess the amount of live data for stats.
- live = calcLiveBlocks() * BLOCK_SIZE_W;
- debugTrace(DEBUG_gc, "Slop: %ldKB",
- (live - calcLiveWords()) / (1024/sizeof(W_)));
+ // Calculate the amount of live data for stats.
+ live = calcLiveWords();
// Free the small objects allocated via allocate(), since this will
// all have been copied into G0S1 now.
g0s0->blocks = NULL;
}
g0s0->n_blocks = 0;
+ g0s0->n_words = 0;
}
alloc_blocks = 0;
alloc_blocks_lim = RtsFlags.GcFlags.minAllocAreaSize;
for (g = RtsFlags.GcFlags.generations - 1; g >= 0; g--) {
blocks = 0;
for (s = 0; s < generations[g].n_steps; s++) {
- blocks += generations[g].steps[s].n_blocks;
+ blocks += generations[g].steps[s].n_words / BLOCK_SIZE_W;
blocks += generations[g].steps[s].n_large_blocks;
}
if (blocks >= generations[g].max_blocks) {
stp->n_old_blocks = stp->n_blocks;
stp->blocks = NULL;
stp->n_blocks = 0;
+ stp->n_words = 0;
// we don't have any to-be-scavenged blocks yet
stp->todos = NULL;
ws->todo_lim = ws->todo_bd->start + BLOCK_SIZE_W;
stp->blocks = stp->blocks->link;
stp->n_blocks -= 1;
+ stp->n_words -= ws->todo_bd->free - ws->todo_bd->start;
ws->todo_bd->link = NULL;
// this block is also the scan block; we must scan
nat gens = RtsFlags.GcFlags.generations;
// live in the oldest generations
- live = oldest_gen->steps[0].n_blocks +
+ live = (oldest_gen->steps[0].n_words + BLOCK_SIZE_W - 1) / BLOCK_SIZE_W+
oldest_gen->steps[0].n_large_blocks;
// default max size for all generations except zero