[GHC] #12455: Compact Regions

[GHC]

#12455: Compact Regions
-------------------------------------+-------------------------------------
        Reporter:  simonmar          |                Owner:  simonmar
            Type:  task              |               Status:  patch
        Priority:  high              |            Milestone:  8.2.1
       Component:  Runtime System    |              Version:  8.1
      Resolution:                    |             Keywords:
Operating System:  Unknown/Multiple  |         Architecture:
                                     |  Unknown/Multiple
 Type of failure:  None/Unknown      |            Test Case:
      Blocked By:                    |             Blocking:
 Related Tickets:                    |  Differential Rev(s):  Phab:D2751
       Wiki Page:                    |
-------------------------------------+-------------------------------------

Comment (by Simon Marlow <marlowsd@…>):

 In [changeset:"7036fde9df61b6eae9719c7f6c656778c756bec9/ghc" 7036fde/ghc]:
 {{{
 #!CommitTicketReference repository="ghc"
 revision="7036fde9df61b6eae9719c7f6c656778c756bec9"
 Overhaul of Compact Regions (#12455)

 Summary:
 This commit makes various improvements and addresses some issues with
 Compact Regions (aka Compact Normal Forms).

 This was the most important thing I wanted to fix.  Compaction
 previously prevented GC from running until it was complete, which
 would be a problem in a multicore setting.  Now, we compact using a
 hand-written Cmm routine that can be interrupted at any point.  When a
 GC is triggered during a sharing-enabled compaction, the GC has to
 traverse and update the hash table, so this hash table is now stored
 in the StgCompactNFData object.

 Previously, compaction consisted of a deepseq using the NFData class,
 followed by a traversal in C code to copy the data.  This is now done
 in a single pass with hand-written Cmm (see rts/Compact.cmm). We no
 longer use the NFData instances, instead the Cmm routine evaluates
 components directly as it compacts.

 The new compaction is about 50% faster than the old one with no
 sharing, and a little faster on average with sharing (the cost of the
 hash table dominates when we're doing sharing).

 Static objects that don't (transitively) refer to any CAFs don't need
 to be copied into the compact region.  In particular this means we
 often avoid copying Char values and small Int values, because these
 are static closures in the runtime.

 Each Compact# object can support a single compactAdd# operation at any
 given time, so the Data.Compact library now enforces mutual exclusion
 using an MVar stored in the Compact object.

 We now get exceptions rather than killing everything with a barf()
 when we encounter an object that cannot be compacted (a function, or a
 mutable object).  We now also detect pinned objects, which can't be
 compacted either.

 The Data.Compact API has been refactored and cleaned up.  A new
 compactSize operation returns the size (in bytes) of the compact
 object.

 Most of the documentation is in the Haddock docs for the compact
 library, which I've expanded and improved here.

 Various comments in the code have been improved, especially the main
 Note [Compact Normal Forms] in rts/sm/CNF.c.

 I've added a few tests, and expanded a few of the tests that were
 there.  We now also run the tests with GHCi, and in a new test way
 that enables sanity checking (+RTS -DS).

 There's a benchmark in libraries/compact/tests/compact_bench.hs for
 measuring compaction speed and comparing sharing vs. no sharing.

 The field totalDataW in StgCompactNFData was unnecessary.

 Test Plan:
 * new unit tests
 * validate
 * tested manually that we can compact Data.Aeson data

 Reviewers: gcampax, bgamari, ezyang, austin, niteria, hvr, erikd

 Subscribers: thomie, simonpj

 Differential Revision: https://phabricator.haskell.org/D2751

 GHC Trac Issues: #12455
 }}}

--
Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12455#comment:6>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler