Data.Conduit.Binary.sinkHandle should not flush after every chunk

[luispedro]

The current behaviour is that sinkHandle calls hFlush after every chunk is written. This can easily lead to a performance bottleneck (see the benchmark below). In the case of using sinkFileCautious, this is particularly galling as there is no need to flush every intermediate chunk.

Removing the hFlush call results in a 4x faster process on my machine. Benchmark (create a file called input.txt before running it):

import qualified Data.ByteString as B

import qualified Data.Conduit.Combinators as CC
import qualified Data.Conduit.Binary as CB
import qualified Data.Conduit.List as CL
import qualified Data.Conduit as C
import           Data.Conduit ((.|))
import Data.Maybe (maybe)
import Data.Time
import Control.Monad.IO.Class 

import System.IO (hClose, openBinaryTempFile)
import qualified System.IO as IO


fastSinkHandle h = C.awaitForever (liftIO . B.hPut h)
fastSinkIOHandle alloc = C.bracketP alloc IO.hClose fastSinkHandle
fastSinkFile fp = fastSinkIOHandle (IO.openBinaryFile fp IO.WriteMode)

main = do
    start <- getCurrentTime
    C.runConduitRes $
        CB.sourceFile "input.txt"
            .| CB.lines
            .| CC.unlinesAscii
            .| CB.sinkFile "output.txt"
    mid <- getCurrentTime
    C.runConduitRes $
        CB.sourceFile "input.txt"
            .| CB.lines
            .| CC.unlinesAscii
            .| fastSinkFile "output.txt"
    end <- getCurrentTime
    putStrLn
        ("Data.Conduit.sinkFile: "++(show $ diffUTCTime mid start)++"\n"++
         "fastSinkFile:          "++(show $ diffUTCTime end   mid)++"\n")

[snoyberg]

I tend to agree. The change was made in b37505f. Someone (me) stupidly made the change without explaining why it was done. I think it's OK to undo it, PR welcome (but please note the change in the changelog).