java - 为什么 haskell 的性能比 java 差

Question

我想用随机数来愚弄一下，如果 haskell 中的随机生成器是否均匀分布，因此我在几次尝试后写了下面的程序(生成的列表导致堆栈溢出)。

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

当我让它工作正常时，我决定用 java 编写另一个版本(我不是很擅长)，并希望 haskell 能打败它，但 java 程序的运行时间大约是 haskell 版本

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);
    }
}

我试图查看 haskell 版本的配置文件 - 它告诉我大部分工作是在循环中完成的 - 难怪!我试图看一下核心，但我真的不了解这一点。我认为 java 版本可能使用了多个内核 - 因为系统使用了超过 100%，当我计时时。

我想可以使用未装箱的 double /整数来改进代码，但我对 hakell 的了解还是达不到这个水平。

Answer 1

我已经尝试了依赖懒惰的代码的粗略版本:

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)

现在，请忽略我遗漏了一些类型声明并且我已经从模块中导入了所有内容这一事实。我只是想自由地进行测试。

回到城堡，你的版本被保存为original.hs，而上面的版本被保存为1.hs。测试时间:

[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

新代码每次都快 4 倍。那是同时仍然拥有使用惰性构造和现有代码的第一个版本。

下一步是测试性能堆，看看是否值得在生成随机列表时嵌入求和计算。

PS:在我的机器上:

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

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

PPS:运行没有-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

只减少了 2 倍，但仍然比 java 快。