/* -----------------------------------------------------------------------------
- * $Id: Storage.c,v 1.34 2001/01/29 17:23:41 simonmar Exp $
+ * $Id: Storage.c,v 1.41 2001/07/23 17:23:20 simonmar Exp $
*
* (c) The GHC Team, 1998-1999
*
* fixed-size allocation area so that we get roughly even-spaced
* samples.
*/
+
+ /* As an experiment, try a 2 generation collector
+ */
+
#if defined(PROFILING) || defined(DEBUG)
if (RtsFlags.ProfFlags.doHeapProfile) {
RtsFlags.GcFlags.generations = 1;
stp->blocks = NULL;
stp->n_blocks = 0;
stp->gen = &generations[g];
+ stp->gen_no = g;
stp->hp = NULL;
stp->hpLim = NULL;
stp->hp_bd = NULL;
stp->large_objects = NULL;
stp->new_large_objects = NULL;
stp->scavenged_large_objects = NULL;
+ stp->is_compacted = 0;
}
}
generations[g].steps[s].to = &generations[g+1].steps[0];
}
- /* The oldest generation has one step and its destination is the
- * same step. */
+ /* The oldest generation has one step and it is compacted. */
+ if (RtsFlags.GcFlags.compact) {
+ oldest_gen->steps[0].is_compacted = 1;
+ }
oldest_gen->steps[0].to = &oldest_gen->steps[0];
/* generation 0 is special: that's the nursery */
pthread_mutex_init(&sm_mutex, NULL);
#endif
- IF_DEBUG(gc, stat_describe_gens());
+ IF_DEBUG(gc, statDescribeGens());
}
void
*/
ACQUIRE_LOCK(&sm_mutex);
-#ifdef GHCI
if (is_dynamically_loaded_rwdata_ptr((StgPtr)caf)) {
((StgIndStatic *)caf)->saved_info = (StgInfoTable *)caf->header.info;
((StgIndStatic *)caf)->static_link = caf_list;
((StgMutClosure *)caf)->mut_link = oldest_gen->mut_once_list;
oldest_gen->mut_once_list = (StgMutClosure *)caf;
}
-#else
- ASSERT( ((StgMutClosure*)caf)->mut_link == NULL );
- ((StgMutClosure *)caf)->mut_link = oldest_gen->mut_once_list;
- oldest_gen->mut_once_list = (StgMutClosure *)caf;
-#endif
RELEASE_LOCK(&sm_mutex);
-}
-
-#ifdef GHCI
-void
-markCafs( void )
-{
- StgClosure *p;
- for (p = caf_list; p != NULL; p = STATIC_LINK2(get_itbl(p),p)) {
- MarkRoot(p);
- }
+#ifdef PAR
+ /* If we are PAR or DIST then we never forget a CAF */
+ { globalAddr *newGA;
+ //belch("<##> Globalising CAF %08x %s",caf,info_type(caf));
+ newGA=makeGlobal(caf,rtsTrue); /*given full weight*/
+ ASSERT(newGA);
+ }
+#endif /* PAR */
}
-#endif /* GHCI */
/* -----------------------------------------------------------------------------
Nursery management.
cap->rNursery = allocNursery(NULL, RtsFlags.GcFlags.minAllocAreaSize);
cap->rCurrentNursery = cap->rNursery;
for (bd = cap->rNursery; bd != NULL; bd = bd->link) {
- bd->back = (bdescr *)cap;
+ bd->u.back = (bdescr *)cap;
}
}
/* Set the back links to be equal to the Capability,
*/
}
#else /* SMP */
- nursery_blocks = RtsFlags.GcFlags.minAllocAreaSize;
- g0s0->blocks = allocNursery(NULL, nursery_blocks);
- g0s0->n_blocks = nursery_blocks;
- g0s0->to_space = NULL;
+ nursery_blocks = RtsFlags.GcFlags.minAllocAreaSize;
+ g0s0->blocks = allocNursery(NULL, nursery_blocks);
+ g0s0->n_blocks = nursery_blocks;
+ g0s0->to_blocks = NULL;
+ g0s0->n_to_blocks = 0;
MainRegTable.rNursery = g0s0->blocks;
MainRegTable.rCurrentNursery = g0s0->blocks;
/* hp, hpLim, hp_bd, to_space etc. aren't used in G0S0 */
for (cap = free_capabilities; cap != NULL; cap = cap->link) {
for (bd = cap->rNursery; bd; bd = bd->link) {
bd->free = bd->start;
- ASSERT(bd->gen == g0);
+ ASSERT(bd->gen_no == 0);
ASSERT(bd->step == g0s0);
IF_DEBUG(sanity,memset(bd->start, 0xaa, BLOCK_SIZE));
}
#else
for (bd = g0s0->blocks; bd; bd = bd->link) {
bd->free = bd->start;
- ASSERT(bd->gen == g0);
+ ASSERT(bd->gen_no == 0);
ASSERT(bd->step == g0s0);
IF_DEBUG(sanity,memset(bd->start, 0xaa, BLOCK_SIZE));
}
bd = allocBlock();
bd->link = last_bd;
bd->step = g0s0;
- bd->gen = g0;
- bd->evacuated = 0;
+ bd->gen_no = 0;
+ bd->flags = 0;
bd->free = bd->start;
last_bd = bd;
}
nat req_blocks = (lnat)BLOCK_ROUND_UP(n*sizeof(W_)) / BLOCK_SIZE;
bd = allocGroup(req_blocks);
dbl_link_onto(bd, &g0s0->large_objects);
- bd->gen = g0;
+ bd->gen_no = 0;
bd->step = g0s0;
- bd->evacuated = 0;
+ bd->flags = BF_LARGE;
bd->free = bd->start;
/* don't add these blocks to alloc_blocks, since we're assuming
* that large objects are likely to remain live for quite a while
bd = allocBlock();
bd->link = small_alloc_list;
small_alloc_list = bd;
- bd->gen = g0;
+ bd->gen_no = 0;
bd->step = g0s0;
- bd->evacuated = 0;
+ bd->flags = 0;
alloc_Hp = bd->start;
alloc_HpLim = bd->start + BLOCK_SIZE_W;
alloc_blocks++;
}
-
+
p = alloc_Hp;
alloc_Hp += n;
RELEASE_LOCK(&sm_mutex);
step *stp;
if (RtsFlags.GcFlags.generations == 1) {
- live = (g0s0->to_blocks - 1) * BLOCK_SIZE_W +
+ live = (g0s0->n_to_blocks - 1) * BLOCK_SIZE_W +
((lnat)g0s0->hp_bd->free - (lnat)g0s0->hp_bd->start) / sizeof(W_);
return live;
}
continue;
}
stp = &generations[g].steps[s];
- live += (stp->n_blocks - 1) * BLOCK_SIZE_W +
- ((lnat)stp->hp_bd->free - (lnat)stp->hp_bd->start) / sizeof(W_);
+ live += (stp->n_blocks - 1) * BLOCK_SIZE_W;
+ if (stp->hp_bd != NULL) {
+ live += ((lnat)stp->hp_bd->free - (lnat)stp->hp_bd->start)
+ / sizeof(W_);
+ }
}
}
return live;
for (s = 0; s < generations[g].n_steps; s++) {
if (g == 0 && s == 0) { continue; }
stp = &generations[g].steps[s];
- if (generations[g].steps[0].n_blocks > generations[g].max_blocks) {
+ if (generations[g].steps[0].n_blocks > generations[g].max_blocks
+ && stp->is_compacted == 0) {
needed += 2 * stp->n_blocks;
} else {
needed += stp->n_blocks;
#ifdef DEBUG
-extern void
+void
memInventory(void)
{
nat g, s;
total_blocks += stp->n_blocks;
if (RtsFlags.GcFlags.generations == 1) {
/* two-space collector has a to-space too :-) */
- total_blocks += g0s0->to_blocks;
+ total_blocks += g0s0->n_to_blocks;
}
for (bd = stp->large_objects; bd; bd = bd->link) {
total_blocks += bd->blocks;
/* count the blocks on the free list */
free_blocks = countFreeList();
- ASSERT(total_blocks + free_blocks == mblocks_allocated * BLOCKS_PER_MBLOCK);
-
-#if 0
if (total_blocks + free_blocks != mblocks_allocated *
BLOCKS_PER_MBLOCK) {
fprintf(stderr, "Blocks: %ld live + %ld free = %ld total (%ld around)\n",
total_blocks, free_blocks, total_blocks + free_blocks,
mblocks_allocated * BLOCKS_PER_MBLOCK);
}
-#endif
-}
-/* Full heap sanity check. */
+ ASSERT(total_blocks + free_blocks == mblocks_allocated * BLOCKS_PER_MBLOCK);
+}
-extern void
-checkSanity(nat N)
+static nat
+countBlocks(bdescr *bd)
{
- nat g, s;
-
- if (RtsFlags.GcFlags.generations == 1) {
- checkHeap(g0s0->to_space, NULL);
- checkChain(g0s0->large_objects);
- } else {
-
- for (g = 0; g <= N; g++) {
- for (s = 0; s < generations[g].n_steps; s++) {
- if (g == 0 && s == 0) { continue; }
- checkHeap(generations[g].steps[s].blocks, NULL);
- }
+ nat n;
+ for (n=0; bd != NULL; bd=bd->link) {
+ n++;
}
- for (g = N+1; g < RtsFlags.GcFlags.generations; g++) {
- for (s = 0; s < generations[g].n_steps; s++) {
- checkHeap(generations[g].steps[s].blocks,
- generations[g].steps[s].blocks->start);
- checkChain(generations[g].steps[s].large_objects);
- }
+ return n;
+}
+
+/* Full heap sanity check. */
+void
+checkSanity( void )
+{
+ nat g, s;
+
+ if (RtsFlags.GcFlags.generations == 1) {
+ checkHeap(g0s0->to_blocks);
+ checkChain(g0s0->large_objects);
+ } else {
+
+ for (g = 0; g < RtsFlags.GcFlags.generations; g++) {
+ for (s = 0; s < generations[g].n_steps; s++) {
+ if (g == 0 && s == 0) { continue; }
+ checkHeap(generations[g].steps[s].blocks);
+ ASSERT(countBlocks(generations[g].steps[s].blocks)
+ == generations[g].steps[s].n_blocks);
+ checkChain(generations[g].steps[s].large_objects);
+ if (g > 0) {
+ checkMutableList(generations[g].mut_list, g);
+ checkMutOnceList(generations[g].mut_once_list, g);
+ }
+ }
+ }
+ checkFreeListSanity();
}
- checkFreeListSanity();
- }
}
#endif
projects / ghc-hetmet.git / blobdiff