March 2018 - ghc-tickets

Re: [GHC] #5129: "evaluate" optimized away
by GHC 19 Mar '18

19 Mar '18

#5129: "evaluate" optimized away -------------------------------------+------------------------------------- Reporter: dons | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.0.3 Resolution: | Keywords: seq, evaluate Operating System: Unknown/Multiple | Architecture: Type of failure: Incorrect result | Unknown/Multiple at runtime | Test Case: Blocked By: | Blocking: Related Tickets: #13930 | Differential Rev(s): Phab:D615 Wiki Page: | -------------------------------------+------------------------------------- Comment (by osa1): Confirmed that adding `{-# NOINLINE evaluate #-}` also fixes #13930. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/5129#comment:27> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

[GHC] #14791: Move stack checks out of code paths that don't use the stack.
by GHC 19 Mar '18

19 Mar '18

#14791: Move stack checks out of code paths that don't use the stack. -------------------------------------+------------------------------------- Reporter: AndreasK | Owner: (none) Type: task | Status: new Priority: normal | Milestone: Component: Compiler | Version: 8.2.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: -------------------------------------+------------------------------------- Given the simple function: {{{ func :: Int -> Int func 11 = 11111 func 41 = 4444 }}} We produce this cmm code: {{{ [section ""data" . T.func_closure" { T.func_closure: const T.func_info; const 0; }, T.func_entry() // [R2] { info_tbl: [(c2lk, label: block_c2lk_info rep:StackRep []), (c2ln, label: T.func_info rep:HeapRep static { Fun {arity: 1 fun_type: ArgSpec 5} })] stack_info: arg_space: 8 updfr_space: Just 8 } {offset c2ln: // global if ((Sp + -8) < SpLim) (likely: False) goto c2lo; else goto c2lp; c2lo: // global R2 = R2; R1 = T.func_closure; call (stg_gc_fun)(R2, R1) args: 8, res: 0, upd: 8; c2lp: // global I64[Sp - 8] = c2lk; R1 = R2; Sp = Sp - 8; if (R1 & 7 != 0) goto c2lk; else goto c2ll; c2ll: // global call (I64[R1])(R1) returns to c2lk, args: 8, res: 8, upd: 8; c2lk: // global _s2kY::I64 = I64[R1 + 7]; if (_s2kY::I64 != 11) goto u2ly; else goto c2lw; u2ly: // global if (_s2kY::I64 == 41) (likely: False) goto c2lx; else goto c2lv; c2lx: // global R1 = T.func1_closure+1; Sp = Sp + 8; call (P64[Sp])(R1) args: 8, res: 0, upd: 8; c2lv: // global R1 = T.func3_closure; Sp = Sp + 8; call (I64[R1])(R1) args: 8, res: 0, upd: 8; c2lw: // global R1 = T.func2_closure+1; Sp = Sp + 8; call (P64[Sp])(R1) args: 8, res: 0, upd: 8; } }] }}} However the code path if the argument is already evaluated never uses the stack: {{{ T.func_entry() // [R2] { info_tbl: [(c2lk, label: block_c2lk_info rep:StackRep []), (c2ln, label: T.func_info rep:HeapRep static { Fun {arity: 1 fun_type: ArgSpec 5} })] stack_info: arg_space: 8 updfr_space: Just 8 } {offset c2ln: // global if ((Sp + -8) < SpLim) (likely: False) goto c2lo; else goto c2lp; c2lp: // global I64[Sp - 8] = c2lk; R1 = R2; Sp = Sp - 8; if (R1 & 7 != 0) goto c2lk; else goto <..>; c2lk: // global _s2kY::I64 = I64[R1 + 7]; if (_s2kY::I64 != 11) goto u2ly; else goto c2lw; u2ly: // global if (_s2kY::I64 == 41) (likely: False) goto c2lx; else goto c2lv; c2lx: // global R1 = T.func1_closure+1; Sp = Sp + 8; call (P64[Sp])(R1) args: 8, res: 0, upd: 8; c2lv: // global R1 = T.func3_closure; Sp = Sp + 8; call (I64[R1])(R1) args: 8, res: 0, upd: 8; c2lw: // global R1 = T.func2_closure+1; Sp = Sp + 8; call (P64[Sp])(R1) args: 8, res: 0, upd: 8; } }] }}} This means if we have a tagged argument we * Perform a stack check * Decrement the stack * Move the continuation onto the stack. * Increment the stack Without any of it being necessary. If I'm not mistaken all of that could be done after we know we need to evaluate the argument. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14791> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3

