#8832: Constant-folding regression wrt `clearBit (bit 0) 0 ` --------------------------------------------+------------------------------ Reporter: hvr | Owner: Type: bug | Status: new Priority: normal | Milestone: 7.8.1 Component: Compiler | Version: 7.8.1-rc2 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: Type of failure: Runtime performance bug | Unknown/Multiple Test Case: | Difficulty: Unknown Blocking: | Blocked By: | Related Tickets: --------------------------------------------+------------------------------ Comment (by jstolarek): Sorry Simon, but I don't have enough time to look into this one. I'm working on #8707 at the moment. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8832#comment:2 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#8832: Constant-folding regression wrt `clearBit (bit 0) 0 ` --------------------------------------------+------------------------------ Reporter: hvr | Owner: simonpj Type: bug | Status: new Priority: normal | Milestone: 7.8.1 Component: Compiler | Version: 7.8.1-rc2 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: Type of failure: Runtime performance bug | Unknown/Multiple Test Case: | Difficulty: Unknown Blocking: | Blocked By: | Related Tickets: --------------------------------------------+------------------------------ Comment (by Simon Peyton Jones ): In [changeset:"8fd7d581da448d81fc2f9d47366c36c5f57ed564/ghc"]: {{{ #!CommitTicketReference repository="ghc" revision="8fd7d581da448d81fc2f9d47366c36c5f57ed564" Add BuiltinRules for constant-folding not# and notI# (logical complement) I don't know why these constant-folding rules were implemented for and/or/xor but not for 'not'. Adding them is part of the fix for Trac #8832. (The other part is in Data.Bits.) }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8832#comment:4 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#8832: Constant-folding regression wrt `clearBit (bit 0) 0 ` --------------------------------------------+------------------------------ Reporter: hvr | Owner: simonpj Type: bug | Status: new Priority: normal | Milestone: 7.8.1 Component: Compiler | Version: 7.8.1-rc2 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: Type of failure: Runtime performance bug | Unknown/Multiple Test Case: | Difficulty: Unknown Blocking: | Blocked By: | Related Tickets: --------------------------------------------+------------------------------ Comment (by Simon Peyton Jones ): In [changeset:"f7a7b586bc89ca7fd56792da4172bd93a2acdae9/base"]: {{{ #!CommitTicketReference repository="base" revision="f7a7b586bc89ca7fd56792da4172bd93a2acdae9" Add shiftR and shiftL implementations to instance Bits Integer Apart from simply making sense (avoid the conditional in 'shift'), this makes left and right shifts on Integer more likely to inline (plain 'shift' is just too large); and this in turn is important when fixing the Integer case of #8832 }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8832#comment:6 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#8832: Constant-folding regression wrt `clearBit (bit 0) 0 ` -------------------------------------------------+------------------------- Reporter: hvr | Owner: Type: bug | simonpj Priority: normal | Status: new Component: Compiler | Milestone: 7.8.1 Resolution: | Version: Operating System: Unknown/Multiple | 7.8.1-rc2 Type of failure: Runtime performance bug | Keywords: Test Case: | Architecture: simplCore/should_compile/T8832 | Unknown/Multiple Blocking: | Difficulty: | Unknown | Blocked By: | Related Tickets: -------------------------------------------------+------------------------- Changes (by simonpj): * testcase: => simplCore/should_compile/T8832 -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8832#comment:8 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#8832: Constant-folding regression wrt `clearBit (bit 0) 0 ` -------------------------------------------------+------------------------- Reporter: hvr | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: Resolution: | 7.8.1-rc2 Operating System: Unknown/Multiple | Keywords: Type of failure: Runtime performance bug | Architecture: Test Case: | Unknown/Multiple simplCore/should_compile/T8832 | Difficulty: Blocking: | Unknown | Blocked By: | Related Tickets: -------------------------------------------------+------------------------- Changes (by simonpj): * owner: simonpj => * status: closed => new * resolution: fixed => Comment: The test fails on 32-bit machines, because we don't have 64-bit primops on a 32-bit machine, so the constant folding doesn't work. Maybe we should have 64-bit primops on a 32-bit machine, but that's a separate story. Meanwhile, we need to fix the test so that it omits the 64-bit test on 32-bit machines. Austin can you do this, post release? Simon -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8832#comment:10 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#8832: Constant-folding regression wrt `clearBit (bit 0) 0 ` -------------------------------------------------+------------------------- Reporter: hvr | Owner: Type: bug | thoughtpolice Priority: normal | Status: new Component: Compiler | Milestone: Resolution: | Version: Operating System: Unknown/Multiple | 7.8.1-rc2 Type of failure: Runtime performance bug | Keywords: Test Case: | Architecture: simplCore/should_compile/T8832 | Unknown/Multiple Blocking: | Difficulty: | Unknown | Blocked By: | Related Tickets: -------------------------------------------------+------------------------- Comment (by Herbert Valerio Riedel ): In [changeset:"40ba3daa8ce68eea92f7a42b0c1f6c716636b494/ghc"]: {{{ #!CommitTicketReference repository="ghc" revision="40ba3daa8ce68eea92f7a42b0c1f6c716636b494" Expect test failure for T8832 on 32bit (re #8832) Signed-off-by: Herbert Valerio Riedel }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8832#comment:12 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#8832: Constant-folding regression wrt `clearBit (bit 0) 0 ` -------------------------------------+------------------------------------- Reporter: hvr | Owner: thoughtpolice Type: bug | Status: new Priority: high | Milestone: 7.10.1 Component: Compiler | Version: 7.8.1-rc2 Resolution: | Keywords: Differential Revisions: | Operating System: Unknown/Multiple Architecture: | Type of failure: Runtime Unknown/Multiple | performance bug Difficulty: Unknown | Test Case: Blocked By: | simplCore/should_compile/T8832 Related Tickets: | Blocking: -------------------------------------+------------------------------------- Changes (by simonpj): * priority: normal => high Comment: The bug is fixed. The only issue is that the test has some 64-bit stuff in it, and on a 32-bit machine that doesn't constant-fold. Which is probably fine. To close the ticket we just need to make the test depend on whether we are on a 64-bit machine. I don't know how to do that, but it can't be hard. Could someone do it? I'll make it "high" priority to get it some attention, rather than because it's terribly important. Simon -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8832#comment:14 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#8832: Constant-folding regression wrt `clearBit (bit 0) 0 ` -------------------------------------+------------------------------------- Reporter: hvr | Owner: thoughtpolice Type: bug | Status: new Priority: high | Milestone: 7.10.1 Component: Compiler | Version: 7.8.1-rc2 Resolution: | Keywords: Operating System: | Architecture: Unknown/Multiple Unknown/Multiple | Difficulty: Unknown Type of failure: Runtime | Blocked By: performance bug | Related Tickets: Test Case: | simplCore/should_compile/T8832 | Blocking: | Differential Revisions: | -------------------------------------+------------------------------------- Comment (by rwbarton): Is this what you had in mind, Simon? Without the `#ifdef`s the grep output on a 32-bit system would contain uniques, so I couldn't just add a `.stdout-ws-32` file. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8832#comment:16 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#8832: Constant-folding regression wrt `clearBit (bit 0) 0 ` -------------------------------------+------------------------------------- Reporter: hvr | Owner: thoughtpolice Type: bug | Status: closed Priority: high | Milestone: 7.10.1 Component: Compiler | Version: 7.8.1-rc2 Resolution: fixed | Keywords: Operating System: | Architecture: Unknown/Multiple Unknown/Multiple | Difficulty: Unknown Type of failure: Runtime | Blocked By: performance bug | Related Tickets: Test Case: | simplCore/should_compile/T8832 | Blocking: | Differential Revisions: | -------------------------------------+------------------------------------- Comment (by hvr): Replying to [comment:15 Reid Barton ]:

