Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Commits on Dec 15, 2010
  1. @simonmar

    Implement stack chunks and separate TSO/STACK objects

    simonmar authored
    This patch makes two changes to the way stacks are managed:
    
    1. The stack is now stored in a separate object from the TSO.
    
    This means that it is easier to replace the stack object for a thread
    when the stack overflows or underflows; we don't have to leave behind
    the old TSO as an indirection any more.  Consequently, we can remove
    ThreadRelocated and deRefTSO(), which were a pain.
    
    This is obviously the right thing, but the last time I tried to do it
    it made performance worse.  This time I seem to have cracked it.
    
    2. Stacks are now represented as a chain of chunks, rather than
       a single monolithic object.
    
    The big advantage here is that individual chunks are marked clean or
    dirty according to whether they contain pointers to the young
    generation, and the GC can avoid traversing clean stack chunks during
    a young-generation collection.  This means that programs with deep
    stacks will see a big saving in GC overhead when using the default GC
    settings.
    
    A secondary advantage is that there is much less copying involved as
    the stack grows.  Programs that quickly grow a deep stack will see big
    improvements.
    
    In some ways the implementation is simpler, as nothing special needs
    to be done to reclaim stack as the stack shrinks (the GC just recovers
    the dead stack chunks).  On the other hand, we have to manage stack
    underflow between chunks, so there's a new stack frame
    (UNDERFLOW_FRAME), and we now have separate TSO and STACK objects.
    The total amount of code is probably about the same as before.
    
    There are new RTS flags:
    
       -ki<size> Sets the initial thread stack size (default 1k)  Egs: -ki4k -ki2m
       -kc<size> Sets the stack chunk size (default 32k)
       -kb<size> Sets the stack chunk buffer size (default 1k)
    
    -ki was previously called just -k, and the old name is still accepted
    for backwards compatibility.  These new options are documented.
Commits on Jul 13, 2010
  1. @igfoo

    Change some TARGET tests to HOST tests in the RTS

    igfoo authored
    Which was being used seemed to be random
Commits on Apr 7, 2010
  1. @simonmar
Commits on Apr 1, 2010
  1. @simonmar

    Remove the IND_OLDGEN and IND_OLDGEN_PERM closure types

    simonmar authored
    These are no longer used: once upon a time they used to have different
    layout from IND and IND_PERM respectively, but that is no longer the
    case since we changed the remembered set to be an array of addresses
    instead of a linked list of closures.
  2. @simonmar

    Change the representation of the MVar blocked queue

    simonmar authored
    The list of threads blocked on an MVar is now represented as a list of
    separately allocated objects rather than being linked through the TSOs
    themselves.  This lets us remove a TSO from the list in O(1) time
    rather than O(n) time, by marking the list object.  Removing this
    linear component fixes some pathalogical performance cases where many
    threads were blocked on an MVar and became unreachable simultaneously
    (nofib/smp/threads007), or when sending an asynchronous exception to a
    TSO in a long list of thread blocked on an MVar.
    
    MVar performance has actually improved by a few percent as a result of
    this change, slightly to my surprise.
    
    This is the final cleanup in the sequence, which let me remove the old
    way of waking up threads (unblockOne(), MSG_WAKEUP) in favour of the
    new way (tryWakeupThread and MSG_TRY_WAKEUP, which is idempotent).  It
    is now the case that only the Capability that owns a TSO may modify
    its state (well, almost), and this simplifies various things.  More of
    the RTS is based on message-passing between Capabilities now.
Commits on Mar 29, 2010
  1. @simonmar
  2. @simonmar

    New implementation of BLACKHOLEs

    simonmar authored
    This replaces the global blackhole_queue with a clever scheme that
    enables us to queue up blocked threads on the closure that they are
    blocked on, while still avoiding atomic instructions in the common
    case.
    
    Advantages:
    
     - gets rid of a locked global data structure and some tricky GC code
       (replacing it with some per-thread data structures and different
       tricky GC code :)
    
     - wakeups are more prompt: parallel/concurrent performance should
       benefit.  I haven't seen anything dramatic in the parallel
       benchmarks so far, but a couple of threading benchmarks do improve
       a bit.
    
     - waking up a thread blocked on a blackhole is now O(1) (e.g. if
       it is the target of throwTo).
    
     - less sharing and better separation of Capabilities: communication
       is done with messages, the data structures are strictly owned by a
       Capability and cannot be modified except by sending messages.
    
     - this change will utlimately enable us to do more intelligent
       scheduling when threads block on each other.  This is what started
       off the whole thing, but it isn't done yet (#3838).
    
    I'll be documenting all this on the wiki in due course.
