mirror of
https://github.com/composewell/streamly.git
synced 2024-10-27 20:18:55 +03:00
d51fab489f
Otherwise the new bench.sh changes for tasy-bench won't work for these modules.
139 lines
4.8 KiB
Haskell
139 lines
4.8 KiB
Haskell
-- |
|
|
-- Module : Main
|
|
-- Copyright : (c) 2018 Composewell Technologies
|
|
--
|
|
-- License : BSD3
|
|
-- Maintainer : streamly@composewell.com
|
|
|
|
import Control.Concurrent (threadDelay)
|
|
import Control.Monad (when)
|
|
import Control.Monad.IO.Class (liftIO)
|
|
import Gauge
|
|
import Streamly.Prelude as S
|
|
import System.Random (randomRIO)
|
|
|
|
-- Note that we should also compare the cpuTime especially when threaded
|
|
-- runtime is used with this benchmark because thread scheduling is not
|
|
-- predictable and can add non-deterministic delay to the total time measured.
|
|
--
|
|
-- Also, the worker dispatch depends on the worker dispatch latency which is
|
|
-- set to fixed 200 us. We need to keep that in mind when designing tests.
|
|
|
|
moduleName :: String
|
|
moduleName = "Prelude.Adaptive"
|
|
|
|
value :: Int
|
|
value = 1000
|
|
|
|
{-# INLINE source #-}
|
|
source :: IsStream t => (Int, Int) -> t IO Int
|
|
source range = S.replicateM value $ do
|
|
r <- randomRIO range
|
|
when (r /= 0) $ liftIO $ threadDelay r
|
|
return r
|
|
|
|
{-# INLINE run #-}
|
|
run :: IsStream t => (Int, Int) -> (Int, Int) -> (t IO Int -> SerialT IO Int) -> IO ()
|
|
run srange crange t = S.drain $ do
|
|
n <- t $ source srange
|
|
d <- liftIO (randomRIO crange)
|
|
when (d /= 0) $ liftIO $ threadDelay d
|
|
return n
|
|
|
|
low, medium, high :: Int
|
|
low = 10
|
|
medium = 20
|
|
high = 30
|
|
|
|
{-# INLINE noDelay #-}
|
|
noDelay :: IsStream t => (t IO Int -> SerialT IO Int) -> IO ()
|
|
noDelay = run (0,0) (0,0)
|
|
|
|
{-# INLINE alwaysConstSlowSerial #-}
|
|
alwaysConstSlowSerial :: IsStream t => (t IO Int -> SerialT IO Int) -> IO ()
|
|
alwaysConstSlowSerial = run (0,0) (medium,medium)
|
|
|
|
{-# INLINE alwaysConstSlow #-}
|
|
alwaysConstSlow :: IsStream t => (t IO Int -> SerialT IO Int) -> IO ()
|
|
alwaysConstSlow = run (low,low) (medium,medium)
|
|
|
|
{-# INLINE alwaysConstFast #-}
|
|
alwaysConstFast :: IsStream t => (t IO Int -> SerialT IO Int) -> IO ()
|
|
alwaysConstFast = run (high,high) (medium,medium)
|
|
|
|
{-# INLINE alwaysVarSlow #-}
|
|
alwaysVarSlow :: IsStream t => (t IO Int -> SerialT IO Int) -> IO ()
|
|
alwaysVarSlow = run (low,low) (low,high)
|
|
|
|
{-# INLINE alwaysVarFast #-}
|
|
alwaysVarFast :: IsStream t => (t IO Int -> SerialT IO Int) -> IO ()
|
|
alwaysVarFast = run (high,high) (low,high)
|
|
|
|
-- XXX add variable producer tests as well
|
|
|
|
{-# INLINE runVarSometimesFast #-}
|
|
runVarSometimesFast :: IsStream t => (t IO Int -> SerialT IO Int) -> IO ()
|
|
runVarSometimesFast = run (medium,medium) (low,high)
|
|
|
|
{-# INLINE randomVar #-}
|
|
randomVar :: IsStream t => (t IO Int -> SerialT IO Int) -> IO ()
|
|
randomVar = run (low,high) (low,high)
|
|
|
|
main :: IO ()
|
|
main =
|
|
defaultMain [bgroup moduleName allBenchmarks]
|
|
|
|
where
|
|
|
|
allBenchmarks =
|
|
[
|
|
bgroup "serialConstantSlowConsumer"
|
|
[ bench "serially" $ nfIO $ alwaysConstSlowSerial fromSerial
|
|
, bench "wSerially" $ nfIO $ alwaysConstSlowSerial fromWSerial
|
|
]
|
|
, bgroup "default"
|
|
[ bench "serially" $ nfIO $ noDelay fromSerial
|
|
, bench "wSerially" $ nfIO $ noDelay fromWSerial
|
|
, bench "aheadly" $ nfIO $ noDelay fromAhead
|
|
, bench "asyncly" $ nfIO $ noDelay fromAsync
|
|
, bench "wAsyncly" $ nfIO $ noDelay fromWAsync
|
|
, bench "parallely" $ nfIO $ noDelay fromParallel
|
|
]
|
|
, bgroup "constantSlowConsumer"
|
|
[ bench "aheadly" $ nfIO $ alwaysConstSlow fromAhead
|
|
, bench "asyncly" $ nfIO $ alwaysConstSlow fromAsync
|
|
, bench "wAsyncly" $ nfIO $ alwaysConstSlow fromWAsync
|
|
, bench "parallely" $ nfIO $ alwaysConstSlow fromParallel
|
|
]
|
|
, bgroup "constantFastConsumer"
|
|
[ bench "aheadly" $ nfIO $ alwaysConstFast fromAhead
|
|
, bench "asyncly" $ nfIO $ alwaysConstFast fromAsync
|
|
, bench "wAsyncly" $ nfIO $ alwaysConstFast fromWAsync
|
|
, bench "parallely" $ nfIO $ alwaysConstFast fromParallel
|
|
]
|
|
, bgroup "variableSlowConsumer"
|
|
[ bench "aheadly" $ nfIO $ alwaysVarSlow fromAhead
|
|
, bench "asyncly" $ nfIO $ alwaysVarSlow fromAsync
|
|
, bench "wAsyncly" $ nfIO $ alwaysVarSlow fromWAsync
|
|
, bench "parallely" $ nfIO $ alwaysVarSlow fromParallel
|
|
]
|
|
, bgroup "variableFastConsumer"
|
|
[ bench "aheadly" $ nfIO $ alwaysVarFast fromAhead
|
|
, bench "asyncly" $ nfIO $ alwaysVarFast fromAsync
|
|
, bench "wAsyncly" $ nfIO $ alwaysVarFast fromWAsync
|
|
, bench "parallely" $ nfIO $ alwaysVarFast fromParallel
|
|
]
|
|
, bgroup "variableSometimesFastConsumer"
|
|
[ bench "aheadly" $ nfIO $ runVarSometimesFast fromAhead
|
|
, bench "asyncly" $ nfIO $ runVarSometimesFast fromAsync
|
|
, bench "wAsyncly" $ nfIO $ runVarSometimesFast fromWAsync
|
|
, bench "parallely" $ nfIO $ runVarSometimesFast fromParallel
|
|
]
|
|
, bgroup "variableFullOverlap"
|
|
[ bench "aheadly" $ nfIO $ randomVar fromAhead
|
|
, bench "asyncly" $ nfIO $ randomVar fromAsync
|
|
, bench "wAsyncly" $ nfIO $ randomVar fromWAsync
|
|
, bench "parallely" $ nfIO $ randomVar fromParallel
|
|
]
|
|
]
|