Question

我在Haskell上实现了Winograd算法，并尝试通过严格的计算来加速算法。在这个我成功了，但我完全不明白为什么，加上严格，它开始更快地工作。由于我的算法代码足够大，我写了两个小函数来证明这个问题。

git fetch

在算法的实现中，矩阵在使用前计算，就像这里一样。在函数module Main where import qualified Data.Vector as V import qualified Data.Matrix as M import Control.DeepSeq import Control.Exception import System.Clock import Data.Time matrixCtor x y size = M.matrix size size $ \(i,j) -> x*i+y*j group v s = foldl (\acc i ->acc + V.unsafeIndex v i * V.unsafeIndex v (i+1)) 0 [0,2..s-1] size = 3000 :: Int testWithForce :: IO () testWithForce = do let a = matrixCtor 2 1 size evaluate $ force a start <- getCurrentTime let c = V.generate size $ \j -> M.getCol (j+1) a evaluate $ force c let d = foldl (\acc i ->acc + group (V.unsafeIndex c i) size) 0 [0,1..(size-1)] evaluate $ force d end <- getCurrentTime print (diffUTCTime end start) testWithoutForce :: IO () testWithoutForce = do let a = matrixCtor (-2) 1 size evaluate $ force a start <- getCurrentTime let c = V.generate size $ \j -> M.getCol (j+1) a let d = foldl (\acc i ->acc + group (V.unsafeIndex c i) size) 0 [0,1..(size-1)] evaluate $ force d end <- getCurrentTime print (diffUTCTime end start) main :: IO () main = do testWithForce testWithoutForce中，我在使用之前计算值testWithForce。在这种情况下，函数c比函数testWithForce工作得更快。我得到了以下结果：

testWithoutForce

我无法理解为什么这种情况下的严格性会加速这项工作。

Answer 1

请原谅非答案，但要确保控制GC：似乎第二个功能可能会受到前一个GC的负担，从而使差异膨胀。

我可以重现您所看到的内容：

$ ghc -O3 --make foo.hs && ./foo
[1 of 1] Compiling Main             ( foo.hs, foo.o )
Linking foo ...
1.471109207s
2.001165795s

然而，当我翻转测试的顺序时，结果是不同的：

main = do
  testWithoutForce 
  testWithForce

$  ghc -O3 --make foo.hs && ./foo
1.626452918s
1.609818958s

所以我在每个测试之间做了main GC：

import System.Mem

main = do
  performMajorGC
  testWithForce
  performMajorGC
  testWithoutForce

强迫的一个仍然更快，但差异大大减少了：

1.460686986s
1.581715988s

Haskell中惰性和严格评估的比较

1 个答案: