@@ -0,0 +1,148 @@
1+-- |
2+-- Module : Streamly.Benchmark.Data.ArrayOps
3+-- Copyright : (c) 2019 Composewell Technologies
4+--
5+-- License : BSD-3-Clause
6+-- Maintainer : streamly@composewell.com
7+-- Stability : experimental
8+-- Portability : GHC
9+
10+{-# LANGUAGE CPP #-}
11+{-# LANGUAGE DeriveAnyClass #-}
12+{-# LANGUAGE DeriveGeneric #-}
13+{-# LANGUAGE FlexibleContexts #-}
14+{-# LANGUAGE ScopedTypeVariables #-}
15+
16+module Streamly.Benchmark.Data.ArrayOps where
17+
18+import Control.Monad.IO.Class (MonadIO)
19+import Prelude (Int, (+), ($), (>), (.), Maybe(..), undefined)
20+import qualified Prelude as P
21+#ifdef DEVBUILD
22+import qualified Data.Foldable as F
23+#endif
24+
25+import qualified Streamly as S hiding (foldMapWith, runStream)
26+import qualified Streamly.Data.Array as A
27+import qualified Streamly.Prelude as S
28+
29+value :: Int
30+value = 10000
31+
32+-------------------------------------------------------------------------------
33+-- Benchmark ops
34+-------------------------------------------------------------------------------
35+
36+-------------------------------------------------------------------------------
37+-- Stream generation and elimination
38+-------------------------------------------------------------------------------
39+
40+type Stream = A.Array
41+
42+{-# INLINE sourceUnfoldr #-}
43+sourceUnfoldr :: MonadIO m => Int -> m (Stream Int)
44+sourceUnfoldr n = S.fold (A.writeN value) $ S.unfoldr step n
45+ where
46+ step cnt =
47+ if cnt > n + value
48+ then Nothing
49+ else (Just (cnt, cnt + 1))
50+
51+{-# INLINE sourceIntFromTo #-}
52+sourceIntFromTo :: MonadIO m => Int -> m (Stream Int)
53+sourceIntFromTo n = S.fold (A.writeN value) $ S.enumerateFromTo n (n + value)
54+
55+{-# INLINE sourceIntFromToFromStream #-}
56+sourceIntFromToFromStream :: MonadIO m => Int -> m (Stream Int)
57+sourceIntFromToFromStream n = S.fold A.write $ S.enumerateFromTo n (n + value)
58+
59+{-# INLINE sourceIntFromToFromList #-}
60+sourceIntFromToFromList :: MonadIO m => Int -> m (Stream Int)
61+sourceIntFromToFromList n = P.return $ A.fromList $ [n..n + value]
62+
63+{-# INLINE sourceFromList #-}
64+sourceFromList :: MonadIO m => Int -> m (Stream Int)
65+sourceFromList n = S.fold (A.writeN value) $ S.fromList [n..n+value]
66+{-
67+{-# INLINE sourceIsList #-}
68+sourceIsList :: Int -> Stream Int
69+sourceIsList n = GHC.fromList [n..n+value]
70+
71+{-# INLINE sourceIsString #-}
72+sourceIsString :: Int -> Stream P.Char
73+sourceIsString n = GHC.fromString (P.replicate (n + value) 'a')
74+-}
75+-------------------------------------------------------------------------------
76+-- Transformation
77+-------------------------------------------------------------------------------
78+
79+{-# INLINE composeN #-}
80+composeN :: P.Monad m
81+ => Int -> (Stream Int -> m (Stream Int)) -> Stream Int -> m (Stream Int)
82+composeN n f x =
83+ case n of
84+ 1 -> f x
85+ 2 -> f x P.>>= f
86+ 3 -> f x P.>>= f P.>>= f
87+ 4 -> f x P.>>= f P.>>= f P.>>= f
88+ _ -> undefined
89+
90+{-# INLINE scanl' #-}
91+{-# INLINE scanl1' #-}
92+{-# INLINE map #-}
93+
94+scanl', scanl1', map
95+ :: MonadIO m => Int -> Stream Int -> m (Stream Int)
96+
97+{-# INLINE onArray #-}
98+onArray
99+ :: MonadIO m => (S.SerialT m Int -> S.SerialT m Int)
100+ -> Stream Int
101+ -> m (Stream Int)
102+onArray f arr = S.fold (A.writeN value) $ f $ (S.unfold A.read arr)
103+
104+scanl' n = composeN n $ onArray $ S.scanl' (+) 0
105+scanl1' n = composeN n $ onArray $ S.scanl1' (+)
106+map n = composeN n $ onArray $ S.map (+1)
107+{-
108+{-# INLINE eqInstance #-}
109+eqInstance :: Stream Int -> Bool
110+eqInstance src = src == src
111+
112+{-# INLINE eqInstanceNotEq #-}
113+eqInstanceNotEq :: Stream Int -> Bool
114+eqInstanceNotEq src = src P./= src
115+
116+{-# INLINE ordInstance #-}
117+ordInstance :: Stream Int -> Bool
118+ordInstance src = src P.< src
119+
120+{-# INLINE ordInstanceMin #-}
121+ordInstanceMin :: Stream Int -> Stream Int
122+ordInstanceMin src = P.min src src
123+
124+{-# INLINE showInstance #-}
125+showInstance :: Stream Int -> P.String
126+showInstance src = P.show src
127+
128+{-# INLINE readInstance #-}
129+readInstance :: P.String -> Stream Int
130+readInstance str =
131+ let r = P.reads str
132+ in case r of
133+ [(x,"")] -> x
134+ _ -> P.error "readInstance: no parse"
135+-}
136+{-# INLINE pureFoldl' #-}
137+pureFoldl' :: MonadIO m => Stream Int -> m Int
138+pureFoldl' = S.foldl' (+) 0 . S.unfold A.read
139+
140+#ifdef DEVBUILD
141+{-# INLINE foldableFoldl' #-}
142+foldableFoldl' :: Stream Int -> Int
143+foldableFoldl' = F.foldl' (+) 0
144+
145+{-# INLINE foldableSum #-}
146+foldableSum :: Stream Int -> Int
147+foldableSum = P.sum
148+#endif