#10712: Regression: make TEST=exceptionsrun001 WAY=optasm is failing -------------------------------------+------------------------------------- Reporter: thomie | Owner: Type: bug | Status: new Priority: high | Milestone: 7.12.1 Component: Compiler | Version: 7.11 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: | base/tests/exceptionsrun001 Blocked By: | Blocking: Related Tickets: | Differential Revisions: -------------------------------------+------------------------------------- Comment (by rwbarton): I'll bisect and see what I find (if you aren't doing so already). -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10712#comment:2> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

#10712: Regression: make TEST=exceptionsrun001 WAY=optasm is failing -------------------------------------+------------------------------------- Reporter: thomie | Owner: Type: bug | Status: new Priority: high | Milestone: 7.12.1 Component: Compiler | Version: 7.11 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: | base/tests/exceptionsrun001 Blocked By: | Blocking: Related Tickets: | Differential Revisions: -------------------------------------+------------------------------------- Changes (by simonpj): * cc: simonmar (added) Comment: Bother. I totally missed that. I think it's reasonable that this should allow the exception to be raised somewhere else (imprecisely): {{{ catch# (\s -> (raise# blah) `seq` blah2) (...) st }}} because `raise#` is in the pure world. But `raiseIO#` is specifically intended to raise an exception precisely at the specified moment, so the new behaviour is unacceptable. Now I think about this more I'm also worried about {{{ let r = \st -> raiseIO# blah st in catch (\st -> ...(r st)..) handler st }}} Now that I'm given `catch` a more aggressive strictness, I'll get a demand `C(S)` for `r`; that is, it is definitly called with one argument. And so it is! But the danger is that we'll feed `C(S)` into `r`'s rhs as the demand of the body, and say that that whole `let` will definitely diverge (which isn't true). However, we ''really'' want this function to be strict in `x`: {{{ f x st = catch (\s -> case x of I# x' -> ...) handler st }}} Getting this strictness was the whole point of the offending commit: {{{ Program Size Allocs Runtime Elapsed TotalMem -------------------------------------------------------------------------------- hpg -0.4% -2.9% -0.9% -1.0% +0.0% reverse-complem -0.4% -10.9% +10.7% +10.9% +0.0% simple -0.3% -0.0% +26.2% +26.2% +3.7% sphere -0.3% -6.3% 0.09 0.09 +0.0% -------------------------------------------------------------------------------- Min -0.7% -10.9% -4.6% -4.7% -1.7% Max -0.2% +0.0% +26.2% +26.2% +6.5% Geometric Mean -0.4% -0.3% +2.1% +2.1% +0.1% }}} There's something very special about `catch`: it turns divergence into non-divergence. (The strictness analyser treats divergence and exceptions identically.) I think #8598 is relevant. Bother bother. I'm really not sure what to do. Even if we revert, we should not revert all, just the strictness signatures for the `catch` primops. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10712#comment:4> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

#10712: Regression: make TEST=exceptionsrun001 WAY=optasm is failing -------------------------------------+------------------------------------- Reporter: thomie | Owner: Type: bug | Status: new Priority: highest | Milestone: 8.0.1 Component: Compiler | Version: 7.11 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: | base/tests/exceptionsrun001 Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Wiki Page: | -------------------------------------+------------------------------------- Changes (by bgamari): * priority: high => highest Old description:

The following program, extracted from the test exceptionsrun001, should exit with exitcode 100. Instead, when compiled with `-O1`, it never gets past the ioTest and somehow manages to exit with exitcode 0.

