- ghc-tickets - Haskell.org

Re: [GHC] #1600: Optimisation: CPR the results of IO
by GHC 31 Jul '17

31 Jul '17

#1600: Optimisation: CPR the results of IO -------------------------------------+------------------------------------- Reporter: simonmar | Owner: (none) Type: task | Status: new Priority: lowest | Milestone: Component: Compiler | Version: 6.6.1 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: Type of failure: Runtime | Unknown/Multiple performance bug | Test Case: Blocked By: | Blocking: Related Tickets: #8598 | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Comment (by bgamari): What is the status of this, akio? > I wonder if this improvement justifies the added complexity to the compiler (about 400 lines of code added under `compiler/`). Right now I don't see any way to make the analysis/transformation more effective. Well, 2.6% improvement in runtime is quite sizeable. This sounds quite worthwhile to me. Good work! Simon, do you agree? -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/1600#comment:74> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

[GHC] #14067: Static Argument Transformation for tail-recursive functions
by GHC 31 Jul '17

31 Jul '17

#14067: Static Argument Transformation for tail-recursive functions -------------------------------------+------------------------------------- Reporter: nomeata | Owner: (none) Type: task | 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: -------------------------------------+------------------------------------- In #13966 it was determined that having a variant of the Static Argument Transformation (StaticArgumentTransformation) pass that would specifically look for tail-recursive functions, and turn them into recursive join points, would be beneficial. This ticket tracks this task. Consider {{{ f x y = case y of A -> f x y' B -> e2 C -> e3 }}} Here the first argument to f is "static"; that is, the same in every call. So we can transform like this {{{ f x y = joinrec $j y = case y of A -> $j y' B -> e2 C -> e3 in $j y }}} Note that `x` isn't passed around in every iteration. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14067> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3

[GHC] #14046: “Illegal type synonym family application in instance” is too strict in the presence of functional dependencies
by GHC 31 Jul '17

31 Jul '17

#14046: “Illegal type synonym family application in instance” is too strict in the presence of functional dependencies -------------------------------------+------------------------------------- Reporter: lexi.lambda | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.1 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: GHC rejects Unknown/Multiple | valid program Test Case: | Blocked By: Blocking: | Related Tickets: #3485 Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- GHC rejects the following instance, complaining about the use of a type synonym family in the instance head: {{{#!hs type family Fam a class Multi a b | a -> b instance Multi (Maybe a) (Fam a) }}} However, this seems too strict to me, since the second parameter of `Multi` is determined by a functional dependency. If I tweak the instance slightly to lift the second parameter out of the instance head into an equality constraint, GHC accepts the instance: {{{#!hs instance (b ~ Fam a) => Multi (Maybe a) b }}} It seems to me that, due to the functional dependency, these two instances are completely equivalent. Therefore, GHC should accept the first instance. This is similar to an old ticket, #3485, but that did not involve fundeps, so GHC’s error was correct. I’m pretty sure the addition of functional dependencies changes things, making the two actually equivalent. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14046> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 9

[GHC] #11995: Can't infer type
by GHC 31 Jul '17

31 Jul '17

