GitLab

We were looking at all the threads for 2 reasons:
 1. to catch transactions that might be looping as a
    result of seeing an inconsistent view of memory.
 2. to catch threads with blocked exceptions that are
    themselves blocked.
For (1) we now check for this case whenever a thread yields, and for
(2) we catch these threads in the GC itself and send the exceptions
after GC (see performPendingThrowTos).

Instead of keeping a single list of all threads, keep one per step
and only look at the threads belonging to steps that we are
collecting.

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.

further attempt to fix #1391 on MacOS

Patch from Audrey Tang.

Having a timer signal go off regularly is bad for power consumption,
and generally bad practice anyway (it means the app cannot be
completely swapped out, for example).  Fortunately the threaded RTS
already had a way to detect when the system was idle, so that it can
trigger a GC and thereby find deadlocks.  After performing the GC, we
now turn off timer signals, and re-enable them again just before
running any Haskell code.

This is pertinent to #1177.  When shutting down a DLL, we need to be
sure that there are no OS threads that can return to the code that we
are about to unload, and previously the threaded RTS was unsafe in
this respect.

When exiting a standalone program we don't have to be quite so
paranoid: all the code will disappear at the same time as any running
threads.  Happily exiting a program happens via a different path:
shutdownHaskellAndExit().  If we're about to exit(), then there's no
need to wait for foreign calls to complete.

We needed to turn some inline C functions and C macros into either
real C functions or C-- macros.

We never want to raise a StackOverflow exception inside
Control.Exception.block, because the user has no reasonable way of
handling it, and it invalidates some useful guarantees.

Now that constructor info tables contain the name of the constructor,
we can generate useful heap profiles without requiring the whole
program and libraries to be compiled with -prof.  So now, "+RTS -hT"
generates a heap profile for any program, dividing the profile by
constructor.  It wouldn't be hard to add support for grouping
constructors by module, or to restrict the profile to certain
constructors/modules/packages.

This means that for the first time we can get heap profiles for GHCi,
which was previously impossible because the byte-code
interpreter and linker don't work with -prof.

Similarly to the way we save errno across context switches and
suspendThread/resumeThread, we must save and restore the Win32 error
code via GetLastError()/SetLastError().  Fixes #896.

Also move closeMutex() etc. into freeTaskManager, this is a free-ish thing

We were freeing the tasks in exitScheduler (stopTaskManager) before
exitStorage (stat_exit), but the latter needs to walk down the list
printing stats. Resulted in segfaults with commands like
    ghc -v0 -e main q.hs -H32m -H32m +RTS -Sstderr
(where q.hs is trivial), but very sensitive to exact commandline and
libc version or something.

Fixes #637.
The implications of this change are:
  - threadDelay on Windows no longer creates a new OS thread each time,
    instead it communicates with the IO manager thread in the same way as
    on Unix.
  - deadlock detection now works the same way on Windows as on Unix; that
    is the timer interrupt wakes up the IO manager thread, which causes
    the scheduler to check for deadlock.
  - Console events now get sent to the IO manager thread, in the same way as
    signals do on Unix.  This means that console events should behave more
    reliably with -threaded on Windows.

All this applies only with -threaded.  Without -threaded, the old
ConsoleEvent code is still used.

After some testing, this could be pushed to the 6.6 branch.

In preparation for parallel GC, split up the monolithic GC.c file into
smaller parts.  Also in this patch (and difficult to separate,
unfortunatley):
  
  - Don't include Stable.h in Rts.h, instead just include it where
    necessary.
  
  - consistently use STATIC_INLINE in source files, and INLINE_HEADER
    in header files.  STATIC_INLINE is now turned off when DEBUG is on,
    to make debugging easier.
  
  - The GC no longer takes the get_roots function as an argument.
    We weren't making use of this generalisation.

I don't think this can ever be useful, because to add more roots you
need to do it consistently for every GC.  The right way to add roots
is to use newStablePtr.

Fixed version of an old patch by Simon Marlow. His description read:
 Also, now an arbitrarily short context switch interval may now be
 specified, as we increase the RTS ticker's resolution to match the
 requested context switch interval.  This also applies to +RTS -i (heap
 profiling) and +RTS -I (the idle GC timer).  +RTS -V is actually only
 required for increasing the resolution of the profile timer.