Comments on: Haskell as fast as C: working at a high altitude for low level performance

By: Migrating from uvector to vector « Control.Monad.Writer

Migrating from uvector to vector « Control.Monad.Writer — Mon, 15 Feb 2010 21:31:57 +0000

[...] These two libraries share a common origin, but have different engineering goals. Both libraries make heavy use of loop fusion based on streams to achieve excellent performance. (You can read more about that in a separate post). [...]

By: Self-optimizing data structures: using types to make lists faster « Control.Monad.Writer

Sun, 11 Oct 2009 22:34:05 +0000

[...] is part of an ongoing series on high-performance Haskell programming. Related posts include stream fusion for lists, programming the inliner, Judy arrays and Haskell and applying stream fusion to [...]

By: Bill

Bill — Mon, 07 Sep 2009 23:43:01 +0000

Don,

Have you tried examples where the C compiler (eg. icc from Intel) manages to vectorize the code? Eg.

float f(float *fs, int n) {
float r = 0.0f;
int i;
for(i = 0; i < n; i++)
r += (fs[i] * 3.14f) – (fs[i] + fs[1]);
return r;
}

where we'd expect the use of 'packed' sse instructions? On recent machines this should be quite a bit faster.

Are there some from-the-trenches tricks we can use to get close to the same performance in Haskell using GHC?

By: Piotr Lesnicki

Piotr Lesnicki — Thu, 22 Jan 2009 04:22:28 +0000

Update on previous comment: I learned rewrite rules and adequate ghc options to fire them… So problem solved and you can delete previous comment.

We can make mean have type [Double]-> Double and have list enumeration fused by writing:

{-# RULES
“toU/enumFromTo” forall (n::Double) (m::Double).
toU (enumFromTo n m) = enumFromToFracU n m;
#-}

mean :: [Double] -> Double
mean xs = s / fromIntegral l
where
P s l = foldlU k (P 0 0) (toU xs)
k (P s l) val = P (s+val) (l+1)

This is great!

However I have to admit that I find those ghc optimizations flags quite obscure (use of -funbox-strict-field for exemple). Details play a great role here!

By: Piotr Lesnicki

Piotr Lesnicki — Thu, 22 Jan 2009 02:53:39 +0000

Suppose I would want mean to still have type ([Double] -> Double) though. I see I can write it using (toU xs) inside of mean instead of (enumFromToFracU n m). Then fusion doesn’t happen.

I’m very novice with Haskell and so I quickly got stuck.

I suppose [1 .. d] is a syntactic sugar for (enumFromTo 1 d), so I made this rule in my file:

{-# RULES

“RealFrac.toU/enumFromTo” (RealFrac n, RealFrac m) => forall n m.
toU (enumFromTo n m) = enumFromToFracU n m
#-}

It doesn’t work unfortunatly. Could You have any guidance? Am I missing something or am I completly misleaded?