From 5a336f14d30f9b46ac74ca319ed1af25430cd67a Mon Sep 17 00:00:00 2001 From: Simon Marlow Date: Tue, 16 Dec 2008 11:42:35 +0000 Subject: [PATCH] UNDO: Add -fpass-case-bndr-to-join-points rolling back: Fri Dec 5 10:51:59 GMT 2008 simonpj@microsoft.com * Add -fpass-case-bndr-to-join-points See Note [Passing the case binder to join points] in Simplify.lhs The default now is *not* to pass the case binder. There are some nofib results with the above note; the effect is almost always negligible. I don't expect this flag to be used by users (hence no docs). It's just there to let me try the performance effects of switching on and off. M ./compiler/main/StaticFlagParser.hs +1 M ./compiler/main/StaticFlags.hs +4 M ./compiler/simplCore/Simplify.lhs -14 +73 --- compiler/main/StaticFlagParser.hs | 1 - compiler/main/StaticFlags.hs | 4 -- compiler/simplCore/Simplify.lhs | 87 ++++++------------------------------- 3 files changed, 14 insertions(+), 78 deletions(-) diff --git a/compiler/main/StaticFlagParser.hs b/compiler/main/StaticFlagParser.hs index 7ed4c4c..31ff9d1 100644 --- a/compiler/main/StaticFlagParser.hs +++ b/compiler/main/StaticFlagParser.hs @@ -161,7 +161,6 @@ isStaticFlag f = "fsimple-list-literals", "fno-ds-multi-tyvar", "fruntime-types", - "fpass-case-bndr-to-join-points", "fno-pre-inlining", "fexcess-precision", "static", diff --git a/compiler/main/StaticFlags.hs b/compiler/main/StaticFlags.hs index 93ff1a7..456f620 100644 --- a/compiler/main/StaticFlags.hs +++ b/compiler/main/StaticFlags.hs @@ -38,7 +38,6 @@ module StaticFlags ( opt_Parallel, -- optimisation opts - opt_PassCaseBndrToJoinPoints, opt_DsMultiTyVar, opt_NoStateHack, opt_SimpleListLiterals, @@ -217,9 +216,6 @@ opt_DsMultiTyVar :: Bool opt_DsMultiTyVar = not (lookUp (fsLit "-fno-ds-multi-tyvar")) -- On by default -opt_PassCaseBndrToJoinPoints :: Bool -opt_PassCaseBndrToJoinPoints = lookUp (fsLit "-fpass-case-bndr-to-join-points") - opt_SpecInlineJoinPoints :: Bool opt_SpecInlineJoinPoints = lookUp (fsLit "-fspec-inline-join-points") diff --git a/compiler/simplCore/Simplify.lhs b/compiler/simplCore/Simplify.lhs index 22c7a5a..eba2728 100644 --- a/compiler/simplCore/Simplify.lhs +++ b/compiler/simplCore/Simplify.lhs @@ -35,8 +35,6 @@ import BasicTypes ( TopLevelFlag(..), isTopLevel, RecFlag(..), isNonRuleLoopBreaker ) import Maybes ( orElse ) import Data.List ( mapAccumL ) -import MonadUtils ( foldlM ) -import StaticFlags ( opt_PassCaseBndrToJoinPoints ) import Outputable import FastString \end{code} @@ -1890,97 +1888,40 @@ mkDupableAlts env case_bndr' the_alts mkDupableAlt :: SimplEnv -> OutId -> (AltCon, [CoreBndr], CoreExpr) -> SimplM (SimplEnv, (AltCon, [CoreBndr], CoreExpr)) -mkDupableAlt env case_bndr1 (con, bndrs1, rhs1) - | exprIsDupable rhs1 -- Note [Small alternative rhs] - = return (env, (con, bndrs1, rhs1)) +mkDupableAlt env case_bndr' (con, bndrs', rhs') + | exprIsDupable rhs' -- Note [Small alternative rhs] + = return (env, (con, bndrs', rhs')) | otherwise - = do { let abstract_over bndr + = do { let rhs_ty' = exprType rhs' + used_bndrs' = filter abstract_over (case_bndr' : bndrs') + abstract_over bndr | isTyVar bndr = True -- Abstract over all type variables just in case | otherwise = not (isDeadBinder bndr) -- The deadness info on the new Ids is preserved by simplBinders - inst_tys1 = tyConAppArgs (idType case_bndr1) - con_app dc = mkConApp dc (map Type inst_tys1 ++ varsToCoreExprs bndrs1) - - (rhs2, final_bndrs) -- See Note [Passing the case binder to join points] - | isDeadBinder case_bndr1 - = (rhs1, filter abstract_over bndrs1) - | opt_PassCaseBndrToJoinPoints, not (null bndrs1) - = (rhs1, (case_bndr1 : filter abstract_over bndrs1)) - | otherwise - = case con of - DataAlt dc -> (Let (NonRec case_bndr1 (con_app dc)) rhs1, bndrs1) - LitAlt lit -> ASSERT( null bndrs1 ) (Let (NonRec case_bndr1 (Lit lit)) rhs1, []) - DEFAULT -> ASSERT( null bndrs1 ) (rhs1, [case_bndr1]) - - ; (final_bndrs1, final_args) -- Note [Join point abstraction] - <- if (any isId final_bndrs) - then return (final_bndrs, varsToCoreExprs final_bndrs) + ; (final_bndrs', final_args) -- Note [Join point abstraction] + <- if (any isId used_bndrs') + then return (used_bndrs', varsToCoreExprs used_bndrs') else do { rw_id <- newId (fsLit "w") realWorldStatePrimTy - ; return (rw_id : final_bndrs, - Var realWorldPrimId : varsToCoreExprs final_bndrs) } + ; return ([rw_id], [Var realWorldPrimId]) } - ; let rhs_ty1 = exprType rhs1 - ; join_bndr <- newId (fsLit "$j") (mkPiTypes final_bndrs1 rhs_ty1) + ; join_bndr <- newId (fsLit "$j") (mkPiTypes final_bndrs' rhs_ty') -- Note [Funky mkPiTypes] ; let -- We make the lambdas into one-shot-lambdas. The -- join point is sure to be applied at most once, and doing so -- prevents the body of the join point being floated out by -- the full laziness pass - really_final_bndrs = map one_shot final_bndrs1 + really_final_bndrs = map one_shot final_bndrs' one_shot v | isId v = setOneShotLambda v | otherwise = v - join_rhs = mkLams really_final_bndrs rhs2 + join_rhs = mkLams really_final_bndrs rhs' join_call = mkApps (Var join_bndr) final_args - ; env1 <- addPolyBind NotTopLevel env (NonRec join_bndr join_rhs) - ; return (env1, (con, bndrs1, join_call)) } + ; return (addPolyBind NotTopLevel env (NonRec join_bndr join_rhs), (con, bndrs', join_call)) } -- See Note [Duplicated env] \end{code} -Note [Passing the case binder to join points] -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -Suppose we have - case e of cb { C1 -> r1[cb]; C2 x y z -> r2[cb,x] } -and we want to make join points for the two alternatives, -which mention the case binder 'cb'. Should we pass 'cb' to -the join point, or reconstruct it? Here are the two alternatives -for the C2 alternative: - - Plan A(pass cb): j2 cb x = r2[cb,x] - - Plan B(reconstruct cb): j2 x y z = let cb = C2 x y z in r2[cb,x] - -The advantge of Plan B is that we can "see" the definition of cb -in r2, and that may be important when we inline stuff in r2. The -disadvantage is that if this optimisation doesn't happen, we end up -re-allocating C2, when it already exists. This does happen occasionally; -an example is the function nofib/spectral/cichelli/Auxil.$whinsert. - -Plan B is always better if the constructor is nullary. - -In both cases we don't have liveness info for cb on a branch-by-branch -basis, and it's possible that 'cb' is used in some branches but not -others. Well, the absence analyser will find that out later, so it's -not too bad. - -Sadly, at the time of writing, neither choice seems an unequivocal -win. Here are nofib results, for adding -fpass-case-bndr-to-join-points -(all others are zero effect): - - Program Size Allocs Runtime Elapsed --------------------------------------------------------------------------------- - cichelli +0.0% -4.4% 0.13 0.13 - pic +0.0% -0.7% 0.01 0.04 - transform -0.0% +2.8% -0.4% -9.1% - wave4main +0.0% +10.5% +3.1% +3.4% --------------------------------------------------------------------------------- - Min -0.0% -4.4% -7.0% -31.9% - Max +0.1% +10.5% +3.1% +15.0% - Geometric Mean +0.0% +0.1% -1.7% -6.1% - - Note [Duplicated env] ~~~~~~~~~~~~~~~~~~~~~ Some of the alternatives are simplified, but have not been turned into a join point -- 1.7.10.4