Haskell 用于严格bytestring的高效导管组块

这是一个后续行动。我有一个管道源代码（来自

Network.HTTP.conduct

），它是严格的

ByteString

。我希望将它们重新组合成更大的块（在另一次编码和转换为lazy bytestring之后，通过网络发送到另一个客户机）。我至少写了

chunksof

conductor，这是从上述问题的答案中得出的，似乎效果不错。我想知道在提高it性能方面是否还有进一步的空间

import Data.Conduit as C
import Control.Monad.IO.Class
import Control.Monad
import Data.Conduit.Combinators as CC
import Data.Conduit.List as CL
import Data.ByteString.Lazy as LBS hiding (putStrLn)
import Data.ByteString as BS hiding (putStrLn)

chunksOfAtLeast :: Monad m => Int -> Conduit BS.ByteString m BS.ByteString
chunksOfAtLeast chunkSize =
    loop
  where
    loop = do
        bs <- takeE chunkSize =$= ((BS.concat . ($ [])) <$> CL.fold (\front next -> front . (next:)) id)
        unless (BS.null bs) $ do
            yield bs
            loop

main = do
  yieldMany ["hello", "there", "world!"] $$ chunksOfAtLeast 8 =$ CL.mapM_ Prelude.print

导入数据。导管为C
导入控制.Monad.IO.Class
进口管制
将Data.conduct.Combinators作为CC导入
将Data.conductor.List导入为CL
导入Data.ByteString.Lazy作为LBS隐藏（putStrLn）
导入Data.ByteString作为BS隐藏（putStrLn）
chunksofest:：Monad m=>Int->conduct BS.ByteString m BS.ByteString
chunksof至少chunkSize=
环
哪里
循环=do
B前面。（下一个：））id）
除非（BS.null BS）$do
产量bs
环
main=do
Yieldmanny[“你好”，“那里”，“世界！”]$$chunksof至少8=$CL.mapM uuude.print

获得最佳性能始终是一种尝试，并对其进行基准测试的过程，因此我不能肯定地告诉您，我正在为您提供更高效的产品。这就是说，将较小的数据块组合成较大的数据块是我们的主要目标，因此利用它们可能更有效。下面是一个例子：

{-# LANGUAGE OverloadedStrings #-}
import Conduit
import Data.ByteString (ByteString)
import Data.ByteString.Builder (byteString)
import Data.Conduit.ByteString.Builder

bufferChunks :: Conduit ByteString IO ByteString
bufferChunks = mapC byteString =$= builderToByteString

main :: IO ()
main = yieldMany ["hello", "there", "world!"] $$ bufferChunks =$ mapM_C print

---

探查器说了什么？我通过

RTS-s

而不是标准微基准标记测试了这个。我获得了每个核心大约30MB/s的吞吐量（在AWS中型m3实例上）。我觉得很体面。只是好奇是否还有其他的表演技巧我也可以使用。或者如果这是最好的。