什么是可能的Haskell優化鍵？

Question

我發現基准測試解決了不同語言中的非常簡單的任務https://github.com/starius/lang-bench 。 這是Haskell的代碼：

cmpsum i j k =
    if i + j == k then 1 else 0

main = print (sum([cmpsum i j k |
    i <- [1..1000], j <- [1..1000], k <- [1..1000]]))

你可以在基准測試中看到這個代碼運行速度非常慢，我覺得這很奇怪。 我試圖內聯函數cmpsum並使用下一個標志進行編譯：

ghc -c -O2 main.hs

但它確實沒有幫助。 我不是要求優化算法，因為它對所有語言都是一樣的，但是關於可能使編碼或代碼優化可以使這段代碼運行得更快的問題。

Answer 1

不是完整的答案，對不起。 在我的機器上使用GHC 7.10進行編譯我的版本為~12s。

我建議總是使用-Wall進行編譯，這表明我們的數字默認為無限精度的Integer類型。 修復：

module Main where

cmpsum :: Int -> Int -> Int -> Int
cmpsum i j k =
    if i + j == k then 1 else 0

main :: IO ()
main = print (sum([cmpsum i j k |
    i <- [1..1000], j <- [1..1000], k <- [1..1000]]))

這對我來說大約需要5秒。 使用+RTS -s運行似乎表明我們在常量內存中有一個循環：

          87,180 bytes allocated in the heap
           1,704 bytes copied during GC
          42,580 bytes maximum residency (1 sample(s))
          18,860 bytes maximum slop
               1 MB total memory in use (0 MB lost due to fragmentation)

                                     Tot time (elapsed)  Avg pause  Max pause
  Gen  0         0 colls,     0 par    0.000s   0.000s     0.0000s    0.0000s
  Gen  1         1 colls,     0 par    0.000s   0.000s     0.0001s    0.0001s

  INIT    time    0.000s  (  0.001s elapsed)
  MUT     time    4.920s  (  4.919s elapsed)
  GC      time    0.000s  (  0.000s elapsed)
  EXIT    time    0.000s  (  0.000s elapsed)
  Total   time    4.920s  (  4.921s elapsed)

  %GC     time       0.0%  (0.0% elapsed)

  Alloc rate    17,719 bytes per MUT second

  Productivity 100.0% of total user, 100.0% of total elapsed

-fllvm了另一秒左右。 也許其他人可以進一步研究它。

編輯 ：再深入挖掘一下這個。 它看起來並不像融合正在發生。 即使我將sum更改為foldr (+) 0 ，這是一個明確的“良好生產者/良好消費者”對。

