@@ -1,531 +0,0 @@
3−-- Copyright : (c) 2018 Harendra Kumar
6−-- Maintainer : streamly@composewell.com
9−{-# LANGUAGE FlexibleContexts #-}
10−{-# LANGUAGE ScopedTypeVariables #-}
11−{-# LANGUAGE DeriveAnyClass #-}
12−{-# LANGUAGE DeriveGeneric #-}
14−module Streamly.Benchmark.Memory.ArrayOps where
16−-- import Control.Monad (when)
17−import Control.Monad.IO.Class (MonadIO)
18−-- import Data.Maybe (fromJust)
19−import Prelude (Int, Bool, (+), ($), (==), (>), (.), Maybe(..), undefined)
20−import qualified Prelude as P
22−import qualified Data.Foldable as F
24−import qualified GHC.Exts as GHC
25−-- import Control.DeepSeq (NFData)
26−-- import GHC.Generics (Generic)
28−import qualified Streamly as S hiding (foldMapWith, runStream)
29−import qualified Streamly.Memory.Array as A
30−import qualified Streamly.Prelude as S
32−value, maxValue :: Int
40−-------------------------------------------------------------------------------
42−-------------------------------------------------------------------------------
44−-------------------------------------------------------------------------------
45−-- Stream generation and elimination
46−-------------------------------------------------------------------------------
50−{-# INLINE sourceUnfoldr #-}
51−sourceUnfoldr :: MonadIO m => Int -> m (Stream Int)
52−sourceUnfoldr n = S.fold (A.writeN value) $ S.unfoldr step n
57− else (Just (cnt, cnt + 1))
59−{-# INLINE sourceIntFromTo #-}
60−sourceIntFromTo :: MonadIO m => Int -> m (Stream Int)
61−sourceIntFromTo n = S.fold (A.writeN value) $ S.enumerateFromTo n (n + value)
63−{-# INLINE sourceIntFromToFromStream #-}
64−sourceIntFromToFromStream :: MonadIO m => Int -> m (Stream Int)
65−sourceIntFromToFromStream n = S.fold A.write $ S.enumerateFromTo n (n + value)
67−sourceIntFromToFromList :: MonadIO m => Int -> m (Stream Int)
68−sourceIntFromToFromList n = P.return $ A.fromList $ [n..n + value]
70−{-# INLINE sourceFromList #-}
71−sourceFromList :: MonadIO m => Int -> m (Stream Int)
72−sourceFromList n = S.fold (A.writeN value) $ S.fromList [n..n+value]
74−{-# INLINE sourceIsList #-}
75−sourceIsList :: Int -> Stream Int
76−sourceIsList n = GHC.fromList [n..n+value]
78−{-# INLINE sourceIsString #-}
79−sourceIsString :: Int -> Stream P.Char
80−sourceIsString n = GHC.fromString (P.replicate (n + value) 'a')
83−-------------------------------------------------------------------------------
85−-------------------------------------------------------------------------------
87−{-# INLINE runStream #-}
88−runStream :: Monad m => Stream m a -> m ()
89−runStream = S.runStream
92−toList :: Monad m => Stream m Int -> m [Int]
96−{-# INLINE maximum #-}
97−{-# INLINE minimum #-}
99−{-# INLINE findIndex #-}
100−{-# INLINE elemIndex #-}
101−{-# INLINE foldl1'Reduce #-}
102−head, last, minimum, maximum, find, findIndex, elemIndex, foldl1'Reduce
103− :: Monad m => Stream m Int -> m (Maybe Int)
105−{-# INLINE minimumBy #-}
106−{-# INLINE maximumBy #-}
107−minimumBy, maximumBy :: Monad m => Stream m Int -> m (Maybe Int)
109−{-# INLINE foldl'Reduce #-}
110−{-# INLINE foldl'ReduceMap #-}
111−{-# INLINE foldlM'Reduce #-}
112−{-# INLINE foldrMReduce #-}
113−{-# INLINE length #-}
115−{-# INLINE product #-}
116−foldl'Reduce, foldl'ReduceMap, foldlM'Reduce, foldrMReduce, length, sum, product
118− => Stream m Int -> m Int
120−{-# INLINE foldl'Build #-}
121−{-# INLINE foldlM'Build #-}
122−{-# INLINE foldrMBuild #-}
123−foldrMBuild, foldl'Build, foldlM'Build
125− => Stream m Int -> m [Int]
133−{-# INLINE notElem #-}
134−null, elem, notElem, all, any, and, or :: Monad m => Stream m Int -> m Bool
136−{-# INLINE toNull #-}
137−toNull :: Monad m => (t m a -> S.SerialT m a) -> t m a -> m ()
138−toNull t = runStream . t
140−{-# INLINE uncons #-}
141−uncons :: Monad m => Stream m Int -> m ()
145− Nothing -> return ()
146− Just (_, t) -> uncons t
149−init :: Monad m => Stream m a -> m ()
150−init s = S.init s >>= Prelude.mapM_ S.runStream
153−tail :: Monad m => Stream m a -> m ()
154−tail s = S.tail s >>= Prelude.mapM_ tail
156−{-# INLINE nullHeadTail #-}
157−nullHeadTail :: Monad m => Stream m Int -> m ()
162− S.tail s >>= Prelude.mapM_ nullHeadTail
165−mapM_ :: Monad m => Stream m Int -> m ()
166−mapM_ = S.mapM_ (\_ -> return ())
170−{-# INLINE toRevList #-}
171−toRevList :: Monad m => Stream m Int -> m [Int]
172−toRevList = S.toRevList
174−foldrMBuild = S.foldrM (\x xs -> xs >>= return . (x :)) (return [])
175−foldl'Build = S.foldl' (flip (:)) []
176−foldlM'Build = S.foldlM' (\xs x -> return $ x : xs) (return [])
178−foldrMReduce = S.foldrM (\x xs -> xs >>= return . (x +)) (return 0)
179−foldl'Reduce = S.foldl' (+) 0
180−foldl'ReduceMap = P.fmap (+1) . S.foldl' (+) 0
181−foldl1'Reduce = S.foldl1' (+)
182−foldlM'Reduce = S.foldlM' (\xs a -> return $ a + xs) (return 0)
187−elem = S.elem maxValue
188−notElem = S.notElem maxValue
190−all = S.all (<= maxValue)
191−any = S.any (> maxValue)
192−and = S.and . S.map (<= maxValue)
193−or = S.or . S.map (> maxValue)
194−find = S.find (== maxValue)
195−findIndex = S.findIndex (== maxValue)
196−elemIndex = S.elemIndex maxValue
201−minimumBy = S.minimumBy compare
202−maximumBy = S.maximumBy compare
205−-------------------------------------------------------------------------------
207−-------------------------------------------------------------------------------
210−{-# INLINE transform #-}
211−transform :: Stream a -> Stream a
215−{-# INLINE composeN #-}
216−composeN :: P.Monad m
217− => Int -> (Stream Int -> m (Stream Int)) -> Stream Int -> m (Stream Int)
222− 3 -> f x P.>>= f P.>>= f
223− 4 -> f x P.>>= f P.>>= f P.>>= f
226−{-# INLINE scanl' #-}
227−{-# INLINE scanl1' #-}
231−{-# INLINE mapMaybe #-}
232−{-# INLINE filterEven #-}
233−{-# INLINE filterAllOut #-}
234−{-# INLINE filterAllIn #-}
235−{-# INLINE takeOne #-}
236−{-# INLINE takeAll #-}
237−{-# INLINE takeWhileTrue #-}
238−{-# INLINE takeWhileMTrue #-}
239−{-# INLINE dropOne #-}
240−{-# INLINE dropAll #-}
241−{-# INLINE dropWhileTrue #-}
242−{-# INLINE dropWhileMTrue #-}
243−{-# INLINE dropWhileFalse #-}
244−{-# INLINE findIndices #-}
245−{-# INLINE elemIndices #-}
246−{-# INLINE insertBy #-}
247−{-# INLINE deleteBy #-}
248−{-# INLINE reverse #-}
249−{-# INLINE foldrS #-}
250−{-# INLINE foldrSMap #-}
251−{-# INLINE foldrT #-}
252−{-# INLINE foldrTMap #-}
254−scanl' , scanl1', map{-, fmap, mapMaybe, filterEven, filterAllOut,
255− filterAllIn, takeOne, takeAll, takeWhileTrue, takeWhileMTrue, dropOne,
256− dropAll, dropWhileTrue, dropWhileMTrue, dropWhileFalse,
257− findIndices, elemIndices, insertBy, deleteBy, reverse,
258− foldrS, foldrSMap, foldrT, foldrTMap -}
259− :: MonadIO m => Int -> Stream Int -> m (Stream Int)
262−{-# INLINE mapMaybeM #-}
263−mapMaybeM :: S.MonadAsync m => Int -> Stream m Int -> m ()
268−mapM, map' :: (S.IsStream t, S.MonadAsync m)
269− => (t m Int -> S.SerialT m Int) -> Int -> t m Int -> m ()
271−fmap' :: (S.IsStream t, S.MonadAsync m, P.Functor (t m))
272− => (t m Int -> S.SerialT m Int) -> Int -> t m Int -> m ()
274−{-# INLINE sequence #-}
275−sequence :: (S.IsStream t, S.MonadAsync m)
276− => (t m Int -> S.SerialT m Int) -> t m (m Int) -> m ()
279−{-# INLINE onArray #-}
281− :: MonadIO m => (S.SerialT m Int -> S.SerialT m Int)
284−onArray f arr = S.fold (A.writeN value) $ f $ (S.unfold A.read arr)
286−scanl' n = composeN n $ onArray $ S.scanl' (+) 0
287−scanl1' n = composeN n $ onArray $ S.scanl1' (+)
288−map n = composeN n $ onArray $ S.map (+1)
289−-- map n = composeN n $ A.map (+1)
291−fmap n = composeN n $ Prelude.fmap (+1)
292−fmap' t n = composeN' n $ t . Prelude.fmap (+1)
293−map' t n = composeN' n $ t . S.map (+1)
294−mapM t n = composeN' n $ t . S.mapM return
295−mapMaybe n = composeN n $ S.mapMaybe
296− (\x -> if Prelude.odd x then Nothing else Just x)
297−mapMaybeM n = composeN n $ S.mapMaybeM
298− (\x -> if Prelude.odd x then return Nothing else return $ Just x)
299−sequence t = transform . t . S.sequence
300−filterEven n = composeN n $ S.filter even
301−filterAllOut n = composeN n $ S.filter (> maxValue)
302−filterAllIn n = composeN n $ S.filter (<= maxValue)
303−takeOne n = composeN n $ S.take 1
304−takeAll n = composeN n $ S.take maxValue
305−takeWhileTrue n = composeN n $ S.takeWhile (<= maxValue)
306−takeWhileMTrue n = composeN n $ S.takeWhileM (return . (<= maxValue))
307−dropOne n = composeN n $ S.drop 1
308−dropAll n = composeN n $ S.drop maxValue
309−dropWhileTrue n = composeN n $ S.dropWhile (<= maxValue)
310−dropWhileMTrue n = composeN n $ S.dropWhileM (return . (<= maxValue))
311−dropWhileFalse n = composeN n $ S.dropWhile (> maxValue)
312−findIndices n = composeN n $ S.findIndices (== maxValue)
313−elemIndices n = composeN n $ S.elemIndices maxValue
314−insertBy n = composeN n $ S.insertBy compare maxValue
315−deleteBy n = composeN n $ S.deleteBy (>=) maxValue
316−reverse n = composeN n $ S.reverse
317−foldrS n = composeN n $ S.foldrS S.cons S.nil
318−foldrSMap n = composeN n $ S.foldrS (\x xs -> x + 1 `S.cons` xs) S.nil
319−foldrT n = composeN n $ S.foldrT S.cons S.nil
320−foldrTMap n = composeN n $ S.foldrT (\x xs -> x + 1 `S.cons` xs) S.nil
322−-------------------------------------------------------------------------------
324−-------------------------------------------------------------------------------
326−iterStreamLen, maxIters :: Int
330−{-# INLINE iterateSource #-}
333− => (Stream m Int -> Stream m Int) -> Int -> Int -> Stream m Int
334−iterateSource g i n = f i (sourceUnfoldrMN iterStreamLen n)
336− f (0 :: Int) m = g m
337− f x m = g (f (x P.- 1) m)
339−{-# INLINE iterateMapM #-}
340−{-# INLINE iterateScan #-}
341−{-# INLINE iterateScanl1 #-}
342−{-# INLINE iterateFilterEven #-}
343−{-# INLINE iterateTakeAll #-}
344−{-# INLINE iterateDropOne #-}
345−{-# INLINE iterateDropWhileFalse #-}
346−{-# INLINE iterateDropWhileTrue #-}
347−iterateMapM, iterateScan, iterateScanl1, iterateFilterEven, iterateTakeAll,
348− iterateDropOne, iterateDropWhileFalse, iterateDropWhileTrue
350− => Int -> Stream m Int
353−iterateScan = iterateSource (S.scanl' (+) 0) (maxIters `div` 10)
355−iterateScanl1 = iterateSource (S.scanl1' (+)) (maxIters `div` 10)
357−iterateMapM = iterateSource (S.mapM return) maxIters
358−iterateFilterEven = iterateSource (S.filter even) maxIters
359−iterateTakeAll = iterateSource (S.take maxValue) maxIters
360−iterateDropOne = iterateSource (S.drop 1) maxIters
361−iterateDropWhileFalse = iterateSource (S.dropWhile (> maxValue)) maxIters
362−iterateDropWhileTrue = iterateSource (S.dropWhile (<= maxValue)) maxIters
364−-------------------------------------------------------------------------------
365−-- Zipping and concat
366−-------------------------------------------------------------------------------
370−{-# INLINE mergeBy #-}
371−zip, zipM, mergeBy :: Monad m => Stream m Int -> m ()
375− let src1 = fromJust r
376− transform (S.zipWith (,) src src1)
379− let src1 = fromJust r
380− transform (S.zipWithM (curry return) src src1)
384− let src1 = fromJust r
385− transform (S.mergeBy P.compare src src1)
387−{-# INLINE isPrefixOf #-}
388−{-# INLINE isSubsequenceOf #-}
389−isPrefixOf, isSubsequenceOf :: Monad m => Stream m Int -> m Bool
391−isPrefixOf src = S.isPrefixOf src src
392−isSubsequenceOf src = S.isSubsequenceOf src src
394−{-# INLINE stripPrefix #-}
395−stripPrefix :: Monad m => Stream m Int -> m ()
397− _ <- S.stripPrefix src src
400−{-# INLINE zipAsync #-}
401−{-# INLINE zipAsyncM #-}
402−{-# INLINE zipAsyncAp #-}
403−zipAsync, zipAsyncAp, zipAsyncM :: S.MonadAsync m => Stream m Int -> m ()
407− let src1 = fromJust r
408− transform (S.zipAsyncWith (,) src src1)
412− let src1 = fromJust r
413− transform (S.zipAsyncWithM (curry return) src src1)
417− let src1 = fromJust r
418− transform (S.zipAsyncly $ (,) <$> S.serially src
419− <*> S.serially src1)
422−eqBy :: (Monad m, P.Eq a) => Stream m a -> m P.Bool
423−eqBy src = S.eqBy (==) src src
426−cmpBy :: (Monad m, P.Ord a) => Stream m a -> m P.Ordering
427−cmpBy src = S.cmpBy P.compare src src
429−concatStreamLen, maxNested :: Int
433−{-# INLINE concatMap #-}
434−concatMap :: S.MonadAsync m => Int -> Stream m Int
435−concatMap n = S.concatMap (\_ -> sourceUnfoldrMN maxNested n)
436− (sourceUnfoldrMN concatStreamLen n)
438−-------------------------------------------------------------------------------
440−-------------------------------------------------------------------------------
442−{-# INLINE scanMap #-}
443−{-# INLINE dropMap #-}
444−{-# INLINE dropScan #-}
445−{-# INLINE takeDrop #-}
446−{-# INLINE takeScan #-}
447−{-# INLINE takeMap #-}
448−{-# INLINE filterDrop #-}
449−{-# INLINE filterTake #-}
450−{-# INLINE filterScan #-}
451−{-# INLINE filterScanl1 #-}
452−{-# INLINE filterMap #-}
453−scanMap, dropMap, dropScan, takeDrop, takeScan, takeMap, filterDrop,
454− filterTake, filterScan, filterScanl1, filterMap
455− :: Monad m => Int -> Stream m Int -> m ()
457−scanMap n = composeN n $ S.map (subtract 1) . S.scanl' (+) 0
458−dropMap n = composeN n $ S.map (subtract 1) . S.drop 1
459−dropScan n = composeN n $ S.scanl' (+) 0 . S.drop 1
460−takeDrop n = composeN n $ S.drop 1 . S.take maxValue
461−takeScan n = composeN n $ S.scanl' (+) 0 . S.take maxValue
462−takeMap n = composeN n $ S.map (subtract 1) . S.take maxValue
463−filterDrop n = composeN n $ S.drop 1 . S.filter (<= maxValue)
464−filterTake n = composeN n $ S.take maxValue . S.filter (<= maxValue)
465−filterScan n = composeN n $ S.scanl' (+) 0 . S.filter (<= maxBound)
466−filterScanl1 n = composeN n $ S.scanl1' (+) . S.filter (<= maxBound)
467−filterMap n = composeN n $ S.map (subtract 1) . S.filter (<= maxValue)
469−data Pair a b = Pair !a !b deriving (Generic, NFData)
471−{-# INLINE sumProductFold #-}
472−sumProductFold :: Monad m => Stream m Int -> m (Int, Int)
473−sumProductFold = S.foldl' (\(s,p) x -> (s + x, p P.* x)) (0,1)
475−{-# INLINE sumProductScan #-}
476−sumProductScan :: Monad m => Stream m Int -> m (Pair Int Int)
477−sumProductScan = S.foldl' (\(Pair _ p) (s0,x) -> Pair s0 (p P.* x)) (Pair 0 1)
478− . S.scanl' (\(s,_) x -> (s + x,x)) (0,0)
480−-------------------------------------------------------------------------------
481−-- Pure stream operations
482−-------------------------------------------------------------------------------
485−{-# INLINE eqInstance #-}
486−eqInstance :: Stream Int -> Bool
487−eqInstance src = src == src
489−{-# INLINE eqInstanceNotEq #-}
490−eqInstanceNotEq :: Stream Int -> Bool
491−eqInstanceNotEq src = src P./= src
493−{-# INLINE ordInstance #-}
494−ordInstance :: Stream Int -> Bool
495−ordInstance src = src P.< src
497−{-# INLINE ordInstanceMin #-}
498−ordInstanceMin :: Stream Int -> Stream Int
499−ordInstanceMin src = P.min src src
501−{-# INLINE showInstance #-}
502−showInstance :: Stream Int -> P.String
503−showInstance src = P.show src
505−{-# INLINE readInstance #-}
506−readInstance :: P.String -> Stream Int
511− _ -> P.error "readInstance: no parse"
513−{-# INLINE pureFoldl' #-}
514−pureFoldl' :: MonadIO m => Stream Int -> m Int
515−pureFoldl' = S.foldl' (+) 0 . S.unfold A.read
518−{-# INLINE foldableFoldl' #-}
519−foldableFoldl' :: Stream Int -> Int
520−foldableFoldl' = F.foldl' (+) 0
522−{-# INLINE foldableSum #-}
523−foldableSum :: Stream Int -> Int
528−{-# INLINE traversableMapM #-}
529−traversableMapM :: Stream Identity Int -> IO (Stream Identity Int)
530−traversableMapM = P.mapM return