... | ... | @@ -13,1298 +13,1309 @@ Here is where we track various on-going efforts to improve the runtime performan |
|
|
|
|
|
Identify tickets by using "Runtime performance bug" for the "Type of failure field".
|
|
|
|
|
|
|
|
|
|
|
|
**Open Tickets:**
|
|
|
|
|
|
<table><tr><th>[\#16340](https://gitlab.haskell.org//ghc/ghc/issues/16340)</th>
|
|
|
<table><tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/16340">#16340</a></th>
|
|
|
<td>Improve properFraction for Ratio</td></tr>
|
|
|
<tr><th>[\#16298](https://gitlab.haskell.org//ghc/ghc/issues/16298)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/16298">#16298</a></th>
|
|
|
<td>Awful(?) code in AArch64 stg_BLACKHOLE entry code</td></tr>
|
|
|
<tr><th>[\#16284](https://gitlab.haskell.org//ghc/ghc/issues/16284)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/16284">#16284</a></th>
|
|
|
<td>Abortion of fixed-point iteration in Demand Analyser discards sound results</td></tr>
|
|
|
<tr><th>[\#16064](https://gitlab.haskell.org//ghc/ghc/issues/16064)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/16064">#16064</a></th>
|
|
|
<td>Improving Placement of Heap Checks - Avoiding Slowdowns in Hot Code</td></tr>
|
|
|
<tr><th>[\#16040](https://gitlab.haskell.org//ghc/ghc/issues/16040)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/16040">#16040</a></th>
|
|
|
<td>Unboxing-Related Performance Issue with Polymorphic Functions</td></tr>
|
|
|
<tr><th>[\#16004](https://gitlab.haskell.org//ghc/ghc/issues/16004)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/16004">#16004</a></th>
|
|
|
<td>Vector performance regression in GHC 8.6</td></tr>
|
|
|
<tr><th>[\#15969](https://gitlab.haskell.org//ghc/ghc/issues/15969)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15969">#15969</a></th>
|
|
|
<td>Generic1 deriving should use more coercions</td></tr>
|
|
|
<tr><th>[\#15842](https://gitlab.haskell.org//ghc/ghc/issues/15842)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15842">#15842</a></th>
|
|
|
<td>Exponentiation needs PrelRules</td></tr>
|
|
|
<tr><th>[\#15731](https://gitlab.haskell.org//ghc/ghc/issues/15731)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15731">#15731</a></th>
|
|
|
<td>Add sortOn/coerce rule</td></tr>
|
|
|
<tr><th>[\#15727](https://gitlab.haskell.org//ghc/ghc/issues/15727)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15727">#15727</a></th>
|
|
|
<td>bug: all generations are collected sequentially when compacting collection kicks in</td></tr>
|
|
|
<tr><th>[\#15717](https://gitlab.haskell.org//ghc/ghc/issues/15717)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15717">#15717</a></th>
|
|
|
<td>Performance regression in for_ alternatives from GHC 8.2.2 to newer GHCs</td></tr>
|
|
|
<tr><th>[\#15652](https://gitlab.haskell.org//ghc/ghc/issues/15652)</th>
|
|
|
<td>SerializedCompact has a \[(Ptr a, Word)\] instead of a custom datatype</td></tr>
|
|
|
<tr><th>[\#15642](https://gitlab.haskell.org//ghc/ghc/issues/15642)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15652">#15652</a></th>
|
|
|
<td>SerializedCompact has a [(Ptr a, Word)] instead of a custom datatype</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15642">#15642</a></th>
|
|
|
<td>Improve the worst case performance of weak pointers</td></tr>
|
|
|
<tr><th>[\#15620](https://gitlab.haskell.org//ghc/ghc/issues/15620)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15620">#15620</a></th>
|
|
|
<td>Speed up Data.Unique</td></tr>
|
|
|
<tr><th>[\#15574](https://gitlab.haskell.org//ghc/ghc/issues/15574)</th>
|
|
|
<td>C wrappers for Haskell foreign exports don't have finalizers (causes memory leak).</td></tr>
|
|
|
<tr><th>[\#15524](https://gitlab.haskell.org//ghc/ghc/issues/15524)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15574">#15574</a></th>
|
|
|
<td>C wrappers for Haskell foreign exports don't have finalizers (causes memory leak).</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15524">#15524</a></th>
|
|
|
<td>Performance regression when using the GHC API to evaluate code compared to 8.4</td></tr>
|
|
|
<tr><th>[\#15503](https://gitlab.haskell.org//ghc/ghc/issues/15503)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15503">#15503</a></th>
|
|
|
<td>interpreter: sequence_ (replicate 100000000 (return ())) gobbles up memory</td></tr>
|
|
|
<tr><th>[\#15366](https://gitlab.haskell.org//ghc/ghc/issues/15366)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15366">#15366</a></th>
|
|
|
<td>GHC.Conc.Windows has a surprising queue</td></tr>
|
|
|
<tr><th>[\#15185](https://gitlab.haskell.org//ghc/ghc/issues/15185)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15185">#15185</a></th>
|
|
|
<td>Enum instance for IntX / WordX are inefficient</td></tr>
|
|
|
<tr><th>[\#15176](https://gitlab.haskell.org//ghc/ghc/issues/15176)</th>
|
|
|
<td>Superclass \`Monad m =\>\` makes program run 100 times slower</td></tr>
|
|
|
<tr><th>[\#15153](https://gitlab.haskell.org//ghc/ghc/issues/15153)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15176">#15176</a></th>
|
|
|
<td>Superclass `Monad m =>` makes program run 100 times slower</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15153">#15153</a></th>
|
|
|
<td>GHC uses O_NONBLOCK on regular files, which has no effect, and blocks the runtime</td></tr>
|
|
|
<tr><th>[\#15127](https://gitlab.haskell.org//ghc/ghc/issues/15127)</th>
|
|
|
<td>Unbox around runRW\#</td></tr>
|
|
|
<tr><th>[\#14980](https://gitlab.haskell.org//ghc/ghc/issues/14980)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15127">#15127</a></th>
|
|
|
<td>Unbox around runRW#</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14980">#14980</a></th>
|
|
|
<td>Runtime performance regression with binary operations on vectors</td></tr>
|
|
|
<tr><th>[\#14941](https://gitlab.haskell.org//ghc/ghc/issues/14941)</th>
|
|
|
<td>Switching direct type family application to EqPred (\~) prevents inlining in code using vector (10x slowdown)</td></tr>
|
|
|
<tr><th>[\#14929](https://gitlab.haskell.org//ghc/ghc/issues/14929)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14941">#14941</a></th>
|
|
|
<td>Switching direct type family application to EqPred (~) prevents inlining in code using vector (10x slowdown)</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14929">#14929</a></th>
|
|
|
<td>Program compiled with -O2 exhibits much worse performance</td></tr>
|
|
|
<tr><th>[\#14870](https://gitlab.haskell.org//ghc/ghc/issues/14870)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14870">#14870</a></th>
|
|
|
<td>Runtime performance regression in 8.4</td></tr>
|
|
|
<tr><th>[\#14827](https://gitlab.haskell.org//ghc/ghc/issues/14827)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14827">#14827</a></th>
|
|
|
<td>Recognize when inlining would create a join point</td></tr>
|
|
|
<tr><th>[\#14816](https://gitlab.haskell.org//ghc/ghc/issues/14816)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14816">#14816</a></th>
|
|
|
<td>Missed Called Arity opportunity?</td></tr>
|
|
|
<tr><th>[\#14797](https://gitlab.haskell.org//ghc/ghc/issues/14797)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14797">#14797</a></th>
|
|
|
<td>High-residency modules during GHC build</td></tr>
|
|
|
<tr><th>[\#14789](https://gitlab.haskell.org//ghc/ghc/issues/14789)</th>
|
|
|
<td>GHCi fails to garbage collect declaration \`l = length \[1..10\^8\]\` entered at prompt</td></tr>
|
|
|
<tr><th>[\#14762](https://gitlab.haskell.org//ghc/ghc/issues/14762)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14789">#14789</a></th>
|
|
|
<td>GHCi fails to garbage collect declaration `l = length [1..10^8]` entered at prompt</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14762">#14762</a></th>
|
|
|
<td>Foreign.Marshal.Pool functions use inefficient O(n) operations</td></tr>
|
|
|
<tr><th>[\#14727](https://gitlab.haskell.org//ghc/ghc/issues/14727)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14727">#14727</a></th>
|
|
|
<td>Unboxed sum performance surprisingly poor</td></tr>
|
|
|
<tr><th>[\#14620](https://gitlab.haskell.org//ghc/ghc/issues/14620)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14620">#14620</a></th>
|
|
|
<td>Polymorphic functions not easily recognized as join points</td></tr>
|
|
|
<tr><th>[\#14610](https://gitlab.haskell.org//ghc/ghc/issues/14610)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14610">#14610</a></th>
|
|
|
<td>newtype wrapping of a monadic stack kills performance</td></tr>
|
|
|
<tr><th>[\#14565](https://gitlab.haskell.org//ghc/ghc/issues/14565)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14565">#14565</a></th>
|
|
|
<td>Performance degrades from -O1 to -O2</td></tr>
|
|
|
<tr><th>[\#14564](https://gitlab.haskell.org//ghc/ghc/issues/14564)</th>
|
|
|
<td>CAF isn't floated</td></tr>
|
|
|
<tr><th>[\#14509](https://gitlab.haskell.org//ghc/ghc/issues/14509)</th>
|
|
|
<td>Consider adding new stg_ap_\* functions</td></tr>
|
|
|
<tr><th>[\#14461](https://gitlab.haskell.org//ghc/ghc/issues/14461)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14564">#14564</a></th>
|
|
|
<td>CAF isn't floated</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14509">#14509</a></th>
|
|
|
<td>Consider adding new stg_ap_* functions</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14461">#14461</a></th>
|
|
|
<td>Reuse free variable lists through nested closures</td></tr>
|
|
|
<tr><th>[\#14407](https://gitlab.haskell.org//ghc/ghc/issues/14407)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14407">#14407</a></th>
|
|
|
<td>rts: Threads/caps affinity</td></tr>
|
|
|
<tr><th>[\#14383](https://gitlab.haskell.org//ghc/ghc/issues/14383)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14383">#14383</a></th>
|
|
|
<td>Allocation in VS up 500%</td></tr>
|
|
|
<tr><th>[\#14359](https://gitlab.haskell.org//ghc/ghc/issues/14359)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14359">#14359</a></th>
|
|
|
<td>C-- pipeline/NCG fails to optimize simple repeated addition</td></tr>
|
|
|
<tr><th>[\#14337](https://gitlab.haskell.org//ghc/ghc/issues/14337)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14337">#14337</a></th>
|
|
|
<td>typeRepKind can perform substantial amounts of allocation</td></tr>
|
|
|
<tr><th>[\#14295](https://gitlab.haskell.org//ghc/ghc/issues/14295)</th>
|
|
|
<td>tagToEnum\# leads to some silly closures</td></tr>
|
|
|
<tr><th>[\#14256](https://gitlab.haskell.org//ghc/ghc/issues/14256)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14295">#14295</a></th>
|
|
|
<td>tagToEnum# leads to some silly closures</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14256">#14256</a></th>
|
|
|
<td>GHCi is faster than compiled code</td></tr>
|
|
|
<tr><th>[\#14239](https://gitlab.haskell.org//ghc/ghc/issues/14239)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14239">#14239</a></th>
|
|
|
<td>Let -fspecialise-aggressively respect NOINLINE (or NOSPECIALISABLE?)</td></tr>
|
|
|
<tr><th>[\#14211](https://gitlab.haskell.org//ghc/ghc/issues/14211)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14211">#14211</a></th>
|
|
|
<td>Compiler is unable to INLINE as well as the programmer can manually</td></tr>
|
|
|
<tr><th>[\#14208](https://gitlab.haskell.org//ghc/ghc/issues/14208)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14208">#14208</a></th>
|
|
|
<td>Performance with O0 is much better than the default or with -O2, runghc performs the best</td></tr>
|
|
|
<tr><th>[\#14072](https://gitlab.haskell.org//ghc/ghc/issues/14072)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14072">#14072</a></th>
|
|
|
<td>Code generated by GHC 8.2.1 faster than 8.0.1 but still somewhat slower than 7.10.3</td></tr>
|
|
|
<tr><th>[\#14003](https://gitlab.haskell.org//ghc/ghc/issues/14003)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14003">#14003</a></th>
|
|
|
<td>Allow more worker arguments in SpecConstr</td></tr>
|
|
|
<tr><th>[\#13904](https://gitlab.haskell.org//ghc/ghc/issues/13904)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13904">#13904</a></th>
|
|
|
<td>LLVM does not need to trash caller-saved registers.</td></tr>
|
|
|
<tr><th>[\#13873](https://gitlab.haskell.org//ghc/ghc/issues/13873)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13873">#13873</a></th>
|
|
|
<td>Adding a SPECIALIZE at a callsite in Main.hs is causing a regression</td></tr>
|
|
|
<tr><th>[\#13851](https://gitlab.haskell.org//ghc/ghc/issues/13851)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13851">#13851</a></th>
|
|
|
<td>Change in specialisation(?) behaviour since 8.0.2 causes 6x slowdown</td></tr>
|
|
|
<tr><th>[\#13763](https://gitlab.haskell.org//ghc/ghc/issues/13763)</th>
|
|
|
<td>Performance regression (\~34%) in 8.2.1, poor register allocation(?) in an inner loop over an array</td></tr>
|
|
|
<tr><th>[\#13725](https://gitlab.haskell.org//ghc/ghc/issues/13725)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13763">#13763</a></th>
|
|
|
<td>Performance regression (~34%) in 8.2.1, poor register allocation(?) in an inner loop over an array</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13725">#13725</a></th>
|
|
|
<td>Remove false dependency on the destination of the popcnt instruction</td></tr>
|
|
|
<tr><th>[\#13692](https://gitlab.haskell.org//ghc/ghc/issues/13692)</th>
|
|
|
<td>Constructors and such should be able to move around seq\# sometimes</td></tr>
|
|
|
<tr><th>[\#13629](https://gitlab.haskell.org//ghc/ghc/issues/13629)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13692">#13692</a></th>
|
|
|
<td>Constructors and such should be able to move around seq# sometimes</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13629">#13629</a></th>
|
|
|
<td>sqrt should use machine instruction on x86_64</td></tr>
|
|
|
<tr><th>[\#13362](https://gitlab.haskell.org//ghc/ghc/issues/13362)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13362">#13362</a></th>
|
|
|
<td>GHC first generation of GC to be as large as largest cache size by default</td></tr>
|
|
|
<tr><th>[\#13339](https://gitlab.haskell.org//ghc/ghc/issues/13339)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13339">#13339</a></th>
|
|
|
<td>Arbitrarily large expressions built out of cheap primops are not floated out</td></tr>
|
|
|
<tr><th>[\#13334](https://gitlab.haskell.org//ghc/ghc/issues/13334)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13334">#13334</a></th>
|
|
|
<td>Constant folding for repeated integer operation of unknown value</td></tr>
|
|
|
<tr><th>[\#13331](https://gitlab.haskell.org//ghc/ghc/issues/13331)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13331">#13331</a></th>
|
|
|
<td>Worker/wrapper can lead to sharing failure</td></tr>
|
|
|
<tr><th>[\#13309](https://gitlab.haskell.org//ghc/ghc/issues/13309)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13309">#13309</a></th>
|
|
|
<td>Use liftA2 in ApplicativeDo</td></tr>
|
|
|
<tr><th>[\#13296](https://gitlab.haskell.org//ghc/ghc/issues/13296)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13296">#13296</a></th>
|
|
|
<td>stat() calls can block Haskell runtime</td></tr>
|
|
|
<tr><th>[\#13280](https://gitlab.haskell.org//ghc/ghc/issues/13280)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13280">#13280</a></th>
|
|
|
<td>Consider deriving more Foldable methods</td></tr>
|
|
|
<tr><th>[\#13225](https://gitlab.haskell.org//ghc/ghc/issues/13225)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13225">#13225</a></th>
|
|
|
<td>Fannkuch-redux time regression from join point patch</td></tr>
|
|
|
<tr><th>[\#13193](https://gitlab.haskell.org//ghc/ghc/issues/13193)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13193">#13193</a></th>
|
|
|
<td>Integer (gmp) performance regression?</td></tr>
|
|
|
<tr><th>[\#13153](https://gitlab.haskell.org//ghc/ghc/issues/13153)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13153">#13153</a></th>
|
|
|
<td>Several Traversable instances have an extra fmap</td></tr>
|
|
|
<tr><th>[\#13080](https://gitlab.haskell.org//ghc/ghc/issues/13080)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13080">#13080</a></th>
|
|
|
<td>Memory leak caused by nested monadic loops</td></tr>
|
|
|
<tr><th>[\#13016](https://gitlab.haskell.org//ghc/ghc/issues/13016)</th>
|
|
|
<td>SPECIALIZE INLINE doesn't necessarily inline specializations of a recursive function</td></tr>
|
|
|
<tr><th>[\#13014](https://gitlab.haskell.org//ghc/ghc/issues/13014)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13016">#13016</a></th>
|
|
|
<td>SPECIALIZE INLINE doesn't necessarily inline specializations of a recursive function</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13014">#13014</a></th>
|
|
|
<td>Seemingly unnecessary marking of a SpecConstr specialization as a loopbreaker</td></tr>
|
|
|
<tr><th>[\#13002](https://gitlab.haskell.org//ghc/ghc/issues/13002)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13002">#13002</a></th>
|
|
|
<td>:set -O does not work in .ghci file</td></tr>
|
|
|
<tr><th>[\#12953](https://gitlab.haskell.org//ghc/ghc/issues/12953)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12953">#12953</a></th>
|
|
|
<td>Use computed gotos in the interpreter when the compiler supports it</td></tr>
|
|
|
<tr><th>[\#12900](https://gitlab.haskell.org//ghc/ghc/issues/12900)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12900">#12900</a></th>
|
|
|
<td>Common up identical info tables</td></tr>
|
|
|
<tr><th>[\#12893](https://gitlab.haskell.org//ghc/ghc/issues/12893)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12893">#12893</a></th>
|
|
|
<td>Profiling defeats stream fusion when using vector library</td></tr>
|
|
|
<tr><th>[\#12817](https://gitlab.haskell.org//ghc/ghc/issues/12817)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12817">#12817</a></th>
|
|
|
<td>Degraded performance with constraint synonyms</td></tr>
|
|
|
<tr><th>[\#12808](https://gitlab.haskell.org//ghc/ghc/issues/12808)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12808">#12808</a></th>
|
|
|
<td>For closures, Loop Invariant Code Flow related to captured free values not lifted outside the loop...</td></tr>
|
|
|
<tr><th>[\#12798](https://gitlab.haskell.org//ghc/ghc/issues/12798)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12798">#12798</a></th>
|
|
|
<td>LLVM seeming to over optimize, producing inefficient assembly code...</td></tr>
|
|
|
<tr><th>[\#12737](https://gitlab.haskell.org//ghc/ghc/issues/12737)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12737">#12737</a></th>
|
|
|
<td>T12227 is failing on ghc-8.0</td></tr>
|
|
|
<tr><th>[\#12665](https://gitlab.haskell.org//ghc/ghc/issues/12665)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12665">#12665</a></th>
|
|
|
<td>Make Read instances for Integral types faster, and make them fail fast</td></tr>
|
|
|
<tr><th>[\#12640](https://gitlab.haskell.org//ghc/ghc/issues/12640)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12640">#12640</a></th>
|
|
|
<td>Class member functions not substituted for MultiParamTypeClasses</td></tr>
|
|
|
<tr><th>[\#12566](https://gitlab.haskell.org//ghc/ghc/issues/12566)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12566">#12566</a></th>
|
|
|
<td>Memory leak</td></tr>
|
|
|
<tr><th>[\#12232](https://gitlab.haskell.org//ghc/ghc/issues/12232)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12232">#12232</a></th>
|
|
|
<td>Opportunity to do better in register allocations</td></tr>
|
|
|
<tr><th>[\#12231](https://gitlab.haskell.org//ghc/ghc/issues/12231)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12231">#12231</a></th>
|
|
|
<td>Eliminate redundant heap allocations/deallocations</td></tr>
|
|
|
<tr><th>[\#12181](https://gitlab.haskell.org//ghc/ghc/issues/12181)</th>
|
|
|
<td>Multi-threaded code on ARM64 GHC runtime doesn't use all available cores</td></tr>
|
|
|
<tr><th>[\#11677](https://gitlab.haskell.org//ghc/ghc/issues/11677)</th>
|
|
|
<td>Dramatic de-optimization with "-O", "-O1", "-O2" options</td></tr>
|
|
|
<tr><th>[\#11668](https://gitlab.haskell.org//ghc/ghc/issues/11668)</th>
|
|
|
<td>SPEC has a runtime cost if constructor specialization isn't performed</td></tr>
|
|
|
<tr><th>[\#11587](https://gitlab.haskell.org//ghc/ghc/issues/11587)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12181">#12181</a></th>
|
|
|
<td>Multi-threaded code on ARM64 GHC runtime doesn't use all available cores</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11677">#11677</a></th>
|
|
|
<td>Dramatic de-optimization with "-O", "-O1", "-O2" options</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11668">#11668</a></th>
|
|
|
<td>SPEC has a runtime cost if constructor specialization isn't performed</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11587">#11587</a></th>
|
|
|
<td>Place shared objects in LIBDIR</td></tr>
|
|
|
<tr><th>[\#11561](https://gitlab.haskell.org//ghc/ghc/issues/11561)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11561">#11561</a></th>
|
|
|
<td>Have static ghci link against its own copy of its libraries</td></tr>
|
|
|
<tr><th>[\#11441](https://gitlab.haskell.org//ghc/ghc/issues/11441)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11441">#11441</a></th>
|
|
|
<td>RFC: Inline intermediate languages (Core, STG, Cmm, even StrictCore)</td></tr>
|
|
|
<tr><th>[\#11393](https://gitlab.haskell.org//ghc/ghc/issues/11393)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11393">#11393</a></th>
|
|
|
<td>Ability to define INLINE pragma for all instances of a given typeclass</td></tr>
|
|
|
<tr><th>[\#11271](https://gitlab.haskell.org//ghc/ghc/issues/11271)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11271">#11271</a></th>
|
|
|
<td>Costly let binding gets duplicated in IO action value</td></tr>
|
|
|
<tr><th>[\#11226](https://gitlab.haskell.org//ghc/ghc/issues/11226)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11226">#11226</a></th>
|
|
|
<td>Performance regression (involving sum, map, enumFromThenTo)</td></tr>
|
|
|
<tr><th>[\#11146](https://gitlab.haskell.org//ghc/ghc/issues/11146)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11146">#11146</a></th>
|
|
|
<td>Manual eta expansion leads to orders of magnitude less allocations</td></tr>
|
|
|
<tr><th>[\#11143](https://gitlab.haskell.org//ghc/ghc/issues/11143)</th>
|
|
|
<td>Feature request: Add index/read/write primops with byte offset for ByteArray\#</td></tr>
|
|
|
<tr><th>[\#11134](https://gitlab.haskell.org//ghc/ghc/issues/11134)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11143">#11143</a></th>
|
|
|
<td>Feature request: Add index/read/write primops with byte offset for ByteArray#</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11134">#11134</a></th>
|
|
|
<td>Limit frequency of idle GCs</td></tr>
|
|
|
<tr><th>[\#11029](https://gitlab.haskell.org//ghc/ghc/issues/11029)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11029">#11029</a></th>
|
|
|
<td>Performance loss due to eta expansion</td></tr>
|
|
|
<tr><th>[\#10992](https://gitlab.haskell.org//ghc/ghc/issues/10992)</th>
|
|
|
<td>Performance regression due to lack of inlining of \`foldl\` and \`foldl'\`.</td></tr>
|
|
|
<tr><th>[\#10944](https://gitlab.haskell.org//ghc/ghc/issues/10944)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10992">#10992</a></th>
|
|
|
<td>Performance regression due to lack of inlining of `foldl` and `foldl'`.</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10944">#10944</a></th>
|
|
|
<td>powModInteger slower than computing pow and mod separately</td></tr>
|
|
|
<tr><th>[\#10922](https://gitlab.haskell.org//ghc/ghc/issues/10922)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10922">#10922</a></th>
|
|
|
<td>String inlining is inconsistent</td></tr>
|
|
|
<tr><th>[\#10906](https://gitlab.haskell.org//ghc/ghc/issues/10906)</th>
|
|
|
<td>\`SPECIALIZE instance\` could be better</td></tr>
|
|
|
<tr><th>[\#10809](https://gitlab.haskell.org//ghc/ghc/issues/10809)</th>
|
|
|
<td>Add prefetch{Small}{Mutable}Array\[0..3\]\#</td></tr>
|
|
|
<tr><th>[\#10804](https://gitlab.haskell.org//ghc/ghc/issues/10804)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10906">#10906</a></th>
|
|
|
<td>`SPECIALIZE instance` could be better</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10809">#10809</a></th>
|
|
|
<td>Add prefetch{Small}{Mutable}Array[0..3]#</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10804">#10804</a></th>
|
|
|
<td>Rules conditional on strictess properties</td></tr>
|
|
|
<tr><th>[\#10730](https://gitlab.haskell.org//ghc/ghc/issues/10730)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10730">#10730</a></th>
|
|
|
<td>Spectral norm allocations increased 17% between 7.6 and 7.8</td></tr>
|
|
|
<tr><th>[\#10652](https://gitlab.haskell.org//ghc/ghc/issues/10652)</th>
|
|
|
<td>Better cache performance in Array\#</td></tr>
|
|
|
<tr><th>[\#10648](https://gitlab.haskell.org//ghc/ghc/issues/10648)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10652">#10652</a></th>
|
|
|
<td>Better cache performance in Array#</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10648">#10648</a></th>
|
|
|
<td>Some 64-vector SIMD primitives are absolutely useless</td></tr>
|
|
|
<tr><th>[\#10626](https://gitlab.haskell.org//ghc/ghc/issues/10626)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10626">#10626</a></th>
|
|
|
<td>Missed opportunity for SpecConstr</td></tr>
|
|
|
<tr><th>[\#10606](https://gitlab.haskell.org//ghc/ghc/issues/10606)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10606">#10606</a></th>
|
|
|
<td>avoid redundant stores to the stack when examining already-tagged data</td></tr>
|
|
|
<tr><th>[\#10482](https://gitlab.haskell.org//ghc/ghc/issues/10482)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10482">#10482</a></th>
|
|
|
<td>Not enough unboxing happens on data-family function argument</td></tr>
|
|
|
<tr><th>[\#10470](https://gitlab.haskell.org//ghc/ghc/issues/10470)</th>
|
|
|
<td>Allocating StablePtrs leads to GC slowdown even after they're freed</td></tr>
|
|
|
<tr><th>[\#10434](https://gitlab.haskell.org//ghc/ghc/issues/10434)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10470">#10470</a></th>
|
|
|
<td>Allocating StablePtrs leads to GC slowdown even after they're freed</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10434">#10434</a></th>
|
|
|
<td>SPECIALISE instance does not specialize as far as SPECIALISE for type signatures</td></tr>
|
|
|
<tr><th>[\#10421](https://gitlab.haskell.org//ghc/ghc/issues/10421)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10421">#10421</a></th>
|
|
|
<td>exponential blowup in inlining (without INLINE pragmas)</td></tr>
|
|
|
<tr><th>[\#10417](https://gitlab.haskell.org//ghc/ghc/issues/10417)</th>
|
|
|
<td>Rule matching not "seeing through" floating and type lambda (and maybe cast)</td></tr>
|
|
|
<tr><th>[\#10401](https://gitlab.haskell.org//ghc/ghc/issues/10401)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10417">#10417</a></th>
|
|
|
<td>Rule matching not "seeing through" floating and type lambda (and maybe cast)</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10401">#10401</a></th>
|
|
|
<td>state hack-related regression</td></tr>
|
|
|
<tr><th>[\#10371](https://gitlab.haskell.org//ghc/ghc/issues/10371)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10371">#10371</a></th>
|
|
|
<td>GHC fails to inline and specialize a function</td></tr>
|
|
|
<tr><th>[\#10346](https://gitlab.haskell.org//ghc/ghc/issues/10346)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10346">#10346</a></th>
|
|
|
<td>Cross-module SpecConstr</td></tr>
|
|
|
<tr><th>[\#10319](https://gitlab.haskell.org//ghc/ghc/issues/10319)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10319">#10319</a></th>
|
|
|
<td>Eta expand PAPs</td></tr>
|
|
|
<tr><th>[\#10229](https://gitlab.haskell.org//ghc/ghc/issues/10229)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10229">#10229</a></th>
|
|
|
<td>setThreadAffinity assumes a certain CPU virtual core layout</td></tr>
|
|
|
<tr><th>[\#10124](https://gitlab.haskell.org//ghc/ghc/issues/10124)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10124">#10124</a></th>
|
|
|
<td>Simple case analyses generate too many branches</td></tr>
|
|
|
<tr><th>[\#10120](https://gitlab.haskell.org//ghc/ghc/issues/10120)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10120">#10120</a></th>
|
|
|
<td>Unnecessary code duplication from case analysis</td></tr>
|
|
|
<tr><th>[\#10069](https://gitlab.haskell.org//ghc/ghc/issues/10069)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10069">#10069</a></th>
|
|
|
<td>CPR related performance issue</td></tr>
|
|
|
<tr><th>[\#10062](https://gitlab.haskell.org//ghc/ghc/issues/10062)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10062">#10062</a></th>
|
|
|
<td>Codegen on sequential FFI calls is not very good</td></tr>
|
|
|
<tr><th>[\#10049](https://gitlab.haskell.org//ghc/ghc/issues/10049)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10049">#10049</a></th>
|
|
|
<td>Lower level memcpy primop</td></tr>
|
|
|
<tr><th>[\#10016](https://gitlab.haskell.org//ghc/ghc/issues/10016)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10016">#10016</a></th>
|
|
|
<td>UNPACK support for existentials</td></tr>
|
|
|
<tr><th>[\#10012](https://gitlab.haskell.org//ghc/ghc/issues/10012)</th>
|
|
|
<td>Cheap-to-compute values aren't pushed into case branches inducing unnecessary register pressure</td></tr>
|
|
|
<tr><th>[\#10005](https://gitlab.haskell.org//ghc/ghc/issues/10005)</th>
|
|
|
<td>Operations on string literals won't be inlined</td></tr>
|
|
|
<tr><th>[\#9992](https://gitlab.haskell.org//ghc/ghc/issues/9992)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10012">#10012</a></th>
|
|
|
<td>Cheap-to-compute values aren't pushed into case branches inducing unnecessary register pressure</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10005">#10005</a></th>
|
|
|
<td>Operations on string literals won't be inlined</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9992">#9992</a></th>
|
|
|
<td>Constructor specialization requires eta expansion</td></tr>
|
|
|
<tr><th>[\#9989](https://gitlab.haskell.org//ghc/ghc/issues/9989)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9989">#9989</a></th>
|
|
|
<td>GHCI is slow for precompiled code</td></tr>
|
|
|
<tr><th>[\#9944](https://gitlab.haskell.org//ghc/ghc/issues/9944)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9944">#9944</a></th>
|
|
|
<td>Performance issue re: simple loop</td></tr>
|
|
|
<tr><th>[\#9923](https://gitlab.haskell.org//ghc/ghc/issues/9923)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9923">#9923</a></th>
|
|
|
<td>Offer copy-on-GC sliced arrays</td></tr>
|
|
|
<tr><th>[\#9809](https://gitlab.haskell.org//ghc/ghc/issues/9809)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9809">#9809</a></th>
|
|
|
<td>Overwhelming the TimerManager</td></tr>
|
|
|
<tr><th>[\#9798](https://gitlab.haskell.org//ghc/ghc/issues/9798)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9798">#9798</a></th>
|
|
|
<td>Frustrating behaviour of the INLINE pragma</td></tr>
|
|
|
<tr><th>[\#9792](https://gitlab.haskell.org//ghc/ghc/issues/9792)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9792">#9792</a></th>
|
|
|
<td>map/coerce rule does not fire until the coercion is known</td></tr>
|
|
|
<tr><th>[\#9790](https://gitlab.haskell.org//ghc/ghc/issues/9790)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9790">#9790</a></th>
|
|
|
<td>Produce coercion rules for derived Functor instances</td></tr>
|
|
|
<tr><th>[\#9786](https://gitlab.haskell.org//ghc/ghc/issues/9786)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9786">#9786</a></th>
|
|
|
<td>Make quot/rem/div/mod with known divisors fast</td></tr>
|
|
|
<tr><th>[\#9701](https://gitlab.haskell.org//ghc/ghc/issues/9701)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9701">#9701</a></th>
|
|
|
<td>GADTs not specialized properly</td></tr>
|
|
|
<tr><th>[\#9688](https://gitlab.haskell.org//ghc/ghc/issues/9688)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9688">#9688</a></th>
|
|
|
<td>Improve the interaction between CSE and the join point transformation</td></tr>
|
|
|
<tr><th>[\#9661](https://gitlab.haskell.org//ghc/ghc/issues/9661)</th>
|
|
|
<td>Branchless ==\# is compiled to branchy code</td></tr>
|
|
|
<tr><th>[\#9660](https://gitlab.haskell.org//ghc/ghc/issues/9660)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9661">#9661</a></th>
|
|
|
<td>Branchless ==# is compiled to branchy code</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9660">#9660</a></th>
|
|
|
<td>unnecessary indirect jump when returning a case scrutinee</td></tr>
|
|
|
<tr><th>[\#9659](https://gitlab.haskell.org//ghc/ghc/issues/9659)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9659">#9659</a></th>
|
|
|
<td>Offer branchless conditional (CMOV) primop</td></tr>
|
|
|
<tr><th>[\#9655](https://gitlab.haskell.org//ghc/ghc/issues/9655)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9655">#9655</a></th>
|
|
|
<td>Do not UNPACK strict fields that are very wide</td></tr>
|
|
|
<tr><th>[\#9646](https://gitlab.haskell.org//ghc/ghc/issues/9646)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9646">#9646</a></th>
|
|
|
<td>Simplifer non-determinism leading to 8 fold difference in run time performance</td></tr>
|
|
|
<tr><th>[\#9645](https://gitlab.haskell.org//ghc/ghc/issues/9645)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9645">#9645</a></th>
|
|
|
<td>Optimize range checks for primitive types</td></tr>
|
|
|
<tr><th>[\#9617](https://gitlab.haskell.org//ghc/ghc/issues/9617)</th>
|
|
|
<td>Implement \`quot\` and \`rem\` using \`quotRem\`; implement \`div\` and \`mod\` using \`divMod\`</td></tr>
|
|
|
<tr><th>[\#9601](https://gitlab.haskell.org//ghc/ghc/issues/9601)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9617">#9617</a></th>
|
|
|
<td>Implement `quot` and `rem` using `quotRem`; implement `div` and `mod` using `divMod`</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9601">#9601</a></th>
|
|
|
<td>Make the rewrite rule system more powerful</td></tr>
|
|
|
<tr><th>[\#9542](https://gitlab.haskell.org//ghc/ghc/issues/9542)</th>
|
|
|
<td>GHC-IO-Handle-Text.hPutStr' and writeBlocks look like they need refactoring</td></tr>
|
|
|
<tr><th>[\#9522](https://gitlab.haskell.org//ghc/ghc/issues/9522)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9542">#9542</a></th>
|
|
|
<td>GHC-IO-Handle-Text.hPutStr' and writeBlocks look like they need refactoring</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9522">#9522</a></th>
|
|
|
<td>SPECIALISE pragmas for derived instances</td></tr>
|
|
|
<tr><th>[\#9447](https://gitlab.haskell.org//ghc/ghc/issues/9447)</th>
|
|
|
<td>Add support for resizing \`MutableByteArray\#\`s</td></tr>
|
|
|
<tr><th>[\#9431](https://gitlab.haskell.org//ghc/ghc/issues/9431)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9447">#9447</a></th>
|
|
|
<td>Add support for resizing `MutableByteArray#`s</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9431">#9431</a></th>
|
|
|
<td>integer-gmp small Integer multiplication does two multiplications on x86</td></tr>
|
|
|
<tr><th>[\#9388](https://gitlab.haskell.org//ghc/ghc/issues/9388)</th>
|
|
|
<td>Narrow the scope of the notorious "state hack"</td></tr>
|
|
|
<tr><th>[\#9374](https://gitlab.haskell.org//ghc/ghc/issues/9374)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9388">#9388</a></th>
|
|
|
<td>Narrow the scope of the notorious "state hack"</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9374">#9374</a></th>
|
|
|
<td>Investigate Static Argument Transformation</td></tr>
|
|
|
<tr><th>[\#9353](https://gitlab.haskell.org//ghc/ghc/issues/9353)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9353">#9353</a></th>
|
|
|
<td>prefetch primops are not currently useful</td></tr>
|
|
|
<tr><th>[\#9350](https://gitlab.haskell.org//ghc/ghc/issues/9350)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9350">#9350</a></th>
|
|
|
<td>Consider using xchg instead of mfence for CS stores</td></tr>
|
|
|
<tr><th>[\#9349](https://gitlab.haskell.org//ghc/ghc/issues/9349)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9349">#9349</a></th>
|
|
|
<td>excessive inlining due to state hack</td></tr>
|
|
|
<tr><th>[\#9342](https://gitlab.haskell.org//ghc/ghc/issues/9342)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9342">#9342</a></th>
|
|
|
<td>Branchless arithmetic operations</td></tr>
|
|
|
<tr><th>[\#9320](https://gitlab.haskell.org//ghc/ghc/issues/9320)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9320">#9320</a></th>
|
|
|
<td>Inlining regression/strangeness in 7.8</td></tr>
|
|
|
<tr><th>[\#9289](https://gitlab.haskell.org//ghc/ghc/issues/9289)</th>
|
|
|
<td>add anyToAddr\# :: (\#a\#)-\> Addr\# primop (inverse of addrToAny\#)</td></tr>
|
|
|
<tr><th>[\#9279](https://gitlab.haskell.org//ghc/ghc/issues/9279)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9289">#9289</a></th>
|
|
|
<td>add anyToAddr# :: (#a#)-> Addr# primop (inverse of addrToAny#)</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9279">#9279</a></th>
|
|
|
<td>Local wrapper function remains in final program; result = extra closure allocation</td></tr>
|
|
|
<tr><th>[\#9251](https://gitlab.haskell.org//ghc/ghc/issues/9251)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9251">#9251</a></th>
|
|
|
<td>ghc does not expose branchless max/min operations as primops</td></tr>
|
|
|
<tr><th>[\#9246](https://gitlab.haskell.org//ghc/ghc/issues/9246)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9246">#9246</a></th>
|
|
|
<td>GHC generates poor code for repeated uses of min/max</td></tr>
|
|
|
<tr><th>[\#9192](https://gitlab.haskell.org//ghc/ghc/issues/9192)</th>
|
|
|
<td>Add sameByteArray\#</td></tr>
|
|
|
<tr><th>[\#9137](https://gitlab.haskell.org//ghc/ghc/issues/9137)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9192">#9192</a></th>
|
|
|
<td>Add sameByteArray#</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9137">#9137</a></th>
|
|
|
<td>A way to match RULES only for literals</td></tr>
|
|
|
<tr><th>[\#9120](https://gitlab.haskell.org//ghc/ghc/issues/9120)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9120">#9120</a></th>
|
|
|
<td>Cache intermediate powers</td></tr>
|
|
|
<tr><th>[\#9088](https://gitlab.haskell.org//ghc/ghc/issues/9088)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9088">#9088</a></th>
|
|
|
<td>Per-thread Haskell thread list/numbering (remove global lock from thread allocation)</td></tr>
|
|
|
<tr><th>[\#9041](https://gitlab.haskell.org//ghc/ghc/issues/9041)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9041">#9041</a></th>
|
|
|
<td>NCG generates slow loop code</td></tr>
|
|
|
<tr><th>[\#8971](https://gitlab.haskell.org//ghc/ghc/issues/8971)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8971">#8971</a></th>
|
|
|
<td>Native Code Generator for 8.0.1 is not as optimized as 7.6.3...</td></tr>
|
|
|
<tr><th>[\#8955](https://gitlab.haskell.org//ghc/ghc/issues/8955)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8955">#8955</a></th>
|
|
|
<td>Syscall intrinsic</td></tr>
|
|
|
<tr><th>[\#8949](https://gitlab.haskell.org//ghc/ghc/issues/8949)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8949">#8949</a></th>
|
|
|
<td>switch -msse2 to be on by default</td></tr>
|
|
|
<tr><th>[\#8905](https://gitlab.haskell.org//ghc/ghc/issues/8905)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8905">#8905</a></th>
|
|
|
<td>Function arguments are always spilled/reloaded if scrutinee is already in WHNF</td></tr>
|
|
|
<tr><th>[\#8903](https://gitlab.haskell.org//ghc/ghc/issues/8903)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8903">#8903</a></th>
|
|
|
<td>Add dead store elimination</td></tr>
|
|
|
<tr><th>[\#8887](https://gitlab.haskell.org//ghc/ghc/issues/8887)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8887">#8887</a></th>
|
|
|
<td>Double double assignment in optimized Cmm on SPARC</td></tr>
|
|
|
<tr><th>[\#8871](https://gitlab.haskell.org//ghc/ghc/issues/8871)</th>
|
|
|
<td>No-op assignment I64\[BaseReg + 784\] = I64\[BaseReg + 784\]; is generated into optimized Cmm</td></tr>
|
|
|
<tr><th>[\#8814](https://gitlab.haskell.org//ghc/ghc/issues/8814)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8871">#8871</a></th>
|
|
|
<td>No-op assignment I64[BaseReg + 784] = I64[BaseReg + 784]; is generated into optimized Cmm</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8814">#8814</a></th>
|
|
|
<td>7.8 optimizes attoparsec improperly</td></tr>
|
|
|
<tr><th>[\#8733](https://gitlab.haskell.org//ghc/ghc/issues/8733)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8733">#8733</a></th>
|
|
|
<td>I/O manager causes unnecessary syscalls in send/recv loops</td></tr>
|
|
|
<tr><th>[\#8732](https://gitlab.haskell.org//ghc/ghc/issues/8732)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8732">#8732</a></th>
|
|
|
<td>Global big object heap allocator lock causes contention</td></tr>
|
|
|
<tr><th>[\#8668](https://gitlab.haskell.org//ghc/ghc/issues/8668)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8668">#8668</a></th>
|
|
|
<td>SPECIALIZE silently fails to apply</td></tr>
|
|
|
<tr><th>[\#8662](https://gitlab.haskell.org//ghc/ghc/issues/8662)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8662">#8662</a></th>
|
|
|
<td>GHC does not inline cheap inner loop when used in two places</td></tr>
|
|
|
<tr><th>[\#8655](https://gitlab.haskell.org//ghc/ghc/issues/8655)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8655">#8655</a></th>
|
|
|
<td>Evaluate know-to-terminate-soon thunks</td></tr>
|
|
|
<tr><th>[\#8635](https://gitlab.haskell.org//ghc/ghc/issues/8635)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8635">#8635</a></th>
|
|
|
<td>GHC optimisation flag ignored when importing a local module with derived type classes</td></tr>
|
|
|
<tr><th>[\#8623](https://gitlab.haskell.org//ghc/ghc/issues/8623)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8623">#8623</a></th>
|
|
|
<td>Strange slowness when using async library with FFI callbacks</td></tr>
|
|
|
<tr><th>[\#8598](https://gitlab.haskell.org//ghc/ghc/issues/8598)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8598">#8598</a></th>
|
|
|
<td>IO hack in demand analyzer gets in the way of CPR</td></tr>
|
|
|
<tr><th>[\#8589](https://gitlab.haskell.org//ghc/ghc/issues/8589)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8589">#8589</a></th>
|
|
|
<td>Bad choice of loop breaker with INLINABLE/INLINE</td></tr>
|
|
|
<tr><th>[\#8578](https://gitlab.haskell.org//ghc/ghc/issues/8578)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8578">#8578</a></th>
|
|
|
<td>Improvements to SpinLock implementation</td></tr>
|
|
|
<tr><th>[\#8457](https://gitlab.haskell.org//ghc/ghc/issues/8457)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8457">#8457</a></th>
|
|
|
<td>-ffull-laziness does more harm than good</td></tr>
|
|
|
<tr><th>[\#8404](https://gitlab.haskell.org//ghc/ghc/issues/8404)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8404">#8404</a></th>
|
|
|
<td>Default to turning on architecture specific optimizations in the codegen</td></tr>
|
|
|
<tr><th>[\#8354](https://gitlab.haskell.org//ghc/ghc/issues/8354)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8354">#8354</a></th>
|
|
|
<td>Add INLINE (or at least INLINABLE) pragmas for methods of Ord in ghc-prim</td></tr>
|
|
|
<tr><th>[\#8336](https://gitlab.haskell.org//ghc/ghc/issues/8336)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8336">#8336</a></th>
|
|
|
<td>Sinking pass could optimize some assignments better</td></tr>
|
|
|
<tr><th>[\#8327](https://gitlab.haskell.org//ghc/ghc/issues/8327)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8327">#8327</a></th>
|
|
|
<td>Cmm sinking does not eliminate dead code in loops</td></tr>
|
|
|
<tr><th>[\#8326](https://gitlab.haskell.org//ghc/ghc/issues/8326)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8326">#8326</a></th>
|
|
|
<td>Place heap checks common in case alternatives before the case</td></tr>
|
|
|
<tr><th>[\#8317](https://gitlab.haskell.org//ghc/ghc/issues/8317)</th>
|
|
|
<td>Optimize tagToEnum\# at Core level</td></tr>
|
|
|
<tr><th>[\#8313](https://gitlab.haskell.org//ghc/ghc/issues/8313)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8317">#8317</a></th>
|
|
|
<td>Optimize tagToEnum# at Core level</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8313">#8313</a></th>
|
|
|
<td>Poor performance of higher-order functions with unboxing</td></tr>
|
|
|
<tr><th>[\#8311](https://gitlab.haskell.org//ghc/ghc/issues/8311)</th>
|
|
|
<td>suboptimal code generated for even :: Int -\> Bool by NCG (x86, x86_64)</td></tr>
|
|
|
<tr><th>[\#8279](https://gitlab.haskell.org//ghc/ghc/issues/8279)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8311">#8311</a></th>
|
|
|
<td>suboptimal code generated for even :: Int -> Bool by NCG (x86, x86_64)</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8279">#8279</a></th>
|
|
|
<td>bad alignment in code gen yields substantial perf issue</td></tr>
|
|
|
<tr><th>[\#8272](https://gitlab.haskell.org//ghc/ghc/issues/8272)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8272">#8272</a></th>
|
|
|
<td>testing if SpLim=$rbp and Sp=$rsp changed performance at all</td></tr>
|
|
|
<tr><th>[\#8151](https://gitlab.haskell.org//ghc/ghc/issues/8151)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8151">#8151</a></th>
|
|
|
<td>ghc-7.4.2 on OpenIndiana (Solaris) createSubprocess fails</td></tr>
|
|
|
<tr><th>[\#8048](https://gitlab.haskell.org//ghc/ghc/issues/8048)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8048">#8048</a></th>
|
|
|
<td>Register spilling produces ineffecient/highly contending code</td></tr>
|
|
|
<tr><th>[\#8046](https://gitlab.haskell.org//ghc/ghc/issues/8046)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8046">#8046</a></th>
|
|
|
<td>Make the timer management scale better across multicore</td></tr>
|
|
|
<tr><th>[\#8032](https://gitlab.haskell.org//ghc/ghc/issues/8032)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8032">#8032</a></th>
|
|
|
<td>Worker-wrapper transform and NOINLINE trigger bad reboxing behavior</td></tr>
|
|
|
<tr><th>[\#8023](https://gitlab.haskell.org//ghc/ghc/issues/8023)</th>
|
|
|
<td>dph-examples binaries don't use all CPUs</td></tr>
|
|
|
<tr><th>[\#7977](https://gitlab.haskell.org//ghc/ghc/issues/7977)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8023">#8023</a></th>
|
|
|
<td>dph-examples binaries don't use all CPUs</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7977">#7977</a></th>
|
|
|
<td>Optimization: Shift dropped list heads by coeffecient to prevent thunk generation</td></tr>
|
|
|
<tr><th>[\#7741](https://gitlab.haskell.org//ghc/ghc/issues/7741)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7741">#7741</a></th>
|
|
|
<td>Add SIMD support to x86/x86_64 NCG</td></tr>
|
|
|
<tr><th>[\#7679](https://gitlab.haskell.org//ghc/ghc/issues/7679)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7679">#7679</a></th>
|
|
|
<td>Regression in -fregs-graph performance</td></tr>
|
|
|
<tr><th>[\#7647](https://gitlab.haskell.org//ghc/ghc/issues/7647)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7647">#7647</a></th>
|
|
|
<td>UNPACK polymorphic fields</td></tr>
|
|
|
<tr><th>[\#7602](https://gitlab.haskell.org//ghc/ghc/issues/7602)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7602">#7602</a></th>
|
|
|
<td>Threaded RTS performing badly on recent OS X (10.8?)</td></tr>
|
|
|
<tr><th>[\#7596](https://gitlab.haskell.org//ghc/ghc/issues/7596)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7596">#7596</a></th>
|
|
|
<td>Opportunity to improve CSE</td></tr>
|
|
|
<tr><th>[\#7542](https://gitlab.haskell.org//ghc/ghc/issues/7542)</th>
|
|
|
<td>GHC doesn't optimize (strict) composition with id</td></tr>
|
|
|
<tr><th>[\#7511](https://gitlab.haskell.org//ghc/ghc/issues/7511)</th>
|
|
|
<td>Room for GHC runtime improvement \>\~5%, inlining related</td></tr>
|
|
|
<tr><th>[\#7398](https://gitlab.haskell.org//ghc/ghc/issues/7398)</th>
|
|
|
<td>RULES don't apply to a newtype constructor</td></tr>
|
|
|
<tr><th>[\#7378](https://gitlab.haskell.org//ghc/ghc/issues/7378)</th>
|
|
|
<td>Identical alts/bad divInt\# code</td></tr>
|
|
|
<tr><th>[\#7374](https://gitlab.haskell.org//ghc/ghc/issues/7374)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7542">#7542</a></th>
|
|
|
<td>GHC doesn't optimize (strict) composition with id</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7511">#7511</a></th>
|
|
|
<td>Room for GHC runtime improvement >~5%, inlining related</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7398">#7398</a></th>
|
|
|
<td>RULES don't apply to a newtype constructor</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7378">#7378</a></th>
|
|
|
<td>Identical alts/bad divInt# code</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7374">#7374</a></th>
|
|
|
<td>rule not firing</td></tr>
|
|
|
<tr><th>[\#7367](https://gitlab.haskell.org//ghc/ghc/issues/7367)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7367">#7367</a></th>
|
|
|
<td>float-out causes extra allocation</td></tr>
|
|
|
<tr><th>[\#7309](https://gitlab.haskell.org//ghc/ghc/issues/7309)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7309">#7309</a></th>
|
|
|
<td>The Ix instance for (,) leaks space in range</td></tr>
|
|
|
<tr><th>[\#7307](https://gitlab.haskell.org//ghc/ghc/issues/7307)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7307">#7307</a></th>
|
|
|
<td>Share top-level code for strings</td></tr>
|
|
|
<tr><th>[\#7300](https://gitlab.haskell.org//ghc/ghc/issues/7300)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7300">#7300</a></th>
|
|
|
<td>Allow CAFs kept reachable by FFI to be forcibly made unreachable for GC</td></tr>
|
|
|
<tr><th>[\#7283](https://gitlab.haskell.org//ghc/ghc/issues/7283)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7283">#7283</a></th>
|
|
|
<td>Specialise INLINE functions</td></tr>
|
|
|
<tr><th>[\#7273](https://gitlab.haskell.org//ghc/ghc/issues/7273)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7273">#7273</a></th>
|
|
|
<td>Binary size increase in nofib/grep between 7.6.1 and HEAD</td></tr>
|
|
|
<tr><th>[\#7206](https://gitlab.haskell.org//ghc/ghc/issues/7206)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7206">#7206</a></th>
|
|
|
<td>Implement cheap build</td></tr>
|
|
|
<tr><th>[\#7114](https://gitlab.haskell.org//ghc/ghc/issues/7114)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7114">#7114</a></th>
|
|
|
<td>Cannot recover (good) inlining behaviour from 7.0.2 in 7.4.1</td></tr>
|
|
|
<tr><th>[\#7109](https://gitlab.haskell.org//ghc/ghc/issues/7109)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7109">#7109</a></th>
|
|
|
<td>Inlining depends on datatype size, even with INLINE pragmas</td></tr>
|
|
|
<tr><th>[\#7080](https://gitlab.haskell.org//ghc/ghc/issues/7080)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7080">#7080</a></th>
|
|
|
<td>Make RULES and SPECIALISE more consistent</td></tr>
|
|
|
<tr><th>[\#7063](https://gitlab.haskell.org//ghc/ghc/issues/7063)</th>
|
|
|
<td>Register allocators can't handle non-uniform register sets</td></tr>
|
|
|
<tr><th>[\#6092](https://gitlab.haskell.org//ghc/ghc/issues/6092)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7063">#7063</a></th>
|
|
|
<td>Register allocators can't handle non-uniform register sets</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/6092">#6092</a></th>
|
|
|
<td>Liberate case not happening</td></tr>
|
|
|
<tr><th>[\#6070](https://gitlab.haskell.org//ghc/ghc/issues/6070)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/6070">#6070</a></th>
|
|
|
<td>Fun with the demand analyser</td></tr>
|
|
|
<tr><th>[\#5928](https://gitlab.haskell.org//ghc/ghc/issues/5928)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5928">#5928</a></th>
|
|
|
<td>INLINABLE fails to specialize in presence of simple wrapper</td></tr>
|
|
|
<tr><th>[\#5834](https://gitlab.haskell.org//ghc/ghc/issues/5834)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5834">#5834</a></th>
|
|
|
<td>Allow both INLINE and INLINABLE for the same function</td></tr>
|
|
|
<tr><th>[\#5775](https://gitlab.haskell.org//ghc/ghc/issues/5775)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5775">#5775</a></th>
|
|
|
<td>Inconsistency in demand analysis</td></tr>
|
|
|
<tr><th>[\#5645](https://gitlab.haskell.org//ghc/ghc/issues/5645)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5645">#5645</a></th>
|
|
|
<td>Sharing across functions causing space leak</td></tr>
|
|
|
<tr><th>[\#5567](https://gitlab.haskell.org//ghc/ghc/issues/5567)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5567">#5567</a></th>
|
|
|
<td>LLVM: Improve alias analysis / performance</td></tr>
|
|
|
<tr><th>[\#5463](https://gitlab.haskell.org//ghc/ghc/issues/5463)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5463">#5463</a></th>
|
|
|
<td>SPECIALISE pragmas generated from Template Haskell are ignored</td></tr>
|
|
|
<tr><th>[\#5444](https://gitlab.haskell.org//ghc/ghc/issues/5444)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5444">#5444</a></th>
|
|
|
<td>Slow 64-bit primops on 32 bit system</td></tr>
|
|
|
<tr><th>[\#5355](https://gitlab.haskell.org//ghc/ghc/issues/5355)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5355">#5355</a></th>
|
|
|
<td>Link plugins against existing libHSghc</td></tr>
|
|
|
<tr><th>[\#5344](https://gitlab.haskell.org//ghc/ghc/issues/5344)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5344">#5344</a></th>
|
|
|
<td>CSE should look through coercions</td></tr>
|
|
|
<tr><th>[\#5326](https://gitlab.haskell.org//ghc/ghc/issues/5326)</th>
|
|
|
<td>Polymorphic instances aren't automatically specialised</td></tr>
|
|
|
<tr><th>[\#5302](https://gitlab.haskell.org//ghc/ghc/issues/5302)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5326">#5326</a></th>
|
|
|
<td>Polymorphic instances aren't automatically specialised</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5302">#5302</a></th>
|
|
|
<td>Unused arguments in join points</td></tr>
|
|
|
<tr><th>[\#5298](https://gitlab.haskell.org//ghc/ghc/issues/5298)</th>
|
|
|
<td>Inlined functions aren't fully specialised</td></tr>
|
|
|
<tr><th>[\#5262](https://gitlab.haskell.org//ghc/ghc/issues/5262)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5298">#5298</a></th>
|
|
|
<td>Inlined functions aren't fully specialised</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5262">#5262</a></th>
|
|
|
<td>Compiling with -O makes some expressions too lazy and causes space leaks</td></tr>
|
|
|
<tr><th>[\#5218](https://gitlab.haskell.org//ghc/ghc/issues/5218)</th>
|
|
|
<td>Add unpackCStringLen\# to create Strings from string literals</td></tr>
|
|
|
<tr><th>[\#5171](https://gitlab.haskell.org//ghc/ghc/issues/5171)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5218">#5218</a></th>
|
|
|
<td>Add unpackCStringLen# to create Strings from string literals</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5171">#5171</a></th>
|
|
|
<td>Misfeature of Cmm optimiser: no way to extract a branch of expression into a separate statement</td></tr>
|
|
|
<tr><th>[\#5075](https://gitlab.haskell.org//ghc/ghc/issues/5075)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5075">#5075</a></th>
|
|
|
<td>CPR optimisation for sum types if only one constructor is used</td></tr>
|
|
|
<tr><th>[\#5059](https://gitlab.haskell.org//ghc/ghc/issues/5059)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5059">#5059</a></th>
|
|
|
<td>Pragma to SPECIALISE on value arguments</td></tr>
|
|
|
<tr><th>[\#4960](https://gitlab.haskell.org//ghc/ghc/issues/4960)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4960">#4960</a></th>
|
|
|
<td>Better inlining test in CoreUnfold</td></tr>
|
|
|
<tr><th>[\#4945](https://gitlab.haskell.org//ghc/ghc/issues/4945)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4945">#4945</a></th>
|
|
|
<td>Another SpecConstr infelicity</td></tr>
|
|
|
<tr><th>[\#4941](https://gitlab.haskell.org//ghc/ghc/issues/4941)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4941">#4941</a></th>
|
|
|
<td>SpecConstr generates functions that do not use their arguments</td></tr>
|
|
|
<tr><th>[\#4937](https://gitlab.haskell.org//ghc/ghc/issues/4937)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4937">#4937</a></th>
|
|
|
<td>Remove indirections caused by sum types, such as Maybe</td></tr>
|
|
|
<tr><th>[\#4833](https://gitlab.haskell.org//ghc/ghc/issues/4833)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4833">#4833</a></th>
|
|
|
<td>Finding the right loop breaker</td></tr>
|
|
|
<tr><th>[\#4831](https://gitlab.haskell.org//ghc/ghc/issues/4831)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4831">#4831</a></th>
|
|
|
<td>Too many specialisations in SpecConstr</td></tr>
|
|
|
<tr><th>[\#4823](https://gitlab.haskell.org//ghc/ghc/issues/4823)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4823">#4823</a></th>
|
|
|
<td>Loop strength reduction for array indexing</td></tr>
|
|
|
<tr><th>[\#4470](https://gitlab.haskell.org//ghc/ghc/issues/4470)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4470">#4470</a></th>
|
|
|
<td>Loop optimization: identical counters</td></tr>
|
|
|
<tr><th>[\#4301](https://gitlab.haskell.org//ghc/ghc/issues/4301)</th>
|
|
|
<td>Optimisations give bad core for foldl' (flip seq) ()</td></tr>
|
|
|
<tr><th>[\#4101](https://gitlab.haskell.org//ghc/ghc/issues/4101)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4301">#4301</a></th>
|
|
|
<td>Optimisations give bad core for foldl' (flip seq) ()</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4101">#4101</a></th>
|
|
|
<td>Primitive constant unfolding</td></tr>
|
|
|
<tr><th>[\#4096](https://gitlab.haskell.org//ghc/ghc/issues/4096)</th>
|
|
|
<td>New primops for indexing: index\*OffAddrUsing\# etc</td></tr>
|
|
|
<tr><th>[\#4081](https://gitlab.haskell.org//ghc/ghc/issues/4081)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4096">#4096</a></th>
|
|
|
<td>New primops for indexing: index*OffAddrUsing# etc</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4081">#4081</a></th>
|
|
|
<td>Strict constructor fields inspected in loop</td></tr>
|
|
|
<tr><th>[\#4005](https://gitlab.haskell.org//ghc/ghc/issues/4005)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4005">#4005</a></th>
|
|
|
<td>Bad behaviour in the generational GC with paraffins -O2</td></tr>
|
|
|
<tr><th>[\#3781](https://gitlab.haskell.org//ghc/ghc/issues/3781)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3781">#3781</a></th>
|
|
|
<td>Improve inlining for local functions</td></tr>
|
|
|
<tr><th>[\#3767](https://gitlab.haskell.org//ghc/ghc/issues/3767)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3767">#3767</a></th>
|
|
|
<td>SpecConstr for join points</td></tr>
|
|
|
<tr><th>[\#3765](https://gitlab.haskell.org//ghc/ghc/issues/3765)</th>
|
|
|
<td>Rules should "look through" case binders too</td></tr>
|
|
|
<tr><th>[\#3755](https://gitlab.haskell.org//ghc/ghc/issues/3755)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3765">#3765</a></th>
|
|
|
<td>Rules should "look through" case binders too</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3755">#3755</a></th>
|
|
|
<td>Improve join point inlining</td></tr>
|
|
|
<tr><th>[\#3744](https://gitlab.haskell.org//ghc/ghc/issues/3744)</th>
|
|
|
<td>Comparisons against minBound/maxBound not optimised for (Int\|Word)(8\|16\|32)</td></tr>
|
|
|
<tr><th>[\#3606](https://gitlab.haskell.org//ghc/ghc/issues/3606)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3744">#3744</a></th>
|
|
|
<td>Comparisons against minBound/maxBound not optimised for (Int|Word)(8|16|32)</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3606">#3606</a></th>
|
|
|
<td>The Ord instance for unboxed arrays is very inefficient</td></tr>
|
|
|
<tr><th>[\#3557](https://gitlab.haskell.org//ghc/ghc/issues/3557)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3557">#3557</a></th>
|
|
|
<td>CPU Vector instructions in GHC.Prim</td></tr>
|
|
|
<tr><th>[\#3462](https://gitlab.haskell.org//ghc/ghc/issues/3462)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3462">#3462</a></th>
|
|
|
<td>New codegen: allocate large objects using allocateLocal()</td></tr>
|
|
|
<tr><th>[\#3458](https://gitlab.haskell.org//ghc/ghc/issues/3458)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3458">#3458</a></th>
|
|
|
<td>Allocation where none should happen</td></tr>
|
|
|
<tr><th>[\#3138](https://gitlab.haskell.org//ghc/ghc/issues/3138)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3138">#3138</a></th>
|
|
|
<td>Returning a known constructor: GHC generates terrible code for cmonad</td></tr>
|
|
|
<tr><th>[\#3107](https://gitlab.haskell.org//ghc/ghc/issues/3107)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3107">#3107</a></th>
|
|
|
<td>Over-eager GC when blocked on a signal in the non-threaded runtime</td></tr>
|
|
|
<tr><th>[\#3073](https://gitlab.haskell.org//ghc/ghc/issues/3073)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3073">#3073</a></th>
|
|
|
<td>Avoid reconstructing dictionaries in recursive instance methods</td></tr>
|
|
|
<tr><th>[\#3061](https://gitlab.haskell.org//ghc/ghc/issues/3061)</th>
|
|
|
<td>GHC's GC default heap growth strategy is not as good as other runtimes</td></tr>
|
|
|
<tr><th>[\#3055](https://gitlab.haskell.org//ghc/ghc/issues/3055)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3061">#3061</a></th>
|
|
|
<td>GHC's GC default heap growth strategy is not as good as other runtimes</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3055">#3055</a></th>
|
|
|
<td>Int / Word / IntN / WordN are unequally optimized</td></tr>
|
|
|
<tr><th>[\#3034](https://gitlab.haskell.org//ghc/ghc/issues/3034)</th>
|
|
|
<td>divInt\# floated into a position which leads to low arity</td></tr>
|
|
|
<tr><th>[\#2731](https://gitlab.haskell.org//ghc/ghc/issues/2731)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3034">#3034</a></th>
|
|
|
<td>divInt# floated into a position which leads to low arity</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2731">#2731</a></th>
|
|
|
<td>Avoid unnecessary evaluation when unpacking constructors</td></tr>
|
|
|
<tr><th>[\#2642](https://gitlab.haskell.org//ghc/ghc/issues/2642)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2642">#2642</a></th>
|
|
|
<td>Improve SpecConstr for join points</td></tr>
|
|
|
<tr><th>[\#2625](https://gitlab.haskell.org//ghc/ghc/issues/2625)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2625">#2625</a></th>
|
|
|
<td>Unexpected -ddump-simpl output for derived Ord instance and UNPACKed fields</td></tr>
|
|
|
<tr><th>[\#2607](https://gitlab.haskell.org//ghc/ghc/issues/2607)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2607">#2607</a></th>
|
|
|
<td>Inlining defeats selector thunk optimisation</td></tr>
|
|
|
<tr><th>[\#2598](https://gitlab.haskell.org//ghc/ghc/issues/2598)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2598">#2598</a></th>
|
|
|
<td>Avoid excessive specialisation in SpecConstr</td></tr>
|
|
|
<tr><th>[\#2465](https://gitlab.haskell.org//ghc/ghc/issues/2465)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2465">#2465</a></th>
|
|
|
<td>Fusion of recursive functions</td></tr>
|
|
|
<tr><th>[\#2439](https://gitlab.haskell.org//ghc/ghc/issues/2439)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2439">#2439</a></th>
|
|
|
<td>Missed optimisation with dictionaries and loops</td></tr>
|
|
|
<tr><th>[\#2387](https://gitlab.haskell.org//ghc/ghc/issues/2387)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2387">#2387</a></th>
|
|
|
<td>Optimizer misses unboxing opportunity</td></tr>
|
|
|
<tr><th>[\#2374](https://gitlab.haskell.org//ghc/ghc/issues/2374)</th>
|
|
|
<td>MutableByteArray\# is slower than Addr\#</td></tr>
|
|
|
<tr><th>[\#2289](https://gitlab.haskell.org//ghc/ghc/issues/2289)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2374">#2374</a></th>
|
|
|
<td>MutableByteArray# is slower than Addr#</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2289">#2289</a></th>
|
|
|
<td>Needless reboxing of values when returning from a tight loop</td></tr>
|
|
|
<tr><th>[\#2273](https://gitlab.haskell.org//ghc/ghc/issues/2273)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2273">#2273</a></th>
|
|
|
<td>inlining defeats seq</td></tr>
|
|
|
<tr><th>[\#2269](https://gitlab.haskell.org//ghc/ghc/issues/2269)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2269">#2269</a></th>
|
|
|
<td>Word type to Double or Float conversions are slower than Int conversions</td></tr>
|
|
|
<tr><th>[\#2255](https://gitlab.haskell.org//ghc/ghc/issues/2255)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2255">#2255</a></th>
|
|
|
<td>Improve SpecConstr for free variables</td></tr>
|
|
|
<tr><th>[\#2132](https://gitlab.haskell.org//ghc/ghc/issues/2132)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2132">#2132</a></th>
|
|
|
<td>Optimise nested comparisons</td></tr>
|
|
|
<tr><th>[\#2028](https://gitlab.haskell.org//ghc/ghc/issues/2028)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2028">#2028</a></th>
|
|
|
<td>STM slightly conservative on write-only transactions</td></tr>
|
|
|
<tr><th>[\#1687](https://gitlab.haskell.org//ghc/ghc/issues/1687)</th>
|
|
|
<td>A faster (\^)-function.</td></tr>
|
|
|
<tr><th>[\#1600](https://gitlab.haskell.org//ghc/ghc/issues/1600)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/1687">#1687</a></th>
|
|
|
<td>A faster (^)-function.</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/1600">#1600</a></th>
|
|
|
<td>Optimisation: CPR the results of IO</td></tr>
|
|
|
<tr><th>[\#1544](https://gitlab.haskell.org//ghc/ghc/issues/1544)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/1544">#1544</a></th>
|
|
|
<td>Derived Read instances for recursive datatypes with infix constructors are too inefficient</td></tr>
|
|
|
<tr><th>[\#1498](https://gitlab.haskell.org//ghc/ghc/issues/1498)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/1498">#1498</a></th>
|
|
|
<td>Optimisation: eliminate unnecessary heap check in recursive function</td></tr>
|
|
|
<tr><th>[\#1216](https://gitlab.haskell.org//ghc/ghc/issues/1216)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/1216">#1216</a></th>
|
|
|
<td>Missed opportunity for let-no-esape</td></tr>
|
|
|
<tr><th>[\#1168](https://gitlab.haskell.org//ghc/ghc/issues/1168)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/1168">#1168</a></th>
|
|
|
<td>Optimisation sometimes decreases sharing in IO code</td></tr>
|
|
|
<tr><th>[\#1147](https://gitlab.haskell.org//ghc/ghc/issues/1147)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/1147">#1147</a></th>
|
|
|
<td>Quadratic behaviour in the compacting GC</td></tr>
|
|
|
<tr><th>[\#932](https://gitlab.haskell.org//ghc/ghc/issues/932)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/932">#932</a></th>
|
|
|
<td>Improve inlining</td></tr>
|
|
|
<tr><th>[\#917](https://gitlab.haskell.org//ghc/ghc/issues/917)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/917">#917</a></th>
|
|
|
<td>-O introduces space leak</td></tr>
|
|
|
<tr><th>[\#855](https://gitlab.haskell.org//ghc/ghc/issues/855)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/855">#855</a></th>
|
|
|
<td>Improvements to SpecConstr</td></tr>
|
|
|
<tr><th>[\#728](https://gitlab.haskell.org//ghc/ghc/issues/728)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/728">#728</a></th>
|
|
|
<td>switch to compacting collection when swapping occurs</td></tr>
|
|
|
<tr><th>[\#605](https://gitlab.haskell.org//ghc/ghc/issues/605)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/605">#605</a></th>
|
|
|
<td>Optimisation: strict enumerations</td></tr>
|
|
|
<tr><th>[\#149](https://gitlab.haskell.org//ghc/ghc/issues/149)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/149">#149</a></th>
|
|
|
<td>missed CSE opportunity</td></tr></table>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
**Closed Tickets:**
|
|
|
|
|
|
<table><tr><th>[\#16109](https://gitlab.haskell.org//ghc/ghc/issues/16109)</th>
|
|
|
<table><tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/16109">#16109</a></th>
|
|
|
<td>cabal install H under Windows 10 does not terminate</td></tr>
|
|
|
<tr><th>[\#15802](https://gitlab.haskell.org//ghc/ghc/issues/15802)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15802">#15802</a></th>
|
|
|
<td>Inlining of constant fails when both cross-module and recursive</td></tr>
|
|
|
<tr><th>[\#15227](https://gitlab.haskell.org//ghc/ghc/issues/15227)</th>
|
|
|
<td>Add PrelRules for par\#</td></tr>
|
|
|
<tr><th>[\#15226](https://gitlab.haskell.org//ghc/ghc/issues/15226)</th>
|
|
|
<td>GHC doesn't know that seq\# produces something in WHNF</td></tr>
|
|
|
<tr><th>[\#15143](https://gitlab.haskell.org//ghc/ghc/issues/15143)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15227">#15227</a></th>
|
|
|
<td>Add PrelRules for par#</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15226">#15226</a></th>
|
|
|
<td>GHC doesn't know that seq# produces something in WHNF</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15143">#15143</a></th>
|
|
|
<td>Passing an IO value through several functions results in program hanging.</td></tr>
|
|
|
<tr><th>[\#15131](https://gitlab.haskell.org//ghc/ghc/issues/15131)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/15131">#15131</a></th>
|
|
|
<td>Speed up certain Foldable NonEmpty methods</td></tr>
|
|
|
<tr><th>[\#14978](https://gitlab.haskell.org//ghc/ghc/issues/14978)</th>
|
|
|
<td>GADTs don't seem to unpack properly</td></tr>
|
|
|
<tr><th>[\#14855](https://gitlab.haskell.org//ghc/ghc/issues/14855)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14978">#14978</a></th>
|
|
|
<td>GADTs don't seem to unpack properly</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14855">#14855</a></th>
|
|
|
<td>Implementation of liftA2 for Const has high arity</td></tr>
|
|
|
<tr><th>[\#14790](https://gitlab.haskell.org//ghc/ghc/issues/14790)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14790">#14790</a></th>
|
|
|
<td>eqTypeRep does not inline</td></tr>
|
|
|
<tr><th>[\#14519](https://gitlab.haskell.org//ghc/ghc/issues/14519)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14519">#14519</a></th>
|
|
|
<td>Exponential runtime performance regression in GHC 8.2 + Data.Text.Lazy + Text.RE.TDFA</td></tr>
|
|
|
<tr><th>[\#14336](https://gitlab.haskell.org//ghc/ghc/issues/14336)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14336">#14336</a></th>
|
|
|
<td>ghci leaks memory</td></tr>
|
|
|
<tr><th>[\#14258](https://gitlab.haskell.org//ghc/ghc/issues/14258)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14258">#14258</a></th>
|
|
|
<td>n-body runtime regressed badly due to CoreFVs patch</td></tr>
|
|
|
<tr><th>[\#14240](https://gitlab.haskell.org//ghc/ghc/issues/14240)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14240">#14240</a></th>
|
|
|
<td>CSE’ing w/w’ed code regresses program runtime</td></tr>
|
|
|
<tr><th>[\#14224](https://gitlab.haskell.org//ghc/ghc/issues/14224)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14224">#14224</a></th>
|
|
|
<td>zipWith does not inline</td></tr>
|
|
|
<tr><th>[\#14192](https://gitlab.haskell.org//ghc/ghc/issues/14192)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14192">#14192</a></th>
|
|
|
<td>Change to 1TB VIRT allocation makes it impossible to core-dump Haskell programs</td></tr>
|
|
|
<tr><th>[\#14187](https://gitlab.haskell.org//ghc/ghc/issues/14187)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14187">#14187</a></th>
|
|
|
<td>Transpose hangs on infinite by finite lists</td></tr>
|
|
|
<tr><th>[\#14140](https://gitlab.haskell.org//ghc/ghc/issues/14140)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14140">#14140</a></th>
|
|
|
<td>Better treatment for dataToTag</td></tr>
|
|
|
<tr><th>[\#14052](https://gitlab.haskell.org//ghc/ghc/issues/14052)</th>
|
|
|
<td>Significant GHCi speed regression with :module and \`let\` in GHC 8.2.1</td></tr>
|
|
|
<tr><th>[\#13999](https://gitlab.haskell.org//ghc/ghc/issues/13999)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/14052">#14052</a></th>
|
|
|
<td>Significant GHCi speed regression with :module and `let` in GHC 8.2.1</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13999">#13999</a></th>
|
|
|
<td>Simple function not inlined within declaration marked NOINLINE</td></tr>
|
|
|
<tr><th>[\#13982](https://gitlab.haskell.org//ghc/ghc/issues/13982)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13982">#13982</a></th>
|
|
|
<td>HEAD GHC+Cabal uses too much memory</td></tr>
|
|
|
<tr><th>[\#13930](https://gitlab.haskell.org//ghc/ghc/issues/13930)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13930">#13930</a></th>
|
|
|
<td>Cabal configure regresses in space/time</td></tr>
|
|
|
<tr><th>[\#13690](https://gitlab.haskell.org//ghc/ghc/issues/13690)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13690">#13690</a></th>
|
|
|
<td>Running profiling tests in the GHCi way is extremely slow</td></tr>
|
|
|
<tr><th>[\#13654](https://gitlab.haskell.org//ghc/ghc/issues/13654)</th>
|
|
|
<td>Optimize casMutVar\# for single-threaded runtime</td></tr>
|
|
|
<tr><th>[\#13623](https://gitlab.haskell.org//ghc/ghc/issues/13623)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13654">#13654</a></th>
|
|
|
<td>Optimize casMutVar# for single-threaded runtime</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13623">#13623</a></th>
|
|
|
<td>join points produce bad code for stream fusion</td></tr>
|
|
|
<tr><th>[\#13604](https://gitlab.haskell.org//ghc/ghc/issues/13604)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13604">#13604</a></th>
|
|
|
<td>ghci no longer loads dynamic .o files by default if they were built with -O</td></tr>
|
|
|
<tr><th>[\#13566](https://gitlab.haskell.org//ghc/ghc/issues/13566)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13566">#13566</a></th>
|
|
|
<td>Bigger core size in ghc8 compared to ghc7</td></tr>
|
|
|
<tr><th>[\#13536](https://gitlab.haskell.org//ghc/ghc/issues/13536)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13536">#13536</a></th>
|
|
|
<td>Program which terminates instantly in GHC 8.0.2 runs for minutes with 8.2.1</td></tr>
|
|
|
<tr><th>[\#13422](https://gitlab.haskell.org//ghc/ghc/issues/13422)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13422">#13422</a></th>
|
|
|
<td>INLINE CONLIKE sometimes fails to inline</td></tr>
|
|
|
<tr><th>[\#13376](https://gitlab.haskell.org//ghc/ghc/issues/13376)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13376">#13376</a></th>
|
|
|
<td>GHC fails to specialize a pair of polymorphic INLINABLE functions</td></tr>
|
|
|
<tr><th>[\#13328](https://gitlab.haskell.org//ghc/ghc/issues/13328)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13328">#13328</a></th>
|
|
|
<td>Foldable, Functor, and Traversable deriving handle phantom types badly</td></tr>
|
|
|
<tr><th>[\#13288](https://gitlab.haskell.org//ghc/ghc/issues/13288)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13288">#13288</a></th>
|
|
|
<td>Resident set size exceeds +RTS -M limit with large nurseries</td></tr>
|
|
|
<tr><th>[\#13246](https://gitlab.haskell.org//ghc/ghc/issues/13246)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13246">#13246</a></th>
|
|
|
<td>hPutBuf issues unnecessary empty write syscalls for large writes</td></tr>
|
|
|
<tr><th>[\#13228](https://gitlab.haskell.org//ghc/ghc/issues/13228)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13228">#13228</a></th>
|
|
|
<td>Surprising inlining failure</td></tr>
|
|
|
<tr><th>[\#13218](https://gitlab.haskell.org//ghc/ghc/issues/13218)</th>
|
|
|
<td>\<$ is bad in derived functor instances</td></tr>
|
|
|
<tr><th>[\#13040](https://gitlab.haskell.org//ghc/ghc/issues/13040)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13218">#13218</a></th>
|
|
|
<td><$ is bad in derived functor instances</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13040">#13040</a></th>
|
|
|
<td>realToFrac into Complex Double has no specialization</td></tr>
|
|
|
<tr><th>[\#13025](https://gitlab.haskell.org//ghc/ghc/issues/13025)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13025">#13025</a></th>
|
|
|
<td>Type family reduction irregularity (change from 7.10.3 to 8.0.1)</td></tr>
|
|
|
<tr><th>[\#13001](https://gitlab.haskell.org//ghc/ghc/issues/13001)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/13001">#13001</a></th>
|
|
|
<td>EnumFromThenTo is is not a good producer</td></tr>
|
|
|
<tr><th>[\#12996](https://gitlab.haskell.org//ghc/ghc/issues/12996)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12996">#12996</a></th>
|
|
|
<td>Memory leak in recursion when switching from -O1 to -O2</td></tr>
|
|
|
<tr><th>[\#12990](https://gitlab.haskell.org//ghc/ghc/issues/12990)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12990">#12990</a></th>
|
|
|
<td>Partially applied constructors with unpacked fields simplified badly</td></tr>
|
|
|
<tr><th>[\#12964](https://gitlab.haskell.org//ghc/ghc/issues/12964)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12964">#12964</a></th>
|
|
|
<td>Runtime regression to RTS change</td></tr>
|
|
|
<tr><th>[\#12804](https://gitlab.haskell.org//ghc/ghc/issues/12804)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12804">#12804</a></th>
|
|
|
<td>forever contains a space leak</td></tr>
|
|
|
<tr><th>[\#12781](https://gitlab.haskell.org//ghc/ghc/issues/12781)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12781">#12781</a></th>
|
|
|
<td>Significantly higher allocation with INLINE vs NOINLINE</td></tr>
|
|
|
<tr><th>[\#12603](https://gitlab.haskell.org//ghc/ghc/issues/12603)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12603">#12603</a></th>
|
|
|
<td>INLINE and manually inlining produce different code</td></tr>
|
|
|
<tr><th>[\#12525](https://gitlab.haskell.org//ghc/ghc/issues/12525)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12525">#12525</a></th>
|
|
|
<td>Internal identifiers creeping into :show bindings</td></tr>
|
|
|
<tr><th>[\#12378](https://gitlab.haskell.org//ghc/ghc/issues/12378)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12378">#12378</a></th>
|
|
|
<td>Not enough inlining happens with single-method type classes</td></tr>
|
|
|
<tr><th>[\#12354](https://gitlab.haskell.org//ghc/ghc/issues/12354)</th>
|
|
|
<td>Word foldl' isn't optimized as well as Int foldl'</td></tr>
|
|
|
<tr><th>[\#12241](https://gitlab.haskell.org//ghc/ghc/issues/12241)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12354">#12354</a></th>
|
|
|
<td>Word foldl' isn't optimized as well as Int foldl'</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12241">#12241</a></th>
|
|
|
<td>Surprising constructor accumulation</td></tr>
|
|
|
<tr><th>[\#12217](https://gitlab.haskell.org//ghc/ghc/issues/12217)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12217">#12217</a></th>
|
|
|
<td>PowerPC NCG: Remove TOC save for calls.</td></tr>
|
|
|
<tr><th>[\#12129](https://gitlab.haskell.org//ghc/ghc/issues/12129)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12129">#12129</a></th>
|
|
|
<td>Optimize the implementation of minusInteger in the integer-gmp package</td></tr>
|
|
|
<tr><th>[\#12022](https://gitlab.haskell.org//ghc/ghc/issues/12022)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/12022">#12022</a></th>
|
|
|
<td>unsafeShiftL and unsafeShiftR are not marked as INLINE</td></tr>
|
|
|
<tr><th>[\#11989](https://gitlab.haskell.org//ghc/ghc/issues/11989)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11989">#11989</a></th>
|
|
|
<td>Performance bug reading large-exponent float without explicit type</td></tr>
|
|
|
<tr><th>[\#11965](https://gitlab.haskell.org//ghc/ghc/issues/11965)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11965">#11965</a></th>
|
|
|
<td>USE_PTHREAD_FOR_ITIMER causes unnecessary wake-ups</td></tr>
|
|
|
<tr><th>[\#11808](https://gitlab.haskell.org//ghc/ghc/issues/11808)</th>
|
|
|
<td>nofib's cryptarithm1 regresses due to deferred inlining of Int's Ord operations</td></tr>
|
|
|
<tr><th>[\#11795](https://gitlab.haskell.org//ghc/ghc/issues/11795)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11808">#11808</a></th>
|
|
|
<td>nofib's cryptarithm1 regresses due to deferred inlining of Int's Ord operations</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11795">#11795</a></th>
|
|
|
<td>Performance issues with replicateM_</td></tr>
|
|
|
<tr><th>[\#11725](https://gitlab.haskell.org//ghc/ghc/issues/11725)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11725">#11725</a></th>
|
|
|
<td>Performance Regression from 7.8.3 to 7.10.3</td></tr>
|
|
|
<tr><th>[\#11710](https://gitlab.haskell.org//ghc/ghc/issues/11710)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11710">#11710</a></th>
|
|
|
<td>Fusion of a simple listArray call is very fragile</td></tr>
|
|
|
<tr><th>[\#11707](https://gitlab.haskell.org//ghc/ghc/issues/11707)</th>
|
|
|
<td>Don't desugar large lists with build</td></tr>
|
|
|
<tr><th>[\#11701](https://gitlab.haskell.org//ghc/ghc/issues/11701)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11707">#11707</a></th>
|
|
|
<td>Don't desugar large lists with build</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11701">#11701</a></th>
|
|
|
<td>ghc generates significant slower code</td></tr>
|
|
|
<tr><th>[\#11688](https://gitlab.haskell.org//ghc/ghc/issues/11688)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11688">#11688</a></th>
|
|
|
<td>Bytestring break failing rewrite to breakByte and failing to eliminate boxing/unboxing</td></tr>
|
|
|
<tr><th>[\#11568](https://gitlab.haskell.org//ghc/ghc/issues/11568)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11568">#11568</a></th>
|
|
|
<td>Regression in nofib/shootout/k-nucleotide</td></tr>
|
|
|
<tr><th>[\#11565](https://gitlab.haskell.org//ghc/ghc/issues/11565)</th>
|
|
|
<td>Restore code to handle '-fmax-worker-args' flag</td></tr>
|
|
|
<tr><th>[\#11533](https://gitlab.haskell.org//ghc/ghc/issues/11533)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11565">#11565</a></th>
|
|
|
<td>Restore code to handle '-fmax-worker-args' flag</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11533">#11533</a></th>
|
|
|
<td>Stack check not optimized out even if it could be</td></tr>
|
|
|
<tr><th>[\#11486](https://gitlab.haskell.org//ghc/ghc/issues/11486)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11486">#11486</a></th>
|
|
|
<td>info tables are no longer aligned</td></tr>
|
|
|
<tr><th>[\#11383](https://gitlab.haskell.org//ghc/ghc/issues/11383)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11383">#11383</a></th>
|
|
|
<td>CAFs lose sharing due to implicit call stacks</td></tr>
|
|
|
<tr><th>[\#11382](https://gitlab.haskell.org//ghc/ghc/issues/11382)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11382">#11382</a></th>
|
|
|
<td>Optimize Data.Char</td></tr>
|
|
|
<tr><th>[\#11372](https://gitlab.haskell.org//ghc/ghc/issues/11372)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11372">#11372</a></th>
|
|
|
<td>Loopification does not trigger for IO even if it could</td></tr>
|
|
|
<tr><th>[\#11365](https://gitlab.haskell.org//ghc/ghc/issues/11365)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11365">#11365</a></th>
|
|
|
<td>Worse performance with -O</td></tr>
|
|
|
<tr><th>[\#11318](https://gitlab.haskell.org//ghc/ghc/issues/11318)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11318">#11318</a></th>
|
|
|
<td>Data.Text.length allocates one closure per character</td></tr>
|
|
|
<tr><th>[\#11284](https://gitlab.haskell.org//ghc/ghc/issues/11284)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11284">#11284</a></th>
|
|
|
<td>Lambda-lifting fails in simple Text example</td></tr>
|
|
|
<tr><th>[\#11273](https://gitlab.haskell.org//ghc/ghc/issues/11273)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11273">#11273</a></th>
|
|
|
<td>PowerPC NCG: Assign all STG float and double regs to PowerPC registers</td></tr>
|
|
|
<tr><th>[\#11272](https://gitlab.haskell.org//ghc/ghc/issues/11272)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11272">#11272</a></th>
|
|
|
<td>Overloaded state-monadic function is not specialised</td></tr>
|
|
|
<tr><th>[\#11222](https://gitlab.haskell.org//ghc/ghc/issues/11222)</th>
|
|
|
<td>Teach strictness analysis about \`catch\`-like operations</td></tr>
|
|
|
<tr><th>[\#11116](https://gitlab.haskell.org//ghc/ghc/issues/11116)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11222">#11222</a></th>
|
|
|
<td>Teach strictness analysis about `catch`-like operations</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11116">#11116</a></th>
|
|
|
<td>GC reports memory in use way below the actual</td></tr>
|
|
|
<tr><th>[\#11054](https://gitlab.haskell.org//ghc/ghc/issues/11054)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/11054">#11054</a></th>
|
|
|
<td>GHC on Windows could not use more than 64 logical processors</td></tr>
|
|
|
<tr><th>[\#10830](https://gitlab.haskell.org//ghc/ghc/issues/10830)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10830">#10830</a></th>
|
|
|
<td>maximumBy has a space leak</td></tr>
|
|
|
<tr><th>[\#10825](https://gitlab.haskell.org//ghc/ghc/issues/10825)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10825">#10825</a></th>
|
|
|
<td>Poor performance of optimized code.</td></tr>
|
|
|
<tr><th>[\#10788](https://gitlab.haskell.org//ghc/ghc/issues/10788)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10788">#10788</a></th>
|
|
|
<td>performance regression involving minimum</td></tr>
|
|
|
<tr><th>[\#10780](https://gitlab.haskell.org//ghc/ghc/issues/10780)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10780">#10780</a></th>
|
|
|
<td>Weak reference is still alive if key is alive, but weak reference itself not reachable</td></tr>
|
|
|
<tr><th>[\#10750](https://gitlab.haskell.org//ghc/ghc/issues/10750)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10750">#10750</a></th>
|
|
|
<td>silly assembly for comparing Doubles</td></tr>
|
|
|
<tr><th>[\#10744](https://gitlab.haskell.org//ghc/ghc/issues/10744)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10744">#10744</a></th>
|
|
|
<td>Allow oneShot to work with unboxed types</td></tr>
|
|
|
<tr><th>[\#10720](https://gitlab.haskell.org//ghc/ghc/issues/10720)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10720">#10720</a></th>
|
|
|
<td>New GHC fails to specialize imported function</td></tr>
|
|
|
<tr><th>[\#10717](https://gitlab.haskell.org//ghc/ghc/issues/10717)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10717">#10717</a></th>
|
|
|
<td>fannkuch-redux allocations increase by factor of 10000 between 7.4.2 and 7.6.3</td></tr>
|
|
|
<tr><th>[\#10678](https://gitlab.haskell.org//ghc/ghc/issues/10678)</th>
|
|
|
<td>integer-gmp's runS seems unnecessarily expensive</td></tr>
|
|
|
<tr><th>[\#10677](https://gitlab.haskell.org//ghc/ghc/issues/10677)</th>
|
|
|
<td>slightly silly assembly for testing whether a Word\# is 0\#\#</td></tr>
|
|
|
<tr><th>[\#10676](https://gitlab.haskell.org//ghc/ghc/issues/10676)</th>
|
|
|
<td>silly assembly for comparing the result of comparisons that return Int\# against 0\#</td></tr>
|
|
|
<tr><th>[\#10649](https://gitlab.haskell.org//ghc/ghc/issues/10649)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10678">#10678</a></th>
|
|
|
<td>integer-gmp's runS seems unnecessarily expensive</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10677">#10677</a></th>
|
|
|
<td>slightly silly assembly for testing whether a Word# is 0##</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10676">#10676</a></th>
|
|
|
<td>silly assembly for comparing the result of comparisons that return Int# against 0#</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10649">#10649</a></th>
|
|
|
<td>Performance issue with unnecessary reboxing</td></tr>
|
|
|
<tr><th>[\#10457](https://gitlab.haskell.org//ghc/ghc/issues/10457)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10457">#10457</a></th>
|
|
|
<td>Revise/remove custom mapM implementation for lists</td></tr>
|
|
|
<tr><th>[\#10415](https://gitlab.haskell.org//ghc/ghc/issues/10415)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10415">#10415</a></th>
|
|
|
<td>ForeignPtr touched in FFI wrapper is never discarded</td></tr>
|
|
|
<tr><th>[\#10400](https://gitlab.haskell.org//ghc/ghc/issues/10400)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10400">#10400</a></th>
|
|
|
<td>Run time increases by 40% in fractal plotter core loop</td></tr>
|
|
|
<tr><th>[\#10359](https://gitlab.haskell.org//ghc/ghc/issues/10359)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10359">#10359</a></th>
|
|
|
<td>Tuple constraint synonym led to asymptotic performance lossage</td></tr>
|
|
|
<tr><th>[\#10291](https://gitlab.haskell.org//ghc/ghc/issues/10291)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10291">#10291</a></th>
|
|
|
<td>compiling huge HashSet hogs memory</td></tr>
|
|
|
<tr><th>[\#10290](https://gitlab.haskell.org//ghc/ghc/issues/10290)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10290">#10290</a></th>
|
|
|
<td>compiling huge HashSet hogs memory</td></tr>
|
|
|
<tr><th>[\#10260](https://gitlab.haskell.org//ghc/ghc/issues/10260)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10260">#10260</a></th>
|
|
|
<td>last uses too much space with optimizations disabled</td></tr>
|
|
|
<tr><th>[\#10148](https://gitlab.haskell.org//ghc/ghc/issues/10148)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10148">#10148</a></th>
|
|
|
<td>Optimization causes repeated computation</td></tr>
|
|
|
<tr><th>[\#10137](https://gitlab.haskell.org//ghc/ghc/issues/10137)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10137">#10137</a></th>
|
|
|
<td>Rewrite switch code generation</td></tr>
|
|
|
<tr><th>[\#10129](https://gitlab.haskell.org//ghc/ghc/issues/10129)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10129">#10129</a></th>
|
|
|
<td>emitCmmLitSwitch could be better</td></tr>
|
|
|
<tr><th>[\#10108](https://gitlab.haskell.org//ghc/ghc/issues/10108)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10108">#10108</a></th>
|
|
|
<td>Dramatic slowdown with -O2 bytestream and list streams combined.</td></tr>
|
|
|
<tr><th>[\#10067](https://gitlab.haskell.org//ghc/ghc/issues/10067)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10067">#10067</a></th>
|
|
|
<td>The Read Integer instance is too slow</td></tr>
|
|
|
<tr><th>[\#10064](https://gitlab.haskell.org//ghc/ghc/issues/10064)</th>
|
|
|
<td>Add support for "foo"\#\# literals to MagicHash</td></tr>
|
|
|
<tr><th>[\#10060](https://gitlab.haskell.org//ghc/ghc/issues/10060)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10064">#10064</a></th>
|
|
|
<td>Add support for "foo"## literals to MagicHash</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10060">#10060</a></th>
|
|
|
<td>The Traversable instance for Array looks unlikely to be good</td></tr>
|
|
|
<tr><th>[\#10034](https://gitlab.haskell.org//ghc/ghc/issues/10034)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10034">#10034</a></th>
|
|
|
<td>Regression in mapM_ performance</td></tr>
|
|
|
<tr><th>[\#10014](https://gitlab.haskell.org//ghc/ghc/issues/10014)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/10014">#10014</a></th>
|
|
|
<td>Data.Array.Base.elems needlessly calls bounds.</td></tr>
|
|
|
<tr><th>[\#9885](https://gitlab.haskell.org//ghc/ghc/issues/9885)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9885">#9885</a></th>
|
|
|
<td>ghc-pkg parser eats too much memory</td></tr>
|
|
|
<tr><th>[\#9848](https://gitlab.haskell.org//ghc/ghc/issues/9848)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9848">#9848</a></th>
|
|
|
<td>List.all does not fuse</td></tr>
|
|
|
<tr><th>[\#9827](https://gitlab.haskell.org//ghc/ghc/issues/9827)</th>
|
|
|
<td>void does not use \<$</td></tr>
|
|
|
<tr><th>[\#9801](https://gitlab.haskell.org//ghc/ghc/issues/9801)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9827">#9827</a></th>
|
|
|
<td>void does not use <$</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9801">#9801</a></th>
|
|
|
<td>Make listArray fuse</td></tr>
|
|
|
<tr><th>[\#9797](https://gitlab.haskell.org//ghc/ghc/issues/9797)</th>
|
|
|
<td>Investigate rewriting \`\>\>=\` to \`\*\>\` or \`\>\>\` for appropriate types</td></tr>
|
|
|
<tr><th>[\#9796](https://gitlab.haskell.org//ghc/ghc/issues/9796)</th>
|
|
|
<td>Implement amap/coerce rule for \`Array\`</td></tr>
|
|
|
<tr><th>[\#9781](https://gitlab.haskell.org//ghc/ghc/issues/9781)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9797">#9797</a></th>
|
|
|
<td>Investigate rewriting `>>=` to `*>` or `>>` for appropriate types</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9796">#9796</a></th>
|
|
|
<td>Implement amap/coerce rule for `Array`</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9781">#9781</a></th>
|
|
|
<td>Make list monad operations fuse</td></tr>
|
|
|
<tr><th>[\#9740](https://gitlab.haskell.org//ghc/ghc/issues/9740)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9740">#9740</a></th>
|
|
|
<td>D380 caused fft2 regressions</td></tr>
|
|
|
<tr><th>[\#9715](https://gitlab.haskell.org//ghc/ghc/issues/9715)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9715">#9715</a></th>
|
|
|
<td>The most minimal Gloss project causes the profiler to fail silently.</td></tr>
|
|
|
<tr><th>[\#9696](https://gitlab.haskell.org//ghc/ghc/issues/9696)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9696">#9696</a></th>
|
|
|
<td>readRawBufferPtr and writeRawBufferPtr allocate memory</td></tr>
|
|
|
<tr><th>[\#9676](https://gitlab.haskell.org//ghc/ghc/issues/9676)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9676">#9676</a></th>
|
|
|
<td>Data.List.isSuffixOf can be very inefficient</td></tr>
|
|
|
<tr><th>[\#9638](https://gitlab.haskell.org//ghc/ghc/issues/9638)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9638">#9638</a></th>
|
|
|
<td>Speed up Data.Char.isDigit</td></tr>
|
|
|
<tr><th>[\#9577](https://gitlab.haskell.org//ghc/ghc/issues/9577)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9577">#9577</a></th>
|
|
|
<td>String literals are wasting space</td></tr>
|
|
|
<tr><th>[\#9546](https://gitlab.haskell.org//ghc/ghc/issues/9546)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9546">#9546</a></th>
|
|
|
<td>filterM is not a good consumer for list fusion</td></tr>
|
|
|
<tr><th>[\#9540](https://gitlab.haskell.org//ghc/ghc/issues/9540)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9540">#9540</a></th>
|
|
|
<td>words is not a good producer; unwords is not a good consumer</td></tr>
|
|
|
<tr><th>[\#9537](https://gitlab.haskell.org//ghc/ghc/issues/9537)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9537">#9537</a></th>
|
|
|
<td>concatMap is not a good producer for list fusion</td></tr>
|
|
|
<tr><th>[\#9520](https://gitlab.haskell.org//ghc/ghc/issues/9520)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9520">#9520</a></th>
|
|
|
<td>Running an action twice uses much more memory than running it once</td></tr>
|
|
|
<tr><th>[\#9510](https://gitlab.haskell.org//ghc/ghc/issues/9510)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9510">#9510</a></th>
|
|
|
<td>Prelude.!! is not a good consumer</td></tr>
|
|
|
<tr><th>[\#9509](https://gitlab.haskell.org//ghc/ghc/issues/9509)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9509">#9509</a></th>
|
|
|
<td>No automatic specialization of inlinable imports in 7.8</td></tr>
|
|
|
<tr><th>[\#9502](https://gitlab.haskell.org//ghc/ghc/issues/9502)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9502">#9502</a></th>
|
|
|
<td>mapAccumL does not participate in foldr/build fusion</td></tr>
|
|
|
<tr><th>[\#9476](https://gitlab.haskell.org//ghc/ghc/issues/9476)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9476">#9476</a></th>
|
|
|
<td>Implement late lambda-lifting</td></tr>
|
|
|
<tr><th>[\#9441](https://gitlab.haskell.org//ghc/ghc/issues/9441)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9441">#9441</a></th>
|
|
|
<td>CSE should deal with letrec</td></tr>
|
|
|
<tr><th>[\#9430](https://gitlab.haskell.org//ghc/ghc/issues/9430)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9430">#9430</a></th>
|
|
|
<td>implement more arithmetic operations natively in the LLVM backend</td></tr>
|
|
|
<tr><th>[\#9398](https://gitlab.haskell.org//ghc/ghc/issues/9398)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9398">#9398</a></th>
|
|
|
<td>Data.List.cycle is not a good producer</td></tr>
|
|
|
<tr><th>[\#9369](https://gitlab.haskell.org//ghc/ghc/issues/9369)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9369">#9369</a></th>
|
|
|
<td>Data.List.unfoldr does not fuse and is not inlined.</td></tr>
|
|
|
<tr><th>[\#9356](https://gitlab.haskell.org//ghc/ghc/issues/9356)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9356">#9356</a></th>
|
|
|
<td>scanl does not participate in list fusion</td></tr>
|
|
|
<tr><th>[\#9355](https://gitlab.haskell.org//ghc/ghc/issues/9355)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9355">#9355</a></th>
|
|
|
<td>scanr does not participate in stream fusion</td></tr>
|
|
|
<tr><th>[\#9345](https://gitlab.haskell.org//ghc/ghc/issues/9345)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9345">#9345</a></th>
|
|
|
<td>Data.List.inits is extremely slow</td></tr>
|
|
|
<tr><th>[\#9344](https://gitlab.haskell.org//ghc/ghc/issues/9344)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9344">#9344</a></th>
|
|
|
<td>takeWhile does not participate in list fusion</td></tr>
|
|
|
<tr><th>[\#9343](https://gitlab.haskell.org//ghc/ghc/issues/9343)</th>
|
|
|
<td>foldl' is not a good consumer</td></tr>
|
|
|
<tr><th>[\#9339](https://gitlab.haskell.org//ghc/ghc/issues/9339)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9343">#9343</a></th>
|
|
|
<td>foldl' is not a good consumer</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9339">#9339</a></th>
|
|
|
<td>last is not a good consumer</td></tr>
|
|
|
<tr><th>[\#9332](https://gitlab.haskell.org//ghc/ghc/issues/9332)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9332">#9332</a></th>
|
|
|
<td>Memory blowing up for strict sum/strict foldl in ghci</td></tr>
|
|
|
<tr><th>[\#9326](https://gitlab.haskell.org//ghc/ghc/issues/9326)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9326">#9326</a></th>
|
|
|
<td>Minor change to list comprehension structure leads to poor performance</td></tr>
|
|
|
<tr><th>[\#9291](https://gitlab.haskell.org//ghc/ghc/issues/9291)</th>
|
|
|
<td>Don't reconstruct sum types if the type subtly changes</td></tr>
|
|
|
<tr><th>[\#9234](https://gitlab.haskell.org//ghc/ghc/issues/9234)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9291">#9291</a></th>
|
|
|
<td>Don't reconstruct sum types if the type subtly changes</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9234">#9234</a></th>
|
|
|
<td>Compiled code performance regression</td></tr>
|
|
|
<tr><th>[\#9214](https://gitlab.haskell.org//ghc/ghc/issues/9214)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9214">#9214</a></th>
|
|
|
<td>UNPACK support for sum types</td></tr>
|
|
|
<tr><th>[\#9203](https://gitlab.haskell.org//ghc/ghc/issues/9203)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9203">#9203</a></th>
|
|
|
<td>Perf regression in 7.8.2 relative to 7.6.3, possibly related to HashMap</td></tr>
|
|
|
<tr><th>[\#9188](https://gitlab.haskell.org//ghc/ghc/issues/9188)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9188">#9188</a></th>
|
|
|
<td>quot with a power of two is not optimized to a shift</td></tr>
|
|
|
<tr><th>[\#9159](https://gitlab.haskell.org//ghc/ghc/issues/9159)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9159">#9159</a></th>
|
|
|
<td>cmm case, binary search instead of jump table</td></tr>
|
|
|
<tr><th>[\#9157](https://gitlab.haskell.org//ghc/ghc/issues/9157)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9157">#9157</a></th>
|
|
|
<td>cmm common block not eliminated</td></tr>
|
|
|
<tr><th>[\#9136](https://gitlab.haskell.org//ghc/ghc/issues/9136)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9136">#9136</a></th>
|
|
|
<td>Constant folding in Core could be better</td></tr>
|
|
|
<tr><th>[\#9132](https://gitlab.haskell.org//ghc/ghc/issues/9132)</th>
|
|
|
<td>takeWhile&C. still not fusible</td></tr>
|
|
|
<tr><th>[\#9105](https://gitlab.haskell.org//ghc/ghc/issues/9105)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9132">#9132</a></th>
|
|
|
<td>takeWhile&C. still not fusible</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9105">#9105</a></th>
|
|
|
<td>Profiling binary consumes CPU even when idle on Linux.</td></tr>
|
|
|
<tr><th>[\#9075](https://gitlab.haskell.org//ghc/ghc/issues/9075)</th>
|
|
|
<td>Per-thread weak pointer list (remove global lock on mkWeak\#)</td></tr>
|
|
|
<tr><th>[\#9067](https://gitlab.haskell.org//ghc/ghc/issues/9067)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9075">#9075</a></th>
|
|
|
<td>Per-thread weak pointer list (remove global lock on mkWeak#)</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9067">#9067</a></th>
|
|
|
<td>Optimize clearNursery by short-circuiting when we get to currentNursery</td></tr>
|
|
|
<tr><th>[\#9021](https://gitlab.haskell.org//ghc/ghc/issues/9021)</th>
|
|
|
<td>\[CID43168\] rts/linker.c has a memory leak in the dlopen/dlerror code</td></tr>
|
|
|
<tr><th>[\#8901](https://gitlab.haskell.org//ghc/ghc/issues/8901)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/9021">#9021</a></th>
|
|
|
<td>[CID43168] rts/linker.c has a memory leak in the dlopen/dlerror code</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8901">#8901</a></th>
|
|
|
<td>(very) bad inline heuristics</td></tr>
|
|
|
<tr><th>[\#8900](https://gitlab.haskell.org//ghc/ghc/issues/8900)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8900">#8900</a></th>
|
|
|
<td>Strictness analysis regression</td></tr>
|
|
|
<tr><th>[\#8835](https://gitlab.haskell.org//ghc/ghc/issues/8835)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8835">#8835</a></th>
|
|
|
<td>7.6.3 vs 7.8-RC performance regression</td></tr>
|
|
|
<tr><th>[\#8832](https://gitlab.haskell.org//ghc/ghc/issues/8832)</th>
|
|
|
<td>Constant-folding regression wrt \`clearBit (bit 0) 0 \`</td></tr>
|
|
|
<tr><th>[\#8793](https://gitlab.haskell.org//ghc/ghc/issues/8793)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8832">#8832</a></th>
|
|
|
<td>Constant-folding regression wrt `clearBit (bit 0) 0 `</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8793">#8793</a></th>
|
|
|
<td>Improve GHC.Event.IntTable performance</td></tr>
|
|
|
<tr><th>[\#8766](https://gitlab.haskell.org//ghc/ghc/issues/8766)</th>
|
|
|
<td>length \[Integer\] is twice as slow but length \[Int\] is 10 times faster</td></tr>
|
|
|
<tr><th>[\#8763](https://gitlab.haskell.org//ghc/ghc/issues/8763)</th>
|
|
|
<td>forM_ \[1..N\] does not get fused (allocates 50% more)</td></tr>
|
|
|
<tr><th>[\#8680](https://gitlab.haskell.org//ghc/ghc/issues/8680)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8766">#8766</a></th>
|
|
|
<td>length [Integer] is twice as slow but length [Int] is 10 times faster</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8763">#8763</a></th>
|
|
|
<td>forM_ [1..N] does not get fused (allocates 50% more)</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8680">#8680</a></th>
|
|
|
<td>In STM: Variables only in left branch of orElse can invalidate the right branch transaction</td></tr>
|
|
|
<tr><th>[\#8647](https://gitlab.haskell.org//ghc/ghc/issues/8647)</th>
|
|
|
<td>Reduce allocations in \`integer-gmp\`</td></tr>
|
|
|
<tr><th>[\#8638](https://gitlab.haskell.org//ghc/ghc/issues/8638)</th>
|
|
|
<td>Optimize by demoting "denormalized" Integers (i.e. J\# -\> S\#)</td></tr>
|
|
|
<tr><th>[\#8609](https://gitlab.haskell.org//ghc/ghc/issues/8609)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8647">#8647</a></th>
|
|
|
<td>Reduce allocations in `integer-gmp`</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8638">#8638</a></th>
|
|
|
<td>Optimize by demoting "denormalized" Integers (i.e. J# -> S#)</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8609">#8609</a></th>
|
|
|
<td>Clean up block allocator</td></tr>
|
|
|
<tr><th>[\#8585](https://gitlab.haskell.org//ghc/ghc/issues/8585)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8585">#8585</a></th>
|
|
|
<td>Loopification should omit stack check</td></tr>
|
|
|
<tr><th>[\#8513](https://gitlab.haskell.org//ghc/ghc/issues/8513)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8513">#8513</a></th>
|
|
|
<td>Parallel GC increases CPU load while slowing down program</td></tr>
|
|
|
<tr><th>[\#8508](https://gitlab.haskell.org//ghc/ghc/issues/8508)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8508">#8508</a></th>
|
|
|
<td>Inlining Unsaturated Function Applications</td></tr>
|
|
|
<tr><th>[\#8472](https://gitlab.haskell.org//ghc/ghc/issues/8472)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8472">#8472</a></th>
|
|
|
<td>Primitive string literals prevent optimization</td></tr>
|
|
|
<tr><th>[\#8456](https://gitlab.haskell.org//ghc/ghc/issues/8456)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8456">#8456</a></th>
|
|
|
<td>Control flow optimisations duplicate blocks</td></tr>
|
|
|
<tr><th>[\#8435](https://gitlab.haskell.org//ghc/ghc/issues/8435)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8435">#8435</a></th>
|
|
|
<td>Do not copy stack after stack overflow</td></tr>
|
|
|
<tr><th>[\#8345](https://gitlab.haskell.org//ghc/ghc/issues/8345)</th>
|
|
|
<td>A more efficient atomicModifyIORef'</td></tr>
|
|
|
<tr><th>[\#8321](https://gitlab.haskell.org//ghc/ghc/issues/8321)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8345">#8345</a></th>
|
|
|
<td>A more efficient atomicModifyIORef'</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8321">#8321</a></th>
|
|
|
<td>improve basic block layout on LLVM backend by predicting stack/heap checks</td></tr>
|
|
|
<tr><th>[\#8255](https://gitlab.haskell.org//ghc/ghc/issues/8255)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8255">#8255</a></th>
|
|
|
<td>GC Less Operation</td></tr>
|
|
|
<tr><th>[\#8224](https://gitlab.haskell.org//ghc/ghc/issues/8224)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8224">#8224</a></th>
|
|
|
<td>Excessive system time -- new IO manager problem?</td></tr>
|
|
|
<tr><th>[\#8124](https://gitlab.haskell.org//ghc/ghc/issues/8124)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8124">#8124</a></th>
|
|
|
<td>Possible leaks when using foreign export.</td></tr>
|
|
|
<tr><th>[\#8082](https://gitlab.haskell.org//ghc/ghc/issues/8082)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8082">#8082</a></th>
|
|
|
<td>Ordering of assembly blocks affects performance</td></tr>
|
|
|
<tr><th>[\#8027](https://gitlab.haskell.org//ghc/ghc/issues/8027)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/8027">#8027</a></th>
|
|
|
<td>Adding one call to getNumCapabilities triggers performance nose dive (6X slowdown)</td></tr>
|
|
|
<tr><th>[\#7954](https://gitlab.haskell.org//ghc/ghc/issues/7954)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7954">#7954</a></th>
|
|
|
<td>Strictness analysis regression</td></tr>
|
|
|
<tr><th>[\#7923](https://gitlab.haskell.org//ghc/ghc/issues/7923)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7923">#7923</a></th>
|
|
|
<td>Optimization for takeMVar/putMVar when MVar left empty</td></tr>
|
|
|
<tr><th>[\#7865](https://gitlab.haskell.org//ghc/ghc/issues/7865)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7865">#7865</a></th>
|
|
|
<td>SpecConstr duplicating computations</td></tr>
|
|
|
<tr><th>[\#7850](https://gitlab.haskell.org//ghc/ghc/issues/7850)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7850">#7850</a></th>
|
|
|
<td>Strangely high memory usage on optimized Ackermann function</td></tr>
|
|
|
<tr><th>[\#7837](https://gitlab.haskell.org//ghc/ghc/issues/7837)</th>
|
|
|
<td>Rules involving equality constraints don't fire</td></tr>
|
|
|
<tr><th>[\#7785](https://gitlab.haskell.org//ghc/ghc/issues/7785)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7837">#7837</a></th>
|
|
|
<td>Rules involving equality constraints don't fire</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7785">#7785</a></th>
|
|
|
<td>Module-local function not specialized with ConstraintKinds</td></tr>
|
|
|
<tr><th>[\#7611](https://gitlab.haskell.org//ghc/ghc/issues/7611)</th>
|
|
|
<td>Rewrite rules application prevented by type variable application (map id vs. map (\\x -\> x))</td></tr>
|
|
|
<tr><th>[\#7561](https://gitlab.haskell.org//ghc/ghc/issues/7561)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7611">#7611</a></th>
|
|
|
<td>Rewrite rules application prevented by type variable application (map id vs. map (\x -> x))</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7561">#7561</a></th>
|
|
|
<td>Unnecessary Heap Allocations - Slow Performance</td></tr>
|
|
|
<tr><th>[\#7556](https://gitlab.haskell.org//ghc/ghc/issues/7556)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7556">#7556</a></th>
|
|
|
<td>build/fold causes with ByteString unpack causes huge memory leak</td></tr>
|
|
|
<tr><th>[\#7460](https://gitlab.haskell.org//ghc/ghc/issues/7460)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7460">#7460</a></th>
|
|
|
<td>Double literals generated bad core</td></tr>
|
|
|
<tr><th>[\#7436](https://gitlab.haskell.org//ghc/ghc/issues/7436)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7436">#7436</a></th>
|
|
|
<td>Derived Foldable and Traversable instances become extremely inefficient due to eta-expansion</td></tr>
|
|
|
<tr><th>[\#7429](https://gitlab.haskell.org//ghc/ghc/issues/7429)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7429">#7429</a></th>
|
|
|
<td>Unexplained performance boost with +RTS -h</td></tr>
|
|
|
<tr><th>[\#7418](https://gitlab.haskell.org//ghc/ghc/issues/7418)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7418">#7418</a></th>
|
|
|
<td>Writing to stderr is 7x slower than writing to stdout</td></tr>
|
|
|
<tr><th>[\#7382](https://gitlab.haskell.org//ghc/ghc/issues/7382)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7382">#7382</a></th>
|
|
|
<td>Evaluating GHCi expressions is slow following the dynamic-by-default change</td></tr>
|
|
|
<tr><th>[\#7363](https://gitlab.haskell.org//ghc/ghc/issues/7363)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7363">#7363</a></th>
|
|
|
<td>runghc leaks space in IO</td></tr>
|
|
|
<tr><th>[\#7292](https://gitlab.haskell.org//ghc/ghc/issues/7292)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7292">#7292</a></th>
|
|
|
<td>Optimization works for Word but not Word32 or Word64</td></tr>
|
|
|
<tr><th>[\#7284](https://gitlab.haskell.org//ghc/ghc/issues/7284)</th>
|
|
|
<td>plusAddr\# x 0 isn't optimised away</td></tr>
|
|
|
<tr><th>[\#7257](https://gitlab.haskell.org//ghc/ghc/issues/7257)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7284">#7284</a></th>
|
|
|
<td>plusAddr# x 0 isn't optimised away</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7257">#7257</a></th>
|
|
|
<td>Regression: pinned memory fragmentation</td></tr>
|
|
|
<tr><th>[\#7219](https://gitlab.haskell.org//ghc/ghc/issues/7219)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7219">#7219</a></th>
|
|
|
<td>Reinstate constant propagation in some form</td></tr>
|
|
|
<tr><th>[\#7211](https://gitlab.haskell.org//ghc/ghc/issues/7211)</th>
|
|
|
<td>Huge space leak on a program that shouldn't leak</td></tr>
|
|
|
<tr><th>[\#7116](https://gitlab.haskell.org//ghc/ghc/issues/7116)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7211">#7211</a></th>
|
|
|
<td>Huge space leak on a program that shouldn't leak</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7116">#7116</a></th>
|
|
|
<td>Missing optimisation: strength reduction of floating-point multiplication</td></tr>
|
|
|
<tr><th>[\#7091](https://gitlab.haskell.org//ghc/ghc/issues/7091)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7091">#7091</a></th>
|
|
|
<td>DPH Matrix product memory usage</td></tr>
|
|
|
<tr><th>[\#7058](https://gitlab.haskell.org//ghc/ghc/issues/7058)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7058">#7058</a></th>
|
|
|
<td>Add strict version of modifySTRef</td></tr>
|
|
|
<tr><th>[\#7052](https://gitlab.haskell.org//ghc/ghc/issues/7052)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/7052">#7052</a></th>
|
|
|
<td>Numeric types’ Read instances use exponential CPU/memory</td></tr>
|
|
|
<tr><th>[\#6166](https://gitlab.haskell.org//ghc/ghc/issues/6166)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/6166">#6166</a></th>
|
|
|
<td>Performance regression in mwc-random since 7.0.x</td></tr>
|
|
|
<tr><th>[\#6121](https://gitlab.haskell.org//ghc/ghc/issues/6121)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/6121">#6121</a></th>
|
|
|
<td>Very poor constant folding</td></tr>
|
|
|
<tr><th>[\#6111](https://gitlab.haskell.org//ghc/ghc/issues/6111)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/6111">#6111</a></th>
|
|
|
<td>Simple loop performance regression of 7.4.1 relative to 7.0.4</td></tr>
|
|
|
<tr><th>[\#6110](https://gitlab.haskell.org//ghc/ghc/issues/6110)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/6110">#6110</a></th>
|
|
|
<td>Data.Vector.Unboxed performance regression of 7.4.1 relative to 7.0.4</td></tr>
|
|
|
<tr><th>[\#6082](https://gitlab.haskell.org//ghc/ghc/issues/6082)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/6082">#6082</a></th>
|
|
|
<td>Program compiled with 7.4.1 runs many times slower than compiled with 7.2.2</td></tr>
|
|
|
<tr><th>[\#6056](https://gitlab.haskell.org//ghc/ghc/issues/6056)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/6056">#6056</a></th>
|
|
|
<td>INLINABLE pragma prevents worker-wrapper to happen.</td></tr>
|
|
|
<tr><th>[\#6000](https://gitlab.haskell.org//ghc/ghc/issues/6000)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/6000">#6000</a></th>
|
|
|
<td>Performance of Fibonnaci compare to Python</td></tr>
|
|
|
<tr><th>[\#5996](https://gitlab.haskell.org//ghc/ghc/issues/5996)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5996">#5996</a></th>
|
|
|
<td>fix for CSE</td></tr>
|
|
|
<tr><th>[\#5991](https://gitlab.haskell.org//ghc/ghc/issues/5991)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5991">#5991</a></th>
|
|
|
<td>regression: huge number of wakeups in xmonad</td></tr>
|
|
|
<tr><th>[\#5949](https://gitlab.haskell.org//ghc/ghc/issues/5949)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5949">#5949</a></th>
|
|
|
<td>Demand analysis attributes manifestly wrong demand type</td></tr>
|
|
|
<tr><th>[\#5945](https://gitlab.haskell.org//ghc/ghc/issues/5945)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5945">#5945</a></th>
|
|
|
<td>Lambda lifting</td></tr>
|
|
|
<tr><th>[\#5926](https://gitlab.haskell.org//ghc/ghc/issues/5926)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5926">#5926</a></th>
|
|
|
<td>Add strict versions of modifyIORef and atomicModifyIORef</td></tr>
|
|
|
<tr><th>[\#5916](https://gitlab.haskell.org//ghc/ghc/issues/5916)</th>
|
|
|
<td>runST isn't free</td></tr>
|
|
|
<tr><th>[\#5888](https://gitlab.haskell.org//ghc/ghc/issues/5888)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5916">#5916</a></th>
|
|
|
<td>runST isn't free</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5888">#5888</a></th>
|
|
|
<td>Performance regression in 7.4.1 compared to 6.12.3</td></tr>
|
|
|
<tr><th>[\#5835](https://gitlab.haskell.org//ghc/ghc/issues/5835)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5835">#5835</a></th>
|
|
|
<td>Make better use of known dictionaries</td></tr>
|
|
|
<tr><th>[\#5809](https://gitlab.haskell.org//ghc/ghc/issues/5809)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5809">#5809</a></th>
|
|
|
<td>Arity analysis could be better</td></tr>
|
|
|
<tr><th>[\#5779](https://gitlab.haskell.org//ghc/ghc/issues/5779)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5779">#5779</a></th>
|
|
|
<td>SPECIALISE pragma generates wrong activations</td></tr>
|
|
|
<tr><th>[\#5776](https://gitlab.haskell.org//ghc/ghc/issues/5776)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5776">#5776</a></th>
|
|
|
<td>Rule matching regression</td></tr>
|
|
|
<tr><th>[\#5774](https://gitlab.haskell.org//ghc/ghc/issues/5774)</th>
|
|
|
<td>main = forever (putStrLn =\<\< getLine) continuously saturates a CPU when compiled</td></tr>
|
|
|
<tr><th>[\#5773](https://gitlab.haskell.org//ghc/ghc/issues/5773)</th>
|
|
|
<td>main = forever (putStrLn =\<\< getLine) continuously saturates a CPU when compiled</td></tr>
|
|
|
<tr><th>[\#5767](https://gitlab.haskell.org//ghc/ghc/issues/5767)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5774">#5774</a></th>
|
|
|
<td>main = forever (putStrLn =<< getLine) continuously saturates a CPU when compiled</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5773">#5773</a></th>
|
|
|
<td>main = forever (putStrLn =<< getLine) continuously saturates a CPU when compiled</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5767">#5767</a></th>
|
|
|
<td>Integer inefficiencies</td></tr>
|
|
|
<tr><th>[\#5749](https://gitlab.haskell.org//ghc/ghc/issues/5749)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5749">#5749</a></th>
|
|
|
<td>GHC 7.0.4 Performance Regression (Possibly Vector)</td></tr>
|
|
|
<tr><th>[\#5741](https://gitlab.haskell.org//ghc/ghc/issues/5741)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5741">#5741</a></th>
|
|
|
<td>openFile should fail if null bytes are in the argument</td></tr>
|
|
|
<tr><th>[\#5731](https://gitlab.haskell.org//ghc/ghc/issues/5731)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5731">#5731</a></th>
|
|
|
<td>Bad code for Double literals</td></tr>
|
|
|
<tr><th>[\#5715](https://gitlab.haskell.org//ghc/ghc/issues/5715)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5715">#5715</a></th>
|
|
|
<td>Inliner fails to inline a function, causing 20x slowdown</td></tr>
|
|
|
<tr><th>[\#5623](https://gitlab.haskell.org//ghc/ghc/issues/5623)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5623">#5623</a></th>
|
|
|
<td>GHC 7.2.1 Performance Regression: Vector</td></tr>
|
|
|
<tr><th>[\#5615](https://gitlab.haskell.org//ghc/ghc/issues/5615)</th>
|
|
|
<td>ghc produces poor code for \`div\` with constant powers of 2.</td></tr>
|
|
|
<tr><th>[\#5598](https://gitlab.haskell.org//ghc/ghc/issues/5598)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5615">#5615</a></th>
|
|
|
<td>ghc produces poor code for `div` with constant powers of 2.</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5598">#5598</a></th>
|
|
|
<td>Function quotRem is inefficient</td></tr>
|
|
|
<tr><th>[\#5569](https://gitlab.haskell.org//ghc/ghc/issues/5569)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5569">#5569</a></th>
|
|
|
<td>Ineffective seq/BangPatterns</td></tr>
|
|
|
<tr><th>[\#5549](https://gitlab.haskell.org//ghc/ghc/issues/5549)</th>
|
|
|
<td>\~100% performance regression in HEAD compared to ghc6.12, \~22% compared to 7.0.4</td></tr>
|
|
|
<tr><th>[\#5505](https://gitlab.haskell.org//ghc/ghc/issues/5505)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5549">#5549</a></th>
|
|
|
<td>~100% performance regression in HEAD compared to ghc6.12, ~22% compared to 7.0.4</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5505">#5505</a></th>
|
|
|
<td>Program runs faster with profiling than without</td></tr>
|
|
|
<tr><th>[\#5367](https://gitlab.haskell.org//ghc/ghc/issues/5367)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5367">#5367</a></th>
|
|
|
<td>Program in (-N1) runs 10 times slower than it with two threads (-N2)</td></tr>
|
|
|
<tr><th>[\#5339](https://gitlab.haskell.org//ghc/ghc/issues/5339)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5339">#5339</a></th>
|
|
|
<td>Data.Bits instances should use default shift instead of shiftL/shiftR</td></tr>
|
|
|
<tr><th>[\#5327](https://gitlab.haskell.org//ghc/ghc/issues/5327)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5327">#5327</a></th>
|
|
|
<td>INLINABLE pragma and newtypes prevents inlining</td></tr>
|
|
|
<tr><th>[\#5237](https://gitlab.haskell.org//ghc/ghc/issues/5237)</th>
|
|
|
<td>Inefficient code generated for x\^2</td></tr>
|
|
|
<tr><th>[\#5205](https://gitlab.haskell.org//ghc/ghc/issues/5205)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5237">#5237</a></th>
|
|
|
<td>Inefficient code generated for x^2</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5205">#5205</a></th>
|
|
|
<td>Control.Monad.forever leaks space</td></tr>
|
|
|
<tr><th>[\#5161](https://gitlab.haskell.org//ghc/ghc/issues/5161)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5161">#5161</a></th>
|
|
|
<td>Poor performance of division; unnecessary branching</td></tr>
|
|
|
<tr><th>[\#5152](https://gitlab.haskell.org//ghc/ghc/issues/5152)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5152">#5152</a></th>
|
|
|
<td>GHC generates poor code for large 64-bit literals</td></tr>
|
|
|
<tr><th>[\#5113](https://gitlab.haskell.org//ghc/ghc/issues/5113)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5113">#5113</a></th>
|
|
|
<td>Huge performance regression of 7.0.2, 7.0.3 and HEAD over 7.0.1 and 6.12 (MonoLocalBinds)</td></tr>
|
|
|
<tr><th>[\#5034](https://gitlab.haskell.org//ghc/ghc/issues/5034)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5034">#5034</a></th>
|
|
|
<td>Performance of Data.Graph.{preorderF, postorderF}</td></tr>
|
|
|
<tr><th>[\#5000](https://gitlab.haskell.org//ghc/ghc/issues/5000)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/5000">#5000</a></th>
|
|
|
<td>Eliminate absent arguments in non-strict positions</td></tr>
|
|
|
<tr><th>[\#4986](https://gitlab.haskell.org//ghc/ghc/issues/4986)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4986">#4986</a></th>
|
|
|
<td>negative Double numbers print out all wrong</td></tr>
|
|
|
<tr><th>[\#4965](https://gitlab.haskell.org//ghc/ghc/issues/4965)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4965">#4965</a></th>
|
|
|
<td>60% performance regression in continuation-heavy code between 6.12 and 7</td></tr>
|
|
|
<tr><th>[\#4962](https://gitlab.haskell.org//ghc/ghc/issues/4962)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4962">#4962</a></th>
|
|
|
<td>Dead code fed to CorePrep because RULEs keep it alive spuriously</td></tr>
|
|
|
<tr><th>[\#4951](https://gitlab.haskell.org//ghc/ghc/issues/4951)</th>
|
|
|
<td>Performance regression 7.0.1 -\> 7.0.1.20110201</td></tr>
|
|
|
<tr><th>[\#4943](https://gitlab.haskell.org//ghc/ghc/issues/4943)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4951">#4951</a></th>
|
|
|
<td>Performance regression 7.0.1 -> 7.0.1.20110201</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4943">#4943</a></th>
|
|
|
<td>Another odd missed SpecConstr opportunity</td></tr>
|
|
|
<tr><th>[\#4930](https://gitlab.haskell.org//ghc/ghc/issues/4930)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4930">#4930</a></th>
|
|
|
<td>Case-of-case not eliminated when it could be</td></tr>
|
|
|
<tr><th>[\#4908](https://gitlab.haskell.org//ghc/ghc/issues/4908)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4908">#4908</a></th>
|
|
|
<td>Easy SpecConstr opportunity that is nonetheless missed</td></tr>
|
|
|
<tr><th>[\#4495](https://gitlab.haskell.org//ghc/ghc/issues/4495)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4495">#4495</a></th>
|
|
|
<td>GHC fails to inline methods of single-method classes</td></tr>
|
|
|
<tr><th>[\#4474](https://gitlab.haskell.org//ghc/ghc/issues/4474)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4474">#4474</a></th>
|
|
|
<td>3 ways to write a function (unexpected performance difference and regression)</td></tr>
|
|
|
<tr><th>[\#4463](https://gitlab.haskell.org//ghc/ghc/issues/4463)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4463">#4463</a></th>
|
|
|
<td>CORE notes break optimisation</td></tr>
|
|
|
<tr><th>[\#4448](https://gitlab.haskell.org//ghc/ghc/issues/4448)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4448">#4448</a></th>
|
|
|
<td>Another case of SpecConstr not specialising</td></tr>
|
|
|
<tr><th>[\#4442](https://gitlab.haskell.org//ghc/ghc/issues/4442)</th>
|
|
|
<td>Add unaligned version of indexWordArray\#</td></tr>
|
|
|
<tr><th>[\#4431](https://gitlab.haskell.org//ghc/ghc/issues/4431)</th>
|
|
|
<td>SpecConstr doesn't specialise</td></tr>
|
|
|
<tr><th>[\#4428](https://gitlab.haskell.org//ghc/ghc/issues/4428)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4442">#4442</a></th>
|
|
|
<td>Add unaligned version of indexWordArray#</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4431">#4431</a></th>
|
|
|
<td>SpecConstr doesn't specialise</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4428">#4428</a></th>
|
|
|
<td>Local functions lose their unfoldings</td></tr>
|
|
|
<tr><th>[\#4397](https://gitlab.haskell.org//ghc/ghc/issues/4397)</th>
|
|
|
<td>RULES for Class ops don't fire in HEAD</td></tr>
|
|
|
<tr><th>[\#4365](https://gitlab.haskell.org//ghc/ghc/issues/4365)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4397">#4397</a></th>
|
|
|
<td>RULES for Class ops don't fire in HEAD</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4365">#4365</a></th>
|
|
|
<td>Error handle in readProcess not closed</td></tr>
|
|
|
<tr><th>[\#4344](https://gitlab.haskell.org//ghc/ghc/issues/4344)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4344">#4344</a></th>
|
|
|
<td>Better toRational for Float and Double</td></tr>
|
|
|
<tr><th>[\#4337](https://gitlab.haskell.org//ghc/ghc/issues/4337)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4337">#4337</a></th>
|
|
|
<td>Better power for Rational</td></tr>
|
|
|
<tr><th>[\#4322](https://gitlab.haskell.org//ghc/ghc/issues/4322)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4322">#4322</a></th>
|
|
|
<td>High CPU usage during idle time due to GC</td></tr>
|
|
|
<tr><th>[\#4306](https://gitlab.haskell.org//ghc/ghc/issues/4306)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4306">#4306</a></th>
|
|
|
<td>UNPACK can lead to unnecessary copying and wasted stack space</td></tr>
|
|
|
<tr><th>[\#4285](https://gitlab.haskell.org//ghc/ghc/issues/4285)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4285">#4285</a></th>
|
|
|
<td>STM bug on Windows?</td></tr>
|
|
|
<tr><th>[\#4280](https://gitlab.haskell.org//ghc/ghc/issues/4280)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4280">#4280</a></th>
|
|
|
<td>Proposal: Performance improvements for Data.Set</td></tr>
|
|
|
<tr><th>[\#4279](https://gitlab.haskell.org//ghc/ghc/issues/4279)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4279">#4279</a></th>
|
|
|
<td>Proposal: Performance improvements for Data.IntMap</td></tr>
|
|
|
<tr><th>[\#4278](https://gitlab.haskell.org//ghc/ghc/issues/4278)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4278">#4278</a></th>
|
|
|
<td>Proposal: Add strict versions of foldlWithKey and insertLookupWithKey to Data.Map</td></tr>
|
|
|
<tr><th>[\#4277](https://gitlab.haskell.org//ghc/ghc/issues/4277)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4277">#4277</a></th>
|
|
|
<td>Proposal: Significant performance improvements for Data.Map</td></tr>
|
|
|
<tr><th>[\#4276](https://gitlab.haskell.org//ghc/ghc/issues/4276)</th>
|
|
|
<td>-O0 runs in constant space, -O1 and -O2 don't</td></tr>
|
|
|
<tr><th>[\#4262](https://gitlab.haskell.org//ghc/ghc/issues/4262)</th>
|
|
|
<td>GHC's runtime never terminates unused worker threads</td></tr>
|
|
|
<tr><th>[\#4223](https://gitlab.haskell.org//ghc/ghc/issues/4223)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4276">#4276</a></th>
|
|
|
<td>-O0 runs in constant space, -O1 and -O2 don't</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4262">#4262</a></th>
|
|
|
<td>GHC's runtime never terminates unused worker threads</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4223">#4223</a></th>
|
|
|
<td>LLVM slower then NCG, C example</td></tr>
|
|
|
<tr><th>[\#4184](https://gitlab.haskell.org//ghc/ghc/issues/4184)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4184">#4184</a></th>
|
|
|
<td>Squirrelly inliner behaviour leads to 80x slowdown</td></tr>
|
|
|
<tr><th>[\#4138](https://gitlab.haskell.org//ghc/ghc/issues/4138)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4138">#4138</a></th>
|
|
|
<td>Performance regression in overloading</td></tr>
|
|
|
<tr><th>[\#4120](https://gitlab.haskell.org//ghc/ghc/issues/4120)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4120">#4120</a></th>
|
|
|
<td>Iface type variable out of scope in cast</td></tr>
|
|
|
<tr><th>[\#4065](https://gitlab.haskell.org//ghc/ghc/issues/4065)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4065">#4065</a></th>
|
|
|
<td>Inconsistent loop performance</td></tr>
|
|
|
<tr><th>[\#4064](https://gitlab.haskell.org//ghc/ghc/issues/4064)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4064">#4064</a></th>
|
|
|
<td>SpecConstr broken for NOINLINE loops in 6.13</td></tr>
|
|
|
<tr><th>[\#4062](https://gitlab.haskell.org//ghc/ghc/issues/4062)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4062">#4062</a></th>
|
|
|
<td>Bad choice of loop breaker?</td></tr>
|
|
|
<tr><th>[\#4021](https://gitlab.haskell.org//ghc/ghc/issues/4021)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4021">#4021</a></th>
|
|
|
<td>Problem of Interaction Between the FreeBSD Kernel and the GHC RTS</td></tr>
|
|
|
<tr><th>[\#4018](https://gitlab.haskell.org//ghc/ghc/issues/4018)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4018">#4018</a></th>
|
|
|
<td>Concurrency space leak</td></tr>
|
|
|
<tr><th>[\#4007](https://gitlab.haskell.org//ghc/ghc/issues/4007)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4007">#4007</a></th>
|
|
|
<td>Look again at eta expansion during gentle simplification</td></tr>
|
|
|
<tr><th>[\#4004](https://gitlab.haskell.org//ghc/ghc/issues/4004)</th>
|
|
|
<td>Improve performance of a few functions in Foreign.Marshal.\*</td></tr>
|
|
|
<tr><th>[\#3990](https://gitlab.haskell.org//ghc/ghc/issues/3990)</th>
|
|
|
<td>UNPACK doesn't unbox data families</td></tr>
|
|
|
<tr><th>[\#3969](https://gitlab.haskell.org//ghc/ghc/issues/3969)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/4004">#4004</a></th>
|
|
|
<td>Improve performance of a few functions in Foreign.Marshal.*</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3990">#3990</a></th>
|
|
|
<td>UNPACK doesn't unbox data families</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3969">#3969</a></th>
|
|
|
<td>Poor performance of generated code on x86.</td></tr>
|
|
|
<tr><th>[\#3938](https://gitlab.haskell.org//ghc/ghc/issues/3938)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3938">#3938</a></th>
|
|
|
<td>Data growth issue in System.Timeout</td></tr>
|
|
|
<tr><th>[\#3838](https://gitlab.haskell.org//ghc/ghc/issues/3838)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3838">#3838</a></th>
|
|
|
<td>Performance issues with blackholes</td></tr>
|
|
|
<tr><th>[\#3772](https://gitlab.haskell.org//ghc/ghc/issues/3772)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3772">#3772</a></th>
|
|
|
<td>Methods not inlined</td></tr>
|
|
|
<tr><th>[\#3738](https://gitlab.haskell.org//ghc/ghc/issues/3738)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3738">#3738</a></th>
|
|
|
<td>Typechecker floats stuff out of INLINE right hand sides</td></tr>
|
|
|
<tr><th>[\#3737](https://gitlab.haskell.org//ghc/ghc/issues/3737)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3737">#3737</a></th>
|
|
|
<td>inlining happens on foldl1 and does not happen on direct application of combinator</td></tr>
|
|
|
<tr><th>[\#3736](https://gitlab.haskell.org//ghc/ghc/issues/3736)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3736">#3736</a></th>
|
|
|
<td>GHC specialising instead of inlining</td></tr>
|
|
|
<tr><th>[\#3735](https://gitlab.haskell.org//ghc/ghc/issues/3735)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3735">#3735</a></th>
|
|
|
<td>GHC specialising instead of inlining</td></tr>
|
|
|
<tr><th>[\#3717](https://gitlab.haskell.org//ghc/ghc/issues/3717)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3717">#3717</a></th>
|
|
|
<td>Superfluous seq no eliminated</td></tr>
|
|
|
<tr><th>[\#3709](https://gitlab.haskell.org//ghc/ghc/issues/3709)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3709">#3709</a></th>
|
|
|
<td>Data.Either.partitionEithers is not lazy enough</td></tr>
|
|
|
<tr><th>[\#3698](https://gitlab.haskell.org//ghc/ghc/issues/3698)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3698">#3698</a></th>
|
|
|
<td>Bad code generated for zip/filter/filter loop</td></tr>
|
|
|
<tr><th>[\#3697](https://gitlab.haskell.org//ghc/ghc/issues/3697)</th>
|
|
|
<td>Method selectors aren't floated out of loops</td></tr>
|
|
|
<tr><th>[\#3655](https://gitlab.haskell.org//ghc/ghc/issues/3655)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3697">#3697</a></th>
|
|
|
<td>Method selectors aren't floated out of loops</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3655">#3655</a></th>
|
|
|
<td>Performance regression relative to 6.10</td></tr>
|
|
|
<tr><th>[\#3627](https://gitlab.haskell.org//ghc/ghc/issues/3627)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3627">#3627</a></th>
|
|
|
<td>Profiling loses eta-expansion opportunities unnecessarily</td></tr>
|
|
|
<tr><th>[\#3586](https://gitlab.haskell.org//ghc/ghc/issues/3586)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3586">#3586</a></th>
|
|
|
<td>Initialisation of unboxed arrays is too slow</td></tr>
|
|
|
<tr><th>[\#3526](https://gitlab.haskell.org//ghc/ghc/issues/3526)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3526">#3526</a></th>
|
|
|
<td>Inliner behaviour with instances is confusing</td></tr>
|
|
|
<tr><th>[\#3518](https://gitlab.haskell.org//ghc/ghc/issues/3518)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3518">#3518</a></th>
|
|
|
<td>GHC GC rises greatly on -N8 compared to -N7</td></tr>
|
|
|
<tr><th>[\#3501](https://gitlab.haskell.org//ghc/ghc/issues/3501)</th>
|
|
|
<td>Error thunks not being exposed with "B" strictness</td></tr>
|
|
|
<tr><th>[\#3437](https://gitlab.haskell.org//ghc/ghc/issues/3437)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3501">#3501</a></th>
|
|
|
<td>Error thunks not being exposed with "B" strictness</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3437">#3437</a></th>
|
|
|
<td>Optimizer creates space leak on simple code</td></tr>
|
|
|
<tr><th>[\#3349](https://gitlab.haskell.org//ghc/ghc/issues/3349)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3349">#3349</a></th>
|
|
|
<td>poor responsiveness of ghci</td></tr>
|
|
|
<tr><th>[\#3331](https://gitlab.haskell.org//ghc/ghc/issues/3331)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3331">#3331</a></th>
|
|
|
<td>control-monad-queue performance regression</td></tr>
|
|
|
<tr><th>[\#3273](https://gitlab.haskell.org//ghc/ghc/issues/3273)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3273">#3273</a></th>
|
|
|
<td>memory leak due to optimisation</td></tr>
|
|
|
<tr><th>[\#3264](https://gitlab.haskell.org//ghc/ghc/issues/3264)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3264">#3264</a></th>
|
|
|
<td>Real World Haskell book example issue</td></tr>
|
|
|
<tr><th>[\#3245](https://gitlab.haskell.org//ghc/ghc/issues/3245)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3245">#3245</a></th>
|
|
|
<td>Quadratic slowdown in Data.Typeable</td></tr>
|
|
|
<tr><th>[\#3181](https://gitlab.haskell.org//ghc/ghc/issues/3181)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3181">#3181</a></th>
|
|
|
<td>Regression in unboxing</td></tr>
|
|
|
<tr><th>[\#3123](https://gitlab.haskell.org//ghc/ghc/issues/3123)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3123">#3123</a></th>
|
|
|
<td>make INLINE work for recursive definitions (generalized loop peeling/loop unrolling)</td></tr>
|
|
|
<tr><th>[\#3116](https://gitlab.haskell.org//ghc/ghc/issues/3116)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3116">#3116</a></th>
|
|
|
<td>missed opportunity for call-pattern specialisation</td></tr>
|
|
|
<tr><th>[\#3076](https://gitlab.haskell.org//ghc/ghc/issues/3076)</th>
|
|
|
<td>Make genericLength tail-recursive so it doesn't overflow stack</td></tr>
|
|
|
<tr><th>[\#3065](https://gitlab.haskell.org//ghc/ghc/issues/3065)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3076">#3076</a></th>
|
|
|
<td>Make genericLength tail-recursive so it doesn't overflow stack</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/3065">#3065</a></th>
|
|
|
<td>Reorder tests in quot to improve code</td></tr>
|
|
|
<tr><th>[\#2940](https://gitlab.haskell.org//ghc/ghc/issues/2940)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2940">#2940</a></th>
|
|
|
<td>Do CSE after CorePrep</td></tr>
|
|
|
<tr><th>[\#2915](https://gitlab.haskell.org//ghc/ghc/issues/2915)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2915">#2915</a></th>
|
|
|
<td>Arity is smaller than need be</td></tr>
|
|
|
<tr><th>[\#2902](https://gitlab.haskell.org//ghc/ghc/issues/2902)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2902">#2902</a></th>
|
|
|
<td>Example where ghc 6.10.1 fails to optimize recursive instance function calls</td></tr>
|
|
|
<tr><th>[\#2884](https://gitlab.haskell.org//ghc/ghc/issues/2884)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2884">#2884</a></th>
|
|
|
<td>Compiled code performance worsens when module names are long enough</td></tr>
|
|
|
<tr><th>[\#2840](https://gitlab.haskell.org//ghc/ghc/issues/2840)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2840">#2840</a></th>
|
|
|
<td>Top level string literals</td></tr>
|
|
|
<tr><th>[\#2831](https://gitlab.haskell.org//ghc/ghc/issues/2831)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2831">#2831</a></th>
|
|
|
<td>Floated error expressions get poor strictness, leaving bad arity</td></tr>
|
|
|
<tr><th>[\#2823](https://gitlab.haskell.org//ghc/ghc/issues/2823)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2823">#2823</a></th>
|
|
|
<td>Another arity expansion bug</td></tr>
|
|
|
<tr><th>[\#2822](https://gitlab.haskell.org//ghc/ghc/issues/2822)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2822">#2822</a></th>
|
|
|
<td>Arity expansion not working right</td></tr>
|
|
|
<tr><th>[\#2797](https://gitlab.haskell.org//ghc/ghc/issues/2797)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2797">#2797</a></th>
|
|
|
<td>ghci stack overflows when ghc does not</td></tr>
|
|
|
<tr><th>[\#2785](https://gitlab.haskell.org//ghc/ghc/issues/2785)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2785">#2785</a></th>
|
|
|
<td>Memory leakage with socket benchmark program</td></tr>
|
|
|
<tr><th>[\#2727](https://gitlab.haskell.org//ghc/ghc/issues/2727)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2727">#2727</a></th>
|
|
|
<td>DiffArray performance unusable for advertized purpose</td></tr>
|
|
|
<tr><th>[\#2720](https://gitlab.haskell.org//ghc/ghc/issues/2720)</th>
|
|
|
<td>eyeball/inline1 still isn't optimised with -fno-method-sharing</td></tr>
|
|
|
<tr><th>[\#2712](https://gitlab.haskell.org//ghc/ghc/issues/2712)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2720">#2720</a></th>
|
|
|
<td>eyeball/inline1 still isn't optimised with -fno-method-sharing</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2712">#2712</a></th>
|
|
|
<td>Parallel GC scheduling problems</td></tr>
|
|
|
<tr><th>[\#2581](https://gitlab.haskell.org//ghc/ghc/issues/2581)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2581">#2581</a></th>
|
|
|
<td>Record selectors not being inlined</td></tr>
|
|
|
<tr><th>[\#2463](https://gitlab.haskell.org//ghc/ghc/issues/2463)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2463">#2463</a></th>
|
|
|
<td>unsafePerformIO in unused record field affects optimisations</td></tr>
|
|
|
<tr><th>[\#2462](https://gitlab.haskell.org//ghc/ghc/issues/2462)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2462">#2462</a></th>
|
|
|
<td>Data.List.sum is slower than 6.8.3</td></tr>
|
|
|
<tr><th>[\#2450](https://gitlab.haskell.org//ghc/ghc/issues/2450)</th>
|
|
|
<td>Data.Complex.magnitude squares using \^(2 :: Int), which is slow</td></tr>
|
|
|
<tr><th>[\#2440](https://gitlab.haskell.org//ghc/ghc/issues/2440)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2450">#2450</a></th>
|
|
|
<td>Data.Complex.magnitude squares using ^(2 :: Int), which is slow</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2440">#2440</a></th>
|
|
|
<td>Bad code with type families</td></tr>
|
|
|
<tr><th>[\#2396](https://gitlab.haskell.org//ghc/ghc/issues/2396)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2396">#2396</a></th>
|
|
|
<td>Default class method not inlined</td></tr>
|
|
|
<tr><th>[\#2329](https://gitlab.haskell.org//ghc/ghc/issues/2329)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2329">#2329</a></th>
|
|
|
<td>Control.Parallel.Strategies: definitions of rnf for most collections are poor</td></tr>
|
|
|
<tr><th>[\#2325](https://gitlab.haskell.org//ghc/ghc/issues/2325)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2325">#2325</a></th>
|
|
|
<td>Compile-time computations</td></tr>
|
|
|
<tr><th>[\#2280](https://gitlab.haskell.org//ghc/ghc/issues/2280)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2280">#2280</a></th>
|
|
|
<td>randomR too slow</td></tr>
|
|
|
<tr><th>[\#2253](https://gitlab.haskell.org//ghc/ghc/issues/2253)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2253">#2253</a></th>
|
|
|
<td>Native code generator could do better</td></tr>
|
|
|
<tr><th>[\#2236](https://gitlab.haskell.org//ghc/ghc/issues/2236)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2236">#2236</a></th>
|
|
|
<td>Deep stacks make execution time go through the roof</td></tr>
|
|
|
<tr><th>[\#2185](https://gitlab.haskell.org//ghc/ghc/issues/2185)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2185">#2185</a></th>
|
|
|
<td>Memory leak with parMap</td></tr>
|
|
|
<tr><th>[\#2163](https://gitlab.haskell.org//ghc/ghc/issues/2163)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2163">#2163</a></th>
|
|
|
<td>GHC makes thunks for Integers we are strict in</td></tr>
|
|
|
<tr><th>[\#2105](https://gitlab.haskell.org//ghc/ghc/issues/2105)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2105">#2105</a></th>
|
|
|
<td>garbage collection confusing in ghci for foreign objects</td></tr>
|
|
|
<tr><th>[\#2092](https://gitlab.haskell.org//ghc/ghc/issues/2092)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2092">#2092</a></th>
|
|
|
<td>Quadratic amount of code generated</td></tr>
|
|
|
<tr><th>[\#2078](https://gitlab.haskell.org//ghc/ghc/issues/2078)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/2078">#2078</a></th>
|
|
|
<td>INLINE and strictness</td></tr>
|
|
|
<tr><th>[\#1890](https://gitlab.haskell.org//ghc/ghc/issues/1890)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/1890">#1890</a></th>
|
|
|
<td>Regression in mandelbrot benchmark due to inlining</td></tr>
|
|
|
<tr><th>[\#1889](https://gitlab.haskell.org//ghc/ghc/issues/1889)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/1889">#1889</a></th>
|
|
|
<td>Regression in concurrency performance from ghc 6.6 to 6.8</td></tr>
|
|
|
<tr><th>[\#1818](https://gitlab.haskell.org//ghc/ghc/issues/1818)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/1818">#1818</a></th>
|
|
|
<td>Code size increase vs. 6.6.1</td></tr>
|
|
|
<tr><th>[\#1752](https://gitlab.haskell.org//ghc/ghc/issues/1752)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/1752">#1752</a></th>
|
|
|
<td>CSE can create space leaks by increasing sharing</td></tr>
|
|
|
<tr><th>[\#1607](https://gitlab.haskell.org//ghc/ghc/issues/1607)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/1607">#1607</a></th>
|
|
|
<td>seq can make code slower</td></tr>
|
|
|
<tr><th>[\#1434](https://gitlab.haskell.org//ghc/ghc/issues/1434)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/1434">#1434</a></th>
|
|
|
<td>Missing RULEs for truncate</td></tr>
|
|
|
<tr><th>[\#1117](https://gitlab.haskell.org//ghc/ghc/issues/1117)</th>
|
|
|
<td>\[2,4..10\] is not a good list producer</td></tr>
|
|
|
<tr><th>[\#955](https://gitlab.haskell.org//ghc/ghc/issues/955)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/1117">#1117</a></th>
|
|
|
<td>[2,4..10] is not a good list producer</td></tr>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/955">#955</a></th>
|
|
|
<td>more object-code blow-up in ghc-6.8.3 vs. ghc-6.4.2 (both with optimization)</td></tr>
|
|
|
<tr><th>[\#876](https://gitlab.haskell.org//ghc/ghc/issues/876)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/876">#876</a></th>
|
|
|
<td>Length is not a good consumer</td></tr>
|
|
|
<tr><th>[\#783](https://gitlab.haskell.org//ghc/ghc/issues/783)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/783">#783</a></th>
|
|
|
<td>SRTs bigger than they should be?</td></tr>
|
|
|
<tr><th>[\#650](https://gitlab.haskell.org//ghc/ghc/issues/650)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/650">#650</a></th>
|
|
|
<td>Improve interaction between mutable arrays and GC</td></tr>
|
|
|
<tr><th>[\#635](https://gitlab.haskell.org//ghc/ghc/issues/635)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/635">#635</a></th>
|
|
|
<td>Replace use of select() in the I/O manager with epoll/kqueue/etc.</td></tr>
|
|
|
<tr><th>[\#594](https://gitlab.haskell.org//ghc/ghc/issues/594)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/594">#594</a></th>
|
|
|
<td>Support use of SSE2 in the x86 native code genreator</td></tr>
|
|
|
<tr><th>[\#427](https://gitlab.haskell.org//ghc/ghc/issues/427)</th>
|
|
|
<tr><th><a href="https://gitlab.haskell.org//ghc/ghc/issues/427">#427</a></th>
|
|
|
<td>Random.StdGen slowness</td></tr></table>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
## Nofib results
|
|
|
|
|
|
|
|
|
### Austin, 5 May 2015
|
|
|
|
|
|
|
... | ... | @@ -1384,6 +1395,10 @@ TODO Lots of fusion changes have happened in the last few months too - but these |
|
|
- `map` strikes again? 2601324 vs 3597333 calls, with an accompanying allocation delta.
|
|
|
- But some other inner loops here work and go away correctly (mainly `go`), unlike e.g. `lcss`.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#### Comparing integer-gmp 0.5 and 1.0
|
|
|
|
|
|
|
... | ... | @@ -1413,6 +1428,8 @@ One of the major factors that has changed recently is `integer-gmp`. Namely, GHC |
|
|
|
|
|
The allocation issue is actually discussed in the commit message ([c774b28f76ee4c220f7c1c9fd81585e0e3af0e8a](/trac/ghc/changeset/c774b28f76ee4c220f7c1c9fd81585e0e3af0e8a/ghc)),
|
|
|
|
|
|
|
|
|
>
|
|
|
>
|
|
|
> Due to the different (over)allocation scheme and potentially different
|
|
|
> accounting (via the new `{shrink,resize}MutableByteArray#` primitives),
|
... | ... | @@ -1420,6 +1437,8 @@ The allocation issue is actually discussed in the commit message ([c774b28f76ee4 |
|
|
> numbers (but not necessarily an increase in runtime!). I believe the
|
|
|
> allocation numbers could improve if `{resize,shrink}MutableByteArray#`
|
|
|
> could be optimised to reallocate in-place more efficiently.
|
|
|
>
|
|
|
>
|
|
|
|
|
|
|
|
|
The message then goes on to list exactly the nofib tests mentioned above. Given that there isn't a strong negative trend in runtime corresponding with these increased allocations, I'm leaning towards ignoring these for now. |