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

Question

我在Haskell上实现了Winograd算法，并由于严格的计算而试图加快算法加快算法。在这方面，我成功了，但我完全不明白为什么补充严格，它开始更快地工作。由于我的该算法的代码足够大，所以我写了两个小功能，证明了这个问题。

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快。我得到以下结果：

0.945078s --testWithForce
1.785158s --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