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