Separate streamly-core and stream benchmarks

benchmark/Streamly/Benchmark/Data/Stream/Exceptions.hs

@@ -21,21 +21,14 @@
 
 module Stream.Exceptions (benchmarks) where
 
-import Control.Exception (Exception, throwIO)
-import Stream.Common (drain)
-
-import qualified Data.IORef as Ref
-import qualified Data.Map.Strict as Map
+import Control.Exception (Exception)
 
 import Control.Exception (SomeException)
-import System.IO (Handle, hClose, hPutChar)
+import System.IO (Handle, hClose)
 import qualified Streamly.FileSystem.Handle as FH
 import qualified Streamly.Internal.FileSystem.Handle as IFH
 import qualified Streamly.Internal.Data.Unfold as IUF
-import qualified Streamly.Internal.Data.Unfold.Prelude as IUF
-
 import qualified Streamly.Internal.Data.Stream as Stream
-import qualified Streamly.Internal.Data.Stream.Prelude as Stream
 
 import Test.Tasty.Bench hiding (env)
 import Prelude hiding (last, length)
@@ -45,23 +38,8 @@ import Streamly.Benchmark.Common.Handle
 #ifdef INSPECTION
 import Control.Monad.Catch (MonadCatch)
 import Test.Inspection
-
-import qualified Streamly.Internal.Data.Stream as D
 #endif
 
-type Stream = Stream.Stream
-toStreamD :: a -> a
-toStreamD = id
-fromStreamD :: a -> a
-fromStreamD = id
-
-afterUnsafe :: IO b -> Stream IO a -> Stream IO a
-finallyUnsafe :: IO b -> Stream IO a -> Stream IO a
-bracketUnsafe :: IO b -> (b -> IO c) -> (b -> Stream IO a) -> Stream IO a
-afterUnsafe = Stream.afterUnsafe
-finallyUnsafe = Stream.finallyUnsafe
-bracketUnsafe = Stream.bracketUnsafe
-
 -------------------------------------------------------------------------------
 -- stream exceptions
 -------------------------------------------------------------------------------
@@ -73,72 +51,6 @@ data BenchException
 
 instance Exception BenchException
 
-retryNoneSimple :: Int -> Int -> IO ()
-retryNoneSimple length from =
-    drain
-        $ Stream.retry
-            (Map.singleton BenchException1 length)
-            (const Stream.nil)
-            source
-
-    where
-
-    source = Stream.enumerateFromTo from (from + length)
-
-retryNone :: Int -> Int -> IO ()
-retryNone length from = do
-    ref <- Ref.newIORef (0 :: Int)
-    drain
-        $ Stream.retry (Map.singleton BenchException1 length) (const Stream.nil)
-        $ source ref
-
-    where
-
-    source ref =
-        Stream.replicateM (from + length)
-            $ Ref.modifyIORef' ref (+ 1) >> Ref.readIORef ref
-
-retryAll :: Int -> Int -> IO ()
-retryAll length from = do
-    ref <- Ref.newIORef 0
-    drain
-        $ Stream.retry
-            (Map.singleton BenchException1 (length + from)) (const Stream.nil)
-        $ source ref
-
-    where
-
-    source ref =
-        Stream.fromEffect
-            $ do
-                Ref.modifyIORef' ref (+ 1)
-                val <- Ref.readIORef ref
-                if val >= length
-                then return length
-                else throwIO BenchException1
-
-retryUnknown :: Int -> Int -> IO ()
-retryUnknown length from = do
-    drain
-        $ Stream.retry (Map.singleton BenchException1 length) (const source)
-        $ throwIO BenchException2 `Stream.before` Stream.nil
-
-    where
-
-    source = Stream.enumerateFromTo from (from + length)
-
-
-o_1_space_serial_exceptions :: Int -> [Benchmark]
-o_1_space_serial_exceptions length =
-    [ bgroup
-          "exceptions/serial"
-          [ benchIOSrc1 "retryNoneSimple" (retryNoneSimple length)
-          , benchIOSrc1 "retryNone" (retryNone length)
-          , benchIOSrc1 "retryAll" (retryAll length)
-          , benchIOSrc1 "retryUnknown" (retryUnknown length)
-          ]
-    ]
-
 -- XXX Move these to FileSystem.Handle benchmarks
 
 -------------------------------------------------------------------------------
@@ -171,63 +83,32 @@ inspect $ hasNoTypeClasses 'readWriteHandleExceptionStream
 readWriteFinally_Stream :: Handle -> Handle -> IO ()
 readWriteFinally_Stream inh devNull =
     let readEx =
-            finallyUnsafe (hClose inh) (Stream.unfold FH.reader inh)
+            Stream.finallyUnsafe (hClose inh) (Stream.unfold FH.reader inh)
     in Stream.fold (FH.write devNull) readEx
 
 #ifdef INSPECTION
 inspect $ hasNoTypeClasses 'readWriteFinally_Stream
 #endif
 