Commits on Mar 11, 2010
  1. @simonmar

    Use message-passing to implement throwTo in the RTS

    simonmar authored
    This replaces some complicated locking schemes with message-passing
    in the implementation of throwTo. The benefits are
    
     - previously it was impossible to guarantee that a throwTo from
       a thread running on one CPU to a thread running on another CPU
       would be noticed, and we had to rely on the GC to pick up these
       forgotten exceptions. This no longer happens.
    
     - the locking regime is simpler (though the code is about the same
       size)
    
     - threads can be unblocked from a blocked_exceptions queue without
       having to traverse the whole queue now.  It's a rare case, but
       replaces an O(n) operation with an O(1).
    
     - generally we move in the direction of sharing less between
       Capabilities (aka HECs), which will become important with other
       changes we have planned.
    
    Also in this patch I replaced several STM-specific closure types with
    a generic MUT_PRIM closure type, which allowed a lot of code in the GC
    and other places to go away, hence the line-count reduction.  The
    message-passing changes resulted in about a net zero line-count
    difference.
Commits on Nov 14, 2009
  1. If a comment says "Is this correct?", it's not.

    Ben.Lippmeier@anu.edu.au authored
  2. Don't share low valued Int and Char closures with Windows DLLs

    Ben.Lippmeier@anu.edu.au authored
Commits on Jun 2, 2009
  1. @simonmar

    Remove old GUM/GranSim code

    simonmar authored
Commits on Dec 10, 2008
  1. @simonmar

    FIX #1364: added support for C finalizers that run as soon as the val…

    simonmar authored
    …ue is not longer reachable.
    
      
    Patch originally by Ivan Tomac <tomac@pacific.net.au>, amended by
    Simon Marlow:
    
      - mkWeakFinalizer# commoned up with mkWeakFinalizerEnv#
      - GC parameters to ALLOC_PRIM fixed
Commits on Nov 18, 2008
  1. @simonmar

    Add optional eager black-holing, with new flag -feager-blackholing

    simonmar authored
    Eager blackholing can improve parallel performance by reducing the
    chances that two threads perform the same computation.  However, it
    has a cost: one extra memory write per thunk entry.  
    
    To get the best results, any code which may be executed in parallel
    should be compiled with eager blackholing turned on.  But since
    there's a cost for sequential code, we make it optional and turn it on
    for the parallel package only.  It might be a good idea to compile
    applications (or modules) with parallel code in with
    -feager-blackholing.
    
    ToDo: document -feager-blackholing.
Commits on Aug 6, 2008
  1. @igfoo
Commits on Aug 5, 2008
  1. @igfoo
