performance - Haskell:Data.Text 与 Data.Text.Lazy 性能对比

Question

为了培训，我编写了一个简短的 Haskell 程序来替代 Perl 脚本。该程序读取一个包含多行消息的日志文件，并简单地将它们连接起来，每条消息生成一行。我的测试输入文件有 14000 行，大小为 1 MB。使用 Data.Text 的版本运行时间为 3.5 秒，使用 Data.Text.Lazy 的版本只有 0.1 秒(原始 perl 脚本需要 0.2 秒)。我在其他帖子中发现，使用 Data.Text.Lazy 只对真正大量的数据有意义，没想到会有这样的差异。任何人都可以解释原因或我的程序有什么问题吗？

源的相关部分(两个版本之间的唯一区别是导入 Data.Text*):

{-# LANGUAGE OverloadedStrings #-}
module Main where
import Data.Char (isDigit)
import Data.Monoid ((<>))
import qualified Data.Text.Lazy    as T
import qualified Data.Text.Lazy.IO as T
import System.Environment (getArgs, getProgName)
import System.IO (openFile, stdin, stdout, Handle,
                  IOMode(ReadMode,WriteMode))

main :: IO ()
main = do
  (inp,out) <- getInput
  actLog <- T.hGetContents inp
  let newLog = processLog actLog
  T.hPutStr out newLog

processLog :: T.Text -> T.Text
processLog = foldr joinLines "" . T.lines

joinLines :: T.Text -> T.Text -> T.Text
joinLines elem accu
  | T.length elem == 0    = accu                     -- Blank Line
  | T.head elem   == ' '  = textElem <> accu         -- Continuation
  | isDigit (T.head elem) = "\n" <> textElem <> accu -- Start
  | otherwise             = accu                     -- Garbage
    where textElem = T.strip elem

Answer 1

这看起来像是数据结构问题而不是惰性问题。严格Text本质上是一大块内存，而一个惰性的 Text本质上是一个严格的链表 Text s(“ block ”)。偷懒的方式Text is split up into chunks 不应该是值的含义的一部分(这只是通过连接所有 block 获得的文本)。但它会对运营成本产生重大影响。

您有一堆 short <> accu 形式的操作其中 accu随着输出的大小而增长。如果这些是严格的Text s，此连接必须复制 short 的全部内容和 accu进入新严Text值(value)。总运行时间必然是二次方的。如果他们懒惰 Text s，然后 <>还有另一种选择:它可以在 block 列表前添加 short到 block 列表 accu .这不需要触及 accu完全没有，但即使有，构成 accu 的 block 链表的主干处理的数据可能比 accu 的全部文本内容少得多，取决于 block 大小。这就是为什么你的懒惰 Text版本要快得多。

看起来你可以把你的程序写成这样

processLog = T.unlines . processLines . T.lines
processLines :: [T.Text] -> [T.Text]
processLines = ...

这留下了如何连接到库函数的问题 T.unlines ，在这种情况下，无论您是否使用严格的 Text，您都可以期望它是高效的或懒惰 Text .