August 2017 - ghc-tickets

[GHC] #8472: Primitive string literals prevent optimization
by GHC 16 Aug '17

16 Aug '17

#8472: Primitive string literals prevent optimization ------------------------------+-------------------------------------------- Reporter: akio | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.6.3 Keywords: | Operating System: Linux Architecture: x86_64 | Type of failure: Runtime performance bug (amd64) | Test Case: Difficulty: Unknown | Blocking: Blocked By: | Related Tickets: | ------------------------------+-------------------------------------------- Using an Addr# literal seems to result in less aggressive optimization. If I compile the attached program like this: {{{ ghc -O2 -fforce-recomp -ddump-simpl addr.hs }}} the code is optimized nicely. Everything are inlined into {{{t}}}, intermediate pairs are eliminated, etc. However, when I replace the Int# literals in the code with Addr# literals by defining the {{{ADDR}}} macro: {{{ ghc -O2 -fforce-recomp -ddump-simpl -DADDR addr.hs }}} GHC now creates 2 extra top-level bindings, each of which allocates a pair. I don't see why the presence of Addr# literals should prevent inlining, so I'm reporting a bug. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/8472> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 24

Re: [GHC] #4385: Type-level natural numbers
by GHC 16 Aug '17

16 Aug '17

#4385: Type-level natural numbers -------------------------------------+------------------------------------- Reporter: diatchki | Owner: diatchki Type: feature request | Status: new Priority: normal | Milestone: Component: Compiler (Type | Version: checker) | Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by bgamari): Iavor, what is the status of your plugin? Given that it seems unlikely that we'll merge an SMT solver into GHC, perhaps we should close this? -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/4385#comment:77> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

Re: [GHC] #2840: Top level string literals
by GHC 16 Aug '17

16 Aug '17

#2840: Top level string literals -------------------------------------+------------------------------------- Reporter: simonpj | Owner: (none) Type: bug | Status: closed Priority: lowest | Milestone: 7.6.2 Component: Compiler | Version: 6.10.1 Resolution: duplicate | Keywords: strings Operating System: Unknown/Multiple | Architecture: Type of failure: Runtime | Unknown/Multiple performance bug | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Changes (by bgamari): * keywords: => strings Old description: > At the moment GHC's internal language does not allow any top-level > definitions of unlifted type, and for the most part rightly so. But > consider this: > {{{ > f :: Int -> String > f n = let a::Addr# = "foo" > in let g y = ...a...g... > in g n > }}} > Here we'd like to float the definitions out thus: > {{{ > a::Addr# = "foo" > g y = ...a...g... > f n = g n > }}} > This is much better. Usually this happens, but not here, because we > don't allow a top-level binding for an `Addr#`. But really perhaps we > should allow an exception for ''literals'', which can safely be bound at > top level. > > For literals other than strings, this doesn't make any difference, > because we inline them freely. But for literal strings we don't want to > make lots of copies of them; on the contrary we'd like to CSE identical > strings. So it'd help to be able to bind them at top level. > > Simon New description: At the moment GHC's internal language does not allow any top-level definitions of unlifted type, and for the most part rightly so. But consider this: {{{#!hs f :: Int -> String f n = let a::Addr# = "foo" in let g y = ...a...g... in g n }}} Here we'd like to float the definitions out thus: {{{#!hs a::Addr# = "foo" g y = ...a...g... f n = g n }}} This is much better. Usually this happens, but not here, because we don't allow a top-level binding for an `Addr#`. But really perhaps we should allow an exception for ''literals'', which can safely be bound at top level. For literals other than strings, this doesn't make any difference, because we inline them freely. But for literal strings we don't want to make lots of copies of them; on the contrary we'd like to CSE identical strings. So it'd help to be able to bind them at top level. Simon -- -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/2840#comment:10> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

Re: [GHC] #5218: Add unpackCStringLen# to create Strings from string literals
by GHC 16 Aug '17

16 Aug '17

#5218: Add unpackCStringLen# to create Strings from string literals -------------------------------------+------------------------------------- Reporter: tibbe | Owner: thoughtpolice Type: feature request | Status: patch Priority: normal | Milestone: Component: Compiler | Version: 7.0.3 Resolution: | Keywords: strings Operating System: Unknown/Multiple | Architecture: Type of failure: Runtime | Unknown/Multiple performance bug | Test Case: Blocked By: | Blocking: Related Tickets: #5877 #10064 | Differential Rev(s): Phab:D2443 #11312, #9719 | Wiki Page: | -------------------------------------+------------------------------------- Changes (by bgamari): * keywords: => strings -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/5218#comment:79> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

Re: [GHC] #7307: Share top-level code for strings
by GHC 16 Aug '17

16 Aug '17

#7307: Share top-level code for strings -------------------------------------+------------------------------------- Reporter: simonpj | Owner: parcs Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.6.1 Resolution: | Keywords: strings Operating System: Unknown/Multiple | Architecture: Type of failure: Runtime | Unknown/Multiple performance bug | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Changes (by bgamari): * keywords: => strings Old description: > A string constant in GHC turns into > {{{ > foo :: String > foo = unpackCString# "the-string' > }}} > This is a top-level thunk, and it expands into rather a lot of code like > this > {{{ > .text > .align 4,0x90 > .long 0 > .long 22 > .globl _Foo_zdfTypeableTzuds1_info > _Foo_zdfTypeableTzuds1_info: > .LcvI: > movl %esi,%eax > leal -12(%ebp),%ecx > cmpl 84(%ebx),%ecx > jb .LcvQ > addl $8,%edi > cmpl 92(%ebx),%edi > ja .LcvS > movl $_stg_CAF_BLACKHOLE_info,-4(%edi) > movl 100(%ebx),%ecx > movl %ecx,0(%edi) > leal -4(%edi),%ecx > pushl %ecx > pushl %eax > pushl %ebx > movl %eax,76(%esp) > call _newCAF > addl $12,%esp > testl %eax,%eax > je .LcvL > movl $_stg_bh_upd_frame_info,-8(%ebp) > leal -4(%edi),%eax > movl %eax,-4(%ebp) > movl $_cvJ_str,-12(%ebp) > addl $-12,%ebp > jmp _ghczmprim_GHCziCString_unpackCStringzh_info > .LcvL: > movl 64(%esp),%eax > jmp *(%eax) > .LcvS: > movl $8,116(%ebx) > .LcvQ: > movl %eax,%esi > jmp *-12(%ebx) > }}} > That's rather a lot of goop for one thunk! Of course we can share this, > by making a 2-word thunk like this: > {{{ > ------------------------------ > | TopUnpack_info | -------|-----> "the-string"# > ------------------------------ > }}} > where `TopUnpack_info` is a shared RTS info-table and code that embodies > the code fragment above. > > This would save useless code bloat for every constant string. (This came > up when looking at the code generated by `deriving(Typeable)`.) New description: A string constant in GHC turns into {{{#!hs foo :: String foo = unpackCString# "the-string' }}} This is a top-level thunk, and it expands into rather a lot of code like this {{{ .text .align 4,0x90 .long 0 .long 22 .globl _Foo_zdfTypeableTzuds1_info _Foo_zdfTypeableTzuds1_info: .LcvI: movl %esi,%eax leal -12(%ebp),%ecx cmpl 84(%ebx),%ecx jb .LcvQ addl $8,%edi cmpl 92(%ebx),%edi ja .LcvS movl $_stg_CAF_BLACKHOLE_info,-4(%edi) movl 100(%ebx),%ecx movl %ecx,0(%edi) leal -4(%edi),%ecx pushl %ecx pushl %eax pushl %ebx movl %eax,76(%esp) call _newCAF addl $12,%esp testl %eax,%eax je .LcvL movl $_stg_bh_upd_frame_info,-8(%ebp) leal -4(%edi),%eax movl %eax,-4(%ebp) movl $_cvJ_str,-12(%ebp) addl $-12,%ebp jmp _ghczmprim_GHCziCString_unpackCStringzh_info .LcvL: movl 64(%esp),%eax jmp *(%eax) .LcvS: movl $8,116(%ebx) .LcvQ: movl %eax,%esi jmp *-12(%ebx) }}} That's rather a lot of goop for one thunk! Of course we can share this, by making a 2-word thunk like this: {{{ ------------------------------ | TopUnpack_info | -------|-----> "the-string"# ------------------------------ }}} where `TopUnpack_info` is a shared RTS info-table and code that embodies the code fragment above. This would save useless code bloat for every constant string. (This came up when looking at the code generated by `deriving(Typeable)`.) -- -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/7307#comment:14> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