#11995: Can't infer type -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.1 (Type checker) | 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 import Data.Kind data NP :: forall k. (ĸ → Type) → ([k] → Type) where Nil :: NP f '[] (:*) :: f x → NP f xs → NP f (x:xs) newtype K a b = K a deriving Show unK (K a) = a h'collapse :: NP (K a) xs -> [a] h'collapse = \case Nil -> [] K x:*xs -> x : h'collapse xs }}} if we replace `xs` by an underscore: {{{ tJN0.hs:13:29-30: error: … • Could not deduce: (xs :: [ĸ]) ~~ ((':) ĸ x xs :: [ĸ]) from the context: ((k :: *) ~~ (ĸ :: *), (t :: [k]) ~~ ((':) ĸ x xs :: [ĸ])) bound by a pattern with constructor: :* :: forall k (f :: k -> *) (x :: k) (xs :: [k]). f x -> NP k k f xs -> NP k k f ((':) k x xs), in a case alternative at /tmp/tJN0.hs:13:3-9 ‘xs’ is a rigid type variable bound by a pattern with constructor: :* :: forall k (f :: k -> *) (x :: k) (xs :: [k]). f x -> NP k k f xs -> NP k k f ((':) k x xs), in a case alternative at /tmp/tJN0.hs:13:3 Expected type: NP ĸ k (K ĸ a) t Actual type: NP ĸ ĸ (K ĸ a) xs • In the first argument of ‘h'collapse’, namely ‘xs’ In the second argument of ‘(:)’, namely ‘h'collapse xs’ In the expression: x : h'collapse xs • Relevant bindings include xs :: NP ĸ ĸ (K ĸ a) xs (bound at /tmp/tJN0.hs:13:8) h'collapse :: NP ĸ k (K ĸ a) t -> [a] (bound at /tmp/tJN0.hs:11:1) Compilation failed. }}} Should it not be able to infer that? The Glorious Glasgow Haskell Compilation System, version 8.1.20160419 -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/11995> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5

[GHC] #14065: Type inference
by GHC 31 Jul '17

31 Jul '17

