git.iko.soy/streamly
on master help sign in
Replace value with size and n with start in bench:Data.Unfold
8d6b695adithyaov
benchmark/Streamly/Benchmark/Data/Unfold.hs+67−63
compare with master
unifiedsplit
@@ -31,26 +31,27 @@ benchIO name f = bench name $ nfIO $ randomRIO (1,1) >>= f
31
31
32{-# INLINE fromListM #-}
32{-# INLINE fromListM #-}
33fromListM :: Monad m => Int -> Int -> m ()
33fromListM :: Monad m => Int -> Int -> m ()
34−fromListM value n =
34+fromListM size start =
35+ S.drain
35− S.drain $ S.unfold UF.fromListM (Prelude.map return [n .. n + value])
36+ $ S.unfold UF.fromListM (Prelude.map return [start .. start + size])
36
37
37{-# INLINE replicateM #-}
38{-# INLINE replicateM #-}
38replicateM :: Monad m => Int -> Int -> m ()
39replicateM :: Monad m => Int -> Int -> m ()
39−replicateM value n = S.drain $ S.unfold (UF.replicateM value) (return n)
40+replicateM size start = S.drain $ S.unfold (UF.replicateM size) (return start)
40
41
41{-# INLINE repeatM #-}
42{-# INLINE repeatM #-}
42repeatM :: Monad m => Int -> Int -> m ()
43repeatM :: Monad m => Int -> Int -> m ()
43−repeatM value n = S.drain $ S.take value $ S.unfold UF.repeatM (return n)
44+repeatM size start = S.drain $ S.take size $ S.unfold UF.repeatM (return start)
44
45
45{-# INLINE enumerateFromStepIntegral #-}
46{-# INLINE enumerateFromStepIntegral #-}
46enumerateFromStepIntegral :: Monad m => Int -> Int -> m ()
47enumerateFromStepIntegral :: Monad m => Int -> Int -> m ()
47−enumerateFromStepIntegral value n = S.drain $
48+enumerateFromStepIntegral size start = S.drain $
48− S.take value $ S.unfold UF.enumerateFromStepIntegral (n, 1)
49+ S.take size $ S.unfold UF.enumerateFromStepIntegral (start, 1)
49
50
50{-# INLINE enumerateFromToIntegral #-}
51{-# INLINE enumerateFromToIntegral #-}
51enumerateFromToIntegral :: Monad m => Int -> Int -> m ()
52enumerateFromToIntegral :: Monad m => Int -> Int -> m ()
52−enumerateFromToIntegral value n =
53+enumerateFromToIntegral size start =
53− S.drain $ S.unfold (UF.enumerateFromToIntegral (value + n)) n
54+ S.drain $ S.unfold (UF.enumerateFromToIntegral (size + start)) start
54
55
55-------------------------------------------------------------------------------
56-------------------------------------------------------------------------------
56-- Stream transformation
57-- Stream transformation
@@ -58,52 +59,55 @@ enumerateFromToIntegral value n =
58
59
59{-# INLINE take #-}
60{-# INLINE take #-}
60take :: Monad m => Int -> Int -> m ()
61take :: Monad m => Int -> Int -> m ()
61−take value n =
62+take size start =
62 S.drain
63 S.drain
64+ $ S.unfold
63− $ S.unfold (UF.take value (UF.enumerateFromToIntegral (value + n))) n
65+ (UF.take size (UF.enumerateFromToIntegral (size + start)))
66+ start
64
67
65{-# INLINE takeWhileM #-}
68{-# INLINE takeWhileM #-}
66takeWhileM :: Monad m => Int -> Int -> m ()
69takeWhileM :: Monad m => Int -> Int -> m ()
67−takeWhileM value n =
70+takeWhileM size start =
68 S.drain
71 S.drain
69 $ S.unfold
72 $ S.unfold
70 (UF.takeWhileM
73 (UF.takeWhileM
71− (\b -> return (b <= value + n))
74+ (\b -> return (b <= size + start))
72− (UF.enumerateFromToIntegral (value + n)))
75+ (UF.enumerateFromToIntegral (size + start)))
73− n
76+ start
74
77
75{-# INLINE _dropOne #-}
78{-# INLINE _dropOne #-}
76_dropOne :: Monad m => Int -> Int -> m ()
79_dropOne :: Monad m => Int -> Int -> m ()
77−_dropOne value n =
80+_dropOne size start =
81+ S.drain
78− S.drain $ S.unfold (UF.drop 1 (UF.enumerateFromToIntegral (value + n))) n
82+ $ S.unfold (UF.drop 1 (UF.enumerateFromToIntegral (size + start))) start
79
83
80{-# INLINE dropAll #-}
84{-# INLINE dropAll #-}
81dropAll :: Monad m => Int -> Int -> m ()
85dropAll :: Monad m => Int -> Int -> m ()
82−dropAll value n =
86+dropAll size start =
83 S.drain
87 S.drain
84 $ S.unfold
88 $ S.unfold
85− (UF.drop (value + 1) (UF.enumerateFromToIntegral (value + n)))
89+ (UF.drop (size + 1) (UF.enumerateFromToIntegral (size + start)))
86− n
90+ start
87
91
88{-# INLINE dropWhileMTrue #-}
92{-# INLINE dropWhileMTrue #-}
89dropWhileMTrue :: Monad m => Int -> Int -> m ()
93dropWhileMTrue :: Monad m => Int -> Int -> m ()
90−dropWhileMTrue value n =
94+dropWhileMTrue size start =
91 S.drain
95 S.drain
92 $ S.unfold
96 $ S.unfold
93 (UF.dropWhileM
97 (UF.dropWhileM
94 (\_ -> return True)
98 (\_ -> return True)
95− (UF.enumerateFromToIntegral (value + n)))
99+ (UF.enumerateFromToIntegral (size + start)))
96− n
100+ start
97
101
98{-# INLINE dropWhileMFalse #-}
102{-# INLINE dropWhileMFalse #-}
99dropWhileMFalse :: Monad m => Int -> Int -> m ()
103dropWhileMFalse :: Monad m => Int -> Int -> m ()
100−dropWhileMFalse value n =
104+dropWhileMFalse size start =
101 S.drain
105 S.drain
102 $ S.unfold
106 $ S.unfold
103 (UF.dropWhileM
107 (UF.dropWhileM
104 (\_ -> return False)
108 (\_ -> return False)
105− (UF.enumerateFromToIntegral (value + n)))
109+ (UF.enumerateFromToIntegral (size + start)))
106− n
110+ start
107
111
108-------------------------------------------------------------------------------
112-------------------------------------------------------------------------------
109-- Stream combination
113-- Stream combination
@@ -111,14 +115,14 @@ dropWhileMFalse value n =
111
115
112{-# INLINE zipWithM #-}
116{-# INLINE zipWithM #-}
113zipWithM :: Monad m => Int -> Int -> m ()
117zipWithM :: Monad m => Int -> Int -> m ()
114−zipWithM value n =
118+zipWithM size start =
115 S.drain
119 S.drain
116 $ S.unfold
120 $ S.unfold
117 (UF.zipWithM
121 (UF.zipWithM
118 (\a b -> return $ a + b)
122 (\a b -> return $ a + b)
119− (UF.enumerateFromToIntegral (value + n))
123+ (UF.enumerateFromToIntegral (size + start))
120− (UF.enumerateFromToIntegral (value + n + 1)))
124+ (UF.enumerateFromToIntegral (size + start + 1)))
121− (n, n + 1)
125+ (start, start + 1)
122
126
123-------------------------------------------------------------------------------
127-------------------------------------------------------------------------------
124-- Benchmarks
128-- Benchmarks
@@ -128,55 +132,55 @@ moduleName :: String
128moduleName = "Data.Unfold"
132moduleName = "Data.Unfold"
129
133
130o_1_space_serial_generation :: Int -> [Benchmark]
134o_1_space_serial_generation :: Int -> [Benchmark]
131−o_1_space_serial_generation value =
135+o_1_space_serial_generation size =
132 [ bgroup "generation"
136 [ bgroup "generation"
133− [ benchIO "fromListM" $ fromListM value
137+ [ benchIO "fromListM" $ fromListM size
134− , benchIO "replicateM" $ replicateM value
138+ , benchIO "replicateM" $ replicateM size
135− , benchIO "repeatM" $ repeatM value
139+ , benchIO "repeatM" $ repeatM size
136− , benchIO "enumerateFromStepIntegral" $ enumerateFromStepIntegral value
140+ , benchIO "enumerateFromStepIntegral" $ enumerateFromStepIntegral size
137− , benchIO "enumerateFromToIntegral" $ enumerateFromToIntegral value
141+ , benchIO "enumerateFromToIntegral" $ enumerateFromToIntegral size
138 ]
142 ]
139 ]
143 ]
140
144
141o_1_space_serial_transformation :: Int -> [Benchmark]
145o_1_space_serial_transformation :: Int -> [Benchmark]
142−o_1_space_serial_transformation value =
146+o_1_space_serial_transformation size =
143 [ bgroup "transformation"
147 [ bgroup "transformation"
144− [ benchIO "take" $ take value
148+ [ benchIO "take" $ take size
145− , benchIO "takeWhileM" $ takeWhileM value
149+ , benchIO "takeWhileM" $ takeWhileM size
146− , benchIO "filterAllOut" $ filterAllOut value
150+ , benchIO "filterAllOut" $ filterAllOut size
147− , benchIO "filterAllIn" $ filterAllIn value
151+ , benchIO "filterAllIn" $ filterAllIn size
148− , benchIO "filterSome" $ filterSome value
152+ , benchIO "filterSome" $ filterSome size
149 -- This will take nanoseconds, We need to fix the benchmark reporting to
153 -- This will take nanoseconds, We need to fix the benchmark reporting to
150 -- have microseconds as the minimum unit before uncommenting this.
154 -- have microseconds as the minimum unit before uncommenting this.
151− -- , benchIO "dropOne" $ dropOne value
155+ -- , benchIO "dropOne" $ dropOne size
152− , benchIO "dropAll" $ dropAll value
156+ , benchIO "dropAll" $ dropAll size
153− , benchIO "dropWhileMTrue" $ dropWhileMTrue value
157+ , benchIO "dropWhileMTrue" $ dropWhileMTrue size
154− , benchIO "dropWhileMFalse" $ dropWhileMFalse value
158+ , benchIO "dropWhileMFalse" $ dropWhileMFalse size
155 ]
159 ]
156 ]
160 ]
157
161
158o_1_space_serial_combination :: Int -> [Benchmark]
162o_1_space_serial_combination :: Int -> [Benchmark]
159−o_1_space_serial_combination value =
163+o_1_space_serial_combination size =
160 [ bgroup "combination"
164 [ bgroup "combination"
161− [ benchIO "zipWithM" $ zipWithM value
165+ [ benchIO "zipWithM" $ zipWithM size
162 ]
166 ]
163 ]
167 ]
164
168
165o_1_space_serial_outerProduct :: Int -> [Benchmark]
169o_1_space_serial_outerProduct :: Int -> [Benchmark]
166−o_1_space_serial_outerProduct value =
170+o_1_space_serial_outerProduct size =
167 [ bgroup "outer-product"
171 [ bgroup "outer-product"
168− [ benchIO "toNull" $ toNull value
172+ [ benchIO "toNull" $ toNull size
169− , benchIO "toNull3" $ toNull3 value
173+ , benchIO "toNull3" $ toNull3 size
170− , benchIO "concat" $ concat value
174+ , benchIO "concat" $ concat size
171− , benchIO "breakAfterSome" $ breakAfterSome value
175+ , benchIO "breakAfterSome" $ breakAfterSome size
172 ]
176 ]
173 ]
177 ]
174
178
175o_n_space_serial :: Int -> [Benchmark]
179o_n_space_serial :: Int -> [Benchmark]
176−o_n_space_serial value =
180+o_n_space_serial size =
177 [ bgroup "outer-product"
181 [ bgroup "outer-product"
178− [ benchIO "toList" $ toList value
182+ [ benchIO "toList" $ toList size
179− , benchIO "toListSome" $ toListSome value
183+ , benchIO "toListSome" $ toListSome size
180 ]
184 ]
181 ]
185 ]
182
186
@@ -186,19 +190,19 @@ o_n_space_serial value =
186
190
187main :: IO ()
191main :: IO ()
188main = do
192main = do
189− (value, cfg, benches) <- parseCLIOpts defaultStreamSize
193+ (size, cfg, benches) <- parseCLIOpts defaultStreamSize
190− value `seq` runMode (mode cfg) cfg benches (allBenchmarks value)
194+ size `seq` runMode (mode cfg) cfg benches (allBenchmarks size)
191
195
192 where
196 where
193
197
194− allBenchmarks value =
198+ allBenchmarks size =
195 [ bgroup (o_1_space_prefix moduleName)
199 [ bgroup (o_1_space_prefix moduleName)
196 $ Prelude.concat
200 $ Prelude.concat
197− [ o_1_space_serial_generation value
201+ [ o_1_space_serial_generation size
198− , o_1_space_serial_transformation value
202+ , o_1_space_serial_transformation size
199− , o_1_space_serial_combination value
203+ , o_1_space_serial_combination size
200− , o_1_space_serial_outerProduct value
204+ , o_1_space_serial_outerProduct size
201 ]
205 ]
202 , bgroup (o_n_space_prefix moduleName)
206 , bgroup (o_n_space_prefix moduleName)
203− $ Prelude.concat [o_n_space_serial value]
207+ $ Prelude.concat [o_n_space_serial size]
204 ]
208 ]