Haskell矢量性能与Scala相比

Question

我在Haskell和Scala中有一段非常简单的代码。此代码旨在以非常严格的循环运行，因此性能很重要。问题是Haskell比Scala慢10倍左右。这里是Haskell代码。

{-# LANGUAGE BangPatterns #-} 
import qualified Data.Vector.Unboxed as VU 

newtype AffineTransform = AffineTransform {get :: (VU.Vector Double)} deriving (Show) 

{-# INLINE runAffineTransform #-} 
runAffineTransform :: AffineTransform -> (Double, Double) -> (Double, Double) 
runAffineTransform affTr (!x, !y) = (get affTr `VU.unsafeIndex` 0 * x + get affTr `VU.unsafeIndex` 1 * y + get affTr `VU.unsafeIndex` 2, 
             get affTr `VU.unsafeIndex` 3 * x + get affTr `VU.unsafeIndex` 4 * y + get affTr `VU.unsafeIndex` 5) 

testAffineTransformSpeed :: AffineTransform -> Int -> (Double, Double) 
testAffineTransformSpeed affTr count = go count (0.5, 0.5) 
    where go :: Int -> (Double, Double) -> (Double, Double) 
     go 0 res = res 
     go !n !res = go (n-1) (runAffineTransform affTr res) 

还可以做些什么来改进此代码？

Answer 1

的主要问题是

runAffineTransform affTr (!x, !y) = (get affTr `VU.unsafeIndex` 0 * x 
            + get affTr `VU.unsafeIndex` 1 * y 
            + get affTr `VU.unsafeIndex` 2, 
             get affTr `VU.unsafeIndex` 3 * x 
            + get affTr `VU.unsafeIndex` 4 * y 
            + get affTr `VU.unsafeIndex` 5) 

产生对的thunk。 runAffineTransform被调用时，组件不会被评估，它们仍然是thunk，直到某些消费者要求对它们进行评估。

testAffineTransformSpeed affTr count = go count (0.5, 0.5) 
    where go :: Int -> (Double, Double) -> (Double, Double) 
     go 0 res = res 
     go !n !res = go (n-1) (runAffineTransform affTr res) 

不是消费者，在res轰仅评估为最外层的构造，(,)，和你这是在最终只评估了

runAffineTransform affTr (runAffineTrasform affTr (runAffineTransform affTr (...))) 

结果是，当最后的正常形式是需要的。

如果强行结果的部件要立即进行评估，

runAffineTransform affTr (!x, !y) = case 
    ( get affTr `U.unsafeIndex` 0 * x 
    + get affTr `U.unsafeIndex` 1 * y 
    + get affTr `U.unsafeIndex` 2 
    , get affTr `U.unsafeIndex` 3 * x 
    + get affTr `U.unsafeIndex` 4 * y 
    + get affTr `U.unsafeIndex` 5 
) of (!a,!b) -> (a,b) 

，让它被内联，使用自定义严格对拆箱Double# s到jtobin的版本的主要区别在于：在testAffineTransformSpeed的循环中，您将使用盒装的Double s作为参数进行一次初始迭代，最后，结果的组件将被装箱，这会增加一些常量开销（每个循环的大约5纳秒）。循环的主要部分在两种情况下都采用Int#和两个Double#参数，并且除了达到n = 0时的装箱外，循环体是相同的。

当然，通过使用unboxed严格配对类型迫使组件立即评估更好。

Answer 2

我定义的以下严格/装箱对类型：

import System.Random.MWC -- for later 
import Control.DeepSeq 

data SP = SP { 
    one :: {-# UNPACK #-} !Double 
    , two :: {-# UNPACK #-} !Double 
    } deriving Show 

instance NFData SP where 
    rnf p = rnf (one p) `seq` rnf (two p) `seq`() 

并在runAffineTransform函数代替它：

runAffineTransform2 :: AffineTransform -> SP -> SP 
runAffineTransform2 affTr !(SP x y) = 
    SP ( get affTr `U.unsafeIndex` 0 * x 
     + get affTr `U.unsafeIndex` 1 * y 
     + get affTr `U.unsafeIndex` 2 ) 

    ( get affTr `U.unsafeIndex` 3 * x 
     + get affTr `U.unsafeIndex` 4 * y 
     + get affTr `U.unsafeIndex` 5 ) 
{-# INLINE runAffineTransform2 #-} 

然后跑这个基准套件：

main :: IO() 
main = do 
    g <- create 
    zs <- fmap (AffineTransform . U.fromList) 
      (replicateM 100000 (uniformR (0 :: Double, 1) g)) 

    let myConfig = defaultConfig { cfgPerformGC = ljust True } 

    defaultMainWith myConfig (return()) [ 
     bench "yours" $ nf (testAffineTransformSpeed zs) 10 
    , bench "mine" $ nf (testAffineTransformSpeed2 zs) 10 
    ] 

编译与-O2并跑，并观察到一些（~4倍）加速：

benchmarking yours 
mean: 257.4559 ns, lb 256.2492 ns, ub 258.9761 ns, ci 0.950 
std dev: 6.889905 ns, lb 5.688330 ns, ub 8.839753 ns, ci 0.950 
found 5 outliers among 100 samples (5.0%) 
    3 (3.0%) high mild 
    2 (2.0%) high severe 
variance introduced by outliers: 20.944% 
variance is moderately inflated by outliers 

benchmarking mine 
mean: 69.56408 ns, lb 69.29910 ns, ub 69.86838 ns, ci 0.950 
std dev: 1.448874 ns, lb 1.261444 ns, ub 1.718074 ns, ci 0.950 
found 4 outliers among 100 samples (4.0%) 
    4 (4.0%) high mild 
variance introduced by outliers: 14.190% 
variance is moderately inflated by outliers 

Full code is in gist here。

编辑

我也贴标准的输出报告here。