为什么这个程序的 F# 版本比 Haskell 快 6 倍？

Question

Haskell 版本（1.03s）：

module Main where
  import qualified Data.Text as T
  import qualified Data.Text.IO as TIO
  import Control.Monad
  import Control.Applicative ((<$>))
  import Data.Vector.Unboxed (Vector,(!))
  import qualified Data.Vector.Unboxed as V

  solve :: Vector Int -> Int
  solve ar =
    V.foldl' go 0 ar' where
      ar' = V.zip ar (V.postscanr' max 0 ar)
      go sr (p,m) = sr + m - p

  main = do
    t <- fmap (read . T.unpack) TIO.getLine -- With Data.Text, the example finishes 15% faster.
    T.unlines . map (T.pack . show . solve . V.fromList . map (read . T.unpack) . T.words)
      <$> replicateM t (TIO.getLine >> TIO.getLine) >>= TIO.putStr

F#版本（0.17s）：

open System

let solve (ar : uint64[]) =
    let ar' = 
        let t = Array.scanBack max ar 0UL |> fun x -> Array.take (x.Length-1) x
        Array.zip ar t

    let go sr (p,m) = sr + m - p
    Array.fold go 0UL ar'

let getIntLine() =
    Console.In.ReadLine().Split [|' '|]
    |> Array.choose (fun x -> if x <> "" then uint64 x |> Some else None)    

let getInt() = getIntLine().[0]

let t = getInt()
for i=1 to int t do
    getInt() |> ignore
    let ar = getIntLine()
    printfn "%i" (solve ar)

以上两个程序是Stock Maximize problem的解决方案，时间是Run Code按钮的第一个测试用例。

由于某种原因，F# 版本的速度大约快了 6 倍，但我很确定，如果我用命令式循环替换慢速库函数，我可以将其速度提高至少 3 倍，更有可能提高 10 倍。

Haskell 版本是否可以进行类似的改进？

我这样做是出于学习目的，总的来说，我发现很难弄清楚如何编写高效的 Haskell 代码。

Answer 1

如果您切换到 ByteString 并坚持使用普通的 Haskell 列表（而不是向量），您将获得更有效的解决方案。您也可以用一次左折叠重写求解函数并绕过 zip 和右扫描 ⁽¹⁾。 总的来说，在我的机器上，与您的 Haskell 解决方案相比，我的性能提高了 20 倍 ⁽²⁾。

下面的 Haskell 代码比 F# 代码执行得更快：

import Data.List (unfoldr)
import Control.Applicative ((<$>))
import Control.Monad (replicateM_)
import Data.ByteString (ByteString)
import qualified Data.ByteString as B
import qualified Data.ByteString.Char8 as C

parse :: ByteString -> [Int]
parse = unfoldr $ C.readInt . C.dropWhile (== ' ')

solve :: [Int] -> Int
solve xs = foldl go (const 0) xs minBound
    where go f x s = if s < x then f x else s - x + f s

main = do
    [n] <- parse <$> B.getLine
    replicateM_ n $ B.getLine >> B.getLine >>= print . solve . parse

1。有关此答案的早期版本，请参阅 edits，它使用 zip 和 scanr 实现 solve。
_{2。 HackerRank 网站的性能提升幅度更大。}

Answer 2

如果我想在 F# 中快速做到这一点，我会避免使用 solve 中的所有高阶函数，而只需编写一个 C 风格的命令式循环：

let solve (ar : uint64[]) =
  let mutable sr, m = 0UL, 0UL
  for i in ar.Length-1 .. -1 .. 0 do
    let p = ar.[i]
    m <- max p m
    sr <- sr + m - p
  sr

根据我的测量，这比你的 F# 快 11 倍。

然后性能受限于 IO 层（unicode 解析）和字符串拆分。这可以通过读取字节缓冲区并手动编写词法分析器来优化：

let buf = Array.create 65536 0uy
let mutable idx = 0
let mutable length = 0

do
  use stream = System.Console.OpenStandardInput()
  let rec read m =
    let c =
      if idx < length then
        idx <- idx + 1
      else
        length <- stream.Read(buf, 0, buf.Length)
        idx <- 1
      buf.[idx-1]
    if length > 0 && '0'B <= c && c <= '9'B then
      read (10UL * m + uint64(c - '0'B))
    else
      m
  let read() = read 0UL
  for _ in 1UL .. read() do
    Array.init (read() |> int) (fun _ -> read())
    |> solve
    |> System.Console.WriteLine

Answer 3

仅作记录，F# 版本也不是最优的。在这一点上我认为这并不重要，但如果人们想比较性能，那么值得注意的是它可以做得更快。

我并没有很努力地尝试过（你当然可以通过使用受限突变来使其更快，这不会违反 F# 的本质），但是在正确的地方使用 Seq 而不是 Array 进行简单的更改（避免分配临时数组）使代码大约快 2 到 3 倍：

let solve (ar : uint64[]) =
    let ar' = Seq.zip ar (Array.scanBack max ar 0UL)    
    let go sr (p,m) = sr + m - p
    Seq.fold go 0UL ar'

如果您使用Seq.zip，您也可以放弃take 调用（因为Seq.zip 会自动截断序列）。使用#time 使用以下 sn-p 测量：

let rnd = Random()
let inp = Array.init 100000 (fun _ -> uint64 (rnd.Next()))
for a in 0 .. 10 do ignore (solve inp) // Measure this line

原始代码大约需要 150 毫秒，使用新版本大约需要 50-75 毫秒。