Commits on Apr 17, 2008
Commits on Apr 16, 2008
  1. Add a write barrier to the TSO link field (#1589)

    Simon Marlow authored
Commits on Apr 2, 2008
  1. Do not #include external header files when compiling via C

    Simon Marlow authored
    This has several advantages:
    
     - -fvia-C is consistent with -fasm with respect to FFI declarations:
       both bind to the ABI, not the API.
    
     - foreign calls can now be inlined freely across module boundaries, since
       a header file is not required when compiling the call.
    
     - bootstrapping via C will be more reliable, because this difference
       in behavour between the two backends has been removed.
    
    There is one disadvantage:
    
     - we get no checking by the C compiler that the FFI declaration
       is correct.
    
    So now, the c-includes field in a .cabal file is always ignored by
    GHC, as are header files specified in an FFI declaration.  This was
    previously the case only for -fasm compilations, now it is also the
    case for -fvia-C too.
Commits on Oct 31, 2007
  1. Initial parallel GC support

    Simon Marlow authored
    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.
Commits on Oct 11, 2007
  1. Add a proper write barrier for MVars

    Simon Marlow authored
    Previously MVars were always on the mutable list of the old
    generation, which meant every MVar was visited during every minor GC.
    With lots of MVars hanging around, this gets expensive.  We addressed
    this problem for MUT_VARs (aka IORefs) a while ago, the solution is to
    use a traditional GC write-barrier when the object is modified.  This
    patch does the same thing for MVars.
    
    TVars are still done the old way, they could probably benefit from the
    same treatment too.
Commits on Sep 5, 2007
  1. @mchakravarty
Commits on Sep 4, 2007
  1. put the @N suffix on stdcall foreign calls in .cmm code

    Simon Marlow authored
    This applies to EnterCriticalSection and LeaveCriticalSection in the RTS
Commits on Aug 29, 2007
  1. Windows: remove the {Enter,Leave}CricialSection wrappers

    Simon Marlow authored
    The C-- parser was missing the "stdcall" calling convention for
    foreign calls, but once added we can call {Enter,Leave}CricialSection
    directly.
Commits on Aug 20, 2007
  1. annotate C-- calls that do not return

    Norman Ramsey authored
      * The correct definition of C-- requires that a procedure not
        'fall off the end'.  The 'never returns' annotation tells us
        if a (foreign) call is not going to return.
    
        Validated!
Commits on Aug 10, 2007
  1. @clefru

    Properly guard imports because they have to be precise on Windows and…

    clefru authored
    … Darwin sets __PIC__ automatically
Commits on Aug 8, 2007
  1. @clefru

    Build RTS as dynamic library

    clefru authored
Commits on Aug 6, 2007
  1. @clefru
Commits on Jul 27, 2007
  1. Pointer Tagging

    Simon Marlow authored
      
    This patch implements pointer tagging as per our ICFP'07 paper "Faster
    laziness using dynamic pointer tagging".  It improves performance by
    10-15% for most workloads, including GHC itself.
    
    The original patches were by Alexey Rodriguez Yakushev
    <mrchebas@gmail.com>, with additions and improvements by me.  I've
    re-recorded the development as a single patch.
    
    The basic idea is this: we use the low 2 bits of a pointer to a heap
    object (3 bits on a 64-bit architecture) to encode some information
    about the object pointed to.  For a constructor, we encode the "tag"
    of the constructor (e.g. True vs. False), for a function closure its
    arity.  This enables some decisions to be made without dereferencing
    the pointer, which speeds up some common operations.  In particular it
    enables us to avoid costly indirect jumps in many cases.
    
    More information in the commentary:
    
    http://hackage.haskell.org/trac/ghc/wiki/Commentary/Rts/HaskellExecution/PointerTagging
Commits on Jun 27, 2007
  1. Implemented and fixed bugs in CmmInfo handling

    Michael D. Adams authored
Commits on Feb 28, 2007
  1. Remove vectored returns.

    Simon Marlow authored
    We recently discovered that they aren't a win any more, and just cost
    code size.
Commits on Feb 7, 2007
  1. @catamorphism

    Lightweight ticky-ticky profiling

    catamorphism authored
    The following changes restore ticky-ticky profiling to functionality
    from its formerly bit-rotted state. Sort of. (It got bit-rotted as part
    of the switch to the C-- back-end.)
    
    The way that ticky-ticky is supposed to work is documented in Section 5.7
    of the GHC manual (though the manual doesn't mention that it hasn't worked
    since sometime around 6.0, alas). Changes from this are as follows (which
    I'll document on the wiki):
    
    * In the past, you had to build all of the libraries with way=t in order to
    use ticky-ticky, because it entailed a different closure layout. No longer.
    You still need to do make way=t in rts/ in order to build the ticky RTS,
    but you should now be able to mix ticky and non-ticky modules.
    
    * Some of the counters that worked in the past aren't implemented yet.
    I was originally just trying to get entry counts to work, so those should
    be correct. The list of counters was never documented in the first place,
    so I hope it's not too much of a disaster that some don't appear anymore.
    Someday, someone (perhaps me) should document all the counters and what 
    they do. For now, all of the counters are either accurate (or at least as
    accurate as they always were), zero, or missing from the ticky profiling
    report altogether.
    
    This hasn't been particularly well-tested, but these changes shouldn't
    affect anything except when compiling with -fticky-ticky (famous last
    words...)
    
    Implementation details:
    
    I got rid of StgTicky.h, which in the past had the macros and declarations 
    for all of the ticky counters. Now, those macros are defined in Cmm.h.
    StgTicky.h was still there for inclusion in C code. Now, any remaining C
    code simply cannot call the ticky macros -- or rather, they do call those
    macros, but from the perspective of C code, they're defined as no-ops. 
    (This shouldn't be too big a problem.)
    
    I added a new file TickyCounter.h that has all the declarations for ticky
    counters, as well as dummy macros for use in C code. Someday, these 
    declarations should really be automatically generated, since they need
    to be kept consistent with the macros defined in Cmm.h.
    
    Other changes include getting rid of the header that was getting added to
    closures before, and getting rid of various code having to do with eager
    blackholing and permanent indirections (the changes under compiler/ 
    and rts/Updates.*).
Commits on Oct 7, 2006
  1. STM invariants

    tharris@microsoft.com authored
Commits on Jul 26, 2006
Commits on Apr 7, 2006
  1. Reorganisation of the source tree

    Simon Marlow authored
    Most of the other users of the fptools build system have migrated to
    Cabal, and with the move to darcs we can now flatten the source tree
    without losing history, so here goes.
    
    The main change is that the ghc/ subdir is gone, and most of what it
    contained is now at the top level.  The build system now makes no
    pretense at being multi-project, it is just the GHC build system.
    
    No doubt this will break many things, and there will be a period of
    instability while we fix the dependencies.  A straightforward build
    should work, but I haven't yet fixed binary/source distributions.
    Changes to the Building Guide will follow, too.
Something went wrong with that request. Please try again.