Fix breakage, and split the stream benchmarks

To reduce memory footprint.

Author: harendra-kumar

benchmark/Streamly/Benchmark/Data/Stream.hs

@@ -25,6 +25,7 @@ import qualified Stream.Generate as Generation
 import qualified Stream.Lift as Lift
 import qualified Stream.Reduce as NestedFold
 import qualified Stream.Split as Split
+import qualified Stream.SplitChunks as SplitChunks
 import qualified Stream.Transform as Transformation
 
 import Streamly.Benchmark.Common
@@ -61,6 +62,7 @@ main = do
         , Elimination.benchmarks moduleName size
         , Exceptions.benchmarks moduleName env size
         , Split.benchmarks moduleName env
+        , SplitChunks.benchmarks moduleName env
         , Transformation.benchmarks moduleName size
         , NestedFold.benchmarks moduleName size
         , Lift.benchmarks moduleName size

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

@@ -27,14 +27,12 @@ module Stream.Common
 
     -- Benchmark stream generation
     , sourceUnfoldr
-    , sourceUnfoldrM
     , sourceUnfoldrAction
     , sourceConcatMapId
     , sourceFromFoldable
     , sourceFromFoldableM
 
     -- Benchmark stream elimination
-    , benchIOSink
     , benchIOSinkPureSrc
     , benchIOSrc
     , benchIO
@@ -79,15 +77,13 @@ import Control.DeepSeq (NFData)
 import Control.Exception (try)
 import GHC.Exception (ErrorCall)
 import System.Random (randomRIO)
+import Streamly.Benchmark.Common (sourceUnfoldrM)
+import Streamly.Internal.Data.Stream (Stream)
 
 import qualified Streamly.Internal.Data.Fold as Fold
 import qualified Streamly.Internal.Data.Pipe as Pipe
 import qualified Streamly.Internal.Data.Scanl as Scanl
 import qualified Streamly.Internal.Data.Scanr as Scanr
-
-
-import Streamly.Internal.Data.Stream (Stream)
-import qualified Streamly.Internal.Data.Stream as D
 import qualified Streamly.Internal.Data.Stream as Stream
 
 import Test.Tasty.Bench
