git.iko.soy/streamly
on 616f034 help sign in
streamly/benchmark/Streamly/Benchmark/FileSystem/Handle/ReadWrite.hs
215 lines 7.2 kB history raw
1-- |
2-- Module : Streamly.Benchmark.FileSystem.Handle
3-- Copyright : (c) 2019 Composewell Technologies
4-- License : BSD3-3-Clause
5-- Maintainer : streamly@composewell.com
6-- Stability : experimental
7-- Portability : GHC
9{-# LANGUAGE CPP #-}
10{-# LANGUAGE ScopedTypeVariables #-}
12#ifdef __HADDOCK_VERSION__
13#undef INSPECTION
14#endif
16#ifdef INSPECTION
17{-# LANGUAGE TemplateHaskell #-}
18{-# OPTIONS_GHC -fplugin Test.Inspection.Plugin #-}
19#endif
21module Handle.ReadWrite
22 (allBenchmarks)
23where
25import System.IO (Handle)
26import Prelude hiding (last, length)
27import Streamly.Internal.System.IO (defaultChunkSize)
29import qualified Streamly.FileSystem.Handle as FH
30import qualified Streamly.Internal.Data.Unfold as IUF
31import qualified Streamly.Internal.FileSystem.Handle as IFH
32import qualified Streamly.Data.Array.Foreign as A
33import qualified Streamly.Prelude as S
35import Gauge hiding (env)
36import Streamly.Benchmark.Common.Handle
38#ifdef INSPECTION
39import Streamly.Internal.Data.Stream.StreamD.Type (Step(..))
41import qualified Streamly.Internal.Data.Stream.StreamD.Type as D
42import qualified Streamly.Internal.Data.Tuple.Strict as Strict
43import qualified Streamly.Internal.Data.Array.Stream.Mut.Foreign as MAS
44import qualified Streamly.Internal.Data.Array.Foreign.Type as AT
45import qualified Streamly.Internal.Data.Array.Foreign.Mut.Type as MA
47import Test.Inspection
48#endif
50-------------------------------------------------------------------------------
51-- copy chunked
52-------------------------------------------------------------------------------
54-- | Copy file
55copyChunks :: Handle -> Handle -> IO ()
56copyChunks inh outh = S.fold (IFH.writeChunks outh) $ IFH.toChunks inh
58#ifdef INSPECTION
59inspect $ hasNoTypeClasses 'copyChunks
60inspect $ 'copyChunks `hasNoType` ''Step
61#endif
63o_1_space_copy_chunked :: BenchEnv -> [Benchmark]
64o_1_space_copy_chunked env =
65 [ bgroup "copy/toChunks"
66 [ mkBench "toNull" env $ \inH _ ->
67 copyChunks inH (nullH env)
68 , mkBench "raw" env $ \inH outH ->
69 copyChunks inH outH
70 ]
71 ]
73-------------------------------------------------------------------------------
74-- copy unfold
75-------------------------------------------------------------------------------
77-- | Copy file
78copyStream :: Handle -> Handle -> IO ()
79copyStream inh outh = S.fold (FH.write outh) (S.unfold FH.read inh)
81#ifdef INSPECTION
82inspect $ hasNoTypeClasses 'copyStream
83inspect $ 'copyStream `hasNoType` ''Step -- S.unfold
84inspect $ 'copyStream `hasNoType` ''IUF.ConcatState -- FH.read/UF.many
85inspect $ 'copyStream `hasNoType` ''MA.ReadUState -- FH.read/A.read
86inspect $ 'copyStream `hasNoType` ''AT.ArrayUnsafe -- FH.write/writeNUnsafe
87inspect $ 'copyStream `hasNoType` ''Strict.Tuple3' -- FH.write/chunksOf
88#endif
90o_1_space_copy_read :: BenchEnv -> [Benchmark]
91o_1_space_copy_read env =
92 [ bgroup "copy/read"
93 [ mkBench "rawToNull" env $ \inh _ ->
94 copyStream inh (nullH env)
95 , mkBench "rawToFile" env $ \inh outh ->
96 copyStream inh outh
97 ]
98 ]
100-------------------------------------------------------------------------------
101-- copy stream
102-------------------------------------------------------------------------------
104-- | Send the file contents to /dev/null
105readFromBytesNull :: Handle -> Handle -> IO ()
106readFromBytesNull inh devNull = IFH.putBytes devNull $ S.unfold FH.read inh
108#ifdef INSPECTION
109inspect $ hasNoTypeClasses 'readFromBytesNull
110inspect $ 'readFromBytesNull `hasNoType` ''Step
111inspect $ 'readFromBytesNull `hasNoType` ''MAS.SpliceState
112inspect $ 'readFromBytesNull `hasNoType` ''AT.ArrayUnsafe -- FH.fromBytes/S.arraysOf
113inspect $ 'readFromBytesNull `hasNoType` ''D.FoldMany
114#endif
116-- | Send the file contents ('defaultChunkSize') to /dev/null
117readWithBufferOfFromBytesNull :: Handle -> Handle -> IO ()
118readWithBufferOfFromBytesNull inh devNull =
119 IFH.putBytes devNull
120 $ S.unfold FH.readWithBufferOf (defaultChunkSize, inh)
122#ifdef INSPECTION
123inspect $ hasNoTypeClasses 'readWithBufferOfFromBytesNull
124inspect $ 'readWithBufferOfFromBytesNull `hasNoType` ''Step
125inspect $ 'readWithBufferOfFromBytesNull `hasNoType` ''MAS.SpliceState
126inspect $ 'readWithBufferOfFromBytesNull `hasNoType` ''AT.ArrayUnsafe -- FH.fromBytes/S.arraysOf
127inspect $ 'readWithBufferOfFromBytesNull `hasNoType` ''D.FoldMany
128#endif
130-- | Send the chunk content ('defaultChunkSize') to /dev/null
131-- Implicitly benchmarked via 'readFromBytesNull'
132_readChunks :: Handle -> Handle -> IO ()
133_readChunks inh devNull = IUF.fold fld unf inh
135 where
137 fld = FH.write devNull
138 unf = IUF.many A.read FH.readChunks
140-- | Send the chunk content to /dev/null
141-- Implicitly benchmarked via 'readWithBufferOfFromBytesNull'
142_readChunksWithBufferOf :: Handle -> Handle -> IO ()
143_readChunksWithBufferOf inh devNull = IUF.fold fld unf (defaultChunkSize, inh)
145 where
147 fld = FH.write devNull
148 unf = IUF.many A.read FH.readChunksWithBufferOf
151o_1_space_copy_fromBytes :: BenchEnv -> [Benchmark]
152o_1_space_copy_fromBytes env =
153 [ bgroup "copy/putBytes"
154 [ mkBench "rawToNull" env $ \inh _ ->
155 readFromBytesNull inh (nullH env)
156 , mkBench "FH.readWithBufferOf" env $ \inh _ ->
157 readWithBufferOfFromBytesNull inh (nullH env)
158 ]
159 ]
161-- | Send the file contents ('defaultChunkSize') to /dev/null
162writeReadWithBufferOf :: Handle -> Handle -> IO ()
163writeReadWithBufferOf inh devNull = IUF.fold fld unf (defaultChunkSize, inh)
165 where
167 fld = FH.writeWithBufferOf defaultChunkSize devNull
168 unf = FH.readWithBufferOf
170#ifdef INSPECTION
171inspect $ hasNoTypeClasses 'writeReadWithBufferOf
172inspect $ 'writeReadWithBufferOf `hasNoType` ''Step
173inspect $ 'writeReadWithBufferOf `hasNoType` ''IUF.ConcatState -- FH.read/UF.many
174inspect $ 'writeReadWithBufferOf `hasNoType` ''MA.ReadUState -- FH.read/A.read
175inspect $ 'writeReadWithBufferOf `hasNoType` ''AT.ArrayUnsafe -- FH.write/writeNUnsafe
176#endif
178-- | Send the file contents ('AT.defaultChunkSize') to /dev/null
179writeRead :: Handle -> Handle -> IO ()
180writeRead inh devNull = IUF.fold fld unf inh
182 where
184 fld = FH.write devNull
185 unf = FH.read
187#ifdef INSPECTION
188inspect $ hasNoTypeClasses 'writeRead
189inspect $ 'writeRead `hasNoType` ''Step
190inspect $ 'writeRead `hasNoType` ''IUF.ConcatState -- FH.read/UF.many
191inspect $ 'writeRead `hasNoType` ''MA.ReadUState -- FH.read/A.read
192inspect $ 'writeRead `hasNoType` ''AT.ArrayUnsafe -- FH.write/writeNUnsafe
193#endif
195o_1_space_copy :: BenchEnv -> [Benchmark]
196o_1_space_copy env =
197 [ bgroup "copy"
198 [ mkBench "FH.write . FH.read" env $ \inh _ ->
199 writeRead inh (nullH env)
200 , mkBench "FH.writeWithBufferOf . FH.readWithBufferOf" env $ \inh _ ->
201 writeReadWithBufferOf inh (nullH env)
202 ]
203 ]
205-------------------------------------------------------------------------------
206--
207-------------------------------------------------------------------------------
209allBenchmarks :: BenchEnv -> [Benchmark]
210allBenchmarks env = Prelude.concat
211 [ o_1_space_copy_chunked env
212 , o_1_space_copy_read env
213 , o_1_space_copy_fromBytes env
214 , o_1_space_copy env
215 ]