寻找字节串终止符的函数的 Haskell 优化

Question

对某些代码的分析表明，大约 65% 的时间我都在以下代码中。

它的作用是使用 Data.Binary.Get monad 遍历一个字节串来寻找终止符。如果检测到 0xff，则检查下一个字节是否为 0x00。如果是，它会丢弃 0x00 并继续。如果它不是 0x00，那么它会丢弃两个字节，并将生成的字节列表转换为字节串并返回。

有什么明显的优化方法吗？我看不到。

parseECS = f [] False
    where
    f acc ff = do
        b <- getWord8
        if ff
            then if b == 0x00
                then f (0xff:acc) False
                else return $ L.pack (reverse acc)
            else if b == 0xff
                then f acc True
                else f (b:acc) False

Answer 1

错误修复

这里似乎有一个错误。如果您在找到 0xff 而不是 0x00 序列之前到达字节流的末尾，则会引发异常。这是您的函数的修改版本：

parseECS :: Get L.ByteString
parseECS = f [] False
  where
    f acc ff = do
      noMore <- isEmpty
      if noMore
         then return $ L.pack (reverse acc)
         else do
           b <- getWord8
           if ff
              then
                if b == 0x00
                   then f (0xff:acc) False
                   else return $ L.pack (reverse acc)
              else
                if b == 0xff
                   then f acc True
                   else f (b:acc) False

优化

我没有进行任何分析，但这个功能可能会更快。反转长列表是昂贵的。我不确定getRemainingLazyByteString 有多懒惰。如果太严格，这可能不适合你。

parseECS2 :: Get L.ByteString
parseECS2 = do
    wx <- liftM L.unpack $ getRemainingLazyByteString
    return . L.pack . go $ wx
  where
    go []             = []
    go (0xff:0x00:wx) = 0xff : go wx
    go (0xff:_)      = []
    go (w:wx)         = w : go wx

Answer 2

如果问题出在“反向”中，您可以使用“lookAhead”扫描位置，然后返回并重建新字符串

parseECS2 :: Get L.ByteString
parseECS2 = do
    let nextWord8 = do
            noMore <- isEmpty
            if noMore then return Nothing
                      else liftM Just getWord8

    let scanChunk !n = do
            b <- nextWord8
            case b of
                Just 0xff -> return (Right (n+1))
                Just _ -> scanChunk (n+1)
                Nothing -> return (Left n)

    let readChunks = do
            c <- lookAhead (scanChunk 0)
            case c of
                Left n -> getLazyByteString n >>= \blk -> return [blk]
                Right n -> do
                    blk <- getLazyByteString n
                    b <- lookAhead nextWord8
                    case b of
                        Just 0x00 -> skip 1 >> liftM (blk:) readChunks
                        _ -> return [L.init blk]

    liftM (foldr L.append L.empty) readChunks