Rec {
$wgo [InlPrag=[0], Occ=LoopBreaker] :: Int# -> Int#
[GblId, Arity=1, Str=DmdType <S,U>]
$wgo =
  \ (w :: Int#) ->
    let {
      $j :: Int# -> Int#
      [LclId, Arity=1, Str=DmdType]
      $j =
        \ (ww [OS=OneShot] :: Int#) ->
          letrec {
            $wgo1 [InlPrag=[0], Occ=LoopBreaker] :: [Int] -> Int#
            [LclId, Arity=1, Str=DmdType <S,1*U>]
            $wgo1 =
              \ (w1 :: [Int]) ->
                case w1 of _ [Occ=Dead] {
                  [] -> ww;
                  : y ys ->
                    case $wgo1 ys of ww1 { __DEFAULT ->
                    case lvl of _ [Occ=Dead] {
                      [] -> ww1;
                      : y1 ys1 ->
                        case y of _ [Occ=Dead] { I# y2 ->
                        case y1 of _ [Occ=Dead] { I# y3 ->
                        case tagToEnum# @ Bool (==# (+# w y2) y3) of _ [Occ=Dead] {
                          False ->
                            letrec {
                              $wgo2 [InlPrag=[0], Occ=LoopBreaker] :: [Int] -> Int#
                              [LclId, Arity=1, Str=DmdType <S,1*U>]
                              $wgo2 =
                                \ (w2 :: [Int]) ->
                                  case w2 of _ [Occ=Dead] {
                                    [] -> ww1;
                                    : y4 ys2 ->
                                      case y4 of _ [Occ=Dead] { I# y5 ->
                                      case tagToEnum# @ Bool (==# (+# w y2) y5) of _ [Occ=Dead] {
                                        False -> $wgo2 ys2;
                                        True -> case $wgo2 ys2 of ww2 { __DEFAULT -> +# 1 ww2 }
                                      }
                                      }
                                  }; } in
                            $wgo2 ys1;
                          True ->
                            letrec {
                              $wgo2 [InlPrag=[0], Occ=LoopBreaker] :: [Int] -> Int#
                              [LclId, Arity=1, Str=DmdType <S,1*U>]
                              $wgo2 =
                                \ (w2 :: [Int]) ->
                                  case w2 of _ [Occ=Dead] {
                                    [] -> ww1;
                                    : y4 ys2 ->
                                      case y4 of _ [Occ=Dead] { I# y5 ->
                                      case tagToEnum# @ Bool (==# (+# w y2) y5) of _ [Occ=Dead] {
                                        False -> $wgo2 ys2;
                                        True -> case $wgo2 ys2 of ww2 { __DEFAULT -> +# 1 ww2 }
                                      }
                                      }
                                  }; } in
                            case $wgo2 ys1 of ww2 { __DEFAULT -> +# 1 ww2 }
                        }
                        }
                        }
                    }
                    }
                }; } in
          $wgo1 lvl } in
    case w of wild {
      __DEFAULT -> case $wgo (+# wild 1) of ww { __DEFAULT -> $j ww };
      1000 -> $j 0
    }
end Rec }

實際上，查看內核的print $ foldr (+) (0:: Int) $ [ i+j | i <- [0..10000], j <- [0..10000]] print $ foldr (+) (0:: Int) $ [ i+j | i <- [0..10000], j <- [0..10000]]似乎只有列表print $ foldr (+) (0:: Int) $ [ i+j | i <- [0..10000], j <- [0..10000]]的第一層被融合了。 那是一個錯誤嗎？

Answer 2

此代碼在1秒內完成工作，GHC 7.10中沒有額外的分配-O2 （請參見底部的分析輸出）：

cmpsum :: Int -> Int -> Int -> Int
cmpsum i j k = fromEnum (i+j==k)

main = print $ sum [cmpsum i j k | i <- [1..1000],
                                   j <- [1..const 1000 i],
                                   k <- [1..const 1000 j]]

在GHC 7.8中，如果在開頭添加以下內容，則在這種情況下（1.4秒）可以獲得幾乎相同的結果：

import Prelude hiding (sum)

sum xs = foldr (\x r a -> a `seq` r (a+x)) id xs 0

這里有三個問題：

1. 將代碼專門Int而不是將其默認為Integer是至關重要的。

2. GHC 7.10為GHC 7.8不提供的sum提供了列表融合。 這是因為基於foldl的新定義， sum的新定義在某些情況下可能非常糟糕，而沒有Joachim Breitner為GHC 7.10創建的“call arity”分析。

3. 在任何內聯發生之前，GHC會在編譯初期執行有限的“完全懶惰”傳遞。 結果，在循環中多次使用的j和k的常數[1..1000]項被提升出循環。 如果這些計算實際上很昂貴，那將是很好的，但在這種情況下，一遍又一遍地進行添加要便宜得多，而不是保存結果。 以上代碼的作用是欺騙GHC。 由於const直到稍后才進行內聯，因此第一次完全懶惰傳遞並未看到列表是常量，因此它不會將它們提升。 我用這種方式寫它是因為它很好而且很短，但不可否認的是，它在脆弱的一面。 為了使其更加健壯，請使用分階段內聯：

    main = print $ sum [cmpsum ijk | i <- [1..1000], j <- [1..konst 1000 i], k <- [1..konst 1000 j]] {-# INLINE [1] konst #-} konst = const 

   這保證了konst將在簡化階段1中內聯，但不會更早。 第1階段發生在列表融合完成之后，因此讓GHC看到所有內容是完全安全的。

          51,472 bytes allocated in the heap
           3,408 bytes copied during GC
          44,312 bytes maximum residency (1 sample(s))
          17,128 bytes maximum slop
               1 MB total memory in use (0 MB lost due to fragmentation)

                                     Tot time (elapsed)  Avg pause  Max pause
  Gen  0         0 colls,     0 par    0.000s   0.000s     0.0000s    0.0000s
  Gen  1         1 colls,     0 par    0.000s   0.000s     0.0002s    0.0002s

  INIT    time    0.000s  (  0.000s elapsed)
  MUT     time    1.071s  (  1.076s elapsed)
  GC      time    0.000s  (  0.000s elapsed)
  EXIT    time    0.000s  (  0.000s elapsed)
  Total   time    1.073s  (  1.077s elapsed)

  %GC     time       0.0%  (0.0% elapsed)

  Alloc rate    48,059 bytes per MUT second

  Productivity  99.9% of total user, 99.6% of total elapsed

Answer 3

您正在通過生成中間結構（列表）並折疊它來將單個語句上的循環與計數進行比較。 我不知道如果你創建一個迭代了十億個元素的鏈表，Java的性能會有多大。

這是Haskell代碼（大約）等同於您的Java代碼。

{-# LANGUAGE BangPatterns #-}

main = print (loop3 1 1 1 0) 

loop1 :: Int -> Int -> Int -> Int -> Int
loop1 !i !j !k !cc | k <= 1000 = loop1 i j (k+1) (cc + fromEnum (i + j == k))
                   | otherwise = cc 

loop2 :: Int -> Int -> Int -> Int -> Int
loop2 !i !j !k !cc | j <= 1000 = loop2 i (j+1) k (loop1 i j k cc)
                   | otherwise = cc 

loop3 :: Int -> Int -> Int -> Int -> Int
loop3 !i !j !k !cc | i <= 1000 = loop3 (i+1) j k (loop2 i j k cc)
                   | otherwise = cc 

在我的機器上執行（test2是你的Haskell代碼）：

$ ghc --make -O2 test1.hs && ghc --make -O2 test2.hs && javac test3.java
$ time ./test1.exe && time ./test2.exe && time java test3
499500

real    0m1.614s
user    0m0.000s
sys     0m0.000s
499500

real    0m35.922s
user    0m0.000s
sys     0m0.000s
499500

real    0m1.589s
user    0m0.000s
sys     0m0.015s