-readWriteFinallyStream :: Handle -> Handle -> IO ()
-readWriteFinallyStream inh devNull =
-    let readEx = Stream.finally (hClose inh) (Stream.unfold FH.reader inh)
-    in Stream.fold (FH.write devNull) readEx
-
 -- | Send the file contents to /dev/null with exception handling
 fromToBytesBracket_Stream :: Handle -> Handle -> IO ()
 fromToBytesBracket_Stream inh devNull =
-    let readEx = bracketUnsafe (return ()) (\_ -> hClose inh)
-                    (\_ -> fromStreamD $ IFH.read inh)
-    in IFH.putBytes devNull (toStreamD readEx)
+    let readEx = Stream.bracketUnsafe (return ()) (\_ -> hClose inh)
+                    (\_ -> IFH.read inh)
+    in IFH.putBytes devNull readEx
 
 #ifdef INSPECTION
 inspect $ hasNoTypeClasses 'fromToBytesBracket_Stream
 #endif
 
-fromToBytesBracketStream :: Handle -> Handle -> IO ()
-fromToBytesBracketStream inh devNull =
-    let readEx = Stream.bracket (return ()) (\_ -> hClose inh)
-                    (\_ -> fromStreamD $ IFH.read inh)
-    in IFH.putBytes devNull (toStreamD readEx)
-
-readWriteBeforeAfterStream :: Handle -> Handle -> IO ()
-readWriteBeforeAfterStream inh devNull =
-    let readEx =
-            Stream.after (hClose inh)
-                $ Stream.before (hPutChar devNull 'A') (Stream.unfold FH.reader inh)
-     in Stream.fold (FH.write devNull) readEx
-
-#ifdef INSPECTION
-inspect $ 'readWriteBeforeAfterStream `hasNoType` ''D.Step
-#endif
-
-readWriteAfterStream :: Handle -> Handle -> IO ()
-readWriteAfterStream inh devNull =
-    let readEx = Stream.after (hClose inh) (Stream.unfold FH.reader inh)
-     in Stream.fold (FH.write devNull) readEx
-
-#ifdef INSPECTION
-inspect $ 'readWriteAfterStream `hasNoType` ''D.Step
-#endif
-
 readWriteAfter_Stream :: Handle -> Handle -> IO ()
 readWriteAfter_Stream inh devNull =
-    let readEx = afterUnsafe (hClose inh) (Stream.unfold FH.reader inh)
+    let readEx = Stream.afterUnsafe (hClose inh) (Stream.unfold FH.reader inh)
      in Stream.fold (FH.write devNull) readEx
 
 #ifdef INSPECTION
 inspect $ hasNoTypeClasses 'readWriteAfter_Stream
-inspect $ 'readWriteAfter_Stream `hasNoType` ''D.Step
+inspect $ 'readWriteAfter_Stream `hasNoType` ''Stream.Step
 #endif
 
 o_1_space_copy_stream_exceptions :: BenchEnv -> [Benchmark]
@@ -239,20 +120,12 @@ o_1_space_copy_stream_exceptions env =
            readWriteHandleExceptionStream inh (nullH env)
        , mkBenchSmall "Stream.finally_" env $ \inh _ ->
            readWriteFinally_Stream inh (nullH env)
-       , mkBenchSmall "Stream.finally" env $ \inh _ ->
-           readWriteFinallyStream inh (nullH env)
-       , mkBenchSmall "Stream.after . Stream.before" env $ \inh _ ->
-           readWriteBeforeAfterStream inh (nullH env)
-       , mkBenchSmall "Stream.after" env $ \inh _ ->
-           readWriteAfterStream inh (nullH env)
        , mkBenchSmall "Stream.after_" env $ \inh _ ->
            readWriteAfter_Stream inh (nullH env)
        ]
     , bgroup "exceptions/fromToBytes"
        [ mkBenchSmall "Stream.bracket_" env $ \inh _ ->
            fromToBytesBracket_Stream inh (nullH env)
-       , mkBenchSmall "Stream.bracket" env $ \inh _ ->
-           fromToBytesBracketStream inh (nullH env)
         ]
     ]
 
@@ -288,20 +161,13 @@ inspect $ hasNoTypeClasses 'readChunksBracket_
 #endif
 #endif
 
-readChunksBracket :: Handle -> Handle -> IO ()
-readChunksBracket inh devNull =
-    let readEx = IUF.bracket return (\_ -> hClose inh) FH.chunkReader
-    in IUF.fold (IFH.writeChunks devNull) readEx inh
-
 o_1_space_copy_exceptions_readChunks :: BenchEnv -> [Benchmark]
 o_1_space_copy_exceptions_readChunks env =
     [ bgroup "exceptions/readChunks"
         [ mkBench "UF.onException" env $ \inH _ ->
             readChunksOnException inH (nullH env)
         , mkBench "UF.bracket_" env $ \inH _ ->
             readChunksBracket_ inH (nullH env)
-        , mkBench "UF.bracket" env $ \inH _ ->
-            readChunksBracket inH (nullH env)
         ]
     ]
 
