Why is haskell performing worse than java

Question

I wanted to fool a bit around with random numbers, if the random generator in haskell is distributed uniformly or not, thus I wrote the following program after a few tries (with lists being generated leading to stack overflow).

module Main where

import System.Environment (getArgs)
import Control.Applicative ((<$>))
import System.Random (randomRIO)

main :: IO ()
main = do nn <- map read <$> getArgs :: IO [Int]
          let n = if null nn then 10000 else head nn
          m <- loop n 0 (randomRIO (0,1))
          putStrLn $ "True: "++show (m//n::Double) ++", False "++show ((n-m)//n :: Double)
          return ()

loop :: Int -> Int -> IO Double -> IO Int
loop n acc x | n<0       = return acc
             | otherwise = do x' <- round <$> x
                              let x'' = (x' + acc) in x'' `seq` loop (n-1) x'' x

(//) :: (Integral a, Fractional b) => a -> a -> b
x // y = fromIntegral x / fromIntegral y

as I got it to work ok-ish I decided to write another version - in java (which I am not very good in), and expected haskell to beat it, but the java program ran about half the time compared to the haskell version

import java.util.Random;

public class MonteCarlo {
    public static void main(String[] args) {
        int n = Integer.parseInt(args[0]);
        Random r = new Random();
        int acc = 0;
        for (int i=0; i<=n; i++) {
            acc += Math.round(r.nextDouble());
        }
        System.out.println("True: "+(double) acc/n+", False: "+(double)(n-acc)/n);
    }
}

I tried to look at the profile of the haskell version - which told me that most of the work was done in the loop - no wonder! I tried to look at the core, but I really don't know enough to understand that. I figure that the java version, may be using more than one core - as the system used more than 100%, when I timed it.

I guess one could improve the code using unboxed Doubles/Ints, but again my knowledge of hakell is not up to that.

The Java version is singlethreaded. But Java uses multiple threads for e.g. garbage collection so you might see a little activity on other cores. And Java always being slow is a myth. Just in time compilation can give you native speeds especially if it is just a simple loop with math and without objects. — zapl
Haskell is an advanced functional programming language, featuring strong static typing, lazy evaluation, extensive parallelism and concurrency support, and unique abstraction capabilities. You expect it to be as fast at simple things as Java? — Hot Licks
To make it comparable, I suggest using randomRs and operating on the list, without loop in the IO monad. — Ingo
According to this post, System.Random is slow. Try using the mwc-random package. — ErikR
@HotLicks Java is an advanced OO programming language, featuring a sophisticated exception-tracking mechanism, inheritance, overloading, strong support for concurrency, bounded polymorphism and subtyping. You expect it to be as fast at simple things as Haskell? — Daniel Wagner

Mihai Maruseac Mihai Maruseac · Accepted Answer · 2014-01-16T01:42:55

I have tried a crude version of your code relying on laziness:

module Main where

import System.Environment
import Control.Applicative
import System.Random

main :: IO ()
main = do
  args <- getArgs
  let n = if null args then 10000 else read $ head args
  g <- getStdGen
  let vals = randomRs (0, 1) g :: [Int]
  let s = sum $ take n vals
  putStrLn $ "True: " ++ f s n ++ ", False" ++ f (n - s) n

f x y = show $ ((fromIntegral x / fromIntegral y) :: Double)

For now, ignore the fact that I've missed some type declarations and I have imported everything from the modules. I just wanted to be free to test.

Back at the castle, your version was saved as original.hs while the above was saved as 1.hs. Testing time:

[mihai@esgaroth so]$ ghc --make -O2 original.hs
[1 of 1] Compiling Main             ( original.hs, original.o )
Linking original ...
[mihai@esgaroth so]$ ghc --make -O2 1.hs 
[1 of 1] Compiling Main             ( 1.hs, 1.o )
Linking 1 ...
[mihai@esgaroth so]$ time ./original 
True: 0.4981, False 0.5019

real    0m0.022s
user    0m0.021s
sys     0m0.000s
[mihai@esgaroth so]$ time ./1 
True: 0.4934, False0.5066

real    0m0.005s
user    0m0.003s
sys     0m0.001s
[mihai@esgaroth so]$ time ./original 
True: 0.5063, False 0.4937

real    0m0.018s
user    0m0.017s
sys     0m0.001s
[mihai@esgaroth so]$ time ./1 
True: 0.5024, False0.4976

real    0m0.005s
user    0m0.003s
sys     0m0.002s

Everytime, the new code was 4 time faster. And that is while still having the first version of using lazy constructs and already existing code.

Next step is to test the performance heaps and to see if it is worth to embed the sum computation when generating the random list.

PS: On my machine:

[mihai@esgaroth so]$ time java MonteCarlo 10000
True: 0.5011, False: 0.4989

real    0m0.063s
user    0m0.066s
sys     0m0.010s

PPS: Running the code compiled without -O2:

[mihai@esgaroth so]$ time ./original 
True: 0.5035, False 0.4965

real    0m0.032s
user    0m0.031s
sys     0m0.001s
[mihai@esgaroth so]$ time ./1 
True: 0.4975, False0.5025

real    0m0.014s
user    0m0.010s
sys     0m0.003s

Only a 2 time reduction but still faster than java.

Why is haskell performing worse than java

3 Answers