[GHC] #9577: String literals are wasting space
by GHC 16 Aug '17

16 Aug '17

#9577: String literals are wasting space -------------------------------------+------------------------------------- Reporter: xnyhps | Owner: Type: bug | Status: new Priority: low | Milestone: Component: Compiler (NCG) | Version: 7.8.2 Keywords: | Operating System: Architecture: Unknown/Multiple | Unknown/Multiple Difficulty: Unknown | Type of failure: Runtime Blocked By: | performance bug Related Tickets: | Test Case: | Blocking: | Differential Revisions: -------------------------------------+------------------------------------- For [https://phabricator.haskell.org/D199 D199] I looked into how string literals are compiled down by GHC. On 64-bit OS X, a simple string `"AAA"` turns into assembly: {{{ .const .align 3 .align 0 c38E_str: .byte 65 .byte 65 .byte 65 .byte 0 }}} (And also something that invokes `unpackCString#`, but that isn't relevant here.) (`MkCore.mkStringExprFS` -> `CmmUtils.mkByteStringCLit` -> `compiler/nativeGen/X86/Ppr.pprSectionHeader`.) Note how this: * Is 8 byte aligned. * Is a `.const` section. I can't find any reason why string literals would need to be 8-byte aligned on OS X. There might be a small benefit in performance to read data starting 8-byte aligned, but I doubt doing that for string literals would be a meaningful difference. Assembly from both clang and gcc does not align string literals. The trivial program: {{{#!hs main :: IO () main = return () }}} has almost 5kB of wasted space of padding between all strings the Prelude brings in, built with GHC HEAD. The fact that it is a `.const` section, instead of `.cstring` (https://developer.apple.com/library/mac/documentation/DeveloperTools/Refere…) means duplicate strings aren't shared by the assembler. GHC floats out string literals to the top-level and uses CSE to eliminate duplicates, but that only works in a single modules. Strings shared between different modules end up as duplicate strings in an executable. The same program as above also has ~4kB of wasted space due to duplicate Prelude strings (`"base"` occurs 16 times!). Compared to the total binary size (4MB after stripping), removing this redundant data wouldn't be a big improvement (0.2%), but I still think it can be a worthwile optimization. I think this can be solved quite easily by creating a new section header for literal strings, which is unaligned and of type `.cstring`. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/9577> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 26

[GHC] #10922: String inlining is inconsistent
by GHC 16 Aug '17

16 Aug '17

#10922: String inlining is inconsistent -------------------------------------+------------------------------------- Reporter: xnyhps | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.10.1 Keywords: | Operating System: Unknown/Multiple Architecture: x86_64 | Type of failure: Runtime (amd64) | performance bug Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | -------------------------------------+------------------------------------- I have the following code: A.hs: {{{#!hs module A where foo :: String {-# INLINE foo #-} foo = "foo" }}} B.hs: {{{#!hs import A main = if foo == "foo" then return () else putStrLn "Wrong" }}} Compiling this with `-O2` shows the if-statement has not been eliminated (`"Wrong"` is still part of the output with `-ddump-simpl`). However, if I rewrite the code to: A.hs: {{{#!hs module A where foo :: () -> String {-# INLINE foo #-} foo () = "foo" }}} B.hs: {{{#!hs import A main = if foo () == "foo" then return () else putStrLn "Wrong" }}} Then the if-statement disappears and the generated Core has no string literals left. Even when the literal can not be eliminated from B it seems GHC is fine with duplicating it accross two modules if it occurs somewhere inside a function. But once I make it a top-level expression of type `String`, inlining it does not happen. I can not think of how this could be working as intended. (The case where `A.foo` is `""` seems to work differently, but also does not get optimized away.) (This happened to me when rewriting some code that previously used `CPP` for conditional compilation to using `if System.Info.os == "darwin" then ... else ...` and expecting the other OS cases to get optimized away.) -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10922> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 1

[GHC] #12585: GHC duplicates string literals in rodata section and breaks 'Ptr Addr#' equality
by GHC 16 Aug '17

16 Aug '17