@@ -312,39 +178,28 @@ o_1_space_copy_exceptions_readChunks env =
 -- | Send the file contents to /dev/null with exception handling
 toChunksBracket_ :: Handle -> Handle -> IO ()
 toChunksBracket_ inh devNull =
-    let readEx = bracketUnsafe
+    let readEx = Stream.bracketUnsafe
             (return ())
             (\_ -> hClose inh)
-            (\_ -> fromStreamD $ IFH.readChunks inh)
+            (\_ -> IFH.readChunks inh)
     in Stream.fold (IFH.writeChunks devNull) readEx
 
 #ifdef INSPECTION
 inspect $ hasNoTypeClasses 'toChunksBracket_
 #endif
 
-toChunksBracket :: Handle -> Handle -> IO ()
-toChunksBracket inh devNull =
-    let readEx = Stream.bracket
-            (return ())
-            (\_ -> hClose inh)
-            (\_ -> fromStreamD $ IFH.readChunks inh)
-    in Stream.fold (IFH.writeChunks devNull) readEx
-
 o_1_space_copy_exceptions_toChunks :: BenchEnv -> [Benchmark]
 o_1_space_copy_exceptions_toChunks env =
     [ bgroup "exceptions/toChunks"
         [ mkBench "Stream.bracket_" env $ \inH _ ->
             toChunksBracket_ inH (nullH env)
-        , mkBench "Stream.bracket" env $ \inH _ ->
-            toChunksBracket inH (nullH env)
         ]
     ]
 
 benchmarks :: String -> BenchEnv -> Int -> [Benchmark]
-benchmarks moduleName _env size =
+benchmarks moduleName _env _size =
         [ bgroup (o_1_space_prefix moduleName) $ concat
-            [ o_1_space_serial_exceptions size
-            , o_1_space_copy_exceptions_readChunks _env
+            [ o_1_space_copy_exceptions_readChunks _env
             , o_1_space_copy_exceptions_toChunks _env
             , o_1_space_copy_stream_exceptions _env
             ]

benchmark/Streamly/Benchmark/Data/Stream/Concurrent.hs → benchmark/Streamly/Benchmark/Data/Stream/Prelude/Concurrent.hs

@@ -5,7 +5,7 @@
 -- License     : BSD3
 -- Maintainer  : streamly@composewell.com
 
-import Stream.ConcurrentCommon
+import ConcurrentCommon
 import Streamly.Benchmark.Common (runWithCLIOpts, defaultStreamSize)
 
 moduleName :: String

benchmark/Streamly/Benchmark/Data/Stream/ConcurrentCommon.hs → benchmark/Streamly/Benchmark/Data/Stream/Prelude/ConcurrentCommon.hs

@@ -9,7 +9,7 @@
 -- License     : BSD3
 -- Maintainer  : streamly@composewell.com
 
-module Stream.ConcurrentCommon
+module ConcurrentCommon
     ( allBenchmarks
     , mkParallel
     , unParallel

benchmark/Streamly/Benchmark/Data/Stream/ConcurrentEager.hs → benchmark/Streamly/Benchmark/Data/Stream/Prelude/ConcurrentEager.hs

@@ -5,7 +5,7 @@
 -- License     : BSD3
 -- Maintainer  : streamly@composewell.com
 
-import Stream.ConcurrentCommon
+import ConcurrentCommon
 import Streamly.Benchmark.Common (runWithCLIOpts, defaultStreamSize)
 
 import qualified Streamly.Internal.Data.Stream.Prelude as Stream

benchmark/Streamly/Benchmark/Data/Stream/ConcurrentInterleaved.hs → benchmark/Streamly/Benchmark/Data/Stream/Prelude/ConcurrentInterleaved.hs

@@ -5,7 +5,7 @@
 -- License     : BSD3
 -- Maintainer  : streamly@composewell.com
 
-import Stream.ConcurrentCommon
+import ConcurrentCommon
 import Streamly.Benchmark.Common (runWithCLIOpts, defaultStreamSize)
 
 import qualified Streamly.Internal.Data.Stream.Prelude as Stream

benchmark/Streamly/Benchmark/Data/Stream/ConcurrentOrdered.hs → benchmark/Streamly/Benchmark/Data/Stream/Prelude/ConcurrentOrdered.hs

@@ -5,7 +5,7 @@
 -- License     : BSD3
 -- Maintainer  : streamly@composewell.com
 
-import Stream.ConcurrentCommon
+import ConcurrentCommon
 import Streamly.Benchmark.Common (runWithCLIOpts, defaultStreamSize)
 
 import qualified Streamly.Data.Stream.Prelude as Stream