Re: [GHC] #5129: "evaluate" optimized away
by GHC 19 Mar '18

19 Mar '18

#5129: "evaluate" optimized away -------------------------------------+------------------------------------- Reporter: dons | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.0.3 Resolution: | Keywords: seq, evaluate Operating System: Unknown/Multiple | Architecture: Type of failure: Incorrect result | Unknown/Multiple at runtime | Test Case: Blocked By: | Blocking: Related Tickets: #13930 | Differential Rev(s): Phab:D615 Wiki Page: | -------------------------------------+------------------------------------- Comment (by osa1): One way to fix this if we want to keep `seq#` as effect-free is avoiding inlining `evaluate` with `{-# NOINLINE evaluate #-}`. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/5129#comment:26> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

Re: [GHC] #5129: "evaluate" optimized away
by GHC 19 Mar '18

19 Mar '18

#5129: "evaluate" optimized away -------------------------------------+------------------------------------- Reporter: dons | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.0.3 Resolution: | Keywords: seq, evaluate Operating System: Unknown/Multiple | Architecture: Type of failure: Incorrect result | Unknown/Multiple at runtime | Test Case: Blocked By: | Blocking: Related Tickets: #13930 | Differential Rev(s): Phab:D615 Wiki Page: | -------------------------------------+------------------------------------- Changes (by alexbiehl): * related: => #13930 -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/5129#comment:25> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

Re: [GHC] #5129: "evaluate" optimized away
by GHC 19 Mar '18

19 Mar '18

#5129: "evaluate" optimized away -------------------------------------+------------------------------------- Reporter: dons | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Compiler | Version: 7.0.3 Resolution: | Keywords: seq, evaluate Operating System: Unknown/Multiple | Architecture: Type of failure: Incorrect result | Unknown/Multiple at runtime | Test Case: Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Phab:D615 Wiki Page: | -------------------------------------+------------------------------------- Comment (by osa1): Started looking into this, With -O1 evaluate (and `seq#`, and the `throwIfNegative` call) vanishes, and the whole program is transformed into an assertFailure: {{{ Main.main1 = \ (eta2_a3iv :: GHC.Prim.State# GHC.Prim.RealWorld) -> GHC.Prim.catch# @ () @ SomeException Main.main3 Main.main2 eta2_a3iv Main.main3 = \ _ [Occ=Dead, OS=OneShot] -> case Main.main4 of wild_00 { } Main.main4 = assertFailure_rCn @ (IO ()) lvl1_r4kE Main.main2 = \ (e1_a3iI [OS=OneShot] :: SomeException) (eta_B1 [OS=OneShot] :: GHC.Prim.State# GHC.Prim.RealWorld) -> case e1_a3iI of wild_a3jJ }}} With some debug prints I was able to find the simplifier call that eliminates seq#: {{{ rebuildCase is_plain_seq expr ok for side effects: seq# @ String @ RealWorld (throwIfNegative (I# -1#)) s_a3jI alts: [((#,#), [ipv_a3jL, ipv1_a3jM], case assertFailure @ (IO ()) (build @ Char (\ (@ b_a3eo) -> unpackFoldrCString# @ b_a3eo "must throw when given a negative number"#)) of { })] cont: Stop[BoringCtxt] (# State# RealWorld, () #) ret: (SimplFloats {lets: FltLifted [] joins: [] in_scope: InScope {...}}, case assertFailure @ (IO ()) (build @ Char (\ (@ b_a3eo) -> unpackFoldrCString# @ b_a3eo "must throw when given a negative number"#)) of wild_00 { }) }}} This basically says `rebuildCase` sees the `seq#` call in the scrutinee position, thinks that it's side-effect-free (because the primop is not marked as effectful), also thinks that it's a "plain seq", and eliminates the case expression. "Plain seq" in this context is defined like this: {{{ is_plain_seq = all_dead_bndrs && isDeadBinder case_bndr -- Evaluation *only* for effect }}} So the code looks correct to me; primops is not marked as effectful, and this case expression is only for the (non-existent) effects, so it can be eliminated. Looking at the discussion above, I think not marking `seq#` as effectful was deliberate (otherwise `seq#` becomes `spark#`). I guess the idea was to force sequencing via a dependency of `State# RealWorld` return value of `seq#` and the next IO action, but I'm not sure how is that supposed to work in pure code. Can anyone say a few words about how do we expect to keep `seq#` when it's not effectful, and its return value is not used? -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/5129#comment:24> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

