git.iko.soy/streamly
on master help sign in
Move global limits into function arguments in bench:StreamK
23253c0Adithya Kumar
benchmark/Streamly/Benchmark/Data/Stream/StreamK.hs+172−155
compare with master
unifiedsplit
@@ -40,13 +40,6 @@ import Streamly.Benchmark.Common
40import Test.Inspection
40import Test.Inspection
41#endif
41#endif
42
42
43−value, value2, value3, value16, maxValue :: Int
44−value = 100000
45−value2 = round (P.fromIntegral value**(1/2::P.Double)) -- double nested loop
46−value3 = round (P.fromIntegral value**(1/3::P.Double)) -- triple nested loop
47−value16 = round (P.fromIntegral value**(1/16::P.Double)) -- triple nested loop
48−maxValue = value
49−
50-------------------------------------------------------------------------------
43-------------------------------------------------------------------------------
51-- Stream generation and elimination
44-- Stream generation and elimination
52-------------------------------------------------------------------------------
45-------------------------------------------------------------------------------
@@ -54,8 +47,8 @@ maxValue = value
54type Stream m a = S.Stream m a
47type Stream m a = S.Stream m a
55
48
56{-# INLINE sourceUnfoldr #-}
49{-# INLINE sourceUnfoldr #-}
57−sourceUnfoldr :: Int -> Stream m Int
50+sourceUnfoldr :: Int -> Int -> Stream m Int
58−sourceUnfoldr n = S.unfoldr step n
51+sourceUnfoldr value n = S.unfoldr step n
59 where
52 where
60 step cnt =
53 step cnt =
61 if cnt > n + value
54 if cnt > n + value
@@ -72,8 +65,8 @@ sourceUnfoldrN m n = S.unfoldr step n
72 else Just (cnt, cnt + 1)
65 else Just (cnt, cnt + 1)
73
66
74{-# INLINE sourceUnfoldrM #-}
67{-# INLINE sourceUnfoldrM #-}
75−sourceUnfoldrM :: S.MonadAsync m => Int -> Stream m Int
68+sourceUnfoldrM :: S.MonadAsync m => Int -> Int -> Stream m Int
76−sourceUnfoldrM n = S.unfoldrM step n
69+sourceUnfoldrM value n = S.unfoldrM step n
77 where
70 where
78 step cnt =
71 step cnt =
79 if cnt > n + value
72 if cnt > n + value
@@ -90,12 +83,12 @@ sourceUnfoldrMN m n = S.unfoldrM step n
90 else return (Just (cnt, cnt + 1))
83 else return (Just (cnt, cnt + 1))
91
84
92{-# INLINE sourceFromFoldable #-}
85{-# INLINE sourceFromFoldable #-}
93−sourceFromFoldable :: Int -> Stream m Int
86+sourceFromFoldable :: Int -> Int -> Stream m Int
94−sourceFromFoldable n = S.fromFoldable [n..n+value]
87+sourceFromFoldable value n = S.fromFoldable [n..n+value]
95
88
96{-# INLINE sourceFromFoldableM #-}
89{-# INLINE sourceFromFoldableM #-}
97−sourceFromFoldableM :: S.MonadAsync m => Int -> Stream m Int
90+sourceFromFoldableM :: S.MonadAsync m => Int -> Int -> Stream m Int
98−sourceFromFoldableM n =
91+sourceFromFoldableM value n =
99 Prelude.foldr S.consM S.nil (Prelude.fmap return [n..n+value])
92 Prelude.foldr S.consM S.nil (Prelude.fmap return [n..n+value])
100
93
101{-# INLINABLE concatMapFoldableWith #-}
94{-# INLINABLE concatMapFoldableWith #-}
@@ -104,12 +97,12 @@ concatMapFoldableWith :: (S.IsStream t, Foldable f)
104concatMapFoldableWith f g = Prelude.foldr (f . g) S.nil
97concatMapFoldableWith f g = Prelude.foldr (f . g) S.nil
105
98
106{-# INLINE sourceFoldMapWith #-}
99{-# INLINE sourceFoldMapWith #-}
107−sourceFoldMapWith :: Int -> Stream m Int
100+sourceFoldMapWith :: Int -> Int -> Stream m Int
108−sourceFoldMapWith n = concatMapFoldableWith S.serial S.yield [n..n+value]
101+sourceFoldMapWith value n = concatMapFoldableWith S.serial S.yield [n..n+value]
109
102
110{-# INLINE sourceFoldMapWithM #-}
103{-# INLINE sourceFoldMapWithM #-}
111−sourceFoldMapWithM :: Monad m => Int -> Stream m Int
104+sourceFoldMapWithM :: Monad m => Int -> Int -> Stream m Int
112−sourceFoldMapWithM n =
105+sourceFoldMapWithM value n =
113 concatMapFoldableWith S.serial (S.yieldM . return) [n..n+value]
106 concatMapFoldableWith S.serial (S.yieldM . return) [n..n+value]
114
107
115-------------------------------------------------------------------------------
108-------------------------------------------------------------------------------
@@ -216,36 +209,36 @@ filterEven :: Monad m => Int -> Stream m Int -> m ()
216filterEven n = composeN n $ S.filter even
209filterEven n = composeN n $ S.filter even
217
210
218{-# INLINE filterAllOut #-}
211{-# INLINE filterAllOut #-}
219−filterAllOut :: Monad m => Int -> Stream m Int -> m ()
212+filterAllOut :: Monad m => Int -> Int -> Stream m Int -> m ()
220−filterAllOut n = composeN n $ S.filter (> maxValue)
213+filterAllOut maxValue n = composeN n $ S.filter (> maxValue)
221
214
222{-# INLINE filterAllIn #-}
215{-# INLINE filterAllIn #-}
223−filterAllIn :: Monad m => Int -> Stream m Int -> m ()
216+filterAllIn :: Monad m => Int -> Int -> Stream m Int -> m ()
224−filterAllIn n = composeN n $ S.filter (<= maxValue)
217+filterAllIn maxValue n = composeN n $ S.filter (<= maxValue)
225
218
226{-# INLINE _takeOne #-}
219{-# INLINE _takeOne #-}
227_takeOne :: Monad m => Int -> Stream m Int -> m ()
220_takeOne :: Monad m => Int -> Stream m Int -> m ()
228_takeOne n = composeN n $ S.take 1
221_takeOne n = composeN n $ S.take 1
229
222
230{-# INLINE takeAll #-}
223{-# INLINE takeAll #-}
231−takeAll :: Monad m => Int -> Stream m Int -> m ()
224+takeAll :: Monad m => Int -> Int -> Stream m Int -> m ()
232−takeAll n = composeN n $ S.take maxValue
225+takeAll maxValue n = composeN n $ S.take maxValue
233
226
234{-# INLINE takeWhileTrue #-}
227{-# INLINE takeWhileTrue #-}
235−takeWhileTrue :: Monad m => Int -> Stream m Int -> m ()
228+takeWhileTrue :: Monad m => Int -> Int -> Stream m Int -> m ()
236−takeWhileTrue n = composeN n $ S.takeWhile (<= maxValue)
229+takeWhileTrue maxValue n = composeN n $ S.takeWhile (<= maxValue)
237
230
238{-# INLINE dropOne #-}
231{-# INLINE dropOne #-}
239dropOne :: Monad m => Int -> Stream m Int -> m ()
232dropOne :: Monad m => Int -> Stream m Int -> m ()
240dropOne n = composeN n $ S.drop 1
233dropOne n = composeN n $ S.drop 1
241
234
242{-# INLINE dropAll #-}
235{-# INLINE dropAll #-}
243−dropAll :: Monad m => Int -> Stream m Int -> m ()
236+dropAll :: Monad m => Int -> Int -> Stream m Int -> m ()
244−dropAll n = composeN n $ S.drop maxValue
237+dropAll maxValue n = composeN n $ S.drop maxValue
245
238
246{-# INLINE dropWhileTrue #-}
239{-# INLINE dropWhileTrue #-}
247−dropWhileTrue :: Monad m => Int -> Stream m Int -> m ()
240+dropWhileTrue :: Monad m => Int -> Int -> Stream m Int -> m ()
248−dropWhileTrue n = composeN n $ S.dropWhile (<= maxValue)
241+dropWhileTrue maxValue n = composeN n $ S.dropWhile (<= maxValue)
249
242
250{-# INLINE dropWhileFalse #-}
243{-# INLINE dropWhileFalse #-}
251dropWhileFalse :: Monad m => Int -> Stream m Int -> m ()
244dropWhileFalse :: Monad m => Int -> Stream m Int -> m ()
@@ -260,56 +253,52 @@ foldlS :: Monad m => Int -> Stream m Int -> m ()
260foldlS n = composeN n $ S.foldlS (flip S.cons) S.nil
253foldlS n = composeN n $ S.foldlS (flip S.cons) S.nil
261
254
262{-# INLINE intersperse #-}
255{-# INLINE intersperse #-}
263−intersperse :: S.MonadAsync m => Int -> Stream m Int -> m ()
256+intersperse :: S.MonadAsync m => Int -> Int -> Stream m Int -> m ()
264−intersperse n = composeN n $ S.intersperse maxValue
257+intersperse maxValue n = composeN n $ S.intersperse maxValue
265
258
266-------------------------------------------------------------------------------
259-------------------------------------------------------------------------------
267-- Iteration
260-- Iteration
268-------------------------------------------------------------------------------
261-------------------------------------------------------------------------------
269
262
270−iterStreamLen, maxIters :: Int
271−iterStreamLen = 10
272−maxIters = 10000
273−
274{-# INLINE iterateSource #-}
263{-# INLINE iterateSource #-}
275iterateSource
264iterateSource
276 :: S.MonadAsync m
265 :: S.MonadAsync m
277− => (Stream m Int -> Stream m Int) -> Int -> Int -> Stream m Int
266+ => Int -> (Stream m Int -> Stream m Int) -> Int -> Int -> Stream m Int
278−iterateSource g i n = f i (sourceUnfoldrMN iterStreamLen n)
267+iterateSource iterStreamLen g i n = f i (sourceUnfoldrMN iterStreamLen n)
279 where
268 where
280 f (0 :: Int) m = g m
269 f (0 :: Int) m = g m
281 f x m = g (f (x P.- 1) m)
270 f x m = g (f (x P.- 1) m)
282
271
283-- this is quadratic
272-- this is quadratic
284{-# INLINE iterateScan #-}
273{-# INLINE iterateScan #-}
285−iterateScan :: S.MonadAsync m => Int -> Stream m Int
274+iterateScan :: S.MonadAsync m => Int -> Int -> Int -> Stream m Int
286−iterateScan = iterateSource (S.scanl' (+) 0) (maxIters `div` 10)
275+iterateScan iterStreamLen maxIters = iterateSource iterStreamLen (S.scanl' (+) 0) (maxIters `div` 10)
287
276
288-- this is quadratic
277-- this is quadratic
289{-# INLINE iterateDropWhileFalse #-}
278{-# INLINE iterateDropWhileFalse #-}
290−iterateDropWhileFalse :: S.MonadAsync m => Int -> Stream m Int
279+iterateDropWhileFalse :: S.MonadAsync m => Int -> Int -> Int -> Int -> Stream m Int
291−iterateDropWhileFalse =
280+iterateDropWhileFalse maxValue iterStreamLen maxIters =
292− iterateSource (S.dropWhile (> maxValue)) (maxIters `div` 10)
281+ iterateSource iterStreamLen (S.dropWhile (> maxValue)) (maxIters `div` 10)
293
282
294{-# INLINE iterateMapM #-}
283{-# INLINE iterateMapM #-}
295−iterateMapM :: S.MonadAsync m => Int -> Stream m Int
284+iterateMapM :: S.MonadAsync m => Int -> Int -> Int -> Stream m Int
296−iterateMapM = iterateSource (S.mapM return) maxIters
285+iterateMapM iterStreamLen maxIters = iterateSource iterStreamLen (S.mapM return) maxIters
297
286
298{-# INLINE iterateFilterEven #-}
287{-# INLINE iterateFilterEven #-}
299−iterateFilterEven :: S.MonadAsync m => Int -> Stream m Int
288+iterateFilterEven :: S.MonadAsync m => Int -> Int -> Int -> Stream m Int
300−iterateFilterEven = iterateSource (S.filter even) maxIters
289+iterateFilterEven iterStreamLen maxIters = iterateSource iterStreamLen (S.filter even) maxIters
301
290
302{-# INLINE iterateTakeAll #-}
291{-# INLINE iterateTakeAll #-}
303−iterateTakeAll :: S.MonadAsync m => Int -> Stream m Int
292+iterateTakeAll :: S.MonadAsync m => Int -> Int -> Int -> Int -> Stream m Int
304−iterateTakeAll = iterateSource (S.take maxValue) maxIters
293+iterateTakeAll maxValue iterStreamLen maxIters = iterateSource iterStreamLen (S.take maxValue) maxIters
305
294
306{-# INLINE iterateDropOne #-}
295{-# INLINE iterateDropOne #-}
307−iterateDropOne :: S.MonadAsync m => Int -> Stream m Int
296+iterateDropOne :: S.MonadAsync m => Int -> Int -> Int -> Stream m Int
308−iterateDropOne = iterateSource (S.drop 1) maxIters
297+iterateDropOne iterStreamLen maxIters = iterateSource iterStreamLen (S.drop 1) maxIters
309
298
310{-# INLINE iterateDropWhileTrue #-}
299{-# INLINE iterateDropWhileTrue #-}
311−iterateDropWhileTrue :: S.MonadAsync m => Int -> Stream m Int
300+iterateDropWhileTrue :: S.MonadAsync m => Int -> Int -> Int -> Int -> Stream m Int
312−iterateDropWhileTrue = iterateSource (S.dropWhile (<= maxValue)) maxIters
301+iterateDropWhileTrue maxValue iterStreamLen maxIters = iterateSource iterStreamLen (S.dropWhile (<= maxValue)) maxIters
313
302
314-------------------------------------------------------------------------------
303-------------------------------------------------------------------------------
315-- Zipping
304-- Zipping
@@ -336,32 +325,33 @@ dropScan :: Monad m => Int -> Stream m Int -> m ()
336dropScan n = composeN n $ S.scanl' (+) 0 . S.drop 1
325dropScan n = composeN n $ S.scanl' (+) 0 . S.drop 1
337
326
338{-# INLINE takeDrop #-}
327{-# INLINE takeDrop #-}
339−takeDrop :: Monad m => Int -> Stream m Int -> m ()
328+takeDrop :: Monad m => Int -> Int -> Stream m Int -> m ()
340−takeDrop n = composeN n $ S.drop 1 . S.take maxValue
329+takeDrop maxValue n = composeN n $ S.drop 1 . S.take maxValue
341
330
342{-# INLINE takeScan #-}
331{-# INLINE takeScan #-}
343−takeScan :: Monad m => Int -> Stream m Int -> m ()
332+takeScan :: Monad m => Int -> Int -> Stream m Int -> m ()
344−takeScan n = composeN n $ S.scanl' (+) 0 . S.take maxValue
333+takeScan maxValue n = composeN n $ S.scanl' (+) 0 . S.take maxValue
345
334
346{-# INLINE takeMap #-}
335{-# INLINE takeMap #-}
347−takeMap :: Monad m => Int -> Stream m Int -> m ()
336+takeMap :: Monad m => Int -> Int -> Stream m Int -> m ()
348−takeMap n = composeN n $ S.map (subtract 1) . S.take maxValue
337+takeMap maxValue n = composeN n $ S.map (subtract 1) . S.take maxValue
349
338
350{-# INLINE filterDrop #-}
339{-# INLINE filterDrop #-}
351−filterDrop :: Monad m => Int -> Stream m Int -> m ()
340+filterDrop :: Monad m => Int -> Int -> Stream m Int -> m ()
352−filterDrop n = composeN n $ S.drop 1 . S.filter (<= maxValue)
341+filterDrop maxValue n = composeN n $ S.drop 1 . S.filter (<= maxValue)
353
342
354{-# INLINE filterTake #-}
343{-# INLINE filterTake #-}
355−filterTake :: Monad m => Int -> Stream m Int -> m ()
344+filterTake :: Monad m => Int -> Int -> Stream m Int -> m ()
356−filterTake n = composeN n $ S.take maxValue . S.filter (<= maxValue)
345+filterTake maxValue n = composeN n $ S.take maxValue . S.filter (<= maxValue)
357
346
347+-- Initially, this used maxBound not maxValue
358{-# INLINE filterScan #-}
348{-# INLINE filterScan #-}
359−filterScan :: Monad m => Int -> Stream m Int -> m ()
349+filterScan :: Monad m => Int -> Int -> Stream m Int -> m ()
360−filterScan n = composeN n $ S.scanl' (+) 0 . S.filter (<= maxBound)
350+filterScan maxValue n = composeN n $ S.scanl' (+) 0 . S.filter (<= maxValue)
361
351
362{-# INLINE filterMap #-}
352{-# INLINE filterMap #-}
363−filterMap :: Monad m => Int -> Stream m Int -> m ()
353+filterMap :: Monad m => Int -> Int -> Stream m Int -> m ()
364−filterMap n = composeN n $ S.map (subtract 1) . S.filter (<= maxValue)
354+filterMap maxValue n = composeN n $ S.map (subtract 1) . S.filter (<= maxValue)
365
355
366-------------------------------------------------------------------------------
356-------------------------------------------------------------------------------
367-- ConcatMap
357-- ConcatMap
@@ -530,23 +520,23 @@ o_1_space :: [Benchmark]
530o_1_space =
520o_1_space =
531 [ bgroup (o_1_space_prefix moduleName)
521 [ bgroup (o_1_space_prefix moduleName)
532 [ bgroup "generation"
522 [ bgroup "generation"
533− [ benchFold "unfoldr" toNull sourceUnfoldr
523+ [ benchFold "unfoldr" toNull (sourceUnfoldr value)
534− , benchFold "unfoldrM" toNull sourceUnfoldrM
524+ , benchFold "unfoldrM" toNull (sourceUnfoldrM value)
535
525
536− , benchFold "fromFoldable" toNull sourceFromFoldable
526+ , benchFold "fromFoldable" toNull (sourceFromFoldable value)
537− , benchFold "fromFoldableM" toNull sourceFromFoldableM
527+ , benchFold "fromFoldableM" toNull (sourceFromFoldableM value)
538
528
539 -- appends
529 -- appends
540− , benchFold "concatMapFoldableWith" toNull sourceFoldMapWith
530+ , benchFold "concatMapFoldableWith" toNull (sourceFoldMapWith value)
541− , benchFold "concatMapFoldableWithM" toNull sourceFoldMapWithM
531+ , benchFold "concatMapFoldableWithM" toNull (sourceFoldMapWithM value)
542 ]
532 ]
543 , bgroup "elimination"
533 , bgroup "elimination"
544− [ benchFold "toNull" toNull sourceUnfoldrM
534+ [ benchFold "toNull" toNull (sourceUnfoldrM value)
545− , benchFold "mapM_" mapM_ sourceUnfoldrM
535+ , benchFold "mapM_" mapM_ (sourceUnfoldrM value)
546− , benchFold "uncons" uncons sourceUnfoldrM
536+ , benchFold "uncons" uncons (sourceUnfoldrM value)
547− , benchFold "init" init sourceUnfoldrM
537+ , benchFold "init" init (sourceUnfoldrM value)
548− , benchFold "foldl'" foldl sourceUnfoldrM
538+ , benchFold "foldl'" foldl (sourceUnfoldrM value)
549− , benchFold "last" last sourceUnfoldrM
539+ , benchFold "last" last (sourceUnfoldrM value)
550 ]
540 ]
551 , bgroup "nested"
541 , bgroup "nested"
552 [ benchFold "toNullAp" toNullApNested (sourceUnfoldrMN value2)
542 [ benchFold "toNullAp" toNullApNested (sourceUnfoldrMN value2)
@@ -561,19 +551,19 @@ o_1_space =
561 , benchFold "filterAllOutPure" filterAllOutNested (sourceUnfoldrN value2)
551 , benchFold "filterAllOutPure" filterAllOutNested (sourceUnfoldrN value2)
562 ]
552 ]
563 , bgroup "transformation"
553 , bgroup "transformation"
564− [ benchFold "foldrS" (foldrS 1) sourceUnfoldrM
554+ [ benchFold "foldrS" (foldrS 1) (sourceUnfoldrM value)
565− , benchFold "scan" (scan 1) sourceUnfoldrM
555+ , benchFold "scan" (scan 1) (sourceUnfoldrM value)
566− , benchFold "map" (map 1) sourceUnfoldrM
556+ , benchFold "map" (map 1) (sourceUnfoldrM value)
567− , benchFold "fmap" (fmapK 1) sourceUnfoldrM
557+ , benchFold "fmap" (fmapK 1) (sourceUnfoldrM value)
568− , benchFold "mapM" (mapM 1) sourceUnfoldrM
558+ , benchFold "mapM" (mapM 1) (sourceUnfoldrM value)
569− , benchFold "mapMSerial" (mapMSerial 1) sourceUnfoldrM
559+ , benchFold "mapMSerial" (mapMSerial 1) (sourceUnfoldrM value)
570 ]
560 ]
571 , bgroup "transformationX4"
561 , bgroup "transformationX4"
572− [ benchFold "scan" (scan 4) sourceUnfoldrM
562+ [ benchFold "scan" (scan 4) (sourceUnfoldrM value)
573− , benchFold "map" (map 4) sourceUnfoldrM
563+ , benchFold "map" (map 4) (sourceUnfoldrM value)
574− , benchFold "fmap" (fmapK 4) sourceUnfoldrM
564+ , benchFold "fmap" (fmapK 4) (sourceUnfoldrM value)
575− , benchFold "mapM" (mapM 4) sourceUnfoldrM
565+ , benchFold "mapM" (mapM 4) (sourceUnfoldrM value)
576− , benchFold "mapMSerial" (mapMSerial 4) sourceUnfoldrM
566+ , benchFold "mapMSerial" (mapMSerial 4) (sourceUnfoldrM value)
577 -- XXX this is horribly slow
567 -- XXX this is horribly slow
578 -- , benchFold "concatMap" (concatMap 4) (sourceUnfoldrMN value16)
568 -- , benchFold "concatMap" (concatMap 4) (sourceUnfoldrMN value16)
579 ]
569 ]
@@ -607,77 +597,87 @@ o_1_space =
607 (concatStreamsWith 1 value)
597 (concatStreamsWith 1 value)
608 ]
598 ]
609 , bgroup "filtering"
599 , bgroup "filtering"
610− [ benchFold "filter-even" (filterEven 1) sourceUnfoldrM
600+ [ benchFold "filter-even" (filterEven 1) (sourceUnfoldrM value)
611− , benchFold "filter-all-out" (filterAllOut 1) sourceUnfoldrM
601+ , benchFold "filter-all-out" (filterAllOut maxValue 1) (sourceUnfoldrM value)
612− , benchFold "filter-all-in" (filterAllIn 1) sourceUnfoldrM
602+ , benchFold "filter-all-in" (filterAllIn maxValue 1) (sourceUnfoldrM value)
613− , benchFold "take-all" (takeAll 1) sourceUnfoldrM
603+ , benchFold "take-all" (takeAll maxValue 1) (sourceUnfoldrM value)
614− , benchFold "takeWhile-true" (takeWhileTrue 1) sourceUnfoldrM
604+ , benchFold "takeWhile-true" (takeWhileTrue maxValue 1) (sourceUnfoldrM value)
615− , benchFold "drop-one" (dropOne 1) sourceUnfoldrM
605+ , benchFold "drop-one" (dropOne 1) (sourceUnfoldrM value)
616− , benchFold "drop-all" (dropAll 1) sourceUnfoldrM
606+ , benchFold "drop-all" (dropAll maxValue 1) (sourceUnfoldrM value)
617− , benchFold "dropWhile-true" (dropWhileTrue 1) sourceUnfoldrM
607+ , benchFold "dropWhile-true" (dropWhileTrue maxValue 1) (sourceUnfoldrM value)
618− , benchFold "dropWhile-false" (dropWhileFalse 1) sourceUnfoldrM
608+ , benchFold "dropWhile-false" (dropWhileFalse 1) (sourceUnfoldrM value)
619 ]
609 ]
620 , bgroup "filteringX4"
610 , bgroup "filteringX4"
621− [ benchFold "filter-even" (filterEven 4) sourceUnfoldrM
611+ [ benchFold "filter-even" (filterEven 4) (sourceUnfoldrM value)
622− , benchFold "filter-all-out" (filterAllOut 4) sourceUnfoldrM
612+ , benchFold "filter-all-out" (filterAllOut maxValue 4) (sourceUnfoldrM value)
623− , benchFold "filter-all-in" (filterAllIn 4) sourceUnfoldrM
613+ , benchFold "filter-all-in" (filterAllIn maxValue 4) (sourceUnfoldrM value)
624− , benchFold "take-all" (takeAll 4) sourceUnfoldrM
614+ , benchFold "take-all" (takeAll maxValue 4) (sourceUnfoldrM value)
625− , benchFold "takeWhile-true" (takeWhileTrue 4) sourceUnfoldrM
615+ , benchFold "takeWhile-true" (takeWhileTrue maxValue 4) (sourceUnfoldrM value)
626− , benchFold "drop-one" (dropOne 4) sourceUnfoldrM
616+ , benchFold "drop-one" (dropOne 4) (sourceUnfoldrM value)
627− , benchFold "drop-all" (dropAll 4) sourceUnfoldrM
617+ , benchFold "drop-all" (dropAll maxValue 4) (sourceUnfoldrM value)
628− , benchFold "dropWhile-true" (dropWhileTrue 4) sourceUnfoldrM
618+ , benchFold "dropWhile-true" (dropWhileTrue maxValue 4) (sourceUnfoldrM value)
629− , benchFold "dropWhile-false" (dropWhileFalse 4) sourceUnfoldrM
619+ , benchFold "dropWhile-false" (dropWhileFalse 4) (sourceUnfoldrM value)
630 ]
620 ]
631 , bgroup "zipping"
621 , bgroup "zipping"
632− [ benchFold "zip" zip sourceUnfoldrM
622+ [ benchFold "zip" zip (sourceUnfoldrM value)
633 ]
623 ]
634 , bgroup "mixed"
624 , bgroup "mixed"
635− [ benchFold "scan-map" (scanMap 1) sourceUnfoldrM
625+ [ benchFold "scan-map" (scanMap 1) (sourceUnfoldrM value)
636− , benchFold "drop-map" (dropMap 1) sourceUnfoldrM
626+ , benchFold "drop-map" (dropMap 1) (sourceUnfoldrM value)
637− , benchFold "drop-scan" (dropScan 1) sourceUnfoldrM
627+ , benchFold "drop-scan" (dropScan 1) (sourceUnfoldrM value)
638− , benchFold "take-drop" (takeDrop 1) sourceUnfoldrM
628+ , benchFold "take-drop" (takeDrop maxValue 1) (sourceUnfoldrM value)
639− , benchFold "take-scan" (takeScan 1) sourceUnfoldrM
629+ , benchFold "take-scan" (takeScan maxValue 1) (sourceUnfoldrM value)
640− , benchFold "take-map" (takeMap 1) sourceUnfoldrM
630+ , benchFold "take-map" (takeMap maxValue 1) (sourceUnfoldrM value)
641− , benchFold "filter-drop" (filterDrop 1) sourceUnfoldrM
631+ , benchFold "filter-drop" (filterDrop maxValue 1) (sourceUnfoldrM value)
642− , benchFold "filter-take" (filterTake 1) sourceUnfoldrM
632+ , benchFold "filter-take" (filterTake maxValue 1) (sourceUnfoldrM value)
643− , benchFold "filter-scan" (filterScan 1) sourceUnfoldrM
633+ , benchFold "filter-scan" (filterScan maxValue 1) (sourceUnfoldrM value)
644− , benchFold "filter-map" (filterMap 1) sourceUnfoldrM
634+ , benchFold "filter-map" (filterMap maxValue 1) (sourceUnfoldrM value)
645 ]
635 ]
646 , bgroup "mixedX2"
636 , bgroup "mixedX2"
647− [ benchFold "scan-map" (scanMap 2) sourceUnfoldrM
637+ [ benchFold "scan-map" (scanMap 2) (sourceUnfoldrM value)
648− , benchFold "drop-map" (dropMap 2) sourceUnfoldrM
638+ , benchFold "drop-map" (dropMap 2) (sourceUnfoldrM value)
649− , benchFold "drop-scan" (dropScan 2) sourceUnfoldrM
639+ , benchFold "drop-scan" (dropScan 2) (sourceUnfoldrM value)
650− , benchFold "take-drop" (takeDrop 2) sourceUnfoldrM
640+ , benchFold "take-drop" (takeDrop maxValue 2) (sourceUnfoldrM value)
651− , benchFold "take-scan" (takeScan 2) sourceUnfoldrM
641+ , benchFold "take-scan" (takeScan maxValue 2) (sourceUnfoldrM value)
652− , benchFold "take-map" (takeMap 2) sourceUnfoldrM
642+ , benchFold "take-map" (takeMap maxValue 2) (sourceUnfoldrM value)
653− , benchFold "filter-drop" (filterDrop 2) sourceUnfoldrM
643+ , benchFold "filter-drop" (filterDrop maxValue 2) (sourceUnfoldrM value)
654− , benchFold "filter-take" (filterTake 2) sourceUnfoldrM
644+ , benchFold "filter-take" (filterTake maxValue 2) (sourceUnfoldrM value)
655− , benchFold "filter-scan" (filterScan 2) sourceUnfoldrM
645+ , benchFold "filter-scan" (filterScan maxValue 2) (sourceUnfoldrM value)
656− , benchFold "filter-map" (filterMap 2) sourceUnfoldrM
646+ , benchFold "filter-map" (filterMap maxValue 2) (sourceUnfoldrM value)
657 ]
647 ]
658 , bgroup "mixedX4"
648 , bgroup "mixedX4"
659− [ benchFold "scan-map" (scanMap 4) sourceUnfoldrM
649+ [ benchFold "scan-map" (scanMap 4) (sourceUnfoldrM value)
660− , benchFold "drop-map" (dropMap 4) sourceUnfoldrM
650+ , benchFold "drop-map" (dropMap 4) (sourceUnfoldrM value)
661− , benchFold "drop-scan" (dropScan 4) sourceUnfoldrM
651+ , benchFold "drop-scan" (dropScan 4) (sourceUnfoldrM value)
662− , benchFold "take-drop" (takeDrop 4) sourceUnfoldrM
652+ , benchFold "take-drop" (takeDrop maxValue 4) (sourceUnfoldrM value)
663− , benchFold "take-scan" (takeScan 4) sourceUnfoldrM
653+ , benchFold "take-scan" (takeScan maxValue 4) (sourceUnfoldrM value)
664− , benchFold "take-map" (takeMap 4) sourceUnfoldrM
654+ , benchFold "take-map" (takeMap maxValue 4) (sourceUnfoldrM value)
665− , benchFold "filter-drop" (filterDrop 4) sourceUnfoldrM
655+ , benchFold "filter-drop" (filterDrop maxValue 4) (sourceUnfoldrM value)
666− , benchFold "filter-take" (filterTake 4) sourceUnfoldrM
656+ , benchFold "filter-take" (filterTake maxValue 4) (sourceUnfoldrM value)
667− , benchFold "filter-scan" (filterScan 4) sourceUnfoldrM
657+ , benchFold "filter-scan" (filterScan maxValue 4) (sourceUnfoldrM value)
668− , benchFold "filter-map" (filterMap 4) sourceUnfoldrM
658+ , benchFold "filter-map" (filterMap maxValue 4) (sourceUnfoldrM value)
669 ]
659 ]
670 ]
660 ]
671 ]
661 ]
662+ where
663+
664+ value = 100000
665+ value2 = round (P.fromIntegral value**(1/2::P.Double)) -- double nested loop
666+ value3 = round (P.fromIntegral value**(1/3::P.Double)) -- triple nested loop
667+ maxValue = value
668+
672
669
673o_n_heap :: [Benchmark]
670o_n_heap :: [Benchmark]
674o_n_heap =
671o_n_heap =
675 [ bgroup (o_n_heap_prefix moduleName)
672 [ bgroup (o_n_heap_prefix moduleName)
676 [ bgroup "transformation"
673 [ bgroup "transformation"
677− [ benchFold "foldlS" (foldlS 1) sourceUnfoldrM
674+ [ benchFold "foldlS" (foldlS 1) (sourceUnfoldrM value)
678 ]
675 ]
679 ]
676 ]
680 ]
677 ]
678+ where
679+
680+ value = 100000
681
681
682{-# INLINE benchK #-}
682{-# INLINE benchK #-}
683benchK :: P.String -> (Int -> Stream P.IO Int) -> Benchmark
683benchK :: P.String -> (Int -> Stream P.IO Int) -> Benchmark
@@ -687,40 +687,52 @@ o_n_stack :: [Benchmark]
687o_n_stack =
687o_n_stack =
688 [ bgroup (o_n_stack_prefix moduleName)
688 [ bgroup (o_n_stack_prefix moduleName)
689 [ bgroup "elimination"
689 [ bgroup "elimination"
690− [ benchFold "tail" tail sourceUnfoldrM
690+ [ benchFold "tail" tail (sourceUnfoldrM value)
691− , benchFold "nullTail" nullTail sourceUnfoldrM
691+ , benchFold "nullTail" nullTail (sourceUnfoldrM value)
692− , benchFold "headTail" headTail sourceUnfoldrM
692+ , benchFold "headTail" headTail (sourceUnfoldrM value)
693 ]
693 ]
694 , bgroup "transformation"
694 , bgroup "transformation"
695 [
695 [
696 -- XXX why do these need so much stack
696 -- XXX why do these need so much stack
697− benchFold "intersperse" (intersperse 1) (sourceUnfoldrMN value2)
697+ benchFold "intersperse" (intersperse maxValue 1) (sourceUnfoldrMN value2)
698− , benchFold "interspersePure" (intersperse 1) (sourceUnfoldrN value2)
698+ , benchFold "interspersePure" (intersperse maxValue 1) (sourceUnfoldrN value2)
699 ]
699 ]
700 , bgroup "transformationX4"
700 , bgroup "transformationX4"
701 [
701 [
702− benchFold "intersperse" (intersperse 4) (sourceUnfoldrMN value16)
702+ benchFold "intersperse" (intersperse maxValue 4) (sourceUnfoldrMN value16)
703 ]
703 ]
704 , bgroup "iterated"
704 , bgroup "iterated"
705− [ benchK "mapM" iterateMapM
705+ [ benchK "mapM" (iterateMapM iterStreamLen maxIters)
706− , benchK "scan(1/10)" iterateScan
706+ , benchK "scan(1/10)" (iterateScan iterStreamLen maxIters)
707− , benchK "filterEven" iterateFilterEven
707+ , benchK "filterEven" (iterateFilterEven iterStreamLen maxIters)
708− , benchK "takeAll" iterateTakeAll
708+ , benchK "takeAll" (iterateTakeAll maxValue iterStreamLen maxIters)
709− , benchK "dropOne" iterateDropOne
709+ , benchK "dropOne" (iterateDropOne iterStreamLen maxIters)
710− , benchK "dropWhileFalse(1/10)" iterateDropWhileFalse
710+ , benchK "dropWhileFalse(1/10)" (iterateDropWhileFalse maxValue iterStreamLen maxIters)
711− , benchK "dropWhileTrue" iterateDropWhileTrue
711+ , benchK "dropWhileTrue" (iterateDropWhileTrue maxValue iterStreamLen maxIters)
712 ]
712 ]
713 ]
713 ]
714 ]
714 ]
715+ where
716+
717+ value = 100000
718+ value2 = round (P.fromIntegral value**(1/2::P.Double)) -- double nested loop
719+ value16 = round (P.fromIntegral value**(1/16::P.Double)) -- triple nested loop
720+ maxValue = value
721+ maxIters = 10000
722+ iterStreamLen = 10
715
723
716o_n_space :: [Benchmark]
724o_n_space :: [Benchmark]
717o_n_space =
725o_n_space =
718 [ bgroup (o_n_space_prefix moduleName)
726 [ bgroup (o_n_space_prefix moduleName)
719 [ bgroup "elimination"
727 [ bgroup "elimination"
720− [ benchFold "toList" toList sourceUnfoldrM
728+ [ benchFold "toList" toList (sourceUnfoldrM value)
721 ]
729 ]
722 ]
730 ]
723 ]
731 ]
732+ where
733+
734+ value = 100000
735+
724
736
725{-# INLINE benchList #-}
737{-# INLINE benchList #-}
726benchList :: P.String -> ([Int] -> [Int]) -> (Int -> [Int]) -> Benchmark
738benchList :: P.String -> ([Int] -> [Int]) -> (Int -> [Int]) -> Benchmark
@@ -741,6 +753,11 @@ o_1_space_list =
741 ]
753 ]
742 ]
754 ]
743 ]
755 ]
756+ where
757+
758+ value = 100000
759+ value2 = round (P.fromIntegral value**(1/2::P.Double)) -- double nested loop
760+ value3 = round (P.fromIntegral value**(1/3::P.Double)) -- triple nested loop
744
761
745main :: IO ()
762main :: IO ()
746main = defaultMain $ concat
763main = defaultMain $ concat