- ghc-tickets - Haskell.org

[GHC] #11372: Loopification does not trigger for IO even if it could
by GHC 11 Apr '17

11 Apr '17

#11372: Loopification does not trigger for IO even if it could -------------------------------------+------------------------------------- Reporter: jscholl | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.3 (CodeGen) | Keywords: cmm, | Operating System: Unknown/Multiple loopification, code generation | Architecture: | Type of failure: Runtime Unknown/Multiple | performance bug Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- The loopification optimization, as I understand it, allows a self- recursive function to jump to a local label instead of the beginning of the function, thus skipping a potential stack check. However, I only observe it triggering for pure functions while IO functions do not get that benefit, even when it would be possible. I discovered this in #8793 after looking into an unexpected speedup by removing the IO context from an otherwise pure loop and while such a loop can simply be changed to a pure version (the {{{IOLoop}}} examples), other functions can not, but the optimization could be applied to them (see {{{MapM.hs}}}). I tried to benchmark the differences between a naive loop in IO and some horrible {{{inlinePerformIO}}} hacks to get the loopification to fire and the "optimized" version performs 3-5% faster on my machine. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11372> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 12

[GHC] #8585: Loopification should omit stack check
by GHC 11 Apr '17

11 Apr '17

#8585: Loopification should omit stack check ------------------------------+-------------------------------------------- Reporter: jstolarek | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.7 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: Runtime performance bug Unknown/Multiple | Test Case: Difficulty: Unknown | Blocking: Blocked By: | Related Tickets: | ------------------------------+-------------------------------------------- When we optimize a self-recursive tail call using loopification we don't need to perform a stack check in every loop. This is because a tail recursive function uses constant amount of stack. We should therefore place the loop header after the stack check, but before the heap check (because heap may grow in every call). parcs proposed a patch [https://ghc.haskell.org/trac/ghc/ticket/8275#comment:34 here]. We just need to make sure why it works and add some documentation. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8585> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5

[GHC] #8871: No-op assignment I64[BaseReg + 784] = I64[BaseReg + 784]; is generated into optimized Cmm
by GHC 11 Apr '17

11 Apr '17

#8871: No-op assignment I64[BaseReg + 784] = I64[BaseReg + 784]; is generated into optimized Cmm ------------------------------------+------------------------------------- Reporter: kgardas | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.9 Keywords: | Operating System: Unknown/Multiple Architecture: Unknown/Multiple | Type of failure: Other Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ------------------------------------+------------------------------------- Hello, on SPARC and I also guess on PPC it's possible to get following line in optimized Cmm code: {{{ I64[BaseReg + 784] = I64[BaseReg + 784]; }}} this line is then translated by NCG wasting 5 isns on SPARC at least. Don't know PPC. I'm not sure if this is possible to duplicate this on i386 due to fewer regs. Generally speaking you need to have 32bit target with more regs available. Interesting fact is that such line is not presented in non-optimized Cmm, but is presented in optimized one. Both optimized and non-optimized Cmms attached. Both get from compiling T7507 testcase by stage1 compiler on SPARC: {{{ /home/karel/vcs/ghc-src/ghc-sparc-reg_ncg/inplace/bin/ghc-stage1 -fforce- recomp -dcore-lint -dcmm-lint -dno-debug-output -no-user-package-db -rtsopts -fno-ghci-history -c T7507.hs -O -ddump-opt-cmm > T7507.opt-cmm- sparc-reg-ncg }}} Of course non-opt Cmm is got by -ddump-cmm instead of -ddump-opt-cmm. If you need more simplified testcase, then following code is usable too: {{{ module Main where import Data.Int main = print ( ( 2 ^ 6 ) :: Int64 ) }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8871> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 7

[GHC] #8887: Double double assignment in optimized Cmm on SPARC
by GHC 11 Apr '17

11 Apr '17

#8887: Double double assignment in optimized Cmm on SPARC ----------------------------+-------------------------------------------- Reporter: kgardas | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.6.3 Keywords: | Operating System: Solaris Architecture: sparc | Type of failure: Runtime performance bug Difficulty: Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | ----------------------------+-------------------------------------------- Hello, while reading ffi003 asm/opt-cmm for fixing this on SPARC I've noticed this code, this is optimized Cmm dump: {{{ 112 c1or: 113 _s1nw::F64 = F64[_s1nv::P32 + 3]; 114 _c1oj::I32 = sin; 115 _c1ok::F64 = _s1nw::F64; }}} this assignment to _s1nw::F64 looks useless as we may assign directly to _c1ok::F64, may we not? Both optimized and non-optimized Cmms attached. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8887> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3

[GHC] #9159: cmm case, binary search instead of jump table
by GHC 11 Apr '17

11 Apr '17

