Changes between Version 30 and Version 31 of Status/Oct10


Ignore:
Timestamp:
Nov 2, 2010 9:23:34 PM (4 years ago)
Author:
simonpj
Comment:

--

Legend:

Unmodified
Added
Removed
Modified
  • Status/Oct10

    v30 v31  
    33GHC is humming along.  We are currently deep into the release cycle for GHC 7.0.  We have finally bumped the major version number, because GHC 7.0 has quite a bit of new stuff 
    44 
    5  * As long promised, Simon PJ and Dimitrios have spent a good chunk of the summer doing a complete rewrite of the constraint solver in the type inference engine.  Because of GHC's myriad type-system extensions, especially GADTs and type families, the old engine had begun to resemble the final stages of a game of Jenga.  It was a delicately-balanced pile of blocks that lived in constant danger of complete collapse, and had become extremely different to modify (or even to understand).  The new inference engine is much more modular and robust; it is described in detail in our paper [[http://haskell.org/haskellwiki/Simonpj/Talk:OutsideIn OutsideIn]].  A blog post describes some consequential changes to let generalisation [[http://hackage.haskell.org/trac/ghc/blog/LetGeneralisationInGhc7 LetGen]]. 
     5 * As long promised, Simon PJ and Dimitrios have spent a good chunk of the summer doing a '''complete rewrite of the constraint solver in the type inference engine'''.  Because of GHC's myriad type-system extensions, especially GADTs and type families, the old engine had begun to resemble the final stages of a game of Jenga.  It was a delicately-balanced pile of blocks that lived in constant danger of complete collapse, and had become extremely different to modify (or even to understand).  The new inference engine is much more modular and robust; it is described in detail in our paper [[http://haskell.org/haskellwiki/Simonpj/Talk:OutsideIn OutsideIn]].  A blog post describes some consequential changes to let generalisation [[http://hackage.haskell.org/trac/ghc/blog/LetGeneralisationInGhc7 LetGen]]. 
    66 
    77 As a result we have closed dozens of open type inference bugs, especially related to GADTs and type families. 
    88 
    9  * There is a new, robust implementation of INLINE pragmas, that behaves much more intuitively. GHC now captures the original RHS of an INLINE function, and keeps it more-or-less pristine, ready to inline at call sites.  Separately, the original RHS is optimised in the usual way.  Suppose you say 
     9 * There is a new, '''robust implementation of INLINE pragmas''', that behaves much more intuitively. GHC now captures the original RHS of an INLINE function, and keeps it more-or-less pristine, ready to inline at call sites.  Separately, the original RHS is optimised in the usual way.  Suppose you say 
    1010{{{ 
    1111{-# INLINE f #-} 
     
    1919 There's a raft of other small changes to the optimisation pipeline too.  The net effect can be dramatic: Bryan O'Sullivan reports some five-fold (!) improvements in his text-equality functions, and concludes "The difference between 6.12 and 7 is so dramatic, there's a strong temptation for me to say 'wait for 7!' to people who report weaker than desired performance." [[http://www.serpentine.com/blog/2010/10/19/a-brief-tale-of-faster-equality/ Bryan]] 
    2020 
    21  * David Terei implemented a new back end for GHC using LLVM. In certain situations using the LLVM backend can give fairly substantial performance improvements to your code, particularly if you're using the Vector libraries, DPH or making heavy use of fusion. In the general case it should give as good performance or slightly better than GHC's native code generator and C backend. You can use it through the '-fllvm' compiler flag. More details of the backend can be found in David's and Manuel Chakravarty's Haskell Symposium paper [[http://www.cse.unsw.edu.au/~davidt/downloads/ghc-llvm-hs10.pdf Llvm]]. 
     21 * David Terei implemented a new '''back end for GHC using LLVM'''. In certain situations using the LLVM backend can give fairly substantial performance improvements to your code, particularly if you're using the Vector libraries, DPH or making heavy use of fusion. In the general case it should give as good performance or slightly better than GHC's native code generator and C backend. You can use it through the '-fllvm' compiler flag. More details of the backend can be found in David's and Manuel Chakravarty's Haskell Symposium paper [[http://www.cse.unsw.edu.au/~davidt/downloads/ghc-llvm-hs10.pdf Llvm]]. 
    2222 
    23  * Bryan O’Sullivan and Johan Tibell and implemented a new, highly-concurrent I/O manager. GHC now supports over a hundred thousand open I/O connections. The new I/O manager defines a separate backend per operating system, using the most efficient system calls for that particular operating system (e.g. `epoll` on Linux.) This means that GHC can now be used to implement servers that make use of e.g. HTTP long polling, where the server needs to handle a large number of open idle connections. 
     23 * Bryan O’Sullivan and Johan Tibell and implemented a new, '''highly-concurrent I/O manager'''. GHC now supports over a hundred thousand open I/O connections. The new I/O manager defines a separate backend per operating system, using the most efficient system calls for that particular operating system (e.g. `epoll` on Linux.) This means that GHC can now be used to implement servers that make use of e.g. HTTP long polling, where the server needs to handle a large number of open idle connections. 
    2424 
    25  * In joint work with Phil Trinder and his colleagues at Herriot Watt, Simon M designed implemented a new parallel strategies library, described in their 2010 Haskell Symposium paper [[http://www.haskell.org/~simonmar/papers/strategies.pdf Seq]]. 
     25 * In joint work with Phil Trinder and his colleagues at Herriot Watt, Simon M designed implemented a new '''parallel strategies library''', described in their 2010 Haskell Symposium paper [[http://www.haskell.org/~simonmar/papers/strategies.pdf Seq]]. 
    2626 
    27  * As reported in the previous status update, the runtime system has undergone substantial changes to the implementation of lazy evaluation in parallel, particularly in the way that threads block and wake up again.  Certain benchmarks show significant improvements, and some cases of wildly unpredictable behaviour when using large numbers of threads are now much more consistent. 
     27 * As reported in the previous status update, '''the runtime system has undergone substantial changes''' to the implementation of lazy evaluation in parallel, particularly in the way that threads block and wake up again.  Certain benchmarks show significant improvements, and some cases of wildly unpredictable behaviour when using large numbers of threads are now much more consistent. 
    2828 
    29  * The API for asynchronous exceptions has had a redesign.  Previously the combinators `block` and `unblock` were used to prevent asynchronous exceptions from striking during critical sections, but these had some serious disadvantages, particularly a lack of modularity where a library function could unblock asynchronous exceptions despite a prevailing `block`.  The new API closes this loophole, and also changes the terminology: preventing asynchronous exceptions is now called "masking", and the new combinator is `mask`.  See the documentation for the new API in `Control.Exception` for more details. 
     29 * The '''API for asynchronous exceptions''' has had a redesign.  Previously the combinators `block` and `unblock` were used to prevent asynchronous exceptions from striking during critical sections, but these had some serious disadvantages, particularly a lack of modularity where a library function could unblock asynchronous exceptions despite a prevailing `block`.  The new API closes this loophole, and also changes the terminology: preventing asynchronous exceptions is now called "masking", and the new combinator is `mask`.  See the documentation for the new API in `Control.Exception` for more details. 
    3030 
    3131We are fortunate to have a growing team of people willing to roll up their