比较 Haskell 和 C 计算素数的速度

Question

我最初写了这个（蛮力和低效的）计算素数的方法，目的是确保在 Haskell 中使用“if-then-else”与使用守卫之间在速度上没有区别（而且没有区别！ ）。但后来我决定写一个 C 程序来比较，我得到了以下结果（Haskell 慢了 25% 以上）：

（请注意，我从以下帖子中得到了使用 rem 而不是 mod 以及编译器调用中的 O3 选项的想法：On improving Haskell's performance compared to C in fibonacci micro-benchmark）

Haskell : Forum.hs

divisibleRec :: Int -> Int -> Bool
divisibleRec i j 
  | j == 1         = False 
  | i `rem` j == 0 = True 
  | otherwise      = divisibleRec i (j-1)

divisible::Int -> Bool
divisible i = divisibleRec i (i-1)

r = [ x | x <- [2..200000], divisible x == False]

main :: IO()
main = print(length(r))

C : main.cpp

#include <stdio.h>

bool divisibleRec(int i, int j){
  if(j==1){ return false; }
  else if(i%j==0){ return true; }
  else{ return divisibleRec(i,j-1); }
}

bool divisible(int i){ return divisibleRec(i, i-1); }

int main(void){
  int i, count =0;
  for(i=2; i<200000; ++i){
    if(divisible(i)==false){
      count = count+1;
    }
  }
  printf("number of primes = %d\n",count);
  return 0;
}

我得到的结果如下：

编译时间

time (ghc -O3 -o runProg Forum.hs)
real    0m0.355s
user    0m0.252s
sys 0m0.040s

time (gcc -O3 -o runProg main.cpp)
real    0m0.070s
user    0m0.036s
sys 0m0.008s

以及以下运行时间：

在 Ubuntu 32 位上的运行时间

Haskell
17984
real    0m54.498s
user    0m51.363s
sys 0m0.140s


C++
number of primes = 17984
real    0m41.739s
user    0m39.642s
sys 0m0.080s

Haskell 的运行时间给我留下了深刻的印象。但是我的问题是：我可以做些什么来加快haskell程序的速度吗：

1. 更改底层算法（很明显，通过更改算法可以获得巨大的加速；但我只是想了解在语言/编译器方面我可以做些什么来提高性能）
2. 调用 llvm 编译器（因为我没有安装）

[编辑：内存使用情况]

在 Alan 发表评论后，我注意到 C 程序使用恒定数量的内存，而 Haskell 程序的内存大小会缓慢增长。起初我认为这与递归有关，但 gspr 在下面解释了为什么会发生这种情况并提供了解决方案。 Will Ness 提供了一种替代解决方案，该解决方案（如 gspr 的解决方案）也确保内存保持静态。

[编辑：大运行总结]

最大测试数：200,000：

(54.498s/41.739s) = Haskell 慢 30.5%

最大测试数：400,000：

3m31.372s/2m45.076s = 211.37s/165s = Haskell 慢 28.1%

最大测试数：800,000：

14m3.266s/11m6.024s = 843.27s/666.02s = Haskell 慢 26.6%

[编辑：艾伦的代码]

这是我之前写的没有递归的代码，我在 200,000 上测试过：

#include <stdio.h>

bool divisibleRec(int i, int j){
  while(j>0){
    if(j==1){ return false; }
    else if(i%j==0){ return true; }
    else{ j -= 1;}
  }
}


bool divisible(int i){ return divisibleRec(i, i-1); }

int main(void){
  int i, count =0;
  for(i=2; i<8000000; ++i){
    if(divisible(i)==false){
      count = count+1;
    }
  }
  printf("number of primes = %d\n",count);
  return 0;
}

有和没有递归的C代码结果如下（800,000）：

使用递归：11m6.024s

没有递归：11m5.328s

请注意，无论最大数量如何，可执行文件似乎都占用了 60kb（如系统监视器中所示），因此我怀疑编译器正在检测此递归。

Answer 1

这并不是真正回答您的问题，而是您在评论中提出的关于当 200000 增长时内存使用量增加的评论。

当这个数字增加时，列表r 也会增加。您的代码最后需要所有 r 来计算其长度。另一方面，C 代码只是增加一个计数器。如果你想要持续使用内存，你也必须在 Haskell 中做类似的事情。代码仍然非常Haskelly，总的来说这是一个明智的提议：你并不需要divisible 是False 的数字列表，你只需要知道有多少。

你可以试试

main :: IO ()
main = print $ foldl' (\s x -> if divisible x then s else s+1) 0 [2..200000]

（foldl' 是 Data.List 的一个更严格的 foldl，可避免建立 thunk）。

Answer 2

好棒的模式给你一个很小的胜利（就像 llvm 一样，但你似乎已经预料到了）：

{-# LANUGAGE BangPatterns #-}

divisibleRec !i !j | j == 1         = False

在我的 x86-64 上，我通过切换到较小的表示形式（例如 Word32）获得了巨大的胜利：

divisibleRec :: Word32 -> Word32 -> Bool
...
divisible :: Word32 -> Bool

我的时间安排：

$ time ./so             -- Int
2262

real    0m2.332s

$ time ./so              -- Word32
2262

real    0m1.424s

这更接近于您的 C 程序，它仅使用 int。它仍然与性能不匹配，我怀疑我们必须查看核心才能找出原因。

编辑：正如我已经注意到的，内存使用是关于命名列表r。我只是内联了r，让它为每个不可分割的值输出一个1 并取和：

main = print $ sum $ [ 1 | x <- [2..800000], not (divisible x) ]

Answer 3

另一种写下算法的方法是

main = print $ length [()|x<-[2..200000], and [rem x d>0|d<-[x-1,x-2..2]]]

不幸的是，它运行速度较慢。使用all ((>0).rem x) [x-1,x-2..2] 作为测试，它的运行速度仍然较慢。但也许你会在你的设置上测试它。

用带有爆炸模式的显式循环替换您的代码没有任何区别：

{-# OPTIONS_GHC -XBangPatterns #-}
r4::Int->Int
r4 n = go 0 2 where
  go !c i | i>n = c
          | True = go (if not(divisible i) then (c+1) else c) (i+1)

divisibleRec::Int->Int->Bool
divisibleRec i !j | j == 1 = False 
                  | i `rem` j == 0 = True 
                  | otherwise = divisibleRec i (j-1)

Answer 4

当我开始使用 Haskell 编程时，我也对它的速度印象深刻。您可能有兴趣阅读article 的第 5 点“Haskell 的速度”。