Question

我有一个Haskell程序，它在ST monad中运行期间生成~280M的日志文本数据。这几乎是所有内存消耗的地方（禁用日志记录，程序分配总计3MB的实内存）。

问题是，我的内存不足。当程序运行内存消耗超过1.5GB时，它最终在尝试将日志字符串写入文件时耗尽。

log函数接受一个String并将日志数据累积到存储在环境中STRef中的字符串构建器中：

import qualified Data.ByteString.Lazy.Builder as BB
...
myLogFunction s = do
    ...
    lift $ modifySTRef myStringBuilderRef (<> BB.stringUtf8 s)

我尝试使用bang模式和modifySTRef'来引入严格性，但这会使内存消耗更加糟糕。

我按照hPutBuilder文档的建议编写日志字符串，如下所示：

    hSetBinaryMode h True
    hSetBuffering  h $ BlockBuffering Nothing
    BB.hPutBuilder h trace

这会消耗几个额外的GB内存。我尝试了不同的缓冲设置并首先转换为懒惰的ByteString（稍好一点）。

Qs的：

如何在程序运行时最大限度地减少内存消耗？我希望给出一个严格的ByteString表示和适当的严格度，我需要的内存比我存储的~280M的实际日志数据要少。
如何在不分配内存的情况下将结果写入文件？我不明白为什么Haskell需要GB的内存才能将一些常驻数据流式传输到文件中。

编辑：

这是小型运行的内存配置文件（约42MB的日志数据）。在禁用日志记录的情况下，总内存使用量为3MB。

    15,632,058,700 bytes allocated in the heap
     4,168,127,708 bytes copied during GC
       343,530,916 bytes maximum residency (42 sample(s))
         7,149,352 bytes maximum slop
               931 MB total memory in use (0 MB lost due to fragmentation)

                                      Tot time (elapsed)  Avg pause  Max pause
    Gen  0     29975 colls,     0 par    5.96s    6.15s     0.0002s    0.0104s
    Gen  1        42 colls,     0 par    6.01s    7.16s     0.1705s    1.5604s

    TASKS: 3 (1 bound, 2 peak workers (2 total), using -N1)

    SPARKS: 0 (0 converted, 0 overflowed, 0 dud, 0 GC'd, 0 fizzled)

    INIT    time    0.00s  (  0.00s elapsed)
    MUT     time   32.38s  ( 33.87s elapsed)
    GC      time   11.97s  ( 13.31s elapsed)
    RP      time    0.00s  (  0.00s elapsed)
    PROF    time    0.00s  (  0.00s elapsed)
    EXIT    time    0.00s  (  0.00s elapsed)
    Total   time   44.35s  ( 47.18s elapsed)

    Alloc rate    482,749,347 bytes per MUT second

    Productivity  73.0% of total user, 68.6% of total elapsed

编辑：

我按照要求运行了一个带有小日志运行的内存配置文件：

profile http://imageshack.us/a/img14/9778/6a5o.png

我尝试在相关位置添加爆炸模式，$ !, deepseq / $ !!，force等，但似乎没有任何区别。我如何强制Haskell实际获取我的字符串/ printf表达式等，并将其放在一个紧密的ByteString中，而不是保留所有那些[Char]列表和未评估的thunk？

编辑：

这是实际的完整跟踪功能

trace s = do
     enable <- asks envTraceEnable
     when (enable) $ do
        envtrace <- asks envTrace
        let b = B8.pack s
        lift $ b `seq` modifySTRef' envtrace (<> BB.byteString b)

这是'严格'吗？如果我在ReaderT / ST monad中调用这个类型类函数，我是否需要注意什么？只是为了它实际上被调用而不是以任何方式推迟。

do
    trace $ printf "%i" myint

很好吗？

谢谢！

Answer 1

由于日志消息占用了大量内存，因此在生成后立即将它们写入文件会更有效。这似乎是不可能的，因为我们在ST monad中，并且你不能在ST monad中执行IO。

但是有一条出路：使用某种类似于“管道”包的协程monad变换器。以下是使用pipes-3.3.0的示例：

{-# LANGUAGE ExplicitForAll #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE LiberalTypeSynonyms #-}

import Control.Monad
import Control.Monad.ST
import Control.Monad.ST (stToIO) -- Transforms ST computations into IO computations
import Control.Monad.Trans
import Control.Monad.Morph (hoist) -- Changes the base monad of a monad transformer
import Control.Proxy.Prelude (stdoutD) -- Consumer that prints to stdout
import Control.Proxy.Core
import Control.Proxy.Core.Correct

import Data.STRef

simpleST :: ST s Bool
simpleST= do
    ref <- newSTRef True
    writeSTRef ref False
    readSTRef ref

-- Like simpleST, but emits log messages during the computation
loggingST :: Producer ProxyCorrect String (ST s) Bool
loggingST = do
    ref <- lift $ newSTRef True
    respond "Before writing"
    lift $ writeSTRef ref False
    respond "After writing"
    lift $ readSTRef ref

adapt :: (forall s . Producer ProxyCorrect String (ST s) a) ->
         Producer ProxyCorrect String IO a
adapt x = hoist stToIO x

main :: IO ()
main = do
    result <- runProxy $ (\_ -> adapt loggingST) >-> stdoutD
    putStrLn . show $ result

它将日志打印到stdout。运行时，它输出以下内容：

Before writing
After writing
False

它的工作方式如下：使用respond在生产者中发出日志消息，同时仍然驻留在ST monad中。这样你就可以记录并仍然确保你的计算不会执行一些奇怪的IO东西。但是，它会强迫你用升降机来代码。

构建ST计算后，使用hoist将生产者的基础monad从ST转换为IO。 hoist是一个非常有用的功能，可让您在餐具仍在桌面上时更换桌布。

现在我们在IO-land！剩下要做的唯一事情就是将生产者与实际编写消息的消费者联系起来（这里他们打印到stdout，但你可以很容易地连接到写入文件的消费者。）

在Haskell的ST Monad中有效记录字符串数据

1 个答案: