@@ -60,139 +60,131 @@ benchIOSink value name f = bench name $ nfIO $ randomRIO (1,1) >>= f . source va
60-- Stream folds
60-- Stream folds
61-------------------------------------------------------------------------------
61-------------------------------------------------------------------------------
63−o_1_space_serial_folds :: Int -> [Benchmark]
63+moduleName :: String
64−o_1_space_serial_folds value =
64+moduleName = "Data.Fold"
66+o_1_space_serial_elimination :: Int -> [Benchmark]
67+o_1_space_serial_elimination value =
66− "serially"
68+ [ bgroup "serially"
67− [ bgroup
69+ [ bgroup "elimination"
69− [ benchIOSink value "drain" (S.fold FL.drain)
70+ [ benchIOSink value "drain" (S.fold FL.drain)
70− , benchIOSink value "drainN" (S.fold (IFL.drainN value))
71+ , benchIOSink value "drainN" (S.fold (IFL.drainN value))
71− , benchIOSink
72+ , benchIOSink
73− "drainWhileTrue"
74+ "drainWhileTrue"
74− (S.fold (IFL.drainWhile $ (<=) (value + 1)))
75+ (S.fold (IFL.drainWhile $ (<=) (value + 1)))
75− , benchIOSink
76+ , benchIOSink
77− "drainWhileFalse"
78+ "drainWhileFalse"
78− (S.fold (IFL.drainWhile $ (>=) (value + 1)))
79+ (S.fold (IFL.drainWhile $ (>=) (value + 1)))
79− , benchIOSink value "sink" (S.fold $ Sink.toFold Sink.drain)
80+ , benchIOSink value "sink" (S.fold $ Sink.toFold Sink.drain)
80− , benchIOSink value "last" (S.fold FL.last)
81+ , benchIOSink value "last" (S.fold FL.last)
81− , benchIOSink value "lastN.1" (S.fold (IA.lastN 1))
82+ , benchIOSink value "lastN.1" (S.fold (IA.lastN 1))
82− , benchIOSink value "lastN.10" (S.fold (IA.lastN 10))
83+ , benchIOSink value "lastN.10" (S.fold (IA.lastN 10))
83− , benchIOSink value "length" (S.fold FL.length)
84+ , benchIOSink value "length" (S.fold FL.length)
84− , benchIOSink value "sum" (S.fold FL.sum)
85+ , benchIOSink value "sum" (S.fold FL.sum)
85− , benchIOSink value "sum (foldMap)" (S.fold (FL.foldMap Sum))
86+ , benchIOSink value "sum (foldMap)" (S.fold (FL.foldMap Sum))
86− , benchIOSink value "product" (S.fold FL.product)
87+ , benchIOSink value "product" (S.fold FL.product)
87− , benchIOSink value "maximumBy" (S.fold (FL.maximumBy compare))
88+ , benchIOSink value "maximumBy" (S.fold (FL.maximumBy compare))
88− , benchIOSink value "maximum" (S.fold FL.maximum)
89+ , benchIOSink value "maximum" (S.fold FL.maximum)
89− , benchIOSink value "minimumBy" (S.fold (FL.minimumBy compare))
90+ , benchIOSink value "minimumBy" (S.fold (FL.minimumBy compare))
90− , benchIOSink value "minimum" (S.fold FL.minimum)
91+ , benchIOSink value "minimum" (S.fold FL.minimum)
91− , benchIOSink
92+ , benchIOSink
97− (S.map (fromIntegral :: Int -> Double) s))
98+ (S.map (fromIntegral :: Int -> Double) s))
98− , benchIOSink
99+ , benchIOSink
100− "variance"
101+ "variance"
103− FL.variance
104+ FL.variance
104− (S.map (fromIntegral :: Int -> Double) s))
105+ (S.map (fromIntegral :: Int -> Double) s))
105− , benchIOSink
106+ , benchIOSink
107− "stdDev"
108+ "stdDev"
110− FL.stdDev
111+ FL.stdDev
111− (S.map (fromIntegral :: Int -> Double) s))
112+ (S.map (fromIntegral :: Int -> Double) s))
112− , benchIOSink
113+ , benchIOSink
114− "mconcat"
115+ "mconcat"
115− (S.fold FL.mconcat . (S.map (Last . Just)))
116+ (S.fold FL.mconcat . (S.map (Last . Just)))
116− , benchIOSink
117+ , benchIOSink
118− "foldMap"
119+ "foldMap"
119− (S.fold (FL.foldMap (Last . Just)))
120+ (S.fold (FL.foldMap (Last . Just)))
120− , benchIOSink value "index" (S.fold (FL.index (value + 1)))
121+ , benchIOSink value "index" (S.fold (FL.index (value + 1)))
121− , benchIOSink value "head" (S.fold FL.head)
122+ , benchIOSink value "head" (S.fold FL.head)
122− , benchIOSink value "find" (S.fold (FL.find (== (value + 1))))
123+ , benchIOSink value "find" (S.fold (FL.find (== (value + 1))))
123− , benchIOSink
124+ , benchIOSink
125− "findIndex"
126+ "findIndex"
126− (S.fold (FL.findIndex (== (value + 1))))
127+ (S.fold (FL.findIndex (== (value + 1))))
127− , benchIOSink
128+ , benchIOSink
129− "elemIndex"
130+ "elemIndex"
130− (S.fold (FL.elemIndex (value + 1)))
131+ (S.fold (FL.elemIndex (value + 1)))
131− , benchIOSink value "null" (S.fold FL.null)
132+ , benchIOSink value "null" (S.fold FL.null)
132− , benchIOSink value "elem" (S.fold (FL.elem (value + 1)))
133+ , benchIOSink value "elem" (S.fold (FL.elem (value + 1)))
133− , benchIOSink value "notElem" (S.fold (FL.notElem (value + 1)))
134+ , benchIOSink value "notElem" (S.fold (FL.notElem (value + 1)))
134− , benchIOSink value "all" (S.fold (FL.all (<= (value + 1))))
135+ , benchIOSink value "all" (S.fold (FL.all (<= (value + 1))))
135− , benchIOSink value "any" (S.fold (FL.any (> (value + 1))))
136+ , benchIOSink value "any" (S.fold (FL.any (> (value + 1))))
136− , benchIOSink
137+ , benchIOSink
139− (\s -> S.fold FL.and (S.map (<= (value + 1)) s))
140+ (\s -> S.fold FL.and (S.map (<= (value + 1)) s))
140− , benchIOSink
141+ , benchIOSink
143− (\s -> S.fold FL.or (S.map (> (value + 1)) s))
144+ (\s -> S.fold FL.or (S.map (> (value + 1)) s))
149−o_1_space_serial_foldsTransforms :: Int -> [Benchmark]
150+o_1_space_serial_transformation :: Int -> [Benchmark]
150−o_1_space_serial_foldsTransforms value =
151+o_1_space_serial_transformation value =
152− "serially"
152+ [ bgroup "serially"
153− [ bgroup
153+ [ bgroup "transformation"
155− [ benchIOSink value "drain" (S.fold FL.drain)
156− , benchIOSink value "lmap" (S.fold (IFL.lmap (+ 1) FL.drain))
154+ [ benchIOSink value "lmap" (S.fold (IFL.lmap (+ 1) FL.drain))
157− , benchIOSink
155+ , benchIOSink
159− "pipe-mapM"
157+ "pipe-mapM"
161− (IFL.transform
159+ (IFL.transform
162− (Pipe.mapM (\x -> return $ x + 1))
160+ (Pipe.mapM (\x -> return $ x + 1))
163− FL.drain))
161+ FL.drain))
168−
166+o_1_space_serial_composition :: Int -> [Benchmark]
169−o_1_space_serial_foldsCompositions :: Int -> [Benchmark]
167+o_1_space_serial_composition value =
170−o_1_space_serial_foldsCompositions value =
172− "serially"
168+ [ bgroup "serially"
173− [ bgroup
169+ [ bgroup "composition" -- Applicative
174− "folds-compositions" -- Applicative
175− [ benchIOSink
170+ [ benchIOSink
177− "all,any"
172+ "all,any"
179− ((,) <$> FL.all (<= (value + 1)) <*>
174+ ((,) <$> FL.all (<= (value + 1)) <*>
180− FL.any (> (value + 1))))
175+ FL.any (> (value + 1))))
181− , benchIOSink
176+ , benchIOSink
183− "sum,length"
178+ "sum,length"
184− (S.fold ((,) <$> FL.sum <*> FL.length))
179+ (S.fold ((,) <$> FL.sum <*> FL.length))
190−o_n_heap_serial_folds :: Int -> [Benchmark]
184+o_n_heap_serial :: Int -> [Benchmark]
191−o_n_heap_serial_folds value =
185+o_n_heap_serial value =
193− "serially"
186+ [ bgroup "serially"
194− [ bgroup
187+ [ bgroup "elimination"
196 -- Left folds for building a structure are inherently non-streaming
188 -- Left folds for building a structure are inherently non-streaming
197 -- as the structure cannot be lazily consumed until fully built.
189 -- as the structure cannot be lazily consumed until fully built.
198 [ benchIOSink value "toStream" (S.fold IP.toStream)
190 [ benchIOSink value "toStream" (S.fold IP.toStream)
@@ -212,20 +204,17 @@ o_n_heap_serial_folds value =
213main :: IO ()
205main :: IO ()
215− (value, cfg, benches) <- parseCLIOpts defaultStreamSize
207+ (value, cfg, benches) <- parseCLIOpts defaultStreamSize
216− value `seq` runMode (mode cfg) cfg benches (allBenchmarks value)
208+ value `seq` runMode (mode cfg) cfg benches (allBenchmarks value)
218 allBenchmarks value =
212 allBenchmarks value =
219− [ bgroup
213+ [ bgroup (o_1_space_prefix moduleName) $ concat
220− "o-1-space"
214+ [ o_1_space_serial_elimination value
221− [ bgroup "fold" $
215+ , o_1_space_serial_transformation value
222− concat
216+ , o_1_space_serial_composition value
223− [ o_1_space_serial_folds value
224− , o_1_space_serial_foldsTransforms value
225− , o_1_space_serial_foldsCompositions value
228− , bgroup
218+ , bgroup (o_n_heap_prefix moduleName) $ concat
229− "o-n-heap"
219+ [ o_n_heap_serial value ]
230− [bgroup "fold" $ concat [o_n_heap_serial_folds value]]