bf39d27 · streamly · git.iko.soy

git.iko.soy/streamly

lint free benchmarks

commitbf39d274465f605278756aa3ebe65a489677809f authorHarendra Kumar <harendra.kumar@gmail.com> dateSat 13 Oct 2018, 08:41 (8 years ago) parent8b8fd22

11 files changed+57−83

compare with master

unifiedsplit

benchmark/Adaptive.hs+1−1 benchmark/BaseStreams.hs+1−1 benchmark/Chart.hs+9−9 benchmark/Linear.hs+5−5 benchmark/LinearAsync.hs+3−3 benchmark/LinearOps.hs+12−24 benchmark/LinearRate.hs+1−1 benchmark/Nested.hs+1−1 benchmark/NestedOps.hs+5−5 benchmark/StreamDOps.hs+7−11 benchmark/StreamKOps.hs+12−22

benchmark/Adaptive.hs+1−1

@@ -78,7 +78,7 @@ randomVar :: IsStream t => (t IO Int -> SerialT IO Int) -> IO ()

7878randomVar = run (low,high) (low,high)

7979

8080main :: IO ()

81−main = do

81+main =

8282 defaultMain

8383 [

8484 bgroup "serialConstantSlowConsumer"

benchmark/BaseStreams.hs+1−1

@@ -31,7 +31,7 @@ _benchId name f = bench name $ nf (runIdentity . f) (Ops.source 10)

3131-}

3232

3333main :: IO ()

34−main = do

34+main =

3535 defaultMain

