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