free empty blocks at the end of GC

move the scan block pointer into the gct structure

improvements to +RTS -s output
- count and report number of parallel collections
- calculate bytes scanned in addition to bytes copied per thread
- calculate "work balance factor"
- tidy up the formatting a bit

wait for threads to start up properly

debug output tweaks

Keep track of an accurate count of live words in each step
This means we can calculate slop easily, and also improve
predictability of GC.

Allow work units smaller than a block to improve load balancing

in scavenge_block1(), we can use the lock-free recordMutableGen()

update the debug counters following changes to scav_find_work()

change the find-work strategy: use oldest-first consistently

per-thread debug output when using multiple threads, not just major gc

small debug output improvements

allow parallel minor collections too

Specialise evac/scav for single-threaded, not minor, GC
So we can parallelise minor collections too.  Sometimes it's worth it.

move usleep(1) to gc_thread_work() from any_work()

use RTS_VAR()

treat the global work list as a queue rather than a stack

GC: move static object processinng into thread-local storage

tmp: usleep(1) during anyWork() if no work

anyWork(): count the number of times we don't find any work

stats fixes

Add +RTS -vg flag for requesting some GC trace messages, outside DEBUG
DEBUG imposes a significant performance hit in the GC, yet we often
want some of the debugging output, so -vg gives us the cheap trace
messages without the sanity checking of DEBUG, just like -vs for the
scheduler.

GC: rearrange storage to reduce memory accesses in the inner loop

Add profiling of spinlocks

rename StgSync to SpinLock