#12585: GHC duplicates string literals in rodata section and breaks 'Ptr Addr#' equality -------------------------------------+------------------------------------- Reporter: slyfox | Owner: Type: bug | Status: new Priority: normal | Milestone: 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: -------------------------------------+------------------------------------- {{{#!hs -- test-sha256.hs: {-# LANGUAGE MagicHash #-} module Main (main) where import GHC.Prim (Addr#) import GHC.Ptr (Ptr(..), minusPtr) bug :: Addr# -> IO () bug a = do print ("cmp:", Ptr a == Ptr a) print ("delta:", Ptr a `minusPtr` Ptr a) print ("values:", Ptr a, Ptr a) main :: IO () main = bug "Assumptions are subtle!"# }}} {{{ $ inplace/bin/ghc-stage2 -fforce-recomp -O1 --make test-sha256.hs && ./test-sha256 [1 of 1] Compiling Main ( test-sha256.hs, test-sha256.o ) Linking test-sha256 ... ("cmp:",False) ("delta:",-24) ("values:",0x000000000072fdc0,0x000000000072fda8) }}} Stg shows that literal gets inlined: {{{ $ inplace/bin/ghc-stage2 -fforce-recomp -O1 --make test-sha256 -ddump-stg -dsuppress-all -dsuppress-uniques 2>&1 | grep Assumptions eqAddr# ["Assumptions are subtle!"# "Assumptions are subtle!"#] minusAddr# ["Assumptions are subtle!"# "Assumptions are subtle!"#] $w$cshowsPrec "Assumptions are subtle!"# w2 $w$cshowsPrec "Assumptions are subtle!"# w2 eqAddr# ["Assumptions are subtle!"# "Assumptions are subtle!"#] minusAddr# ["Assumptions are subtle!"# "Assumptions are subtle!"#] $w$cshowsPrec "Assumptions are subtle!"# w2 $w$cshowsPrec "Assumptions are subtle!"# w2 }}} I've found this bug as a SIGSEGV on testsuite cryptohash-sha256-0.11.100.1 from hackage. Bytestring assumes that address does not change and implements loops over Ptrs https://github.com/haskell/bytestring/blob/master/Data/ByteString.hs#L1171 : {{{#!hs filter :: (Word8 -> Bool) -> ByteString -> ByteString filter k ps@(PS x s l) | null ps = ps | otherwise = unsafePerformIO $ createAndTrim l $ \p -> withForeignPtr x $ \f -> do t <- go (f `plusPtr` s) p (f `plusPtr` (s + l)) return $! t `minusPtr` p -- actual length where go !f !t !end | f == end = return t | otherwise = do w <- peek f if k w then poke t w >> go (f `plusPtr` 1) (t `plusPtr` 1) end else go (f `plusPtr` 1) t end {-# INLINE filter #-} }}} In case of cryptohash-sha256-0.11.100.1 '''t <- go (f `plusPtr` s) p (f `plusPtr` (s + l))''' for literal inlined righ at 'f' call which caused testsuite failure. It seems sensible not to emit the literal more than once into '''.rodata''' section. It won't guard against problems where literal is exported as a part of .hi file but might be good enough for common cases like this. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12585> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 7

[GHC] #13367: CSE not working for top-level literal strings
by GHC 16 Aug '17

16 Aug '17

#13367: CSE not working for top-level literal strings -------------------------------------+------------------------------------- Reporter: simonpj | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: 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: -------------------------------------+------------------------------------- Consider {{{ {-# LANGUAGE MagicHash #-} module S( z ) where import GHC.Exts data T = MkT Addr# x = MkT "foo"# y = MkT "foo"# z = (x,y) }}} You'd expect those literal strings to get CSE'd but currently they are not. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13367> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3

[GHC] #13226: Compiler allocation regressions from top-level string literal patch
by GHC 16 Aug '17

16 Aug '17

#13226: Compiler allocation regressions from top-level string literal patch -------------------------------------+------------------------------------- Reporter: dfeuer | Owner: Type: bug | Status: new Priority: normal | Milestone: 8.2.1 Component: Compiler | Version: 8.1 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: Compile-time Unknown/Multiple | performance bug Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- d49b2bb21691892ca6ac8f2403e31f2a5e53feb3 leads to compiler allocation regressions in T12425 and T13035 when those tests are compiled with `-O2`. I took a look at T13035 tonight. `-v` reveals more terms and types. Interestingly, it appears that virtually all the string literals arise from the derived `Typeable` instance. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13226> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 7