git.iko.soy/streamly
on master help sign in
Fix benchmarks and package deps
ff84127Harendra Kumar
asyncly.cabal+23−34
compare with master
unifiedsplit
@@ -30,21 +30,16 @@ library
30 ghc-options: -Wall -fwarn-identities -fwarn-incomplete-record-updates
30 ghc-options: -Wall -fwarn-identities -fwarn-incomplete-record-updates
31 -fwarn-incomplete-uni-patterns -fwarn-tabs
31 -fwarn-incomplete-uni-patterns -fwarn-tabs
32
32
33− build-depends: base >= 4.8.1 && < 5
33+ build-depends: base >= 4.8 && < 5
34− , containers >= 0.5.6
34+ , containers >= 0.5 && < 0.6
35− , time >= 1.5
36− , transformers >= 0.4.2
37− , ghc-prim
38−
39− -- libraries not bundled with GHC
40− , atomic-primops
41− , exceptions
35+ , exceptions >= 0.8 && < 0.9
42− , lifted-base
36+ , lifted-base >= 0.2 && < 0.3
43− , monad-control
37+ , monad-control >= 1.0 && < 2
44− , monad-recorder
38+ , monad-recorder >= 0.1 && < 0.2
45− , mtl
39+ , mtl >= 2.2 && < 3
46− , stm
40+ , stm >= 2.4.3 && < 2.5
47− , transformers-base
41+ , transformers >= 0.5 && < 0.6
42+ , transformers-base >= 0.4 && < 0.5
48
43
49test-suite test
44test-suite test
50 type: exitcode-stdio-1.0
45 type: exitcode-stdio-1.0
@@ -53,11 +48,11 @@ test-suite test
53 ghc-options: -O0 -Wall -fwarn-identities -fwarn-incomplete-record-updates
48 ghc-options: -O0 -Wall -fwarn-identities -fwarn-incomplete-record-updates
54 -fwarn-incomplete-uni-patterns -fwarn-tabs
49 -fwarn-incomplete-uni-patterns -fwarn-tabs
55 build-depends:
50 build-depends:
51+ asyncly
56− base >= 4.7 && < 5
52+ , base >= 4.8 && < 5
57− , hspec >= 2.0 && < 3
53+ , hspec >= 2.0 && < 3
58− , containers
54+ , containers >= 0.5 && < 0.6
59− , asyncly
60− , monad-recorder
55+ , monad-recorder >= 0.1 && < 0.2
61 default-language: Haskell2010
56 default-language: Haskell2010
62
57
63benchmark bench
58benchmark bench
@@ -70,20 +65,14 @@ benchmark bench
70 -fno-ignore-asserts
65 -fno-ignore-asserts
71 build-depends:
66 build-depends:
72 asyncly
67 asyncly
73− , atomic-primops
68+ , atomic-primops >= 0.8 && < 0.9
74− , base >= 4.7 && < 5
69+ , base >= 4.8 && < 5
75− , conduit
76− , conduit-combinators
77− , criterion
70+ , criterion >= 1 && < 2
78− , io-streams
79− , list-t
71+ , list-t >= 1 && < 2
80− , logict
72+ , logict >= 0.6 && < 0.7
81− , machines
73+ , machines >= 0.6 && < 0.7
82− , mtl
74+ , mtl >= 2.2 && < 3
83− , pipes
84− , simple-conduit
85− , streaming
86− , transient
75+ , transient >= 0.5 && < 0.6
87 default-language: Haskell2010
76 default-language: Haskell2010
88
77
89source-repository head
78source-repository head
benchmark/Main.hs+39−126
@@ -1,51 +1,34 @@
1−{-# LANGUAGE RecordWildCards #-}
2module Main where
1module Main where
3
2
4−import Criterion.Main (defaultMain, bgroup, bench, nfIO)
3+import Control.Applicative (Alternative(..))
5import Control.Exception (assert)
4import Control.Exception (assert)
6−import Control.Monad.IO.Class (MonadIO (liftIO))
7−--
8−-- import Fusion as F hiding ((&))
9−import Data.Function ((&))
10−
11−import qualified Data.Conduit as C
12−import qualified Data.Conduit.Combinators as C
13−import qualified Pipes as P
14−import qualified Pipes.Prelude as P
15−import qualified Streaming.Prelude as Str
16−import qualified System.IO.Streams as IOS
17−import qualified Conduit.Simple as S
18−
19−-- Transient
20import Control.Monad (guard)
5import Control.Monad (guard)
21−import Control.Applicative (Alternative(..))
6+import Control.Monad.IO.Class (MonadIO (liftIO))
22−import Data.IORef (IORef, newIORef, writeIORef)
7+import Criterion.Main (defaultMain, bgroup, bench, nfIO)
23import Data.Atomics (atomicModifyIORefCAS)
8import Data.Atomics (atomicModifyIORefCAS)
9+import Data.IORef (IORef, newIORef, writeIORef)
24import System.IO.Unsafe (unsafePerformIO)
10import System.IO.Unsafe (unsafePerformIO)
25−import qualified Transient.Internals as T
26−import qualified Transient.Indeterminism as T
27
11
12+import qualified Asyncly as A
13+import qualified Control.Monad.Logic as LG
28import qualified Data.Machine as M
14import qualified Data.Machine as M
15+import qualified Transient.Internals as T
16+import qualified Transient.Indeterminism as T
29import qualified ListT as LT
17import qualified ListT as LT
30−import qualified Control.Monad.Logic as LG
31−import qualified Asyncly as A
32
18
33main :: IO ()
19main :: IO ()
34main = do
20main = do
35 defaultMain [
21 defaultMain [
22+ bgroup "basic"
23+ [ bench "asyncly (<>)" $ nfIO (asyncly_basic (A.<>))
24+ , bench "asyncly (<=>)" $ nfIO (asyncly_basic (A.<=>))
25+ , bench "asyncly (<|)" $ nfIO (asyncly_basic (A.<|))
36− bgroup "basic" [ bench "asyncly" $ nfIO asyncly_basic
26+ , bench "asyncly (<|>)" $ nfIO (asyncly_basic (A.<|>))
27+ , bench "transient" $ nfIO transient_basic
37− , bench "logict" $ nfIO logict_basic
28+ , bench "logict" $ nfIO logict_basic
38− , bench "list-t" $ nfIO list_t_basic
29+ , bench "list-t" $ nfIO list_t_basic
39− , bench "transient" $ nfIO transient_basic
40− , bench "machines" $ nfIO machines_basic
30+ , bench "machines" $ nfIO machines_basic
41− , bench "stream" $ nfIO stream_basic
42− , bench "conduit" $ nfIO conduit_basic
43− , bench "pipes" $ nfIO pipes_basic
44− , bench "simple-conduit" $ nfIO simple_conduit_basic
45− , bench "iostreams" $ nfIO iostreams_basic
46− -- , bench "fusion" $ nfIO fusion_basic
47−
48− ]
31+ ]
49 ]
32 ]
50
33
51{-# INLINABLE map #-}
34{-# INLINABLE map #-}
@@ -77,18 +60,18 @@ tfilter = Main.filter
77tdrop :: Int -> Int -> T.TransIO Int
60tdrop :: Int -> Int -> T.TransIO Int
78tdrop = Main.drop
61tdrop = Main.drop
79
62
80−transient_basic :: IO Int
63+transient_basic :: IO (Maybe Int)
81transient_basic = T.keep' $ T.threads 0 $ do
64transient_basic = T.keep' $ T.threads 0 $ do
82 liftIO $ writeIORef count 0
65 liftIO $ writeIORef count 0
83− xs <- T.group 499001 $ do
66+ xs <- T.group 49900 $ do
84− T.choose [1..1000001 :: Int]
67+ T.choose [1..100000 :: Int]
85 >>= tfilter even
68 >>= tfilter even
86 >>= tmap (+1)
69 >>= tmap (+1)
87− >>= tdrop 1000
70+ >>= tdrop 100
88 >>= tmap (+1)
71 >>= tmap (+1)
89 >>= tfilter (\x -> x `mod` 2 == 0)
72 >>= tfilter (\x -> x `mod` 2 == 0)
90
73
91− assert (Prelude.length xs == 499000) $
74+ assert (Prelude.length xs == 49900) $
92 T.exit (Prelude.length xs)
75 T.exit (Prelude.length xs)
93
76
94amap :: (Int -> Int) -> Int -> A.AsyncT IO Int
77amap :: (Int -> Int) -> Int -> A.AsyncT IO Int
@@ -100,18 +83,20 @@ afilter = Main.filter
100adrop :: Int -> Int -> A.AsyncT IO Int
83adrop :: Int -> Int -> A.AsyncT IO Int
101adrop = Main.drop
84adrop = Main.drop
102
85
86+{-# INLINE asyncly_basic #-}
103−asyncly_basic :: IO Int
87+asyncly_basic :: (A.AsyncT IO Int -> A.AsyncT IO Int -> A.AsyncT IO Int)
88+ -> IO Int
104−asyncly_basic = do
89+asyncly_basic f = do
105 writeIORef count 0
90 writeIORef count 0
106 xs <- A.toList $ do
91 xs <- A.toList $ do
107− (A.forEachWith (A.<|) [1..1000000 :: Int] $ \x ->
92+ (A.forEachWith f [1..100000 :: Int] $ \x ->
108 return x
93 return x
109 >>= afilter even
94 >>= afilter even
110 >>= amap (+1)
95 >>= amap (+1)
111− >>= adrop 1000
96+ >>= adrop 100
112 >>= amap (+1)
97 >>= amap (+1)
113 >>= afilter (\y -> y `mod` 2 == 0))
98 >>= afilter (\y -> y `mod` 2 == 0))
114− assert (Prelude.length xs == 499000) $
99+ assert (Prelude.length xs == 49900) $
115 return (Prelude.length xs)
100 return (Prelude.length xs)
116
101
117lfilter :: (Int -> Bool) -> Int -> LT.ListT IO Int
102lfilter :: (Int -> Bool) -> Int -> LT.ListT IO Int
@@ -127,13 +112,13 @@ list_t_basic :: IO Int
127list_t_basic = do
112list_t_basic = do
128 writeIORef count 0
113 writeIORef count 0
129 xs <- LT.toList $ do
114 xs <- LT.toList $ do
130− LT.fromFoldable [1..1000000 :: Int]
115+ LT.fromFoldable [1..100000 :: Int]
131 >>= lfilter even
116 >>= lfilter even
132 >>= lmap (+1)
117 >>= lmap (+1)
133− >>= ldrop 1000
118+ >>= ldrop 100
134 >>= lmap (+1)
119 >>= lmap (+1)
135 >>= lfilter (\x -> x `mod` 2 == 0)
120 >>= lfilter (\x -> x `mod` 2 == 0)
136− assert (Prelude.length xs == 499000) $
121+ assert (Prelude.length xs == 49900) $
137 return (Prelude.length xs)
122 return (Prelude.length xs)
138
123
139lgfilter :: (Int -> Bool) -> Int -> LG.LogicT IO Int
124lgfilter :: (Int -> Bool) -> Int -> LG.LogicT IO Int
@@ -150,94 +135,22 @@ logict_basic = do
150 writeIORef count 0
135 writeIORef count 0
151 --xs <- LG.observeManyT 2900 $ do
136 --xs <- LG.observeManyT 2900 $ do
152 xs <- LG.observeAllT $ do
137 xs <- LG.observeAllT $ do
153− LG.msum $ Prelude.map return [1..1000000]
138+ LG.msum $ Prelude.map return [1..100000]
154 >>= lgfilter even
139 >>= lgfilter even
155 >>= lgmap (+1)
140 >>= lgmap (+1)
156− >>= lgdrop 1000
141+ >>= lgdrop 100
157 >>= lgmap (+1)
142 >>= lgmap (+1)
158 >>= lgfilter (\x -> x `mod` 2 == 0)
143 >>= lgfilter (\x -> x `mod` 2 == 0)
159− assert (Prelude.length xs == 499000) $
144+ assert (Prelude.length xs == 49900) $
160 return (Prelude.length xs)
145 return (Prelude.length xs)
161
146
162machines_basic :: IO Int
147machines_basic :: IO Int
163machines_basic = do
148machines_basic = do
164− xs <- M.runT $ M.source [1..1000000]
149+ xs <- M.runT $ M.source [1..100000]
165 M.~> M.filtered even
150 M.~> M.filtered even
166 M.~> M.mapping (+1)
151 M.~> M.mapping (+1)
167− M.~> M.dropping 1000
152+ M.~> M.dropping 100
168 M.~> M.mapping (+1)
153 M.~> M.mapping (+1)
169 M.~> M.filtered (\x -> x `mod` 2 == 0)
154 M.~> M.filtered (\x -> x `mod` 2 == 0)
170− assert (Prelude.length xs == 499000) $
155+ assert (Prelude.length xs == 49900) $
171− return (Prelude.length (xs ::[Int]))
172−
173−pipes_basic :: IO Int
174−pipes_basic = do
175− xs <- P.toListM $ P.each [1..1000000]
176− P.>-> P.filter even
177− P.>-> P.map (+1)
178− P.>-> P.drop 1000
179− P.>-> P.map (+1)
180− P.>-> P.filter (\x -> x `mod` 2 == 0)
181− assert (Prelude.length xs == 499000) $
182 return (Prelude.length (xs ::[Int]))
156 return (Prelude.length (xs ::[Int]))
183−
184−conduit_basic :: IO Int
185−conduit_basic = do
186− xs <- C.yieldMany [1..1000000]
187− C.$= C.filter even
188− C.$= C.map ((+1) :: Int -> Int)
189− C.$= (C.drop 1000 >> C.awaitForever C.yield)
190− C.$= C.map ((+1) :: Int -> Int)
191− C.$= C.filter (\x -> x `mod` 2 == 0)
192− C.$$ C.sinkList
193− assert (Prelude.length xs == 499000) $
194− return (Prelude.length (xs :: [Int]))
195−
196−simple_conduit_basic :: IO Int
197−simple_conduit_basic = do
198− xs <- S.sourceList [1..1000000]
199− S.$= S.filterC even
200− S.$= S.mapC ((+1) :: Int -> Int)
201− S.$= S.dropC 1000
202− S.$= S.mapC ((+1) :: Int -> Int)
203− S.$= S.filterC (\x -> x `mod` 2 == 0)
204− S.$$ S.sinkList
205− assert (Prelude.length xs == 499000) $
206− return (Prelude.length (xs :: [Int]))
207−
208−
209−
210−-- fusion_basic :: IO Int
211−-- fusion_basic = do
212−-- xs <- F.toListM $ F.each [1..1000000]
213−-- & F.filter even
214−-- & F.map (+1)
215−-- & F.drop 1000
216−-- & F.map (+1)
217−-- & F.filter (\x -> x `mod` 2 == 0)
218−-- assert (Prelude.length xs == 499000) $
219−-- return (Prelude.length (xs :: [Int]))
220−
221−stream_basic :: IO Int
222−stream_basic = do
223− let ns = [1..1000000] :: [Int]
224− xs Str.:> _ <- Str.toList $ Str.each ns
225− & Str.filter even
226− & Str.map (+1)
227− & Str.drop 1000
228− & Str.map (+1)
229− & Str.filter (\x -> x `mod` 2 == 0)
230− assert (Prelude.length xs == 499000) $
231− return (Prelude.length xs)
232−
233−iostreams_basic :: IO Int
234−iostreams_basic = do
235− s0 <- IOS.fromList [1..1000000]
236− s1 <- IOS.filter even s0
237− s2 <- IOS.map (+1) s1
238− s3 <- IOS.drop 1000 s2
239− s4 <- IOS.map (+1) s3
240− s5 <- IOS.filter (\x -> x `mod` 2 == 0) s4
241− xs <- IOS.toList s5
242− assert (Prelude.length xs == 499000) $
243− return (Prelude.length (xs :: [Int]))
src/Asyncly.hs+18−1
@@ -123,17 +123,34 @@ module Asyncly
123 ( AsyncT
123 ( AsyncT
124 , MonadAsync
124 , MonadAsync
125
125
126− -- * Run
126+ -- * Running
127 , runAsyncly
127 , runAsyncly
128 , toList
128 , toList
129+
130+ -- * Composing Operators
129 , interleave
131 , interleave
130 , (<=>)
132 , (<=>)
131 , parLeft
133 , parLeft
132 , (<|)
134 , (<|)
135+
136+ -- * Utilities
133 , foldWith
137 , foldWith
134 , foldMapWith
138 , foldMapWith
135 , forEachWith
139 , forEachWith
140+
141+ -- * Re-exports
142+ , Monoid (..)
143+ , (<>)
144+ , Alternative (..)
145+ , MonadPlus (..)
146+ , liftIO
147+ , lift
136 )
148 )
137where
149where
138
150
139import Asyncly.AsyncT
151import Asyncly.AsyncT
152+import Data.Monoid (Monoid(..), (<>))
153+import Control.Applicative (Alternative(..))
154+import Control.Monad (MonadPlus(..))
155+import Control.Monad.IO.Class (liftIO)
156+import Control.Monad.Trans.Class (lift)
stack.yaml+2−3
@@ -1,12 +1,11 @@
1−resolver: lts-8.23
1+resolver: lts-9.2
2packages:
2packages:
3- '.'
3- '.'
4- location:
4- location:
5 git: https://github.com/harendra-kumar/monad-recorder
5 git: https://github.com/harendra-kumar/monad-recorder
6 commit: 05bb0cfd827d9f955108d3b03dfb20b7c6820c25
6 commit: 05bb0cfd827d9f955108d3b03dfb20b7c6820c25
7 extra-dep: true
7 extra-dep: true
8−extra-deps:
8+extra-deps: []
9− - simple-conduit-0.6.0
10flags: {}
9flags: {}
11extra-package-dbs: []
10extra-package-dbs: []
12pvp-bounds: both
11pvp-bounds: both