3636 [ bgroup "streamD"

3737 [ bgroup "generation"

benchmark/Chart.hs+9−9

@@ -55,10 +55,10 @@ parseBench = do

5555 Just "nested" -> setBenchType Nested

5656 Just "base" -> setBenchType Base

5757 Just str -> do

58− liftIO $ putStrLn $ "unrecognized benchmark type " ++ str

58+ liftIO $ putStrLn $ "unrecognized benchmark type " <> str

5959 mzero

6060 Nothing -> do

61− liftIO $ putStrLn $ "please provide a benchmark type "

61+ liftIO $ putStrLn "please provide a benchmark type "

6262 mzero

6363

6464-- totally imperative style option parsing

@@ -71,13 +71,13 @@ parseOptions = do

7171 Just "--graphs" -> setGenGraphs True

7272 Just "--benchmark" -> parseBench

7373 Just str -> do

74− liftIO $ putStrLn $ "Unrecognized option " ++ str

74+ liftIO $ putStrLn $ "Unrecognized option " <> str

7575 mzero

7676 Nothing -> return ()

7777 fmap snd get

7878

7979ignoringErr a = catch a (\(ErrorCall err :: ErrorCall) ->

80− putStrLn $ "Failed with error:\n" ++ err ++ "\nSkipping.")

80+ putStrLn $ "Failed with error:\n" <> err <> "\nSkipping.")

8181

8282------------------------------------------------------------------------------

8383-- Linear composition charts

@@ -88,7 +88,7 @@ makeLinearGraphs cfg inputFile = do

8888 ignoringErr $ graph inputFile "operations" $ cfg

8989 { title = Just "Streamly operations"

9090 , classifyBenchmark = \b ->

91− if (not $ "serially/" `isPrefixOf` b)

91+ if not ("serially/" `isPrefixOf` b)

9292 || "/generation" `isInfixOf` b

9393 || "/compose" `isInfixOf` b

9494 || "/concat" `isSuffixOf` b

@@ -120,7 +120,7 @@ makeLinearGraphs cfg inputFile = do

120120------------------------------------------------------------------------------

121121

122122makeNestedGraphs :: Config -> String -> IO ()

123−makeNestedGraphs cfg inputFile = do

123+makeNestedGraphs cfg inputFile =

124124 ignoringErr $ graph inputFile "nested-serial-diff" $ cfg

125125 { title = Just "Nested serial"

126126 , classifyBenchmark = \b ->

@@ -165,10 +165,10 @@ benchShow Options{..} cfg func inp out =

165165 { selectBenchmarks =

166166 \f ->

167167 reverse

168− $ map fst

168+ $ fmap fst

169169 $ either

170170 (const $ either error id $ f $ ColumnIndex 0)

171− (sortBy (comparing snd))

171+ (sortOn snd)

172172 $ f $ ColumnIndex 1

173173 }

174174

@@ -181,7 +181,7 @@ main = do

181181 Nothing -> do

182182 putStrLn "cannot parse options"

183183 return ()

184− Just opts@Options{..} -> do

184+ Just opts@Options{..} ->

185185 case benchType of

186186 Linear -> benchShow opts cfg makeLinearGraphs

187187 "charts/linear/results.csv"

benchmark/Linear.hs+5−5

@@ -37,12 +37,12 @@ _benchId name f = bench name $ nf (runIdentity . f) (Ops.source 10)

3737-}

3838

3939main :: IO ()

40−main = do

40+main =

4141 defaultMain

4242 [ bgroup "serially"

4343 [ bgroup "generation"

4444 [ -- Most basic, barely stream continuations running

45− benchSrcIO serially "unfoldr" $ Ops.sourceUnfoldr

45+ benchSrcIO serially "unfoldr" Ops.sourceUnfoldr

4646 , benchSrcIO serially "unfoldrM" Ops.sourceUnfoldrM

4747 , benchSrcIO serially "fromList" Ops.sourceFromList

4848 , benchSrcIO serially "fromListM" Ops.sourceFromListM

@@ -91,7 +91,7 @@ main = do

9191 , benchIO "mapMaybe" Ops.mapMaybe

9292 , benchIO "mapMaybeM" Ops.mapMaybeM

9393 , bench "sequence" $ nfIO $ randomRIO (1,1000) >>= \n ->

94− (Ops.sequence serially) (Ops.sourceUnfoldrMAction n)

94+ Ops.sequence serially (Ops.sourceUnfoldrMAction n)

9595 , benchIO "findIndices" Ops.findIndices

9696 , benchIO "elemIndices" Ops.elemIndices

9797 -- , benchIO "concat" Ops.concat

@@ -107,8 +107,8 @@ main = do

107107 , benchIO "dropWhile-true" Ops.dropWhileTrue

108108 , benchIO "dropWhileM-true" Ops.dropWhileMTrue

109109 ]

110− , benchIO "zip" $ Ops.zip

111− , benchIO "zipM" $ Ops.zipM

110+ , benchIO "zip" Ops.zip

111+ , benchIO "zipM" Ops.zipM

112112 , bgroup "compose"

113113 [ benchIO "mapM" Ops.composeMapM

114114 , benchIO "map-with-all-in-filter" Ops.composeMapAllInFilter

benchmark/LinearAsync.hs+3−3

@@ -37,7 +37,7 @@ _benchId name f = bench name $ nf (runIdentity . f) (Ops.source 10)

3737-}

3838

3939main :: IO ()

40−main = do

40+main =

4141 defaultMain

4242 [ bgroup "asyncly"

4343 [ -- benchIO "unfoldr" $ Ops.toNull asyncly

@@ -86,7 +86,7 @@ main = do

8686 , benchSrcIO parallely "foldMapWithM" Ops.sourceFoldMapWithM

8787 , benchIO "mapM" $ Ops.mapM parallely

8888 -- Zip has only one parallel flavor

89− , benchIO "zip" $ Ops.zipAsync

90− , benchIO "zipM" $ Ops.zipAsyncM

89+ , benchIO "zip" Ops.zipAsync

90+ , benchIO "zipM" Ops.zipAsyncM

9191 ]

9292 ]

benchmark/LinearOps.hs+12−24

@@ -10,10 +10,11 @@

1010

1111module LinearOps where

1212

13+import Control.Monad (when)

1314import Data.Maybe (fromJust)

1415import Prelude

1516 (Monad, Int, (+), ($), (.), return, fmap, even, (>), (<=), (==), (<=),

16− subtract, undefined, Maybe(..), odd, Bool, not)

17+ subtract, undefined, Maybe(..), odd, Bool, not, (>>=), mapM_, curry)

1718

1819import qualified Streamly as S

1920import qualified Streamly.Prelude as S

@@ -74,7 +75,7 @@ sourceUnfoldr n = S.unfoldr step n

7475 step cnt =

7576 if cnt > n + value

7677 then Nothing

77− else (Just (cnt, cnt + 1))

78+ else Just (cnt, cnt + 1)

7879

7980{-# INLINE sourceUnfoldrM #-}

8081sourceUnfoldrM :: (S.IsStream t, S.MonadAsync m) => Int -> t m Int

@@ -154,32 +155,19 @@ uncons s = do

154155

155156{-# INLINE init #-}

156157init :: Monad m => Stream m a -> m ()

157−init s = do

158− r <- S.init s

159− case r of

160− Nothing -> return ()

161− Just x -> S.runStream x

158+init s = S.init s >>= Prelude.mapM_ S.runStream

162159

163160{-# INLINE tail #-}

164161tail :: Monad m => Stream m a -> m ()

165−tail s = do

166− r <- S.tail s

167− case r of

168− Nothing -> return ()

169− Just x -> tail x

162+tail s = S.tail s >>= Prelude.mapM_ tail

170163

171164{-# INLINE nullHeadTail #-}

172165nullHeadTail :: Monad m => Stream m Int -> m ()

173166nullHeadTail s = do

174167 r <- S.null s

175− if not r

176− then do

168+ when (not r) $ do

177169 _ <- S.head s

178− t <- S.tail s

179− case t of

180− Nothing -> return ()

181− Just x -> nullHeadTail x

182− else return ()

170+ S.tail s >>= Prelude.mapM_ nullHeadTail

183171

184172mapM_ = S.mapM_ (\_ -> return ())

185173toList = S.toList

@@ -254,7 +242,7 @@ mapM t = transform . t . S.mapM return

254242mapMaybe = transform . S.mapMaybe

255243 (\x -> if Prelude.odd x then Nothing else Just ())

256244mapMaybeM = transform . S.mapMaybeM

257− (\x -> if Prelude.odd x then (return Nothing) else return $ Just ())

245+ (\x -> if Prelude.odd x then return Nothing else return $ Just ())

258246sequence t = transform . t . S.sequence

259247filterEven = transform . S.filter even

260248filterAllOut = transform . S.filter (> maxValue)

@@ -285,19 +273,19 @@ zipAsync, zipAsyncM :: S.MonadAsync m => Stream m Int -> m ()

285273zip src = do

286274 r <- S.tail src

287275 let src1 = fromJust r

288− transform $ (S.zipWith (,) src src1)

276+ transform (S.zipWith (,) src src1)

289277zipM src = do

290278 r <- S.tail src

291279 let src1 = fromJust r

292− transform $ (S.zipWithM (\a b -> return (a,b)) src src1)

280+ transform (S.zipWithM (curry return) src src1)

293281zipAsync src = do

294282 r <- S.tail src

295283 let src1 = fromJust r

296− transform $ (S.zipAsyncWith (,) src src1)

284+ transform (S.zipAsyncWith (,) src src1)

297285zipAsyncM src = do

298286 r <- S.tail src

299287 let src1 = fromJust r

300− transform $ (S.zipAsyncWithM (\a b -> return (a,b)) src src1)

288+ transform (S.zipAsyncWithM (curry return) src src1)

301289concat _n = return ()

302290

303291-------------------------------------------------------------------------------

benchmark/LinearRate.hs+1−1

@@ -31,7 +31,7 @@ _benchId name f = bench name $ nf (runIdentity . f) (Ops.source 10)

3131-}

3232

3333main :: IO ()

34−main = do

34+main =

3535 defaultMain

3636 -- XXX arbitrarily large rate should be the same as rate Nothing

3737 [ bgroup "avgrate"

benchmark/Nested.hs+1−1

@@ -19,7 +19,7 @@ _benchId :: (NFData b) => String -> (Int -> Identity b) -> Benchmark

1919_benchId name f = bench name $ nf (\g -> runIdentity (g 1)) f

2020

2121main :: IO ()

22−main = do

22+main =

2323 -- TBD Study scaling with 10, 100, 1000 loop iterations

2424 defaultMain

2525 [ bgroup "serially"

benchmark/NestedOps.hs+5−5

@@ -48,7 +48,7 @@ sourceUnfoldr start n = S.unfoldr step start

4848 step cnt =

4949 if cnt > start + n

5050 then Nothing

51− else (Just (cnt, cnt + 1))

51+ else Just (cnt, cnt + 1)

5252

5353{-# INLINE runStream #-}

5454runStream :: Monad m => Stream m a -> m ()

@@ -98,7 +98,7 @@ filterAllOut t start = runStream . t $ do

9898 x <- source start prodCount

9999 y <- source start prodCount

100100 let s = x + y

101− if (s < 0)

101+ if s < 0

102102 then return s

103103 else S.nil

104104

@@ -110,7 +110,7 @@ filterAllIn t start = runStream . t $ do

110110 x <- source start prodCount

111111 y <- source start prodCount

112112 let s = x + y

113− if (s > 0)

113+ if s > 0

114114 then return s

115115 else S.nil

116116

@@ -122,7 +122,7 @@ filterSome t start = runStream . t $ do

122122 x <- source start prodCount

123123 y <- source start prodCount

124124 let s = x + y

125− if (s > 1100000)

125+ if s > 1100000

126126 then return s

127127 else S.nil

128128

@@ -135,7 +135,7 @@ breakAfterSome t start = do

135135 x <- source start prodCount

136136 y <- source start prodCount

137137 let s = x + y

138− if (s > 1100000)

138+ if s > 1100000

139139 then error "break"

140140 else return s

141141 return ()

benchmark/StreamDOps.hs+7−11

@@ -9,9 +9,10 @@

1010module StreamDOps where

1111

12+import Control.Monad (when)

1213import Prelude

1314 (Monad, Int, (+), ($), (.), return, (>), even, (<=),

14− subtract, undefined, Maybe(..), not)

15+ subtract, undefined, Maybe(..), not, mapM_, (>>=))

1516

1617import qualified Streamly.Streams.StreamD as S

1718

@@ -76,7 +77,7 @@ sourceUnfoldr n = S.unfoldr step n

7677 step cnt =

7778 if cnt > n + value

7879 then Nothing

79− else (Just (cnt, cnt + 1))

80+ else Just (cnt, cnt + 1)

8081

8182{-# INLINE sourceUnfoldrM #-}

8283sourceUnfoldrM :: Monad m => Int -> Stream m Int

@@ -97,7 +98,7 @@ sourceFromList n = S.fromList [n..n+value]

9798

9899{-# INLINE source #-}

99100source :: Monad m => Int -> Stream m Int

100−source n = sourceUnfoldrM n

101+source = sourceUnfoldrM

101102

102103-------------------------------------------------------------------------------

103104-- Elimination

@@ -115,14 +116,9 @@ uncons s = do

115116 Just (_, t) -> uncons t

116117nullHeadTail s = do

117118 r <- S.null s

118− if not r

119− then do

119+ when (not r) $ do

120120 _ <- S.head s

121− t <- S.tail s

122− case t of

123− Nothing -> return ()

124− Just x -> nullHeadTail x

125− else return ()

121+ S.tail s >>= mapM_ nullHeadTail

126122toList = S.toList

127123foldl = S.foldl' (+) 0

128124last = S.last

@@ -151,7 +147,7 @@ dropWhileTrue = transform . S.dropWhile (<= maxValue)

151147-- Zipping and concat

152148-------------------------------------------------------------------------------

153149

154−zip src = transform $ (S.zipWith (,) src src)

150+zip src = transform $ S.zipWith (,) src src

155151-- concat _n = return ()

156152

157153-------------------------------------------------------------------------------

benchmark/StreamKOps.hs+12−22

@@ -9,9 +9,10 @@

1010module StreamKOps where

1111

12+import Control.Monad (when)

1213import Prelude

1314 (Monad, Int, (+), ($), (.), return, fmap, even, (>), (<=),

14− subtract, undefined, Maybe(..), not)

15+ subtract, undefined, Maybe(..), not, mapM_, (>>=))

1516

1617import qualified Streamly.Streams.StreamK as S

1718import qualified Streamly.Streams.Prelude as S

@@ -76,7 +77,7 @@ sourceUnfoldr n = S.unfoldr step n

7677 step cnt =

7778 if cnt > n + value

7879 then Nothing

79− else (Just (cnt, cnt + 1))

80+ else Just (cnt, cnt + 1)

8081

8182{-# INLINE sourceUnfoldrM #-}

8283sourceUnfoldrM :: S.MonadAsync m => Int -> Stream m Int

@@ -105,15 +106,15 @@ sourceFromFoldableM n = S.fromFoldableM (Prelude.fmap return [n..n+value])

105106

106107{-# INLINE sourceFoldMapWith #-}

107108sourceFoldMapWith :: Int -> Stream m Int

108−sourceFoldMapWith n = S.foldMapWith (S.serial) S.yield [n..n+value]

109+sourceFoldMapWith n = S.foldMapWith S.serial S.yield [n..n+value]

109110

110111{-# INLINE sourceFoldMapWithM #-}

111112sourceFoldMapWithM :: Monad m => Int -> Stream m Int

112−sourceFoldMapWithM n = S.foldMapWith (S.serial) (S.yieldM . return) [n..n+value]

113+sourceFoldMapWithM n = S.foldMapWith S.serial (S.yieldM . return) [n..n+value]

113114

114115{-# INLINE source #-}

115116source :: S.MonadAsync m => Int -> Stream m Int

116−source n = sourceUnfoldrM n

117+source = sourceUnfoldrM

117118

118119-------------------------------------------------------------------------------

119120-- Elimination

@@ -133,31 +134,20 @@ uncons s = do

133134{-# INLINE init #-}

134135init :: (Monad m, S.IsStream t) => t m a -> m ()

135136init s = do

136− r <- S.init s

137− case r of

138− Nothing -> return ()

139− Just x -> S.runStream x

137+ t <- S.init s

138+ mapM_ S.runStream t

140139

141140{-# INLINE tail #-}

142141tail :: (Monad m, S.IsStream t) => t m a -> m ()

143−tail s = do

144− r <- S.tail s

145− case r of

146− Nothing -> return ()

147− Just x -> tail x

142+tail s = S.tail s >>= mapM_ tail

148143

149144-- | If the stream is not null get its head and tail and then do the same to

150145-- the tail.

151146nullHeadTail s = do

152147 r <- S.null s

153− if not r

154− then do

148+ when (not r) $ do

155149 _ <- S.head s

156− t <- S.tail s

157− case t of

158− Nothing -> return ()

159− Just x -> nullHeadTail x

160− else return ()

150+ S.tail s >>= mapM_ nullHeadTail

161151

162152toList = S.toList

163153foldl = S.foldl' (+) 0

@@ -187,7 +177,7 @@ dropWhileTrue = transform . S.dropWhile (<= maxValue)

187177-- Zipping and concat

188178-------------------------------------------------------------------------------

189179

190−zip src = transform $ (S.zipWith (,) src src)

180+zip src = transform $ S.zipWith (,) src src

191181concat _n = return ()

192182

193183-------------------------------------------------------------------------------