c718880 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Add micro benchmarks for multiple exposed functions in Prelude

c718880adithyaov6 years ago

benchmark/Streamly/Benchmark/FileSystem/Handle/ReadWrite.hs+24−1

compare with master

unifiedsplit

@@ -24,7 +24,7 @@ module Handle.ReadWrite

24where

26import Control.Exception (SomeException)

27−import System.IO (Handle, hClose)

27+import System.IO (Handle, hClose, hGetChar)

28import Prelude hiding (last, length)

30import qualified Streamly.Data.Fold as FL

@@ -403,6 +403,23 @@ fromToBytesBracketStream inh devNull =

403 (\_ -> IFH.toBytes inh)

404 in IFH.fromBytes devNull $ readEx

405

406+readWriteBeforeAfterStream :: Handle -> Handle -> IO ()

407+readWriteBeforeAfterStream inh devNull =

408+ let readEx =

409+ IP.after (hClose inh)

410+ $ IP.before (hGetChar inh) (S.unfold FH.read inh)

411+ in S.fold (FH.write devNull) readEx

412+

413+readWriteAfterStream :: Handle -> Handle -> IO ()

414+readWriteAfterStream inh devNull =

415+ let readEx = IP.after (hClose inh) (S.unfold FH.read inh)

416+ in S.fold (FH.write devNull) readEx

417+

418+readWriteAfter_Stream :: Handle -> Handle -> IO ()

419+readWriteAfter_Stream inh devNull =

420+ let readEx = IP.after_ (hClose inh) (S.unfold FH.read inh)

421+ in S.fold (FH.write devNull) readEx

422+

406o_1_space_copy_stream_exceptions :: BenchEnv -> [Benchmark]

423o_1_space_copy_stream_exceptions :: BenchEnv -> [Benchmark]

407o_1_space_copy_stream_exceptions env =

424o_1_space_copy_stream_exceptions env =

408 [ bgroup "copy/read/exceptions"

425 [ bgroup "copy/read/exceptions"

@@ -414,6 +431,12 @@ o_1_space_copy_stream_exceptions env =

414 readWriteFinally_Stream inh (nullH env)

431 readWriteFinally_Stream inh (nullH env)

415 , mkBenchSmall "S.finally" env $ \inh _ ->

432 , mkBenchSmall "S.finally" env $ \inh _ ->

416 readWriteFinallyStream inh (nullH env)

433 readWriteFinallyStream inh (nullH env)

434+ , mkBenchSmall "S.after . S.before" env $ \inh _ ->

435+ readWriteBeforeAfterStream inh (nullH env)

436+ , mkBenchSmall "S.after" env $ \inh _ ->

437+ readWriteAfterStream inh (nullH env)

438+ , mkBenchSmall "S.after_" env $ \inh _ ->

439+ readWriteAfter_Stream inh (nullH env)

417 ]

440 ]

418 , bgroup "copy/fromToBytes/exceptions"

441 , bgroup "copy/fromToBytes/exceptions"