{{{ {-# LANGUAGE ScopedTypeVariables #-} module Main where

import Control.Exception import System.IO.Error import System.Exit

main = do ioTest exitWith (ExitFailure 100)

ioTest :: IO () ioTest = (catch (ioError (userError "wibble")) (\(e::IOException) -> return ()) }}}

I think this will require a git bisect: * last known good commit: 34bb4605d4ec5b131df57ca4c91d6840b7539194 * first known bad commit: f83aab95f59ae9b29f22fc7924e050512229cb9c.

New description: The following program, extracted from the test exceptionsrun001, should exit with exitcode 100. Instead, when compiled with `-O1`, it never gets past the ioTest and somehow manages to exit with exitcode 0. {{{#!hs {-# LANGUAGE ScopedTypeVariables #-} module Main where import Control.Exception import System.IO.Error import System.Exit main = do ioTest exitWith (ExitFailure 100) ioTest :: IO () ioTest = (catch (ioError (userError "wibble")) (\(e::IOException) -> return ()) }}} I think this will require a git bisect: * last known good commit: 34bb4605d4ec5b131df57ca4c91d6840b7539194 * first known bad commit: f83aab95f59ae9b29f22fc7924e050512229cb9c. -- -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10712#comment:7> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

#10712: Regression: make TEST=exceptionsrun001 WAY=optasm is failing -------------------------------------+------------------------------------- Reporter: thomie | Owner: Type: bug | Status: patch Priority: highest | Milestone: 8.0.1 Component: Compiler | Version: 7.11 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: | base/tests/exceptionsrun001 Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Phab:D1616 Wiki Page: | -------------------------------------+------------------------------------- Changes (by bgamari): * status: new => patch * differential: => Phab:D1616 Comment: I have opened Phab:D1616 with what I believe is a fix for this. I have also opened #11222 to track the fact that currently we are forced to pessimize our strictness signatures on `catch`-like operations. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10712#comment:9> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

#10712: Regression: make TEST=exceptionsrun001 WAY=optasm is failing -------------------------------------+------------------------------------- Reporter: thomie | Owner: Type: bug | Status: closed Priority: highest | Milestone: 8.0.1 Component: Compiler | Version: 7.11 Resolution: fixed | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: | base/tests/exceptionsrun001 Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Phab:D1616 Wiki Page: | -------------------------------------+------------------------------------- Changes (by bgamari): * status: patch => closed * resolution: => fixed Comment: Fixed. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10712#comment:11> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

#10712: Regression: make TEST=exceptionsrun001 WAY=optasm is failing -------------------------------------+------------------------------------- Reporter: thomie | Owner: Type: bug | Status: new Priority: highest | Milestone: 8.0.1 Component: Compiler | Version: 7.11 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: | base/tests/exceptionsrun001 Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Phab:D1616 Wiki Page: | -------------------------------------+------------------------------------- Comment (by Thomas Miedema <thomasmiedema@…>): In [changeset:"a2f04a26fe6bf989fb3575d73cb2a07464ab81a5/ghc" a2f04a2/ghc]: {{{ #!CommitTicketReference repository="ghc" revision="a2f04a26fe6bf989fb3575d73cb2a07464ab81a5" Testsuite: #10712 is fixed Verified by running: make TEST='exceptionsrun001 T3279 conc012 conc014' slowtest }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10712#comment:13> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

#10712: Regression: make TEST=exceptionsrun001 WAY=optasm is failing -------------------------------------+------------------------------------- Reporter: thomie | Owner: Type: bug | Status: closed Priority: highest | Milestone: 8.0.1 Component: Compiler | Version: 7.11 Resolution: fixed | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: | base/tests/exceptionsrun001 Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Phab:D1616 Wiki Page: | -------------------------------------+------------------------------------- Comment (by Simon Peyton Jones <simonpj@…>): In [changeset:"9915b6564403a6d17651e9969e9ea5d7d7e78e7f/ghc" 9915b656/ghc]: {{{ #!CommitTicketReference repository="ghc" revision="9915b6564403a6d17651e9969e9ea5d7d7e78e7f" Make demand analysis understand catch As Trac #11222, and #10712 note, the strictness analyser needs to be rather careful about exceptions. Previously it treated them as identical to divergence, but that won't quite do. See Note [Exceptions and strictness] in Demand, which explains the deal. Getting more strictness in 'catch' and friends is a very good thing. Here is the nofib summary, keeping only the big ones. -------------------------------------------------------------------------------- Program Size Allocs Runtime Elapsed TotalMem -------------------------------------------------------------------------------- fasta -0.1% -6.9% -3.0% -3.0% +0.0% hpg -0.1% -2.0% -6.2% -6.2% +0.0% maillist -0.1% -0.3% 0.08 0.09 +1.2% reverse-complem -0.1% -10.9% -6.0% -5.9% +0.0% sphere -0.1% -4.3% 0.08 0.08 +0.0% x2n1 -0.1% -0.0% 0.00 0.00 +0.0% -------------------------------------------------------------------------------- Min -0.2% -10.9% -17.4% -17.3% +0.0% Max -0.0% +0.0% +4.3% +4.4% +1.2% Geometric Mean -0.1% -0.3% -2.9% -3.0% +0.0% On the way I did quite a bit of refactoring in Demand.hs }}} -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10712#comment:15> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

#10712: Regression: make TEST=exceptionsrun001 WAY=optasm is failing -------------------------------------+------------------------------------- Reporter: thomie | Owner: Type: bug | Status: new Priority: highest | Milestone: 8.0.1 Component: Compiler | Version: 7.11 Resolution: | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: | base/tests/exceptionsrun001 Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Phab:D1616 Wiki Page: | -------------------------------------+------------------------------------- Comment (by simonpj): Are you sure? exceptionsrun001 seems OK to me. It turns out that the other three all relied on imprecise exceptions being precise. Eg conc012 has {{{ forkIO $ Control.Exception.catch (x `seq` putMVar result Finished) $ }}} If you want to be sure that `x` will only be evaluated under the `catch` you must use `evaluate` thus: {{{ forkIO $ Control.Exception.catch (evaluate x >> putMVar result Finished) $ }}} Similarly conc014 had {{{ error "wibble" `Control.Exception.catch` ... }}} But the `error "wibble"` is a pure bottom value and we make no guarantees about when it is evaluated. It should be more like {{{ throwIO (ErrorCall "wibble") `Control.Exception.catch` .... }}} which raises the exception in the IO monad (i.e. precisely). Same with `T3279`, which had {{{ error "foo" `catch` \(SomeException e) -> do }}} Again that `error "foo"` should be `throwIO (ErrorCall "foo")`. Incidentally, is there a function for `throwIO . ErrorCall`? I'll make a patch for these three tests. Then I claim we are done. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10712#comment:17> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

#10712: Regression: make TEST=exceptionsrun001 WAY=optasm is failing -------------------------------------+------------------------------------- Reporter: thomie | Owner: Type: bug | Status: closed Priority: highest | Milestone: 8.0.1 Component: Compiler | Version: 7.11 Resolution: fixed | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: | base/tests/exceptionsrun001 Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Phab:D1616 Wiki Page: | -------------------------------------+------------------------------------- Changes (by simonpj): * status: new => closed * resolution: => fixed -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10712#comment:19> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

#10712: Regression: make TEST=exceptionsrun001 WAY=optasm is failing -------------------------------------+------------------------------------- Reporter: thomie | Owner: Type: bug | Status: closed Priority: highest | Milestone: 8.0.1 Component: Compiler | Version: 7.11 Resolution: fixed | Keywords: Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: | base/tests/exceptionsrun001 Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Phab:D1616 Wiki Page: | -------------------------------------+------------------------------------- Comment (by rwbarton): Well the test is wrong in the same way as the others. {{{ patMatchTest = catch (case test1 [1..10] of () -> return ()) (...) }}} where `test1 [1..10]` results in a pattern match failure. Maybe the best question is why the test ''doesn't'' fail with way optasm. After all why not evaluate `case test1 [1..10] of () -> return ()` first, if `catch` is strict in that argument. That argument becomes (up to a coercion) {{{ a_s2uX :: GHC.Prim.State# GHC.Prim.RealWorld -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #) [LclId, Arity=1, Str=DmdType, Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True, WorkFree=True, Expandable=True, Guidance=IF_ARGS [0] 290 30}] a_s2uX = \ (eta_B1 [OS=OneShot] :: GHC.Prim.State# GHC.Prim.RealWorld) -> case GHC.Base.build @ Integer (\ (@ b_a2uz) (c_a2uA [OS=OneShot] :: Integer -> b_a2uz -> b_a2uz) (n_a2uB [OS=OneShot] :: b_a2uz) -> GHC.Enum.enumDeltaToInteger1FB @ b_a2uz c_a2uA n_a2uB 1 10) of _ [Occ=Dead] { [] -> (# eta_B1, GHC.Tuple.() #); : ipv_s2hb ipv_s2hc -> case lvl_s2v4 of wild_00 { } } }}} Perhaps some of the `Value=True, ConLike=True, WorkFree=True, Expandable=True` flags are causing the value not to get evaluated eagerly. Is that what GHC should be doing? (The hpc version has all those flags set to `False`, maybe because of the ticks wrapping the expression, or because the coercion was not removed yet: the hpc version of this binding has type `IO ()` still.) Anyways, GHC's behavior is correct either way, but maybe there is something to learn here before fixing the test. -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10712#comment:21> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler

#10712: Regression: make TEST=exceptionsrun001 WAY=optasm is failing -------------------------------------+------------------------------------- Reporter: thomie | Owner: (none) Type: bug | Status: closed Priority: highest | Milestone: 8.0.1 Component: Compiler | Version: 7.11 Resolution: fixed | Keywords: Exceptions Operating System: Unknown/Multiple | Architecture: | Unknown/Multiple Type of failure: None/Unknown | Test Case: | base/tests/exceptionsrun001 Blocked By: | Blocking: Related Tickets: | Differential Rev(s): Phab:D1616 Wiki Page: | -------------------------------------+------------------------------------- Changes (by simonpj): * keywords: => Exceptions -- Ticket URL: <http://ghc.haskell.org/trac/ghc/ticket/10712#comment:23> GHC <http://www.haskell.org/ghc/> The Glasgow Haskell Compiler