+++ /dev/null
- ------------------------------------
- GHCI hacking
- ------------------------------------
-
-* Don't forget to put deferred-type-decls back into RnIfaces
-
-* Do we want to record a package name in a .hi file?
- Does pi_mod have a ModuleName or a Module?
-
- ------------------------------------
- Mainly FunDeps (23 Jan 01)
- ------------------------------------
-
-This commit re-engineers the handling of functional dependencies.
-A functional dependency is no longer an Inst; instead, the necessary
-dependencies are snaffled out of their Class when necessary.
-
-As part of this exercise I found that I had to re-work how to do generalisation
-in a binding group. There is rather exhaustive documentation on the new Plan
-at the top of TcSimplify.
-
- ******************
- WARNING: I have compiled all the libraries with this new compiler
- and all looks well, but I have not run many programs.
- Things may break. Let me know if so.
- ******************
-
-The main changes are these:
-
-1. typecheck/TcBinds and TcSimplify have a lot of changes due to the
- new generalisation and context reduction story. There are extensive
- comments at the start of TcSimplify
-
-2. typecheck/TcImprove is removed altogether. Instead, improvement is
- interleaved with context reduction (until a fixpoint is reached).
- All this is done in TcSimplify.
-
-3. types/FunDeps has new exports
- * 'improve' does improvement, returning a list of equations
- * 'grow' and 'oclose' close a list of type variables wrt a set of
- PredTypes, but in slightly different ways. Comments in file.
-
-4. I improved the way in which we check that main::IO t. It's tidier now.
-
-In addition
-
-* typecheck/TcMatches:
- a) Tidy up, introducing a common function tcCheckExistentialPat
-
- b) Improve the typechecking of parallel list comprehensions,
- which wasn't quite right before. (see comments with tcStmts)
-
- WARNING: (b) is untested! Jeff, you might want to check.
-
-* Numerous other incidental changes in the typechecker
-
-* Manuel found that rules don't fire well when you have partial applications
- from overloading. For example, we may get
-
- f a (d::Ord a) = let m_g = g a d
- in
- \y :: a -> ...(m_g (h y))...
-
- The 'method' m_g doesn't get inlined because (g a d) might be a redex.
- Yet a rule that looks like
- g a d (h y) = ...
- won't fire because that doesn't show up. One way out would be to make
- the rule matcher a bit less paranoid about duplicating work, but instead
- I've added a flag
- -fno-method-sharing
- which controls whether we generate things like m_g in the first place.
- It's not clear that they are a win in the first place.
-
- The flag is actually consulted in Inst.tcInstId
-
-
-
- ------------------------------------
- Mainly PredTypes (28 Sept 00)
- ------------------------------------
-
-Three things in this commit:
-
- 1. Main thing: tidy up PredTypes
- 2. Move all Keys into PrelNames
- 3. Check for unboxed tuples in function args
-
-1. Tidy up PredTypes
-~~~~~~~~~~~~~~~~~~~~
-The main thing in this commit is to modify the representation of Types
-so that they are a (much) better for the qualified-type world. This
-should simplify Jeff's life as he proceeds with implicit parameters
-and functional dependencies. In particular, PredType, introduced by
-Jeff, is now blessed and dignified with a place in TypeRep.lhs:
-
- data PredType = Class Class [Type]
- | IParam Name Type
-
-Consider these examples:
- f :: (Eq a) => a -> Int
- g :: (?x :: Int -> Int) => a -> Int
- h :: (r\l) => {r} => {l::Int | r}
-
-Here the "Eq a" and "?x :: Int -> Int" and "r\l" are all called
-*predicates*, and are represented by a PredType. (We don't support
-TREX records yet, but the setup is designed to expand to allow them.)
-
-In addition, Type gains an extra constructor:
-
- data Type = .... | PredTy PredType
-
-so that PredType is injected directly into Type. So the type
- p => t
-is represented by
- PredType p `FunTy` t
-
-I have deleted the hackish IPNote stuff; predicates are dealt with entirely
-through PredTys, not through NoteTy at all.
-
-
-2. Move Keys into PrelNames
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-This is just a housekeeping operation. I've moved all the pre-assigned Uniques
-(aka Keys) from Unique.lhs into PrelNames.lhs. I've also moved knowKeyRdrNames
-from PrelInfo down into PrelNames. This localises in PrelNames lots of stuff
-about predefined names. Previously one had to alter three files to add one,
-now only one.
-
-3. Unboxed tuples
-~~~~~~~~~~~~~~~~~~
-Add a static check for unboxed tuple arguments. E.g.
- data T = T (# Int, Int #)
-is illegal
-
-
-
- ---------------------------------------
- Update in place
- ---------------------------------------
-
--funfolding-update-in-place
-Switching it on doesn't affect many programs, except these
-sphere is because it makes a critical function (vecsub) more inlinable
-
- sphere 66465k -20.61%
- infer 13390k +1.27%
- parstof 1461k +1.18%
- fluid 3442k +1.61%
- atom 177163k +13.20%
- bspt 4837k +4.85%
- cichelli 33546k +2.69%
- typecheck 146023k +1.47%
-
-
- ---------------------------------------
- Simon's tuning changes: early Sept 2000
- ---------------------------------------
-
-Library changes
-~~~~~~~~~~~~~~~
-* Eta expand PrelShow.showLitChar. It's impossible to compile this well,
- and it makes a big difference to some programs (e.g. gen_regexps)
-
-* Make PrelList.concat into a good producer (in the foldr/build sense)
-
-
-Flag changes
-~~~~~~~~~~~~
-* Add -ddump-hi-diffs to print out changes in interface files. Useful
- when watching what the compiler is doing
-
-* Add -funfolding-update-in-place to enable the experimental optimisation
- that makes the inliner a bit keener to inline if it's in the RHS of
- a thunk that might be updated in place. Sometimes this is a bad idea
- (one example is in spectral/sphere; see notes in nofib/Simon-nofib-notes)
-
-
-Tuning things
-~~~~~~~~~~~~~
-* Fix a bug in SetLevels.lvlMFE. (change ctxt_lvl to dest_level)
- I don't think this has any performance effect, but it saves making
- a redundant let-binding that is later eliminated.
-
-* Desugar.dsProgram and DsForeign
- Glom together all the bindings into a single Rec. Previously the
- bindings generated by 'foreign' declarations were not glommed together, but
- this led to an infelicity (i.e. poorer code than necessary) in the modules
- that actually declare Float and Double (explained a bit more in Desugar.dsProgram)
-
-* OccurAnal.shortMeOut and IdInfo.shortableIdInfo
- Don't do the occurrence analyser's shorting out stuff for things which
- have rules. Comments near IdInfo.shortableIdInfo.
- This is deeply boring, and mainly to do with making rules work well.
- Maybe rules should have phases attached too....
-
-* CprAnalyse.addIdCprInfo
- Be a bit more willing to add CPR information to thunks;
- in particular, if the strictness analyser has just discovered that this
- is a strict let, then the let-to-case transform will happen, and CPR is fine.
- This made a big difference to PrelBase.modInt, which had something like
- modInt = \ x -> let r = ... -> I# v in
- ...body strict in r...
- r's RHS isn't a value yet; but modInt returns r in various branches, so
- if r doesn't have the CPR property then neither does modInt
-
-* MkId.mkDataConWrapId
- Arrange that vanilla constructors, like (:) and I#, get unfoldings that are
- just a simple variable $w:, $wI#. This ensures they'll be inlined even into
- rules etc, which makes matching a bit more reliable. The downside is that in
- situations like (map (:) xs), we'll end up with (map (\y ys. $w: y ys) xs.
- Which is tiresome but it doesn't happen much.
-
-* SaAbsInt.findStrictness
- Deal with the case where a thing with no arguments is bottom. This is Good.
- E.g. module M where { foo = error "help" }
- Suppose we have in another module
- case M.foo of ...
- Then we'd like to do the case-of-error transform, without inlining foo.
-
-
-Tidying up things
-~~~~~~~~~~~~~~~~~
-* Reorganised Simplify.completeBinding (again).
-
-* Removed the is_bot field in CoreUnfolding (is_cheap is true if is_bot is!)
- This is just a tidy up
-
-* HsDecls and others
- Remove the NewCon constructor from ConDecl. It just added code, and nothing else.
- And it led to a bug in MkIface, which though that a newtype decl was always changing!
-
-* IdInfo and many others
- Remove all vestiges of UpdateInfo (hasn't been used for years)
-
- ------------------------------
- Join points Sept 2000
- ------------------------------
-
-With Andrew Kennedy, I found out why a few of the join points introduced by
-the simplifier end up as *not* let-no-escpaed. Here's an example:
-
-f x y = case (pwr x b) == 1 of
- False -> False
- True -> pwr x c == 1
-
-This compiles to:
- f = \ @ t w :: Integer ->
- let {
- $j :: (State# RealWorld -> Bool)
- P
- $j
- = \ w1 :: (State# RealWorld) ->
- case pwr w c of wild {
- S# i -> case i of wild1 { 1 -> $wTrue; __DEFAULT -> $wFalse };
- J# s d1 ->
- case cmpIntegerInt# s d1 1 of wild2 {
- 0 -> $wTrue; __DEFAULT -> $wFalse
- }
- }
- } in
- case pwr w b of wild {
- S# i ->
- case i of wild1 { 1 -> $j realWorld#; __DEFAULT -> $wFalse };
- J# s d1 ->
- case cmpIntegerInt# s d1 1 of wild2 {
- 0 -> $j realWorld#; __DEFAULT -> $wFalse
- }
- }
-
-Now consider
-
- case (f x) of
- True -> False
- False -> True
-
-Suppose f is inlined into this case. No new join points are introduced,
-because the alternatives are both small. But the consumer
- case [.] of {True -> False; False -> True}
-will move into the body of f, be duplicated 4 ways, and end up consuming
-the result of the four outcomes at the body of f. This yields:
- $j :: (State# RealWorld -> Bool)
- P
- $j
- = \ w1 :: (State# RealWorld) ->
- case pwr w c of wild {
- S# i -> case i of wild1 { 1 -> $wTrue; __DEFAULT -> $wFalse };
- J# s d1 ->
- case cmpIntegerInt# s d1 1 of wild2 {
- 0 -> $wTrue; __DEFAULT -> $wFalse
- }
- }
- } in
- case pwr w b of wild {
- S# i ->
- case i of wild1 { 1 -> case $j realWorld# of {T->F; F->T}
- ; __DEFAULT -> $wTrue };
- J# s d1 ->
- case cmpIntegerInt# s d1 1 of wild2 {
- 0 -> case $j realWorld# of {T->F; F->T}
- ; __DEFAULT -> $wTrue
- }
- }
-
-And, voila, the join point $j isn't let-no-escaped any more.
-The point is that the consuming context can't "see inside" the join point.
-It's a phase ordering thing. If f is inlined before the join points
-are built in the first place, then all is well.
-
-
-
- -----------------------------
- Sept 7 2000
- -----------------------------
-
-* Make the simplifier's Stop continuation record whether the expression being
- simplified is the RHS of a thunk, or (say) the body of a lambda or case RHS.
- In the thunk case we want to be a bit keener about inlining if the type of
- the thunk is amenable to update in place.
-
-* SetLevels was being a bit too eager to float things to the top
- level; e.g. _inline_me_ (\a -> e); here e got floated...
- Easily fixed by a change to ltMajLvl
-
-* Make CoreUnfold.calcUnfoldingGuidance a bit less keen to make case expressions
- seem small. The original idea was to make inlined wrappers look small, so that
- when we inline a wrapper it doesn't make call site (much) bigger
- Otherwise we get nasty phase ordering stuff:
- -- f x = g x x
- -- h y = ...(f e)...
- If we inline g's wrapper, f looks big, and doesn't get inlined
- into h; if we inline f first, while it looks small, then g's
- wrapper will get inlined later anyway. To avoid this nasty
- ordering difference, we make (case a of (x,y) -> ...),
- *where a is one of the arguments* look free.
-
- BUT (a) It's too eager. We don't want to inline a wrapper into a
- context with no benefit.
- E.g. \ x. f (x+x) o point in inlining (+) here!
-
- (b) It's ineffective. Once g's wrapper is inlined, its case-expressions
- aren't scrutinising arguments any more
-
- So I've rescinded this idea for now. cases still look fairly small.
-
-* Fix interestingArg, which was being too liberal, and hence doing
- too much inlining.
-
-* Extended CoreUtils.exprIsCheap to make two more things cheap:
- - case (coerce x) of ...
- - let x = y +# z
- This makes a bit more eta expansion happen. It was provoked by
- a program of Marcin's.
-
-* The simplifier used to glom together all the top-level bindings into
- a single Rec every time it was invoked. The reason for this is explained
- in SimplCore.lhs, but for at least one simple program it meant that the
- simplifier never got around to unravelling the recursive group into
- non-recursive pieces. So I've put the glomming under explicit flag
- control with a -fglom-binds simplifier pass. A side benefit is
- that because it happens less often, the (expensive) SCC algorithm
- runs less often.
-
-* MkIface.ifaceBinds. Make sure that we emit rules for things
- (like class operations) that don't get a top-level binding in the
- interface file. Previously such rules were silently forgotten.
-
-* Move transformRhs to *after* simplification, which makes it a
- little easier to do, and means that the arity it computes is
- readily available to completeBinding. This gets much better
- arities.
-
-* Do coerce splitting in completeBinding. This gets good code for
- newtype CInt = CInt Int
-
- test:: CInt -> Int
- test x = case x of
- 1 -> 2
- 2 -> 4
- 3 -> 8
- 4 -> 16
- _ -> 0
-
-* Modify the meaning of "arity" so that during compilation it means
- "if you apply this function to fewer args, it will do virtually
- no work". So, for example
- f = coerce t (\x -> e)
- has arity at least 1. When a function is exported, it's arity becomes
- the number of exposed, top-level lambdas, which is subtly different.
- But that's ok.
-
- I removed CoreUtils.exprArity altogether: it looked only at the exposed
- lambdas. Instead, we use exprEtaExpandArity exclusively.
-
- All of this makes I/O programs work much better.
-
-
- -----------------------------
- Sept 4 2000
- -----------------------------
-
-* PrimRep, TysPrim. Add PrimPtrRep as the representation for
- MVars and MutVars. Previously they were given PtrRep, but that
- crashed dataReturnConvPrim! Here's the program the killed it:
- data STRef s a = STRef (MutVar# s a)
- from (STRef x) = x
-
-* Make the desugarer use string equality for string literal
- patterns longer than 1 character. And put a specialised
- eqString into PrelBase, with a suitable specialisation rule.
- This makes a huge difference to the size of the code generated
- by deriving(Read) notably in Time.lhs
-
- -----------------------------
- Marktoberdorf Commits (Aug 2000)
- -----------------------------
-
-1. Tidy up the renaming story for "system binders", such as
-dictionary functions, default methods, constructor workers etc. These
-are now documented in HsDecls. The main effect of the change, apart
-from tidying up, is to make the *type-checker* (instead of the
-renamer) generate names for dict-funs and default-methods. This is
-good because Sergei's generic-class stuff generates new classes at
-typecheck time.
-
-
-2. Fix the CSE pass so it does not require the no-shadowing invariant.
-Keith discovered that the simplifier occasionally returns a result
-with shadowing. After much fiddling around (which has improved the
-code in the simplifier a bit) I found that it is nearly impossible to
-arrange that it really does do no-shadowing. So I gave up and fixed
-the CSE pass (which is the only one to rely on it) instead.
-
-
-3. Fix a performance bug in the simplifier. The change is in
-SimplUtils.interestingArg. It computes whether an argment should
-be considered "interesting"; if a function is applied to an interesting
-argument, we are more likely to inline that function.
-Consider this case
- let x = 3 in f x
-The 'x' argument was considered "uninteresting" for a silly reason.
-Since x only occurs once, it was unconditionally substituted, but
-interestingArg didn't take account of that case. Now it does.
-
-I also made interestingArg a bit more liberal. Let's see if we
-get too much inlining now.
-
-
-4. In the occurrence analyser, we were choosing a bad loop breaker.
-Here's the comment that's now in OccurAnal.reOrderRec
-
- score ((bndr, rhs), _, _)
- | exprIsTrivial rhs = 3 -- Practically certain to be inlined
- -- Used to have also: && not (isExportedId bndr)
- -- But I found this sometimes cost an extra iteration when we have
- -- rec { d = (a,b); a = ...df...; b = ...df...; df = d }
- -- where df is the exported dictionary. Then df makes a really
- -- bad choice for loop breaker
-
-I also increased the score for bindings with a non-functional type, so that
-dictionaries have a better chance of getting inlined early
-
-
-5. Add a hash code to the InScopeSet (and make it properly abstract)
-This should make uniqAway a lot more robust. Simple experiments suggest
-that uniqAway no longer gets into the long iteration chains that it used
-to.
-
-
-6. Fix a bug in the inliner that made the simplifier tend to get into
-a loop where it would keep iterating ("4 iterations, bailing out" message).
-In SimplUtils.mkRhsTyLam we float bindings out past a big lambda, thus:
- x = /\ b -> let g = \x -> f x x
- in E
-becomes
- g* = /\a -> \x -> f x x
- x = /\ b -> let g = g* b in E
-
-It's essential that we don't simply inling g* back into the RHS of g,
-else we will be back to square 1. The inliner is meant not to do this
-because there's no benefit to the inlining, but the size calculation
-was a little off in CoreUnfold.
-
-
-7. In SetLevels we were bogus-ly building a Subst with an empty in-scope
-set, so a WARNING popped up when compiling some modules. (knights/ChessSetList
-was the example that tickled it.) Now in fact the warning wasn't an error,
-but the Right Thing to do is to carry down a proper Subst in SetLevels, so
-that is what I have now done. It is very little more expensive.
-
-
-
- ~~~~~~~~~~~~
- Apr/May 2000
- ~~~~~~~~~~~~
-
-This is a pretty big commit! It adds stuff I've been working on
-over the last month or so. DO NOT MERGE IT WITH 4.07!
-
-Recompilation checking
-~~~~~~~~~~~~~~~~~~~~~~
-Substantial improvement in recompilation checking. The version management
-is now entirely internal to GHC. ghc-iface.lprl is dead!
-
-The trick is to generate the new interface file in two steps:
- - first convert Types etc to HsTypes etc, and thereby
- build a new ParsedIface
- - then compare against the parsed (but not renamed) version of the old
- interface file
-Doing this meant adding code to convert *to* HsSyn things, and to
-compare HsSyn things for equality. That is the main tedious bit.
-
-Another improvement is that we now track version info for
-fixities and rules, which was missing before.
-
-
-Interface file reading
-~~~~~~~~~~~~~~~~~~~~~~
-Make interface files reading more robust.
- * If the old interface file is unreadable, don't fail. [bug fix]
-
- * If the old interface file mentions interfaces
- that are unreadable, don't fail. [bug fix]
-
- * When we can't find the interface file,
- print the directories we are looking in. [feature]
-
-
-Type signatures
-~~~~~~~~~~~~~~~
- * New flag -ddump-types to print type signatures
-
-
-Type pruning
-~~~~~~~~~~~~
-When importing
- data T = T1 A | T2 B | T3 C
-it seems excessive to import the types A, B, C as well, unless
-the constructors T1, T2 etc are used. A,B,C might be more types,
-and importing them may mean reading more interfaces, and so on.
- So the idea is that the renamer will just import the decl
- data T
-unless one of the constructors is used. This turns out to be quite
-easy to implement. The downside is that we must make sure the
-constructors are always available if they are really needed, so
-I regard this as an experimental feature.
-
-
-Elimininate ThinAir names
-~~~~~~~~~~~~~~~~~~~~~~~~~
-Eliminate ThinAir.lhs and all its works. It was always a hack, and now
-the desugarer carries around an environment I think we can nuke ThinAir
-altogether.
-
-As part of this, I had to move all the Prelude RdrName defns from PrelInfo
-to PrelMods --- so I renamed PrelMods as PrelNames.
-
-I also had to move the builtinRules so that they are injected by the renamer
-(rather than appearing out of the blue in SimplCore). This is if anything simpler.
-
-Miscellaneous
-~~~~~~~~~~~~~
-* Tidy up the data types involved in Rules
-
-* Eliminate RnEnv.better_provenance; use Name.hasBetterProv instead
-
-* Add Unique.hasKey :: Uniquable a => a -> Unique -> Bool
- It's useful in a lot of places
-
-* Fix a bug in interface file parsing for __U[!]
-
-
-=======================================
-To-do
-~~~~~
-* Try the effect of enhancing update in place with the CPR
- idea in CoreUnfold.calcUnfoldingGuidance
-
-* Check with Simon M re srt on Lit
-
-* Make all primops return a data type so that we can't over-apply a primop
- This makes code gen simpler. Currently the only primops with a polymorphic
- return type are:
- raise# :: a -> b
- catch# :: a -> (b->a) -> a
- tagToEnum# :: Int -> a
-
- Very strange code for PrelException.catchException! What has STret got
- to do with it?
-
-* Liberate case
-
-* Missing w/w for coerce in go2 functions of fibToList' in fibheaps
-
-* Watch out for re-boxing in workers; sometimes it happens
- and then w/w is a Bad Thing
-
-* Only two uses of mkCompulsoryUnfolding -- try to nuke it
-
-* Note that mkDupAlt makes alts that have binders that
- are guaranteed to appear just once or not at all
- (a,b) -> j a
- Same for case binder, but that's harder to take into account.
-
-* max :: Int -> Int -> Int could be CPRd but isn't.
-
-* In mandel2 we do a little less well than 4.04 because we aren't
- inlining point_colour, and that means we have to box up an argument
- before calling it. [This was due to a bug in 4.04]
- There's also a great opportunity for liberateCase
- in check_radius, where it loops around with two lazy F# built each time
-
-* In PrelShow.itos' we find a thunk like:
- tpl = case chrzh {(zpzh {(remIntzh {x{-aMf-} 10}) 48})}
- of tpl{-X1j-} __D P { __DEFAULT ->
- PrelBase.Czh{-62,s-} {tpl{-X1j-}}
- }
- This is a pity. The remInt# can't fail because the divisor isn't 0,
- so we could do the sum eagerly and allocate a charcter instead of a thunk.
-
-* It's good to do let-to-case before we wrap up. Consider
- f b xs = let ys = partition isUpper xs
- zs = case ys of (a,b) -> a
- in case b of
- True -> case ys of
- (a,b) -> (zs,[])
- False -> case ys of
- (a,b) -> (zs ++ xs,[])
- If we don't do let-to-case at all, we get 3 redundant case ys left.
- On the other hand we don't want to do it too early, because it
- prevents inlining into strict arg positions, which is important for
- rules to work.
-
-* Strict dictionaries.
-
-* INLINE functions are not always INLINEd, so it's sad to leave
- stuff in their bodies like constructors that havn't been inlined.
-
-* If let x = e in b is strict, then CPR can use the CPR info from x
- This bites in the mod method of Integral Int
-
-* Inline wrappers if they are the RHS of a let, so that update in place
- can happen?
-
-* Consider doing unboxing on strict constr args in a pattern match,
- as part of w/w.
-
-* In spectral/expert/Search.ask there's a statically visible CSE. Catching this
- depends almost entirely on chance, which is a pity.
-
-* Think about exprEtaExpandArity in WwLib. Perhaps eliminate eta expand in simplify?
- Perhaps use even if no coerces etc, just eta expansion. (e.g. PrelArr.done)
-
-* In knights/KnightHeuristic, we don't find that possibleMoves is strict
- (with important knock-on effects) unless we apply rules before floating
- out the literal list [A,B,C...].
- Similarly, in f_se (F_Cmp ...) in listcompr (but a smaller effect)
-
-* Floating can float the entire body of an INLINE thing out.
- e.g. PrelArr.done
- This is sad, and a bit stupid.
-
-* In spectral/multiplier, we have
- xor = lift21 forceBit f
- where f :: Bit -> Bit -> Bit
- f 0 0 = 0
- f 0 1 = 1
- f 1 0 = 1
- f 1 1 = 0
- Trouble is, f is CPR'd, and that means that instead of returning
- the constants I# 0, I# 1, it returns 0,1 and then boxes them.
- So allocation goes up. I don't see a way around this.
-
-* spectral/hartel/parstof ends up saying
- case (unpackCString "x") of { c:cs -> ... }
- quite a bit. We should spot these and behave accordingly.
-
-* Try a different hashing algorithms in hashUFM. This might reduce long CSE lists
- as well as making uniqAway faster.
-
-* [I'm not sure this is really important in the end.]
- Don't float out partial applications in lvlMFE. E.g. (in hPutStr defn of shoveString)
- \x -> case .. of
- [] -> setBufWPtr a b
- ...
- setBufWPtr has arity 3. Floating it out is plain silly. And in this particular
- case it's harmful, because it ends up preventing eta expansion on the \x.
- That in turn leads to a big extra cost in hPutStr.
-
- *** Try not doing lvlMFE on the body of a lambda and case alternative ***
-
-* PrelNumExtra.lhs we get three copies of dropTrailing0s. Too much inlining!
- drop0 has cost 21, but gets a discount of 6 (3 * #constrs) for its arg.
- With a keen-neess factor of 2, that makes a discount of 12. Add two for
- the arguments and we get 21-12-2, which is just small enough to inline.
- But that is plainly stupid.
-
- Add one for cases; and decrease discount for constructors.
-
-* IO.hGetContents still doesn't see that it is strict in the handle.
- Coerces still getting in the way.
-
-* Try not having really_interesting_cont (subsumed by changes in the
- way guidance is calculated for inline things?)
-
-* Enumeration types in worker/wrapper for strictness analysis
-
-* This should be reported as an error:
- data T k = MkT (k Int#)
-
-* Bogus report of overlapped pattern for
- f (R {field = [c]}) = 1
- f (R {}) = 2
- This shows up for TyCon.maybeTyConSingleCon
-
-* > module Main( main ) where
-
- > f :: String -> Int
- > f "=<" = 0
- > f "=" = 0
-
- > g :: [Char] -> Int
- > g ['=','<'] = 0
- > g ['='] = 0
-
- > main = return ()
-
- For ``f'' the following is reported.
-
- tmp.lhs:4:
- Pattern match(es) are overlapped in the definition of function `f'
- "=" = ...
-
- There are no complaints for definition for ``g''.
-
-* Without -O I don't think we need change the module version
- if the usages change; I forget why it changes even with -O
-
-* Record selectors for existential type; no good! What to do?
- Record update doesn't make sense either.
-
- Need to be careful when figuring out strictness, and when generating
- worker-wrapper split.
-
- Also when deriving.
-
-
- Jan 2000
- ~~~~~~~~
-
-A fairly big pile of work originally aimed at
-removing the Con form of Core expression, and replacing it with simple
-Lit form. However, I wanted to make sure that the resulting thing
-performed better than the original, so I ended up making an absolute
-raft of other changes.
-
-Removing the Con form of Core expressions
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-The big thing is that
-
- For every constructor C there are now *two* Ids:
-
- C is the constructor's *wrapper*. It evaluates and unboxes arguments
- before calling $wC. It has a perfectly ordinary top-level defn
- in the module defining the data type.
-
- $wC is the constructor's *worker*. It is like a primop that simply
- allocates and builds the constructor value. Its arguments are the
- actual representation arguments of the constructor.
-
- For every primop P there is *one* Id, its (curried) Id
-
- Neither contructor worker Id nor the primop Id have a defminition anywhere.
- Instead they are saturated during the core-to-STG pass, and the code generator
- generates code for them directly. The STG language still has saturated
- primops and constructor applications.
-
-* The Const type disappears, along with Const.lhs. The literal part
- of Const.lhs reappears as Literal.lhs. Much tidying up in here,
- to bring all the range checking into this one module.
-
-* I got rid of NoRep literals entirely. They just seem to be too much trouble.
-
-* Because Con's don't exist any more, the funny C { args } syntax
- disappears from inteface files.
-
-* Every constructor, C, comes with a
-
- *wrapper*, called C, whose type is exactly what it looks like
- in the source program. It is an ordinary function,
- and it gets a top-level binding like any other function
-
- *worker*, called $wC, which is the actual data constructor.
- Its type may be different to C, because:
- - useless dict args are dropped
- - strict args may be flattened
- It does not have a binding.
-
- The worker is very like a primop, in that it has no binding,
-
-
-Parsing
-~~~~~~~
-* Result type signatures now work
- f :: Int -> Int = \x -> x
- -- The Int->Int is the type of f
-
- g x y :: Int = x+y
- -- The Int is the type of the result of (g x y)
-
-
-Recompilation checking and make
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-* The .hi file for a modules is not touched if it doesn't change. (It used to
- be touched regardless, forcing a chain of recompilations.) The penalty for this
- is that we record exported things just as if they were mentioned in the body of
- the module. And the penalty for that is that we may recompile a module when
- the only things that have changed are the things it is passing on without using.
- But it seems like a good trade.
-
-* -recomp is on by default
-
-Foreign declarations
-~~~~~~~~~~~~~~~~~~~~
-* If you say
- foreign export zoo :: Int -> IO Int
- then you get a C produre called 'zoo', not 'zzoo' as before.
- I've also added a check that complains if you export (or import) a C
- procedure whose name isn't legal C.
-
-
-Code generation and labels
-~~~~~~~~~~~~~~~~~~~~~~~~~~
-* Now that constructor workers and wrappers have distinct names, there's
- no need to have a Foo_static_closure and a Foo_closure for constructor Foo.
- I nuked the entire StaticClosure story. This has effects in some of
- the RTS headers (i.e. s/static_closure/closure/g)
-
-
-Rules, constant folding
-~~~~~~~~~~~~~~~~~~~~~~~
-* Constant folding becomes just another rewrite rule, attached to the Id for the
- PrimOp. To achieve this, there's a new form of Rule, a BuiltinRule (see CoreSyn.lhs).
- The prelude rules are in prelude/PrelRules.lhs, while simplCore/ConFold.lhs has gone.
-
-* Appending of constant strings now works, using fold/build fusion, plus
- the rewrite rule
- unpack "foo" c (unpack "baz" c n) = unpack "foobaz" c n
- Implemented in PrelRules.lhs
-
-* The CCall primop is tidied up quite a bit. There is now a data type CCall,
- defined in PrimOp, that packages up the info needed for a particular CCall.
- There is a new Id for each new ccall, with an big "occurrence name"
- {__ccall "foo" gc Int# -> Int#}
- In interface files, this is parsed as a single Id, which is what it is, really.
-
-Miscellaneous
-~~~~~~~~~~~~~
-* There were numerous places where the host compiler's
- minInt/maxInt was being used as the target machine's minInt/maxInt.
- I nuked all of these; everything is localised to inIntRange and inWordRange,
- in Literal.lhs
-
-* Desugaring record updates was broken: it didn't generate correct matches when
- used withe records with fancy unboxing etc. It now uses matchWrapper.
-
-* Significant tidying up in codeGen/SMRep.lhs
-
-* Add __word, __word64, __int64 terminals to signal the obvious types
- in interface files. Add the ability to print word values in hex into
- C code.
-
-* PrimOp.lhs is no longer part of a loop. Remove PrimOp.hi-boot*
-
-
-Types
-~~~~~
-* isProductTyCon no longer returns False for recursive products, nor
- for unboxed products; you have to test for these separately.
- There's no reason not to do CPR for recursive product types, for example.
- Ditto splitProductType_maybe.
-
-Simplification
-~~~~~~~~~~~~~~~
-* New -fno-case-of-case flag for the simplifier. We use this in the first run
- of the simplifier, where it helps to stop messing up expressions that
- the (subsequent) full laziness pass would otherwise find float out.
- It's much more effective than previous half-baked hacks in inlining.
-
- Actually, it turned out that there were three places in Simplify.lhs that
- needed to know use this flag.
-
-* Make the float-in pass push duplicatable bindings into the branches of
- a case expression, in the hope that we never have to allocate them.
- (see FloatIn.sepBindsByDropPoint)
-
-* Arrange that top-level bottoming Ids get a NOINLINE pragma
- This reduced gratuitous inlining of error messages.
- But arrange that such things still get w/w'd.
-
-* Arrange that a strict argument position is regarded as an 'interesting'
- context, so that if we see
- foldr k z (g x)
- then we'll be inclined to inline g; this can expose a build.
-
-* There was a missing case in CoreUtils.exprEtaExpandArity that meant
- we were missing some obvious cases for eta expansion
- Also improve the code when handling applications.
-
-* Make record selectors (identifiable by their IdFlavour) into "cheap" operations.
- [The change is a 2-liner in CoreUtils.exprIsCheap]
- This means that record selection may be inlined into function bodies, which
- greatly improves the arities of overloaded functions.
-
-* Make a cleaner job of inlining "lone variables". There was some distributed
- cunning, but I've centralised it all now in SimplUtils.analyseCont, which
- analyses the context of a call to decide whether it is "interesting".
-
-* Don't specialise very small functions in Specialise.specDefn
- It's better to inline it. Rather like the worker/wrapper case.
-
-* Be just a little more aggressive when floating out of let rhss.
- See comments with Simplify.wantToExpose
- A small change with an occasional big effect.
-
-* Make the inline-size computation think that
- case x of I# x -> ...
- is *free*.
-
-
-CPR analysis
-~~~~~~~~~~~~
-* Fix what was essentially a bug in CPR analysis. Consider
-
- letrec f x = let g y = let ... in f e1
- in
- if ... then (a,b) else g x
-
- g has the CPR property if f does; so when generating the final annotated
- RHS for f, we must use an envt in which f is bound to its final abstract
- value. This wasn't happening. Instead, f was given the CPR tag but g
- wasn't; but of course the w/w pass gives rotten results in that case!!
- (Because f's CPR-ness relied on g's.)
-
- On they way I tidied up the code in CprAnalyse. It's quite a bit shorter.
-
- The fact that some data constructors return a constructed product shows
- up in their CPR info (MkId.mkDataConId) not in CprAnalyse.lhs
-
-
-
-Strictness analysis and worker/wrapper
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-* BIG THING: pass in the demand to StrictAnal.saExpr. This affects situations
- like
- f (let x = e1 in (x,x))
- where f turns out to have strictness u(SS), say. In this case we can
- mark x as demanded, and use a case expression for it.
-
- The situation before is that we didn't "know" that there is the u(SS)
- demand on the argument, so we simply computed that the body of the let
- expression is lazy in x, and marked x as lazily-demanded. Then even after
- f was w/w'd we got
-
- let x = e1 in case (x,x) of (a,b) -> $wf a b
-
- and hence
-
- let x = e1 in $wf a b
-
- I found a much more complicated situation in spectral/sphere/Main.shade,
- which improved quite a bit with this change.
-
-* Moved the StrictnessInfo type from IdInfo to Demand. It's the logical
- place for it, and helps avoid module loops
-
-* Do worker/wrapper for coerces even if the arity is zero. Thus:
- stdout = coerce Handle (..blurg..)
- ==>
- wibble = (...blurg...)
- stdout = coerce Handle wibble
- This is good because I found places where we were saying
- case coerce t stdout of { MVar a ->
- ...
- case coerce t stdout of { MVar b ->
- ...
- and the redundant case wasn't getting eliminated because of the coerce.
-
-
-
-End December
-~~~~~~~~~~~~
-* Fix a few renamer bugs
-
-* Substantially reorganise the Prelude to eliminate all orphan declarations.
- Details in PrelBase.lhs
-
-* Do a much better job of appending literal strings
- - remove NoRepStr
- - move unpackCString stuff to PrelBase
- - add BuiltinRules to the Rule type
- - add fold/build rules for literal strings
-
-
-
-Week of Mon 25 Oct
-~~~~~~~~~~~~~~~~~~
-* Fix a terrible bug in Simplify.mkDupableAlt; we were duplicating a small
- *InAlt*, but doing so invalidated occurrence info, which could lead to
- substantial code duplication.
-
-* Fix a bug in WwLib.mkWWcpr; I was generating CPR wrappers like
- I# (case x of ...)
- which is utterly wrong. It should be
- case x of ...(I# r)
- (The effect was to make functions stricter than they really are.)
-
-* Try doing no inlining at all in phase 0. This noticeably improved
- spectral/fish (esp Main.hs I think), by improving floating.
- This single change has quite a large effect on some programs (allocation)
-
- Don't inline Don't inline
- wrappers anything
- in phase 0 in phase 0
- awards 113k -7.08%
- cichelli 28962k -3.12%
- wave4main 88089k +130.45%
- fibheaps 31731k +19.01%
- fish 8273k -1.64%
- typecheck 148713k +4.91%
-
- But I found that fish worked much better if we inline *local* things
- in phase 0, but not *imported* things.
-
-* Fix a terrible bug in Simplify.mkLamBndrZapper. It was counting
- type args in one place, but not type binders, so it was sometimes
- inlining into unsaturated lambdas!
-
-* I found that there were some very bad loss-of-arity cases in PrelShow.
- In particular, we had:
-
- showl "" = showChar '"' s
- showl ('"':xs) = showString "\\\"" . showl xs
- showl (x:xs) = showLitChar x . showl xs
-
- Trouble is, we get
- showl = \xs -> case xs of
- ...
- (x:xs) -> let f = showLitChar x
- g = showl xs
- in \s -> f (g x)
- which is TERRIBLE. We can't spot that showLitChar has arity 2 because
- it looks like this:
-
- ...other eqns...
- showLitChar c = showString ('\\' : asciiTab!!ord c)
-
- notice that the (asciiTab!!orc c) is outside the \s, so GHC can't rewrite it to
-
- showLitChar c = \s -> showString ('\\' : asciiTab!!ord c) s
-
- So I've changed PrelShow.showLitChar to use explicit \s. Even then, showl
- doesn't work, because GHC can't see that showl xs can be pushed inside the \s.
- So I've put an explict \s there too.
-
- showl "" s = showChar '"' s
- showl ('"':xs) s = showString "\\\"" (showl xs s)
- showl (x:xs) s = showLitChar x (showl xs s)
-
- Net result: imaginary/gen_regexps more than halves in allocation!
-
- Turns out that the mkLamBndrZapper bug (above) meant that showl was
- erroneously inlining showLitChar x and showl xs, which is why this
- problem hasn't shown up before.
-
-* Improve CSE a bit. In ptic
- case h x of y -> ...(h x)...
- replaces (h x) by y.
-
-* Inline INLINE things very agressively, even though we get code duplication
- thereby. Reason: otherwise we sometimes call the original un-inlined INLINE
- defns, which have constructors etc still un-inlined in their RHSs. The
- improvement is dramatic for a few programs:
-
- typecheck 150865k -1.43%
- wave4main 114216k -22.87%
- boyer 28793k -7.86%
- cichelli 33786k -14.28%
- ida 59505k -1.79%
- rewrite 14665k -4.91%
- sched 17641k -4.22%
-
- Code size increases by 10% which is not so good. There must be a better way.
- Another bad thing showed up in fish/Main.hs. Here we have
- (x1,y1) `vec_add` (x2,y2) = (x1+x2, y1+y2)
- which tends to get inlined. But if we first inline (+), it looks big,
- so we don't inline it. Sigh.
-
-
-* Don't inline constructors in INLINE RHSs. Ever. Otherwise rules don't match.
- E.g. build
-
-* In ebnf2ps/Lexer.uncommentString, it would be a good idea to inline a constructor
- that occurs once in each branch of a case. That way it doesn't get allocated
- in the branches that don't use it. And in fact in this particular case
- something else good happens. So CoreUnfold now does that.
-
-* Reverted to n_val_binders+2 in calcUnfoldingGuidance
- Otherwise wrappers are inlined even if there's no benefit.
-
-
-Week of Mon 18 Oct
-~~~~~~~~~~
-* Arrange that simplConArgs works in one less pass than before.
- This exposed a bug: a bogus call to completeBeta.
-
-* Add a top-level flag in CoreUnfolding, used in callSiteInline
-
-* Extend w/w to use etaExpandArity, so it does eta/coerce expansion
-
-* Don't float anything out of an INLINE.
- Don't float things to top level unless they also escape a value lambda.
- [see comments with SetLevels.lvlMFE
- Without at least one of these changes, I found that
- {-# INLINE concat #-}
- concat = __inline (/\a -> foldr (++) [])
- was getting floated to
- concat = __inline( /\a -> lvl a )
- lvl = ...inlined version of foldr...
-
- Subsequently I found that not floating constants out of an INLINE
- gave really bad code like
- __inline (let x = e in \y -> ...)
- so I now let things float out of INLINE
-
-* Implement inline phases. The meaning of the inline pragmas is
- described in CoreUnfold.lhs
-
-* Implement the "reverse-mapping" idea for CSE; actually it turned out to be easier
- to implement it in SetLevels, and may benefit full laziness too.
-
-Thurs 14 Oct
-~~~~~~~~~~~~
-* It's a good idea to inline inRange. Consider
-
- index (l,h) i = case inRange (l,h) i of
- True -> l+i
- False -> error
- inRange itself isn't strict in h, but if it't inlined then 'index'
- *does* become strict in h. Interesting!
-
-* Big change to the way unfoldings and occurrence info is propagated in the simplifier
- The plan is described in Subst.lhs with the Subst type
- Occurrence info is now in a separate IdInfo field than user pragmas
-
-* I found that
- (coerce T (coerce S (\x.e))) y
- didn't simplify in one round. First we get to
- (\x.e) y
- and only then do the beta. Solution: cancel the coerces in the continuation
-
-* Amazingly, CoreUnfold wasn't counting the cost of a function an application.
-
-Early Oct
-~~~~~~~~~
-* No commas between for-alls in RULES
-
-* Disable rules in initial simplifier run. Otherwise full laziness
- doesn't get a chance to lift out a MFE before a rule (e.g. fusion)
- zaps it. queens is a case in point
-
-* Improve float-out stuff significantly. The big change is that if we have
-
- \x -> ... /\a -> ...let p = ..a.. in let q = ...p...
-
- where p's rhs doesn't x, we abstract a from p, so that we can get p past x.
- (We did that before.) But we also substitute (p a) for p in q, and then
- we can do the same thing for q. (We didn't do that, so q got stuck.)
- This is much better. It involves doing a substitution "as we go" in SetLevels,
- though.
-
-
-Weds 15 Sept
-~~~~~~~~~~~~
-* exprIsDupable for an application (f e1 .. en) wasn't calling exprIsDupable
- on the arguments!! So applications with few, but large, args were being dupliated.
-
-* sizeExpr on an application wasn't doing a nukeScrutDiscount on the arg of
- an application!! So bogus discounts could accumulate from arguments!
-
-* Improve handling of INLINE pragmas in calcUnfoldingGuidance. It was really
- wrong before
-
-* Substantially improve handling of coerces in worker/wrapper
-
-Tuesday 6 June
-~~~~~~~~~~~~~~
-* Fix Kevin Atkinson's cant-find-instance bug. Turns out that Rename.slurpSourceRefs
- needs to repeatedly call getImportedInstDecls, and then go back to slurping
- source-refs. Comments with Rename.slurpSourceRefs.
-
-* Add a case to Simplify.mkDupableAlt for the quite-common case where there's
- a very simple alternative, in which case there's no point in creating a
- join-point binding.
-
-* Fix CoreUtils.exprOkForSpeculation so that it returns True of (==# a# b#).
- This lack meant that
- case ==# a# b# of { True -> x; False -> x }
- was not simplifying
-
-* Make float-out dump bindings at the top of a function argument, as
- at the top of a let(rec) rhs. See notes with FloatOut.floatRhs
-
-* Make the ArgOf case of mkDupableAlt generate a OneShot lambda.
- This gave a noticeable boost to spectral/boyer2
-
-
-Monday 5 June
-~~~~~~~~~~~~~
-Work, using IO.hPutStr as an example, to reduce the number of coerces.
-The main idea is in WwLib.mkWWcoerce. The gloss is that we must do
-the w/w split even for small non-recursive things. See notes with
-WorkWrap.tryWw.
-
-
-Friday 2 June
-~~~~~~~~~~~~~
-Study why gen_regexps is slower than before. Problem is in IO.writeLines,
-in particular the local defn shoveString. Two things are getting
-in the way of arity expansion, which means we build far more function
-closures than we should:
- shove = \ x -> let lvl = \s -> ...
- in \s -> ... lvl ...
-
-The two things are:
- a) coerces
- b) full laziness floats
-
-
-Solution to (a): add coerces to the worker/wrapper stuff.
-See notes with WwLib.mkWWcoerce.
-
-This further complicated getWorkerId, so I finally bit the bullet and
-make the workerInfo field of the IdInfo work properly, including
-under substitutions. Death to getWorkerId.
-
-
-
-Solution to (b): make all lambdas over realWorldStatePrimTy
-into one-shot lambdas. This is a GROSS HACK.
-
-* Also make the occurrence analyser aware of one-shot lambdas.
-
-
-Thurs 1 June
-~~~~~~~~~~~~
-Fix SetLevels so that it does not clone top-level bindings, but it
-*does* clone bindings that are destined for the top level.
-
-The global invariant is that the top level bindings are always
-unique, and never cloned.
projects / ghc-hetmet.git / blobdiff