Control.Monad foldM 意外的内存增长

Question

我有以下代码，它已被剥离，我认为尽可能少，但有一些非常奇怪的行为。

代码由两个源文件组成： 一、定义一些数据：

module MyFunction where

data MyFunction =
    MyFunction {
        functionNumber :: Int,
        functionResult :: IO String
        }

makeMyFunction :: Show a => Int -> IO a -> MyFunction
makeMyFunction number result = MyFunction {
    functionNumber = number,
    functionResult = result >>= return . show }

另一个是Main：

module Main (main) where

import System.CPUTime (getCPUTime)
import Data.List (foldl')
import Data.Foldable (foldlM)
import Control.Monad (foldM)
import MyFunction

exampleFunction = do
    --let x = foldl' (\a b -> a `seq` (a + b)) 0 [1..20000000]      -- This works
    --x <- foldlM (\a b -> a `seq` return (a + b)) 0 [1..20000000]  -- This works (*)
    x <- foldM (\a b -> a `seq` return (a + b)) 0 [1..20000000]    -- This doesn't
    print x
    return ()

runFunction fn = do
    result <- functionResult fn
    duration <- getCPUTime
    if result /= "()"
        then putStrLn ""
        else return ()
    putStrLn (show (fromIntegral duration / (10^9)) ++ "ms")
    return fn

main = do
    runFunction (makeMyFunction 123 exampleFunction)
    return ()

上述代码（使用 GHC 7.10.3 编译，堆栈 1.0.0 和默认标志）内存使用量迅速增加（超过 1GB），通常需要 3.3 秒。

如果我对代码进行更改，例如：

• 使用问题行的注释替代方法之一
• 从runFunction中取出任意一行

内存使用量将保持最小，只需大约 1 秒。

我认为最令我惊讶的一个功能是用foldlM（据我所知foldM = foldlM）替换foldM 可以解决问题。

还对我看不到的代码进行更改与问题代码行有任何关系也可以解决问题。例如删除最后一个 putStrLn。

另一个奇怪的地方是，如果我将 MyFunction 模块合并到 Main 模块中，虽然它不能解决问题，但它实际上会导致 foldlM 使用过多的内存作为 foldM。

在这个来自的真实代码中，我有大量的exampleFunctions，并且有明显更多的Main 代码，而且我经常遇到这种来自函数的无法解释的内存使用情况，通常可以用某种巫术来解决。

我正在寻找该行为的解释。如果我知道为什么会发生这种情况，我可以考虑避免它。这可能是编译器问题，还是我的误解？

(*) 我强调了导致 foldlM 出现相同内存增长的次要问题。

Answer 1

这是来自Foldable.hs (ghc) 的foldlM

-- | Monadic fold over the elements of a structure,
-- associating to the left, i.e. from left to right.
foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
foldlM f z0 xs = foldr f' return xs z0
  where f' x k z = f z x >>= k

和foldM 来自Monad.hs

foldM          :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
{-# INLINEABLE foldM #-}
{-# SPECIALISE foldM :: (a -> b -> IO a) -> a -> [b] -> IO a #-}
{-# SPECIALISE foldM :: (a -> b -> Maybe a) -> a -> [b] -> Maybe a #-}
foldM          = foldlM

我将这些定义放在一个单独的模块 Test 中，并测试了使用和不使用 INLINEABLE / SPESIALISE 行的执行情况。不管是什么原因，省略 SPECIALIZE 指令有帮助，执行时间和内存使用与 foldlM 一样。

再挖一点点，去掉线

{-# SPECIALISE foldM :: (a -> b -> IO a) -> a -> [b] -> IO a #-}

影响最大。