[GHC] #14407: rts: Threads/caps affinity
by GHC 18 Mar '18

18 Mar '18

#14407: rts: Threads/caps affinity -------------------------------------+------------------------------------- Reporter: pacak | Owner: (none) Type: feature | Status: new request | Priority: normal | Milestone: Component: Runtime | Version: 8.3 System | Keywords: | 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: -------------------------------------+------------------------------------- Currently GHC supports two kinds of threads with respect to thread migration - pinned to a specific capability and those it can migrate between any capabilities. For purposes of achieving lower latency in Haskell applications it would be nice to have something in between - threads GHC rts can migrate but within a certain subset of capabilities only. I'm developing a program that contains several kinds of threads - those that do little work and sensitive to latency and those that can spend more CPU time and less latency sensitive. I looked into several cases of increased latency in those sensitive threads (using GHC eventlog) and in all cases sensitive threads were waiting for non-sensitive threads to finish working. I was able to reduce worst case latency by factor of 10 by pinning all the threads in the program to specific capability but manually distributing threads (60+ of them) between capabilities (several different machines with different numbers of cores available) seems very fragile. World stopping GC is still a problem but at least in my case is much less frequently so. I have a patch for rts that implements this proposal {{{#!hs {- | 'setThreadAffinity' limits RTS ability to migrate thread to capabilities with numbers that matches set bits of affinity mask, thus mask of `0b101` (5) will allow RTS to migrate this thread to caps 0 (64, 128, ..) and 3 (64 + 3 = 67, 128 + 3 = 131, ...). Setting all bits to 0 or 1 will disable the restriction. -} setThreadAffinity :: ThreadId -> Int -> IO () }}} This allows to define up to 64 distinct groups and allow user to break down their threads into bigger number of potentially intersecting groups by specifying things like capability 0 does latency sensitive things, caps 1..5 - less sensitive things, caps 5-7 bulk things. Sample program using this API {{{#!hs {-# LANGUAGE LambdaCase #-} import Data.Time import Control.Monad import Control.Concurrent import System.Environment (getArgs) import GHC.Conc wastetime :: Bool -> IO () wastetime affine = do tid <- forkIO $ do myThreadId >>= \tid -> labelThread tid "timewaster" forever $ do when (sum [1..1000000] < (0 :: Integer)) $ print "impossible" threadDelay 100 yield when affine $ setThreadAffinity tid (255 - 2) client :: Bool -> IO () client affine = do myThreadId >>= \tid -> labelThread tid "client" when affine $ myThreadId >>= \tid -> setThreadAffinity tid 2 before <- getCurrentTime replicateM_ 10 $ do threadDelay 10000 after <- getCurrentTime print $ after `diffUTCTime` before startClient :: Bool -> IO () startClient = {- replicateM_ 10 . -} client main :: IO () main = do getArgs >>= \case [wno's, aff's] -> do let wno = read wno's aff = read aff's putStrLn $ unwords ["Affinity:", show aff, "Timewasters:", show wno] replicateM_ wno (wastetime aff) startClient aff _ -> putStrLn "Usage: <progname> <number of time wasters> <enable affinity: True/False>" }}} Compiled with -threaded and running with rts -N8 on 6 core (12 threads) machine. Results are noisy but repeatable {{{ Affinity: False Timewasters: 24 0.42482036s }}} {{{ Affinity: True Timewasters: 24 0.111743474s }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14407> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 4

[GHC] #14930: GHC.Stats Since annotations are wrong
by GHC 18 Mar '18

18 Mar '18

#14930: GHC.Stats Since annotations are wrong -------------------------------------+------------------------------------- Reporter: NeilMitchell | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: | Version: 8.4.1 libraries/base | Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: Incorrect API Unknown/Multiple | annotation Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- GHC.Stats claims all the RTS Stats stuff is available since base 4.9.0.0. In truth it was only added in base 4.10.0.0. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14930> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3

[GHC] #9671: Allow expressions in patterns
by GHC 16 Mar '18

16 Mar '18

#9671: Allow expressions in patterns -------------------------------------+------------------------------------- Reporter: Iceland_jack | Owner: Type: feature request | Status: new Priority: normal | Milestone: 7.10.1 Component: Compiler | Version: Keywords: patterns, pattern | Operating System: synonyms | Unknown/Multiple Architecture: Unknown/Multiple | Type of failure: Difficulty: Unknown | None/Unknown Blocked By: | Test Case: Related Tickets: | Blocking: | Differential Revisions: -------------------------------------+------------------------------------- I've outlined a proposal for extending pattern synonyms to depend on terms (PatternFamilies), the name is less than ideal but I'll keep the page under that name for now. The proposal's introduction has been rewritten. The simplest use case are patterns that matches only when a set contains an element (`IsMember`) or when a set does not contain an element (`NotMember`): [[Image(wiki:PatternFamilies:member.png)]] {{{#!hs hasKeys :: Set Item -> IO () hasKeys (IsMember "keys") = leaveHouse hasKeys (NotMember "keys") = findKeys >> leaveHouse }}} or a pattern that matches a map if the key exists: [[Image(wiki:PatternFamilies:lookup.png)]] used like this: {{{#!hs age :: Map Person Age -> String age (Lookup "Alice" 60) = "Alice is 60 years old!" age (Lookup "Alice" age) = "Alice is " ++ show age ++ "." age (Lookup "Bob" _) = "No info on Alice but we know how old Bob is." age _ = "..." }}} Further details and examples can be found here: PatternFamilies, I discussed it with several people ICFP 2014. This would not require a new extension but would extend PatternSynonyms. This feature can be quite useful, especially when working with deeply nested structures (ASTs, JSON, XML, ...). If people are fine with it I will implement it. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/9671> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 14

Re: [GHC] #5611: Asynchronous exception discarded after safe FFI call
by GHC 16 Mar '18

16 Mar '18

#5611: Asynchronous exception discarded after safe FFI call -------------------------------------+------------------------------------- Reporter: joeyadams | Owner: (none) Type: bug | Status: closed Priority: normal | Milestone: 8.6.1 Component: Runtime System | Version: 7.0.3 Resolution: fixed | Keywords: FFI, | exception, Exceptions 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: | -------------------------------------+------------------------------------- Changes (by bgamari): * status: new => closed * resolution: => fixed Comment: I've not seen this fail on CI in the years I've been looking at results. I'm going to call this resolved. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/5611#comment:7> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 0

[GHC] #14919: python3-based GHC scripts don't work on my RHEL machine
by GHC 15 Mar '18

15 Mar '18

