f8afec6 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Comment out benchmarking code for pipes ops.

f8afec6Pranay Sashank7 years ago

benchmark/Linear.hs+5−5

compare with master

unifiedsplit

@@ -20,7 +20,7 @@ import qualified LinearOps as Ops

21import Streamly

22import qualified Streamly.Fold as FL

23−import qualified Streamly.Pipe as Pipe

23+--import qualified Streamly.Pipe as Pipe

24import qualified Streamly.Mem.Array as A

25import qualified Streamly.Prelude as S

26-- import qualified Streamly.Sink as Sink

@@ -242,15 +242,15 @@ main =

242 , bgroup "folds-transforms"

243 [ benchIOSink "drain" (FL.foldl' FL.drain)

244 , benchIOSink "lmap" (FL.foldl' (FL.lmap (+1) FL.drain))

245− , benchIOSink "pipe-mapM"

245+ {-, benchIOSink "pipe-mapM"

246− (FL.foldl' (FL.transform (Pipe.mapM (\x -> return $ x + 1)) FL.drain))

246+ (FL.foldl' (FL.transform (Pipe.mapM (\x -> return $ x + 1)) FL.drain))-}

247 ]

248 , bgroup "folds-compositions" -- Applicative

249 [

250 benchIOSink "all,any" (FL.foldl' ((,) <$> FL.all (<= Ops.maxValue)

251 <*> FL.any (> Ops.maxValue)))

252 , benchIOSink "sum,length" (FL.foldl' ((,) <$> FL.sum <*> FL.length))

253− ]

253+ ] {-

254 , bgroup "pipes"

255 [ benchIOSink "mapM" (Ops.transformMapM serially 1)

256 , benchIOSink "compose" (Ops.transformComposeMapM serially 1)

@@ -262,7 +262,7 @@ main =

262 , benchIOSink "compose" (Ops.transformComposeMapM serially 4)

263 , benchIOSink "tee" (Ops.transformTeeMapM serially 4)

264 , benchIOSink "zip" (Ops.transformZipMapM serially 4)

265− ]

265+ ] -}

266 , bgroup "transformation"

267 [ benchIOSink "scanl" (Ops.scan 1)

268 , benchIOSink "scanl1'" (Ops.scanl1' 1)

benchmark/LinearOps.hs+15−7

@@ -30,7 +30,7 @@ import GHC.Generics (Generic)

31import qualified Streamly as S hiding (foldMapWith, runStream)

32import qualified Streamly.Prelude as S

33−import qualified Streamly.Pipe as Pipe

33+-- import qualified Streamly.Pipe as Pipe

35value, maxValue, value2 :: Int

36#ifdef LINEAR_ASYNC

@@ -370,14 +370,9 @@ scan, scanl1', map, fmap, mapMaybe, filterEven, filterAllOut,

370mapMaybeM, intersperse :: S.MonadAsync m => Int -> Stream m Int -> m ()

371

372{-# INLINE mapM #-}

373−{-# INLINE transformMapM #-}

374−{-# INLINE transformComposeMapM #-}

375−{-# INLINE transformTeeMapM #-}

376−{-# INLINE transformZipMapM #-}

377{-# INLINE map' #-}

373{-# INLINE map' #-}

378{-# INLINE fmap' #-}

374{-# INLINE fmap' #-}

379−mapM, map', transformMapM, transformComposeMapM, transformTeeMapM,

380− transformZipMapM :: (S.IsStream t, S.MonadAsync m)

375+mapM, map' :: (S.IsStream t, S.MonadAsync m)

381 => (t m Int -> S.SerialT m Int) -> Int -> t m Int -> m ()

376 => (t m Int -> S.SerialT m Int) -> Int -> t m Int -> m ()

382

377

383fmap' :: (S.IsStream t, S.MonadAsync m, P.Functor (t m))

378fmap' :: (S.IsStream t, S.MonadAsync m, P.Functor (t m))

@@ -395,6 +390,18 @@ map n = composeN n $ S.map (+1)

395map' t n = composeN' n $ t . S.map (+1)

390map' t n = composeN' n $ t . S.map (+1)

396mapM t n = composeN' n $ t . S.mapM return

391mapM t n = composeN' n $ t . S.mapM return

397

392

393+-- Temporarily commented these ops as they depend on the hidden

394+-- Pipe module.

395+{-

396+{-# INLINE transformMapM #-}

397+{-# INLINE transformComposeMapM #-}

398+{-# INLINE transformTeeMapM #-}

399+{-# INLINE transformZipMapM #-}

400+

401+transformMapM, transformComposeMapM, transformTeeMapM,

402+ transformZipMapM :: (S.IsStream t, S.MonadAsync m)

403+ => (t m Int -> S.SerialT m Int) -> Int -> t m Int -> m ()

404+

398transformMapM t n = composeN' n $ t . S.transform (Pipe.mapM return)

405transformMapM t n = composeN' n $ t . S.transform (Pipe.mapM return)

399transformComposeMapM t n = composeN' n $ t . S.transform

406transformComposeMapM t n = composeN' n $ t . S.transform

400 (Pipe.mapM (\x -> return (x + 1))

407 (Pipe.mapM (\x -> return (x + 1))

@@ -405,6 +412,7 @@ transformTeeMapM t n = composeN' n $ t . S.transform

405transformZipMapM t n = composeN' n $ t . S.transform

412transformZipMapM t n = composeN' n $ t . S.transform

406 (Pipe.zipWith (+) (Pipe.mapM (\x -> return (x + 1)))

413 (Pipe.zipWith (+) (Pipe.mapM (\x -> return (x + 1)))

407 (Pipe.mapM (\x -> return (x + 2))))

414 (Pipe.mapM (\x -> return (x + 2))))

415+-}

408

416

409mapMaybe n = composeN n $ S.mapMaybe

417mapMaybe n = composeN n $ S.mapMaybe

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

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