@@ -107,7 +103,7 @@ append = Stream.append
 
 {-# INLINE append2 #-}
 append2 :: Monad m => Stream m a -> Stream m a -> Stream m a
-append2 = D.append
+append2 = Stream.append
 
 {-# INLINE drain #-}
 drain :: Monad m => Stream m a -> m ()
@@ -129,17 +125,6 @@ fromListM = Stream.sequence . Stream.fromList
 fromFoldableM :: MonadAsync m => [m a] -> Stream m a
 fromFoldableM = Stream.sequence . Stream.fromFoldable
 
-{-# INLINE sourceUnfoldrM #-}
-sourceUnfoldrM :: MonadAsync m => Int -> Int -> Stream m Int
-sourceUnfoldrM count start = Stream.unfoldrM step start
-
-    where
-
-    step cnt =
-        if cnt > start + count
-        then return Nothing
-        else return (Just (cnt, cnt + 1))
-
 {-# INLINE sourceUnfoldr #-}
 sourceUnfoldr :: Monad m => Int -> Int -> Stream m Int
 sourceUnfoldr count start = Stream.unfoldr step start
@@ -170,13 +155,6 @@ sourceFromFoldable value n = Stream.fromFoldable [n..n+value]
 sourceFromFoldableM :: Monad m => Int -> Int -> Stream m Int
 sourceFromFoldableM value n = Stream.fromFoldableM (fmap return [n..n+value])
 
-{-# INLINE benchIOSink #-}
-benchIOSink
-    :: (NFData b)
-    => Int -> String -> (Stream IO Int -> IO b) -> Benchmark
-benchIOSink value name f =
-    bench name $ nfIO $ randomRIO (1,1) >>= f . sourceUnfoldrM value
-
 {-# INLINE benchIOSinkPureSrc #-}
 benchIOSinkPureSrc
     :: (NFData b)
@@ -201,7 +179,7 @@ benchIO name f = bench name $ nfIO $ randomRIO (1,1) >>= f
 sourceConcatMapId :: (Monad m)
     => Int -> Int -> Stream m (Stream m Int)
 sourceConcatMapId value n =
-    Stream.fromList $ fmap (D.fromEffect . return) [n..n+value]
+    Stream.fromList $ fmap (Stream.fromEffect . return) [n..n+value]
 
 {-# INLINE apDiscardFst #-}
 apDiscardFst :: MonadAsync m =>

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

@@ -35,7 +35,6 @@ import qualified Streamly.Internal.Data.Fold as Fold
 #ifdef INSPECTION
 import GHC.Types (SPEC(..))
 import Test.Inspection
-import qualified Streamly.Internal.Data.Stream as D
 #endif
 
 import Stream.Common
@@ -581,7 +580,7 @@ eqByPure value n = eqBy' (sourceUnfoldr value n)
 #ifdef INSPECTION
 inspect $ hasNoTypeClasses 'eqByPure
 inspect $ 'eqByPure `hasNoType` ''SPEC
-inspect $ 'eqByPure `hasNoType` ''D.Step
+inspect $ 'eqByPure `hasNoType` ''S.Step
 #endif
 
 {-# INLINE eqInstance #-}
@@ -603,7 +602,7 @@ cmpByPure value n = cmpBy' (sourceUnfoldr value n)
 #ifdef INSPECTION
 inspect $ hasNoTypeClasses 'cmpByPure
 inspect $ 'cmpByPure `hasNoType` ''SPEC
-inspect $ 'cmpByPure `hasNoType` ''D.Step
+inspect $ 'cmpByPure `hasNoType` ''S.Step
 #endif
 
 {-# INLINE ordInstance #-}
@@ -642,7 +641,7 @@ eqBy value n = eqBy' (sourceUnfoldrM value n)
 #ifdef INSPECTION
 inspect $ hasNoTypeClasses 'eqBy
 inspect $ 'eqBy `hasNoType` ''SPEC
-inspect $ 'eqBy `hasNoType` ''D.Step
+inspect $ 'eqBy `hasNoType` ''S.Step
 #endif
 
 {-# INLINE cmpBy #-}
@@ -652,7 +651,7 @@ cmpBy value n = cmpBy' (sourceUnfoldrM value n)
 #ifdef INSPECTION
 inspect $ hasNoTypeClasses 'cmpBy
 inspect $ 'cmpBy `hasNoType` ''SPEC
-inspect $ 'cmpBy `hasNoType` ''D.Step
+inspect $ 'cmpBy `hasNoType` ''S.Step
 #endif
 
 o_1_space_elimination_multi_stream :: Int -> [Benchmark]

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

@@ -23,23 +23,22 @@ module Stream.Expand (benchmarks) where
 #ifdef INSPECTION
 import GHC.Types (SPEC(..))
 import Test.Inspection
-
-import qualified Streamly.Internal.Data.Stream as D
 #endif
 
-import qualified Stream.Common as Common
-import qualified Streamly.Internal.Data.Unfold as UF
-
 import Streamly.Data.Stream (Stream)
 import Streamly.Data.Unfold (Unfold)
+
+import qualified Stream.Common as Common
+import qualified Streamly.Internal.Data.Unfold as UF
 import qualified Streamly.Internal.Data.Stream as S
 import qualified Streamly.Internal.Data.Unfold as Unfold
 import qualified Streamly.Internal.Data.Fold as Fold
 import qualified Streamly.Internal.Data.Stream as Stream
 import qualified Streamly.Internal.Data.StreamK as StreamK
+
 import Test.Tasty.Bench
 import Stream.Common
-import Streamly.Benchmark.Common
+import Streamly.Benchmark.Common hiding (benchIOSrc)
 import Prelude hiding (concatMap, zipWith)
 
 -------------------------------------------------------------------------------
@@ -218,7 +217,7 @@ unfoldSched outer inner n =
 inspect $ hasNoTypeClasses 'unfoldSched
 -- inspect $ 'unfoldSched `hasNoType` ''SPEC
 -- inspect $ 'unfoldSched `hasNoType`
---      ''D.ConcatUnfoldInterleaveState
+--      ''Stream.ConcatUnfoldInterleaveState
 #endif
 
 o_1_space_joining :: Int -> [Benchmark]
@@ -328,7 +327,7 @@ unfoldEach outer inner start = drain $
 
 #ifdef INSPECTION
 inspect $ hasNoTypeClasses 'unfoldEach
-inspect $ 'unfoldEach `hasNoType` ''D.UnfoldEachState
+inspect $ 'unfoldEach `hasNoType` ''Stream.UnfoldEachState
 inspect $ 'unfoldEach `hasNoType` ''SPEC
 #endif
 

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

@@ -17,28 +17,20 @@ module Stream.Generate (benchmarks) where
 import Control.DeepSeq (NFData(..))
 import Control.Monad.IO.Class (MonadIO)
 import Data.Functor.Identity (Identity(..))
+import Streamly.Internal.Data.Stream (Stream)
 import Streamly.Internal.Data.Time.Units (AbsTime)
 
 import qualified GHC.Exts as GHC
 import qualified Streamly.Internal.Data.Fold as Fold
-
-import Stream.Common
-import Streamly.Internal.Data.Stream (Stream)
 import qualified Streamly.Internal.Data.Stream as Stream
 
 import Test.Tasty.Bench
-import Streamly.Benchmark.Common
+import Stream.Common
+import Streamly.Benchmark.Common hiding (benchIOSrc)
 import qualified Prelude
 
 import Prelude hiding (repeat, replicate, iterate)
 
--------------------------------------------------------------------------------
--- Generation
--------------------------------------------------------------------------------
-
-toStreamD :: a -> a
-toStreamD = id
-
 -------------------------------------------------------------------------------
 -- fromList
 -------------------------------------------------------------------------------
@@ -177,8 +169,8 @@ o_1_space_generation value =
         , benchIOSrc "fracFromTo" (sourceFracFromTo value)
         , benchIOSrc "fromList" (sourceFromList value)
         , benchIOSrc "fromListM" (sourceFromListM value)
-        , benchPureSrc "IsList.fromList" (toStreamD . sourceIsList value)
-        , benchPureSrc "IsString.fromString" (toStreamD . sourceIsString value)
+        , benchPureSrc "IsList.fromList" (sourceIsList value)
+        , benchPureSrc "IsString.fromString" (sourceIsString value)
         , benchIOSrc "enumerateFrom" (enumerateFrom value)
         , benchIOSrc "enumerateFromTo" (enumerateFromTo value)
         , benchIOSrc "enumerateFromThen" (enumerateFromThen value)

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

@@ -14,17 +14,16 @@ module Stream.Lift (benchmarks) where
 import Control.DeepSeq (NFData(..))
 import Control.Monad.State.Strict (StateT, get, put)
 import Data.Functor.Identity (Identity)
-import Stream.Common (sourceUnfoldr, sourceUnfoldrM, benchIOSrc)
+import Stream.Common (sourceUnfoldr, benchIOSrc)
 import System.Random (randomRIO)
+import Streamly.Internal.Data.Stream (Stream)
 
 import qualified Stream.Common as Common
 import qualified Streamly.Internal.Data.Fold as Fold
-
-import Streamly.Internal.Data.Stream (Stream)
 import qualified Streamly.Internal.Data.Stream as Stream
 
 import Test.Tasty.Bench
-import Streamly.Benchmark.Common
+import Streamly.Benchmark.Common hiding (benchIOSrc)
 import Prelude hiding (reverse, tail)
 
 -------------------------------------------------------------------------------

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

@@ -19,16 +19,15 @@ import Control.Monad.IO.Class (MonadIO(..))
 import Data.Maybe (isJust)
 import Data.Monoid (Sum(..))
 import GHC.Generics (Generic)
+import Streamly.Internal.Data.Stream (Stream)
 
-import qualified Streamly.Internal.Data.Refold.Type as Refold
-import qualified Streamly.Internal.Data.Fold as FL
 import qualified Stream.Common as Common
-
-import Streamly.Internal.Data.Stream (Stream)
+import qualified Streamly.Internal.Data.Fold as FL
+import qualified Streamly.Internal.Data.Refold.Type as Refold
 import qualified Streamly.Internal.Data.Stream as S
 
 import Test.Tasty.Bench
-import Streamly.Benchmark.Common
+import Streamly.Benchmark.Common hiding (benchIOSrc)
 import Stream.Common
 import Prelude hiding (reverse, tail)
 

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

@@ -30,7 +30,6 @@ import qualified Streamly.Internal.Data.Array as Array
 import qualified Streamly.Internal.Data.Fold as Fold
 import qualified Streamly.Internal.Data.Stream as Stream
 import qualified Streamly.Internal.FileSystem.Handle as Handle
-import qualified Streamly.Internal.Unicode.Stream as Unicode
 
 import Test.Tasty.Bench hiding (env)
 import Prelude hiding (last, length)
@@ -277,28 +276,9 @@ o_1_space_reduce_read_split env =
         ]
     ]
 
--- | Split on a character sequence.
-splitOnSeqUtf8 :: String -> Handle -> IO Int
-splitOnSeqUtf8 str inh =
-    (Stream.fold Fold.length
-        $ Stream.splitSepBySeq_ (Array.fromList str) Fold.drain
-        $ Unicode.decodeUtf8Chunks
-        $ Handle.readChunks inh) -- >>= print
-
-o_1_space_reduce_toChunks_split :: BenchEnv -> [Benchmark]
-o_1_space_reduce_toChunks_split env =
-    [ bgroup "FileSplitSeqUtf8"
-        [ mkBenchSmall "splitOnSeqUtf8 word abcdefgh"
-            env $ \inh _ -> splitOnSeqUtf8 "abcdefgh" inh
-        , mkBenchSmall "splitOnSeqUtf8 KR abcdefghijklmnopqrstuvwxyz"
-            env $ \inh _ -> splitOnSeqUtf8 "abcdefghijklmnopqrstuvwxyz" inh
-        ]
-    ]
-
 benchmarks :: String -> BenchEnv -> [Benchmark]
 benchmarks moduleName env =
         [ bgroup (o_1_space_prefix moduleName) $ concat
             [ o_1_space_reduce_read_split env
-            , o_1_space_reduce_toChunks_split env
             ]
         ]

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

@@ -0,0 +1,73 @@
+
+-- |
+-- Module      : Stream.SplitChunks
+-- Copyright   : (c) 2019 Composewell Technologies
+-- License     : BSD-3-Clause
+-- Maintainer  : [email protected]
+-- Stability   : experimental
+-- Portability : GHC
+
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+
+#ifdef __HADDOCK_VERSION__
+#undef INSPECTION
+#endif
+
+#ifdef INSPECTION
+{-# LANGUAGE TemplateHaskell #-}
+{-# OPTIONS_GHC -fplugin Test.Inspection.Plugin #-}
+#endif
+
+module Stream.SplitChunks (benchmarks) where
+
+import System.IO (Handle)
+
+import qualified Streamly.Internal.Data.Array as Array
+import qualified Streamly.Internal.Data.Fold as Fold
+import qualified Streamly.Internal.Data.Stream as Stream
+import qualified Streamly.Internal.FileSystem.Handle as Handle
+import qualified Streamly.Internal.Unicode.Stream as Unicode
+
+import Test.Tasty.Bench hiding (env)
+import Prelude hiding (last, length)
+import Streamly.Benchmark.Common
+import Streamly.Benchmark.Common.Handle
+
+#ifdef INSPECTION
+import Streamly.Internal.Data.Stream (Step(..))
+
+import qualified Streamly.Internal.Data.MutArray as MutArray
+import qualified Streamly.Internal.Data.Unfold as Unfold
+
+import Test.Inspection
+#endif
+
+-------------------------------------------------------------------------------
+-- reduce with splitting transformations
+-------------------------------------------------------------------------------
+
+-- | Split on a character sequence.
+splitOnSeqUtf8 :: String -> Handle -> IO Int
+splitOnSeqUtf8 str inh =
+    (Stream.fold Fold.length
+        $ Stream.splitSepBySeq_ (Array.fromList str) Fold.drain
+        $ Unicode.decodeUtf8Chunks
+        $ Handle.readChunks inh) -- >>= print
+
+o_1_space_reduce_toChunks_split :: BenchEnv -> [Benchmark]
+o_1_space_reduce_toChunks_split env =
+    [ bgroup "FileSplitSeqUtf8"
+        [ mkBenchSmall "splitOnSeqUtf8 word abcdefgh"
+            env $ \inh _ -> splitOnSeqUtf8 "abcdefgh" inh
+        , mkBenchSmall "splitOnSeqUtf8 KR abcdefghijklmnopqrstuvwxyz"
+            env $ \inh _ -> splitOnSeqUtf8 "abcdefghijklmnopqrstuvwxyz" inh
+        ]
+    ]
+
+benchmarks :: String -> BenchEnv -> [Benchmark]
+benchmarks moduleName env =
+        [ bgroup (o_1_space_prefix moduleName) $ concat
+            [ o_1_space_reduce_toChunks_split env
+            ]
+        ]