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