git.iko.soy/streamly
on dbaacea help sign in
streamly/benchmark/Array.hs
249 lines 10 kB history raw
1{-# LANGUAGE CPP #-}
2-- |
3-- Module : Main
4-- Copyright : (c) 2018 Harendra Kumar
5--
6-- License : BSD3
7-- Maintainer : harendra.kumar@gmail.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.Mem.Array as A
17import qualified Streamly.Prelude as S
19import Gauge
21-------------------------------------------------------------------------------
22--
23-------------------------------------------------------------------------------
25{-# INLINE benchPure #-}
26benchPure :: NFData b => String -> (Int -> a) -> (a -> b) -> Benchmark
27benchPure name src f = bench name $ nfIO $
28 randomRIO (1,1) >>= return . f . src
30-- Drain a source that generates a pure array
31{-# INLINE benchPureSrc #-}
32benchPureSrc :: (NFData a, Storable a)
33 => String -> (Int -> Ops.Stream a) -> Benchmark
34benchPureSrc name src = benchPure name src id
36{-# INLINE benchIO #-}
37benchIO :: NFData b => String -> (Int -> IO a) -> (a -> b) -> Benchmark
38benchIO name src f = bench name $ nfIO $
39 randomRIO (1,1) >>= src >>= return . f
41-- Drain a source that generates an array in the IO monad
42{-# INLINE benchIOSrc #-}
43benchIOSrc :: (NFData a, Storable a)
44 => String -> (Int -> IO (Ops.Stream a)) -> Benchmark
45benchIOSrc name src = benchIO name src id
47{-# INLINE benchPureSink #-}
48benchPureSink :: NFData b => String -> (Ops.Stream Int -> b) -> Benchmark
49benchPureSink name f = benchIO name Ops.sourceIntFromTo f
51{-# INLINE benchIO' #-}
52benchIO' :: NFData b => String -> (Int -> IO a) -> (a -> IO b) -> Benchmark
53benchIO' name src f = bench name $ nfIO $
54 randomRIO (1,1) >>= src >>= f
56{-# INLINE benchIOSink #-}
57benchIOSink :: NFData b => String -> (Ops.Stream Int -> IO b) -> Benchmark
58benchIOSink name f = benchIO' name Ops.sourceIntFromTo f
60mkString :: String
61mkString = "[1" ++ concat (replicate Ops.value ",1") ++ "]"
63main :: IO ()
64main =
65 defaultMain
66 [ bgroup "array"
67 [ bgroup "generation"
68 [ benchIOSrc "writeN . intFromTo" Ops.sourceIntFromTo
69 , benchIOSrc "write . intFromTo" Ops.sourceIntFromToFromStream
70 , benchIOSrc "fromList . intFromTo" Ops.sourceIntFromToFromList
71 , benchIOSrc "writeN . unfoldr" Ops.sourceUnfoldr
72 , benchIOSrc "writeN . fromList" Ops.sourceFromList
73 , benchPureSrc "writeN . IsList.fromList" Ops.sourceIsList
74 , benchPureSrc "writeN . IsString.fromString" Ops.sourceIsString
75 , mkString `deepseq` (bench "read" $ nf Ops.readInstance mkString)
76 , benchPureSink "show" Ops.showInstance
77 ]
78 , bgroup "elimination"
79 [ benchPureSink "id" id
80 -- , benchPureSink "eqBy" Ops.eqBy
81 , benchPureSink "==" Ops.eqInstance
82 , benchPureSink "/=" Ops.eqInstanceNotEq
83 {-
84 , benchPureSink "cmpBy" Ops.cmpBy
85 -}
86 , benchPureSink "<" Ops.ordInstance
87 , benchPureSink "min" Ops.ordInstanceMin
88 , benchPureSink "IsList.toList" GHC.toList
89 , benchIOSink "foldl'" Ops.pureFoldl'
90 , benchIOSink "read" (S.drain . A.read)
91 , benchIOSink "readRev" (S.drain . A.readRev)
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 ]