In [changeset:"a72614c40186521da7ba090b102436e61a80b7a7/ghc"]: {{{ #!CommitTicketReference repository="ghc" revision="a72614c40186521da7ba090b102436e61a80b7a7" Make T8832 operative on 32-bit systems (#8832)

(Also, the 'extra_clean' was unnecessary.) }}}

Btw, now that I saw that commit, I've seen other testcases making use of the pre-defined `SIZEOF_HSWORD` (and there's also `WORD_SIZE_IN_BITS`) CPP symbol to test for wordsize. Would that have worked as well? -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8832#comment:18 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#8832: Constant-folding regression wrt `clearBit (bit 0) 0 ` -------------------------------------+------------------------------------- Reporter: hvr | Owner: Type: bug | Status: new Priority: high | Milestone: 7.10.1 Component: Compiler | Version: 7.8.1-rc2 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: Type of failure: Runtime | Unknown/Multiple performance bug | Test Case: Blocked By: | simplCore/should_compile/T8832 Related Tickets: | Blocking: | Differential Revisions: -------------------------------------+------------------------------------- Changes (by thomie): * owner: thoughtpolice => * status: closed => new * resolution: fixed => Comment: `z` is still not properly constant-folded. The test is deceiving. It greps for '#', and there is no '#' in the output for `z` (not until #8274 is implemented, which I'm working on). {{{ $ ghc-7.10.0.20150123 Temp.hs -ddump-simpl -fforce-recomp -dsuppress-all -O [1 of 1] Compiling M ( Temp.hs, Temp.o ) ==================== Tidy Core ==================== Result size of Tidy Core = {terms: 10, types: 3, coercions: 0} z2 z2 = bitInteger 0 z1 z1 = complementInteger z2 z z = andInteger z2 z1 }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8832#comment:20 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#8832: Constant-folding regression wrt `clearBit (bit 0) 0 ` -------------------------------------+------------------------------------- Reporter: hvr | Owner: Type: bug | Status: new Priority: high | Milestone: 7.12.1 Component: Compiler | Version: 7.8.1-rc2 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: Runtime | Test Case: performance bug | simplCore/should_compile/T8832 Blocked By: | Blocking: Related Tickets: | Differential Revisions: -------------------------------------+------------------------------------- Comment (by bgamari): The problem here is that the `Bits` instance for `Integer` overrides `bit`, using it's own `bitInteger` function in place of the usual `bitDefault`. `bitDefault` is constant folded by `PrelRules` by virtue of being implemented in terms of `shiftL`. This is presumably done to optimize the case of construction of a `BigNat` for large arguments, but `bitBigNat#`, which is what handles this case, is currently just the naive implementation with a TODO. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8832#comment:23 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#8832: Constant-folding regression wrt `clearBit (bit 0) 0 ` -------------------------------------+------------------------------------- Reporter: hvr | Owner: ekmett Type: bug | Status: new Priority: high | Milestone: 7.12.1 Component: Core Libraries | Version: 7.8.1-rc2 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: Runtime | Test Case: performance bug | simplCore/should_compile/T8832 Blocked By: | Blocking: Related Tickets: | Differential Revisions: -------------------------------------+------------------------------------- Comment (by bgamari): For the record, hvr has indicated that he will eventually be implementing a more efficient `bitInteger`. However, this still means that `Integer` won't get proper constant folding (as it won't be implemented in terms of `shiftL`). I'm not really sure it's fair to call this a library problem: the compiler currently makes the library author choose between having a constant-folded `bit` implementation (by implementing in terms of other operations which are constant folded) or an implementation which is implemented efficiently for the type in question. There are a few ways we could handle this: 1. add a `PrelRule` to specifically handle `Bits.bits` 2. somehow extend the rule rewriting system to allow these rules to be expressed in the source language Option 1 is unfortunate in that `Bits.bits` is likely far from the last operation which will need this treatment. Moreover, it leaves users who want to implement other types implementing `Bits` and similar classes covered by `PrelRules` high and dry. Arguably this is a limitation of the rule rewriting system, hence option 2. At first glance it would seem like allowing a rule to match conditioned on the nature of its arguments (either literal or non-literal) and allowing compile-time evaluation of the RHS may be sufficient to address this. This, however, would be non-trivial to implement (namely compile- time evaluation would require the interpreter) and may present termination issues. For these reasons (and perhaps others I haven't yet thought of) I doubt this is a viable path. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8832#comment:25 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#8832: Constant-folding regression wrt `clearBit (bit 0) 0 ` -------------------------------------+------------------------------------- Reporter: hvr | Owner: bgamari Type: bug | Status: new Priority: high | Milestone: 7.12.1 Component: Core Libraries | Version: 7.8.1-rc2 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: Runtime | Test Case: performance bug | simplCore/should_compile/T8832 Blocked By: | Blocking: Related Tickets: | Differential Revisions: -------------------------------------+------------------------------------- Changes (by bgamari): * owner: ekmett => bgamari Comment: I discussed this with Simon during out GHC meeting and we agreed that the best solution here would be to add a `PrelRule` covering `bit`. -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8832#comment:27 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#8832: Constant-folding regression wrt `clearBit (bit 0) 0 ` -------------------------------------+------------------------------------- Reporter: hvr | Owner: bgamari Type: bug | Status: patch Priority: high | Milestone: 8.0.1 Component: Core Libraries | Version: 7.8.1-rc2 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: Runtime | Test Case: performance bug | simplCore/should_compile/T8832 Blocked By: | Blocking: Related Tickets: | Differential Revisions: Phab:D1255 -------------------------------------+------------------------------------- Changes (by bgamari): * status: new => patch * differential: => Phab:D1255 -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8832#comment:30 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#8832: Constant-folding regression wrt `clearBit (bit 0) 0 ` -------------------------------------+------------------------------------- Reporter: hvr | Owner: bgamari Type: bug | Status: patch Priority: high | Milestone: 8.0.1 Component: Core Libraries | Version: 7.8.1-rc2 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: Runtime | Test Case: performance bug | simplCore/should_compile/T8832 Blocked By: | Blocking: Related Tickets: | Differential Revisions: Phab:D1255 -------------------------------------+------------------------------------- Comment (by Thomas Miedema ): In [changeset:"4f9ee91303be9c122af6e91e5e599f589e3f196f/ghc" 4f9ee91/ghc]: {{{ #!CommitTicketReference repository="ghc" revision="4f9ee91303be9c122af6e91e5e599f589e3f196f" Testsuite: update expected output for T8832 on 32-bit systems (#8832) }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8832#comment:32 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler

#8832: Constant-folding regression wrt `clearBit (bit 0) 0 ` -------------------------------------+------------------------------------- Reporter: hvr | Owner: bgamari Type: bug | Status: closed Priority: high | Milestone: 8.0.1 Component: Core Libraries | Version: 7.8.1-rc2 Resolution: fixed | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: Runtime | Test Case: performance bug | simplCore/should_compile/T8832 Blocked By: | Blocking: Related Tickets: | Differential Revisions: Phab:D1255 -------------------------------------+------------------------------------- Comment (by Thomas Miedema ): In [changeset:"5883b5665860ed5f3199c59dc0d843a66408741b/ghc" 5883b56/ghc]: {{{ #!CommitTicketReference repository="ghc" revision="5883b5665860ed5f3199c59dc0d843a66408741b" Testsuite: properly fix T8832.stdout-ws-32 (#8832) }}} -- Ticket URL: http://ghc.haskell.org/trac/ghc/ticket/8832#comment:34 GHC http://www.haskell.org/ghc/ The Glasgow Haskell Compiler