@@ -31,48 +31,57 @@ module Streamly.Internal.Data.MutArray.Type
31 -- ** Type
31 -- ** Type
32 -- $arrayNotes
32 -- $arrayNotes
33 MutArray (..)
33 MutArray (..)
36+ -- *** Pinned and Unpinned
36 , isPinned
39 , isPinned
38− -- -- * Constructing and Writing
41+ -- ** Casting
39− -- ** Construction
42+ , cast
40− , nil
43+ , castUnsafe -- XXX unsafeCast
42− -- *** Uninitialized Arrays
45+ , unsafePinnedAsPtr
43− , pinnedNew
46+ , unsafeAsPtr
52+ -- | New arrays are always empty arrays with some reserve capacity to
53+ -- extend the length without reallocating.
55+ , newArrayWith -- emptyAlignedWith
57+ , pinnedNewAligned -- XXX not required
58+ -- , new -- uninitialized array of specified length
49− -- ** Cloning arrays
60+ -- *** Cloning
51 , pinnedClone
62 , pinnedClone
53− -- ** Slicing
64+ -- *** Slicing
54 -- | Get a subarray without copying
65 -- | Get a subarray without copying
55− , getSliceUnsafe
66+ , getSliceUnsafe -- XXX unsafeGetSlice
56 , getSlice
67 , getSlice
57 , splitAt -- XXX should be able to express using getSlice
68 , splitAt -- XXX should be able to express using getSlice
60− -- *** From streams
71+ -- *** Stream Folds
61 , ArrayUnsafe (..)
72 , ArrayUnsafe (..)
62− , writeNWithUnsafe
73+ , unsafeCreateOfWith
63− , writeNWith
74+ , unsafeCreateOf
64− , writeNUnsafe
75+ , unsafePinnedCreateOf
65− , pinnedWriteNUnsafe
76+ , pinnedCreateOf
66− , writeN
77+ , createOfWith
67− , pinnedWriteN
78+ , createOf
68− , pinnedWriteNAligned
79+ , revCreateOf
70− , writeWith
81+ , pinnedCreate
71− , write
82+ , createWith
72− , pinnedWrite
83+ , create
77 -- *** From containers
86 -- *** From containers
78 , fromListN
87 , fromListN
@@ -88,11 +97,11 @@ module Streamly.Internal.Data.MutArray.Type
88 , fromByteStr#
97 , fromByteStr#
89 , fromPtrN
98 , fromPtrN
90 , fromChunksK
99 , fromChunksK
91− , fromChunksRealloced
100+ , fromChunksRealloced -- fromSmallChunks
93 -- ** Random writes
102 -- ** Random writes
94 , putIndex
103 , putIndex
95− , putIndexUnsafe
104+ , putIndexUnsafe -- XXX unsafePutIndex
96 , putIndices
105 , putIndices
97 -- , putFromThenTo
106 -- , putFromThenTo
98 -- , putFrom -- start writing at the given position
107 -- , putFrom -- start writing at the given position
@@ -100,87 +109,70 @@ module Streamly.Internal.Data.MutArray.Type
100 -- , putFromTo
109 -- , putFromTo
101 -- , putFromRev
110 -- , putFromRev
102 -- , putUptoRev
111 -- , putUptoRev
103− , modifyIndexUnsafe
112+ , modifyIndexUnsafe -- XXX unsafeModifyIndex
104 , modifyIndex
113 , modifyIndex
105 , modifyIndices
114 , modifyIndices
107 , swapIndices
116 , swapIndices
108 , unsafeSwapIndices
117 , unsafeSwapIndices
110− -- ** Growing and Shrinking
111− -- | Arrays grow only at the end, though it is possible to grow on both sides
112− -- and therefore have a cons as well as snoc. But that will require two
113− -- bounds in the array representation.
115− -- *** Appending elements
122− -- *** Appending streams
123− , writeAppendNUnsafe
128− -- *** Appending arrays
136− -- , appendSliceFrom
138− -- ** Eliminating and Reading
119+ -- ** Reading
140− -- *** To streams
121+ -- *** Indexing
141− , reader
122+ , getIndex
142− , readerRevWith
123+ , getIndexUnsafe -- XXX unsafeGetIndex
143− , readerRev
124+ -- , getFromThenTo
125+ , getIndexRev -- getRevIndex?
145− -- *** To containers
129+ -- *** To Streams
151 , readRev
131 , readRev
152 , toStreamK
134 , toStreamK
153 , toStreamKRev
136 , toStreamKRev
139+ -- *** To Containers
156 -- experimental
143 -- experimental
157 , producerWith
144 , producerWith
158 , producer
145 , producer
160− -- *** Random reads
147+ , reader
161− , getIndex
148+ , readerRevWith
162− , getIndexUnsafe
149+ , readerRev
168− -- ** Memory Management
171− , allocBytesToElemCount
177− -- ** Size
151+ -- ** Size and Capacity
179 , byteLength
154 , byteLength
180 -- , capacity
157 -- , capacity
181 , byteCapacity
158 , byteCapacity
182 , bytesFree
159 , bytesFree
161+ -- *** Capacity Management
164+ , allocBytesToElemCount
165+ , realloc -- this is "resize"
184 -- ** In-place Mutation Algorithms
176 -- ** In-place Mutation Algorithms
186 , reverse
178 , reverse
@@ -191,19 +183,43 @@ module Streamly.Internal.Data.MutArray.Type
191 , mergeBy
183 , mergeBy
194− -- ** Casting
186+ -- ** Growing and Shrinking
195− , cast
187+ -- | Arrays grow only at the end, though it is possible to grow on both
196− , castUnsafe
188+ -- sides and therefore have a cons as well as snoc. But that will require
197− , asBytes
189+ -- both lower and upper bound in the array representation.
199− , asUnpinnedPtrUnsafe
201− -- ** Folding
191+ -- *** Appending elements
202− , foldl'
192+ , snocWith
204− , cmp
194+ , snocLinear
205− , byteCmp
195+ , snocMay
206− , byteEq
196+ , snocUnsafe -- XXX unsafeSnoc
198+ -- *** Appending streams
204+ -- *** Appending arrays
209+ , spliceUnsafe -- XXX unsafeSplice
212+ -- , appendSliceFrom
214+ -- ** Serialization using Unbox
217+ , pokeSkipUnsafe -- unsafePokeSkip
219+ -- ** Deserialization using Unbox
221+ , peekUnconsUnsafe -- unsafePeekUncons
222+ , peekSkipUnsafe -- unsafePeekSkip
208 -- Arrays of arrays
224 -- Arrays of arrays
209 -- We can add dimensionality parameter to the array type to get
225 -- We can add dimensionality parameter to the array type to get
@@ -211,28 +227,38 @@ module Streamly.Internal.Data.MutArray.Type
211 -- convenience wrapper on top of single dimensional arrays.
227 -- convenience wrapper on top of single dimensional arrays.
213 -- ** Streams of Arrays
229 -- ** Streams of Arrays
214− -- *** Group a stream into arrays
231+ -- | Group a stream into arrays.
215 , chunksOf
232 , chunksOf
216 , pinnedChunksOf
233 , pinnedChunksOf
217 , buildChunks
234 , buildChunks
219− -- *** Split an array into slices
237+ -- | Split an array into slices.
220 -- , getSlicesFromLenN
239 -- , getSlicesFromLenN
221 , splitOn
240 , splitOn
222 -- , slicesOf
241 -- , slicesOf
224− -- *** Flatten a stream of arrays
243+ -- *** Concat
225− , concatChunks
244+ -- | Append the arrays in a stream to form a stream of elements.
226− , concatChunksRev
245+ , concatWith
228− -- *** Compaction
250+ -- *** Compact
251+ -- | Append the arrays in a stream to form a stream of larger arrays.
229 , SpliceState (..)
252 , SpliceState (..)
230− , pCompactChunksLE
253+ , pCompactLE
231− , rCompactChunksLE
254+ , pPinnedCompactLE
232− , fCompactChunksGE
255+ , compactLeAs
233− , lCompactChunksGE
256+ , fCompactGE
234− , compactChunksGE
257+ , fPinnedCompactGE
235− , compactChunksEQ
258+ , lCompactGE
237 -- ** Utilities
263 -- ** Utilities
238 , roundUpToPower2
264 , roundUpToPower2
@@ -241,12 +267,37 @@ module Streamly.Internal.Data.MutArray.Type
241 , c_memchr
267 , c_memchr
243 -- * Deprecated
269 -- * Deprecated
244 , writeChunks
271 , writeChunks
245 , flattenArrays
272 , flattenArrays
246 , flattenArraysRev
273 , flattenArraysRev
247 , fromArrayStreamK
274 , fromArrayStreamK
248 , fromStreamDN
275 , fromStreamDN
249 , fromStreamD
276 , fromStreamD
286+ , writeAppendNUnsafe
293+ , pinnedWriteNUnsafe
296+ , pinnedWriteNAligned -- XXX not required
@@ -302,7 +353,7 @@ import qualified Streamly.Internal.Data.StreamK.Type as K
302import qualified Prelude
353import qualified Prelude
304import Prelude hiding
355import Prelude hiding
305− (Foldable(..), read, unlines, splitAt, reverse, truncate)
356+ (Foldable(..), concat, read, unlines, splitAt, reverse, truncate)
307#include "DocTestDataMutArray.hs"
358#include "DocTestDataMutArray.hs"
@@ -428,6 +479,8 @@ isPinned MutArray{..} = Unboxed.isPinned arrContents
428-- we need more than that. See stg_pinnedNewAlignedByteArrayzh and
479-- we need more than that. See stg_pinnedNewAlignedByteArrayzh and
429-- allocatePinned in GHC source.
480-- allocatePinned in GHC source.
482+-- XXX Rename to emptyAlignedWith, alignSize should be first arg.
431-- | @newArrayWith allocator alignment count@ allocates a new array of zero
484-- | @newArrayWith allocator alignment count@ allocates a new array of zero
432-- length and with a capacity to hold @count@ elements, using @allocator
485-- length and with a capacity to hold @count@ elements, using @allocator
433-- size alignment@ as the memory allocator function.
486-- size alignment@ as the memory allocator function.
@@ -451,12 +504,25 @@ newArrayWith alloc alignSize count = do
451 , arrBound = size
504 , arrBound = size
507+-- For arrays "nil" sounds a bit odd. empty is better. The only problem with
508+-- empty is that it is also used by the Alternative type class. But assuming we
509+-- will mostly import the Array module qualified this should be fine.
511+-- | Create an empty array.
517+empty = MutArray Unboxed.empty 0 0 0
519+{-# DEPRECATED nil "Please use empty instead." #-}
455#ifdef DEVBUILD
521#ifdef DEVBUILD
456 Unbox a =>
522 Unbox a =>
458 MutArray a
524 MutArray a
459−nil = MutArray Unboxed.nil 0 0 0
525+nil = empty
461{-# INLINE newBytesAs #-}
527{-# INLINE newBytesAs #-}
462newBytesAs :: MonadIO m =>
528newBytesAs :: MonadIO m =>
@@ -473,12 +539,13 @@ newBytesAs ps bytes = do
473 , arrBound = bytes
539 , arrBound = bytes
476−-- | Allocates a pinned empty array that can hold 'count' items. The memory of
542+-- | Allocates a pinned empty array that with a reserved capacity of bytes.
477−-- the array is uninitialized and the allocation is aligned as per the
543+-- The memory of the array is uninitialized and the allocation is aligned as
478−-- 'Unboxed' instance of the type.
544+-- per the 'Unboxed' instance of the type.
480-- /Pre-release/
546-- /Pre-release/
481{-# INLINE pinnedNewBytes #-}
547{-# INLINE pinnedNewBytes #-}
548+{-# DEPRECATED pinnedNewBytes "Please use pinnedEmptyOf with appropriate calculation" #-}
482pinnedNewBytes :: MonadIO m =>
549pinnedNewBytes :: MonadIO m =>
483#ifdef DEVBUILD
550#ifdef DEVBUILD
484 Unbox a =>
551 Unbox a =>
@@ -503,21 +570,31 @@ newAs ps =
503 (error "new: alignment is not used in unpinned arrays.")
570 (error "new: alignment is not used in unpinned arrays.")
505-- XXX can unaligned allocation be more efficient when alignment is not needed?
572-- XXX can unaligned allocation be more efficient when alignment is not needed?
507−-- | Allocates an empty pinned array that can hold 'count' items. The memory of
574+-- | Allocates a pinned array of zero length but growable to the specified
508−-- the array is uninitialized and the allocation is aligned as per the 'Unboxed'
575+-- capacity without reallocation.
509−-- instance of the type.
576+{-# INLINE pinnedEmptyOf #-}
510−--
577+pinnedEmptyOf :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a)
578+pinnedEmptyOf = newAs Pinned
580+-- XXX Deprecate in major
581+-- {-# DEPRECATED pinnedNew "Please use pinnedEmptyOf instead." #-}
511{-# INLINE pinnedNew #-}
582{-# INLINE pinnedNew #-}
512pinnedNew :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a)
583pinnedNew :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a)
513−pinnedNew = newAs Pinned
584+pinnedNew = pinnedEmptyOf
515−-- | Allocates an empty unpinned array that can hold 'count' items. The memory
586+-- | Allocates an unpinned array of zero length but growable to the specified
516−-- of the array is uninitialized.
587+-- capacity without reallocation.
589+{-# INLINE emptyOf #-}
590+emptyOf :: (MonadIO m, Unbox a) => Int -> m (MutArray a)
591+emptyOf = newAs Unpinned
593+-- XXX Deprecate in major
594+-- {-# DEPRECATED new "Please use emptyOf instead." #-}
518{-# INLINE new #-}
595{-# INLINE new #-}
519new :: (MonadIO m, Unbox a) => Int -> m (MutArray a)
596new :: (MonadIO m, Unbox a) => Int -> m (MutArray a)
520−new = newAs Unpinned
597+new = emptyOf
522-------------------------------------------------------------------------------
599-------------------------------------------------------------------------------
523-- Random writes
600-- Random writes
@@ -565,7 +642,7 @@ putIndices arr = FL.foldlM' step (return ())
568− step () (i, x) = liftIO (putIndex i arr x)
645+ step () (i, x) = putIndex i arr x
570-- | Modify a given index of an array using a modifier function.
647-- | Modify a given index of an array using a modifier function.
@@ -761,22 +838,19 @@ arrayChunkBytes = 1024
761roundDownTo :: Int -> Int -> Int
838roundDownTo :: Int -> Int -> Int
762roundDownTo elemSize size = size - (size `mod` elemSize)
839roundDownTo elemSize size = size - (size `mod` elemSize)
764−-- XXX See if resizing can be implemented by reading the old array as a stream
765−-- and then using writeN to the new array.
767-- NOTE: we are passing elemSize explicitly to avoid an Unboxed constraint.
841-- NOTE: we are passing elemSize explicitly to avoid an Unboxed constraint.
768-- Since this is not inlined Unboxed consrraint leads to dictionary passing
842-- Since this is not inlined Unboxed consrraint leads to dictionary passing
769-- which complicates some inspection tests.
843-- which complicates some inspection tests.
771−{-# NOINLINE reallocExplicit #-}
845+{-# NOINLINE reallocExplicitAs #-}
772−reallocExplicit :: Int -> Int -> MutArray a -> IO (MutArray a)
846+reallocExplicitAs :: PinnedState -> Int -> Int -> MutArray a -> IO (MutArray a)
773−reallocExplicit elemSize newCapacityInBytes MutArray{..} = do
847+reallocExplicitAs ps elemSize newCapacityInBytes MutArray{..} = do
774 assertM(arrEnd <= arrBound)
848 assertM(arrEnd <= arrBound)
776 -- Allocate new array
850 -- Allocate new array
777 let newCapMaxInBytes = roundUpLargeArray newCapacityInBytes
851 let newCapMaxInBytes = roundUpLargeArray newCapacityInBytes
778 contents <-
852 contents <-
779− if Unboxed.isPinned arrContents
853+ if ps == Pinned
780 then Unboxed.pinnedNew newCapMaxInBytes
854 then Unboxed.pinnedNew newCapMaxInBytes
781 else Unboxed.new newCapMaxInBytes
855 else Unboxed.new newCapMaxInBytes
782 let !(MutByteArray mbarrFrom#) = arrContents
856 let !(MutByteArray mbarrFrom#) = arrContents
@@ -801,6 +875,10 @@ reallocExplicit elemSize newCapacityInBytes MutArray{..} = do
801 , arrBound = newCapInBytes
875 , arrBound = newCapInBytes
878+-- XXX Should these be called reallocBytes etc?
879+-- XXX We may also need reallocAs to allocate as pinned/unpinned explicitly. In
880+-- fact clone/pinnedClone can be implemented using reallocAs.
804-- | @realloc newCapacity array@ reallocates the array to the specified
882-- | @realloc newCapacity array@ reallocates the array to the specified
805-- capacity in bytes.
883-- capacity in bytes.
@@ -812,7 +890,12 @@ reallocExplicit elemSize newCapacityInBytes MutArray{..} = do
812-- If the original array is pinned, the newly allocated array is also pinned.
890-- If the original array is pinned, the newly allocated array is also pinned.
813{-# INLINABLE realloc #-}
891{-# INLINABLE realloc #-}
814realloc :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (MutArray a)
892realloc :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (MutArray a)
815−realloc bytes arr = liftIO $ reallocExplicit (SIZE_OF(a)) bytes arr
898+ in liftIO $ reallocExplicitAs ps (SIZE_OF(a)) bytes arr
817-- | @reallocWith label capSizer minIncrBytes array@. The label is used
900-- | @reallocWith label capSizer minIncrBytes array@. The label is used
818-- in error messages and the capSizer is used to determine the capacity of the
901-- in error messages and the capSizer is used to determine the capacity of the
@@ -835,14 +918,14 @@ reallocWith label capSizer minIncrBytes arr = do
837 badSize newSize =
920 badSize newSize =
838− concat
921+ Prelude.concat
840 , ": new array size (in bytes) is less than required size "
923 , ": new array size (in bytes) is less than required size "
841 , show newSize
924 , show newSize
842 , ". Please check the sizing function passed."
925 , ". Please check the sizing function passed."
845−-- | @resize newCapacity array@ changes the total capacity of the array so that
928+-- | @grow newCapacity array@ changes the total capacity of the array so that
846-- it is enough to hold the specified number of elements. Nothing is done if
929-- it is enough to hold the specified number of elements. Nothing is done if
847-- the specified capacity is less than the length of the array.
930-- the specified capacity is less than the length of the array.
@@ -850,34 +933,46 @@ reallocWith label capSizer minIncrBytes arr = do
850-- the block size (4K).
933-- the block size (4K).
852-- /Pre-release/
935-- /Pre-release/
853−{-# INLINE resize #-}
936+{-# INLINE grow #-}
854−resize :: forall m a. (MonadIO m, Unbox a) =>
937+grow :: forall m a. (MonadIO m, Unbox a) =>
855 Int -> MutArray a -> m (MutArray a)
938 Int -> MutArray a -> m (MutArray a)
856−resize nElems arr@MutArray{..} = do
939+grow nElems arr@MutArray{..} = do
857 let req = SIZE_OF(a) * nElems
940 let req = SIZE_OF(a) * nElems
858− len = arrEnd - arrStart
941+ cap = arrBound - arrStart
859− if req < len
942+ if req < cap
860 then return arr
943 then return arr
861 else realloc req arr
944 else realloc req arr
946+{-# DEPRECATED resize "Please use grow instead." #-}
947+{-# INLINE resize #-}
948+resize :: forall m a. (MonadIO m, Unbox a) =>
949+ Int -> MutArray a -> m (MutArray a)
863−-- | Like 'resize' but if the byte capacity is more than 'largeObjectThreshold'
952+-- | Like 'grow' but if the requested byte capacity is more than
864−-- then it is rounded up to the closest power of 2.
953+-- 'largeObjectThreshold' then it is rounded up to the closest power of 2.
866-- /Pre-release/
955-- /Pre-release/
867−{-# INLINE resizeExp #-}
956+{-# INLINE growExp #-}
868−resizeExp :: forall m a. (MonadIO m, Unbox a) =>
957+growExp :: forall m a. (MonadIO m, Unbox a) =>
869 Int -> MutArray a -> m (MutArray a)
958 Int -> MutArray a -> m (MutArray a)
870−resizeExp nElems arr@MutArray{..} = do
959+growExp nElems arr@MutArray{..} = do
871 let req = roundUpLargeArray (SIZE_OF(a) * nElems)
960 let req = roundUpLargeArray (SIZE_OF(a) * nElems)
873 if req > largeObjectThreshold
962 if req > largeObjectThreshold
874 then roundUpToPower2 req
963 then roundUpToPower2 req
876− len = arrEnd - arrStart
965+ cap = arrBound - arrStart
877− if req1 < len
966+ if req1 < cap
878 then return arr
967 then return arr
879 else realloc req1 arr
968 else realloc req1 arr
970+{-# DEPRECATED resizeExp "Please use growExp instead." #-}
971+{-# INLINE resizeExp #-}
972+resizeExp :: forall m a. (MonadIO m, Unbox a) =>
973+ Int -> MutArray a -> m (MutArray a)
881-- | Resize the allocated memory to drop any reserved free space at the end of
976-- | Resize the allocated memory to drop any reserved free space at the end of
882-- the array and reallocate it to reduce wastage.
977-- the array and reallocate it to reduce wastage.
@@ -942,7 +1037,7 @@ snocUnsafe arr@MutArray{..} = snocNewEnd (INDEX_NEXT(arrEnd,a)) arr
942{-# INLINE snocMay #-}
1037{-# INLINE snocMay #-}
943snocMay :: forall m a. (MonadIO m, Unbox a) =>
1038snocMay :: forall m a. (MonadIO m, Unbox a) =>
944 MutArray a -> a -> m (Maybe (MutArray a))
1039 MutArray a -> a -> m (Maybe (MutArray a))
945−snocMay arr@MutArray{..} x = liftIO $ do
1040+snocMay arr@MutArray{..} x = do
946 let newEnd = INDEX_NEXT(arrEnd,a)
1041 let newEnd = INDEX_NEXT(arrEnd,a)
947 if newEnd <= arrBound
1042 if newEnd <= arrBound
948 then Just <$> snocNewEnd newEnd arr x
1043 then Just <$> snocNewEnd newEnd arr x
@@ -956,7 +1051,7 @@ snocWithRealloc :: forall m a. (MonadIO m, Unbox a) =>
957 -> m (MutArray a)
1052 -> m (MutArray a)
958snocWithRealloc sizer arr x = do
1053snocWithRealloc sizer arr x = do
959− arr1 <- liftIO $ reallocWith "snocWith" sizer (SIZE_OF(a)) arr
1054+ arr1 <- reallocWith "snocWith" sizer (SIZE_OF(a)) arr
960 snocUnsafe arr1 x
1055 snocUnsafe arr1 x
962-- | @snocWith sizer arr elem@ mutates @arr@ to append @elem@. The length of
1057-- | @snocWith sizer arr elem@ mutates @arr@ to append @elem@. The length of
@@ -978,7 +1073,7 @@ snocWith :: forall m a. (MonadIO m, Unbox a) =>
978 -> MutArray a
1073 -> MutArray a
980 -> m (MutArray a)
1075 -> m (MutArray a)
981−snocWith allocSize arr x = liftIO $ do
1076+snocWith allocSize arr x = do
982 let newEnd = INDEX_NEXT(arrEnd arr,a)
1077 let newEnd = INDEX_NEXT(arrEnd arr,a)
983 if newEnd <= arrBound arr
1078 if newEnd <= arrBound arr
984 then snocNewEnd newEnd arr x
1079 then snocNewEnd newEnd arr x
@@ -1022,6 +1117,126 @@ snoc = snocWith f
1022 then oldSize * 2
1117 then oldSize * 2
1023 else roundUpToPower2 oldSize * 2
1118 else roundUpToPower2 oldSize * 2
1120+-------------------------------------------------------------------------------
1121+-- Serialization/Deserialization
1122+-------------------------------------------------------------------------------
1124+{-# INLINE pokeNewEnd #-}
1125+pokeNewEnd :: (MonadIO m, Unbox a) =>
1126+ Int -> MutArray Word8 -> a -> m (MutArray Word8)
1127+pokeNewEnd newEnd arr@MutArray{..} x = liftIO $ do
1128+ assert (newEnd <= arrBound) (return ())
1129+ liftIO $ pokeAt arrEnd arrContents x
1130+ return $ arr {arrEnd = newEnd}
1132+-- | Really really unsafe, unboxes a Haskell type and appends the resulting
1133+-- bytes to the byte array, may cause silent data corruption or if you are
1134+-- lucky a segfault if the array does not have enough space to append the
1138+{-# INLINE pokeAppendUnsafe #-}
1139+pokeAppendUnsafe :: forall m a. (MonadIO m, Unbox a) =>
1140+ MutArray Word8 -> a -> m (MutArray Word8)
1141+pokeAppendUnsafe arr@MutArray{..} = pokeNewEnd (arrEnd + SIZE_OF(a)) arr
1143+-- | Skip the specified number of bytes in the array. The data in the skipped
1144+-- region remains uninitialzed.
1145+{-# INLINE pokeSkipUnsafe #-}
1146+pokeSkipUnsafe :: Int -> MutArray Word8 -> MutArray Word8
1147+pokeSkipUnsafe n arr@MutArray{..} = do
1148+ let newEnd = arrEnd + n
1149+ in assert (newEnd <= arrBound) (arr {arrEnd = newEnd})
1151+-- | Like 'pokeAppend' but does not grow the array when pre-allocated array
1152+-- capacity becomes full.
1155+{-# INLINE pokeAppendMay #-}
1156+pokeAppendMay :: forall m a. (MonadIO m, Unbox a) =>
1157+ MutArray Word8 -> a -> m (Maybe (MutArray Word8))
1158+pokeAppendMay arr@MutArray{..} x = liftIO $ do
1159+ let newEnd = arrEnd + SIZE_OF(a)
1160+ if newEnd <= arrBound
1161+ then Just <$> pokeNewEnd newEnd arr x
1162+ else return Nothing
1164+{-# NOINLINE pokeWithRealloc #-}
1165+pokeWithRealloc :: forall m a. (MonadIO m, Unbox a) =>
1169+ -> m (MutArray Word8)
1170+pokeWithRealloc sizer arr x = do
1171+ arr1 <- liftIO $ reallocWith "pokeWithRealloc" sizer (SIZE_OF(a)) arr
1172+ pokeAppendUnsafe arr1 x
1174+{-# INLINE pokeAppendWith #-}
1175+pokeAppendWith :: forall m a. (MonadIO m, Unbox a) =>
1179+ -> m (MutArray Word8)
1180+pokeAppendWith allocSize arr x = liftIO $ do
1181+ let newEnd = arrEnd arr + SIZE_OF(a)
1182+ if newEnd <= arrBound arr
1183+ then pokeNewEnd newEnd arr x
1184+ else pokeWithRealloc allocSize arr x
1186+-- | Unbox a Haskell type and append the resulting bytes to a mutable byte
1187+-- array. The array is grown exponentially when more space is needed.
1191+-- >>> pokeAppend arr x = MutArray.castUnsafe <$> MutArray.snoc (MutArray.castUnsafe arr) x
1193+{-# INLINE pokeAppend #-}
1194+pokeAppend :: forall m a. (MonadIO m, Unbox a) =>
1195+ MutArray Word8 -> a -> m (MutArray Word8)
1196+pokeAppend = pokeAppendWith f
1201+ if isPower2 oldSize
1203+ else roundUpToPower2 oldSize * 2
1205+-- | Really really unsafe, create a Haskell value from an unboxed byte array,
1206+-- does not check if the array is big enough, may return garbage or if you are
1207+-- lucky may cause a segfault.
1210+{-# INLINE peekUnconsUnsafe #-}
1211+peekUnconsUnsafe :: forall m a. (MonadIO m, Unbox a) =>
1212+ MutArray Word8 -> m (a, MutArray Word8)
1213+peekUnconsUnsafe MutArray{..} = do
1214+ let start1 = arrStart + SIZE_OF(a)
1215+ assert (start1 <= arrEnd) (return ())
1217+ r <- peekAt arrStart arrContents
1218+ return (r, MutArray arrContents start1 arrEnd arrBound)
1220+-- | Discard the specified number of bytes in the array.
1221+{-# INLINE peekSkipUnsafe #-}
1222+peekSkipUnsafe :: Int -> MutArray Word8 -> MutArray Word8
1223+peekSkipUnsafe n MutArray{..} =
1224+ let start1 = arrStart + n
1225+ in assert (start1 <= arrEnd) (MutArray arrContents start1 arrEnd arrBound)
1227+-- | Create a Haskell value from its unboxed representation from the head of a
1228+-- byte array, return the value and the remaining array.
1229+{-# INLINE peekUncons #-}
1230+peekUncons :: forall m a. (MonadIO m, Unbox a) =>
1231+ MutArray Word8 -> m (Maybe a, MutArray Word8)
1232+peekUncons arr@MutArray{..} = do
1233+ let start1 = arrStart + SIZE_OF(a)
1235+ then return (Nothing, arr)
1237+ r <- peekAt arrStart arrContents
1238+ return (Just r, MutArray arrContents start1 arrEnd arrBound)
1025-------------------------------------------------------------------------------
1240-------------------------------------------------------------------------------
1026-- Random reads
1241-- Random reads
1027-------------------------------------------------------------------------------
1242-------------------------------------------------------------------------------
@@ -1064,10 +1279,10 @@ getIndexRev i MutArray{..} = do
1064data GetIndicesState contents start end st =
1279data GetIndicesState contents start end st =
1065 GetIndicesState contents start end st
1280 GetIndicesState contents start end st
1067−{-# INLINE getIndicesWith #-}
1282+{-# INLINE indexReaderWith #-}
1068−getIndicesWith :: (Monad m, Unbox a) =>
1283+indexReaderWith :: (Monad m, Unbox a) =>
1069 (forall b. IO b -> m b) -> D.Stream m Int -> Unfold m (MutArray a) a
1284 (forall b. IO b -> m b) -> D.Stream m Int -> Unfold m (MutArray a) a
1070−getIndicesWith liftio (D.Stream stepi sti) = Unfold step inject
1285+indexReaderWith liftio (D.Stream stepi sti) = Unfold step inject
@@ -1086,14 +1301,26 @@ getIndicesWith liftio (D.Stream stepi sti) = Unfold step inject
1086 D.Skip s -> return $ D.Skip (GetIndicesState contents start end s)
1301 D.Skip s -> return $ D.Skip (GetIndicesState contents start end s)
1087 D.Stop -> return D.Stop
1302 D.Stop -> return D.Stop
1304+{-# DEPRECATED getIndicesWith "Please use indexReaderWith instead." #-}
1305+{-# INLINE getIndicesWith #-}
1306+getIndicesWith :: (Monad m, Unbox a) =>
1307+ (forall b. IO b -> m b) -> D.Stream m Int -> Unfold m (MutArray a) a
1308+getIndicesWith = indexReaderWith
1089-- | Given an unfold that generates array indices, read the elements on those
1310-- | Given an unfold that generates array indices, read the elements on those
1090-- indices from the supplied MutArray. An error is thrown if an index is out of
1311-- indices from the supplied MutArray. An error is thrown if an index is out of
1091-- bounds.
1312-- bounds.
1093-- /Pre-release/
1314-- /Pre-release/
1315+{-# INLINE indexReader #-}
1316+indexReader :: (MonadIO m, Unbox a) => Stream m Int -> Unfold m (MutArray a) a
1317+indexReader = indexReaderWith liftIO
1319+-- XXX DO NOT REMOVE, change the signature to use Stream instead of unfold
1320+{-# DEPRECATED getIndices "Please use indexReader instead." #-}
1094{-# INLINE getIndices #-}
1321{-# INLINE getIndices #-}
1095getIndices :: (MonadIO m, Unbox a) => Stream m Int -> Unfold m (MutArray a) a
1322getIndices :: (MonadIO m, Unbox a) => Stream m Int -> Unfold m (MutArray a) a
1096−getIndices = getIndicesWith liftIO
1323+getIndices = indexReader
1098-------------------------------------------------------------------------------
1325-------------------------------------------------------------------------------
1099-- Subarrays
1326-- Subarrays
@@ -1388,7 +1615,7 @@ chunksOfAs ps n (D.Stream step state) =
1389-- Same as the following but may be more efficient:
1616-- Same as the following but may be more efficient:
1391−-- >>> chunksOf n = Stream.foldMany (MutArray.writeN n)
1618+-- >>> chunksOf n = Stream.foldMany (MutArray.createOf n)
1393-- /Pre-release/
1620-- /Pre-release/
1394{-# INLINE_NORMAL chunksOf #-}
1621{-# INLINE_NORMAL chunksOf #-}
@@ -1397,14 +1624,14 @@ chunksOf :: forall m a. (MonadIO m, Unbox a)
1397-- XXX the idiomatic implementation leads to large regression in the D.reverse'
1624-- XXX the idiomatic implementation leads to large regression in the D.reverse'
1398-- benchmark. It seems it has difficulty producing optimized code when
1625-- benchmark. It seems it has difficulty producing optimized code when
1399-- converting to StreamK. Investigate GHC optimizations.
1626-- converting to StreamK. Investigate GHC optimizations.
1400−-- chunksOf n = D.foldMany (writeN n)
1627+-- chunksOf n = D.foldMany (createOf n)
1401chunksOf = chunksOfAs Unpinned
1628chunksOf = chunksOfAs Unpinned
1403-- | Like 'chunksOf' but creates pinned arrays.
1630-- | Like 'chunksOf' but creates pinned arrays.
1404{-# INLINE_NORMAL pinnedChunksOf #-}
1631{-# INLINE_NORMAL pinnedChunksOf #-}
1405pinnedChunksOf :: forall m a. (MonadIO m, Unbox a)
1632pinnedChunksOf :: forall m a. (MonadIO m, Unbox a)
1406 => Int -> D.Stream m a -> D.Stream m (MutArray a)
1633 => Int -> D.Stream m a -> D.Stream m (MutArray a)
1407−-- pinnedChunksOf n = D.foldMany (pinnedWriteN n)
1634+-- pinnedChunksOf n = D.foldMany (pinnedCreateOf n)
1408pinnedChunksOf = chunksOfAs Pinned
1635pinnedChunksOf = chunksOfAs Pinned
1410-- | When we are buffering a stream of unknown size into an array we do not
1637-- | When we are buffering a stream of unknown size into an array we do not
@@ -1437,16 +1664,10 @@ data FlattenState s contents a =
1437 OuterLoop s
1664 OuterLoop s
1438 | InnerLoop s contents !Int !Int
1665 | InnerLoop s contents !Int !Int
1440−-- | Use the "reader" unfold instead.
1442−-- @concatChunks = unfoldMany reader@
1444−-- We can try this if there are any fusion issues in the unfold.
1446−{-# INLINE_NORMAL concatChunks #-}
1667+{-# INLINE_NORMAL concatWith #-}
1447−concatChunks :: forall m a. (MonadIO m, Unbox a)
1668+concatWith :: forall m a. (Monad m, Unbox a)
1448− => D.Stream m (MutArray a) -> D.Stream m a
1669+ => (forall b. IO b -> m b) -> D.Stream m (MutArray a) -> D.Stream m a
1449−concatChunks (D.Stream step state) = D.Stream step' (OuterLoop state)
1670+concatWith liftio (D.Stream step state) = D.Stream step' (OuterLoop state)
@@ -1463,24 +1684,30 @@ concatChunks (D.Stream step state) = D.Stream step' (OuterLoop state)
1463 return $ D.Skip $ OuterLoop st
1684 return $ D.Skip $ OuterLoop st
1465 step' _ (InnerLoop st contents p end) = do
1686 step' _ (InnerLoop st contents p end) = do
1466− x <- liftIO $ peekAt p contents
1687+ x <- liftio $ peekAt p contents
1467 return $ D.Yield x (InnerLoop st contents (INDEX_NEXT(p,a)) end)
1688 return $ D.Yield x (InnerLoop st contents (INDEX_NEXT(p,a)) end)
1469−{-# DEPRECATED flattenArrays "Please use \"unfoldMany reader\" instead." #-}
1470−flattenArrays :: forall m a. (MonadIO m, Unbox a)
1471− => D.Stream m (MutArray a) -> D.Stream m a
1472−flattenArrays = concatChunks
1474−-- | Use the "readerRev" unfold instead.
1690+-- | Use the "reader" unfold instead.
1476−-- @concatChunks = unfoldMany readerRev@
1692+-- @concat = unfoldMany reader@
1478-- We can try this if there are any fusion issues in the unfold.
1694-- We can try this if there are any fusion issues in the unfold.
1480−{-# INLINE_NORMAL concatChunksRev #-}
1696+{-# INLINE_NORMAL concat #-}
1481−concatChunksRev :: forall m a. (MonadIO m, Unbox a)
1697+concat :: forall m a. (MonadIO m, Unbox a)
1482 => D.Stream m (MutArray a) -> D.Stream m a
1698 => D.Stream m (MutArray a) -> D.Stream m a
1699+concat = concatWith liftIO
1701+{-# DEPRECATED flattenArrays "Please use \"unfoldMany reader\" instead." #-}
1702+{-# INLINE flattenArrays #-}
1703+flattenArrays :: forall m a. (MonadIO m, Unbox a)
1704+ => D.Stream m (MutArray a) -> D.Stream m a
1705+flattenArrays = concat
1707+{-# INLINE_NORMAL concatRevWith #-}
1708+concatRevWith :: forall m a. (Monad m, Unbox a)
1709+ => (forall b. IO b -> m b) -> D.Stream m (MutArray a) -> D.Stream m a
1483−concatChunksRev (D.Stream step state) = D.Stream step' (OuterLoop state)
1710+concatRevWith liftio (D.Stream step state) = D.Stream step' (OuterLoop state)
@@ -1498,14 +1725,26 @@ concatChunksRev (D.Stream step state) = D.Stream step' (OuterLoop state)
1498 return $ D.Skip $ OuterLoop st
1725 return $ D.Skip $ OuterLoop st
1500 step' _ (InnerLoop st contents p start) = do
1727 step' _ (InnerLoop st contents p start) = do
1501− x <- liftIO $ peekAt p contents
1728+ x <- liftio $ peekAt p contents
1502 let cur = INDEX_PREV(p,a)
1729 let cur = INDEX_PREV(p,a)
1503 return $ D.Yield x (InnerLoop st contents cur start)
1730 return $ D.Yield x (InnerLoop st contents cur start)
1732+-- | Use the "readerRev" unfold instead.
1734+-- @concat = unfoldMany readerRev@
1736+-- We can try this if there are any fusion issues in the unfold.
1738+{-# INLINE_NORMAL concatRev #-}
1739+concatRev :: forall m a. (MonadIO m, Unbox a)
1740+ => D.Stream m (MutArray a) -> D.Stream m a
1741+concatRev = concatRevWith liftIO
1505{-# DEPRECATED flattenArraysRev "Please use \"unfoldMany readerRev\" instead." #-}
1743{-# DEPRECATED flattenArraysRev "Please use \"unfoldMany readerRev\" instead." #-}
1744+{-# INLINE flattenArraysRev #-}
1506flattenArraysRev :: forall m a. (MonadIO m, Unbox a)
1745flattenArraysRev :: forall m a. (MonadIO m, Unbox a)
1507 => D.Stream m (MutArray a) -> D.Stream m a
1746 => D.Stream m (MutArray a) -> D.Stream m a
1508−flattenArraysRev = concatChunksRev
1747+flattenArraysRev = concatRev
1510-------------------------------------------------------------------------------
1749-------------------------------------------------------------------------------
1511-- Unfolds
1750-- Unfolds
@@ -1734,7 +1973,7 @@ foldr f z arr = D.foldr f z $ read arr
1735-- XXX Keep the bound intact to not lose any free space? Perf impact?
1974-- XXX Keep the bound intact to not lose any free space? Perf impact?
1737−-- | @writeAppendNUnsafe n arr@ appends up to @n@ input items to the supplied
1976+-- | @unsafeAppendN n arr@ appends up to @n@ input items to the supplied
1738-- array.
1977-- array.
1740-- Unsafe: Do not drive the fold beyond @n@ elements, it will lead to memory
1979-- Unsafe: Do not drive the fold beyond @n@ elements, it will lead to memory
@@ -1743,13 +1982,12 @@ foldr f z arr = D.foldr f z $ read arr
1743-- Any free space left in the array after appending @n@ elements is lost.
1982-- Any free space left in the array after appending @n@ elements is lost.
1745-- /Internal/
1984-- /Internal/
1746−{-# INLINE_NORMAL writeAppendNUnsafe #-}
1985+{-# INLINE_NORMAL unsafeAppendN #-}
1747−writeAppendNUnsafe :: forall m a. (MonadIO m, Unbox a) =>
1986+unsafeAppendN :: forall m a. (MonadIO m, Unbox a) =>
1749 -> m (MutArray a)
1988 -> m (MutArray a)
1750 -> Fold m a (MutArray a)
1989 -> Fold m a (MutArray a)
1751−writeAppendNUnsafe n action =
1752− fmap fromArrayUnsafe $ FL.foldlM' step initial
1990+unsafeAppendN n action = fmap fromArrayUnsafe $ FL.foldlM' step initial
@@ -1762,7 +2000,7 @@ writeAppendNUnsafe n action =
1762 -- otherwise we lose that space.
2000 -- otherwise we lose that space.
1764 if free < needed
2002 if free < needed
1765− then noinline reallocWith "writeAppendNUnsafeWith" (+ needed) needed arr
2003+ then noinline reallocWith "unsafeAppendN" (+ needed) needed arr
1766 else return arr
2004 else return arr
1767 return $ toArrayUnsafe arr1
2005 return $ toArrayUnsafe arr1
@@ -1770,30 +2008,51 @@ writeAppendNUnsafe n action =
1770 liftIO $ pokeAt end contents x
2008 liftIO $ pokeAt end contents x
1771 return $ ArrayUnsafe contents start (INDEX_NEXT(end,a))
2009 return $ ArrayUnsafe contents start (INDEX_NEXT(end,a))
2011+{-# DEPRECATED writeAppendNUnsafe "Please use unsafeAppendN instead." #-}
2012+{-# INLINE writeAppendNUnsafe #-}
2013+writeAppendNUnsafe :: forall m a. (MonadIO m, Unbox a) =>
2016+ -> Fold m a (MutArray a)
2017+writeAppendNUnsafe = unsafeAppendN
1773-- | Append @n@ elements to an existing array. Any free space left in the array
2019-- | Append @n@ elements to an existing array. Any free space left in the array
1774-- after appending @n@ elements is lost.
2020-- after appending @n@ elements is lost.
1776−-- >>> writeAppendN n initial = Fold.take n (MutArray.writeAppendNUnsafe n initial)
2022+-- >>> appendN n initial = Fold.take n (MutArray.unsafeAppendN n initial)
1778−{-# INLINE_NORMAL writeAppendN #-}
2024+{-# INLINE_NORMAL appendN #-}
2025+appendN :: forall m a. (MonadIO m, Unbox a) =>
2026+ Int -> m (MutArray a) -> Fold m a (MutArray a)
2027+appendN n initial = FL.take n (unsafeAppendN n initial)
2029+-- XXX Deprecate in major
2030+-- {-# DEPRECATED writeAppendN "Please use appendN instead." #-}
2031+{-# INLINE writeAppendN #-}
1779writeAppendN :: forall m a. (MonadIO m, Unbox a) =>
2032writeAppendN :: forall m a. (MonadIO m, Unbox a) =>
1780 Int -> m (MutArray a) -> Fold m a (MutArray a)
2033 Int -> m (MutArray a) -> Fold m a (MutArray a)
1781−writeAppendN n initial = FL.take n (writeAppendNUnsafe n initial)
2034+writeAppendN = appendN
1783−-- | @writeAppendWith realloc action@ mutates the array generated by @action@ to
2036+-- | @appendWith realloc action@ mutates the array generated by @action@ to
1784-- append the input stream. If there is no reserved space available in the
2037-- append the input stream. If there is no reserved space available in the
1785-- array it is reallocated to a size in bytes determined by @realloc oldSize@,
2038-- array it is reallocated to a size in bytes determined by @realloc oldSize@,
1786-- where @oldSize@ is the current size of the array in bytes.
2039-- where @oldSize@ is the current size of the array in bytes.
1788-- Note that the returned array may be a mutated version of original array.
2041-- Note that the returned array may be a mutated version of original array.
1790−-- >>> writeAppendWith sizer = Fold.foldlM' (MutArray.snocWith sizer)
2043+-- >>> appendWith sizer = Fold.foldlM' (MutArray.snocWith sizer)
1792-- /Pre-release/
2045-- /Pre-release/
2046+{-# INLINE appendWith #-}
2047+appendWith :: forall m a. (MonadIO m, Unbox a) =>
2048+ (Int -> Int) -> m (MutArray a) -> Fold m a (MutArray a)
2049+appendWith sizer = FL.foldlM' (snocWith sizer)
2051+{-# DEPRECATED writeAppendWith "Please use appendWith instead." #-}
1793{-# INLINE writeAppendWith #-}
2052{-# INLINE writeAppendWith #-}
1794writeAppendWith :: forall m a. (MonadIO m, Unbox a) =>
2053writeAppendWith :: forall m a. (MonadIO m, Unbox a) =>
1795 (Int -> Int) -> m (MutArray a) -> Fold m a (MutArray a)
2054 (Int -> Int) -> m (MutArray a) -> Fold m a (MutArray a)
1796−writeAppendWith sizer = FL.foldlM' (snocWith sizer)
2055+writeAppendWith = appendWith
1798-- | @append action@ mutates the array generated by @action@ to append the
2057-- | @append action@ mutates the array generated by @action@ to append the
1799-- input stream. If there is no reserved space available in the array it is
2058-- input stream. If there is no reserved space available in the array it is
@@ -1801,26 +2060,33 @@ writeAppendWith sizer = FL.foldlM' (snocWith sizer)
1802-- Note that the returned array may be a mutated version of original array.
2061-- Note that the returned array may be a mutated version of original array.
1804−-- >>> writeAppend = MutArray.writeAppendWith (* 2)
2063+-- >>> append = MutArray.appendWith (* 2)
2065+{-# INLINE append #-}
2066+append :: forall m a. (MonadIO m, Unbox a) =>
2067+ m (MutArray a) -> Fold m a (MutArray a)
2068+append = appendWith (* 2)
2070+-- XXX Deprecate in major
2071+-- {-# DEPRECATED writeAppend "Please use append instead." #-}
1806{-# INLINE writeAppend #-}
2072{-# INLINE writeAppend #-}
1807writeAppend :: forall m a. (MonadIO m, Unbox a) =>
2073writeAppend :: forall m a. (MonadIO m, Unbox a) =>
1808 m (MutArray a) -> Fold m a (MutArray a)
2074 m (MutArray a) -> Fold m a (MutArray a)
1809−writeAppend = writeAppendWith (* 2)
2075+writeAppend = append
1811-- XXX We can carry bound as well in the state to make sure we do not lose the
2077-- XXX We can carry bound as well in the state to make sure we do not lose the
1812-- remaining capacity. Need to check perf impact.
2078-- remaining capacity. Need to check perf impact.
1814−-- | Like 'writeNUnsafe' but takes a new array allocator @alloc size@ function
2080+-- | Like 'unsafeCreateOf' but takes a new array allocator @alloc size@
1815−-- as argument.
2081+-- function as argument.
1817−-- >>> writeNWithUnsafe alloc n = MutArray.writeAppendNUnsafe (alloc n) n
2083+-- >>> unsafeCreateOfWith alloc n = MutArray.unsafeAppendN (alloc n) n
1819-- /Pre-release/
2085-- /Pre-release/
1820−{-# INLINE_NORMAL writeNWithUnsafe #-}
2086+{-# INLINE_NORMAL unsafeCreateOfWith #-}
1821−writeNWithUnsafe :: forall m a. (MonadIO m, Unbox a)
2087+unsafeCreateOfWith :: forall m a. (MonadIO m, Unbox a)
1822 => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
2088 => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
1823−writeNWithUnsafe alloc n = fromArrayUnsafe <$> FL.foldlM' step initial
2089+unsafeCreateOfWith alloc n = fromArrayUnsafe <$> FL.foldlM' step initial
@@ -1831,40 +2097,64 @@ writeNWithUnsafe alloc n = fromArrayUnsafe <$> FL.foldlM' step initial
1832 $ ArrayUnsafe contents start (INDEX_NEXT(end,a))
2098 $ ArrayUnsafe contents start (INDEX_NEXT(end,a))
2100+{-# DEPRECATED writeNWithUnsafe "Please use unsafeCreateOfWith instead." #-}
2101+{-# INLINE writeNWithUnsafe #-}
2102+writeNWithUnsafe :: forall m a. (MonadIO m, Unbox a)
2103+ => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
2104+writeNWithUnsafe = unsafeCreateOfWith
1834{-# INLINE_NORMAL writeNUnsafeAs #-}
2106{-# INLINE_NORMAL writeNUnsafeAs #-}
1835writeNUnsafeAs :: forall m a. (MonadIO m, Unbox a)
2107writeNUnsafeAs :: forall m a. (MonadIO m, Unbox a)
1836 => PinnedState -> Int -> Fold m a (MutArray a)
2108 => PinnedState -> Int -> Fold m a (MutArray a)
1837−writeNUnsafeAs ps = writeNWithUnsafe (newAs ps)
2109+writeNUnsafeAs ps = unsafeCreateOfWith (newAs ps)
1839−-- | Like 'writeN' but does not check the array bounds when writing. The fold
2111+-- | Like 'createOf' but does not check the array bounds when writing. The fold
1840-- driver must not call the step function more than 'n' times otherwise it will
2112-- driver must not call the step function more than 'n' times otherwise it will
1841-- corrupt the memory and crash. This function exists mainly because any
2113-- corrupt the memory and crash. This function exists mainly because any
1842-- conditional in the step function blocks fusion causing 10x performance
2114-- conditional in the step function blocks fusion causing 10x performance
1843-- slowdown.
2115-- slowdown.
1845−-- >>> writeNUnsafe = MutArray.writeNWithUnsafe MutArray.new
2117+-- >>> unsafeCreateOf = MutArray.unsafeCreateOfWith MutArray.emptyOf
2119+{-# INLINE_NORMAL unsafeCreateOf #-}
2120+unsafeCreateOf :: forall m a. (MonadIO m, Unbox a)
2121+ => Int -> Fold m a (MutArray a)
2122+unsafeCreateOf = writeNUnsafeAs Unpinned
2124+{-# DEPRECATED writeNUnsafe "Please use unsafeCreateOf instead." #-}
1847−{-# INLINE_NORMAL writeNUnsafe #-}
2125+{-# INLINE writeNUnsafe #-}
1848writeNUnsafe :: forall m a. (MonadIO m, Unbox a)
2126writeNUnsafe :: forall m a. (MonadIO m, Unbox a)
1849 => Int -> Fold m a (MutArray a)
2127 => Int -> Fold m a (MutArray a)
1850−writeNUnsafe = writeNUnsafeAs Unpinned
2128+writeNUnsafe = unsafeCreateOf
1852−-- | Like 'writeNUnsafe' but creates a pinned array.
2130+-- | Like 'unsafeCreateOf' but creates a pinned array.
2131+{-# INLINE_NORMAL unsafePinnedCreateOf #-}
2132+unsafePinnedCreateOf :: forall m a. (MonadIO m, Unbox a)
2133+ => Int -> Fold m a (MutArray a)
2134+unsafePinnedCreateOf = writeNUnsafeAs Pinned
2136+{-# DEPRECATED pinnedWriteNUnsafe "Please use unsafePinnedCreateOf instead." #-}
1853−{-# INLINE_NORMAL pinnedWriteNUnsafe #-}
2137+{-# INLINE pinnedWriteNUnsafe #-}
1854pinnedWriteNUnsafe :: forall m a. (MonadIO m, Unbox a)
2138pinnedWriteNUnsafe :: forall m a. (MonadIO m, Unbox a)
1855 => Int -> Fold m a (MutArray a)
2139 => Int -> Fold m a (MutArray a)
1856−pinnedWriteNUnsafe = writeNUnsafeAs Pinned
2140+pinnedWriteNUnsafe = unsafePinnedCreateOf
1858−-- | @writeNWith alloc n@ folds a maximum of @n@ elements into an array
2142+-- | @createOfWith alloc n@ folds a maximum of @n@ elements into an array
1859-- allocated using the @alloc@ function.
2143-- allocated using the @alloc@ function.
1861−-- >>> writeNWith alloc n = Fold.take n (MutArray.writeNWithUnsafe alloc n)
2145+-- >>> createOfWith alloc n = Fold.take n (MutArray.unsafeCreateOfWith alloc n)
1862−-- >>> writeNWith alloc n = MutArray.writeAppendN (alloc n) n
2146+-- >>> createOfWith alloc n = MutArray.appendN (alloc n) n
1864−{-# INLINE_NORMAL writeNWith #-}
2148+{-# INLINE_NORMAL createOfWith #-}
2149+createOfWith :: forall m a. (MonadIO m, Unbox a)
2150+ => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
2151+createOfWith alloc n = FL.take n (unsafeCreateOfWith alloc n)
2153+-- {-# DEPRECATED writeNWith "Please use createOfWith instead." #-}
2154+{-# INLINE writeNWith #-}
1865writeNWith :: forall m a. (MonadIO m, Unbox a)
2155writeNWith :: forall m a. (MonadIO m, Unbox a)
1866 => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
2156 => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
1867−writeNWith alloc n = FL.take n (writeNWithUnsafe alloc n)
2157+writeNWith = createOfWith
1869{-# INLINE_NORMAL writeNAs #-}
2159{-# INLINE_NORMAL writeNAs #-}
1870writeNAs ::
2160writeNAs ::
@@ -1872,28 +2162,42 @@ writeNAs ::
1872 => PinnedState
2162 => PinnedState
1874 -> Fold m a (MutArray a)
2164 -> Fold m a (MutArray a)
1875−writeNAs ps = writeNWith (newAs ps)
2165+writeNAs ps = createOfWith (newAs ps)
1877−-- | @writeN n@ folds a maximum of @n@ elements from the input stream to an
2167+-- | @createOf n@ folds a maximum of @n@ elements from the input stream to an
1878-- 'MutArray'.
2168-- 'MutArray'.
1880−-- >>> writeN = MutArray.writeNWith MutArray.new
2170+-- >>> createOf = MutArray.createOfWith MutArray.new
1881−-- >>> writeN n = Fold.take n (MutArray.writeNUnsafe n)
2171+-- >>> createOf n = Fold.take n (MutArray.unsafeCreateOf n)
1882−-- >>> writeN n = MutArray.writeAppendN n (MutArray.new n)
2172+-- >>> createOf n = MutArray.appendN n (MutArray.emptyOf n)
1884−{-# INLINE_NORMAL writeN #-}
2174+{-# INLINE_NORMAL createOf #-}
2175+createOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
2176+createOf = writeNAs Unpinned
2178+-- XXX Deprecate in major
2179+-- {-# DEPRECATED writeN "Please use createOf instead." #-}
2180+{-# INLINE writeN #-}
1885writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
2181writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
1886−writeN = writeNAs Unpinned
2182+writeN = createOf
1888−-- | Like 'writeN' but creates a pinned array.
2184+-- | Like 'createOf' but creates a pinned array.
2185+{-# INLINE_NORMAL pinnedCreateOf #-}
2187+ forall m a. (MonadIO m, Unbox a)
2189+ -> Fold m a (MutArray a)
2190+pinnedCreateOf = writeNAs Pinned
2192+{-# DEPRECATED pinnedWriteN "Please use pinnedCreateOf instead." #-}
1889−{-# INLINE_NORMAL pinnedWriteN #-}
2193+{-# INLINE pinnedWriteN #-}
1890pinnedWriteN ::
2194pinnedWriteN ::
1891 forall m a. (MonadIO m, Unbox a)
2195 forall m a. (MonadIO m, Unbox a)
1893 -> Fold m a (MutArray a)
2197 -> Fold m a (MutArray a)
1894−pinnedWriteN = writeNAs Pinned
2198+pinnedWriteN = pinnedCreateOf
1896−-- | Like writeNWithUnsafe but writes the array in reverse order.
2200+-- | Like unsafeCreateOfWith but writes the array in reverse order.
1898-- /Internal/
2202-- /Internal/
1899{-# INLINE_NORMAL writeRevNWithUnsafe #-}
2203{-# INLINE_NORMAL writeRevNWithUnsafe #-}
@@ -1914,7 +2218,7 @@ writeRevNWithUnsafe alloc n = fromArrayUnsafe <$> FL.foldlM' step initial
1915 $ ArrayUnsafe contents ptr end
2219 $ ArrayUnsafe contents ptr end
1917−-- | Like writeNWith but writes the array in reverse order.
2221+-- | Like createOfWith but writes the array in reverse order.
1919-- /Internal/
2223-- /Internal/
1920{-# INLINE_NORMAL writeRevNWith #-}
2224{-# INLINE_NORMAL writeRevNWith #-}
@@ -1922,31 +2226,36 @@ writeRevNWith :: forall m a. (MonadIO m, Unbox a)
1922 => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
2226 => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
1923writeRevNWith alloc n = FL.take n (writeRevNWithUnsafe alloc n)
2227writeRevNWith alloc n = FL.take n (writeRevNWithUnsafe alloc n)
1925−-- | Like writeN but writes the array in reverse order.
2229+-- | Like 'createOf' but writes the array in reverse order.
1927-- /Pre-release/
2231-- /Pre-release/
1928−{-# INLINE_NORMAL writeRevN #-}
2232+{-# INLINE_NORMAL revCreateOf #-}
2233+revCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
2234+revCreateOf = writeRevNWith new
2236+{-# DEPRECATED writeRevN "Please use revCreateOf instead." #-}
2237+{-# INLINE writeRevN #-}
1929writeRevN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
2238writeRevN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
1930−writeRevN = writeRevNWith new
2239+writeRevN = revCreateOf
1932-- | @pinnedWriteNAligned align n@ folds a maximum of @n@ elements from the
2241-- | @pinnedWriteNAligned align n@ folds a maximum of @n@ elements from the
1933-- input stream to a 'MutArray' aligned to the given size.
2242-- input stream to a 'MutArray' aligned to the given size.
1935−-- >>> pinnedWriteNAligned align = MutArray.writeNWith (MutArray.pinnedNewAligned align)
2244+-- >>> pinnedWriteNAligned align = MutArray.createOfWith (MutArray.pinnedNewAligned align)
1936−-- >>> pinnedWriteNAligned align n = MutArray.writeAppendN n (MutArray.pinnedNewAligned align n)
2245+-- >>> pinnedWriteNAligned align n = MutArray.appendN n (MutArray.pinnedNewAligned align n)
1938-- /Pre-release/
2247-- /Pre-release/
1940{-# INLINE_NORMAL pinnedWriteNAligned #-}
2249{-# INLINE_NORMAL pinnedWriteNAligned #-}
1941pinnedWriteNAligned :: forall m a. (MonadIO m, Unbox a)
2250pinnedWriteNAligned :: forall m a. (MonadIO m, Unbox a)
1942 => Int -> Int -> Fold m a (MutArray a)
2251 => Int -> Int -> Fold m a (MutArray a)
1943−pinnedWriteNAligned align = writeNWith (pinnedNewAligned align)
2252+pinnedWriteNAligned align = createOfWith (pinnedNewAligned align)
1945-- XXX Buffer to a list instead?
2254-- XXX Buffer to a list instead?
1947-- | Buffer a stream into a stream of arrays.
2256-- | Buffer a stream into a stream of arrays.
1949−-- >>> buildChunks n = Fold.many (MutArray.writeN n) Fold.toStreamK
2258+-- >>> buildChunks n = Fold.many (MutArray.createOf n) Fold.toStreamK
1951-- Breaking an array into an array stream can be useful to consume a large
2260-- Breaking an array into an array stream can be useful to consume a large
1952-- array sequentially such that memory of the array is released incrementatlly.
2261-- array sequentially such that memory of the array is released incrementatlly.
@@ -1958,9 +2267,10 @@ pinnedWriteNAligned align = writeNWith (pinnedNewAligned align)
1958{-# INLINE_NORMAL buildChunks #-}
2267{-# INLINE_NORMAL buildChunks #-}
1959buildChunks :: (MonadIO m, Unbox a) =>
2268buildChunks :: (MonadIO m, Unbox a) =>
1960 Int -> Fold m a (StreamK n (MutArray a))
2269 Int -> Fold m a (StreamK n (MutArray a))
1961−buildChunks n = FL.many (writeN n) FL.toStreamK
2270+buildChunks n = FL.many (createOf n) FL.toStreamK
1963{-# DEPRECATED writeChunks "Please use buildChunks instead." #-}
2272{-# DEPRECATED writeChunks "Please use buildChunks instead." #-}
2273+{-# INLINE writeChunks #-}
1964writeChunks :: (MonadIO m, Unbox a) =>
2274writeChunks :: (MonadIO m, Unbox a) =>
1965 Int -> Fold m a (StreamK n (MutArray a))
2275 Int -> Fold m a (StreamK n (MutArray a))
1966writeChunks = buildChunks
2276writeChunks = buildChunks
@@ -1968,29 +2278,29 @@ writeChunks = buildChunks
1968{-# INLINE_NORMAL writeWithAs #-}
2278{-# INLINE_NORMAL writeWithAs #-}
1969writeWithAs :: forall m a. (MonadIO m, Unbox a)
2279writeWithAs :: forall m a. (MonadIO m, Unbox a)
1970 => PinnedState -> Int -> Fold m a (MutArray a)
2280 => PinnedState -> Int -> Fold m a (MutArray a)
1971−-- writeWithAs ps n = FL.rmapM rightSize $ writeAppendWith (* 2) (newAs ps n)
2281+-- writeWithAs ps n = FL.rmapM rightSize $ appendWith (* 2) (newAs ps n)
1972writeWithAs ps elemCount =
2282writeWithAs ps elemCount =
1973 FL.rmapM extract $ FL.foldlM' step initial
2283 FL.rmapM extract $ FL.foldlM' step initial
1977 initial = do
2287 initial = do
1978− when (elemCount < 0) $ error "writeWith: elemCount is negative"
2288+ when (elemCount < 0) $ error "createWith: elemCount is negative"
1979− liftIO $ newAs ps elemCount
2289+ newAs ps elemCount
1981 step arr@(MutArray _ start end bound) x
2291 step arr@(MutArray _ start end bound) x
1982 | INDEX_NEXT(end,a) > bound = do
2292 | INDEX_NEXT(end,a) > bound = do
1983 let oldSize = end - start
2293 let oldSize = end - start
1984 newSize = max (oldSize * 2) 1
2294 newSize = max (oldSize * 2) 1
1985− arr1 <- liftIO $ reallocExplicit (SIZE_OF(a)) newSize arr
2295+ arr1 <- liftIO $ reallocExplicitAs ps (SIZE_OF(a)) newSize arr
1986 snocUnsafe arr1 x
2296 snocUnsafe arr1 x
1987 step arr x = snocUnsafe arr x
2297 step arr x = snocUnsafe arr x
1989 extract = liftIO . rightSize
2299 extract = liftIO . rightSize
1991−-- XXX Compare writeWith with fromStreamD which uses an array of streams
2301+-- XXX Compare createWith with fromStreamD which uses an array of streams
1992-- implementation. We can write this using buildChunks above if that is faster.
2302-- implementation. We can write this using buildChunks above if that is faster.
1993−-- If writeWith is faster then we should use that to implement
2303+-- If createWith is faster then we should use that to implement
1994-- fromStreamD.
2304-- fromStreamD.
1996-- XXX The realloc based implementation needs to make one extra copy if we use
2306-- XXX The realloc based implementation needs to make one extra copy if we use
@@ -2005,39 +2315,56 @@ writeWithAs ps elemCount =
2005-- XXX check if GHC's memory allocator is efficient enough. We can try the C
2315-- XXX check if GHC's memory allocator is efficient enough. We can try the C
2006-- malloc to compare against.
2316-- malloc to compare against.
2008−-- | @writeWith minCount@ folds the whole input to a single array. The array
2318+-- | @createWith minCount@ folds the whole input to a single array. The array
2009-- starts at a size big enough to hold minCount elements, the size is doubled
2319-- starts at a size big enough to hold minCount elements, the size is doubled
2010-- every time the array needs to be grown.
2320-- every time the array needs to be grown.
2012-- /Caution! Do not use this on infinite streams./
2322-- /Caution! Do not use this on infinite streams./
2014−-- >>> f n = MutArray.writeAppendWith (* 2) (MutArray.new n)
2324+-- >>> f n = MutArray.appendWith (* 2) (MutArray.emptyOf n)
2015−-- >>> writeWith n = Fold.rmapM MutArray.rightSize (f n)
2325+-- >>> createWith n = Fold.rmapM MutArray.rightSize (f n)
2016−-- >>> writeWith n = Fold.rmapM MutArray.fromChunksK (MutArray.buildChunks n)
2326+-- >>> createWith n = Fold.rmapM MutArray.fromChunksK (MutArray.buildChunks n)
2018-- /Pre-release/
2328-- /Pre-release/
2019−{-# INLINE_NORMAL writeWith #-}
2329+{-# INLINE_NORMAL createWith #-}
2330+createWith :: forall m a. (MonadIO m, Unbox a)
2331+ => Int -> Fold m a (MutArray a)
2332+-- createWith n = FL.rmapM rightSize $ appendWith (* 2) (emptyOf n)
2333+createWith = writeWithAs Unpinned
2335+{-# DEPRECATED writeWith "Please use createWith instead." #-}
2336+{-# INLINE writeWith #-}
2020writeWith :: forall m a. (MonadIO m, Unbox a)
2337writeWith :: forall m a. (MonadIO m, Unbox a)
2021 => Int -> Fold m a (MutArray a)
2338 => Int -> Fold m a (MutArray a)
2022−-- writeWith n = FL.rmapM rightSize $ writeAppendWith (* 2) (new n)
2339+writeWith = createWith
2023−writeWith = writeWithAs Unpinned
2025-- | Fold the whole input to a single array.
2341-- | Fold the whole input to a single array.
2027−-- Same as 'writeWith' using an initial array size of 'arrayChunkBytes' bytes
2343+-- Same as 'createWith' using an initial array size of 'arrayChunkBytes' bytes
2028-- rounded up to the element size.
2344-- rounded up to the element size.
2030-- /Caution! Do not use this on infinite streams./
2346-- /Caution! Do not use this on infinite streams./
2348+{-# INLINE create #-}
2349+create :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
2350+create = createWith (allocBytesToElemCount (undefined :: a) arrayChunkBytes)
2352+-- XXX Deprecate in major
2353+-- {-# DEPRECATED write "Please use create instead." #-}
2032{-# INLINE write #-}
2354{-# INLINE write #-}
2033write :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
2355write :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
2034−write = writeWith (allocBytesToElemCount (undefined :: a) arrayChunkBytes)
2356+write = create
2036−-- | Like 'write' but creates a pinned array.
2358+-- | Like 'create' but creates a pinned array.
2359+{-# INLINE pinnedCreate #-}
2360+pinnedCreate :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
2362+ writeWithAs Pinned (allocBytesToElemCount (undefined :: a) arrayChunkBytes)
2364+{-# DEPRECATED pinnedWrite "Please use pinnedCreate instead." #-}
2037{-# INLINE pinnedWrite #-}
2365{-# INLINE pinnedWrite #-}
2038pinnedWrite :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
2366pinnedWrite :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
2039−pinnedWrite =
2367+pinnedWrite = pinnedCreate
2040− writeWithAs Pinned (allocBytesToElemCount (undefined :: a) arrayChunkBytes)
2042-------------------------------------------------------------------------------
2369-------------------------------------------------------------------------------
2043-- construct from streams, known size
2370-- construct from streams, known size
@@ -2047,7 +2374,7 @@ pinnedWrite =
2047fromStreamDNAs :: forall m a. (MonadIO m, Unbox a)
2374fromStreamDNAs :: forall m a. (MonadIO m, Unbox a)
2048 => PinnedState -> Int -> D.Stream m a -> m (MutArray a)
2375 => PinnedState -> Int -> D.Stream m a -> m (MutArray a)
2049fromStreamDNAs ps limit str = do
2376fromStreamDNAs ps limit str = do
2050− (arr :: MutArray a) <- liftIO $ newAs ps limit
2377+ (arr :: MutArray a) <- newAs ps limit
2051 end <- D.foldlM' (fwrite (arrContents arr)) (return $ arrEnd arr) $ D.take limit str
2378 end <- D.foldlM' (fwrite (arrContents arr)) (return $ arrEnd arr) $ D.take limit str
2052 return $ arr {arrEnd = end}
2379 return $ arr {arrEnd = end}
@@ -2057,17 +2384,18 @@ fromStreamDNAs ps limit str = do
2057 liftIO $ pokeAt ptr arrContents x
2384 liftIO $ pokeAt ptr arrContents x
2058 return $ INDEX_NEXT(ptr,a)
2385 return $ INDEX_NEXT(ptr,a)
2060−-- | Use the 'writeN' fold instead.
2387+-- | Use the 'createOf' fold instead.
2062−-- >>> fromStreamN n = Stream.fold (MutArray.writeN n)
2389+-- >>> fromStreamN n = Stream.fold (MutArray.createOf n)
2064{-# INLINE_NORMAL fromStreamN #-}
2391{-# INLINE_NORMAL fromStreamN #-}
2065fromStreamN :: forall m a. (MonadIO m, Unbox a)
2392fromStreamN :: forall m a. (MonadIO m, Unbox a)
2066 => Int -> D.Stream m a -> m (MutArray a)
2393 => Int -> D.Stream m a -> m (MutArray a)
2067−-- fromStreamDN n = D.fold (writeN n)
2394+-- fromStreamDN n = D.fold (createOf n)
2068fromStreamN = fromStreamDNAs Unpinned
2395fromStreamN = fromStreamDNAs Unpinned
2070{-# DEPRECATED fromStreamDN "Please use fromStreamN instead." #-}
2397{-# DEPRECATED fromStreamDN "Please use fromStreamN instead." #-}
2398+{-# INLINE fromStreamDN #-}
2071fromStreamDN :: forall m a. (MonadIO m, Unbox a)
2399fromStreamDN :: forall m a. (MonadIO m, Unbox a)
2072 => Int -> D.Stream m a -> m (MutArray a)
2400 => Int -> D.Stream m a -> m (MutArray a)
2073fromStreamDN = fromStreamN
2401fromStreamDN = fromStreamN
@@ -2090,20 +2418,20 @@ pinnedFromListN n xs = fromStreamDNAs Pinned n $ D.fromList xs
2090-- /Pre-release/
2418-- /Pre-release/
2091{-# INLINE fromListRevN #-}
2419{-# INLINE fromListRevN #-}
2092fromListRevN :: (MonadIO m, Unbox a) => Int -> [a] -> m (MutArray a)
2420fromListRevN :: (MonadIO m, Unbox a) => Int -> [a] -> m (MutArray a)
2093−fromListRevN n xs = D.fold (writeRevN n) $ D.fromList xs
2421+fromListRevN n xs = D.fold (revCreateOf n) $ D.fromList xs
2095-- | Convert a pure stream in Identity monad to a mutable array.
2423-- | Convert a pure stream in Identity monad to a mutable array.
2096{-# INLINABLE fromPureStreamN #-}
2424{-# INLINABLE fromPureStreamN #-}
2097fromPureStreamN :: (MonadIO m, Unbox a) =>
2425fromPureStreamN :: (MonadIO m, Unbox a) =>
2098 Int -> Stream Identity a -> m (MutArray a)
2426 Int -> Stream Identity a -> m (MutArray a)
2099fromPureStreamN n xs =
2427fromPureStreamN n xs =
2100− liftIO $ D.fold (writeN n) $ D.morphInner (return . runIdentity) xs
2428+ D.fold (createOf n) $ D.morphInner (return . runIdentity) xs
2102-- | Convert a pure stream in Identity monad to a mutable array.
2430-- | Convert a pure stream in Identity monad to a mutable array.
2103{-# INLINABLE fromPureStream #-}
2431{-# INLINABLE fromPureStream #-}
2104fromPureStream :: (MonadIO m, Unbox a) => Stream Identity a -> m (MutArray a)
2432fromPureStream :: (MonadIO m, Unbox a) => Stream Identity a -> m (MutArray a)
2105fromPureStream xs =
2433fromPureStream xs =
2106− liftIO $ D.fold write $ D.morphInner (return . runIdentity) xs
2434+ D.fold create $ D.morphInner (return . runIdentity) xs
2108{-# INLINABLE fromPtrN #-}
2436{-# INLINABLE fromPtrN #-}
2109fromPtrN :: MonadIO m => Int -> Ptr Word8 -> m (MutArray Word8)
2437fromPtrN :: MonadIO m => Int -> Ptr Word8 -> m (MutArray Word8)
@@ -2112,7 +2440,7 @@ fromPtrN len addr = do
2112 -- XXX We can implement a stream copy in a similar way by streaming Word64
2440 -- XXX We can implement a stream copy in a similar way by streaming Word64
2113 -- first and then remaining Word8.
2441 -- first and then remaining Word8.
2114 arr <- new len
2442 arr <- new len
2115− _ <- asUnpinnedPtrUnsafe arr
2443+ _ <- unsafeAsPtr arr
2116 (\ptr -> liftIO $ c_memcpy ptr addr (fromIntegral len))
2444 (\ptr -> liftIO $ c_memcpy ptr addr (fromIntegral len))
2117 return (arr {arrEnd = len})
2445 return (arr {arrEnd = len})
@@ -2128,7 +2456,7 @@ fromByteStr# addr = do
2128 len <- liftIO $ c_strlen (Ptr addr)
2456 len <- liftIO $ c_strlen (Ptr addr)
2129 let lenInt = fromIntegral len
2457 let lenInt = fromIntegral len
2130 arr <- new lenInt
2458 arr <- new lenInt
2131− _ <- asUnpinnedPtrUnsafe arr (\ptr -> liftIO $ c_memcpy ptr (Ptr addr) len)
2459+ _ <- unsafeAsPtr arr (\ptr -> liftIO $ c_memcpy ptr (Ptr addr) len)
2132 return (arr {arrEnd = lenInt})
2460 return (arr {arrEnd = lenInt})
2134-------------------------------------------------------------------------------
2462-------------------------------------------------------------------------------
@@ -2149,7 +2477,7 @@ fromChunksRealloced s = do
2149 arr <- D.foldlM' spliceExp (pure a) strm
2477 arr <- D.foldlM' spliceExp (pure a) strm
2150 -- Reallocation is exponential so there may be 50% empty space in
2478 -- Reallocation is exponential so there may be 50% empty space in
2151 -- worst case. One more reallocation to reclaim the space.
2479 -- worst case. One more reallocation to reclaim the space.
2152− liftIO $ rightSize arr
2480+ rightSize arr
2153 Nothing -> pure nil
2481 Nothing -> pure nil
2155-------------------------------------------------------------------------------
2483-------------------------------------------------------------------------------
@@ -2187,6 +2515,7 @@ fromChunksK :: (Unbox a, MonadIO m) =>
2187fromChunksK = fromChunkskAs Unpinned
2515fromChunksK = fromChunkskAs Unpinned
2189{-# DEPRECATED fromArrayStreamK "Please use fromChunksK instead." #-}
2517{-# DEPRECATED fromArrayStreamK "Please use fromChunksK instead." #-}
2518+{-# INLINE fromArrayStreamK #-}
2190fromArrayStreamK :: (Unbox a, MonadIO m) =>
2519fromArrayStreamK :: (Unbox a, MonadIO m) =>
2191 StreamK m (MutArray a) -> m (MutArray a)
2520 StreamK m (MutArray a) -> m (MutArray a)
2192fromArrayStreamK = fromChunksK
2521fromArrayStreamK = fromChunksK
@@ -2198,7 +2527,7 @@ fromStreamDAs ps m =
2198 arrayStreamKFromStreamDAs Unpinned m >>= fromChunkskAs ps
2527 arrayStreamKFromStreamDAs Unpinned m >>= fromChunkskAs ps
2200-- | Create an 'Array' from a stream. This is useful when we want to create a
2529-- | Create an 'Array' from a stream. This is useful when we want to create a
2201−-- single array from a stream of unknown size. 'writeN' is at least twice
2530+-- single array from a stream of unknown size. 'createOf' is at least twice
2202-- as efficient when the size is already known.
2531-- as efficient when the size is already known.
2204-- Note that if the input stream is too large memory allocation for the array
2533-- Note that if the input stream is too large memory allocation for the array
@@ -2210,19 +2539,19 @@ fromStreamDAs ps m =
2210fromStream :: (MonadIO m, Unbox a) => Stream m a -> m (MutArray a)
2539fromStream :: (MonadIO m, Unbox a) => Stream m a -> m (MutArray a)
2211fromStream = fromStreamDAs Unpinned
2540fromStream = fromStreamDAs Unpinned
2213−-- fromStream (Stream m) = P.fold write m
2542+-- fromStream (Stream m) = P.fold create m
2214-- CAUTION: a very large number (millions) of arrays can degrade performance
2543-- CAUTION: a very large number (millions) of arrays can degrade performance
2215-- due to GC overhead because we need to buffer the arrays before we flatten
2544-- due to GC overhead because we need to buffer the arrays before we flatten
2216-- all the arrays.
2545-- all the arrays.
2218−-- XXX Compare if this is faster or "fold write".
2547+-- XXX Compare if this is faster or "fold create".
2220-- | We could take the approach of doubling the memory allocation on each
2549-- | We could take the approach of doubling the memory allocation on each
2221-- overflow. This would result in more or less the same amount of copying as in
2550-- overflow. This would result in more or less the same amount of copying as in
2222-- the chunking approach. However, if we have to shrink in the end then it may
2551-- the chunking approach. However, if we have to shrink in the end then it may
2223-- result in an extra copy of the entire data.
2552-- result in an extra copy of the entire data.
2225−-- >>> fromStreamD = StreamD.fold MutArray.write
2554+-- >>> fromStreamD = StreamD.fold MutArray.create
2227{-# INLINE fromStreamD #-}
2556{-# INLINE fromStreamD #-}
2228{-# DEPRECATED fromStreamD "Please use fromStream instead." #-}
2557{-# DEPRECATED fromStreamD "Please use fromStream instead." #-}
@@ -2252,6 +2581,10 @@ fromListRev xs = fromListRevN (Prelude.length xs) xs
2252-- Cloning
2581-- Cloning
2253-------------------------------------------------------------------------------
2582-------------------------------------------------------------------------------
2584+-- Arrays are aligned on 64-bit boundaries. The fastest way to copy an array is
2585+-- to unsafeCast it to Word64, read it, write it to Word64 array and unsafeCast
2586+-- it again. We can use SIMD read/write as well.
2255{-# INLINE cloneAs #-}
2588{-# INLINE cloneAs #-}
2256cloneAs ::
2589cloneAs ::
2257 ( MonadIO m
2590 ( MonadIO m
@@ -2261,7 +2594,7 @@ cloneAs ::
2262 => PinnedState -> MutArray a -> m (MutArray a)
2595 => PinnedState -> MutArray a -> m (MutArray a)
2263cloneAs ps src =
2596cloneAs ps src =
2264− liftIO $ do
2597+ do
2265 let startSrc = arrStart src
2598 let startSrc = arrStart src
2266 srcLen = arrEnd src - startSrc
2599 srcLen = arrEnd src - startSrc
2267 newArrContents <-
2600 newArrContents <-
@@ -2300,17 +2633,16 @@ spliceCopy :: forall m a. MonadIO m =>
2300 Unbox a =>
2633 Unbox a =>
2302 MutArray a -> MutArray a -> m (MutArray a)
2635 MutArray a -> MutArray a -> m (MutArray a)
2303−spliceCopy arr1 arr2 = liftIO $ do
2636+spliceCopy arr1 arr2 = do
2304 let start1 = arrStart arr1
2637 let start1 = arrStart arr1
2305 start2 = arrStart arr2
2638 start2 = arrStart arr2
2306 len1 = arrEnd arr1 - start1
2639 len1 = arrEnd arr1 - start1
2307 len2 = arrEnd arr2 - start2
2640 len2 = arrEnd arr2 - start2
2308− let newLen = len1 + len2
2641+ let len = len1 + len2
2309 newArrContents <-
2642 newArrContents <-
2310 if Unboxed.isPinned (arrContents arr1)
2643 if Unboxed.isPinned (arrContents arr1)
2311− then Unboxed.pinnedNew newLen
2644+ then liftIO $ Unboxed.pinnedNew len
2312− else Unboxed.new newLen
2645+ else liftIO $ Unboxed.new len
2313− let len = len1 + len2
2314 putSliceUnsafe (arrContents arr1) start1 newArrContents 0 len1
2646 putSliceUnsafe (arrContents arr1) start1 newArrContents 0 len1
2315 putSliceUnsafe (arrContents arr2) start2 newArrContents len1 len2
2647 putSliceUnsafe (arrContents arr2) start2 newArrContents len1 len2
2316 return $ MutArray newArrContents 0 len len
2648 return $ MutArray newArrContents 0 len len
@@ -2322,7 +2654,7 @@ spliceCopy arr1 arr2 = liftIO $ do
2322spliceUnsafe :: MonadIO m =>
2654spliceUnsafe :: MonadIO m =>
2323 MutArray a -> MutArray a -> m (MutArray a)
2655 MutArray a -> MutArray a -> m (MutArray a)
2324spliceUnsafe dst src =
2656spliceUnsafe dst src =
2325− liftIO $ do
2657+ do
2326 let startSrc = arrStart src
2658 let startSrc = arrStart src
2327 srcLen = arrEnd src - startSrc
2659 srcLen = arrEnd src - startSrc
2328 endDst = arrEnd dst
2660 endDst = arrEnd dst
@@ -2344,7 +2676,7 @@ spliceWith :: forall m a. (MonadIO m, Unbox a) =>
2344 (Int -> Int -> Int) -> MutArray a -> MutArray a -> m (MutArray a)
2676 (Int -> Int -> Int) -> MutArray a -> MutArray a -> m (MutArray a)
2345spliceWith sizer dst@(MutArray _ start end bound) src = do
2677spliceWith sizer dst@(MutArray _ start end bound) src = do
2347− let f = writeAppendWith (`sizer` byteLength src) (return dst)
2679+ let f = appendWith (`sizer` byteLength src) (return dst)
2348 in D.fold f (toStreamD src)
2680 in D.fold f (toStreamD src)
2350 assert (end <= bound) (return ())
2682 assert (end <= bound) (return ())
@@ -2360,7 +2692,7 @@ spliceWith sizer dst@(MutArray _ start end bound) src = do
2360 $ "splice: newSize is less than the total size "
2692 $ "splice: newSize is less than the total size "
2361 ++ "of arrays being appended. Please check the "
2693 ++ "of arrays being appended. Please check the "
2362 ++ "sizer function passed."
2694 ++ "sizer function passed."
2363− liftIO $ realloc newSizeInBytes dst
2695+ realloc newSizeInBytes dst
2364 else return dst
2696 else return dst
2365 spliceUnsafe dst1 src
2697 spliceUnsafe dst1 src
@@ -2412,7 +2744,7 @@ splitOn predicate arr =
2412{-# INLINE breakOn #-}
2744{-# INLINE breakOn #-}
2413breakOn :: MonadIO m
2745breakOn :: MonadIO m
2414 => Word8 -> MutArray Word8 -> m (MutArray Word8, Maybe (MutArray Word8))
2746 => Word8 -> MutArray Word8 -> m (MutArray Word8, Maybe (MutArray Word8))
2415−breakOn sep arr@MutArray{..} = asUnpinnedPtrUnsafe arr $ \p -> liftIO $ do
2747+breakOn sep arr@MutArray{..} = unsafeAsPtr arr $ \p -> liftIO $ do
2416 -- XXX We do not need memchr here, we can use a Haskell equivalent.
2748 -- XXX We do not need memchr here, we can use a Haskell equivalent.
2417 -- Need efficient stream based primitives that work on Word64.
2749 -- Need efficient stream based primitives that work on Word64.
2418 loc <- c_memchr p sep (fromIntegral $ byteLength arr)
2750 loc <- c_memchr p sep (fromIntegral $ byteLength arr)
@@ -2435,33 +2767,41 @@ breakOn sep arr@MutArray{..} = asUnpinnedPtrUnsafe arr $ \p -> liftIO $ do
2770+-- | Like 'splitAt' but does not check whether the index is valid.
2772+{-# INLINE unsafeSplitAt #-}
2773+unsafeSplitAt :: forall a. Unbox a =>
2774+ Int -> MutArray a -> (MutArray a, MutArray a)
2775+unsafeSplitAt i MutArray{..} =
2776+ let off = i * SIZE_OF(a)
2779+ { arrContents = arrContents
2780+ , arrStart = arrStart
2785+ { arrContents = arrContents
2788+ , arrBound = arrBound
2438-- | Create two slices of an array without copying the original array. The
2792-- | Create two slices of an array without copying the original array. The
2439-- specified index @i@ is the first index of the second slice.
2793-- specified index @i@ is the first index of the second slice.
2441{-# INLINE splitAt #-}
2795{-# INLINE splitAt #-}
2442splitAt :: forall a. Unbox a => Int -> MutArray a -> (MutArray a, MutArray a)
2796splitAt :: forall a. Unbox a => Int -> MutArray a -> (MutArray a, MutArray a)
2443−splitAt i arr@MutArray{..} =
2797+splitAt i arr =
2444 let maxIndex = length arr - 1
2798 let maxIndex = length arr - 1
2445 in if i < 0
2799 in if i < 0
2446 then error "sliceAt: negative array index"
2800 then error "sliceAt: negative array index"
2447 else if i > maxIndex
2801 else if i > maxIndex
2448 then error $ "sliceAt: specified array index " ++ show i
2802 then error $ "sliceAt: specified array index " ++ show i
2449 ++ " is beyond the maximum index " ++ show maxIndex
2803 ++ " is beyond the maximum index " ++ show maxIndex
2450− else let off = i * SIZE_OF(a)
2804+ else unsafeSplitAt i arr
2453− { arrContents = arrContents
2454− , arrStart = arrStart
2459− { arrContents = arrContents
2462− , arrBound = arrBound
2466-------------------------------------------------------------------------------
2806-------------------------------------------------------------------------------
2467-- Casting
2807-- Casting
@@ -2511,9 +2851,13 @@ cast arr =
2511-- guarantees that unsafe calls will be performed in the calling thread. Making
2851-- guarantees that unsafe calls will be performed in the calling thread. Making
2512-- it safe to pass heap-allocated objects to unsafe functions.
2852-- it safe to pass heap-allocated objects to unsafe functions.
2514−-- Should we just name it asPtr, the unsafety is implicit for any pointer
2854+-- XXX Should we just name it asPtr, the unsafety is implicit for any pointer
2515-- operations. And we are safe from Haskell perspective because we will be
2855-- operations. And we are safe from Haskell perspective because we will be
2516-- pinning the memory.
2856-- pinning the memory.
2858+-- XXX we cannot pass the length of the ptr here as in some cases it may not be
2859+-- available e.g. a null terminated C string. However, we can create another
2860+-- flavor of the API e.g. asPtrN.
2518-- | Use a @MutArray a@ as @Ptr a@. This is useful when we want to pass an
2862-- | Use a @MutArray a@ as @Ptr a@. This is useful when we want to pass an
2519-- array as a pointer to some operating system call or to a "safe" FFI call.
2863-- array as a pointer to some operating system call or to a "safe" FFI call.
@@ -2531,16 +2875,21 @@ cast arr =
2532-- /Pre-release/
2876-- /Pre-release/
2878+{-# INLINE unsafePinnedAsPtr #-}
2879+unsafePinnedAsPtr :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b
2880+unsafePinnedAsPtr arr f =
2881+ Unboxed.unsafePinnedAsPtr
2882+ (arrContents arr) (\ptr -> f (ptr `plusPtr` arrStart arr))
2884+{-# DEPRECATED asPtrUnsafe "Please use unsafePinnedAsPtr instead." #-}
2534{-# INLINE asPtrUnsafe #-}
2885{-# INLINE asPtrUnsafe #-}
2535asPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b
2886asPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b
2536−asPtrUnsafe arr f =
2887+asPtrUnsafe = unsafePinnedAsPtr
2537− Unboxed.asPtrUnsafe
2538− (arrContents arr) (\ptr -> f (ptr `plusPtr` arrStart arr))
2540−{-# INLINE asUnpinnedPtrUnsafe #-}
2889+{-# INLINE unsafeAsPtr #-}
2541−asUnpinnedPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b
2890+unsafeAsPtr :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b
2542−asUnpinnedPtrUnsafe arr f =
2891+unsafeAsPtr arr f =
2543− Unboxed.asUnpinnedPtrUnsafe
2892+ Unboxed.unsafeAsPtr
2544 (arrContents arr) (\ptr -> f (ptr `plusPtr` arrStart arr))
2893 (arrContents arr) (\ptr -> f (ptr `plusPtr` arrStart arr))
2546-------------------------------------------------------------------------------
2895-------------------------------------------------------------------------------
@@ -2558,28 +2907,26 @@ asUnpinnedPtrUnsafe arr f =
2558-- /Pre-release/
2907-- /Pre-release/
2559{-# INLINE byteCmp #-}
2908{-# INLINE byteCmp #-}
2560byteCmp :: MonadIO m => MutArray a -> MutArray a -> m Ordering
2909byteCmp :: MonadIO m => MutArray a -> MutArray a -> m Ordering
2561−byteCmp arr1 arr2 =
2910+byteCmp arr1 arr2 = do
2564− let marr1 = getMutableByteArray# (arrContents arr1)
2911+ let marr1 = getMutableByteArray# (arrContents arr1)
2565− marr2 = getMutableByteArray# (arrContents arr2)
2912+ marr2 = getMutableByteArray# (arrContents arr2)
2566− !(I# st1#) = arrStart arr1
2913+ !(I# st1#) = arrStart arr1
2567− !(I# st2#) = arrStart arr2
2914+ !(I# st2#) = arrStart arr2
2568− !(I# len#) = byteLength arr1
2915+ !(I# len#) = byteLength arr1
2569− case compare (byteLength arr1) (byteLength arr2) of
2916+ case compare (byteLength arr1) (byteLength arr2) of
2570− EQ -> do
2917+ EQ -> do
2571− r <- liftIO $ IO $ \s# ->
2918+ r <- liftIO $ IO $ \s# ->
2572− let res =
2919+ let res =
2574− (compareByteArrays#
2921+ (compareByteArrays#
2575− (unsafeCoerce# marr1)
2922+ (unsafeCoerce# marr1)
2577− (unsafeCoerce# marr2)
2924+ (unsafeCoerce# marr2)
2580− in (# s#, res #)
2927+ in (# s#, res #)
2581− return $ compare r 0
2928+ return $ compare r 0
2582− x -> return x
2929+ x -> return x
2584{-# INLINE cmp #-}
2931{-# INLINE cmp #-}
2585{-# DEPRECATED cmp "Please use byteCmp instead." #-}
2932{-# DEPRECATED cmp "Please use byteCmp instead." #-}
@@ -2599,46 +2946,48 @@ byteEq arr1 arr2 = fmap (EQ ==) $ byteCmp arr1 arr2
2599-- Compact
2946-- Compact
2600-------------------------------------------------------------------------------
2947-------------------------------------------------------------------------------
2602−-- | Parser @pCompactChunksLE n@ coalesces adjacent arrays in the input stream
2949+-- Note: LE versions avoid an extra copy compared to GE. LE parser trades
2603−-- only if the combined size would be less than or equal to n.
2950+-- backtracking one array in lieu of avoiding a copy. However, LE and GE both
2604−--
2951+-- can leave some memory unused. They can split the last array to fit it
2605−-- /Internal/
2952+-- exactly in the space.
2606−{-# INLINE_NORMAL pCompactChunksLE #-}
2954+{-# INLINE_NORMAL pCompactLeAs #-}
2607−pCompactChunksLE ::
2955+pCompactLeAs ::
2608 forall m a. (MonadIO m, Unbox a)
2956 forall m a. (MonadIO m, Unbox a)
2609− => Int -> Parser (MutArray a) m (MutArray a)
2957+ => PinnedState -> Int -> Parser (MutArray a) m (MutArray a)
2610−pCompactChunksLE n = Parser step initial extract
2958+pCompactLeAs ps maxElems = Parser step initial extract
2614− nBytes = n * SIZE_OF(a)
2962+ maxBytes = maxElems * SIZE_OF(a)
2616− functionName = "Streamly.Internal.Data.MutArray.pCompactChunksLE"
2964+ functionName = "Streamly.Internal.Data.MutArray.pCompactLE"
2618 initial =
2966 initial =
2620− $ if n <= 0
2968+ $ if maxElems <= 0
2621 then error
2969 then error
2622 $ functionName
2970 $ functionName
2623 ++ ": the size of arrays ["
2971 ++ ": the size of arrays ["
2624− ++ show n ++ "] must be a natural number"
2972+ ++ show maxElems ++ "] must be a natural number"
2625 else Parser.IPartial Nothing
2973 else Parser.IPartial Nothing
2627 step Nothing arr =
2975 step Nothing arr =
2629 $ let len = byteLength arr
2977 $ let len = byteLength arr
2630− in if len >= nBytes
2978+ in if len >= maxBytes
2631 then Parser.Done 0 arr
2979 then Parser.Done 0 arr
2632 else Parser.Partial 0 (Just arr)
2980 else Parser.Partial 0 (Just arr)
2981+ -- XXX Split the last array to use the space more compactly.
2633 step (Just buf) arr =
2982 step (Just buf) arr =
2634 let len = byteLength buf + byteLength arr
2983 let len = byteLength buf + byteLength arr
2635− in if len > nBytes
2984+ in if len > maxBytes
2636 then return $ Parser.Done 1 buf
2985 then return $ Parser.Done 1 buf
2638− -- XXX check this in the Nothing case
2640− if byteCapacity buf < nBytes
2988+ if byteCapacity buf < maxBytes
2641− then liftIO $ realloc nBytes buf
2989+ then liftIO $ reallocExplicitAs
2990+ ps (SIZE_OF(a)) maxBytes buf
2642 else return buf
2991 else return buf
2643 buf2 <- spliceUnsafe buf1 arr
2992 buf2 <- spliceUnsafe buf1 arr
2644 return $ Parser.Partial 0 (Just buf2)
2993 return $ Parser.Partial 0 (Just buf2)
@@ -2646,6 +2995,30 @@ pCompactChunksLE n = Parser step initial extract
2646 extract Nothing = return $ Parser.Done 0 nil
2995 extract Nothing = return $ Parser.Done 0 nil
2647 extract (Just buf) = return $ Parser.Done 0 buf
2996 extract (Just buf) = return $ Parser.Done 0 buf
2998+-- | Parser @pCompactLE maxElems@ coalesces adjacent arrays in the input stream
2999+-- only if the combined size would be less than or equal to @maxElems@
3000+-- elements. Note that it won't split an array if the original array is already
3001+-- larger than maxElems.
3003+-- @maxElems@ must be greater than 0.
3005+-- Generates unpinned arrays irrespective of the pinning status of input
3009+{-# INLINE pCompactLE #-}
3011+ forall m a. (MonadIO m, Unbox a)
3012+ => Int -> Parser (MutArray a) m (MutArray a)
3013+pCompactLE = pCompactLeAs Unpinned
3015+-- | Pinned version of 'pCompactLE'.
3016+{-# INLINE pPinnedCompactLE #-}
3018+ forall m a. (MonadIO m, Unbox a)
3019+ => Int -> Parser (MutArray a) m (MutArray a)
3020+pPinnedCompactLE = pCompactLeAs Pinned
2649data SpliceState s arr
3022data SpliceState s arr
2650 = SpliceInitial s
3023 = SpliceInitial s
2651 | SpliceBuffering s arr
3024 | SpliceBuffering s arr
@@ -2657,48 +3030,47 @@ data SpliceState s arr
2657-- immutable array never has additional space so a new array is allocated
3030-- immutable array never has additional space so a new array is allocated
2658-- instead of mutating it.
3031-- instead of mutating it.
2660−-- | Scan @rCompactChunksLE n@ coalesces adjacent arrays in the input stream
2661−-- only if the combined size would be less than or equal to n.
2664−{-# INLINE_NORMAL rCompactChunksLE #-}
3033+{-# INLINE_NORMAL compactLeAs #-}
2665−rCompactChunksLE :: (MonadIO m, Unbox a)
3034+compactLeAs :: forall m a. (MonadIO m, Unbox a)
2666− => Int -> D.Stream m (MutArray a) -> D.Stream m (MutArray a)
3035+ => PinnedState -> Int -> D.Stream m (MutArray a) -> D.Stream m (MutArray a)
2667−rCompactChunksLE n (D.Stream step state) =
3036+compactLeAs ps maxElems (D.Stream step state) =
2668 D.Stream step' (SpliceInitial state)
3037 D.Stream step' (SpliceInitial state)
3041+ maxBytes = maxElems * SIZE_OF(a)
2672− functionName = "Streamly.Internal.Data.MutArray.rCompactChunksLE"
3043+ functionName = "Streamly.Internal.Data.MutArray.rCompactLE"
2674 {-# INLINE_LATE step' #-}
3045 {-# INLINE_LATE step' #-}
2675 step' gst (SpliceInitial st) = do
3046 step' gst (SpliceInitial st) = do
2676− when (n <= 0) $
3047+ when (maxElems <= 0) $
2677 -- XXX we can pass the module string from the higher level API
3048 -- XXX we can pass the module string from the higher level API
2678− error $ functionName ++ ": the size of arrays [" ++ show n
3049+ error $ functionName ++ ": the size of arrays [" ++ show maxElems
2679 ++ "] must be a natural number"
3050 ++ "] must be a natural number"
2680 r <- step gst st
3051 r <- step gst st
2681 case r of
3052 case r of
2682 D.Yield arr s -> return $
3053 D.Yield arr s -> return $
2683 let len = byteLength arr
3054 let len = byteLength arr
2684− in if len >= n
3055+ in if len >= maxBytes
2685 then D.Skip (SpliceYielding arr (SpliceInitial s))
3056 then D.Skip (SpliceYielding arr (SpliceInitial s))
2686 else D.Skip (SpliceBuffering s arr)
3057 else D.Skip (SpliceBuffering s arr)
2687 D.Skip s -> return $ D.Skip (SpliceInitial s)
3058 D.Skip s -> return $ D.Skip (SpliceInitial s)
2688 D.Stop -> return D.Stop
3059 D.Stop -> return D.Stop
3061+ -- XXX Split the last array to use the space more compactly.
2690 step' gst (SpliceBuffering st buf) = do
3062 step' gst (SpliceBuffering st buf) = do
2691 r <- step gst st
3063 r <- step gst st
2692 case r of
3064 case r of
2693 D.Yield arr s -> do
3065 D.Yield arr s -> do
2694 let len = byteLength buf + byteLength arr
3066 let len = byteLength buf + byteLength arr
2695− if len > n
3067+ if len > maxBytes
2696 then return $
3068 then return $
2697 D.Skip (SpliceYielding buf (SpliceBuffering s arr))
3069 D.Skip (SpliceYielding buf (SpliceBuffering s arr))
2699− -- XXX check this in the SpliceInitial case
2700− buf1 <- if byteCapacity buf < n
3071+ buf1 <- if byteCapacity buf < maxBytes
2701− then liftIO $ realloc n buf
3072+ then liftIO $ reallocExplicitAs
3073+ ps (SIZE_OF(a)) maxBytes buf
2702 else return buf
3074 else return buf
2703 buf2 <- spliceUnsafe buf1 arr
3075 buf2 <- spliceUnsafe buf1 arr
2704 return $ D.Skip (SpliceBuffering s buf2)
3076 return $ D.Skip (SpliceBuffering s buf2)
@@ -2709,113 +3081,124 @@ rCompactChunksLE n (D.Stream step state) =
2710 step' _ (SpliceYielding arr next) = return $ D.Yield arr next
3082 step' _ (SpliceYielding arr next) = return $ D.Yield arr next
2712−-- | Fold @fCompactChunksGE n@ coalesces adjacent arrays in the input stream
3084+
2713−-- until the size becomes greater than or equal to n.
2715−{-# INLINE_NORMAL fCompactChunksGE #-}
3085+{-# INLINE_NORMAL fCompactGeAs #-}
2716−fCompactChunksGE ::
3086+fCompactGeAs ::
2717 forall m a. (MonadIO m, Unbox a)
3087 forall m a. (MonadIO m, Unbox a)
2718− => Int -> FL.Fold m (MutArray a) (MutArray a)
3088+ => PinnedState -> Int -> FL.Fold m (MutArray a) (MutArray a)
2719−fCompactChunksGE n = Fold step initial extract extract
3089+fCompactGeAs ps minElems = Fold step initial extract extract
2723− nBytes = n * SIZE_OF(a)
3093+ minBytes = minElems * SIZE_OF(a)
2725− functionName = "Streamly.Internal.Data.MutArray.fCompactChunksGE"
3095+ functionName = "Streamly.Internal.Data.MutArray.fCompactGE"
2727 initial =
3097 initial =
2729− $ if n < 0
3099+ $ if minElems < 0
2730 then error
3100 then error
2731 $ functionName
3101 $ functionName
2732 ++ ": the size of arrays ["
3102 ++ ": the size of arrays ["
2733− ++ show n ++ "] must be a natural number"
3103+ ++ show minElems ++ "] must be a natural number"
2734 else FL.Partial Nothing
3104 else FL.Partial Nothing
2736 step Nothing arr =
3106 step Nothing arr =
2738 $ let len = byteLength arr
3108 $ let len = byteLength arr
2739− in if len >= nBytes
3109+ in if len >= minBytes
2740 then FL.Done arr
3110 then FL.Done arr
2741 else FL.Partial (Just arr)
3111 else FL.Partial (Just arr)
3112+ -- XXX Buffer arrays as a list to avoid copy and reallocations
2742 step (Just buf) arr = do
3113 step (Just buf) arr = do
2743 let len = byteLength buf + byteLength arr
3114 let len = byteLength buf + byteLength arr
2745 if byteCapacity buf < len
3116 if byteCapacity buf < len
2746− then liftIO $ realloc (max len nBytes) buf
3117+ then liftIO $ reallocExplicitAs
3118+ ps (SIZE_OF(a)) (max minBytes len) buf
2747 else return buf
3119 else return buf
2748 buf2 <- spliceUnsafe buf1 arr
3120 buf2 <- spliceUnsafe buf1 arr
2749− if len >= n
3121+ if len >= minBytes
2750 then return $ FL.Done buf2
3122 then return $ FL.Done buf2
2751 else return $ FL.Partial (Just buf2)
3123 else return $ FL.Partial (Just buf2)
2753 extract Nothing = return nil
3125 extract Nothing = return nil
2754 extract (Just buf) = return buf
3126 extract (Just buf) = return buf
2756−-- | Like 'compactChunksGE' but for transforming folds instead of stream.
3128+-- | Fold @fCompactGE minElems@ coalesces adjacent arrays in the input stream
2757−--
3129+-- until the size becomes greater than or equal to @minElems@.
2758−-- >>> lCompactChunksGE n = Fold.many (MutArray.fCompactChunksGE n)
3131+-- Generates unpinned arrays irrespective of the pinning status of input
3133+{-# INLINE fCompactGE #-}
3135+ forall m a. (MonadIO m, Unbox a)
3136+ => Int -> FL.Fold m (MutArray a) (MutArray a)
3137+fCompactGE = fCompactGeAs Unpinned
3139+-- | Pinned version of 'fCompactGE'.
3140+{-# INLINE fPinnedCompactGE #-}
3142+ forall m a. (MonadIO m, Unbox a)
3143+ => Int -> FL.Fold m (MutArray a) (MutArray a)
3144+fPinnedCompactGE = fCompactGeAs Pinned
2760−{-# INLINE_NORMAL lCompactChunksGE #-}
3146+{-# INLINE_NORMAL lCompactGeAs #-}
2761−lCompactChunksGE :: (MonadIO m, Unbox a)
3147+lCompactGeAs :: forall m a. (MonadIO m, Unbox a)
2762− => Int -> Fold m (MutArray a) () -> Fold m (MutArray a) ()
3148+ => PinnedState -> Int -> Fold m (MutArray a) () -> Fold m (MutArray a) ()
2763−-- lCompactChunksGE n = Fold.many (fCompactChunksGE n)
3149+-- The fold version turns out to be a little bit slower.
3150+-- lCompactGeAs ps n = FL.many (fCompactGeAs ps n)
2764−lCompactChunksGE n (Fold step1 initial1 _ final1) =
3151+lCompactGeAs ps minElems (Fold step1 initial1 _ final1) =
2765 Fold step initial extract final
3152 Fold step initial extract final
3156+ minBytes = minElems * SIZE_OF(a)
2769− functionName = "Streamly.Internal.Data.MutArray.lCompactChunksGE"
3158+ functionName = "Streamly.Internal.Data.MutArray.lCompactGE"
2771 initial = do
3160 initial = do
2772− when (n <= 0) $
3161+ when (minElems <= 0) $
2773 -- XXX we can pass the module string from the higher level API
3162 -- XXX we can pass the module string from the higher level API
2774 error $ functionName ++ ": the size of arrays ["
3163 error $ functionName ++ ": the size of arrays ["
2775− ++ show n ++ "] must be a natural number"
3164+ ++ show minElems ++ "] must be a natural number"
2777 r <- initial1
3166 r <- initial1
2778 return $ first (Tuple' Nothing) r
3167 return $ first (Tuple' Nothing) r
2780− step (Tuple' Nothing r1) arr =
3169+ {-# INLINE runInner #-}
2781− let len = byteLength arr
3170+ runInner len acc buf =
2786− FL.Done _ -> return $ FL.Done ()
2790− return $ first (Tuple' Nothing) res
2791− else return $ FL.Partial $ Tuple' (Just arr) r1
2793− step (Tuple' (Just buf) r1) arr = do
2794− let len = byteLength buf + byteLength arr
2795− buf1 <- if byteCapacity buf < len
2796− then liftIO $ realloc (max n len) buf
2798− buf2 <- spliceUnsafe buf1 arr
2800− -- XXX this is common in both the equations of step
2801− if len >= n
3171+ if len >= minBytes
2803− r <- step1 r1 buf2
3173+ r <- step1 acc buf
2804 case r of
3174 case r of
2805 FL.Done _ -> return $ FL.Done ()
3175 FL.Done _ -> return $ FL.Done ()
2806 FL.Partial s -> do
3176 FL.Partial s -> do
2807 _ <- final1 s
3177 _ <- final1 s
2808 res <- initial1
3178 res <- initial1
2809 return $ first (Tuple' Nothing) res
3179 return $ first (Tuple' Nothing) res
2810− else return $ FL.Partial $ Tuple' (Just buf2) r1
3180+ else return $ FL.Partial $ Tuple' (Just buf) acc
3182+ step (Tuple' Nothing r1) arr =
3183+ runInner (byteLength arr) r1 arr
3185+ -- XXX Buffer arrays as a list to avoid copy and reallocations
3186+ step (Tuple' (Just buf) r1) arr = do
3187+ let len = byteLength buf + byteLength arr
3188+ buf1 <- if byteCapacity buf < len
3189+ then liftIO $ reallocExplicitAs
3190+ ps (SIZE_OF(a)) (max minBytes len) buf
3192+ buf2 <- spliceUnsafe buf1 arr
3193+ runInner len r1 buf2
2812 -- XXX Several folds do extract >=> final, therefore, we need to make final
3195 -- XXX Several folds do extract >=> final, therefore, we need to make final
2813− -- return "m b" rather than using extract post it if we want extract to be
3196+ -- return "m b" rather than using extract post it if we want extract to be
2814 -- partial.
3197 -- partial.
2816 -- extract forces the pending buffer to be sent to the fold which is not
3199 -- extract forces the pending buffer to be sent to the fold which is not
2817 -- what we want.
3200 -- what we want.
2818− extract _ = error "lCompactChunksGE: not designed for scanning"
3201+ extract _ = error "lCompactGE: not designed for scanning"
2820 final (Tuple' Nothing r1) = final1 r1
3203 final (Tuple' Nothing r1) = final1 r1
2821 final (Tuple' (Just buf) r1) = do
3204 final (Tuple' (Just buf) r1) = do
@@ -2824,25 +3207,42 @@ lCompactChunksGE n (Fold step1 initial1 _ final1) =
2824 FL.Partial rr -> final1 rr
3207 FL.Partial rr -> final1 rr
2825 FL.Done _ -> return ()
3208 FL.Done _ -> return ()
3210+-- | Like 'compactGE' but for transforming folds instead of stream.
3212+-- >>> lCompactGE n = Fold.many (MutArray.fCompactGE n)
3214+-- Generates unpinned arrays irrespective of the pinning status of input
3216+{-# INLINE lCompactGE #-}
3217+lCompactGE :: forall m a. (MonadIO m, Unbox a)
3218+ => Int -> Fold m (MutArray a) () -> Fold m (MutArray a) ()
3219+lCompactGE = lCompactGeAs Unpinned
3221+-- | Pinned version of 'lCompactGE'.
3222+{-# INLINE lPinnedCompactGE #-}
3223+lPinnedCompactGE :: forall m a. (MonadIO m, Unbox a)
3224+ => Int -> Fold m (MutArray a) () -> Fold m (MutArray a) ()
3225+lPinnedCompactGE = lCompactGeAs Pinned
2827−-- | @compactChunksGE n stream@ coalesces adjacent arrays in the @stream@ until
3227+-- | @compactGE n stream@ coalesces adjacent arrays in the @stream@ until
2828-- the size becomes greater than or equal to @n@.
3228-- the size becomes greater than or equal to @n@.
2830−-- >>> compactChunksGE n = Stream.foldMany (MutArray.fCompactChunksGE n)
3230+-- >>> compactGE n = Stream.foldMany (MutArray.fCompactGE n)
2832−{-# INLINE compactChunksGE #-}
3232+{-# INLINE compactGE #-}
2833−compactChunksGE ::
3233+compactGE ::
2834 (MonadIO m, Unbox a)
3234 (MonadIO m, Unbox a)
2835 => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
3235 => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
2836−compactChunksGE n = D.foldMany (fCompactChunksGE n)
3236+compactGE n = D.foldMany (fCompactGE n)
2838−-- | 'compactChunksEQ n' coalesces adajacent arrays in the input stream to
3238+-- | 'compactEQ n' coalesces adajacent arrays in the input stream to
2839-- arrays of exact size @n@.
3239-- arrays of exact size @n@.
2841-- /Unimplemented/
3241-- /Unimplemented/
2842−{-# INLINE compactChunksEQ #-}
3242+{-# INLINE compactEQ #-}
2843−compactChunksEQ :: -- (MonadIO m, Unbox a) =>
3243+compactEQ :: -- (MonadIO m, Unbox a) =>
2844 Int -> Stream m (MutArray a) -> Stream m (MutArray a)
3244 Int -> Stream m (MutArray a) -> Stream m (MutArray a)
2845−compactChunksEQ _n = undefined -- D.parseManyD (pCompactChunksEQ n)
3245+compactEQ _n = undefined -- D.parseManyD (pCompactEQ n)
2847-------------------------------------------------------------------------------
3247-------------------------------------------------------------------------------
2848-- In-place mutation algorithms
3248-- In-place mutation algorithms