#14065: Type inference -------------------------------------+------------------------------------- Reporter: zaoqi | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.0.2 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 --Copyright (C) 2017 Zaoqi --This program is free software: you can redistribute it and/or modify --it under the terms of the GNU Affero General Public License as published --by the Free Software Foundation, either version 3 of the License, or --(at your option) any later version. --This program is distributed in the hope that it will be useful, --but WITHOUT ANY WARRANTY; without even the implied warranty of --MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the --GNU Affero General Public License for more details. --You should have received a copy of the GNU Affero General Public License --along with this program. If not, see <http://www.gnu.org/licenses/>. {-# LANGUAGE DataKinds, KindSignatures, GADTs #-} import Control.Exception data Nat = Z | S Nat deriving (Eq, Ord) instance Enum Nat where succ = S pred (S x) = x pred _ = throw Underflow toEnum 0 = Z toEnum x | x < 0 = throw Underflow | otherwise = S . toEnum $ pred x fromEnum Z = 0 fromEnum (S x) = succ $ fromEnum x enumFrom x = x : enumFrom (S x) instance Num Nat where Z + x = x (S x) + y = S $ x + y Z * _ = Z (S x) * y = y + (x * y) abs = id signum Z = Z signum _ = S Z fromInteger 0 = Z fromInteger x | x < 0 = throw Underflow | otherwise = S . fromInteger $ pred x x - Z = x (S x) - (S y) = x - y _ - _ = throw Underflow negate Z = Z negate _ = throw Underflow instance Real Nat where toRational = toRational . toInteger instance Integral Nat where quot x y = fromInteger $ quot (toInteger x) (toInteger y) rem x y = fromInteger $ rem (toInteger x) (toInteger y) div x y = fromInteger $ div (toInteger x) (toInteger y) mod x y = fromInteger $ mod (toInteger x) (toInteger y) quotRem x y = let (x, y) = quotRem (toInteger x) (toInteger y) in (fromInteger x, fromInteger y) divMod x y = let (x, y) = divMod (toInteger x) (toInteger y) in (fromInteger x, fromInteger y) toInteger Z = 0 toInteger (S x) = succ $ toInteger x data Vec :: Nat -> * -> * where Nil :: Vec Z a Cons :: a -> Vec x a -> Vec (S x) a data ReadableVec :: * -> * where ReadableVec :: Vec x a -> ReadableVec a instance Read a => Read (ReadableVec a) where readsPrec x s = map (\(xs, r) -> (l2rv xs, r)) (readsPrec x s) where l2rv [] = ReadableVec Nil l2rv (x : xs) = case l2rv xs of ReadableVec rs -> ReadableVec (Cons x rs) instance Show a => Show (Vec x a) where showsPrec p xs = showsPrec p (ReadableVec xs) instance Show a => Show (ReadableVec a) where showsPrec p xs = showsPrec p (rv2l xs) where rv2l :: ReadableVec x -> [x] rv2l (ReadableVec Nil) = [] rv2l (ReadableVec (Cons x xs)) = x : rv2l (ReadableVec xs) }}} {{{ GHCi, version 8.0.2: http://www.haskell.org/ghc/ :? for help Prelude> :load Vec.hs [1 of 1] Compiling Main ( Vec.hs, interpreted ) Ok, modules loaded: Main. }}} {{{#!hs --Copyright (C) 2017 Zaoqi --This program is free software: you can redistribute it and/or modify --it under the terms of the GNU Affero General Public License as published --by the Free Software Foundation, either version 3 of the License, or --(at your option) any later version. --This program is distributed in the hope that it will be useful, --but WITHOUT ANY WARRANTY; without even the implied warranty of --MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the --GNU Affero General Public License for more details. --You should have received a copy of the GNU Affero General Public License --along with this program. If not, see <http://www.gnu.org/licenses/>. {-# LANGUAGE DataKinds, KindSignatures, GADTs #-} import Control.Exception data Nat = Z | S Nat deriving (Eq, Ord) instance Enum Nat where succ = S pred (S x) = x pred _ = throw Underflow toEnum 0 = Z toEnum x | x < 0 = throw Underflow | otherwise = S . toEnum $ pred x fromEnum Z = 0 fromEnum (S x) = succ $ fromEnum x enumFrom x = x : enumFrom (S x) instance Num Nat where Z + x = x (S x) + y = S $ x + y Z * _ = Z (S x) * y = y + (x * y) abs = id signum Z = Z signum _ = S Z fromInteger 0 = Z fromInteger x | x < 0 = throw Underflow | otherwise = S . fromInteger $ pred x x - Z = x (S x) - (S y) = x - y _ - _ = throw Underflow negate Z = Z negate _ = throw Underflow instance Real Nat where toRational = toRational . toInteger instance Integral Nat where quot x y = fromInteger $ quot (toInteger x) (toInteger y) rem x y = fromInteger $ rem (toInteger x) (toInteger y) div x y = fromInteger $ div (toInteger x) (toInteger y) mod x y = fromInteger $ mod (toInteger x) (toInteger y) quotRem x y = let (x, y) = quotRem (toInteger x) (toInteger y) in (fromInteger x, fromInteger y) divMod x y = let (x, y) = divMod (toInteger x) (toInteger y) in (fromInteger x, fromInteger y) toInteger Z = 0 toInteger (S x) = succ $ toInteger x data Vec :: Nat -> * -> * where Nil :: Vec Z a Cons :: a -> Vec x a -> Vec (S x) a data ReadableVec :: * -> * where ReadableVec :: Vec x a -> ReadableVec a instance Read a => Read (ReadableVec a) where readsPrec x s = map (\(xs, r) -> (l2rv xs, r)) (readsPrec x s) where l2rv [] = ReadableVec Nil l2rv (x : xs) = case l2rv xs of ReadableVec rs -> ReadableVec (Cons x rs) instance Show a => Show (Vec x a) where showsPrec p xs = showsPrec p (ReadableVec xs) instance Show a => Show (ReadableVec a) where showsPrec p xs = showsPrec p (rv2l xs) where --rv2l :: ReadableVec x -> [x] rv2l (ReadableVec Nil) = [] rv2l (ReadableVec (Cons x xs)) = x : rv2l (ReadableVec xs) }}} {{{ GHCi, version 8.0.2: http://www.haskell.org/ghc/ :? for help Prelude> :load Vec.hs [1 of 1] Compiling Main ( Vec.hs, interpreted ) Vec.hs:79:22: error: • Could not deduce (Show a0) arising from a use of ‘showsPrec’ from the context: Show a bound by the instance declaration at Vec.hs:78:10-39 The type variable ‘a0’ is ambiguous These potential instances exist: instance Show ArithException -- Defined in ‘GHC.Exception’ instance Show ErrorCall -- Defined in ‘GHC.Exception’ instance Show SomeException -- Defined in ‘GHC.Exception’ ...plus 27 others ...plus 12 instances involving out-of-scope types (use -fprint-potential-instances to see them all) • In the expression: showsPrec p (rv2l xs) In an equation for ‘showsPrec’: showsPrec p xs = showsPrec p (rv2l xs) where rv2l (ReadableVec Nil) = [] rv2l (ReadableVec (Cons x xs)) = x : rv2l (ReadableVec xs) In the instance declaration for ‘Show (ReadableVec a)’ Vec.hs:82:34: error: • Couldn't match expected type ‘t’ with actual type ‘[t0]’ ‘t’ is untouchable inside the constraints: x ~ 'Z bound by a pattern with constructor: Nil :: forall a. Vec 'Z a, in an equation for ‘rv2l’ at Vec.hs:82:27-29 ‘t’ is a rigid type variable bound by the inferred type of rv2l :: ReadableVec t1 -> t at Vec.hs:82:9 Possible fix: add a type signature for ‘rv2l’ • In the expression: [] In an equation for ‘rv2l’: rv2l (ReadableVec Nil) = [] In an equation for ‘showsPrec’: showsPrec p xs = showsPrec p (rv2l xs) where rv2l (ReadableVec Nil) = [] rv2l (ReadableVec (Cons x xs)) = x : rv2l (ReadableVec xs) • Relevant bindings include rv2l :: ReadableVec t1 -> t (bound at Vec.hs:82:9) Vec.hs:83:46: error: • Couldn't match type ‘t’ with ‘[t1]’ ‘t’ is untouchable inside the constraints: x ~ 'S x1 bound by a pattern with constructor: Cons :: forall a (x :: Nat). a -> Vec x a -> Vec ('S x) a, in an equation for ‘rv2l’ at Vec.hs:83:28-36 ‘t’ is a rigid type variable bound by the inferred type of rv2l :: ReadableVec t1 -> t at Vec.hs:82:9 Possible fix: add a type signature for ‘rv2l’ Expected type: ReadableVec t1 -> [t1] Actual type: ReadableVec t1 -> t • In the second argument of ‘(:)’, namely ‘rv2l (ReadableVec xs)’ In the expression: x : rv2l (ReadableVec xs) In an equation for ‘rv2l’: rv2l (ReadableVec (Cons x xs)) = x : rv2l (ReadableVec xs) • Relevant bindings include xs :: Vec x1 t1 (bound at Vec.hs:83:35) x :: t1 (bound at Vec.hs:83:33) rv2l :: ReadableVec t1 -> t (bound at Vec.hs:82:9) Failed, modules loaded: none. }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14065> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3

