X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=rts%2Fsm%2FStorage.c;h=b76fcf450b9216dc7b76c4b1c1d71561bca67195;hb=a7f2a897bab20f05d4cf5fc8cdae328698c7fc82;hp=a07685b25e89c26762f8d9e5435d22718b6092c5;hpb=06f9b7c365fb9e9b53723f892b4d63b4f7a56e9a;p=ghc-hetmet.git diff --git a/rts/sm/Storage.c b/rts/sm/Storage.c index a07685b..b76fcf4 100644 --- a/rts/sm/Storage.c +++ b/rts/sm/Storage.c @@ -1,6 +1,6 @@ /* ----------------------------------------------------------------------------- * - * (c) The GHC Team, 1998-2006 + * (c) The GHC Team, 1998-2008 * * Storage manager front end * @@ -30,7 +30,7 @@ #include "OSMem.h" #include "Trace.h" #include "GC.h" -#include "GCUtils.h" +#include "Evac.h" #include #include @@ -51,6 +51,9 @@ generation *g0 = NULL; /* generation 0, for convenience */ generation *oldest_gen = NULL; /* oldest generation, for convenience */ step *g0s0 = NULL; /* generation 0, step 0, for convenience */ +nat total_steps = 0; +step *all_steps = NULL; /* single array of steps */ + ullong total_allocated = 0; /* total memory allocated during run */ nat n_nurseries = 0; /* == RtsFlags.ParFlags.nNodes, convenience */ @@ -80,8 +83,10 @@ static void initStep (step *stp, int g, int s) { stp->no = s; + stp->abs_no = RtsFlags.GcFlags.steps * g + s; stp->blocks = NULL; stp->n_blocks = 0; + stp->n_words = 0; stp->old_blocks = NULL; stp->n_old_blocks = 0; stp->gen = &generations[g]; @@ -96,6 +101,8 @@ initStep (step *stp, int g, int s) initSpinLock(&stp->sync_todo); initSpinLock(&stp->sync_large_objects); #endif + stp->threads = END_TSO_QUEUE; + stp->old_threads = END_TSO_QUEUE; } void @@ -103,7 +110,6 @@ initStorage( void ) { nat g, s; generation *gen; - step *step_arr; if (generations != NULL) { // multi-init protection @@ -151,10 +157,9 @@ initStorage( void ) it this way, because we need the invariant that two step pointers can be directly compared to see which is the oldest. Remember that the last generation has only one step. */ - step_arr = stgMallocBytes(sizeof(struct step_) - * (1 + ((RtsFlags.GcFlags.generations - 1) - * RtsFlags.GcFlags.steps)), - "initStorage: steps"); + total_steps = 1 + (RtsFlags.GcFlags.generations - 1) * RtsFlags.GcFlags.steps; + all_steps = stgMallocBytes(total_steps * sizeof(struct step_), + "initStorage: steps"); /* Initialise all generations */ for(g = 0; g < RtsFlags.GcFlags.generations; g++) { @@ -162,6 +167,7 @@ initStorage( void ) gen->no = g; gen->mut_list = allocBlock(); gen->collections = 0; + gen->par_collections = 0; gen->failed_promotions = 0; gen->max_blocks = 0; } @@ -176,19 +182,19 @@ initStorage( void ) /* Oldest generation: one step */ oldest_gen->n_steps = 1; - oldest_gen->steps = step_arr + (RtsFlags.GcFlags.generations - 1) + oldest_gen->steps = all_steps + (RtsFlags.GcFlags.generations - 1) * RtsFlags.GcFlags.steps; /* set up all except the oldest generation with 2 steps */ for(g = 0; g < RtsFlags.GcFlags.generations-1; g++) { generations[g].n_steps = RtsFlags.GcFlags.steps; - generations[g].steps = step_arr + g * RtsFlags.GcFlags.steps; + generations[g].steps = all_steps + g * RtsFlags.GcFlags.steps; } } else { /* single generation, i.e. a two-space collector */ g0->n_steps = 1; - g0->steps = step_arr; + g0->steps = all_steps; } #ifdef THREADED_RTS @@ -256,6 +262,8 @@ initStorage( void ) #ifdef THREADED_RTS initSpinLock(&gc_alloc_block_sync); + initSpinLock(&recordMutableGen_sync); + whitehole_spin = 0; #endif IF_DEBUG(gc, statDescribeGens()); @@ -545,6 +553,22 @@ resizeNurseries (nat blocks) resizeNurseriesFixed(blocks / n_nurseries); } + +/* ----------------------------------------------------------------------------- + move_TSO is called to update the TSO structure after it has been + moved from one place to another. + -------------------------------------------------------------------------- */ + +void +move_TSO (StgTSO *src, StgTSO *dest) +{ + ptrdiff_t diff; + + // relocate the stack pointer... + diff = (StgPtr)dest - (StgPtr)src; // In *words* + dest->sp = (StgPtr)dest->sp + diff; +} + /* ----------------------------------------------------------------------------- The allocate() interface @@ -633,6 +657,34 @@ allocatedBytes( void ) return allocated; } +// split N blocks off the start of the given bdescr, returning the +// remainder as a new block group. We treat the remainder as if it +// had been freshly allocated in generation 0. +bdescr * +splitLargeBlock (bdescr *bd, nat blocks) +{ + bdescr *new_bd; + + // subtract the original number of blocks from the counter first + bd->step->n_large_blocks -= bd->blocks; + + new_bd = splitBlockGroup (bd, blocks); + + dbl_link_onto(new_bd, &g0s0->large_objects); + g0s0->n_large_blocks += new_bd->blocks; + new_bd->gen_no = g0s0->no; + new_bd->step = g0s0; + new_bd->flags = BF_LARGE; + new_bd->free = bd->free; + + // add the new number of blocks to the counter. Due to the gaps + // for block descriptor, new_bd->blocks + bd->blocks might not be + // equal to the original bd->blocks, which is why we do it this way. + bd->step->n_large_blocks += bd->blocks; + + return new_bd; +} + /* ----------------------------------------------------------------------------- allocateLocal() @@ -788,6 +840,35 @@ dirty_MUT_VAR(StgRegTable *reg, StgClosure *p) } } +// Setting a TSO's link field with a write barrier. +// It is *not* necessary to call this function when +// * setting the link field to END_TSO_QUEUE +// * putting a TSO on the blackhole_queue +// * setting the link field of the currently running TSO, as it +// will already be dirty. +void +setTSOLink (Capability *cap, StgTSO *tso, StgTSO *target) +{ + bdescr *bd; + if ((tso->flags & (TSO_DIRTY|TSO_LINK_DIRTY)) == 0) { + tso->flags |= TSO_LINK_DIRTY; + bd = Bdescr((StgPtr)tso); + if (bd->gen_no > 0) recordMutableCap((StgClosure*)tso,cap,bd->gen_no); + } + tso->_link = target; +} + +void +dirty_TSO (Capability *cap, StgTSO *tso) +{ + bdescr *bd; + if ((tso->flags & (TSO_DIRTY|TSO_LINK_DIRTY)) == 0) { + bd = Bdescr((StgPtr)tso); + if (bd->gen_no > 0) recordMutableCap((StgClosure*)tso,cap,bd->gen_no); + } + tso->flags |= TSO_DIRTY; +} + /* This is the write barrier for MVARs. An MVAR_CLEAN objects is not on the mutable list; a MVAR_DIRTY is. When written to, a @@ -966,7 +1047,7 @@ calcLiveWords(void) step *stp; if (RtsFlags.GcFlags.generations == 1) { - return countOccupied(g0s0->blocks) + countOccupied(g0s0->large_objects); + return g0s0->n_words + countOccupied(g0s0->large_objects); } live = 0; @@ -974,8 +1055,7 @@ calcLiveWords(void) for (s = 0; s < generations[g].n_steps; s++) { if (g == 0 && s == 0) continue; stp = &generations[g].steps[s]; - live += countOccupied(stp->blocks) + - countOccupied(stp->large_objects); + live += stp->n_words + countOccupied(stp->large_objects); } } return live; @@ -1228,6 +1308,9 @@ memInventory (rtsBool show) #define MB(n) (((n) * BLOCK_SIZE_W) / ((1024*1024)/sizeof(W_))) leak = live_blocks + free_blocks != mblocks_allocated * BLOCKS_PER_MBLOCK; + + ASSERT(n_alloc_blocks == live_blocks); + if (show || leak) { if (leak) {