#9159: cmm case, binary search instead of jump table ------------------------------+-------------------------------------------- Reporter: wojteknar | Owner: Type: bug | Status: new Priority: low | Milestone: Component: Compiler | Version: 7.8.2 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: Runtime performance bug Unknown/Multiple | Test Case: Difficulty: Unknown | Blocking: Blocked By: | Related Tickets: | ------------------------------+-------------------------------------------- I'm not sure if this is qualifies as a bug or feature request. For case expressions where the scrutinee is Int#,or Int, or probably anything else numerical, GHC generates binary search, where a jump table could easily be used instead. The functions toChunk1# and toChunk2# yield suboptimal code. I found a satisfactory workaround, toChunk3# uses Enum and it is fine. For the attached code it probably does not matter much, but I have 65 cases in my real code, trying to implement a variant of ByteString, which will have the lowest possible storage overhead (just the info table pointer == one word) for lengths up to 64 bytes. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/9159> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 8

[GHC] #13563: Avoid redundant MOVes in generated code
by GHC 11 Apr '17

11 Apr '17

#13563: Avoid redundant MOVes in generated code --------------------------------------+--------------------------------- Reporter: alexbiehl | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.2 Keywords: | Operating System: Windows Architecture: x86_64 (amd64) | Type of failure: None/Unknown Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: --------------------------------------+--------------------------------- I stumbled upon this generated code: Everything is fine, a heap check like many others. {{{#!hs c2ro: Hp = Hp + 16; if (Hp > I64[BaseReg + 856]) goto c2rt; else goto c2rs; c2rt: I64[BaseReg + 904] = 16; I64[Sp - 48] = block_c2rp_info; I64[Sp - 40] = _s2pI::I64; I64[Sp - 32] = _s2pJ::I64; I64[Sp - 24] = _s2pK::I64; I64[Sp - 16] = _s2pN::I64; I64[Sp - 8] = _s2pO::I64; Sp = Sp - 48; call stg_gc_noregs() returns to c2rp, args: 8, res: 8, upd: 8; c2rp: _s2pI::I64 = I64[Sp + 8]; _s2pJ::I64 = I64[Sp + 16]; _s2pK::I64 = I64[Sp + 24]; _s2pN::I64 = I64[Sp + 32]; _s2pO::I64 = I64[Sp + 40]; Sp = Sp + 48; goto c2ro; c2rs: }}} Compiled to assembler: {{{#!asm _c2ro: addq $16,%r12 ; Heap check as usual cmpq 856(%r13),%r12 ja _c2rt _c2rs: ... _c2rt: movq $16,904(%r13) movq $block_c2rp_info,-48(%rbp) movq %r14,-40(%rbp) ; copy out sequence: move live variables movq %rsi,-32(%rbp) ; to stack movq %rax,-24(%rbp) movq %rbx,-16(%rbp) movq %rdi,-8(%rbp) addq $-48,%rbp jmp stg_gc_noregs ... .align 8 .quad 1989 .quad 32 block_c2rp_info: _c2rp: movq 8(%rbp),%rax ; we returned from gc land, now copy live variables back in movq 16(%rbp),%rbx movq 24(%rbp),%rcx movq 32(%rbp),%rdx movq 40(%rbp),%rsi addq $48,%rbp _n2st: ; Oh dear! We are moving our freshly moved register again for no obvious reason! movq %rsi,%rdi movq %rbx,%rsi movq %rdx,%rbx movq %rax,%r14 movq %rcx,%rax jmp _c2ro }}} What is happening here that GHC isn't able to directly assign the correct registers? Also the label `_n2st` suggest it is inserted at a later stage than the generated cmm code (Every other label is named contigously). -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13563> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 6

[GHC] #13562: Avoid redundant MOVes in generated code
by GHC 11 Apr '17

11 Apr '17