[GHC] #13540: Enable -msse2 by default on i386
by GHC 31 Jul '17

31 Jul '17

#13540: Enable -msse2 by default on i386 -------------------------------------+------------------------------------- Reporter: bgamari | Owner: (none) Type: task | Status: new Priority: high | Milestone: 8.4.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: -------------------------------------+------------------------------------- SSE2 has been around for nearly 15 years now and at this point it is supported nearly universally. Currently we pass `-msse2` to numerically- sensitive testsuite tests since x87 is too imprecise. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13540> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 5

[GHC] #12878: Use gold linker by default if available on ELF systems
by GHC 31 Jul '17

31 Jul '17

#12878: Use gold linker by default if available on ELF systems -------------------------------------+------------------------------------- Reporter: dobenour | Owner: Type: feature | Status: new request | Priority: normal | Milestone: Component: Driver | Version: 8.0.1 Keywords: | Operating System: Linux Architecture: | Type of failure: Compile-time Unknown/Multiple | performance bug Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- `ld.gold` is both faster and less buggy than `ld.bfd`, but only works on ELF. On ELF systems, we should thus prefer `ld.gold` when it is installed, even when `ld.bfd` is supported (as it is on x86). -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/12878> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 2

[GHC] #13283: T5435_dyn_asm fails with gold linker
by GHC 31 Jul '17

