f0398ee · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Add benchmarking for fromParserK

f0398eeHarendra Kumar6 years ago

benchmark/Streamly/Benchmark/Data/Parser/ParserK.hs+19−11

compare with master

unifiedsplit

@@ -5,7 +5,9 @@

5-- License : BSD-3-Clause

6-- Maintainer : streamly@composewell.com

8+{-# LANGUAGE CPP #-}

8{-# LANGUAGE FlexibleContexts #-}

9{-# LANGUAGE FlexibleContexts #-}

10+{-# OPTIONS_GHC -fspec-constr-recursive=4 #-}

10module Main

12module Main

11 (

13 (

@@ -59,6 +61,12 @@ benchIOSink value name f =

59-- Parsers

61-- Parsers

60-------------------------------------------------------------------------------

62-------------------------------------------------------------------------------

64+#ifdef FROM_PARSERK

65+#define PARSE_OP (IP.parseD . PRD.fromParserK)

66+#else

67+#define PARSE_OP IP.parseK

68+#endif

69+

62{-# INLINE satisfy #-}

70{-# INLINE satisfy #-}

63satisfy :: MonadCatch m => (a -> Bool) -> PR.Parser m a a

71satisfy :: MonadCatch m => (a -> Bool) -> PR.Parser m a a

64satisfy = PRD.toParserK . PRD.satisfy

72satisfy = PRD.toParserK . PRD.satisfy

@@ -69,7 +77,7 @@ any = PRD.toParserK . PRD.any

70{-# INLINE anyK #-}

78{-# INLINE anyK #-}

71anyK :: (MonadCatch m, Ord a) => a -> SerialT m a -> m Bool

79anyK :: (MonadCatch m, Ord a) => a -> SerialT m a -> m Bool

72−anyK value = IP.parseK (any (> value))

80+anyK value = PARSE_OP (any (> value))

74{-# INLINE all #-}

82{-# INLINE all #-}

75all :: MonadCatch m => (a -> Bool) -> PR.Parser m a Bool

83all :: MonadCatch m => (a -> Bool) -> PR.Parser m a Bool

@@ -77,7 +85,7 @@ all = PRD.toParserK . PRD.all

78{-# INLINE allK #-}

86{-# INLINE allK #-}

79allK :: (MonadCatch m, Ord a) => a -> SerialT m a -> m Bool

87allK :: (MonadCatch m, Ord a) => a -> SerialT m a -> m Bool

80−allK value = IP.parseK (all (<= value))

88+allK value = PARSE_OP (all (<= value))

82{-# INLINE take #-}

90{-# INLINE take #-}

83take :: MonadCatch m => Int -> PR.Parser m a ()

91take :: MonadCatch m => Int -> PR.Parser m a ()

@@ -85,7 +93,7 @@ take value = PRD.toParserK $ PRD.take value FL.drain

86{-# INLINE takeK #-}

94{-# INLINE takeK #-}

87takeK :: MonadCatch m => Int -> SerialT m a -> m ()

95takeK :: MonadCatch m => Int -> SerialT m a -> m ()

88−takeK value = IP.parseK (take value)

96+takeK value = PARSE_OP (take value)

90{-# INLINE takeWhile #-}

98{-# INLINE takeWhile #-}

91takeWhile :: MonadCatch m => (a -> Bool) -> PR.Parser m a ()

99takeWhile :: MonadCatch m => (a -> Bool) -> PR.Parser m a ()

@@ -93,20 +101,20 @@ takeWhile p = PRD.toParserK $ PRD.takeWhile p FL.drain

101

94{-# INLINE takeWhileK #-}

102{-# INLINE takeWhileK #-}

95takeWhileK :: MonadCatch m => Int -> SerialT m Int -> m ()

103takeWhileK :: MonadCatch m => Int -> SerialT m Int -> m ()

96−takeWhileK value = IP.parseK (takeWhile (<= value))

104+takeWhileK value = PARSE_OP (takeWhile (<= value))

105

98{-# INLINE splitApp #-}

106{-# INLINE splitApp #-}

99splitApp :: MonadCatch m

107splitApp :: MonadCatch m

100 => Int -> SerialT m Int -> m (Bool, Bool)

108 => Int -> SerialT m Int -> m (Bool, Bool)

101splitApp value =

109splitApp value =

102− IP.parseK ((,) <$> any (>= (value `div` 2)) <*> any (> value))

110+ PARSE_OP ((,) <$> any (>= (value `div` 2)) <*> any (> value))

103

111

104{-# INLINE sequenceA #-}

112{-# INLINE sequenceA #-}

105sequenceA :: MonadCatch m => Int -> SerialT m Int -> m Int

113sequenceA :: MonadCatch m => Int -> SerialT m Int -> m Int

106sequenceA value xs = do

114sequenceA value xs = do

107 let parser = satisfy (> 0)

115 let parser = satisfy (> 0)

108 list = Prelude.replicate value parser

116 list = Prelude.replicate value parser

109− x <- IP.parseK (TR.sequenceA list) xs

117+ x <- PARSE_OP (TR.sequenceA list) xs

110 return $ Prelude.length x

118 return $ Prelude.length x

111

119

112{-# INLINE sequenceA_ #-}

120{-# INLINE sequenceA_ #-}

@@ -114,32 +122,32 @@ sequenceA_ :: MonadCatch m => Int -> SerialT m Int -> m ()

114sequenceA_ value xs = do

122sequenceA_ value xs = do

115 let parser = satisfy (> 0)

123 let parser = satisfy (> 0)

116 list = Prelude.replicate value parser

124 list = Prelude.replicate value parser

117− IP.parseK (F.sequenceA_ list) xs

125+ PARSE_OP (F.sequenceA_ list) xs

118

126

119{-# INLINE sequence #-}

127{-# INLINE sequence #-}

120sequence :: MonadCatch m => Int -> SerialT m Int -> m Int

128sequence :: MonadCatch m => Int -> SerialT m Int -> m Int

121sequence value xs = do

129sequence value xs = do

122 let parser = satisfy (> 0)

130 let parser = satisfy (> 0)

123 list = Prelude.replicate value parser

131 list = Prelude.replicate value parser

124− x <- IP.parseK (TR.sequence list) xs

132+ x <- PARSE_OP (TR.sequence list) xs

125 return $ Prelude.length x

133 return $ Prelude.length x

126

134

127{-# INLINE manyAlt #-}

135{-# INLINE manyAlt #-}

128manyAlt :: MonadCatch m => SerialT m Int -> m Int

136manyAlt :: MonadCatch m => SerialT m Int -> m Int

129manyAlt xs = do

137manyAlt xs = do

130− x <- IP.parseK (AP.many (satisfy (> 0))) xs

138+ x <- PARSE_OP (AP.many (satisfy (> 0))) xs

131 return $ Prelude.length x

139 return $ Prelude.length x

132

140

133{-# INLINE someAlt #-}

141{-# INLINE someAlt #-}

134someAlt :: MonadCatch m => SerialT m Int -> m Int

142someAlt :: MonadCatch m => SerialT m Int -> m Int

135someAlt xs = do

143someAlt xs = do

136− x <- IP.parseK (AP.some (satisfy (> 0))) xs

144+ x <- PARSE_OP (AP.some (satisfy (> 0))) xs

137 return $ Prelude.length x

145 return $ Prelude.length x

138

146

139{-# INLINE choice #-}

147{-# INLINE choice #-}

140choice :: MonadCatch m => Int -> SerialT m Int -> m Int

148choice :: MonadCatch m => Int -> SerialT m Int -> m Int

141choice value =

149choice value =

142− IP.parseK (asum (replicate value (satisfy (< 0)))

150+ PARSE_OP (asum (replicate value (satisfy (< 0)))

143 AP.<|> satisfy (> 0))

151 AP.<|> satisfy (> 0))

144

152

145-------------------------------------------------------------------------------

153-------------------------------------------------------------------------------

benchmark/streamly-benchmarks.cabal+16

@@ -275,6 +275,22 @@ benchmark Data.Parser.ParserK

275 buildable: True

276 build-depends: exceptions >= 0.8 && < 0.11

277

278+-- Note: to use this we have to set DISABLE_FUSION in ParserD.hs so that

279+-- the rewrite rules are disabled. We can also use the "no-fusion" build

280+-- flag but we need to keep in mind that it disables fusion for streams

281+-- as well.

282+benchmark Data.Parser.FromParserK

283+ import: bench-options

284+ type: exitcode-stdio-1.0

285+ hs-source-dirs: Streamly/Benchmark/Data/Parser

286+ cpp-options: -DFROM_PARSERK

287+ main-is: ParserK.hs

288+ if impl(ghcjs)

289+ buildable: False

290+ else

291+ buildable: True

292+ build-depends: exceptions >= 0.8 && < 0.11

293+

278benchmark Data.Parser

294benchmark Data.Parser

279 import: bench-options

295 import: bench-options

280 type: exitcode-stdio-1.0

296 type: exitcode-stdio-1.0