419 [ mkBenchSmall "S.bracket_" env $ \inh _ ->

442 [ mkBenchSmall "S.bracket_" env $ \inh _ ->

benchmark/Streamly/Benchmark/Prelude/Serial.hs+210−14

@@ -34,9 +34,10 @@ import Data.Functor.Identity (Identity, runIdentity)

34import Data.IORef (newIORef, modifyIORef')

35import GHC.Generics (Generic)

36import System.Random (randomRIO)

37+import Prelude hiding

37−import Prelude hiding (concatMap, mapM_, init, last, elem, notElem, all, any,

38+ ( concatMap, mapM_, init, last, elem, notElem, all, any

38− and, or, length, sum, product, maximum, minimum, reverse, fmap, map,

39+ , and, or, length, sum, product, maximum, minimum, reverse, fmap, map

39− sequence, mapM, tail)

40+ , sequence, mapM, tail, repeat, replicate, iterate, (!!), lookup)

41import qualified Control.Applicative as AP

42import qualified Control.Applicative as AP

42import qualified Prelude as P

43import qualified Prelude as P

@@ -50,14 +51,13 @@ import Test.Inspection

50import qualified Streamly.Internal.Data.Stream.StreamD as D

51import qualified Streamly.Internal.Data.Stream.StreamD as D

51#endif

52#endif

53−

54import qualified Streamly.Prelude as S

55import qualified Streamly.Internal.Data.Stream.IsStream as Internal

56import qualified Streamly.Internal.Data.Fold as FL

57import qualified Streamly.Internal.Data.Unfold as UF

59import Gauge

60−import Streamly.Prelude (SerialT, IsStream, serially, serial)

60+import Streamly.Prelude (SerialT, IsStream, serially, serial, MonadAsync)

61import Streamly.Benchmark.Common

62import Streamly.Benchmark.Prelude

63import Streamly.Internal.Data.Time.Units

@@ -98,11 +98,70 @@ readInstanceList str =

98 [(x,"")] -> x

99 _ -> P.error "readInstance: no parse"

100

101+{-# INLINE repeat #-}

102+repeat :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

103+repeat count = S.take count . S.repeat

104+

105+{-# INLINE repeatM #-}

106+repeatM :: (MonadAsync m, S.IsStream t) => Int -> Int -> t m Int

107+repeatM count = S.take count . S.repeatM . return

108+

109+{-# INLINE replicate #-}

110+replicate :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

111+replicate count = S.replicate count

112+

113+{-# INLINE replicateM #-}

114+replicateM :: (MonadAsync m, S.IsStream t) => Int -> Int -> t m Int

115+replicateM count = S.replicateM count . return

116+

117+{-# INLINE enumerateFrom #-}

118+enumerateFrom :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

119+enumerateFrom count = S.take count . S.enumerateFrom

120+

121+{-# INLINE enumerateFromTo #-}

122+enumerateFromTo :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

123+enumerateFromTo = sourceIntFromTo

124+

125+{-# INLINE enumerateFromThen #-}

126+enumerateFromThen :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

127+enumerateFromThen count inp = S.take count $ S.enumerateFromThen inp (inp + 1)

128+

129+{-# INLINE enumerateFromThenTo #-}

130+enumerateFromThenTo :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

131+enumerateFromThenTo = sourceIntFromThenTo

132+

133+-- XXX enumerate?

134+-- XXX enumerateTo?

135+

136+{-# INLINE iterate #-}

137+iterate :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

138+iterate count = S.take count . S.iterate (+1)

139+

140+{-# INLINE iterateM #-}

141+iterateM :: (MonadAsync m, S.IsStream t) => Int -> Int -> t m Int

142+iterateM count = S.take count . S.iterateM (return . (+1)) . return

143+

144+{-# INLINE fromIndices #-}

145+fromIndices :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

146+fromIndices value n = S.take value $ S.fromIndices (+ n)

147+

148+{-# INLINE fromIndicesM #-}

149+fromIndicesM :: (MonadAsync m, S.IsStream t) => Int -> Int -> t m Int

150+fromIndicesM value n = S.take value $ S.fromIndicesM (return <$> (+ n))

151+

101o_1_space_generation :: Int -> [Benchmark]

152o_1_space_generation :: Int -> [Benchmark]

102o_1_space_generation value =

153o_1_space_generation value =

103 [ bgroup "generation"

154 [ bgroup "generation"

104 [ benchIOSrc serially "unfoldr" (sourceUnfoldr value)

155 [ benchIOSrc serially "unfoldr" (sourceUnfoldr value)

105 , benchIOSrc serially "unfoldrM" (sourceUnfoldrM value)

156 , benchIOSrc serially "unfoldrM" (sourceUnfoldrM value)

157+ , benchIOSrc serially "repeat" (repeat value)

158+ , benchIOSrc serially "repeatM" (repeatM value)

159+ , benchIOSrc serially "replicate" (replicate value)

160+ , benchIOSrc serially "replicateM" (replicateM value)

161+ , benchIOSrc serially "iterate" (iterate value)

162+ , benchIOSrc serially "iterateM" (iterateM value)

163+ , benchIOSrc serially "fromIndices" (fromIndices value)

164+ , benchIOSrc serially "fromIndicesM" (fromIndicesM value)

106 , benchIOSrc serially "intFromTo" (sourceIntFromTo value)

165 , benchIOSrc serially "intFromTo" (sourceIntFromTo value)

107 , benchIOSrc serially "intFromThenTo" (sourceIntFromThenTo value)

166 , benchIOSrc serially "intFromThenTo" (sourceIntFromThenTo value)

108 , benchIOSrc serially "integerFromStep" (sourceIntegerFromStep value)

167 , benchIOSrc serially "integerFromStep" (sourceIntegerFromStep value)

@@ -459,6 +518,26 @@ minimumBy = S.minimumBy compare

459maximumBy :: Monad m => SerialT m Int -> m (Maybe Int)

518maximumBy :: Monad m => SerialT m Int -> m (Maybe Int)

460maximumBy = S.maximumBy compare

519maximumBy = S.maximumBy compare

461

520

521+{-# INLINE the #-}

522+the :: Monad m => SerialT m Int -> m (Maybe Int)

523+the = S.the

524+

525+{-# INLINE drainN #-}

526+drainN :: Monad m => Int -> SerialT m Int -> m ()

527+drainN val = S.drainN val

528+

529+{-# INLINE drainWhile #-}

530+drainWhile :: Monad m => SerialT m Int -> m ()

531+drainWhile = S.drainWhile (const True)

532+

533+{-# INLINE (!!) #-}

534+(!!) :: Monad m => Int -> SerialT m Int -> m (Maybe Int)

535+(!!) val = flip (Internal.!!) val

536+

537+{-# INLINE lookup #-}

538+lookup :: Monad m => Int -> SerialT m Int -> m (Maybe Int)

539+lookup val = S.lookup val . S.map (\x -> (x, x))

540+

462o_1_space_elimination_folds :: Int -> [Benchmark]

541o_1_space_elimination_folds :: Int -> [Benchmark]

463o_1_space_elimination_folds value =

542o_1_space_elimination_folds value =

464 [ bgroup "elimination"

543 [ bgroup "elimination"

@@ -496,6 +575,8 @@ o_1_space_elimination_folds value =

496

575

497 -- draining

576 -- draining

498 , benchIOSink value "drain" $ toNull serially

577 , benchIOSink value "drain" $ toNull serially

578+ , benchIOSink value "drainN" $ drainN value

579+ , benchIOSink value "drainWhile" $ drainWhile

499 , benchPureSink value "drain (pure)" P.id

580 , benchPureSink value "drain (pure)" P.id

500 , benchIOSink value "mapM_" mapM_

581 , benchIOSink value "mapM_" mapM_

501

582

@@ -512,8 +593,11 @@ o_1_space_elimination_folds value =

512 , benchIOSink value "minimumBy" minimumBy

593 , benchIOSink value "minimumBy" minimumBy

513 , benchIOSink value "minimum" minimum

594 , benchIOSink value "minimum" minimum

514

595

596+ , bench "the" $ nfIO $ randomRIO (1,1) >>= the . repeat value

515 , benchIOSink value "find" (find value)

597 , benchIOSink value "find" (find value)

516− -- , benchIOSink value "lookup" lookup

598+ -- , benchIOSink value "lookupFirst" (lookup 1)

599+ , benchIOSink value "lookupNever" (lookup (value + 1))

600+ , benchIOSink value "(!!)" ((!!) value)

517 , benchIOSink value "findIndex" (findIndex value)

601 , benchIOSink value "findIndex" (findIndex value)

518 , benchIOSink value "elemIndex" (elemIndex value)

602 , benchIOSink value "elemIndex" (elemIndex value)

519 -- this is too fast, causes all benchmarks reported in ns

603 -- this is too fast, causes all benchmarks reported in ns

@@ -764,10 +848,22 @@ o_n_space_traversable value =

764scan :: MonadIO m => Int -> SerialT m Int -> m ()

848scan :: MonadIO m => Int -> SerialT m Int -> m ()

765scan n = composeN n $ S.scanl' (+) 0

849scan n = composeN n $ S.scanl' (+) 0

766

850

851+{-# INLINE scanlM' #-}

852+scanlM' :: MonadIO m => Int -> SerialT m Int -> m ()

853+scanlM' n = composeN n $ S.scanlM' (\b a -> return $ b + a) 0

854+

767{-# INLINE scanl1' #-}

855{-# INLINE scanl1' #-}

768scanl1' :: MonadIO m => Int -> SerialT m Int -> m ()

856scanl1' :: MonadIO m => Int -> SerialT m Int -> m ()

769scanl1' n = composeN n $ S.scanl1' (+)

857scanl1' n = composeN n $ S.scanl1' (+)

770

858

859+{-# INLINE postscanl' #-}

860+postscanl' :: MonadIO m => Int -> SerialT m Int -> m ()

861+postscanl' n = composeN n $ S.postscanl' (+) 0

862+

863+{-# INLINE postscanlM' #-}

864+postscanlM' :: MonadIO m => Int -> SerialT m Int -> m ()

865+postscanlM' n = composeN n $ S.postscanlM' (\b a -> return $ b + a) 0

866+

771{-# INLINE sequence #-}

867{-# INLINE sequence #-}

772sequence ::

868sequence ::

773 (S.IsStream t, S.MonadAsync m)

869 (S.IsStream t, S.MonadAsync m)

@@ -815,6 +911,11 @@ foldrT n = composeN n $ Internal.foldrT S.cons S.nil

815foldrTMap :: MonadIO m => Int -> SerialT m Int -> m ()

911foldrTMap :: MonadIO m => Int -> SerialT m Int -> m ()

816foldrTMap n = composeN n $ Internal.foldrT (\x xs -> x + 1 `S.cons` xs) S.nil

912foldrTMap n = composeN n $ Internal.foldrT (\x xs -> x + 1 `S.cons` xs) S.nil

817

913

914+

915+{-# INLINE trace #-}

916+trace :: MonadAsync m => Int -> SerialT m Int -> m ()

917+trace n = composeN n $ Internal.trace return

918+

818o_1_space_mapping :: Int -> [Benchmark]

919o_1_space_mapping :: Int -> [Benchmark]

819o_1_space_mapping value =

920o_1_space_mapping value =

820 [ bgroup

921 [ bgroup

@@ -839,6 +940,9 @@ o_1_space_mapping value =

839 -- Scanning

940 -- Scanning

840 , benchIOSink value "scanl'" (scan 1)

941 , benchIOSink value "scanl'" (scan 1)

841 , benchIOSink value "scanl1'" (scanl1' 1)

942 , benchIOSink value "scanl1'" (scanl1' 1)

943+ , benchIOSink value "scanlM'" (scanlM' 1)

944+ , benchIOSink value "postscanl'" (postscanl' 1)

945+ , benchIOSink value "postscanlM'" (postscanlM' 1)

842

946

843 ]

947 ]

844 ]

948 ]

@@ -848,9 +952,13 @@ o_1_space_mappingX4 value =

848 [ bgroup "mappingX4"

952 [ bgroup "mappingX4"

849 [ benchIOSink value "map" (mapN serially 4)

953 [ benchIOSink value "map" (mapN serially 4)

850 , benchIOSink value "mapM" (mapM serially 4)

954 , benchIOSink value "mapM" (mapM serially 4)

955+ , benchIOSink value "trace" (trace 4)

851

956

852 , benchIOSink value "scan" (scan 4)

957 , benchIOSink value "scan" (scan 4)

853 , benchIOSink value "scanl1'" (scanl1' 4)

958 , benchIOSink value "scanl1'" (scanl1' 4)

959+ , benchIOSink value "scanlM'" (scanlM' 4)

960+ , benchIOSink value "postscanl'" (postscanl' 4)

961+ , benchIOSink value "postscanlM'" (postscanlM' 4)

854

962

855 ]

963 ]

856 ]

964 ]

@@ -972,6 +1080,18 @@ filterAllOut value n = composeN n $ S.filter (> (value + 1))

972filterAllIn :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

1080filterAllIn :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

973filterAllIn value n = composeN n $ S.filter (<= (value + 1))

1081filterAllIn value n = composeN n $ S.filter (<= (value + 1))

974

1082

1083+{-# INLINE filterMEven #-}

1084+filterMEven :: MonadIO m => Int -> SerialT m Int -> m ()

1085+filterMEven n = composeN n $ S.filterM (return . even)

1086+

1087+{-# INLINE filterMAllOut #-}

1088+filterMAllOut :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

1089+filterMAllOut value n = composeN n $ S.filterM (\x -> return $ x > (value + 1))

1090+

1091+{-# INLINE filterMAllIn #-}

1092+filterMAllIn :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

1093+filterMAllIn value n = composeN n $ S.filterM (\x -> return $ x <= (value + 1))

1094+

975{-# INLINE _takeOne #-}

1095{-# INLINE _takeOne #-}

976_takeOne :: MonadIO m => Int -> SerialT m Int -> m ()

1096_takeOne :: MonadIO m => Int -> SerialT m Int -> m ()

977_takeOne n = composeN n $ S.take 1

1097_takeOne n = composeN n $ S.take 1

@@ -984,9 +1104,9 @@ takeAll value n = composeN n $ S.take (value + 1)

984takeWhileTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

1104takeWhileTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

985takeWhileTrue value n = composeN n $ S.takeWhile (<= (value + 1))

1105takeWhileTrue value n = composeN n $ S.takeWhile (<= (value + 1))

986

1106

987−{-# INLINE _takeWhileMTrue #-}

1107+{-# INLINE takeWhileMTrue #-}

988−_takeWhileMTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

1108+takeWhileMTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

989−_takeWhileMTrue value n = composeN n $ S.takeWhileM (return . (<= (value + 1)))

1109+takeWhileMTrue value n = composeN n $ S.takeWhileM (return . (<= (value + 1)))

990

1110

991{-# INLINE takeByTime #-}

1111{-# INLINE takeByTime #-}

992takeByTime :: NanoSecond64 -> Int -> SerialT IO Int -> IO ()

1112takeByTime :: NanoSecond64 -> Int -> SerialT IO Int -> IO ()

@@ -1010,14 +1130,23 @@ dropAll value n = composeN n $ S.drop (value + 1)

1010dropWhileTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

1130dropWhileTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

1011dropWhileTrue value n = composeN n $ S.dropWhile (<= (value + 1))

1131dropWhileTrue value n = composeN n $ S.dropWhile (<= (value + 1))

1012

1132

1013−{-# INLINE _dropWhileMTrue #-}

1133+{-# INLINE dropWhileMTrue #-}

1014−_dropWhileMTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

1134+dropWhileMTrue :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

1015−_dropWhileMTrue value n = composeN n $ S.dropWhileM (return . (<= (value + 1)))

1135+dropWhileMTrue value n = composeN n $ S.dropWhileM (return . (<= (value + 1)))

1016

1136

1017{-# INLINE dropWhileFalse #-}

1137{-# INLINE dropWhileFalse #-}

1018dropWhileFalse :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

1138dropWhileFalse :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

1019dropWhileFalse value n = composeN n $ S.dropWhile (> (value + 1))

1139dropWhileFalse value n = composeN n $ S.dropWhile (> (value + 1))

1020

1140

1141+-- XXX Decide on the time interval

1142+{-# INLINE _intervalsOfSum #-}

1143+_intervalsOfSum :: MonadAsync m => Double -> Int -> SerialT m Int -> m ()

1144+_intervalsOfSum i n = composeN n (S.intervalsOf i FL.sum)

1145+

1146+-- S.groups

1147+-- S.groupsBy

1148+-- S.groupsByRolling

1149+

1021{-# INLINE dropByTime #-}

1150{-# INLINE dropByTime #-}

1022dropByTime :: NanoSecond64 -> Int -> SerialT IO Int -> IO ()

1151dropByTime :: NanoSecond64 -> Int -> SerialT IO Int -> IO ()

1023dropByTime i n = composeN n (Internal.dropByTime i)

1152dropByTime i n = composeN n (Internal.dropByTime i)

@@ -1039,6 +1168,11 @@ elemIndices value n = composeN n $ S.elemIndices (value + 1)

1039deleteBy :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

1168deleteBy :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

1040deleteBy value n = composeN n $ S.deleteBy (>=) (value + 1)

1169deleteBy value n = composeN n $ S.deleteBy (>=) (value + 1)

1041

1170

1171+-- uniq . uniq == uniq, composeN 2 ~ composeN 1

1172+{-# INLINE uniq #-}

1173+uniq :: MonadIO m => Int -> SerialT m Int -> m ()

1174+uniq n = composeN n S.uniq

1175+

1042{-# INLINE mapMaybe #-}

1176{-# INLINE mapMaybe #-}

1043mapMaybe :: MonadIO m => Int -> SerialT m Int -> m ()

1177mapMaybe :: MonadIO m => Int -> SerialT m Int -> m ()

1044mapMaybe n =

1178mapMaybe n =

@@ -1066,6 +1200,10 @@ o_1_space_filtering value =

1066 , benchIOSink value "filter-all-out" (filterAllOut value 1)

1200 , benchIOSink value "filter-all-out" (filterAllOut value 1)

1067 , benchIOSink value "filter-all-in" (filterAllIn value 1)

1201 , benchIOSink value "filter-all-in" (filterAllIn value 1)

1068

1202

1203+ , benchIOSink value "filterM-even" (filterMEven 1)

1204+ , benchIOSink value "filterM-all-out" (filterMAllOut value 1)

1205+ , benchIOSink value "filterM-all-in" (filterMAllIn value 1)

1206+

1069 -- Trimming

1207 -- Trimming

1070 , benchIOSink value "take-all" (takeAll value 1)

1208 , benchIOSink value "take-all" (takeAll value 1)

1071 , benchIOSink

1209 , benchIOSink

@@ -1088,6 +1226,8 @@ o_1_space_filtering value =

1088 (dropWhileFalse value 1)

1226 (dropWhileFalse value 1)

1089 , benchIOSink value "deleteBy" (deleteBy value 1)

1227 , benchIOSink value "deleteBy" (deleteBy value 1)

1090

1228

1229+ , benchIOSink value "uniq" (uniq 1)

1230+

1091 -- Map and filter

1231 -- Map and filter

1092 , benchIOSink value "mapMaybe" (mapMaybe 1)

1232 , benchIOSink value "mapMaybe" (mapMaybe 1)

1093 , benchIOSink value "mapMaybeM" (mapMaybeM 1)

1233 , benchIOSink value "mapMaybeM" (mapMaybeM 1)

@@ -1105,20 +1245,26 @@ o_1_space_filteringX4 value =

1105 , benchIOSink value "filter-all-out" (filterAllOut value 4)

1245 , benchIOSink value "filter-all-out" (filterAllOut value 4)

1106 , benchIOSink value "filter-all-in" (filterAllIn value 4)

1246 , benchIOSink value "filter-all-in" (filterAllIn value 4)

1107

1247

1248+ , benchIOSink value "filterM-even" (filterMEven 4)

1249+ , benchIOSink value "filterM-all-out" (filterMAllOut value 4)

1250+ , benchIOSink value "filterM-all-in" (filterMAllIn value 4)

1251+

1108 -- trimming

1252 -- trimming

1109 , benchIOSink value "take-all" (takeAll value 4)

1253 , benchIOSink value "take-all" (takeAll value 4)

1110 , benchIOSink value "takeWhile-true" (takeWhileTrue value 4)

1254 , benchIOSink value "takeWhile-true" (takeWhileTrue value 4)

1111− -- , benchIOSink value "takeWhileM-true" (_takeWhileMTrue value 4)

1255+ , benchIOSink value "takeWhileM-true" (takeWhileMTrue value 4)

1112 , benchIOSink value "drop-one" (dropOne 4)

1256 , benchIOSink value "drop-one" (dropOne 4)

1113 , benchIOSink value "drop-all" (dropAll value 4)

1257 , benchIOSink value "drop-all" (dropAll value 4)

1114 , benchIOSink value "dropWhile-true" (dropWhileTrue value 4)

1258 , benchIOSink value "dropWhile-true" (dropWhileTrue value 4)

1115− -- , benchIOSink value "dropWhileM-true" (_dropWhileMTrue value 4)

1259+ , benchIOSink value "dropWhileM-true" (dropWhileMTrue value 4)

1116 , benchIOSink

1260 , benchIOSink

1117 value

1261 value

1118 "dropWhile-false"

1262 "dropWhile-false"

1119 (dropWhileFalse value 4)

1263 (dropWhileFalse value 4)

1120 , benchIOSink value "deleteBy" (deleteBy value 4)

1264 , benchIOSink value "deleteBy" (deleteBy value 4)

1121

1265

1266+ , benchIOSink value "uniq" (uniq 4)

1267+

1122 -- map and filter

1268 -- map and filter

1123 , benchIOSink value "mapMaybe" (mapMaybe 4)

1269 , benchIOSink value "mapMaybe" (mapMaybe 4)

1124 , benchIOSink value "mapMaybeM" (mapMaybeM 4)

1270 , benchIOSink value "mapMaybeM" (mapMaybeM 4)

@@ -1137,6 +1283,10 @@ o_1_space_filteringX4 value =

1137intersperse :: S.MonadAsync m => Int -> Int -> SerialT m Int -> m ()

1283intersperse :: S.MonadAsync m => Int -> Int -> SerialT m Int -> m ()

1138intersperse value n = composeN n $ S.intersperse (value + 1)

1284intersperse value n = composeN n $ S.intersperse (value + 1)

1139

1285

1286+{-# INLINE intersperseM #-}

1287+intersperseM :: S.MonadAsync m => Int -> Int -> SerialT m Int -> m ()

1288+intersperseM value n = composeN n $ S.intersperseM (return $ value + 1)

1289+

1140{-# INLINE insertBy #-}

1290{-# INLINE insertBy #-}

1141insertBy :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

1291insertBy :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

1142insertBy value n = composeN n $ S.insertBy compare (value + 1)

1292insertBy value n = composeN n $ S.insertBy compare (value + 1)

@@ -1145,6 +1295,7 @@ o_1_space_inserting :: Int -> [Benchmark]

1145o_1_space_inserting value =

1295o_1_space_inserting value =

1146 [ bgroup "filtering"

1296 [ bgroup "filtering"

1147 [ benchIOSink value "intersperse" (intersperse value 1)

1297 [ benchIOSink value "intersperse" (intersperse value 1)

1298+ , benchIOSink value "intersperseM" (intersperseM value 1)

1148 , benchIOSink value "insertBy" (insertBy value 1)

1299 , benchIOSink value "insertBy" (insertBy value 1)

1149 ]

1300 ]

1150 ]

1301 ]

@@ -1157,6 +1308,34 @@ o_1_space_insertingX4 value =

1157 ]

1308 ]

1158 ]

1309 ]

1159

1310

1311+-------------------------------------------------------------------------------

1312+-- Indexing

1313+-------------------------------------------------------------------------------

1314+

1315+{-# INLINE indexed #-}

1316+indexed :: MonadIO m => Int -> SerialT m Int -> m ()

1317+indexed n = composeN n (S.map snd . S.indexed)

1318+

1319+{-# INLINE indexedR #-}

1320+indexedR :: MonadIO m => Int -> Int -> SerialT m Int -> m ()

1321+indexedR value n = composeN n (S.map snd . S.indexedR value)

1322+

1323+o_1_space_indexing :: Int -> [Benchmark]

1324+o_1_space_indexing value =

1325+ [ bgroup "indexing"

1326+ [ benchIOSink value "indexed" (indexed 1)

1327+ , benchIOSink value "indexedR" (indexedR value 1)

1328+ ]

1329+ ]

1330+

1331+o_1_space_indexingX4 :: Int -> [Benchmark]

1332+o_1_space_indexingX4 value =

1333+ [ bgroup "indexingx4"

1334+ [ benchIOSink value "indexed" (indexed 4)

1335+ , benchIOSink value "indexedR" (indexedR value 4)

1336+ ]

1337+ ]

1338+

1160-------------------------------------------------------------------------------

1339-------------------------------------------------------------------------------

1161-- Reordering

1340-- Reordering

1162-------------------------------------------------------------------------------

1341-------------------------------------------------------------------------------

@@ -1465,10 +1644,23 @@ mergeBy count n =

1465 (sourceUnfoldrM count n)

1644 (sourceUnfoldrM count n)

1466 (sourceUnfoldrM count (n + 1))

1645 (sourceUnfoldrM count (n + 1))

1467

1646

1647+{-# INLINE mergeByM #-}

1648+mergeByM :: Int -> Int -> IO ()

1649+mergeByM count n =

1650+ S.drain $

1651+ S.mergeByM

1652+ (\a b -> return $ P.compare a b)

1653+ (sourceUnfoldrM count n)

1654+ (sourceUnfoldrM count (n + 1))

1655+

1468#ifdef INSPECTION

1656#ifdef INSPECTION

1469inspect $ hasNoTypeClasses 'mergeBy

1657inspect $ hasNoTypeClasses 'mergeBy

1470inspect $ 'mergeBy `hasNoType` ''SPEC

1658inspect $ 'mergeBy `hasNoType` ''SPEC

1471inspect $ 'mergeBy `hasNoType` ''D.Step

1659inspect $ 'mergeBy `hasNoType` ''D.Step

1660+

1661+inspect $ hasNoTypeClasses 'mergeByM

1662+inspect $ 'mergeByM `hasNoType` ''SPEC

1663+inspect $ 'mergeByM `hasNoType` ''D.Step

1472#endif

1664#endif

1473

1665

1474o_1_space_joining :: Int -> [Benchmark]

1666o_1_space_joining :: Int -> [Benchmark]

@@ -1479,6 +1671,7 @@ o_1_space_joining value =

1479 , benchIOSrc1 "serial (2,2,x/4)" (serial4 (value `div` 4))

1671 , benchIOSrc1 "serial (2,2,x/4)" (serial4 (value `div` 4))

1480 , benchIOSrc1 "append (2,2,x/4)" (append4 (value `div` 4))

1672 , benchIOSrc1 "append (2,2,x/4)" (append4 (value `div` 4))

1481 , benchIOSrc1 "mergeBy (2,x/2)" (mergeBy (value `div` 2))

1673 , benchIOSrc1 "mergeBy (2,x/2)" (mergeBy (value `div` 2))

1674+ , benchIOSrc1 "mergeByM (2,x/2)" (mergeByM (value `div` 2))

1482 ]

1675 ]

1483 ]

1676 ]

1484

1677

@@ -1790,6 +1983,7 @@ o_n_heap_transformer value =

1790 ]

1983 ]

1791 ]

1984 ]

1792

1985

1986+

1793-------------------------------------------------------------------------------

1987-------------------------------------------------------------------------------

1794-- Main

1988-- Main

1795-------------------------------------------------------------------------------

1989-------------------------------------------------------------------------------

@@ -1824,6 +2018,8 @@ main = do

1824 , o_1_space_insertingX4 size

2018 , o_1_space_insertingX4 size

1825 , o_1_space_transformations_mixed size

2019 , o_1_space_transformations_mixed size

1826 , o_1_space_transformations_mixedX4 size

2020 , o_1_space_transformations_mixedX4 size

2021+ , o_1_space_indexing size

2022+ , o_1_space_indexingX4 size

1827

2023

1828 -- pipes

2024 -- pipes

1829 , o_1_space_pipes size

2025 , o_1_space_pipes size

benchmark/lib/Streamly/Benchmark/Prelude.hs−12

@@ -95,18 +95,6 @@ sourceUnfoldrMSerial count start = Serial.unfoldrM step start

95 then return Nothing

96 else return (Just (cnt, cnt + 1))

98−-------------------------------------------------------------------------------

99−-- fromIndices

100−-------------------------------------------------------------------------------

101−

102−{-# INLINE _sourceFromIndices #-}

103−_sourceFromIndices :: (Monad m, S.IsStream t) => Int -> Int -> t m Int

104−_sourceFromIndices value n = S.take value $ S.fromIndices (+ n)

105−

106−{-# INLINE _sourceFromIndicesM #-}

107−_sourceFromIndicesM :: (S.MonadAsync m, S.IsStream t) => Int -> Int -> t m Int

108−_sourceFromIndicesM value n = S.take value $ S.fromIndicesM (fmap return (+ n))

109−

110-------------------------------------------------------------------------------

98-------------------------------------------------------------------------------

111-- fromList

99-- fromList

112-------------------------------------------------------------------------------

100-------------------------------------------------------------------------------