Release some of the memory allocated to a stack when it shrinks (#2090)
When a stack is occupying less than 1/4 of the memory it owns, and is
larger than a megablock, we release half of it.  Shrinking is O(1), it
doesn't need to copy the stack.

scavengeTSO might encounter a ThreadRelocated; cope

Updating a thunk in raiseAsync might encounter an IND; cope
There was already a check to avoid updating an IND, but it was
originally there to avoid a bug which doesn't exist now.  Furthermore
the test and update are not atomic, so another thread could be
updating this thunk while we are.  We have to just go ahead and update
anyway - it might waste a little work, but this is a very rare case.

add GC(0) and GC(1) time

round_to_mblocks: should use StgWord not nat

debugging code

refactoring

fix off-by-one

measure mut_elapsed_time

fix build with 6.8

add ROUNDUP_BYTES_TO_WDS

Allow +RTS -H0 as a way to override a previous -H<size>

comment out a bogus assertion

memInventory: optionally dump the memory inventory
in addition to checking for leaks

calcNeeded: fix the calculation, we weren't counting G0 step 1

calcNeeded: add in the large blocks too

update a comment

tell Emacs these files are C

fix an assertion

cut-and-pasto

small rearrangement

recordMutableGen_GC: we must call the spinlocked version of allocBlock()

remove unused declaration

more fixes for THUNK_SELECTORs

Fix bug in eval_thunk_selector()

move markSparkQueue into GC.c, as it needs the register variable defined

Windows fix

Fix bug: eval_thunk_selector was calling the unlocked evacuate()

add GC elapsed time

update to match Mb -> MB change in -s output

use "MB" rather than "Mb" for abbreviating megabytes

findSlop: useful function for tracking down excessive slop in gdb

calculate wastage due to unused memory at the end of each block

bugfix: check for NULL before testing isPartiallyFull(stp->blocks)

have each GC thread call GetRoots()

use synchronised version of freeChain() in scavenge_mutable_list()

remove declarations for variables that no longer exist

remove old comment

GC: small improvement to parallelism
don't cache a work block locally if the global queue is empty

EVACUATED: target is definitely HEAP_ALLOCED(), no need to check

in scavenge_block(), keep going if we're scanning the todo block

count the number of todo blocks, and add a trace

oops, restore accidentally disabled hash-consing for Char

kill the PAR/GRAN debug flags

stats: print elapsed time for GC in each generation

assertion fix

cache bd->todo_bd->free and the limit in the workspace
avoids cache contention: bd->todo_bd->free may clash with any cache
line, so we localise it.

warning fix

fix boundary bugs in a couple of for-loops

improvements to PAPI support
- major (multithreaded) GC is measured separately from minor GC
- events to measure can now be specified on the command line, e.g
     prog +RTS -a+PAPI_TOT_CYC

use SRC_CC_OPTS rather than SRC_HC_OPTS for C options

allow PAPI to be installed somewhere non-standard

fix warnings

fix a warning

fix a warning

rename n_threads to n_gc_threads

Refactor PAPI support, and add profiling of multithreaded GC

fix merge errors

refactoring of eager_promotion in scavenge_block()

compile special minor GC versions of evacuate() and scavenge_block()

This is for two reasons: minor GCs don't need to do per-object locking
for parallel GC, which is fairly expensive, and secondly minor GCs
don't need to follow SRTs.

fixes for eval_thunk_selector() in parallel GC

Remove the optimisation of avoiding scavenging for certain objects

Some objects don't need to be scavenged, in particular if they have no
pointers.  This seems like an obvious optimisation, but in fact it
only accounts for about 1% of objects (in GHC, for example), and the
extra complication means it probably isn't worth doing.

GC refactoring: change evac_gen to evac_step

By establishing an ordering on step pointers, we can simplify the test
  (stp->gen_no < evac_gen)
to
  (stp < evac_step)
which is common in evacuate().

GC refactoring: make evacuate() take an StgClosure**

Change the type of evacuate() from
  StgClosure *evacuate(StgClosure *);
to
  void evacuate(StgClosure **);

So evacuate() itself writes the source pointer, rather than the
caller.  This is slightly cleaner, and avoids a few memory writes:
sometimes evacuate() doesn't move the object, and in these cases the
source pointer doesn't need to be written.  It doesn't have a
measurable impact on performance, though.

tiny optimisation in evacuate()

Initial parallel GC support

eg. use +RTS -g2 -RTS for 2 threads.  Only major GCs are parallelised,
minor GCs are still sequential. Don't use more threads than you
have CPUs.

It works most of the time, although you won't see much speedup yet.
Tuning and more work on stability still required.

Refactoring of the GC in preparation for parallel GC

This patch localises the state of the GC into a gc_thread structure,
and reorganises the inner loop of the GC to scavenge one block at a
time from global work lists in each "step".  The gc_thread structure
has a "workspace" for each step, in which it collects evacuated
objects until it has a full block to push out to the step's global
list.  Details of the algorithm will be on the wiki in due course.

At the moment, THREADED_RTS does not compile, but the single-threaded
GC works (and is 10-20% slower than before).

also count total dispatch stalls in +RTS -as

move GetRoots() to GC.c

Tweak a comment to talk about UnboxedTuples rather than -fglasgow-exts

Suggest -XRelaxedPolyRec rather than -fglasgow-exts in an error message

Fix the splitter with perl 5.10; patch from Audrey Tang

Remove some build system code that can't happen
ghc_ge_601 is no longer defined

Fix Trac #2358: 1-tuples in Template Haskell

fons points out that TH was treating 1-tuples inconsistently.  Generally
we make a 1-tuple into a no-op, so that (e) and e are the same.  But
I'd forgotten to do this for types.

It is possible to have a type with an un-saturated 1-tuple type
constructor. That now elicits an error message when converting from
TH syntax to Hs syntax

Fix nasty Simplifier scoping bug

This bug was somehow tickled by the new code for desugaring
polymorphic bindings, but the bug has been there a long time.  The
bindings floated out in simplLazyBind, generated by abstractFloats,
were getting processed by postInlineUnconditionally. But that was
wrong because part of their scope has already been processed.

That led to a bit of refactoring in the simplifier.  See comments
with Simplify.addPolyBind.

In principle this might happen in 6.8.3, but in practice it doesn't seem
to, so probably not worth merging.