#13562: Avoid redundant MOVes in generated code --------------------------------------+--------------------------------- Reporter: alexbiehl | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.2 Keywords: | Operating System: Windows Architecture: x86_64 (amd64) | Type of failure: None/Unknown Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: --------------------------------------+--------------------------------- I stumbled upon this generated code: Everything is fine, a heap check like many others. {{{#!hs c2ro: Hp = Hp + 16; if (Hp > I64[BaseReg + 856]) goto c2rt; else goto c2rs; c2rt: I64[BaseReg + 904] = 16; I64[Sp - 48] = block_c2rp_info; I64[Sp - 40] = _s2pI::I64; I64[Sp - 32] = _s2pJ::I64; I64[Sp - 24] = _s2pK::I64; I64[Sp - 16] = _s2pN::I64; I64[Sp - 8] = _s2pO::I64; Sp = Sp - 48; call stg_gc_noregs() returns to c2rp, args: 8, res: 8, upd: 8; c2rp: _s2pI::I64 = I64[Sp + 8]; _s2pJ::I64 = I64[Sp + 16]; _s2pK::I64 = I64[Sp + 24]; _s2pN::I64 = I64[Sp + 32]; _s2pO::I64 = I64[Sp + 40]; Sp = Sp + 48; goto c2ro; c2rs: }}} Compiled to assembler: {{{#!asm _c2ro: addq $16,%r12 ; Heap check as usual cmpq 856(%r13),%r12 ja _c2rt _c2rs: ... _c2rt: movq $16,904(%r13) movq $block_c2rp_info,-48(%rbp) movq %r14,-40(%rbp) ; copy out sequence: move live variables movq %rsi,-32(%rbp) ; to stack movq %rax,-24(%rbp) movq %rbx,-16(%rbp) movq %rdi,-8(%rbp) addq $-48,%rbp jmp stg_gc_noregs ... .align 8 .quad 1989 .quad 32 block_c2rp_info: _c2rp: movq 8(%rbp),%rax ; we returned from gc land, now copy live variables back in movq 16(%rbp),%rbx movq 24(%rbp),%rcx movq 32(%rbp),%rdx movq 40(%rbp),%rsi addq $48,%rbp _n2st: ; Oh dear! We are moving our freshly moved register again for no obvious reason! movq %rsi,%rdi movq %rbx,%rsi movq %rdx,%rbx movq %rax,%r14 movq %rcx,%rax jmp _c2ro }}} What is happening here that GHC isn't able to directly assign the correct registers? Also the label `_n2st` suggest it is inserted at a later stage than the generated cmm code (Every other label is named contigously). -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13562> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 1

Re: [GHC] #4154: Deadlock in Chan module
by GHC 11 Apr '17

11 Apr '17

#4154: Deadlock in Chan module -------------------------------------+------------------------------------- Reporter: NeilMitchell | Owner: (none) Type: bug | Status: closed Priority: high | Milestone: 8.4.1 Component: libraries/base | Version: 6.12.3 Resolution: fixed | Keywords: Operating System: Unknown/Multiple | Architecture: Type of failure: Incorrect result | Unknown/Multiple at runtime | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by osa1): > Is it possible to define instead of isEmptyChan some non-blocking version of > readChan with tryTakeMVar and tryPutMVar? I think this can't work. A `readChan` is actually two `takeMVar`s. Implementation of `tryReadChan` has to use `tryTakeMVar`s, otherwise you can't avoid being blocked in some cases. So these two MVars that need to be taken to be able to read something off a chan need to be taken with `tryReadChan`. First `tryTakeMVar` would only succeed if the queue is empty. The trouble is in the case where the chan has enough stuff but currently some other thread is busy actually reading the contents (and updating the read-end) you'd get a `Nothing`, even though if you actually do `readChan` you'd get blocked for a very short amount of time because chan has enough contents. So this implementation would return `Nothing` in some cases when there is enough contents in the chan. Now suppose that you use `tryReadMVar` to read the read-end. Suppose that right after you read the read-end another thread does `readChan`, and takes the read-end MVar. Now there's a race condition between your thread and the other thread. The loser needs to re-take the read-end. Furthermore, if your thread was the only thread you can't update the read-end, because you didn't take it (remember that in this scenario we use `tryReadMVar` instead of `tryTakeMVar`). So neither `tryTakeMVar` nor `tryReadMVar` gives you a race-free implementation of `tryReadChan`. I hope this makes sense. (Another problem with both implementations is that you have no guarantees that you'll be able to read the contents. For example if chan has enough contents but a million threads are running `readChan` in parallel you may not be able to read anything with `tryReadChan`) `MVar`-based implementation is cute but has this limitation. (it also doesn't scale as number of writers and readers increase) -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/4154#comment:12> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

[GHC] #12603: INLINE and manually inlining produce different code
by GHC 11 Apr '17

11 Apr '17

#12603: INLINE and manually inlining produce different code -------------------------------------+------------------------------------- Reporter: bgamari | Owner: Type: task | Status: new Priority: normal | Milestone: 8.2.1 Component: Compiler | Version: 8.0.1 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: None/Unknown Unknown/Multiple | Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- Mikolaj reported that he was seeing significantly different code generated in the case of a manual `INLINE` versus manually inlining. I haven't looked into what the cause it and this isn't necessarily problematic; this is just a reminder to look into what is happening. See https://github.com/LambdaHack/LambdaHack/blob/97724fe8c73e80b329ddf326a8eb0…. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12603> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 38

Re: [GHC] #5609: Type checking arrow notation in the presence of deferred constraints
by GHC 11 Apr '17

11 Apr '17

#5609: Type checking arrow notation in the presence of deferred constraints -------------------------------------+------------------------------------- Reporter: dreixel | Owner: ross Type: bug | Status: closed Priority: low | Milestone: 7.6.2 Component: Compiler (Type | Version: 7.3 checker) | Resolution: fixed | Keywords: Arrows Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Changes (by simonpj): * keywords: => Arrows -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/5609#comment:7> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0