git.iko.soy/streamly
on 745265e help sign in
streamly/benchmark/Streamly/Benchmark/Memory/Array.hs
252 lines 10 kB history raw
1{-# LANGUAGE CPP #-}
2-- |
3-- Module : Main
4-- Copyright : (c) 2018 Harendra Kumar
5--
6-- License : BSD3
7-- Maintainer : streamly@composewell.com
9import Control.DeepSeq (NFData(..), deepseq)
10import Foreign.Storable (Storable(..))
11import System.Random (randomRIO)
13import qualified GHC.Exts as GHC
15import qualified Streamly.Benchmark.Memory.ArrayOps as Ops
16import qualified Streamly.Internal.Memory.Array as IA
17import qualified Streamly.Memory.Array as A
18import qualified Streamly.Prelude as S
20import Streamly.Benchmark.Common hiding (benchPureSrc)
21import Gauge
23-------------------------------------------------------------------------------
24--
25-------------------------------------------------------------------------------
27-- Drain a source that generates a pure array
28{-# INLINE benchPureSrc #-}
29benchPureSrc :: (NFData a, Storable a)
30 => String -> (Int -> Ops.Stream a) -> Benchmark
31benchPureSrc name src = benchPure name src id
33{-# INLINE benchIO #-}
34benchIO :: NFData b => String -> (Int -> IO a) -> (a -> b) -> Benchmark
35benchIO name src f = bench name $ nfIO $
36 randomRIO (1,1) >>= src >>= return . f
38-- Drain a source that generates an array in the IO monad
39{-# INLINE benchIOSrc #-}
40benchIOSrc :: (NFData a, Storable a)
41 => String -> (Int -> IO (Ops.Stream a)) -> Benchmark
42benchIOSrc name src = benchIO name src id
44{-# INLINE benchPureSink #-}
45benchPureSink :: NFData b => String -> (Ops.Stream Int -> b) -> Benchmark
46benchPureSink name f = benchIO name Ops.sourceIntFromTo f
48{-# INLINE benchIO' #-}
49benchIO' :: NFData b => String -> (Int -> IO a) -> (a -> IO b) -> Benchmark
50benchIO' name src f = bench name $ nfIO $
51 randomRIO (1,1) >>= src >>= f
53{-# INLINE benchIOSink #-}
54benchIOSink :: NFData b => String -> (Ops.Stream Int -> IO b) -> Benchmark
55benchIOSink name f = benchIO' name Ops.sourceIntFromTo f
57testStr :: String
58testStr = mkListString Ops.value
60moduleName :: String
61moduleName = "Memory.Array"
63o_1_space :: [Benchmark]
64o_1_space =
65 [ bgroup (o_1_space_prefix moduleName)
66 [ bgroup "generation"
67 [ benchIOSrc "writeN . intFromTo" Ops.sourceIntFromTo
68 , benchIOSrc "write . intFromTo" Ops.sourceIntFromToFromStream
69 , benchIOSrc "fromList . intFromTo" Ops.sourceIntFromToFromList
70 , benchIOSrc "writeN . unfoldr" Ops.sourceUnfoldr
71 , benchIOSrc "writeN . fromList" Ops.sourceFromList
72 , benchPureSrc "writeN . IsList.fromList" Ops.sourceIsList
73 , benchPureSrc "writeN . IsString.fromString" Ops.sourceIsString
74 , testStr `deepseq` (bench "read" $ nf Ops.readInstance testStr)
75 , benchPureSink "show" Ops.showInstance
76 ]
77 , bgroup "elimination"
78 [ benchPureSink "id" id
79 -- , benchPureSink "eqBy" Ops.eqBy
80 , benchPureSink "==" Ops.eqInstance
81 , benchPureSink "/=" Ops.eqInstanceNotEq
82 {-
83 , benchPureSink "cmpBy" Ops.cmpBy
84 -}
85 , benchPureSink "<" Ops.ordInstance
86 , benchPureSink "min" Ops.ordInstanceMin
87 -- length is used to check for foldr/build fusion
88 , benchPureSink "length . IsList.toList" (length . GHC.toList)
89 , benchIOSink "foldl'" Ops.pureFoldl'
90 , benchIOSink "read" (S.drain . S.unfold A.read)
91 , benchIOSink "toStreamRev" (S.drain . IA.toStreamRev)
92#ifdef DEVBUILD
93 , benchPureSink "foldable/foldl'" Ops.foldableFoldl'
94 , benchPureSink "foldable/sum" Ops.foldableSum
95 -- , benchPureSinkIO "traversable/mapM" Ops.traversableMapM
96#endif
97 ]
99 {-
100 [ benchPureSink "uncons" Ops.uncons
101 , benchPureSink "toNull" $ Ops.toNull serially
102 , benchPureSink "mapM_" Ops.mapM_
104 , benchPureSink "init" Ops.init
105 , benchPureSink "tail" Ops.tail
106 , benchPureSink "nullHeadTail" Ops.nullHeadTail
108 -- this is too low and causes all benchmarks reported in ns
109 -- , benchPureSink "head" Ops.head
110 , benchPureSink "last" Ops.last
111 -- , benchPureSink "lookup" Ops.lookup
112 , benchPureSink "find" Ops.find
113 , benchPureSink "findIndex" Ops.findIndex
114 , benchPureSink "elemIndex" Ops.elemIndex
116 -- this is too low and causes all benchmarks reported in ns
117 -- , benchPureSink "null" Ops.null
118 , benchPureSink "elem" Ops.elem
119 , benchPureSink "notElem" Ops.notElem
120 , benchPureSink "all" Ops.all
121 , benchPureSink "any" Ops.any
122 , benchPureSink "and" Ops.and
123 , benchPureSink "or" Ops.or
125 , benchPureSink "length" Ops.length
126 , benchPureSink "sum" Ops.sum
127 , benchPureSink "product" Ops.product
129 , benchPureSink "maximumBy" Ops.maximumBy
130 , benchPureSink "maximum" Ops.maximum
131 , benchPureSink "minimumBy" Ops.minimumBy
132 , benchPureSink "minimum" Ops.minimum
134 , benchPureSink "toList" Ops.toList
135 , benchPureSink "toRevList" Ops.toRevList
136 ]
137 -}
138 , bgroup "transformation"
139 [ benchIOSink "scanl'" (Ops.scanl' 1)
140 , benchIOSink "scanl1'" (Ops.scanl1' 1)
141 , benchIOSink "map" (Ops.map 1)
142 {-
143 , benchPureSink "fmap" (Ops.fmap 1)
144 , benchPureSink "mapM" (Ops.mapM serially 1)
145 , benchPureSink "mapMaybe" (Ops.mapMaybe 1)
146 , benchPureSink "mapMaybeM" (Ops.mapMaybeM 1)
147 , bench "sequence" $ nfIO $ randomRIO (1,1000) >>= \n ->
148 Ops.sequence serially (Ops.sourceUnfoldrMAction n)
149 , benchPureSink "findIndices" (Ops.findIndices 1)
150 , benchPureSink "elemIndices" (Ops.elemIndices 1)
151 , benchPureSink "reverse" (Ops.reverse 1)
152 , benchPureSink "foldrS" (Ops.foldrS 1)
153 , benchPureSink "foldrSMap" (Ops.foldrSMap 1)
154 , benchPureSink "foldrT" (Ops.foldrT 1)
155 , benchPureSink "foldrTMap" (Ops.foldrTMap 1)
156 -}
157 ]
158 , bgroup "transformationX4"
159 [ benchIOSink "scanl'" (Ops.scanl' 4)
160 , benchIOSink "scanl1'" (Ops.scanl1' 4)
161 , benchIOSink "map" (Ops.map 4)
162 {-
163 , benchPureSink "fmap" (Ops.fmap 4)
164 , benchPureSink "mapM" (Ops.mapM serially 4)
165 , benchPureSink "mapMaybe" (Ops.mapMaybe 4)
166 , benchPureSink "mapMaybeM" (Ops.mapMaybeM 4)
167 -- , bench "sequence" $ nfIO $ randomRIO (1,1000) >>= \n ->
168 -- Ops.sequence serially (Ops.sourceUnfoldrMAction n)
169 , benchPureSink "findIndices" (Ops.findIndices 4)
170 , benchPureSink "elemIndices" (Ops.elemIndices 4)
171 -}
172 ]
173 {-
174 , bgroup "filtering"
175 [ benchPureSink "filter-even" (Ops.filterEven 1)
176 , benchPureSink "filter-all-out" (Ops.filterAllOut 1)
177 , benchPureSink "filter-all-in" (Ops.filterAllIn 1)
178 , benchPureSink "take-all" (Ops.takeAll 1)
179 , benchPureSink "takeWhile-true" (Ops.takeWhileTrue 1)
180 --, benchPureSink "takeWhileM-true" (Ops.takeWhileMTrue 1)
181 , benchPureSink "drop-one" (Ops.dropOne 1)
182 , benchPureSink "drop-all" (Ops.dropAll 1)
183 , benchPureSink "dropWhile-true" (Ops.dropWhileTrue 1)
184 --, benchPureSink "dropWhileM-true" (Ops.dropWhileMTrue 1)
185 , benchPureSink "dropWhile-false" (Ops.dropWhileFalse 1)
186 , benchPureSink "deleteBy" (Ops.deleteBy 1)
187 , benchPureSink "insertBy" (Ops.insertBy 1)
188 ]
189 , bgroup "filteringX4"
190 [ benchPureSink "filter-even" (Ops.filterEven 4)
191 , benchPureSink "filter-all-out" (Ops.filterAllOut 4)
192 , benchPureSink "filter-all-in" (Ops.filterAllIn 4)
193 , benchPureSink "take-all" (Ops.takeAll 4)
194 , benchPureSink "takeWhile-true" (Ops.takeWhileTrue 4)
195 --, benchPureSink "takeWhileM-true" (Ops.takeWhileMTrue 4)
196 , benchPureSink "drop-one" (Ops.dropOne 4)
197 , benchPureSink "drop-all" (Ops.dropAll 4)
198 , benchPureSink "dropWhile-true" (Ops.dropWhileTrue 4)
199 --, benchPureSink "dropWhileM-true" (Ops.dropWhileMTrue 4)
200 , benchPureSink "dropWhile-false" (Ops.dropWhileFalse 4)
201 , benchPureSink "deleteBy" (Ops.deleteBy 4)
202 , benchPureSink "insertBy" (Ops.insertBy 4)
203 ]
204 , bgroup "multi-stream"
205 [ benchPureSink "eqBy" Ops.eqBy
206 , benchPureSink "cmpBy" Ops.cmpBy
207 , benchPureSink "zip" Ops.zip
208 , benchPureSink "zipM" Ops.zipM
209 , benchPureSink "mergeBy" Ops.mergeBy
210 , benchPureSink "isPrefixOf" Ops.isPrefixOf
211 , benchPureSink "isSubsequenceOf" Ops.isSubsequenceOf
212 , benchPureSink "stripPrefix" Ops.stripPrefix
213 , benchPureSrc serially "concatMap" Ops.concatMap
214 ]
215 -- scanl-map and foldl-map are equivalent to the scan and fold in the foldl
216 -- library. If scan/fold followed by a map is efficient enough we may not
217 -- need monolithic implementations of these.
218 , bgroup "mixed"
219 [ benchPureSink "scanl-map" (Ops.scanMap 1)
220 , benchPureSink "foldl-map" Ops.foldl'ReduceMap
221 , benchPureSink "sum-product-fold" Ops.sumProductFold
222 , benchPureSink "sum-product-scan" Ops.sumProductScan
223 ]
224 , bgroup "mixedX4"
225 [ benchPureSink "scan-map" (Ops.scanMap 4)
226 , benchPureSink "drop-map" (Ops.dropMap 4)
227 , benchPureSink "drop-scan" (Ops.dropScan 4)
228 , benchPureSink "take-drop" (Ops.takeDrop 4)
229 , benchPureSink "take-scan" (Ops.takeScan 4)
230 , benchPureSink "take-map" (Ops.takeMap 4)
231 , benchPureSink "filter-drop" (Ops.filterDrop 4)
232 , benchPureSink "filter-take" (Ops.filterTake 4)
233 , benchPureSink "filter-scan" (Ops.filterScan 4)
234 , benchPureSink "filter-scanl1" (Ops.filterScanl1 4)
235 , benchPureSink "filter-map" (Ops.filterMap 4)
236 ]
237 , bgroup "iterated"
238 [ benchPureSrc serially "mapM" Ops.iterateMapM
239 , benchPureSrc serially "scan(1/100)" Ops.iterateScan
240 , benchPureSrc serially "scanl1(1/100)" Ops.iterateScanl1
241 , benchPureSrc serially "filterEven" Ops.iterateFilterEven
242 , benchPureSrc serially "takeAll" Ops.iterateTakeAll
243 , benchPureSrc serially "dropOne" Ops.iterateDropOne
244 , benchPureSrc serially "dropWhileFalse" Ops.iterateDropWhileFalse
245 , benchPureSrc serially "dropWhileTrue" Ops.iterateDropWhileTrue
246 ]
247 -}
248 ]
249 ]
251main :: IO ()
252main = defaultMain $ concat [o_1_space]