31 Jul '17

#13283: T5435_dyn_asm fails with gold linker -------------------------------------+------------------------------------- Reporter: rwbarton | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Runtime | Version: 8.1 System (Linker) | 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: -------------------------------------+------------------------------------- I tried validating with `ld.gold` as my system linker and one test failed: {{{ cd "./rts/T5435_dyn_asm.run" && $MAKE -s --no-print-directory T5435_dyn_asm T5435_dyn_asm failed with ['initArray1', 'initArray2', 'ctors2', 'ctors1', 'success'], see all.T for details }}} The expected output has `ctors1` and then `ctors2`. This looks like a bug in gold to me. ezyang, do you agree? -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13283> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3

[GHC] #13744: Compile-time regression in 8.2 when compiling bloodhound's test suite
by GHC 31 Jul '17

31 Jul '17

#13744: Compile-time regression in 8.2 when compiling bloodhound's test suite -------------------------------------+------------------------------------- Reporter: refold | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.2.1-rc2 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: -------------------------------------+------------------------------------- GHC 8.2 takes much longer to compile bloodhound's test suite than GHC 8.0.2. With 8.0.2, compilation takes approximately a minute on my machine, 8.2 takes approximately four minutes and uses much more memory. How to reproduce: {{{ $ git clone -b ghc-8.2 https://github.com/23Skidoo/bloodhound.git $ cd bloodhound $ cabal new-build -w ghc-8.0.1 --enable-tests $ cabal new-build -w ghc-8.2.1 --enable-tests }}} GHC version: {{{ $ ghc-8.2.1 --version The Glorious Glasgow Haskell Compilation System, version 8.2.0.20170505 }}} These warnings (fixed in my `ghc-8.2` branch of `bloodhound`) may provide a clue to what's happening: {{{ tests/V1/tests.hs:1876:17: warning: [-Wsimplifiable-class-constraints] • The constraint ‘SOP.All SOP.SListI (SOP.GCode a)’ matches an instance declaration instance forall k (f :: k -> Constraint) (xs :: [k]). (Generics.SOP.Constraint.AllF f xs, SOP.SListI xs) => SOP.All f xs -- Defined in ‘Generics.SOP.Constraint’ This makes type inference for inner bindings fragile; either use MonoLocalBinds, or simplify it using the instance • In the type signature: sopArbitrary :: forall a. (Generic a, SOP.GTo a, SOP.All SOP.SListI (SOP.GCode a), SOP.All2 Arbitrary (SOP.GCode a)) => Gen a }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13744> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 1

[GHC] #13817: Simplifier and SpecConstr performance regression with 8.2.1
by GHC 31 Jul '17

31 Jul '17

#13817: Simplifier and SpecConstr performance regression with 8.2.1 -------------------------------------+------------------------------------- Reporter: albertov | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.2.1-rc1 Keywords: | Operating System: Linux Architecture: | Type of failure: Compile-time Unknown/Multiple | performance bug Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- A propietary application I've upgraded to compile with 8.2.1-rc1 makes GHC manifest a performance regression when producing optimized ({{{-O2}}}) code. After a crude analysis of a compile log produced with {{{-show-passes}}} it appears that the biggest slowdown is in the Simplifier and SpecConstr phases when compiling the "main" modules. Theres a conversation at GHC Users with more details: https://mail.haskell.org/pipermail/glasgow-haskell- users/2017-June/026543.html. The data, the results and the script to to analyse it live at: https://gist.github.com/albertov/145ac5c01bfbadc5c9ff55e9c5c2e50e I'll try to update this ticket with a way to to reproduce it as soon as I can (if I can) -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/13817> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 2