X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=rts%2Fsm%2FGC.c;h=a3611757d8a5222885be6a6f3b9a8e3307817e49;hb=dbbf15c0f141357aa49b583286174867baadb821;hp=fa589059dc176d65c856362390c2ccdbd8b16447;hpb=64d2f63295d25b55056c5c4698fcdb37150fbe05;p=ghc-hetmet.git diff --git a/rts/sm/GC.c b/rts/sm/GC.c index fa58905..a361175 100644 --- a/rts/sm/GC.c +++ b/rts/sm/GC.c @@ -134,7 +134,7 @@ SpinLock recordMutableGen_sync; static void mark_root (StgClosure **root); static void zero_static_object_list (StgClosure* first_static); -static void initialise_N (rtsBool force_major_gc); +static nat initialise_N (rtsBool force_major_gc); static void alloc_gc_threads (void); static void init_collected_gen (nat g, nat threads); static void init_uncollected_gen (nat g, nat threads); @@ -147,6 +147,7 @@ static void gc_thread_work (void); static nat inc_running (void); static nat dec_running (void); static void wakeup_gc_threads (nat n_threads); +static void shutdown_gc_threads (nat n_threads); #if 0 && defined(DEBUG) static void gcCAFs (void); @@ -183,7 +184,7 @@ GarbageCollect ( rtsBool force_major_gc ) lnat live, allocated; lnat oldgen_saved_blocks = 0; gc_thread *saved_gct; - nat g, s, t; + nat g, s, t, n; // necessary if we stole a callee-saves register for gct: saved_gct = gct; @@ -228,7 +229,7 @@ GarbageCollect ( rtsBool force_major_gc ) /* Figure out which generation to collect */ - initialise_N(force_major_gc); + n = initialise_N(force_major_gc); /* Allocate + initialise the gc_thread structures. */ @@ -242,11 +243,13 @@ GarbageCollect ( rtsBool force_major_gc ) * We don't try to parallelise minor GC. */ #if defined(THREADED_RTS) - if (N == 0) { + if (n < (4*1024*1024 / BLOCK_SIZE)) { n_gc_threads = 1; } 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 @@ -265,6 +268,11 @@ GarbageCollect ( rtsBool force_major_gc ) // check stack sanity *before* GC (ToDo: check all threads) IF_DEBUG(sanity, checkFreeListSanity()); + // Initialise all our gc_thread structures + for (t = 0; t < n_gc_threads; t++) { + init_gc_thread(gc_threads[t]); + } + // Initialise all the generations/steps that we're collecting. for (g = 0; g <= N; g++) { init_collected_gen(g,n_gc_threads); @@ -286,16 +294,6 @@ GarbageCollect ( rtsBool force_major_gc ) mark_stack_bdescr = NULL; } - // Initialise all our gc_thread structures - for (t = 0; t < n_gc_threads; t++) { - init_gc_thread(gc_threads[t]); - } - - // the main thread is running: this prevents any other threads from - // exiting prematurely, so we can start them now. - inc_running(); - wakeup_gc_threads(n_gc_threads); - // this is the main thread gct = gc_threads[0]; @@ -307,15 +305,21 @@ GarbageCollect ( rtsBool force_major_gc ) * Also do them in reverse generation order, for the usual reason: * namely to reduce the likelihood of spurious old->new pointers. */ - { - for (g = RtsFlags.GcFlags.generations-1; g > N; g--) { + for (g = RtsFlags.GcFlags.generations-1; g > N; g--) { generations[g].saved_mut_list = generations[g].mut_list; generations[g].mut_list = allocBlock(); - // mut_list always has at least one block. - } - for (g = RtsFlags.GcFlags.generations-1; g > N; g--) { + // mut_list always has at least one block. + } + + // the main thread is running: this prevents any other threads from + // exiting prematurely, so we can start them now. + // NB. do this after the mutable lists have been saved above, otherwise + // the other GC threads will be writing into the old mutable lists. + inc_running(); + wakeup_gc_threads(n_gc_threads); + + for (g = RtsFlags.GcFlags.generations-1; g > N; g--) { scavenge_mutable_list(&generations[g]); - } } // follow roots from the CAF list (used by GHCi) @@ -366,6 +370,8 @@ GarbageCollect ( rtsBool force_major_gc ) break; } + shutdown_gc_threads(n_gc_threads); + // Update pointers from the Task list update_task_list(); @@ -416,22 +422,34 @@ GarbageCollect ( rtsBool force_major_gc ) ws = &thr->steps[s]; // Not true? // ASSERT( ws->scan_bd == ws->todo_bd ); - ASSERT( ws->scan_bd ? ws->scan == ws->scan_bd->free : 1 ); + ASSERT( ws->scan_bd ? ws->scan_bd->u.scan == ws->scan_bd->free : 1 ); // Push the final block - if (ws->scan_bd) { push_scan_block(ws->scan_bd, ws); } + if (ws->scan_bd) { push_scanned_block(ws->scan_bd, ws); } ASSERT(countBlocks(ws->scavd_list) == ws->n_scavd_blocks); - prev = ws->scavd_list; + prev = ws->part_list; + for (bd = ws->part_list; bd != NULL; bd = bd->link) { + bd->flags &= ~BF_EVACUATED; // now from-space + prev = bd; + } + if (prev != NULL) { + prev->link = ws->scavd_list; + } for (bd = ws->scavd_list; bd != NULL; bd = bd->link) { bd->flags &= ~BF_EVACUATED; // now from-space prev = bd; } - prev->link = ws->stp->blocks; - ws->stp->blocks = ws->scavd_list; - ws->stp->n_blocks += ws->n_scavd_blocks; - ASSERT(countBlocks(ws->stp->blocks) == ws->stp->n_blocks); + prev->link = ws->step->blocks; + if (ws->part_list != NULL) { + ws->step->blocks = ws->part_list; + } else { + ws->step->blocks = ws->scavd_list; + } + 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); } } } @@ -455,13 +473,12 @@ GarbageCollect ( rtsBool force_major_gc ) { nat i; for (i=0; i < n_gc_threads; i++) { - if (major_gc) { + if (n_gc_threads > 1) { trace(TRACE_gc,"thread %d:", i); trace(TRACE_gc," copied %ld", gc_threads[i]->copied * sizeof(W_)); trace(TRACE_gc," any_work %ld", gc_threads[i]->any_work); trace(TRACE_gc," no_work %ld", gc_threads[i]->no_work); - trace(TRACE_gc," scav_global_work %ld", gc_threads[i]->scav_global_work); - trace(TRACE_gc," scav_local_work %ld", gc_threads[i]->scav_local_work); + trace(TRACE_gc," scav_find_work %ld", gc_threads[i]->scav_find_work); } copied += gc_threads[i]->copied; } @@ -655,7 +672,7 @@ GarbageCollect ( rtsBool force_major_gc ) IF_DEBUG(sanity, checkSanity()); // extra GC trace info - if (traceClass(TRACE_gc)) statDescribeGens(); + if (traceClass(TRACE_gc|DEBUG_gc)) statDescribeGens(); #ifdef DEBUG // symbol-table based profiling @@ -901,27 +918,44 @@ isAlive(StgClosure *p) /* ----------------------------------------------------------------------------- Figure out which generation to collect, initialise N and major_gc. + + Also returns the total number of blocks in generations that will be + collected. -------------------------------------------------------------------------- */ -static void +static nat initialise_N (rtsBool force_major_gc) { - nat g; + int g; + nat s, blocks, blocks_total; + + blocks = 0; + blocks_total = 0; if (force_major_gc) { - N = RtsFlags.GcFlags.generations - 1; - major_gc = rtsTrue; + N = RtsFlags.GcFlags.generations - 1; } else { - N = 0; - for (g = 0; g < RtsFlags.GcFlags.generations; g++) { - if (generations[g].steps[0].n_blocks + - generations[g].steps[0].n_large_blocks - >= generations[g].max_blocks) { - N = g; - } - } - major_gc = (N == RtsFlags.GcFlags.generations-1); + N = 0; } + + 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_large_blocks; + } + if (blocks >= generations[g].max_blocks) { + N = stg_max(N,g); + } + if ((nat)g <= N) { + blocks_total += blocks; + } + } + + blocks_total += countNurseryBlocks(); + + major_gc = (N == RtsFlags.GcFlags.generations-1); + return blocks_total; } /* ----------------------------------------------------------------------------- @@ -959,16 +993,18 @@ alloc_gc_thread (int n) for (s = 0; s < total_steps; s++) { ws = &t->steps[s]; - ws->stp = &all_steps[s]; - ASSERT(s == ws->stp->abs_no); + ws->step = &all_steps[s]; + ASSERT(s == ws->step->abs_no); ws->gct = t; ws->scan_bd = NULL; - ws->scan = NULL; ws->todo_bd = NULL; ws->buffer_todo_bd = NULL; + ws->part_list = NULL; + ws->n_part_blocks = 0; + ws->scavd_list = NULL; ws->n_scavd_blocks = 0; } @@ -1016,6 +1052,7 @@ inc_running (void) ACQUIRE_LOCK(&gc_running_mutex); n_running = ++gc_running_threads; RELEASE_LOCK(&gc_running_mutex); + ASSERT(n_running <= n_gc_threads); return n_running; } @@ -1024,6 +1061,7 @@ dec_running (void) { nat n_running; ACQUIRE_LOCK(&gc_running_mutex); + ASSERT(n_gc_threads != 0); n_running = --gc_running_threads; RELEASE_LOCK(&gc_running_mutex); return n_running; @@ -1082,13 +1120,13 @@ gc_thread_mainloop (void) // Wait until we're told to wake up ACQUIRE_LOCK(&gct->wake_mutex); + gct->wakeup = rtsFalse; while (!gct->wakeup) { debugTrace(DEBUG_gc, "GC thread %d standing by...", gct->thread_index); waitCondition(&gct->wake_cond, &gct->wake_mutex); } RELEASE_LOCK(&gct->wake_mutex); - gct->wakeup = rtsFalse; if (gct->exit) break; #ifdef USE_PAPI @@ -1157,6 +1195,26 @@ wakeup_gc_threads (nat n_threads USED_IF_THREADS) #endif } +// After GC is complete, we must wait for all GC threads to enter the +// standby state, otherwise they may still be executing inside +// any_work(), and may even remain awake until the next GC starts. +static void +shutdown_gc_threads (nat n_threads USED_IF_THREADS) +{ +#if defined(THREADED_RTS) + nat i; + rtsBool wakeup; + for (i=1; i < n_threads; i++) { + do { + ACQUIRE_LOCK(&gc_threads[i]->wake_mutex); + wakeup = gc_threads[i]->wakeup; + // wakeup is false while the thread is waiting + RELEASE_LOCK(&gc_threads[i]->wake_mutex); + } while (wakeup); + } +#endif +} + /* ---------------------------------------------------------------------------- Initialise a generation that is to be collected ------------------------------------------------------------------------- */ @@ -1260,15 +1318,17 @@ init_collected_gen (nat g, nat n_threads) ws = &gc_threads[t]->steps[g * RtsFlags.GcFlags.steps + s]; ws->scan_bd = NULL; - ws->scan = NULL; ws->todo_large_objects = NULL; + ws->part_list = NULL; + ws->n_part_blocks = 0; + // allocate the first to-space block; extra blocks will be // chained on as necessary. ws->todo_bd = NULL; ws->buffer_todo_bd = NULL; - gc_alloc_todo_block(ws); + alloc_todo_block(ws,0); ws->scavd_list = NULL; ws->n_scavd_blocks = 0; @@ -1299,11 +1359,14 @@ init_uncollected_gen (nat g, nat threads) for (s = 0; s < generations[g].n_steps; s++) { ws = &gc_threads[t]->steps[g * RtsFlags.GcFlags.steps + s]; - stp = ws->stp; + stp = ws->step; ws->buffer_todo_bd = NULL; ws->todo_large_objects = NULL; + ws->part_list = NULL; + ws->n_part_blocks = 0; + ws->scavd_list = NULL; ws->n_scavd_blocks = 0; @@ -1321,7 +1384,7 @@ init_uncollected_gen (nat g, nat threads) // this block is also the scan block; we must scan // from the current end point. ws->scan_bd = ws->todo_bd; - ws->scan = ws->scan_bd->free; + ws->scan_bd->u.scan = ws->scan_bd->free; // subtract the contents of this block from the stats, // because we'll count the whole block later. @@ -1330,9 +1393,8 @@ init_uncollected_gen (nat g, nat threads) else { ws->scan_bd = NULL; - ws->scan = NULL; ws->todo_bd = NULL; - gc_alloc_todo_block(ws); + alloc_todo_block(ws,0); } } } @@ -1366,8 +1428,7 @@ init_gc_thread (gc_thread *t) t->copied = 0; t->any_work = 0; t->no_work = 0; - t->scav_global_work = 0; - t->scav_local_work = 0; + t->scav_find_work = 0; }