#14919: python3-based GHC scripts don't work on my RHEL machine -------------------------------------+------------------------------------- Reporter: RyanGlScott | Owner: (none) Type: bug | Status: new Priority: normal | Milestone: Component: Build System | Version: 8.5 Keywords: | Operating System: Unknown/Multiple Architecture: | Type of failure: Building GHC Unknown/Multiple | failed Test Case: | Blocked By: Blocking: | Related Tickets: Differential Rev(s): | Wiki Page: -------------------------------------+------------------------------------- I recently switched over machines to work on GHC stuff, but to my dismay, several `python3`-based scripts which glue GHC together do not work with my new machine. One of these is `boot`. If I run this, I am greeted with: {{{ $ ./boot Traceback (most recent call last): File "./boot", line 193, in <module> check_for_url_rewrites() File "./boot", line 29, in check_for_url_rewrites subprocess.check_output('git config remote.origin.url'.split()).find(b'github.com') != -1 and \ File "/l/python3/lib/python3.5/subprocess.py", line 626, in check_output **kwargs).stdout File "/l/python3/lib/python3.5/subprocess.py", line 693, in run with Popen(*popenargs, **kwargs) as process: File "/l/python3/lib/python3.5/subprocess.py", line 947, in __init__ restore_signals, start_new_session) File "/l/python3/lib/python3.5/subprocess.py", line 1551, in _execute_child raise child_exception_type(errno_num, err_msg) FileNotFoundError: [Errno 2] No such file or directory: 'git' }}} One thing that's relevant here is that my `python3` installation is in an unusual location, `/usr/local/bin`. Most of my other executables are installed in `/usr/bin`, such as `git`, `sed`, `autoconf`, `python2`, etc. The fact that `python3` is located elsewhere seems important, because if I hack `boot` to use `python2`: {{{#!diff diff --git a/boot b/boot index f913724..995293a 100755 --- a/boot +++ b/boot @@ -1,4 +1,4 @@ -#!/usr/bin/env python3 +#!/usr/bin/env python2 import glob import os @@ -18,7 +18,7 @@ parser.add_argument('--hadrian', action='store_true', help='Do not assume the ma args = parser.parse_args() def print_err(s): - print(dedent(s), file=sys.stderr) + print dedent(s) def die(mesg): print_err(mesg) }}} Then it works. It seems that `subprocess.check_output` is //only// looking up executable names in the same directory as `python(3)`, for reasons that I don't fully understand. Other scripts based around `python3`, such as the test suite driver, also fail. If I run those, I also experience errors, such as: {{{ $ make test TEST="T11311" <elided> /bin/sh: locale: command not found /bin/sh: grep: command not found /bin/sh: grep: command not found /bin/sh: locale: command not found /bin/sh: grep: command not found Timeout is 300 Found 400 .T files... Beginning test run at Wed Mar 14 11:03:46 2018 EDT <elided> =====> T11311(normal) 1 of 1 [0, 0, 0] cd "./dependent/should_compile/T11311.run" && "/nfs/nfs7/home/rgscott/Software/ghc/inplace/test spaces/ghc-stage2" -c T11311.hs -dcore-lint -dcmm-lint -no-user-package-db -rtsopts -fno-warn- missed-specialisations -fshow-warning-groups -fdiagnostics-color=never -fno-diagnostics-show-caret -dno-debug-output Compile failed (exit code 1) errors were: <no location info>: error: Warning: Couldn't figure out C compiler information! Make sure you're using GNU gcc, or clang ghc-stage2: could not execute: gcc *** unexpected failure for T11311(normal) Unexpected results from: TEST="T11311" SUMMARY for test run started at Wed Mar 14 11:03:46 2018 EDT 0:00:02 spent to go through 1 total tests, which gave rise to 3 test cases, of which 2 were skipped 0 had missing libraries 0 expected passes 0 expected failures 0 caused framework failures 0 caused framework warnings 0 unexpected passes 1 unexpected failures 0 unexpected stat failures Unexpected failures: dependent/should_compile/T11311.run T11311 [exit code non-0] (normal) make[1]: *** [test] Error 1 make[1]: Leaving directory `/nfs/nfs7/home/rgscott/Software/ghc/testsuite/tests' make: *** [test] Error 2 }}} I don't know a way to hack around this problem, unfortunately. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/14919> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

1 3