@@ -0,0 +1,145 @@
1+{-# LANGUAGE RecordWildCards #-}
4+import Criterion.Main (defaultMain, bgroup, bench, nfIO)
5+import Control.Exception (assert)
7+-- import Fusion as F hiding ((&))
8+import Data.Function ((&))
10+import Data.Conduit as C
11+import Data.Conduit.Combinators as C
13+import qualified Pipes.Prelude as P
14+import qualified Streaming.Prelude as Str
15+import qualified System.IO.Streams as IOS
16+import Conduit.Simple as S
19+import Control.Monad (guard)
20+import Data.IORef (IORef, newIORef, writeIORef)
21+import Data.Atomics (atomicModifyIORefCAS)
22+import System.IO.Unsafe (unsafePerformIO)
23+import Transient.Internals as T
24+import Transient.Indeterminism as T
29+ bgroup "basic" [ bench "transient" $ nfIO transient_basic
30+ , bench "stream" $ nfIO stream_basic
31+ , bench "iostreams" $ nfIO iostreams_basic
32+ , bench "pipes" $ nfIO pipes_basic
33+ , bench "conduit" $ nfIO conduit_basic
34+ -- , bench "simple-conduit" $ nfIO simple_conduit_basic
35+ -- , bench "fusion" $ nfIO fusion_basic
41+map :: (a -> Int) -> a -> TransIO Int
42+map f x = return $ f x
44+{-# INLINABLE filter #-}
45+filter :: (a -> Bool) -> a -> TransIO a
46+filter cond x = guard (cond x) >> return x
48+{-# NOINLINE count #-}
50+count = unsafePerformIO $ newIORef 0
52+drop :: Int -> Int -> TransIO Int
55+ mn <- liftIO $ atomicModifyIORefCAS count $ \n ->
57+ in if n' < num then (n + 1, False) else (n + 1, True)
61+transient_basic :: IO Int
62+transient_basic = T.keep' $ T.threads 0 $ do
63+ xs <- T.group 499000 $ do
64+ liftIO $ writeIORef count 0
65+ T.choose [1..1000000::Int]
70+ >>= Main.filter (\x -> x `mod` 2 == 0)
72+ assert (Prelude.length xs == 499000) $
73+ T.exit (Prelude.length xs)
77+ xs <- P.toListM $ P.each [1..1000000]
82+ >-> P.filter (\x -> x `mod` 2 == 0)
83+ assert (Prelude.length xs == 499000) $
84+ return (Prelude.length (xs ::[Int]))
86+conduit_basic :: IO Int
88+ xs <- C.yieldMany [1..1000000]
90+ C.$= C.map ((+1) :: Int -> Int)
91+ C.$= (C.drop 1000 >> C.awaitForever C.yield)
92+ C.$= C.map ((+1) :: Int -> Int)
93+ C.$= C.filter (\x -> x `mod` 2 == 0)
95+ assert (Prelude.length xs == 499000) $
96+ return (Prelude.length (xs :: [Int]))
98+simple_conduit_basic :: IO Int
99+simple_conduit_basic = do
100+ xs <- S.sourceList [1..1000000]
102+ S.$= S.mapC ((+1) :: Int -> Int)
104+ S.$= S.mapC ((+1) :: Int -> Int)
105+ S.$= S.filterC (\x -> x `mod` 2 == 0)
107+ assert (Prelude.length xs == 499000) $
108+ return (Prelude.length (xs :: [Int]))
112+-- fusion_basic :: IO Int
114+-- xs <- F.toListM $ F.each [1..1000000]
119+-- & F.filter (\x -> x `mod` 2 == 0)
120+-- assert (Prelude.length xs == 499000) $
121+-- return (Prelude.length (xs :: [Int]))
123+stream_basic :: IO Int
125+ let ns = [1..1000000] :: [Int]
126+ xs <- Str.toList $ Str.each ns
131+ & Str.filter (\x -> x `mod` 2 == 0)
132+ assert (Prelude.length xs == 499000) $
133+ return (Prelude.length xs)
135+iostreams_basic :: IO Int
137+ s0 <- IOS.fromList [1..1000000]
138+ s1 <- IOS.filter even s0
139+ s2 <- IOS.map (+1) s1
140+ s3 <- IOS.drop 1000 s2
141+ s4 <- IOS.map (+1) s3
142+ s5 <- IOS.filter (\x -> x `mod` 2 == 0) s4
144+ assert (Prelude.length xs == 499000) $
145+ return (Prelude.length (xs :: [Int]))