I was reading an old post where Hal Daume III was analyzing Haskell performance for arrays. He proposed a test program which initializes an array, reverse it a number of times, and sums the contents. So I wrote a c++ reference program, a naive haskell version using lists and I also tweaked a little bit with the IOArray version, which should be the fastest. Unfortunately there is a huge performance gap. Haskell is slower by a factor of ten, even when using imperative style. C++ time ./arrayC 499 real 0m0.059s user 0m0.044s sys 0m0.008s HASKELL - IOUArray time ./IOMutArrayUnboxed 499 real 0m0.720s user 0m0.571s sys 0m0.019s HASKELL - list time ./list 499 real 0m1.845s user 0m1.770s sys 0m0.064s Can anyone suggest a faster version (using whatever data structure)? I like Haskell very much but I still have to figure out if the slowness of some code is due to my lack of knowledge or to some intrinsic limitation of the language (or libraries). By the way, sorry for the poor quality of the code, I am not a computer scientist. ------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------- //compile with //g++ -o arrayC arrayC.cc #include <stdio.h> #include < math.h> int main() { int array[500001]; for (int i=0;i<=500000;i++) { array[i]=(19*i+23)%911; } int tmp=0; for (int cnt=0;cnt<12;cnt++) { for (int x=0;x<=250000;x++) { tmp=array[500000-x]; array[500000-x]=array[x]; array[x]=tmp; } } int result=0; for (int i=0;i<=500000;i++) { result=result+(array[i]%911); } result=result % 911; printf("%d",result); return 0; } --------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------- -- compile with -- ghc --make -o list list.hs module Main where testArray = [ (19*i+23) `mod` 911 |i <- [0..500000]] sumArrayMod = foldl (\x y -> (y+x) `mod` 911) 0 main = print $ sumArrayMod$ reverse$ reverse$ reverse$ reverse$ reverse$ reverse$ reverse$ reverse$ reverse$ reverse$ reverse$ reverse$ reverse$ reverse$ reverse$ reverse$ testArray --------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------- -- compile with -- ghc --make -o IOMutArrayUnboxed IOMutArrayUnboxed.hs module Main where import Monad import Data.Array.IO import Data.Array.MArray import Data.Array.Unboxed total, semiTotal ::Int total= 500000 semiTotal=250000 testArray :: IO (IOUArray Int Int) testArray = newListArray (0,total) [(19*i+23) `mod` 911 |i <- [0..total]] reverseArray :: IOUArray Int Int -> IO () reverseArray arr = mapM_ (\i -> do oldi <- readArray arr i oldj <- readArray arr (total-i) writeArray arr i oldj writeArray arr (total-i) oldi) [0..semiTotal] sumArrayMod :: IOUArray Int Int -> IO Int sumArrayMod arr = foldM (\s i -> do x <- readArray arr i return $!(s+x) `mod` 911) 0 [0..total] main::IO() main = testArray >>= \a -> reverseArray a >> reverseArray a >> reverseArray a >> reverseArray a
reverseArray a >> reverseArray a >> reverseArray a >> reverseArray a
reverseArray a >> reverseArray a >> reverseArray a >> reverseArray a
reverseArray a >> reverseArray a >> reverseArray a >> reverseArray a
sumArrayMod a >>= print
--------------------------------------------------------------------------------------------------------- Federico