1. 17 Dec, 2008 4 commits
  2. 15 Dec, 2008 3 commits
  3. 16 Dec, 2008 3 commits
    • Simon Marlow's avatar
    • Simon Marlow's avatar
      UNDO: Add -fpass-case-bndr-to-join-points · 5a336f14
      Simon Marlow authored
      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 
        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
    • Simon Marlow's avatar
      Rollback INLINE patches · e79c9ce0
      Simon Marlow authored
      rolling back:
      Fri Dec  5 16:54:00 GMT 2008  simonpj@microsoft.com
        * Completely new treatment of INLINE pragmas (big patch)
        This is a major patch, which changes the way INLINE pragmas work.
        Although lots of files are touched, the net is only +21 lines of
        code -- and I bet that most of those are comments!
        HEADS UP: interface file format has changed, so you'll need to
        recompile everything.
        There is not much effect on overall performance for nofib, 
        probably because those programs don't make heavy use of INLINE pragmas.
                Program           Size    Allocs   Runtime   Elapsed
                    Min         -11.3%     -6.9%     -9.2%     -8.2%
                    Max          -0.1%     +4.6%     +7.5%     +8.9%
         Geometric Mean          -2.2%     -0.2%     -1.0%     -0.8%
        (The +4.6% for on allocs is cichelli; see other patch relating to
        The old INLINE system
        The old system worked like this. A function with an INLINE pragam
        got a right-hand side which looked like
             f = __inline_me__ (\xy. e)
        The __inline_me__ part was an InlineNote, and was treated specially
        in various ways.  Notably, the simplifier didn't inline inside an
        __inline_me__ note.  
        As a result, the code for f itself was pretty crappy. That matters
        if you say (map f xs), because then you execute the code for f,
        rather than inlining a copy at the call site.
        The new story: InlineRules
        The new system removes the InlineMe Note altogether.  Instead there
        is a new constructor InlineRule in CoreSyn.Unfolding.  This is a 
        bit like a RULE, in that it remembers the template to be inlined inside
        the InlineRule.  No simplification or inlining is done on an InlineRule,
        just like RULEs.  
        An Id can have an InlineRule *or* a CoreUnfolding (since these are two
        constructors from Unfolding). The simplifier treats them differently:
          - An InlineRule is has the substitution applied (like RULES) but 
            is otherwise left undisturbed.
          - A CoreUnfolding is updated with the new RHS of the definition,
            on each iteration of the simplifier.
        An InlineRule fires regardless of size, but *only* when the function
        is applied to enough arguments.  The "arity" of the rule is specified
        (by the programmer) as the number of args on the LHS of the "=".  So
        it makes a difference whether you say
          	{-# INLINE f #-}
        	f x = \y -> e     or     f x y = e
        This is one of the big new features that InlineRule gives us, and it
        is one that Roman really wanted.
        In contrast, a CoreUnfolding can fire when it is applied to fewer
        args than than the function has lambdas, provided the result is small
        Consequential stuff
        * A 'wrapper' no longer has a WrapperInfo in the IdInfo.  Instead,
          the InlineRule has a field identifying wrappers.
        * Of course, IfaceSyn and interface serialisation changes appropriately.
        * Making implication constraints inline nicely was a bit fiddly. In
          the end I added a var_inline field to HsBInd.VarBind, which is why
          this patch affects the type checker slightly
        * I made some changes to the way in which eta expansion happens in
          CorePrep, mainly to ensure that *arguments* that become let-bound
          are also eta-expanded.  I'm still not too happy with the clarity
          and robustness fo the result.
        * We now complain if the programmer gives an INLINE pragma for
          a recursive function (prevsiously we just ignored it).  Reason for
          change: we don't want an InlineRule on a LoopBreaker, because then
          we'd have to check for loop-breaker-hood at occurrence sites (which
          isn't currenlty done).  Some tests need changing as a result.
        This patch has been in my tree for quite a while, so there are
        probably some other minor changes.
          M ./compiler/basicTypes/Id.lhs -11
          M ./compiler/basicTypes/IdInfo.lhs -82
          M ./compiler/basicTypes/MkId.lhs -2 +2
          M ./compiler/coreSyn/CoreFVs.lhs -2 +25
          M ./compiler/coreSyn/CoreLint.lhs -5 +1
          M ./compiler/coreSyn/CorePrep.lhs -59 +53
          M ./compiler/coreSyn/CoreSubst.lhs -22 +31
          M ./compiler/coreSyn/CoreSyn.lhs -66 +92
          M ./compiler/coreSyn/CoreUnfold.lhs -112 +112
          M ./compiler/coreSyn/CoreUtils.lhs -185 +184
          M ./compiler/coreSyn/MkExternalCore.lhs -1
          M ./compiler/coreSyn/PprCore.lhs -4 +40
          M ./compiler/deSugar/DsBinds.lhs -70 +118
          M ./compiler/deSugar/DsForeign.lhs -2 +4
          M ./compiler/deSugar/DsMeta.hs -4 +3
          M ./compiler/hsSyn/HsBinds.lhs -3 +3
          M ./compiler/hsSyn/HsUtils.lhs -2 +7
          M ./compiler/iface/BinIface.hs -11 +25
          M ./compiler/iface/IfaceSyn.lhs -13 +21
          M ./compiler/iface/MkIface.lhs -24 +19
          M ./compiler/iface/TcIface.lhs -29 +23
          M ./compiler/main/TidyPgm.lhs -55 +49
          M ./compiler/parser/ParserCore.y -5 +6
          M ./compiler/simplCore/CSE.lhs -2 +1
          M ./compiler/simplCore/FloatIn.lhs -6 +1
          M ./compiler/simplCore/FloatOut.lhs -23
          M ./compiler/simplCore/OccurAnal.lhs -36 +5
          M ./compiler/simplCore/SetLevels.lhs -59 +54
          M ./compiler/simplCore/SimplCore.lhs -48 +52
          M ./compiler/simplCore/SimplEnv.lhs -26 +22
          M ./compiler/simplCore/SimplUtils.lhs -28 +4
          M ./compiler/simplCore/Simplify.lhs -91 +109
          M ./compiler/specialise/Specialise.lhs -15 +18
          M ./compiler/stranal/WorkWrap.lhs -14 +11
          M ./compiler/stranal/WwLib.lhs -2 +2
          M ./compiler/typecheck/Inst.lhs -1 +3
          M ./compiler/typecheck/TcBinds.lhs -17 +27
          M ./compiler/typecheck/TcClassDcl.lhs -1 +2
          M ./compiler/typecheck/TcExpr.lhs -4 +6
          M ./compiler/typecheck/TcForeign.lhs -1 +1
          M ./compiler/typecheck/TcGenDeriv.lhs -14 +13
          M ./compiler/typecheck/TcHsSyn.lhs -3 +2
          M ./compiler/typecheck/TcInstDcls.lhs -5 +4
          M ./compiler/typecheck/TcRnDriver.lhs -2 +11
          M ./compiler/typecheck/TcSimplify.lhs -10 +17
          M ./compiler/vectorise/VectType.hs +7
      Mon Dec  8 12:43:10 GMT 2008  simonpj@microsoft.com
        * White space only
          M ./compiler/simplCore/Simplify.lhs -2
      Mon Dec  8 12:48:40 GMT 2008  simonpj@microsoft.com
        * Move simpleOptExpr from CoreUnfold to CoreSubst
          M ./compiler/coreSyn/CoreSubst.lhs -1 +87
          M ./compiler/coreSyn/CoreUnfold.lhs -72 +1
      Mon Dec  8 17:30:18 GMT 2008  simonpj@microsoft.com
        * Use CoreSubst.simpleOptExpr in place of the ad-hoc simpleSubst (reduces code too)
          M ./compiler/deSugar/DsBinds.lhs -50 +16
      Tue Dec  9 17:03:02 GMT 2008  simonpj@microsoft.com
        * Fix Trac #2861: bogus eta expansion
        Urghlhl!  I "tided up" the treatment of the "state hack" in CoreUtils, but
        missed an unexpected interaction with the way that a bottoming function
        simply swallows excess arguments.  There's a long
             Note [State hack and bottoming functions]
        to explain (which accounts for most of the new lines of code).
          M ./compiler/coreSyn/CoreUtils.lhs -16 +53
      Mon Dec 15 10:02:21 GMT 2008  Simon Marlow <marlowsd@gmail.com>
        * Revert CorePrep part of "Completely new treatment of INLINE pragmas..."
        The original patch said:
        * I made some changes to the way in which eta expansion happens in
          CorePrep, mainly to ensure that *arguments* that become let-bound
          are also eta-expanded.  I'm still not too happy with the clarity
          and robustness fo the result.
        Unfortunately this change apparently broke some invariants that were
        relied on elsewhere, and in particular lead to panics when compiling
        with profiling on.
        Will re-investigate in the new year.
          M ./compiler/coreSyn/CorePrep.lhs -53 +58
          M ./configure.ac -1 +1
      Mon Dec 15 12:28:51 GMT 2008  Simon Marlow <marlowsd@gmail.com>
        * revert accidental change to configure.ac
          M ./configure.ac -1 +1
  4. 15 Dec, 2008 2 commits
  5. 10 Dec, 2008 2 commits
  6. 11 Dec, 2008 3 commits
  7. 10 Dec, 2008 3 commits
  8. 09 Dec, 2008 1 commit
  9. 10 Dec, 2008 1 commit
  10. 09 Dec, 2008 12 commits
  11. 04 Dec, 2008 1 commit
  12. 08 Dec, 2008 5 commits
    • simonpj@microsoft.com's avatar
      Inject implicit bindings after CoreTidy, not before Simplify · 19fcb519
      simonpj@microsoft.com authored
      Originally I inject the "implicit bindings" (record selectors, class
      method selectors, data con wrappers...) after CoreTidy.  However, in a
      misguided attempt to fix Trac #2070, I moved the injection point to
      before the Simplifier, so that record selectors would be optimised by
      the simplifier.
      This was misguided because record selectors (indeed all implicit bindings)
      are GlobalIds, whose IdInfo is meant to be frozen.  But the Simplifier,
      and other Core-to-Core optimisations, merrily change the IdInfo.  That 
      ultimately made Trac #2844 happen, where a record selector got arity 2,
      but the GlobalId (which importing scopes re-construct from the class decl
      rather than reading from the interface file) has arity 1.
      So this patch moves the injection back to CoreTidy. Happily #2070 should
      still be OK because we now use CoreSubst.simpleOptExpr on the unfoldings
      for implict things, which gets rid of the most gratuitous infelicities.
      Still, there's a strong case for stoppping record selectors from being
      GlobalIds, and treating them much more like dict-funs.  I'm thinking
      about that.  Meanwhile, #2844 is ok now.
    • simonpj@microsoft.com's avatar
      Add assertion for arity match (checks Trac #2844) · 60881299
      simonpj@microsoft.com authored
      The exported arity of a function must match the arity for the
      STG function.  Trac #2844 was a pretty obscure manifestation of
      the failure of this invariant. This patch doesn't cure the bug;
      rather it adds an assertion to CoreToStg to check the invariant
      so we should get an earlier and less obscure warning if this
      fails in future.
    • simonpj@microsoft.com's avatar
    • simonpj@microsoft.com's avatar
    • simonpj@microsoft.com's avatar
      White space only · 85289ab5
      simonpj@microsoft.com authored