Haskell中用于调试与基准测试的函数调用追踪方法有哪些

现有Debug.Trace的固有问题 #

你目前使用的Debug.Trace模块本质是基于unsafePerformIO的手动插桩，两个核心问题会破坏追踪的确定性：

• GHC优化器不会将trace的日志输出判定为不可消除的副作用，高优化等级下可能直接移除调用点，或者将其提升到错误的求值位置
• 惰性求值的特性会导致trace的触发时机完全依赖后续的求值需求，和实际的函数调用顺序没有强绑定，追踪结果不稳定，无法支撑原始算法性能的基准测试

不受优化干扰的手动插桩方案 #

要实现完全不受GHC优化影响的追踪，只需要在原有trace的逻辑上做两个关键调整：

• 对所有追踪相关的函数、全局日志引用添加{-# NOINLINE <名称> #-}编译指令，强制GHC在优化阶段不要内联、不要折叠消除这些调用点
• 用内存中的可变引用（IORef）存储追踪日志，避免直接的终端IO因为缓冲、调度问题打乱执行顺序

对应你给出的测试代码的可运行实现：

import System.IO.Unsafe (unsafePerformIO)
import Data.IORef
import Control.DeepSeq (force)
import Control.Exception (evaluate)

-- 全局日志存储，禁止GHC优化消除
logRef :: IORef [String]
logRef = unsafePerformIO (newIORef [])
{-# NOINLINE logRef #-}

-- 确定性追踪函数，不会被优化移除
track :: String -> a -> a
track msg val = unsafePerformIO $ do
  modifyIORef' logRef (msg :)
  return val
{-# NOINLINE track #-}

-- 重写原有计算逻辑
heavyComputation :: Int -> Int
heavyComputation x = track ("heavyComputation " ++ show x) (x + 1)

addition :: Int -> Int -> Int
addition a b = track ("addition " ++ show a ++ " " ++ show b) (a + b)

impl1 :: [Int]
impl1 = track "Impl1" [heavyComputation i | i <- [0..5]]

impl2 :: [Int]
impl2 = track "Impl2" $
  let n = heavyComputation 0
  in [i `addition` n | i <- [0..5]]

-- 清空日志并强制求值目标实现，得到完整调用序列
runTrace :: NFData a => a -> IO [String]
runTrace target = do
  writeIORef logRef []
  _ <- evaluate (force target)
  reverse <$> readIORef logRef

运行runTrace impl2就会得到和示例要求完全一致的输出：

["Impl2", "heavyComputation 0", "addition 0 1", "addition 1 1", "addition 2 1", "addition 3 1", "addition 4 1", "addition 5 1"]

这个方案的执行结果完全不受GHC优化等级的影响，因为NOINLINE指令从编译层面阻断了优化器对追踪调用的移除操作，和实际运行时的计算顺序完全对齐。

Writer Monad 纯风格追踪方案 #

不需要依赖形式化正确性证明的Writer实现，只需要严格对齐实际求值顺序即可：

• 直接使用严格版的Writer Monad，避免惰性累积导致的日志顺序错乱
• 不需要验证Monad的代数定律，只要确保日志记录的触发时机和值的绑定时机一致即可

对应示例的Writer版本实现：

import Control.Monad.Writer.Strict (Writer, tell, runWriter)

heavyComputationW :: Int -> Writer [String] Int
heavyComputationW x = do
  tell ["heavyComputation " ++ show x]
  return (x + 1)

additionW :: Int -> Int -> Writer [String] Int
additionW a b = do
  tell ["addition " ++ show a ++ " " ++ show b]
  return (a + b)

impl2W :: Writer [String] [Int]
impl2W = do
  n <- heavyComputationW 0
  sequence [additionW i n | i <- [0..5]]

-- 运行后可直接拆分得到计算结果和完整调用序列
-- runWriter impl2W = (结果列表, 调用序列列表)

这种方案的优势是追踪逻辑和业务逻辑完全解耦，不需要依赖unsafePerformIO，但要注意在大日志量场景下，严格Writer的内存开销会比手动插桩稍高，适合做逻辑正确性的追踪，手动插桩的方案更适合需要稳定性能基准的场景。

基准测试场景注意事项 #

• 追踪插桩的代码要单独编译版本，不要把追踪的开销算到算法本身的性能测试结果里
• 如果需要验证追踪结果的可靠性，可以对比手动插桩和Writer版本的输出是否完全一致，不需要依赖形式化证明就能确认结果和GHC实际运行行为对齐

内容的提问来源于stack exchange，提问作者thoughtpolice