git.iko.soy/streamly
on master help sign in
update benchmarks for streamD/K
d0a07bbHarendra Kumar
benchmark/BaseStreams.hs+9−2
compare with master
unifiedsplit
@@ -41,8 +41,15 @@ main = do
41 -- , benchIO "fromFoldableM" D.sourceFromFoldableM
41 -- , benchIO "fromFoldableM" D.sourceFromFoldableM
42 ]
42 ]
43 , bgroup "transformation"
43 , bgroup "transformation"
44− [
44+ [ -- benchIO "scan" D.scan D.sourceUnfoldrM
45+ benchIO "map" D.map D.sourceUnfoldrM
45− benchIO "mapM" D.mapM D.sourceUnfoldrM
46+ , benchIO "mapM" D.mapM D.sourceUnfoldrM
47+ ]
48+ , bgroup "filtering"
49+ [ benchIO "filter-even" D.filterEven D.sourceUnfoldrM
50+ , benchIO "filter-all-out" D.filterAllOut D.sourceUnfoldrM
51+ , benchIO "filter-all-in" D.filterAllIn D.sourceUnfoldrM
52+ , benchIO "take-all" D.takeAll D.sourceUnfoldrM
46 ]
53 ]
47 ]
54 ]
48 , bgroup "streamK"
55 , bgroup "streamK"
benchmark/StreamDOps.hs+13−23
@@ -13,7 +13,7 @@ module StreamDOps where
13 -- (Monad, Int, (+), ($), (.), return, fmap, even, (>), (<=),
13 -- (Monad, Int, (+), ($), (.), return, fmap, even, (>), (<=),
14 -- subtract, undefined, Maybe(..))
14 -- subtract, undefined, Maybe(..))
15import Prelude
15import Prelude
16− (Monad, Int, (+), (.), return, (>),
16+ (Monad, Int, (+), (.), return, (>), even, (<=),
17 Maybe(..))
17 Maybe(..))
18
18
19import qualified Streamly.Streams.StreamD as S
19import qualified Streamly.Streams.StreamD as S
@@ -26,14 +26,14 @@ maxValue = value + 1000
26-- Benchmark ops
26-- Benchmark ops
27-------------------------------------------------------------------------------
27-------------------------------------------------------------------------------
28
28
29−{-
30−{-# INLINE scan #-}
29+-- {-# INLINE scan #-}
31{-# INLINE map #-}
30{-# INLINE map #-}
32{-# INLINE filterEven #-}
31{-# INLINE filterEven #-}
33{-# INLINE filterAllOut #-}
32{-# INLINE filterAllOut #-}
34{-# INLINE filterAllIn #-}
33{-# INLINE filterAllIn #-}
35{-# INLINE takeOne #-}
34{-# INLINE takeOne #-}
36{-# INLINE takeAll #-}
35{-# INLINE takeAll #-}
36+{-
37{-# INLINE takeWhileTrue #-}
37{-# INLINE takeWhileTrue #-}
38{-# INLINE dropAll #-}
38{-# INLINE dropAll #-}
39{-# INLINE dropWhileTrue #-}
39{-# INLINE dropWhileTrue #-}
@@ -42,15 +42,18 @@ maxValue = value + 1000
42{-# INLINE composeAllInFilters #-}
42{-# INLINE composeAllInFilters #-}
43{-# INLINE composeAllOutFilters #-}
43{-# INLINE composeAllOutFilters #-}
44{-# INLINE composeMapAllInFilter #-}
44{-# INLINE composeMapAllInFilter #-}
45+-}
45−scan, map, filterEven, filterAllOut,
46+map, filterEven, filterAllOut,
46− filterAllIn, takeOne, takeAll, takeWhileTrue, dropAll, dropWhileTrue, zip,
47+ filterAllIn, takeOne, takeAll -- takeWhileTrue, dropAll, dropWhileTrue, zip,
47− concat, composeAllInFilters, composeAllOutFilters,
48+ -- concat, composeAllInFilters, composeAllOutFilters,
48− composeMapAllInFilter
49+ -- composeMapAllInFilter
49 :: Monad m
50 :: Monad m
50 => Stream m Int -> m ()
51 => Stream m Int -> m ()
51
52
53+{-
52{-# INLINE composeMapM #-}
54{-# INLINE composeMapM #-}
53composeMapM :: S.MonadAsync m => Stream m Int -> m ()
55composeMapM :: S.MonadAsync m => Stream m Int -> m ()
56+-}
54
57
55{-# INLINE toList #-}
58{-# INLINE toList #-}
56toList :: Monad m => Stream m Int -> m [Int]
59toList :: Monad m => Stream m Int -> m [Int]
@@ -58,9 +61,6 @@ toList :: Monad m => Stream m Int -> m [Int]
58foldl :: Monad m => Stream m Int -> m Int
61foldl :: Monad m => Stream m Int -> m Int
59{-# INLINE last #-}
62{-# INLINE last #-}
60last :: Monad m => Stream m Int -> m (Maybe Int)
63last :: Monad m => Stream m Int -> m (Maybe Int)
61−{-# INLINE zipAsync #-}
62−zipAsync :: S.MonadAsync m => Stream m Int -> m ()
63−-}
64
64
65{-# INLINE toNull #-}
65{-# INLINE toNull #-}
66{-# INLINE mapM #-}
66{-# INLINE mapM #-}
@@ -98,12 +98,6 @@ sourceFromEnum n = S.enumFromStepN n 1 value
98sourceFromFoldable :: Monad m => Int -> Stream m Int
98sourceFromFoldable :: Monad m => Int -> Stream m Int
99sourceFromFoldable n = S.fromList [n..n+value]
99sourceFromFoldable n = S.fromList [n..n+value]
100
100
101−{-
102−{-# INLINE sourceFromFoldableM #-}
103−sourceFromFoldableM :: (S.IsStream t, S.MonadAsync m) => Int -> t m Int
104−sourceFromFoldableM n = S.fromFoldableM (Prelude.fmap return [n..n+value])
105−-}
106−
107{-# INLINE source #-}
101{-# INLINE source #-}
108source :: Monad m => Int -> Stream m Int
102source :: Monad m => Int -> Stream m Int
109source n = sourceUnfoldrM n
103source n = sourceUnfoldrM n
@@ -117,11 +111,9 @@ runStream :: Monad m => Stream m a -> m ()
117runStream = S.runStream
111runStream = S.runStream
118
112
119toNull = runStream
113toNull = runStream
120−{-
121toList = S.toList
114toList = S.toList
122foldl = S.foldl' (+) 0
115foldl = S.foldl' (+) 0
123last = S.last
116last = S.last
124−-}
125
117
126-------------------------------------------------------------------------------
118-------------------------------------------------------------------------------
127-- Transformation
119-- Transformation
@@ -131,17 +123,15 @@ last = S.last
131transform :: Monad m => Stream m a -> m ()
123transform :: Monad m => Stream m a -> m ()
132transform = runStream
124transform = runStream
133
125
134−{-
135−scan = transform . S.scanl' (+) 0
126+-- scan = transform . S.scanl' (+) 0
136−map = transform . fmap (+1)
127+map = transform . S.map (+1)
137−-}
138mapM = transform . S.mapM return
128mapM = transform . S.mapM return
139−{-
140filterEven = transform . S.filter even
129filterEven = transform . S.filter even
141filterAllOut = transform . S.filter (> maxValue)
130filterAllOut = transform . S.filter (> maxValue)
142filterAllIn = transform . S.filter (<= maxValue)
131filterAllIn = transform . S.filter (<= maxValue)
143takeOne = transform . S.take 1
132takeOne = transform . S.take 1
144takeAll = transform . S.take maxValue
133takeAll = transform . S.take maxValue
134+{-
145takeWhileTrue = transform . S.takeWhile (<= maxValue)
135takeWhileTrue = transform . S.takeWhile (<= maxValue)
146dropAll = transform . S.drop maxValue
136dropAll = transform . S.drop maxValue
147dropWhileTrue = transform . S.dropWhile (<= maxValue)
137dropWhileTrue = transform . S.dropWhile (<= maxValue)
benchmark/StreamKOps.hs+6−6
@@ -16,7 +16,7 @@ import Prelude
16import qualified Streamly.Streams.StreamK as S hiding (runStream)
16import qualified Streamly.Streams.StreamK as S hiding (runStream)
17-- import qualified Streamly.Streams.Serial as S
17-- import qualified Streamly.Streams.Serial as S
18import qualified Streamly as S
18import qualified Streamly as S
19−import qualified Streamly.Prelude as S
19+import qualified Streamly.Prelude as P
20
20
21value, maxValue :: Int
21value, maxValue :: Int
22value = 1000000
22value = 1000000
@@ -99,7 +99,7 @@ sourceFromFoldable n = S.fromFoldable [n..n+value]
99
99
100{-# INLINE sourceFromFoldableM #-}
100{-# INLINE sourceFromFoldableM #-}
101sourceFromFoldableM :: S.MonadAsync m => Int -> Stream m Int
101sourceFromFoldableM :: S.MonadAsync m => Int -> Stream m Int
102−sourceFromFoldableM n = S.fromFoldableM (Prelude.fmap return [n..n+value])
102+sourceFromFoldableM n = P.fromFoldableM (Prelude.fmap return [n..n+value])
103
103
104{-# INLINE sourceFoldMapWith #-}
104{-# INLINE sourceFoldMapWith #-}
105sourceFoldMapWith :: Monad m => Int -> Stream m Int
105sourceFoldMapWith :: Monad m => Int -> Stream m Int
@@ -142,15 +142,15 @@ filterAllOut = transform . S.filter (> maxValue)
142filterAllIn = transform . S.filter (<= maxValue)
142filterAllIn = transform . S.filter (<= maxValue)
143takeOne = transform . S.take 1
143takeOne = transform . S.take 1
144takeAll = transform . S.take maxValue
144takeAll = transform . S.take maxValue
145−takeWhileTrue = transform . S.takeWhile (<= maxValue)
145+takeWhileTrue = transform . P.takeWhile (<= maxValue)
146−dropAll = transform . S.drop maxValue
146+dropAll = transform . P.drop maxValue
147−dropWhileTrue = transform . S.dropWhile (<= maxValue)
147+dropWhileTrue = transform . P.dropWhile (<= maxValue)
148
148
149-------------------------------------------------------------------------------
149-------------------------------------------------------------------------------
150-- Zipping and concat
150-- Zipping and concat
151-------------------------------------------------------------------------------
151-------------------------------------------------------------------------------
152
152
153−zip src = transform $ (S.zipWith (,) src src)
153+zip src = transform $ (P.zipWith (,) src src)
154concat _n = return ()
154concat _n = return ()
155
155
156-------------------------------------------------------------------------------
156-------------------------------------------------------------------------------