@@ -28,80 +28,57 @@
2828
2929module Streamly.Internal.Data.MutArray.Type
3030 (
31− -- ** Type
31+ -- * Type
3232 -- $arrayNotes
3333 MutArray (..)
34−
35− -- ** Conversion
36− -- *** Pinned and Unpinned
34+ , MutableByteArray
35+ , touch
3736 , pin
3837 , unpin
3938 , isPinned
4039
41− -- ** Casting
42− , cast
43− , castUnsafe -- XXX unsafeCast
44− , asBytes
45− , unsafePinnedAsPtr
46− , unsafeAsPtr
47−
40+ -- * Constructing and Writing
4841 -- ** Construction
49− , empty
50−
51− -- *** New
52− -- | New arrays are always empty arrays with some reserve capacity to
53− -- extend the length without reallocating.
54− , emptyOf
55− , newArrayWith -- emptyAlignedWith
56− , pinnedEmptyOf
57− , pinnedNewAligned -- XXX not required
58− -- , new -- uninitialized array of specified length
59−
60− -- *** Cloning
61− , clone
62− , pinnedClone
42+ , nil
6343
64− -- *** Slicing
65− -- | Get a subarray without copying
66− , getSliceUnsafe -- XXX unsafeGetSlice
67− , getSlice
68− , splitAt -- XXX should be able to express using getSlice
69− , breakOn
44+ -- *** Uninitialized Arrays
45+ , pinnedNew
46+ , pinnedNewBytes
47+ , pinnedNewAligned
48+ , new
49+ , newArrayWith
7050
71− -- *** Stream Folds
51+ -- *** From streams
7252 , ArrayUnsafe (..)
73− , unsafeCreateOfWith
74− , unsafeCreateOf
75− , unsafePinnedCreateOf
76− , pinnedCreateOf
77− , createOfWith
78− , createOf
79− , revCreateOf
80−
81− , pinnedCreate
82− , createWith
83− , create
84− -- , revCreate
85−
86− -- *** From containers
53+ , writeNWithUnsafe
54+ , writeNWith
55+ , writeNUnsafe
56+ , pinnedWriteNUnsafe
57+ , writeN
58+ , pinnedWriteN
59+ , pinnedWriteNAligned
60+
61+ , writeWith
62+ , write
63+ , pinnedWrite
64+
65+ , writeRevN
66+ -- , writeRev
67+
68+ -- ** From containers
8769 , fromListN
8870 , pinnedFromListN
8971 , fromList
9072 , pinnedFromList
9173 , fromListRevN
9274 , fromListRev
93− , fromStreamN
94− , fromStream
95− , fromPureStreamN
75+ , fromStreamDN
76+ , fromStreamD
9677 , fromPureStream
97− , fromByteStr#
98− , fromPtrN
99− , fromChunksK
100− , fromChunksRealloced -- fromSmallChunks
10178
102− -- ** Random writes
79+ -- * Random writes
10380 , putIndex
104− , putIndexUnsafe -- XXX unsafePutIndex
81+ , putIndexUnsafe
10582 , putIndices
10683 -- , putFromThenTo
10784 -- , putFrom -- start writing at the given position
@@ -109,71 +86,78 @@ module Streamly.Internal.Data.MutArray.Type
10986 -- , putFromTo
11087 -- , putFromRev
11188 -- , putUptoRev
112− , modifyIndexUnsafe -- XXX unsafeModifyIndex
89+ , modifyIndexUnsafe
11390 , modifyIndex
11491 , modifyIndices
11592 , modify
11693 , swapIndices
11794 , unsafeSwapIndices
11895
119− -- ** Reading
96+ -- * Growing and Shrinking
97+ -- Arrays grow only at the end, though it is possible to grow on both sides
98+ -- and therefore have a cons as well as snoc. But that will require two
99+ -- bounds in the array representation.
120100
121− -- *** Indexing
122− , getIndex
123− , getIndexUnsafe -- XXX unsafeGetIndex
124− -- , getFromThenTo
125− , getIndexRev -- getRevIndex?
126− , indexReader
127− , indexReaderWith
101+ -- ** Appending elements
102+ , snocWith
103+ , snoc
104+ , snocLinear
105+ , snocMay
106+ , snocUnsafe
128107
129− -- *** To Streams
108+ -- ** Appending streams
109+ , writeAppendNUnsafe
110+ , writeAppendN
111+ , writeAppendWith
112+ , writeAppend
113+
114+ -- * Eliminating and Reading
115+
116+ -- ** To streams
117+ , reader
118+ , readerRevWith
119+ , readerRev
120+
121+ -- ** To containers
122+ , toStreamDWith
123+ , toStreamDRevWith
124+ , toStreamKWith
125+ , toStreamKRevWith
130126 , read
131127 , readRev
132− , toStreamWith
133− , toStreamRevWith
134128 , toStreamK
135− , toStreamKWith
136129 , toStreamKRev
137− , toStreamKRevWith
138−
139− -- *** To Containers
140130 , toList
141131
142− -- *** Unfolds
143132 -- experimental
144133 , producerWith
145134 , producer
146135
147− , reader
148− , readerRevWith
149− , readerRev
150−
151− -- ** Size and Capacity
152− -- *** Size
153− , length
154− , byteLength
155−
156− -- *** Capacity
157− -- , capacity
158− , byteCapacity
159− , bytesFree
136+ -- ** Random reads
137+ , getIndex
138+ , getIndexUnsafe
139+ , getIndices
140+ , getIndicesD
141+ -- , getFromThenTo
142+ , getIndexRev
160143
161− -- *** Capacity Management
144+ -- * Memory Management
162145 , blockSize
163146 , arrayChunkBytes
164147 , allocBytesToElemCount
165− , realloc -- this is "resize"
166− , grow
167− , growExp
148+ , realloc
149+ , resize
150+ , resizeExp
168151 , rightSize
169152
170− -- ** Folding
171− , foldl'
172− , foldr
173− , byteCmp
174− , byteEq
153+ -- * Size
154+ , length
155+ , byteLength
156+ -- , capacity
157+ , byteCapacity
158+ , bytesFree
175159
176− -- ** In-place Mutation Algorithms
160+ -- * In-place Mutation Algorithms
177161 , strip
178162 , reverse
179163 , permute
@@ -183,121 +167,62 @@ module Streamly.Internal.Data.MutArray.Type
183167 , mergeBy
184168 , bubble
185169
186− -- ** Growing and Shrinking
187− -- | Arrays grow only at the end, though it is possible to grow on both
188− -- sides and therefore have a cons as well as snoc. But that will require
189− -- both lower and upper bound in the array representation.
190−
191− -- *** Appending elements
192− , snocWith
193− , snoc
194− , snocLinear
195− , snocMay
196− , snocUnsafe -- XXX unsafeSnoc
197−
198− -- *** Appending streams
199− , unsafeAppendN
200− , appendN
201− , appendWith
202− , append
203−
204− -- *** Appending arrays
205− , spliceCopy
206− , spliceWith
207− , splice
208− , spliceExp
209− , spliceUnsafe -- XXX unsafeSplice
210− -- , putSlice
211− -- , appendSlice
212− -- , appendSliceFrom
213−
214− -- ** Serialization using Unbox
215− , pokeAppend
216− , pokeAppendMay
217− , pokeSkipUnsafe -- unsafePokeSkip
170+ -- * Casting
171+ , cast
172+ , castUnsafe
173+ , asBytes
174+ , asPtrUnsafe
218175
219− -- ** Deserialization using Unbox
220− , peekUncons
221− , peekUnconsUnsafe -- unsafePeekUncons
222− , peekSkipUnsafe -- unsafePeekSkip
176+ -- * Folding
177+ , foldl'
178+ , foldr
179+ , cmp
223180
224− -- Arrays of arrays
181+ -- * Arrays of arrays
225182 -- We can add dimensionality parameter to the array type to get
226183 -- multidimensional arrays. Multidimensional arrays would just be a
227184 -- convenience wrapper on top of single dimensional arrays.
228185
229− -- ** Streams of Arrays
230− -- *** Chunk
231− -- | Group a stream into arrays.
186+ -- | Operations dealing with multiple arrays, streams of arrays or
187+ -- multidimensional array representations.
188+
189+ -- ** Construct from streams
232190 , chunksOf
233191 , pinnedChunksOf
234− , buildChunks
192+ , writeChunks
235193
236− -- *** Split
237− -- | Split an array into slices.
194+ -- ** Eliminate to streams
195+ , flattenArrays
196+ , flattenArraysRev
197+ , fromArrayStreamK
238198
199+ -- ** Construct from arrays
200+ -- get chunks without copying
201+ , getSliceUnsafe
202+ , getSlice
239203 -- , getSlicesFromLenN
240− , splitOn
241− -- , slicesOf
242−
243− -- *** Concat
244− -- | Append the arrays in a stream to form a stream of elements.
245− , concatWith
246− , concatRevWith
247− , concat
248− , concatRev
249−
250− -- *** Compact
251− -- | Append the arrays in a stream to form a stream of larger arrays.
252− , SpliceState (..)
253− , pCompactLE
254− , pPinnedCompactLE
255− , compactLeAs
256− , fCompactGE
257− , fPinnedCompactGE
258− , lCompactGE
259− , lPinnedCompactGE
260− , compactGE
261− , compactEQ
262−
263− -- ** Utilities
204+ , splitAt -- XXX should be able to express using getSlice
205+ , breakOn
206+
207+ -- ** Cloning arrays
208+ , clone
209+ , pinnedClone
210+
211+ -- ** Appending arrays
212+ , spliceCopy
213+ , spliceWith
214+ , splice
215+ , spliceExp
216+ , spliceUnsafe
217+ -- , putSlice
218+ -- , appendSlice
219+ -- , appendSliceFrom
220+
221+ -- * Utilities
264222 , roundUpToPower2
265223 , memcpy
266224 , memcmp
267225 , c_memchr
268−
269− -- * Deprecated
270− , asPtrUnsafe
271− , writeChunks
272− , flattenArrays
273− , flattenArraysRev
274− , fromArrayStreamK
275− , fromStreamDN
276− , fromStreamD
277− , cmp
278− , getIndices
279− , getIndicesWith
280− , resize
281− , resizeExp
282− , nil
283− , new
284− , pinnedNew
285− , pinnedNewBytes
286− , writeAppendNUnsafe
287− , writeAppendN
288− , writeAppendWith
289− , writeAppend
290− , writeNWithUnsafe
291− , writeNWith
292− , writeNUnsafe
293− , pinnedWriteNUnsafe
294− , writeN
295− , pinnedWriteN
296− , pinnedWriteNAligned -- XXX not required
297− , writeWith
298− , write
299− , pinnedWrite
300− , writeRevN
301226 )
302227where
303228
@@ -308,52 +233,49 @@ where
308233
309234import Control.Monad (when, void)
310235import Control.Monad.IO.Class (MonadIO(..))
311−import Data.Bifunctor (first)
312236import Data.Bits (shiftR, (.|.), (.&.))
313237import Data.Functor.Identity (Identity(..))
314238import Data.Proxy (Proxy(..))
315239import Data.Word (Word8)
316240import Foreign.C.Types (CSize(..), CInt(..))
317241import Foreign.Ptr (plusPtr, minusPtr, nullPtr)
318−import Streamly.Internal.Data.MutByteArray.Type
319− ( MutByteArray(..)
242+import Streamly.Internal.Data.Unbox
243+ ( MutableByteArray(..)
244+ , Unbox(..)
320245 , PinnedState(..)
321246 , getMutableByteArray#
247+ , touch
322248 , putSliceUnsafe
323249 )
324−import Streamly.Internal.Data.Unbox (Unbox(..))
325250import GHC.Base
326251 ( IO(..)
327252 , Int(..)
253+ , byteArrayContents#
328254 , compareByteArrays#
329255 , copyMutableByteArray#
330256 )
331257import GHC.Base (noinline)
332−import GHC.Exts (unsafeCoerce#, Addr#)
258+import GHC.Exts (unsafeCoerce#)
333259import GHC.Ptr (Ptr(..))
334260
335261import Streamly.Internal.Data.Fold.Type (Fold(..))
336262import Streamly.Internal.Data.Producer.Type (Producer (..))
337263import Streamly.Internal.Data.Stream.Type (Stream)
338−import Streamly.Internal.Data.Parser.Type (Parser (..))
339264import Streamly.Internal.Data.StreamK.Type (StreamK)
340265import Streamly.Internal.Data.SVar.Type (adaptState, defState)
341−import Streamly.Internal.Data.Tuple.Strict (Tuple'(..))
342266import Streamly.Internal.Data.Unfold.Type (Unfold(..))
343267import Streamly.Internal.System.IO (arrayPayloadSize, defaultChunkSize)
344268
345269import qualified Streamly.Internal.Data.Fold.Type as FL
346−import qualified Streamly.Internal.Data.MutByteArray.Type as Unboxed
347−import qualified Streamly.Internal.Data.Parser.Type as Parser
348−-- import qualified Streamly.Internal.Data.Fold.Type as Fold
349270import qualified Streamly.Internal.Data.Producer as Producer
350271import qualified Streamly.Internal.Data.Stream.Type as D
351272import qualified Streamly.Internal.Data.Stream.Lift as D
352273import qualified Streamly.Internal.Data.StreamK.Type as K
274+import qualified Streamly.Internal.Data.Unbox as Unboxed
353275import qualified Prelude
354276
355277import Prelude hiding
356− (Foldable(..), concat, read, unlines, splitAt, reverse, truncate)
278+ (Foldable(..), read, unlines, splitAt, reverse, truncate)
357279
358280#include "DocTestDataMutArray.hs"
359281
@@ -361,7 +283,6 @@ import Prelude hiding
361283-- Foreign helpers
362284-------------------------------------------------------------------------------
363285
364−-- NOTE: Have to be "ccall unsafe" so that we can pass unpinned memory to these
365286foreign import ccall unsafe "string.h memcpy" c_memcpy
366287 :: Ptr Word8 -> Ptr Word8 -> CSize -> IO (Ptr Word8)
367288
@@ -371,9 +292,6 @@ foreign import ccall unsafe "string.h memchr" c_memchr
371292foreign import ccall unsafe "string.h memcmp" c_memcmp
372293 :: Ptr Word8 -> Ptr Word8 -> CSize -> IO CInt
373294
374−foreign import ccall unsafe "string.h strlen" c_strlen
375− :: Ptr Word8 -> IO CSize
376−
377295-- | Given an 'Unboxed' type (unused first arg) and a number of bytes, return
378296-- how many elements of that type will completely fit in those bytes.
379297--
@@ -428,7 +346,7 @@ data MutArray a =
428346 -- The array is a range into arrContents. arrContents may be a superset of
429347 -- the slice represented by the array. All offsets are in bytes.
430348 MutArray
431− { arrContents :: {-# UNPACK #-} !MutByteArray
349+ { arrContents :: {-# UNPACK #-} !MutableByteArray
432350 , arrStart :: {-# UNPACK #-} !Int -- ^ index into arrContents
433351 , arrEnd :: {-# UNPACK #-} !Int -- ^ index into arrContents
434352 -- Represents the first invalid index of
@@ -440,8 +358,8 @@ data MutArray a =
440358-- Pinning & Unpinning
441359-------------------------------------------------------------------------------
442360
443−-- | Return a copy of the array in pinned memory if unpinned, else return the
444−-- original array.
361+-- | Copy the 'MutArray' to pinned memory if unpinned, else do nothing. The
362+-- overhead is a copy if the input array is unpinned.
445363{-# INLINE pin #-}
446364pin :: MutArray a -> IO (MutArray a)
447365pin arr@MutArray{..} =
@@ -449,8 +367,8 @@ pin arr@MutArray{..} =
449367 then pure arr
450368 else pinnedClone arr
451369
452−-- | Return a copy of the array in unpinned memory if pinned, else return the
453−-- original array.
370+-- | Copy the 'MutArray' to unpinned memory if pinned, else do nothing. The
371+-- overhead is a copy if the input array is pinned.
454372{-# INLINE unpin #-}
455373unpin :: MutArray a -> IO (MutArray a)
456374unpin arr@MutArray{..} =
@@ -458,7 +376,6 @@ unpin arr@MutArray{..} =
458376 then clone arr
459377 else pure arr
460378
461−-- | Return 'True' if the array is allocated in pinned memory.
462379{-# INLINE isPinned #-}
463380isPinned :: MutArray a -> Bool
464381isPinned MutArray{..} = Unboxed.isPinned arrContents
@@ -479,8 +396,6 @@ isPinned MutArray{..} = Unboxed.isPinned arrContents
479396-- we need more than that. See stg_pinnedNewAlignedByteArrayzh and
480397-- allocatePinned in GHC source.
481398
482−-- XXX Rename to emptyAlignedWith, alignSize should be first arg.
483−
484399-- | @newArrayWith allocator alignment count@ allocates a new array of zero
485400-- length and with a capacity to hold @count@ elements, using @allocator
486401-- size alignment@ as the memory allocator function.
@@ -493,7 +408,7 @@ isPinned MutArray{..} = Unboxed.isPinned arrContents
493408-- /Pre-release/
494409{-# INLINE newArrayWith #-}
495410newArrayWith :: forall m a. (MonadIO m, Unbox a)
496− => (Int -> Int -> m MutByteArray) -> Int -> Int -> m (MutArray a)
411+ => (Int -> Int -> m MutableByteArray) -> Int -> Int -> m (MutArray a)
497412newArrayWith alloc alignSize count = do
498413 let size = max (count * SIZE_OF(a)) 0
499414 contents <- alloc size alignSize
@@ -504,25 +419,12 @@ newArrayWith alloc alignSize count = do
504419 , arrBound = size
505420 }
506421
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.
510−
511−-- | Create an empty array.
512−empty ::
513−#ifdef DEVBUILD
514− Unbox a =>
515−#endif
516− MutArray a
517−empty = MutArray Unboxed.empty 0 0 0
518−
519−{-# DEPRECATED nil "Please use empty instead." #-}
520422nil ::
521423#ifdef DEVBUILD
522424 Unbox a =>
523425#endif
524426 MutArray a
525−nil = empty
427+nil = MutArray Unboxed.nil 0 0 0
526428
527429{-# INLINE newBytesAs #-}
528430newBytesAs :: MonadIO m =>
@@ -539,13 +441,12 @@ newBytesAs ps bytes = do
539441 , arrBound = bytes
540442 }
541443
542−-- | Allocates a pinned empty array that with a reserved capacity of bytes.
543−-- The memory of the array is uninitialized and the allocation is aligned as
544−-- per the 'Unboxed' instance of the type.
444+-- | Allocates a pinned empty array that can hold 'count' items. The memory of
445+-- the array is uninitialized and the allocation is aligned as per the
446+-- 'Unboxed' instance of the type.
545447--
546448-- /Pre-release/
547449{-# INLINE pinnedNewBytes #-}
548−{-# DEPRECATED pinnedNewBytes "Please use pinnedEmptyOf with appropriate calculation" #-}
549450pinnedNewBytes :: MonadIO m =>
550451#ifdef DEVBUILD
551452 Unbox a =>
@@ -570,31 +471,21 @@ newAs ps =
570471 (error "new: alignment is not used in unpinned arrays.")
571472
572473-- XXX can unaligned allocation be more efficient when alignment is not needed?
573−
574−-- | Allocates a pinned array of zero length but growable to the specified
575−-- capacity without reallocation.
576−{-# INLINE pinnedEmptyOf #-}
577−pinnedEmptyOf :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a)
578−pinnedEmptyOf = newAs Pinned
579−
580−-- XXX Deprecate in major
581−-- {-# DEPRECATED pinnedNew "Please use pinnedEmptyOf instead." #-}
474+--
475+-- | Allocates an empty pinned array that can hold 'count' items. The memory of
476+-- the array is uninitialized and the allocation is aligned as per the 'Unboxed'
477+-- instance of the type.
478+--
582479{-# INLINE pinnedNew #-}
583480pinnedNew :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a)
584−pinnedNew = pinnedEmptyOf
481+pinnedNew = newAs Pinned
585482
586−-- | Allocates an unpinned array of zero length but growable to the specified
587−-- capacity without reallocation.
483+-- | Allocates an empty unpinned array that can hold 'count' items. The memory
484+-- of the array is uninitialized.
588485--
589−{-# INLINE emptyOf #-}
590−emptyOf :: (MonadIO m, Unbox a) => Int -> m (MutArray a)
591−emptyOf = newAs Unpinned
592−
593−-- XXX Deprecate in major
594−-- {-# DEPRECATED new "Please use emptyOf instead." #-}
595486{-# INLINE new #-}
596487new :: (MonadIO m, Unbox a) => Int -> m (MutArray a)
597−new = emptyOf
488+new = newAs Unpinned
598489
599490-------------------------------------------------------------------------------
600491-- Random writes
@@ -610,7 +501,7 @@ putIndexUnsafe :: forall m a. (MonadIO m, Unbox a)
610501putIndexUnsafe i MutArray{..} x = do
611502 let index = INDEX_OF(arrStart, i, a)
612503 assert (i >= 0 && INDEX_VALID(index, arrEnd, a)) (return ())
613− liftIO $ pokeAt index arrContents x
504+ liftIO $ pokeByteIndex index arrContents x
614505
615506invalidIndex :: String -> Int -> a
616507invalidIndex label i =
@@ -628,7 +519,7 @@ putIndex :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> a -> m ()
628519putIndex i MutArray{..} x = do
629520 let index = INDEX_OF(arrStart,i,a)
630521 if i >= 0 && INDEX_VALID(index,arrEnd,a)
631− then liftIO $ pokeAt index arrContents x
522+ then liftIO $ pokeByteIndex index arrContents x
632523 else invalidIndex "putIndex" i
633524
634525-- | Write an input stream of (index, value) pairs to an array. Throws an
@@ -642,7 +533,7 @@ putIndices arr = FL.foldlM' step (return ())
642533
643534 where
644535
645− step () (i, x) = putIndex i arr x
536+ step () (i, x) = liftIO (putIndex i arr x)
646537
647538-- | Modify a given index of an array using a modifier function.
648539--
@@ -654,9 +545,9 @@ modifyIndexUnsafe :: forall m a b. (MonadIO m, Unbox a) =>
654545modifyIndexUnsafe i MutArray{..} f = liftIO $ do
655546 let index = INDEX_OF(arrStart,i,a)
656547 assert (i >= 0 && INDEX_NEXT(index,a) <= arrEnd) (return ())
657− r <- peekAt index arrContents
548+ r <- peekByteIndex index arrContents
658549 let (x, res) = f r
659− pokeAt index arrContents x
550+ pokeByteIndex index arrContents x
660551 return res
661552
662553-- | Modify a given index of an array using a modifier function.
@@ -668,9 +559,9 @@ modifyIndex i MutArray{..} f = do
668559 let index = INDEX_OF(arrStart,i,a)
669560 if i >= 0 && INDEX_VALID(index,arrEnd,a)
670561 then liftIO $ do
671− r <- peekAt index arrContents
562+ r <- peekByteIndex index arrContents
672563 let (x, res) = f r
673− pokeAt index arrContents x
564+ pokeByteIndex index arrContents x
674565 return res
675566 else invalidIndex "modifyIndex" i
676567
@@ -704,8 +595,8 @@ modify MutArray{..} f = liftIO $
704595
705596 go i =
706597 when (INDEX_VALID(i,arrEnd,a)) $ do
707− r <- peekAt i arrContents
708− pokeAt i arrContents (f r)
598+ r <- peekByteIndex i arrContents
599+ pokeByteIndex i arrContents (f r)
709600 go (INDEX_NEXT(i,a))
710601
711602-- XXX We could specify the number of bytes to swap instead of Proxy. Need
@@ -714,15 +605,15 @@ modify MutArray{..} f = liftIO $
714605swapArrayByteIndices ::
715606 forall a. Unbox a
716607 => Proxy a
717− -> MutByteArray
608+ -> MutableByteArray
718609 -> Int
719610 -> Int
720611 -> IO ()
721612swapArrayByteIndices _ arrContents i1 i2 = do
722− r1 <- peekAt i1 arrContents
723− r2 <- peekAt i2 arrContents
724− pokeAt i1 arrContents (r2 :: a)
725− pokeAt i2 arrContents (r1 :: a)
613+ r1 <- peekByteIndex i1 arrContents
614+ r2 <- peekByteIndex i2 arrContents
615+ pokeByteIndex i1 arrContents (r2 :: a)
616+ pokeByteIndex i2 arrContents (r1 :: a)
726617
727618-- | Swap the elements at two indices without validating the indices.
728619--
@@ -838,23 +729,26 @@ arrayChunkBytes = 1024
838729roundDownTo :: Int -> Int -> Int
839730roundDownTo elemSize size = size - (size `mod` elemSize)
840731
732+-- XXX See if resizing can be implemented by reading the old array as a stream
733+-- and then using writeN to the new array.
734+--
841735-- NOTE: we are passing elemSize explicitly to avoid an Unboxed constraint.
842736-- Since this is not inlined Unboxed consrraint leads to dictionary passing
843737-- which complicates some inspection tests.
844738--
845−{-# NOINLINE reallocExplicitAs #-}
846−reallocExplicitAs :: PinnedState -> Int -> Int -> MutArray a -> IO (MutArray a)
847−reallocExplicitAs ps elemSize newCapacityInBytes MutArray{..} = do
739+{-# NOINLINE reallocExplicit #-}
740+reallocExplicit :: Int -> Int -> MutArray a -> IO (MutArray a)
741+reallocExplicit elemSize newCapacityInBytes MutArray{..} = do
848742 assertM(arrEnd <= arrBound)
849743
850744 -- Allocate new array
851745 let newCapMaxInBytes = roundUpLargeArray newCapacityInBytes
852746 contents <-
853− if ps == Pinned
854− then Unboxed.pinnedNew newCapMaxInBytes
855− else Unboxed.new newCapMaxInBytes
856− let !(MutByteArray mbarrFrom#) = arrContents
857− !(MutByteArray mbarrTo#) = contents
747+ if Unboxed.isPinned arrContents
748+ then Unboxed.pinnedNewBytes newCapMaxInBytes
749+ else Unboxed.newBytes newCapMaxInBytes
750+ let !(MutableByteArray mbarrFrom#) = arrContents
751+ !(MutableByteArray mbarrTo#) = contents
858752
859753 -- Copy old data
860754 let oldStart = arrStart
@@ -875,10 +769,6 @@ reallocExplicitAs ps elemSize newCapacityInBytes MutArray{..} = do
875769 , arrBound = newCapInBytes
876770 }
877771
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.
881−
882772-- | @realloc newCapacity array@ reallocates the array to the specified
883773-- capacity in bytes.
884774--
@@ -890,12 +780,7 @@ reallocExplicitAs ps elemSize newCapacityInBytes MutArray{..} = do
890780-- If the original array is pinned, the newly allocated array is also pinned.
891781{-# INLINABLE realloc #-}
892782realloc :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (MutArray a)
893−realloc bytes arr =
894− let ps =
895− if isPinned arr
896− then Pinned
897− else Unpinned
898− in liftIO $ reallocExplicitAs ps (SIZE_OF(a)) bytes arr
783+realloc bytes arr = liftIO $ reallocExplicit (SIZE_OF(a)) bytes arr
899784
900785-- | @reallocWith label capSizer minIncrBytes array@. The label is used
901786-- in error messages and the capSizer is used to determine the capacity of the
@@ -918,14 +803,14 @@ reallocWith label capSizer minIncrBytes arr = do
918803 where
919804
920805 badSize newSize =
921− Prelude.concat
806+ concat
922807 [ label
923808 , ": new array size (in bytes) is less than required size "
924809 , show newSize
925810 , ". Please check the sizing function passed."
926811 ]
927812
928−-- | @grow newCapacity array@ changes the total capacity of the array so that
813+-- | @resize newCapacity array@ changes the total capacity of the array so that
929814-- it is enough to hold the specified number of elements. Nothing is done if
930815-- the specified capacity is less than the length of the array.
931816--
@@ -933,46 +818,34 @@ reallocWith label capSizer minIncrBytes arr = do
933818-- the block size (4K).
934819--
935820-- /Pre-release/
936−{-# INLINE grow #-}
937−grow :: forall m a. (MonadIO m, Unbox a) =>
821+{-# INLINE resize #-}
822+resize :: forall m a. (MonadIO m, Unbox a) =>
938823 Int -> MutArray a -> m (MutArray a)
939−grow nElems arr@MutArray{..} = do
824+resize nElems arr@MutArray{..} = do
940825 let req = SIZE_OF(a) * nElems
941− cap = arrBound - arrStart
942− if req < cap
826+ len = arrEnd - arrStart
827+ if req < len
943828 then return arr
944829 else realloc req arr
945830
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)
950−resize = grow
951−
952−-- | Like 'grow' but if the requested byte capacity is more than
953−-- 'largeObjectThreshold' then it is rounded up to the closest power of 2.
831+-- | Like 'resize' but if the byte capacity is more than 'largeObjectThreshold'
832+-- then it is rounded up to the closest power of 2.
954833--
955834-- /Pre-release/
956−{-# INLINE growExp #-}
957−growExp :: forall m a. (MonadIO m, Unbox a) =>
835+{-# INLINE resizeExp #-}
836+resizeExp :: forall m a. (MonadIO m, Unbox a) =>
958837 Int -> MutArray a -> m (MutArray a)
959−growExp nElems arr@MutArray{..} = do
838+resizeExp nElems arr@MutArray{..} = do
960839 let req = roundUpLargeArray (SIZE_OF(a) * nElems)
961840 req1 =
962841 if req > largeObjectThreshold
963842 then roundUpToPower2 req
964843 else req
965− cap = arrBound - arrStart
966− if req1 < cap
844+ len = arrEnd - arrStart
845+ if req1 < len
967846 then return arr
968847 else realloc req1 arr
969848
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)
974−resizeExp = growExp
975−
976849-- | Resize the allocated memory to drop any reserved free space at the end of
977850-- the array and reallocate it to reduce wastage.
978851--
@@ -1017,7 +890,7 @@ rightSize arr@MutArray{..} = do
1017890snocNewEnd :: (MonadIO m, Unbox a) => Int -> MutArray a -> a -> m (MutArray a)
1018891snocNewEnd newEnd arr@MutArray{..} x = liftIO $ do
1019892 assert (newEnd <= arrBound) (return ())
1020− pokeAt arrEnd arrContents x
893+ pokeByteIndex arrEnd arrContents x
1021894 return $ arr {arrEnd = newEnd}
1022895
1023896-- | Really really unsafe, appends the element into the first array, may
@@ -1037,7 +910,7 @@ snocUnsafe arr@MutArray{..} = snocNewEnd (INDEX_NEXT(arrEnd,a)) arr
1037910{-# INLINE snocMay #-}
1038911snocMay :: forall m a. (MonadIO m, Unbox a) =>
1039912 MutArray a -> a -> m (Maybe (MutArray a))
1040−snocMay arr@MutArray{..} x = do
913+snocMay arr@MutArray{..} x = liftIO $ do
1041914 let newEnd = INDEX_NEXT(arrEnd,a)
1042915 if newEnd <= arrBound
1043916 then Just <$> snocNewEnd newEnd arr x
@@ -1051,7 +924,7 @@ snocWithRealloc :: forall m a. (MonadIO m, Unbox a) =>
1051924 -> a
1052925 -> m (MutArray a)
1053926snocWithRealloc sizer arr x = do
1054− arr1 <- reallocWith "snocWith" sizer (SIZE_OF(a)) arr
927+ arr1 <- liftIO $ reallocWith "snocWith" sizer (SIZE_OF(a)) arr
1055928 snocUnsafe arr1 x
1056929
1057930-- | @snocWith sizer arr elem@ mutates @arr@ to append @elem@. The length of
@@ -1073,7 +946,7 @@ snocWith :: forall m a. (MonadIO m, Unbox a) =>
1073946 -> MutArray a
1074947 -> a
1075948 -> m (MutArray a)
1076−snocWith allocSize arr x = do
949+snocWith allocSize arr x = liftIO $ do
1077950 let newEnd = INDEX_NEXT(arrEnd arr,a)
1078951 if newEnd <= arrBound arr
1079952 then snocNewEnd newEnd arr x
@@ -1117,126 +990,6 @@ snoc = snocWith f
1117990 then oldSize * 2
1118991 else roundUpToPower2 oldSize * 2
1119992
1120−-------------------------------------------------------------------------------
1121−-- Serialization/Deserialization
1122−-------------------------------------------------------------------------------
1123−
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}
1131−
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
1135−-- element.
1136−--
1137−-- /Internal/
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
1142−
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})
1150−
1151−-- | Like 'pokeAppend' but does not grow the array when pre-allocated array
1152−-- capacity becomes full.
1153−--
1154−-- /Internal/
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
1163−
1164−{-# NOINLINE pokeWithRealloc #-}
1165−pokeWithRealloc :: forall m a. (MonadIO m, Unbox a) =>
1166− (Int -> Int)
1167− -> MutArray Word8
1168− -> 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
1173−
1174−{-# INLINE pokeAppendWith #-}
1175−pokeAppendWith :: forall m a. (MonadIO m, Unbox a) =>
1176− (Int -> Int)
1177− -> MutArray Word8
1178− -> 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
1185−
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.
1188−--
1189−-- Definition:
1190−--
1191−-- >>> pokeAppend arr x = MutArray.castUnsafe <$> MutArray.snoc (MutArray.castUnsafe arr) x
1192−--
1193−{-# INLINE pokeAppend #-}
1194−pokeAppend :: forall m a. (MonadIO m, Unbox a) =>
1195− MutArray Word8 -> a -> m (MutArray Word8)
1196−pokeAppend = pokeAppendWith f
1197−
1198− where
1199−
1200− f oldSize =
1201− if isPower2 oldSize
1202− then oldSize * 2
1203− else roundUpToPower2 oldSize * 2
1204−
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.
1208−--
1209−-- /Internal/
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 ())
1216− liftIO $ do
1217− r <- peekAt arrStart arrContents
1218− return (r, MutArray arrContents start1 arrEnd arrBound)
1219−
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)
1226−
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)
1234− if start1 > arrEnd
1235− then return (Nothing, arr)
1236− else liftIO $ do
1237− r <- peekAt arrStart arrContents
1238− return (Just r, MutArray arrContents start1 arrEnd arrBound)
1239−
1240993-------------------------------------------------------------------------------
1241994-- Random reads
1242995-------------------------------------------------------------------------------
@@ -1251,7 +1004,7 @@ getIndexUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m a
12511004getIndexUnsafe i MutArray{..} = do
12521005 let index = INDEX_OF(arrStart,i,a)
12531006 assert (i >= 0 && INDEX_VALID(index,arrEnd,a)) (return ())
1254− liftIO $ peekAt index arrContents
1007+ liftIO $ peekByteIndex index arrContents
12551008
12561009-- | /O(1)/ Lookup the element at the given index. Index starts from 0.
12571010--
@@ -1260,7 +1013,7 @@ getIndex :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (Maybe a)
12601013getIndex i MutArray{..} = do
12611014 let index = INDEX_OF(arrStart,i,a)
12621015 if i >= 0 && INDEX_VALID(index,arrEnd,a)
1263− then liftIO $ Just <$> peekAt index arrContents
1016+ then liftIO $ Just <$> peekByteIndex index arrContents
12641017 else return Nothing
12651018
12661019-- | /O(1)/ Lookup the element at the given index from the end of the array.
@@ -1273,16 +1026,21 @@ getIndexRev :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m a
12731026getIndexRev i MutArray{..} = do
12741027 let index = RINDEX_OF(arrEnd,i,a)
12751028 if i >= 0 && index >= arrStart
1276− then liftIO $ peekAt index arrContents
1029+ then liftIO $ peekByteIndex index arrContents
12771030 else invalidIndex "getIndexRev" i
12781031
12791032data GetIndicesState contents start end st =
12801033 GetIndicesState contents start end st
12811034
1282−{-# INLINE indexReaderWith #-}
1283−indexReaderWith :: (Monad m, Unbox a) =>
1035+-- | Given an unfold that generates array indices, read the elements on those
1036+-- indices from the supplied MutArray. An error is thrown if an index is out of
1037+-- bounds.
1038+--
1039+-- /Pre-release/
1040+{-# INLINE getIndicesD #-}
1041+getIndicesD :: (Monad m, Unbox a) =>
12841042 (forall b. IO b -> m b) -> D.Stream m Int -> Unfold m (MutArray a) a
1285−indexReaderWith liftio (D.Stream stepi sti) = Unfold step inject
1043+getIndicesD liftio (D.Stream stepi sti) = Unfold step inject
12861044
12871045 where
12881046
@@ -1301,26 +1059,9 @@ indexReaderWith liftio (D.Stream stepi sti) = Unfold step inject
13011059 D.Skip s -> return $ D.Skip (GetIndicesState contents start end s)
13021060 D.Stop -> return D.Stop
13031061
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
1309−
1310−-- | Given an unfold that generates array indices, read the elements on those
1311−-- indices from the supplied MutArray. An error is thrown if an index is out of
1312−-- bounds.
1313−--
1314−-- /Pre-release/
1315−{-# INLINE indexReader #-}
1316−indexReader :: (MonadIO m, Unbox a) => Stream m Int -> Unfold m (MutArray a) a
1317−indexReader = indexReaderWith liftIO
1318−
1319−-- XXX DO NOT REMOVE, change the signature to use Stream instead of unfold
1320−{-# DEPRECATED getIndices "Please use indexReader instead." #-}
13211062{-# INLINE getIndices #-}
13221063getIndices :: (MonadIO m, Unbox a) => Stream m Int -> Unfold m (MutArray a) a
1323−getIndices = indexReader
1064+getIndices = getIndicesD liftIO
13241065
13251066-------------------------------------------------------------------------------
13261067-- Subarrays
@@ -1425,7 +1166,7 @@ partitionBy f arr@MutArray{..} = liftIO $ do
14251166
14261167 -- Invariant low < high on entry, and on return as well
14271168 moveHigh low high = do
1428− h <- peekAt high arrContents
1169+ h <- peekByteIndex high arrContents
14291170 if f h
14301171 then
14311172 -- Correctly classified, continue the loop
@@ -1445,7 +1186,7 @@ partitionBy f arr@MutArray{..} = liftIO $ do
14451186 -- low <= high
14461187 -- Both low and high are valid locations within the array
14471188 go low high = do
1448− l <- peekAt low arrContents
1189+ l <- peekByteIndex low arrContents
14491190 if f l
14501191 then
14511192 -- low is wrongly classified
@@ -1456,8 +1197,8 @@ partitionBy f arr@MutArray{..} = liftIO $ do
14561197 case r of
14571198 Nothing -> return low
14581199 Just (high1, h) -> do -- low < high1
1459− pokeAt low arrContents h
1460− pokeAt high1 arrContents l
1200+ pokeByteIndex low arrContents h
1201+ pokeByteIndex high1 arrContents l
14611202 let low1 = INDEX_NEXT(low,a)
14621203 high2 = INDEX_PREV(high1,a)
14631204 if low1 <= high2
@@ -1591,7 +1332,7 @@ chunksOfAs ps n (D.Stream step state) =
15911332 r <- step (adaptState gst) st
15921333 case r of
15931334 D.Yield x s -> do
1594− liftIO $ pokeAt end contents x
1335+ liftIO $ pokeByteIndex end contents x
15951336 let end1 = INDEX_NEXT(end,a)
15961337 return $
15971338 if end1 >= bound
@@ -1610,12 +1351,10 @@ chunksOfAs ps n (D.Stream step state) =
16101351
16111352 step' _ GroupFinish = return D.Stop
16121353
1613−-- | @chunksOf n stream@ groups the elements in the input stream into arrays of
1614−-- @n@ elements each.
1615−--
1616−-- Same as the following but may be more efficient:
1354+-- | @chunksOf n stream@ groups the input stream into a stream of
1355+-- arrays of size n.
16171356--
1618−-- >>> chunksOf n = Stream.foldMany (MutArray.createOf n)
1357+-- @chunksOf n = StreamD.foldMany (MutArray.writeN n)@
16191358--
16201359-- /Pre-release/
16211360{-# INLINE_NORMAL chunksOf #-}
@@ -1624,29 +1363,17 @@ chunksOf :: forall m a. (MonadIO m, Unbox a)
16241363-- XXX the idiomatic implementation leads to large regression in the D.reverse'
16251364-- benchmark. It seems it has difficulty producing optimized code when
16261365-- converting to StreamK. Investigate GHC optimizations.
1627−-- chunksOf n = D.foldMany (createOf n)
1366+-- chunksOf n = D.foldMany (writeN n)
16281367chunksOf = chunksOfAs Unpinned
16291368
16301369-- | Like 'chunksOf' but creates pinned arrays.
16311370{-# INLINE_NORMAL pinnedChunksOf #-}
16321371pinnedChunksOf :: forall m a. (MonadIO m, Unbox a)
16331372 => Int -> D.Stream m a -> D.Stream m (MutArray a)
1634−-- pinnedChunksOf n = D.foldMany (pinnedCreateOf n)
1373+-- pinnedChunksOf n = D.foldMany (pinnedWriteN n)
16351374pinnedChunksOf = chunksOfAs Pinned
16361375
1637−-- | When we are buffering a stream of unknown size into an array we do not
1638−-- know how much space to pre-allocate. So we start with the min size and emit
1639−-- the array then keep on doubling the size every time. Thus we do not need to
1640−-- guess the optimum chunk size.
1641−--
1642−-- We can incorporate this in chunksOfAs if the additional size parameter does
1643−-- not impact perf.
1644−--
1645−{-# INLINE _chunksOfRange #-}
1646−_chunksOfRange :: -- (MonadIO m, Unbox a) =>
1647− PinnedState -> Int -> Int -> D.Stream m a -> D.Stream m (MutArray a)
1648−_chunksOfRange _ps _low _hi = undefined
1649−
1376+-- XXX This should take a PinnedState
16501377-- XXX buffer to a list instead?
16511378-- | Buffer the stream into arrays in memory.
16521379{-# INLINE arrayStreamKFromStreamDAs #-}
@@ -1664,10 +1391,16 @@ data FlattenState s contents a =
16641391 OuterLoop s
16651392 | InnerLoop s contents !Int !Int
16661393
1667−{-# INLINE_NORMAL concatWith #-}
1668−concatWith :: forall m a. (Monad m, Unbox a)
1669− => (forall b. IO b -> m b) -> D.Stream m (MutArray a) -> D.Stream m a
1670−concatWith liftio (D.Stream step state) = D.Stream step' (OuterLoop state)
1394+-- | Use the "reader" unfold instead.
1395+--
1396+-- @flattenArrays = unfoldMany reader@
1397+--
1398+-- We can try this if there are any fusion issues in the unfold.
1399+--
1400+{-# INLINE_NORMAL flattenArrays #-}
1401+flattenArrays :: forall m a. (MonadIO m, Unbox a)
1402+ => D.Stream m (MutArray a) -> D.Stream m a
1403+flattenArrays (D.Stream step state) = D.Stream step' (OuterLoop state)
16711404
16721405 where
16731406
@@ -1684,30 +1417,19 @@ concatWith liftio (D.Stream step state) = D.Stream step' (OuterLoop state)
16841417 return $ D.Skip $ OuterLoop st
16851418
16861419 step' _ (InnerLoop st contents p end) = do
1687− x <- liftio $ peekAt p contents
1420+ x <- liftIO $ peekByteIndex p contents
16881421 return $ D.Yield x (InnerLoop st contents (INDEX_NEXT(p,a)) end)
16891422
1690−-- | Use the "reader" unfold instead.
1423+-- | Use the "readerRev" unfold instead.
16911424--
1692−-- @concat = unfoldMany reader@
1425+-- @flattenArrays = unfoldMany readerRev@
16931426--
16941427-- We can try this if there are any fusion issues in the unfold.
16951428--
1696−{-# INLINE_NORMAL concat #-}
1697−concat :: forall m a. (MonadIO m, Unbox a)
1698− => D.Stream m (MutArray a) -> D.Stream m a
1699−concat = concatWith liftIO
1700−
1701−{-# DEPRECATED flattenArrays "Please use \"unfoldMany reader\" instead." #-}
1702−{-# INLINE flattenArrays #-}
1703−flattenArrays :: forall m a. (MonadIO m, Unbox a)
1429+{-# INLINE_NORMAL flattenArraysRev #-}
1430+flattenArraysRev :: forall m a. (MonadIO m, Unbox a)
17041431 => D.Stream m (MutArray a) -> D.Stream m a
1705−flattenArrays = concat
1706−
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
1710−concatRevWith liftio (D.Stream step state) = D.Stream step' (OuterLoop state)
1432+flattenArraysRev (D.Stream step state) = D.Stream step' (OuterLoop state)
17111433
17121434 where
17131435
@@ -1725,33 +1447,16 @@ concatRevWith liftio (D.Stream step state) = D.Stream step' (OuterLoop state)
17251447 return $ D.Skip $ OuterLoop st
17261448
17271449 step' _ (InnerLoop st contents p start) = do
1728− x <- liftio $ peekAt p contents
1450+ x <- liftIO $ peekByteIndex p contents
17291451 let cur = INDEX_PREV(p,a)
17301452 return $ D.Yield x (InnerLoop st contents cur start)
17311453
1732−-- | Use the "readerRev" unfold instead.
1733−--
1734−-- @concat = unfoldMany readerRev@
1735−--
1736−-- We can try this if there are any fusion issues in the unfold.
1737−--
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
1742−
1743−{-# DEPRECATED flattenArraysRev "Please use \"unfoldMany readerRev\" instead." #-}
1744−{-# INLINE flattenArraysRev #-}
1745−flattenArraysRev :: forall m a. (MonadIO m, Unbox a)
1746− => D.Stream m (MutArray a) -> D.Stream m a
1747−flattenArraysRev = concatRev
1748−
17491454-------------------------------------------------------------------------------
17501455-- Unfolds
17511456-------------------------------------------------------------------------------
17521457
17531458data ArrayUnsafe a = ArrayUnsafe
1754− {-# UNPACK #-} !MutByteArray -- contents
1459+ {-# UNPACK #-} !MutableByteArray -- contents
17551460 {-# UNPACK #-} !Int -- index 1
17561461 {-# UNPACK #-} !Int -- index 2
17571462
@@ -1781,7 +1486,7 @@ producerWith liftio = Producer step (return . toArrayUnsafe) extract
17811486 -- few actions for correctness and execution order sanity. We want
17821487 -- the peek to occur right here and not lazily at some later point
17831488 -- because we want the peek to be ordered with respect to the touch.
1784− !x <- liftio $ peekAt cur contents
1489+ !x <- liftio $ peekByteIndex cur contents
17851490 return $ D.Yield x (ArrayUnsafe contents (INDEX_NEXT(cur,a)) end)
17861491
17871492 extract = return . fromArrayUnsafe
@@ -1812,7 +1517,7 @@ readerRevWith liftio = Unfold step inject
18121517 {-# INLINE_LATE step #-}
18131518 step (ArrayUnsafe _ start p) | p < start = return D.Stop
18141519 step (ArrayUnsafe contents start p) = do
1815− !x <- liftio $ peekAt p contents
1520+ !x <- liftio $ peekByteIndex p contents
18161521 return $ D.Yield x (ArrayUnsafe contents start (INDEX_PREV(p,a)))
18171522
18181523-- | Unfold an array into a stream in reverse order.
@@ -1843,7 +1548,7 @@ toListFB c n MutArray{..} = go arrStart
18431548 -- evaluated/written to before we peek at them.
18441549 -- XXX
18451550 let !x = unsafeInlineIO $ do
1846− r <- peekAt arrContents p
1551+ r <- peekByteIndex arrContents p
18471552 return r
18481553 in c x (go (PTR_NEXT(p,a)))
18491554-}
@@ -1860,21 +1565,21 @@ toList MutArray{..} = liftIO $ go arrStart
18601565
18611566 go p | assert (p <= arrEnd) (p == arrEnd) = return []
18621567 go p = do
1863− x <- peekAt p arrContents
1568+ x <- peekByteIndex p arrContents
18641569 (:) x <$> go (INDEX_NEXT(p,a))
18651570
1866−{-# INLINE_NORMAL toStreamWith #-}
1867−toStreamWith ::
1571+{-# INLINE_NORMAL toStreamDWith #-}
1572+toStreamDWith ::
18681573 forall m a. (Monad m, Unbox a)
18691574 => (forall b. IO b -> m b) -> MutArray a -> D.Stream m a
1870−toStreamWith liftio MutArray{..} = D.Stream step arrStart
1575+toStreamDWith liftio MutArray{..} = D.Stream step arrStart
18711576
18721577 where
18731578
18741579 {-# INLINE_LATE step #-}
18751580 step _ p | assert (p <= arrEnd) (p == arrEnd) = return D.Stop
18761581 step _ p = liftio $ do
1877− r <- peekAt p arrContents
1582+ r <- peekByteIndex p arrContents
18781583 return $ D.Yield r (INDEX_NEXT(p,a))
18791584
18801585-- | Convert a 'MutArray' into a stream.
@@ -1883,7 +1588,7 @@ toStreamWith liftio MutArray{..} = D.Stream step arrStart
18831588--
18841589{-# INLINE_NORMAL read #-}
18851590read :: forall m a. (MonadIO m, Unbox a) => MutArray a -> D.Stream m a
1886−read = toStreamWith liftIO
1591+read = toStreamDWith liftIO
18871592
18881593{-# INLINE toStreamKWith #-}
18891594toStreamKWith ::
@@ -1895,18 +1600,18 @@ toStreamKWith liftio MutArray{..} = go arrStart
18951600
18961601 go p | assert (p <= arrEnd) (p == arrEnd) = K.nil
18971602 | otherwise =
1898− let elemM = peekAt p arrContents
1603+ let elemM = peekByteIndex p arrContents
18991604 in liftio elemM `K.consM` go (INDEX_NEXT(p,a))
19001605
19011606{-# INLINE toStreamK #-}
19021607toStreamK :: forall m a. (MonadIO m, Unbox a) => MutArray a -> StreamK m a
19031608toStreamK = toStreamKWith liftIO
19041609
1905−{-# INLINE_NORMAL toStreamRevWith #-}
1906−toStreamRevWith ::
1610+{-# INLINE_NORMAL toStreamDRevWith #-}
1611+toStreamDRevWith ::
19071612 forall m a. (Monad m, Unbox a)
19081613 => (forall b. IO b -> m b) -> MutArray a -> D.Stream m a
1909−toStreamRevWith liftio MutArray{..} =
1614+toStreamDRevWith liftio MutArray{..} =
19101615 let p = INDEX_PREV(arrEnd,a)
19111616 in D.Stream step p
19121617
@@ -1915,7 +1620,7 @@ toStreamRevWith liftio MutArray{..} =
19151620 {-# INLINE_LATE step #-}
19161621 step _ p | p < arrStart = return D.Stop
19171622 step _ p = liftio $ do
1918− r <- peekAt p arrContents
1623+ r <- peekByteIndex p arrContents
19191624 return $ D.Yield r (INDEX_PREV(p,a))
19201625
19211626-- | Convert a 'MutArray' into a stream in reverse order.
@@ -1924,7 +1629,7 @@ toStreamRevWith liftio MutArray{..} =
19241629--
19251630{-# INLINE_NORMAL readRev #-}
19261631readRev :: forall m a. (MonadIO m, Unbox a) => MutArray a -> D.Stream m a
1927−readRev = toStreamRevWith liftIO
1632+readRev = toStreamDRevWith liftIO
19281633
19291634{-# INLINE toStreamKRevWith #-}
19301635toStreamKRevWith ::
@@ -1938,7 +1643,7 @@ toStreamKRevWith liftio MutArray {..} =
19381643
19391644 go p | p < arrStart = K.nil
19401645 | otherwise =
1941− let elemM = peekAt p arrContents
1646+ let elemM = peekByteIndex p arrContents
19421647 in liftio elemM `K.consM` go (INDEX_PREV(p,a))
19431648
19441649{-# INLINE toStreamKRev #-}
@@ -1973,7 +1678,7 @@ foldr f z arr = D.foldr f z $ read arr
19731678
19741679-- XXX Keep the bound intact to not lose any free space? Perf impact?
19751680
1976−-- | @unsafeAppendN n arr@ appends up to @n@ input items to the supplied
1681+-- | @writeAppendNUnsafe n arr@ appends up to @n@ input items to the supplied
19771682-- array.
19781683--
19791684-- Unsafe: Do not drive the fold beyond @n@ elements, it will lead to memory
@@ -1982,12 +1687,13 @@ foldr f z arr = D.foldr f z $ read arr
19821687-- Any free space left in the array after appending @n@ elements is lost.
19831688--
19841689-- /Internal/
1985−{-# INLINE_NORMAL unsafeAppendN #-}
1986−unsafeAppendN :: forall m a. (MonadIO m, Unbox a) =>
1690+{-# INLINE_NORMAL writeAppendNUnsafe #-}
1691+writeAppendNUnsafe :: forall m a. (MonadIO m, Unbox a) =>
19871692 Int
19881693 -> m (MutArray a)
19891694 -> Fold m a (MutArray a)
1990−unsafeAppendN n action = fmap fromArrayUnsafe $ FL.foldlM' step initial
1695+writeAppendNUnsafe n action =
1696+ fmap fromArrayUnsafe $ FL.foldlM' step initial
19911697
19921698 where
19931699
@@ -2000,59 +1706,38 @@ unsafeAppendN n action = fmap fromArrayUnsafe $ FL.foldlM' step initial
20001706 -- otherwise we lose that space.
20011707 arr1 <-
20021708 if free < needed
2003− then noinline reallocWith "unsafeAppendN" (+ needed) needed arr
1709+ then noinline reallocWith "writeAppendNUnsafeWith" (+ needed) needed arr
20041710 else return arr
20051711 return $ toArrayUnsafe arr1
20061712
20071713 step (ArrayUnsafe contents start end) x = do
2008− liftIO $ pokeAt end contents x
1714+ liftIO $ pokeByteIndex end contents x
20091715 return $ ArrayUnsafe contents start (INDEX_NEXT(end,a))
20101716
2011−{-# DEPRECATED writeAppendNUnsafe "Please use unsafeAppendN instead." #-}
2012−{-# INLINE writeAppendNUnsafe #-}
2013−writeAppendNUnsafe :: forall m a. (MonadIO m, Unbox a) =>
2014− Int
2015− -> m (MutArray a)
2016− -> Fold m a (MutArray a)
2017−writeAppendNUnsafe = unsafeAppendN
2018−
20191717-- | Append @n@ elements to an existing array. Any free space left in the array
20201718-- after appending @n@ elements is lost.
20211719--
2022−-- >>> appendN n initial = Fold.take n (MutArray.unsafeAppendN n initial)
1720+-- >>> writeAppendN n initial = Fold.take n (MutArray.writeAppendNUnsafe n initial)
20231721--
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)
2028−
2029−-- XXX Deprecate in major
2030−-- {-# DEPRECATED writeAppendN "Please use appendN instead." #-}
2031−{-# INLINE writeAppendN #-}
1722+{-# INLINE_NORMAL writeAppendN #-}
20321723writeAppendN :: forall m a. (MonadIO m, Unbox a) =>
20331724 Int -> m (MutArray a) -> Fold m a (MutArray a)
2034−writeAppendN = appendN
1725+writeAppendN n initial = FL.take n (writeAppendNUnsafe n initial)
20351726
2036−-- | @appendWith realloc action@ mutates the array generated by @action@ to
1727+-- | @writeAppendWith realloc action@ mutates the array generated by @action@ to
20371728-- append the input stream. If there is no reserved space available in the
20381729-- array it is reallocated to a size in bytes determined by @realloc oldSize@,
20391730-- where @oldSize@ is the current size of the array in bytes.
20401731--
20411732-- Note that the returned array may be a mutated version of original array.
20421733--
2043−-- >>> appendWith sizer = Fold.foldlM' (MutArray.snocWith sizer)
1734+-- >>> writeAppendWith sizer = Fold.foldlM' (MutArray.snocWith sizer)
20441735--
20451736-- /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)
2050−
2051−{-# DEPRECATED writeAppendWith "Please use appendWith instead." #-}
20521737{-# INLINE writeAppendWith #-}
20531738writeAppendWith :: forall m a. (MonadIO m, Unbox a) =>
20541739 (Int -> Int) -> m (MutArray a) -> Fold m a (MutArray a)
2055−writeAppendWith = appendWith
1740+writeAppendWith sizer = FL.foldlM' (snocWith sizer)
20561741
20571742-- | @append action@ mutates the array generated by @action@ to append the
20581743-- input stream. If there is no reserved space available in the array it is
@@ -2060,101 +1745,70 @@ writeAppendWith = appendWith
20601745--
20611746-- Note that the returned array may be a mutated version of original array.
20621747--
2063−-- >>> append = MutArray.appendWith (* 2)
1748+-- >>> writeAppend = MutArray.writeAppendWith (* 2)
20641749--
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)
2069−
2070−-- XXX Deprecate in major
2071−-- {-# DEPRECATED writeAppend "Please use append instead." #-}
20721750{-# INLINE writeAppend #-}
20731751writeAppend :: forall m a. (MonadIO m, Unbox a) =>
20741752 m (MutArray a) -> Fold m a (MutArray a)
2075−writeAppend = append
1753+writeAppend = writeAppendWith (* 2)
20761754
20771755-- XXX We can carry bound as well in the state to make sure we do not lose the
20781756-- remaining capacity. Need to check perf impact.
20791757--
2080−-- | Like 'unsafeCreateOf' but takes a new array allocator @alloc size@
2081−-- function as argument.
1758+-- | Like 'writeNUnsafe' but takes a new array allocator @alloc size@ function
1759+-- as argument.
20821760--
2083−-- >>> unsafeCreateOfWith alloc n = MutArray.unsafeAppendN (alloc n) n
1761+-- >>> writeNWithUnsafe alloc n = MutArray.writeAppendNUnsafe (alloc n) n
20841762--
20851763-- /Pre-release/
2086−{-# INLINE_NORMAL unsafeCreateOfWith #-}
2087−unsafeCreateOfWith :: forall m a. (MonadIO m, Unbox a)
1764+{-# INLINE_NORMAL writeNWithUnsafe #-}
1765+writeNWithUnsafe :: forall m a. (MonadIO m, Unbox a)
20881766 => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
2089−unsafeCreateOfWith alloc n = fromArrayUnsafe <$> FL.foldlM' step initial
1767+writeNWithUnsafe alloc n = fromArrayUnsafe <$> FL.foldlM' step initial
20901768
20911769 where
20921770
20931771 initial = toArrayUnsafe <$> alloc (max n 0)
20941772
20951773 step (ArrayUnsafe contents start end) x = do
2096− liftIO $ pokeAt end contents x
1774+ liftIO $ pokeByteIndex end contents x
20971775 return
20981776 $ ArrayUnsafe contents start (INDEX_NEXT(end,a))
20991777
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
2105−
21061778{-# INLINE_NORMAL writeNUnsafeAs #-}
21071779writeNUnsafeAs :: forall m a. (MonadIO m, Unbox a)
21081780 => PinnedState -> Int -> Fold m a (MutArray a)
2109−writeNUnsafeAs ps = unsafeCreateOfWith (newAs ps)
1781+writeNUnsafeAs ps = writeNWithUnsafe (newAs ps)
21101782
2111−-- | Like 'createOf' but does not check the array bounds when writing. The fold
1783+-- | Like 'writeN' but does not check the array bounds when writing. The fold
21121784-- driver must not call the step function more than 'n' times otherwise it will
21131785-- corrupt the memory and crash. This function exists mainly because any
21141786-- conditional in the step function blocks fusion causing 10x performance
21151787-- slowdown.
21161788--
2117−-- >>> unsafeCreateOf = MutArray.unsafeCreateOfWith MutArray.emptyOf
1789+-- >>> writeNUnsafe = MutArray.writeNWithUnsafe MutArray.new
21181790--
2119−{-# INLINE_NORMAL unsafeCreateOf #-}
2120−unsafeCreateOf :: forall m a. (MonadIO m, Unbox a)
2121− => Int -> Fold m a (MutArray a)
2122−unsafeCreateOf = writeNUnsafeAs Unpinned
2123−
2124−{-# DEPRECATED writeNUnsafe "Please use unsafeCreateOf instead." #-}
2125−{-# INLINE writeNUnsafe #-}
1791+{-# INLINE_NORMAL writeNUnsafe #-}
21261792writeNUnsafe :: forall m a. (MonadIO m, Unbox a)
21271793 => Int -> Fold m a (MutArray a)
2128−writeNUnsafe = unsafeCreateOf
1794+writeNUnsafe = writeNUnsafeAs Unpinned
21291795
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
2135−
2136−{-# DEPRECATED pinnedWriteNUnsafe "Please use unsafePinnedCreateOf instead." #-}
2137−{-# INLINE pinnedWriteNUnsafe #-}
1796+-- | Like 'writeNUnsafe' but creates a pinned array.
1797+{-# INLINE_NORMAL pinnedWriteNUnsafe #-}
21381798pinnedWriteNUnsafe :: forall m a. (MonadIO m, Unbox a)
21391799 => Int -> Fold m a (MutArray a)
2140−pinnedWriteNUnsafe = unsafePinnedCreateOf
1800+pinnedWriteNUnsafe = writeNUnsafeAs Pinned
21411801
2142−-- | @createOfWith alloc n@ folds a maximum of @n@ elements into an array
1802+-- | @writeNWith alloc n@ folds a maximum of @n@ elements into an array
21431803-- allocated using the @alloc@ function.
21441804--
2145−-- >>> createOfWith alloc n = Fold.take n (MutArray.unsafeCreateOfWith alloc n)
2146−-- >>> createOfWith alloc n = MutArray.appendN (alloc n) n
1805+-- >>> writeNWith alloc n = Fold.take n (MutArray.writeNWithUnsafe alloc n)
1806+-- >>> writeNWith alloc n = MutArray.writeAppendN (alloc n) n
21471807--
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)
2152−
2153−-- {-# DEPRECATED writeNWith "Please use createOfWith instead." #-}
2154−{-# INLINE writeNWith #-}
1808+{-# INLINE_NORMAL writeNWith #-}
21551809writeNWith :: forall m a. (MonadIO m, Unbox a)
21561810 => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
2157−writeNWith = createOfWith
1811+writeNWith alloc n = FL.take n (writeNWithUnsafe alloc n)
21581812
21591813{-# INLINE_NORMAL writeNAs #-}
21601814writeNAs ::
@@ -2162,42 +1816,28 @@ writeNAs ::
21621816 => PinnedState
21631817 -> Int
21641818 -> Fold m a (MutArray a)
2165−writeNAs ps = createOfWith (newAs ps)
1819+writeNAs ps = writeNWith (newAs ps)
21661820
2167−-- | @createOf n@ folds a maximum of @n@ elements from the input stream to an
1821+-- | @writeN n@ folds a maximum of @n@ elements from the input stream to an
21681822-- 'MutArray'.
21691823--
2170−-- >>> createOf = MutArray.createOfWith MutArray.new
2171−-- >>> createOf n = Fold.take n (MutArray.unsafeCreateOf n)
2172−-- >>> createOf n = MutArray.appendN n (MutArray.emptyOf n)
1824+-- >>> writeN = MutArray.writeNWith MutArray.new
1825+-- >>> writeN n = Fold.take n (MutArray.writeNUnsafe n)
1826+-- >>> writeN n = MutArray.writeAppendN n (MutArray.new n)
21731827--
2174−{-# INLINE_NORMAL createOf #-}
2175−createOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
2176−createOf = writeNAs Unpinned
2177−
2178−-- XXX Deprecate in major
2179−-- {-# DEPRECATED writeN "Please use createOf instead." #-}
2180−{-# INLINE writeN #-}
1828+{-# INLINE_NORMAL writeN #-}
21811829writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
2182−writeN = createOf
2183−
2184−-- | Like 'createOf' but creates a pinned array.
2185−{-# INLINE_NORMAL pinnedCreateOf #-}
2186−pinnedCreateOf ::
2187− forall m a. (MonadIO m, Unbox a)
2188− => Int
2189− -> Fold m a (MutArray a)
2190−pinnedCreateOf = writeNAs Pinned
1830+writeN = writeNAs Unpinned
21911831
2192−{-# DEPRECATED pinnedWriteN "Please use pinnedCreateOf instead." #-}
2193−{-# INLINE pinnedWriteN #-}
1832+-- | Like 'writeN' but creates a pinned array.
1833+{-# INLINE_NORMAL pinnedWriteN #-}
21941834pinnedWriteN ::
21951835 forall m a. (MonadIO m, Unbox a)
21961836 => Int
21971837 -> Fold m a (MutArray a)
2198−pinnedWriteN = pinnedCreateOf
1838+pinnedWriteN = writeNAs Pinned
21991839
2200−-- | Like unsafeCreateOfWith but writes the array in reverse order.
1840+-- | Like writeNWithUnsafe but writes the array in reverse order.
22011841--
22021842-- /Internal/
22031843{-# INLINE_NORMAL writeRevNWithUnsafe #-}
@@ -2214,11 +1854,11 @@ writeRevNWithUnsafe alloc n = fromArrayUnsafe <$> FL.foldlM' step initial
22141854
22151855 step (ArrayUnsafe contents start end) x = do
22161856 let ptr = INDEX_PREV(start,a)
2217− liftIO $ pokeAt ptr contents x
1857+ liftIO $ pokeByteIndex ptr contents x
22181858 return
22191859 $ ArrayUnsafe contents ptr end
22201860
2221−-- | Like createOfWith but writes the array in reverse order.
1861+-- | Like writeNWith but writes the array in reverse order.
22221862--
22231863-- /Internal/
22241864{-# INLINE_NORMAL writeRevNWith #-}
@@ -2226,36 +1866,31 @@ writeRevNWith :: forall m a. (MonadIO m, Unbox a)
22261866 => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
22271867writeRevNWith alloc n = FL.take n (writeRevNWithUnsafe alloc n)
22281868
2229−-- | Like 'createOf' but writes the array in reverse order.
1869+-- | Like writeN but writes the array in reverse order.
22301870--
22311871-- /Pre-release/
2232−{-# INLINE_NORMAL revCreateOf #-}
2233−revCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
2234−revCreateOf = writeRevNWith new
2235−
2236−{-# DEPRECATED writeRevN "Please use revCreateOf instead." #-}
2237−{-# INLINE writeRevN #-}
1872+{-# INLINE_NORMAL writeRevN #-}
22381873writeRevN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
2239−writeRevN = revCreateOf
1874+writeRevN = writeRevNWith new
22401875
22411876-- | @pinnedWriteNAligned align n@ folds a maximum of @n@ elements from the
22421877-- input stream to a 'MutArray' aligned to the given size.
22431878--
2244−-- >>> pinnedWriteNAligned align = MutArray.createOfWith (MutArray.pinnedNewAligned align)
2245−-- >>> pinnedWriteNAligned align n = MutArray.appendN n (MutArray.pinnedNewAligned align n)
1879+-- >>> pinnedWriteNAligned align = MutArray.writeNWith (MutArray.pinnedNewAligned align)
1880+-- >>> pinnedWriteNAligned align n = MutArray.writeAppendN n (MutArray.pinnedNewAligned align n)
22461881--
22471882-- /Pre-release/
22481883--
22491884{-# INLINE_NORMAL pinnedWriteNAligned #-}
22501885pinnedWriteNAligned :: forall m a. (MonadIO m, Unbox a)
22511886 => Int -> Int -> Fold m a (MutArray a)
2252−pinnedWriteNAligned align = createOfWith (pinnedNewAligned align)
1887+pinnedWriteNAligned align = writeNWith (pinnedNewAligned align)
22531888
22541889-- XXX Buffer to a list instead?
2255−
1890+--
22561891-- | Buffer a stream into a stream of arrays.
22571892--
2258−-- >>> buildChunks n = Fold.many (MutArray.createOf n) Fold.toStreamK
1893+-- >>> writeChunks n = Fold.many (MutArray.writeN n) Fold.toStreamK
22591894--
22601895-- Breaking an array into an array stream can be useful to consume a large
22611896-- array sequentially such that memory of the array is released incrementatlly.
@@ -2264,43 +1899,37 @@ pinnedWriteNAligned align = createOfWith (pinnedNewAligned align)
22641899--
22651900-- /Unimplemented/
22661901--
2267−{-# INLINE_NORMAL buildChunks #-}
2268−buildChunks :: (MonadIO m, Unbox a) =>
2269− Int -> Fold m a (StreamK n (MutArray a))
2270−buildChunks n = FL.many (createOf n) FL.toStreamK
2271−
2272−{-# DEPRECATED writeChunks "Please use buildChunks instead." #-}
2273−{-# INLINE writeChunks #-}
1902+{-# INLINE_NORMAL writeChunks #-}
22741903writeChunks :: (MonadIO m, Unbox a) =>
22751904 Int -> Fold m a (StreamK n (MutArray a))
2276−writeChunks = buildChunks
1905+writeChunks n = FL.many (writeN n) FL.toStreamK
22771906
22781907{-# INLINE_NORMAL writeWithAs #-}
22791908writeWithAs :: forall m a. (MonadIO m, Unbox a)
22801909 => PinnedState -> Int -> Fold m a (MutArray a)
2281−-- writeWithAs ps n = FL.rmapM rightSize $ appendWith (* 2) (newAs ps n)
1910+-- writeWithAs ps n = FL.rmapM rightSize $ writeAppendWith (* 2) (newAs ps n)
22821911writeWithAs ps elemCount =
22831912 FL.rmapM extract $ FL.foldlM' step initial
22841913
22851914 where
22861915
22871916 initial = do
2288− when (elemCount < 0) $ error "createWith: elemCount is negative"
2289− newAs ps elemCount
1917+ when (elemCount < 0) $ error "writeWith: elemCount is negative"
1918+ liftIO $ newAs ps elemCount
22901919
22911920 step arr@(MutArray _ start end bound) x
22921921 | INDEX_NEXT(end,a) > bound = do
22931922 let oldSize = end - start
22941923 newSize = max (oldSize * 2) 1
2295− arr1 <- liftIO $ reallocExplicitAs ps (SIZE_OF(a)) newSize arr
1924+ arr1 <- liftIO $ reallocExplicit (SIZE_OF(a)) newSize arr
22961925 snocUnsafe arr1 x
22971926 step arr x = snocUnsafe arr x
22981927
22991928 extract = liftIO . rightSize
23001929
2301−-- XXX Compare createWith with fromStreamD which uses an array of streams
2302−-- implementation. We can write this using buildChunks above if that is faster.
2303−-- If createWith is faster then we should use that to implement
1930+-- XXX Compare writeWith with fromStreamD which uses an array of streams
1931+-- implementation. We can write this using writeChunks above if that is faster.
1932+-- If writeWith is faster then we should use that to implement
23041933-- fromStreamD.
23051934--
23061935-- XXX The realloc based implementation needs to make one extra copy if we use
@@ -2315,56 +1944,39 @@ writeWithAs ps elemCount =
23151944-- XXX check if GHC's memory allocator is efficient enough. We can try the C
23161945-- malloc to compare against.
23171946
2318−-- | @createWith minCount@ folds the whole input to a single array. The array
1947+-- | @writeWith minCount@ folds the whole input to a single array. The array
23191948-- starts at a size big enough to hold minCount elements, the size is doubled
23201949-- every time the array needs to be grown.
23211950--
23221951-- /Caution! Do not use this on infinite streams./
23231952--
2324−-- >>> f n = MutArray.appendWith (* 2) (MutArray.emptyOf n)
2325−-- >>> createWith n = Fold.rmapM MutArray.rightSize (f n)
2326−-- >>> createWith n = Fold.rmapM MutArray.fromChunksK (MutArray.buildChunks n)
1953+-- >>> f n = MutArray.writeAppendWith (* 2) (MutArray.new n)
1954+-- >>> writeWith n = Fold.rmapM MutArray.rightSize (f n)
1955+-- >>> writeWith n = Fold.rmapM MutArray.fromArrayStreamK (MutArray.writeChunks n)
23271956--
23281957-- /Pre-release/
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
2334−
2335−{-# DEPRECATED writeWith "Please use createWith instead." #-}
2336−{-# INLINE writeWith #-}
1958+{-# INLINE_NORMAL writeWith #-}
23371959writeWith :: forall m a. (MonadIO m, Unbox a)
23381960 => Int -> Fold m a (MutArray a)
2339−writeWith = createWith
1961+-- writeWith n = FL.rmapM rightSize $ writeAppendWith (* 2) (new n)
1962+writeWith = writeWithAs Unpinned
23401963
23411964-- | Fold the whole input to a single array.
23421965--
2343−-- Same as 'createWith' using an initial array size of 'arrayChunkBytes' bytes
1966+-- Same as 'writeWith' using an initial array size of 'arrayChunkBytes' bytes
23441967-- rounded up to the element size.
23451968--
23461969-- /Caution! Do not use this on infinite streams./
23471970--
2348−{-# INLINE create #-}
2349−create :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
2350−create = createWith (allocBytesToElemCount (undefined :: a) arrayChunkBytes)
2351−
2352−-- XXX Deprecate in major
2353−-- {-# DEPRECATED write "Please use create instead." #-}
23541971{-# INLINE write #-}
23551972write :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
2356−write = create
2357−
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)
2361−pinnedCreate =
2362− writeWithAs Pinned (allocBytesToElemCount (undefined :: a) arrayChunkBytes)
1973+write = writeWith (allocBytesToElemCount (undefined :: a) arrayChunkBytes)
23631974
2364−{-# DEPRECATED pinnedWrite "Please use pinnedCreate instead." #-}
1975+-- | Like 'write' but creates a pinned array.
23651976{-# INLINE pinnedWrite #-}
23661977pinnedWrite :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
2367−pinnedWrite = pinnedCreate
1978+pinnedWrite =
1979+ writeWithAs Pinned (allocBytesToElemCount (undefined :: a) arrayChunkBytes)
23681980
23691981-------------------------------------------------------------------------------
23701982-- construct from streams, known size
@@ -2374,31 +1986,25 @@ pinnedWrite = pinnedCreate
23741986fromStreamDNAs :: forall m a. (MonadIO m, Unbox a)
23751987 => PinnedState -> Int -> D.Stream m a -> m (MutArray a)
23761988fromStreamDNAs ps limit str = do
2377− (arr :: MutArray a) <- newAs ps limit
1989+ (arr :: MutArray a) <- liftIO $ newAs ps limit
23781990 end <- D.foldlM' (fwrite (arrContents arr)) (return $ arrEnd arr) $ D.take limit str
23791991 return $ arr {arrEnd = end}
23801992
23811993 where
23821994
23831995 fwrite arrContents ptr x = do
2384− liftIO $ pokeAt ptr arrContents x
1996+ liftIO $ pokeByteIndex ptr arrContents x
23851997 return $ INDEX_NEXT(ptr,a)
23861998
2387−-- | Use the 'createOf' fold instead.
1999+-- | Use the 'writeN' fold instead.
23882000--
2389−-- >>> fromStreamN n = Stream.fold (MutArray.createOf n)
2001+-- >>> fromStreamDN n = Stream.fold (MutArray.writeN n)
23902002--
2391−{-# INLINE_NORMAL fromStreamN #-}
2392−fromStreamN :: forall m a. (MonadIO m, Unbox a)
2393− => Int -> D.Stream m a -> m (MutArray a)
2394−-- fromStreamDN n = D.fold (createOf n)
2395−fromStreamN = fromStreamDNAs Unpinned
2396−
2397−{-# DEPRECATED fromStreamDN "Please use fromStreamN instead." #-}
2398−{-# INLINE fromStreamDN #-}
2003+{-# INLINE_NORMAL fromStreamDN #-}
23992004fromStreamDN :: forall m a. (MonadIO m, Unbox a)
24002005 => Int -> D.Stream m a -> m (MutArray a)
2401−fromStreamDN = fromStreamN
2006+-- fromStreamDN n = D.fold (writeN n)
2007+fromStreamDN = fromStreamDNAs Unpinned
24022008
24032009-- | Create a 'MutArray' from the first N elements of a list. The array is
24042010-- allocated to size N, if the list terminates before N elements then the
@@ -2418,70 +2024,16 @@ pinnedFromListN n xs = fromStreamDNAs Pinned n $ D.fromList xs
24182024-- /Pre-release/
24192025{-# INLINE fromListRevN #-}
24202026fromListRevN :: (MonadIO m, Unbox a) => Int -> [a] -> m (MutArray a)
2421−fromListRevN n xs = D.fold (revCreateOf n) $ D.fromList xs
2422−
2423−-- | Convert a pure stream in Identity monad to a mutable array.
2424−{-# INLINABLE fromPureStreamN #-}
2425−fromPureStreamN :: (MonadIO m, Unbox a) =>
2426− Int -> Stream Identity a -> m (MutArray a)
2427−fromPureStreamN n xs =
2428− D.fold (createOf n) $ D.morphInner (return . runIdentity) xs
2027+fromListRevN n xs = D.fold (writeRevN n) $ D.fromList xs
24292028
24302029-- | Convert a pure stream in Identity monad to a mutable array.
24312030{-# INLINABLE fromPureStream #-}
24322031fromPureStream :: (MonadIO m, Unbox a) => Stream Identity a -> m (MutArray a)
24332032fromPureStream xs =
2434− D.fold create $ D.morphInner (return . runIdentity) xs
2435−
2436−{-# INLINABLE fromPtrN #-}
2437−fromPtrN :: MonadIO m => Int -> Ptr Word8 -> m (MutArray Word8)
2438−fromPtrN len addr = do
2439− -- memcpy is better than stream copy when the size is known.
2440− -- XXX We can implement a stream copy in a similar way by streaming Word64
2441− -- first and then remaining Word8.
2442− arr <- new len
2443− _ <- unsafeAsPtr arr
2444− (\ptr -> liftIO $ c_memcpy ptr addr (fromIntegral len))
2445− return (arr {arrEnd = len})
2446−
2447−{-# INLINABLE fromByteStr# #-}
2448−fromByteStr# :: MonadIO m => Addr# -> m (MutArray Word8)
2449−fromByteStr# addr = do
2450− -- It is better to count the size first and allocate exact space.
2451− -- Also, memcpy is better than stream copy when the size is known.
2452− -- C strlen compares 4 bytes at a time, so is better than the stream
2453− -- version. https://github.com/bminor/glibc/blob/master/string/strlen.c
2454− -- XXX We can possibly use a stream of Word64 to do the same.
2455− -- fromByteStr# addr = fromPureStream (D.fromByteStr# addr)
2456− len <- liftIO $ c_strlen (Ptr addr)
2457− let lenInt = fromIntegral len
2458− arr <- new lenInt
2459− _ <- unsafeAsPtr arr (\ptr -> liftIO $ c_memcpy ptr (Ptr addr) len)
2460− return (arr {arrEnd = lenInt})
2033+ liftIO $ D.fold write $ D.morphInner (return . runIdentity) xs
24612034
24622035-------------------------------------------------------------------------------
2463−-- convert a stream of arrays to a single array by reallocating and copying
2464−-------------------------------------------------------------------------------
2465−
2466−-- XXX Both of these implementations of splicing seem to perform equally well.
2467−-- We need to perform benchmarks over a range of sizes though.
2468−
2469−-- | Also see 'fromChunksK'.
2470−{-# INLINE fromChunksRealloced #-}
2471−fromChunksRealloced :: forall m a. (MonadIO m, Unbox a)
2472− => Stream m (MutArray a) -> m (MutArray a)
2473−fromChunksRealloced s = do
2474− res <- D.uncons s
2475− case res of
2476− Just (a, strm) -> do
2477− arr <- D.foldlM' spliceExp (pure a) strm
2478− -- Reallocation is exponential so there may be 50% empty space in
2479− -- worst case. One more reallocation to reclaim the space.
2480− rightSize arr
2481− Nothing -> pure nil
2482−
2483−-------------------------------------------------------------------------------
2484−-- convert a stream of arrays to a single array by buffering arrays first
2036+-- convert stream to a single array
24852037-------------------------------------------------------------------------------
24862038
24872039{-# INLINE arrayStreamKLength #-}
@@ -2491,72 +2043,34 @@ arrayStreamKLength as = K.foldl' (+) 0 (K.map length as)
24912043-- | Convert an array stream to an array. Note that this requires peak memory
24922044-- that is double the size of the array stream.
24932045--
2494−{-# INLINE fromChunkskAs #-}
2495−fromChunkskAs :: (Unbox a, MonadIO m) =>
2496− PinnedState -> StreamK m (MutArray a) -> m (MutArray a)
2497−fromChunkskAs ps as = do
2498− len <- arrayStreamKLength as
2499− arr <- newAs ps len
2500− -- XXX is StreamK fold faster or StreamD fold?
2501− K.foldlM' spliceUnsafe (pure arr) as
2502− -- fromStreamDN len $ D.unfoldMany reader $ D.fromStreamK as
2503−
2504−-- XXX Need to compare this with fromChunks and fromChunkList and keep the
2505−-- fastest or simplest one if all are equally fast.
2506−
2507−-- | Convert an array stream to an array. Note that this requires peak memory
2508−-- that is double the size of the array stream.
2509−--
2510−-- Also see 'fromChunksRealloced'.
2511−--
2512−{-# INLINE fromChunksK #-}
2513−fromChunksK :: (Unbox a, MonadIO m) =>
2514− StreamK m (MutArray a) -> m (MutArray a)
2515−fromChunksK = fromChunkskAs Unpinned
2516−
2517−{-# DEPRECATED fromArrayStreamK "Please use fromChunksK instead." #-}
25182046{-# INLINE fromArrayStreamK #-}
25192047fromArrayStreamK :: (Unbox a, MonadIO m) =>
25202048 StreamK m (MutArray a) -> m (MutArray a)
2521−fromArrayStreamK = fromChunksK
2049+fromArrayStreamK as = do
2050+ len <- arrayStreamKLength as
2051+ fromStreamDN len $ D.unfoldMany reader $ D.fromStreamK as
25222052
25232053{-# INLINE fromStreamDAs #-}
25242054fromStreamDAs ::
25252055 (MonadIO m, Unbox a) => PinnedState -> D.Stream m a -> m (MutArray a)
2526−fromStreamDAs ps m =
2527− arrayStreamKFromStreamDAs Unpinned m >>= fromChunkskAs ps
2056+fromStreamDAs ps m = arrayStreamKFromStreamDAs ps m >>= fromArrayStreamK
25282057
2529−-- | Create an 'Array' from a stream. This is useful when we want to create a
2530−-- single array from a stream of unknown size. 'createOf' is at least twice
2531−-- as efficient when the size is already known.
2532−--
2533−-- Note that if the input stream is too large memory allocation for the array
2534−-- may fail. When the stream size is not known, `chunksOf` followed by
2535−-- processing of indvidual arrays in the resulting stream should be preferred.
2536−--
2537−-- /Pre-release/
2538−{-# INLINE fromStream #-}
2539−fromStream :: (MonadIO m, Unbox a) => Stream m a -> m (MutArray a)
2540−fromStream = fromStreamDAs Unpinned
2541−
2542−-- fromStream (Stream m) = P.fold create m
25432058-- CAUTION: a very large number (millions) of arrays can degrade performance
25442059-- due to GC overhead because we need to buffer the arrays before we flatten
25452060-- all the arrays.
25462061--
2547−-- XXX Compare if this is faster or "fold create".
2062+-- XXX Compare if this is faster or "fold write".
25482063--
25492064-- | We could take the approach of doubling the memory allocation on each
25502065-- overflow. This would result in more or less the same amount of copying as in
25512066-- the chunking approach. However, if we have to shrink in the end then it may
25522067-- result in an extra copy of the entire data.
25532068--
2554−-- >>> fromStreamD = StreamD.fold MutArray.create
2069+-- >>> fromStreamD = StreamD.fold MutArray.write
25552070--
25562071{-# INLINE fromStreamD #-}
2557−{-# DEPRECATED fromStreamD "Please use fromStream instead." #-}
25582072fromStreamD :: (MonadIO m, Unbox a) => D.Stream m a -> m (MutArray a)
2559−fromStreamD = fromStream
2073+fromStreamD = fromStreamDAs Unpinned
25602074
25612075-- | Create a 'MutArray' from a list. The list must be of finite size.
25622076--
@@ -2581,44 +2095,22 @@ fromListRev xs = fromListRevN (Prelude.length xs) xs
25812095-- Cloning
25822096-------------------------------------------------------------------------------
25832097
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.
2587−
25882098{-# INLINE cloneAs #-}
2589−cloneAs ::
2590− ( MonadIO m
2591−#ifdef DEVBUILD
2592− , Unbox a
2593−#endif
2594− )
2595− => PinnedState -> MutArray a -> m (MutArray a)
2099+cloneAs :: MonadIO m => PinnedState -> MutArray a -> m (MutArray a)
25962100cloneAs ps src =
2597− do
2101+ liftIO $ do
25982102 let startSrc = arrStart src
25992103 srcLen = arrEnd src - startSrc
2600− newArrContents <-
2601− Unboxed.cloneSliceUnsafeAs ps startSrc srcLen (arrContents src)
2104+ newArrContents <- Unboxed.newBytesAs ps srcLen
2105+ putSliceUnsafe (arrContents src) startSrc newArrContents 0 srcLen
26022106 return $ MutArray newArrContents 0 srcLen srcLen
26032107
26042108{-# INLINE clone #-}
2605−clone ::
2606− ( MonadIO m
2607−#ifdef DEVBUILD
2608− , Unbox a
2609−#endif
2610− )
2611− => MutArray a -> m (MutArray a)
2109+clone :: MonadIO m => MutArray a -> m (MutArray a)
26122110clone = cloneAs Unpinned
26132111
26142112{-# INLINE pinnedClone #-}
2615−pinnedClone ::
2616− ( MonadIO m
2617−#ifdef DEVBUILD
2618− , Unbox a
2619−#endif
2620− )
2621− => MutArray a -> m (MutArray a)
2113+pinnedClone :: MonadIO m => MutArray a -> m (MutArray a)
26222114pinnedClone = cloneAs Pinned
26232115
26242116-------------------------------------------------------------------------------
@@ -2633,16 +2125,17 @@ spliceCopy :: forall m a. MonadIO m =>
26332125 Unbox a =>
26342126#endif
26352127 MutArray a -> MutArray a -> m (MutArray a)
2636−spliceCopy arr1 arr2 = do
2128+spliceCopy arr1 arr2 = liftIO $ do
26372129 let start1 = arrStart arr1
26382130 start2 = arrStart arr2
26392131 len1 = arrEnd arr1 - start1
26402132 len2 = arrEnd arr2 - start2
2641− let len = len1 + len2
2133+ let newLen = len1 + len2
26422134 newArrContents <-
26432135 if Unboxed.isPinned (arrContents arr1)
2644− then liftIO $ Unboxed.pinnedNew len
2645− else liftIO $ Unboxed.new len
2136+ then Unboxed.pinnedNewBytes newLen
2137+ else Unboxed.newBytes newLen
2138+ let len = len1 + len2
26462139 putSliceUnsafe (arrContents arr1) start1 newArrContents 0 len1
26472140 putSliceUnsafe (arrContents arr2) start2 newArrContents len1 len2
26482141 return $ MutArray newArrContents 0 len len
@@ -2654,7 +2147,7 @@ spliceCopy arr1 arr2 = do
26542147spliceUnsafe :: MonadIO m =>
26552148 MutArray a -> MutArray a -> m (MutArray a)
26562149spliceUnsafe dst src =
2657− do
2150+ liftIO $ do
26582151 let startSrc = arrStart src
26592152 srcLen = arrEnd src - startSrc
26602153 endDst = arrEnd dst
@@ -2676,7 +2169,7 @@ spliceWith :: forall m a. (MonadIO m, Unbox a) =>
26762169 (Int -> Int -> Int) -> MutArray a -> MutArray a -> m (MutArray a)
26772170spliceWith sizer dst@(MutArray _ start end bound) src = do
26782171{-
2679− let f = appendWith (`sizer` byteLength src) (return dst)
2172+ let f = writeAppendWith (`sizer` byteLength src) (return dst)
26802173 in D.fold f (toStreamD src)
26812174-}
26822175 assert (end <= bound) (return ())
@@ -2692,7 +2185,7 @@ spliceWith sizer dst@(MutArray _ start end bound) src = do
26922185 $ "splice: newSize is less than the total size "
26932186 ++ "of arrays being appended. Please check the "
26942187 ++ "sizer function passed."
2695− realloc newSizeInBytes dst
2188+ liftIO $ realloc newSizeInBytes dst
26962189 else return dst
26972190 spliceUnsafe dst1 src
26982191
@@ -2729,24 +2222,14 @@ spliceExp = spliceWith (\l1 l2 -> max (l1 * 2) (l1 + l2))
27292222-- Splitting
27302223-------------------------------------------------------------------------------
27312224
2732−-- | Generate a stream of array slices using a predicate. The array element
2733−-- matching the predicate is dropped.
2734−--
2735−-- /Pre-release/
2736−{-# INLINE splitOn #-}
2737−splitOn :: (MonadIO m, Unbox a) =>
2738− (a -> Bool) -> MutArray a -> Stream m (MutArray a)
2739−splitOn predicate arr =
2740− fmap (\(i, len) -> getSliceUnsafe i len arr)
2741− $ D.indexOnSuffix predicate (read arr)
2742−
27432225-- | Drops the separator byte
27442226{-# INLINE breakOn #-}
27452227breakOn :: MonadIO m
27462228 => Word8 -> MutArray Word8 -> m (MutArray Word8, Maybe (MutArray Word8))
2747−breakOn sep arr@MutArray{..} = unsafeAsPtr arr $ \p -> liftIO $ do
2229+breakOn sep arr@MutArray{..} = asPtrUnsafe arr $ \p -> liftIO $ do
2230+ -- XXX Instead of using asPtrUnsafe (pinning memory) we can pass unlifted
2231+ -- Addr# to memchr and it should be safe (from ghc 8.4).
27482232 -- XXX We do not need memchr here, we can use a Haskell equivalent.
2749− -- Need efficient stream based primitives that work on Word64.
27502233 loc <- c_memchr p sep (fromIntegral $ byteLength arr)
27512234 let sepIndex = loc `minusPtr` p
27522235 return $
@@ -2767,41 +2250,32 @@ breakOn sep arr@MutArray{..} = unsafeAsPtr arr $ \p -> liftIO $ do
27672250 }
27682251 )
27692252
2770−-- | Like 'splitAt' but does not check whether the index is valid.
2771−--
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)
2777− p = arrStart + off
2778− in ( MutArray
2779− { arrContents = arrContents
2780− , arrStart = arrStart
2781− , arrEnd = p
2782− , arrBound = p
2783− }
2784− , MutArray
2785− { arrContents = arrContents
2786− , arrStart = p
2787− , arrEnd = arrEnd
2788− , arrBound = arrBound
2789− }
2790− )
2791−
27922253-- | Create two slices of an array without copying the original array. The
27932254-- specified index @i@ is the first index of the second slice.
27942255--
2795−{-# INLINE splitAt #-}
27962256splitAt :: forall a. Unbox a => Int -> MutArray a -> (MutArray a, MutArray a)
2797−splitAt i arr =
2257+splitAt i arr@MutArray{..} =
27982258 let maxIndex = length arr - 1
27992259 in if i < 0
28002260 then error "sliceAt: negative array index"
28012261 else if i > maxIndex
28022262 then error $ "sliceAt: specified array index " ++ show i
28032263 ++ " is beyond the maximum index " ++ show maxIndex
2804− else unsafeSplitAt i arr
2264+ else let off = i * SIZE_OF(a)
2265+ p = arrStart + off
2266+ in ( MutArray
2267+ { arrContents = arrContents
2268+ , arrStart = arrStart
2269+ , arrEnd = p
2270+ , arrBound = p
2271+ }
2272+ , MutArray
2273+ { arrContents = arrContents
2274+ , arrStart = p
2275+ , arrEnd = arrEnd
2276+ , arrBound = arrBound
2277+ }
2278+ )
28052279
28062280-------------------------------------------------------------------------------
28072281-- Casting
@@ -2851,16 +2325,13 @@ cast arr =
28512325-- guarantees that unsafe calls will be performed in the calling thread. Making
28522326-- it safe to pass heap-allocated objects to unsafe functions.
28532327
2854−-- XXX Should we just name it asPtr, the unsafety is implicit for any pointer
2855−-- operations. And we are safe from Haskell perspective because we will be
2856−-- pinning the memory.
2857−--
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.
2328+-- Unsafe because of direct pointer operations. The user must ensure that they
2329+-- are writing within the legal bounds of the array. Should we just name it
2330+-- asPtr, the unsafety is implicit for any pointer operations. And we are safe
2331+-- from Haskell perspective because we will be pinning the memory.
28612332
2862−-- | Use a @MutArray a@ as @Ptr a@. This is useful when we want to pass an
2863−-- array as a pointer to some operating system call or to a "safe" FFI call.
2333+-- | Use an @MutArray a@ as @Ptr a@. This is useful when we want to pass an array
2334+-- as a pointer to some operating system call or to a "safe" FFI call.
28642335--
28652336-- If the array is not pinned it is copied to pinned memory before passing it
28662337-- to the monadic action.
@@ -2870,382 +2341,57 @@ cast arr =
28702341-- opportunistically before this operation occurs, to avoid the cost of a copy
28712342-- if possible.
28722343--
2873−-- /Unsafe/ because of direct pointer operations. The user must ensure that
2874−-- they are writing within the legal bounds of the array.
2344+-- /Unsafe/
28752345--
28762346-- /Pre-release/
28772347--
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))
2883−
2884−{-# DEPRECATED asPtrUnsafe "Please use unsafePinnedAsPtr instead." #-}
28852348{-# INLINE asPtrUnsafe #-}
28862349asPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b
2887−asPtrUnsafe = unsafePinnedAsPtr
2350+asPtrUnsafe arr f = do
2351+ contents <- liftIO $ Unboxed.pin $ arrContents arr
2352+ let !ptr = Ptr (byteArrayContents#
2353+ (unsafeCoerce# (getMutableByteArray# contents)))
28882354
2889−{-# INLINE unsafeAsPtr #-}
2890−unsafeAsPtr :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b
2891−unsafeAsPtr arr f =
2892− Unboxed.unsafeAsPtr
2893− (arrContents arr) (\ptr -> f (ptr `plusPtr` arrStart arr))
2355+ r <- f (ptr `plusPtr` arrStart arr)
2356+ liftIO $ touch contents
2357+ return r
28942358
28952359-------------------------------------------------------------------------------
28962360-- Equality
28972361-------------------------------------------------------------------------------
28982362
2899−-- | Byte compare two arrays. Compare the length of the arrays. If the length
2900−-- is equal, compare the lexicographical ordering of two underlying byte arrays
2901−-- otherwise return the result of length comparison.
2902−--
2903−-- /Unsafe/: Note that the 'Unbox' instance of sum types with constructors of
2904−-- different sizes may leave some memory uninitialized which can make byte
2905−-- comparison unreliable.
2363+-- | Compare the length of the arrays. If the length is equal, compare the
2364+-- lexicographical ordering of two underlying byte arrays otherwise return the
2365+-- result of length comparison.
29062366--
29072367-- /Pre-release/
2908−{-# INLINE byteCmp #-}
2909−byteCmp :: MonadIO m => MutArray a -> MutArray a -> m Ordering
2910−byteCmp arr1 arr2 = do
2911− let marr1 = getMutableByteArray# (arrContents arr1)
2912− marr2 = getMutableByteArray# (arrContents arr2)
2913− !(I# st1#) = arrStart arr1
2914− !(I# st2#) = arrStart arr2
2915− !(I# len#) = byteLength arr1
2916− case compare (byteLength arr1) (byteLength arr2) of
2917− EQ -> do
2918− r <- liftIO $ IO $ \s# ->
2919− let res =
2920− I#
2921− (compareByteArrays#
2922− (unsafeCoerce# marr1)
2923− st1#
2924− (unsafeCoerce# marr2)
2925− st2#
2926− len#)
2927− in (# s#, res #)
2928− return $ compare r 0
2929− x -> return x
2930−
29312368{-# INLINE cmp #-}
2932−{-# DEPRECATED cmp "Please use byteCmp instead." #-}
29332369cmp :: MonadIO m => MutArray a -> MutArray a -> m Ordering
2934−cmp = byteCmp
2935−
2936−-- | Byte equality of two arrays.
2937−--
2938−-- >>> byteEq arr1 arr2 = (==) EQ $ MArray.byteCmp arr1 arr2
2939−--
2940−-- /Unsafe/: See 'byteCmp'.
2941−{-# INLINE byteEq #-}
2942−byteEq :: MonadIO m => MutArray a -> MutArray a -> m Bool
2943−byteEq arr1 arr2 = fmap (EQ ==) $ byteCmp arr1 arr2
2944−
2945−-------------------------------------------------------------------------------
2946−-- Compact
2947−-------------------------------------------------------------------------------
2948−
2949−-- Note: LE versions avoid an extra copy compared to GE. LE parser trades
2950−-- backtracking one array in lieu of avoiding a copy. However, LE and GE both
2951−-- can leave some memory unused. They can split the last array to fit it
2952−-- exactly in the space.
2953−
2954−{-# INLINE_NORMAL pCompactLeAs #-}
2955−pCompactLeAs ::
2956− forall m a. (MonadIO m, Unbox a)
2957− => PinnedState -> Int -> Parser (MutArray a) m (MutArray a)
2958−pCompactLeAs ps maxElems = Parser step initial extract
2959−
2960− where
2961−
2962− maxBytes = maxElems * SIZE_OF(a)
2963−
2964− functionName = "Streamly.Internal.Data.MutArray.pCompactLE"
2965−
2966− initial =
2967− return
2968− $ if maxElems <= 0
2969− then error
2970− $ functionName
2971− ++ ": the size of arrays ["
2972− ++ show maxElems ++ "] must be a natural number"
2973− else Parser.IPartial Nothing
2974−
2975− step Nothing arr =
2976− return
2977− $ let len = byteLength arr
2978− in if len >= maxBytes
2979− then Parser.Done 0 arr
2980− else Parser.Partial 0 (Just arr)
2981− -- XXX Split the last array to use the space more compactly.
2982− step (Just buf) arr =
2983− let len = byteLength buf + byteLength arr
2984− in if len > maxBytes
2985− then return $ Parser.Done 1 buf
2986− else do
2987− buf1 <-
2988− if byteCapacity buf < maxBytes
2989− then liftIO $ reallocExplicitAs
2990− ps (SIZE_OF(a)) maxBytes buf
2991− else return buf
2992− buf2 <- spliceUnsafe buf1 arr
2993− return $ Parser.Partial 0 (Just buf2)
2994−
2995− extract Nothing = return $ Parser.Done 0 nil
2996− extract (Just buf) = return $ Parser.Done 0 buf
2997−
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.
3002−--
3003−-- @maxElems@ must be greater than 0.
3004−--
3005−-- Generates unpinned arrays irrespective of the pinning status of input
3006−-- arrays.
3007−--
3008−-- /Internal/
3009−{-# INLINE pCompactLE #-}
3010−pCompactLE ::
3011− forall m a. (MonadIO m, Unbox a)
3012− => Int -> Parser (MutArray a) m (MutArray a)
3013−pCompactLE = pCompactLeAs Unpinned
3014−
3015−-- | Pinned version of 'pCompactLE'.
3016−{-# INLINE pPinnedCompactLE #-}
3017−pPinnedCompactLE ::
3018− forall m a. (MonadIO m, Unbox a)
3019− => Int -> Parser (MutArray a) m (MutArray a)
3020−pPinnedCompactLE = pCompactLeAs Pinned
3021−
3022−data SpliceState s arr
3023− = SpliceInitial s
3024− | SpliceBuffering s arr
3025− | SpliceYielding arr (SpliceState s arr)
3026− | SpliceFinish
3027−
3028−-- This mutates the first array (if it has space) to append values from the
3029−-- second one. This would work for immutable arrays as well because an
3030−-- immutable array never has additional space so a new array is allocated
3031−-- instead of mutating it.
3032−
3033−{-# INLINE_NORMAL compactLeAs #-}
3034−compactLeAs :: forall m a. (MonadIO m, Unbox a)
3035− => PinnedState -> Int -> D.Stream m (MutArray a) -> D.Stream m (MutArray a)
3036−compactLeAs ps maxElems (D.Stream step state) =
3037− D.Stream step' (SpliceInitial state)
3038−
3039− where
3040−
3041− maxBytes = maxElems * SIZE_OF(a)
3042−
3043− functionName = "Streamly.Internal.Data.MutArray.rCompactLE"
3044−
3045− {-# INLINE_LATE step' #-}
3046− step' gst (SpliceInitial st) = do
3047− when (maxElems <= 0) $
3048− -- XXX we can pass the module string from the higher level API
3049− error $ functionName ++ ": the size of arrays [" ++ show maxElems
3050− ++ "] must be a natural number"
3051− r <- step gst st
3052− case r of
3053− D.Yield arr s -> return $
3054− let len = byteLength arr
3055− in if len >= maxBytes
3056− then D.Skip (SpliceYielding arr (SpliceInitial s))
3057− else D.Skip (SpliceBuffering s arr)
3058− D.Skip s -> return $ D.Skip (SpliceInitial s)
3059− D.Stop -> return D.Stop
3060−
3061− -- XXX Split the last array to use the space more compactly.
3062− step' gst (SpliceBuffering st buf) = do
3063− r <- step gst st
3064− case r of
3065− D.Yield arr s -> do
3066− let len = byteLength buf + byteLength arr
3067− if len > maxBytes
3068− then return $
3069− D.Skip (SpliceYielding buf (SpliceBuffering s arr))
3070− else do
3071− buf1 <- if byteCapacity buf < maxBytes
3072− then liftIO $ reallocExplicitAs
3073− ps (SIZE_OF(a)) maxBytes buf
3074− else return buf
3075− buf2 <- spliceUnsafe buf1 arr
3076− return $ D.Skip (SpliceBuffering s buf2)
3077− D.Skip s -> return $ D.Skip (SpliceBuffering s buf)
3078− D.Stop -> return $ D.Skip (SpliceYielding buf SpliceFinish)
3079−
3080− step' _ SpliceFinish = return D.Stop
3081−
3082− step' _ (SpliceYielding arr next) = return $ D.Yield arr next
3083−
3084−
3085−{-# INLINE_NORMAL fCompactGeAs #-}
3086−fCompactGeAs ::
3087− forall m a. (MonadIO m, Unbox a)
3088− => PinnedState -> Int -> FL.Fold m (MutArray a) (MutArray a)
3089−fCompactGeAs ps minElems = Fold step initial extract extract
3090−
3091− where
3092−
3093− minBytes = minElems * SIZE_OF(a)
3094−
3095− functionName = "Streamly.Internal.Data.MutArray.fCompactGE"
3096−
3097− initial =
3098− return
3099− $ if minElems < 0
3100− then error
3101− $ functionName
3102− ++ ": the size of arrays ["
3103− ++ show minElems ++ "] must be a natural number"
3104− else FL.Partial Nothing
3105−
3106− step Nothing arr =
3107− return
3108− $ let len = byteLength arr
3109− in if len >= minBytes
3110− then FL.Done arr
3111− else FL.Partial (Just arr)
3112− -- XXX Buffer arrays as a list to avoid copy and reallocations
3113− step (Just buf) arr = do
3114− let len = byteLength buf + byteLength arr
3115− buf1 <-
3116− if byteCapacity buf < len
3117− then liftIO $ reallocExplicitAs
3118− ps (SIZE_OF(a)) (max minBytes len) buf
3119− else return buf
3120− buf2 <- spliceUnsafe buf1 arr
3121− if len >= minBytes
3122− then return $ FL.Done buf2
3123− else return $ FL.Partial (Just buf2)
3124−
3125− extract Nothing = return nil
3126− extract (Just buf) = return buf
3127−
3128−-- | Fold @fCompactGE minElems@ coalesces adjacent arrays in the input stream
3129−-- until the size becomes greater than or equal to @minElems@.
3130−--
3131−-- Generates unpinned arrays irrespective of the pinning status of input
3132−-- arrays.
3133−{-# INLINE fCompactGE #-}
3134−fCompactGE ::
3135− forall m a. (MonadIO m, Unbox a)
3136− => Int -> FL.Fold m (MutArray a) (MutArray a)
3137−fCompactGE = fCompactGeAs Unpinned
3138−
3139−-- | Pinned version of 'fCompactGE'.
3140−{-# INLINE fPinnedCompactGE #-}
3141−fPinnedCompactGE ::
3142− forall m a. (MonadIO m, Unbox a)
3143− => Int -> FL.Fold m (MutArray a) (MutArray a)
3144−fPinnedCompactGE = fCompactGeAs Pinned
3145−
3146−{-# INLINE_NORMAL lCompactGeAs #-}
3147−lCompactGeAs :: forall m a. (MonadIO m, Unbox a)
3148− => PinnedState -> Int -> Fold m (MutArray a) () -> Fold m (MutArray a) ()
3149−-- The fold version turns out to be a little bit slower.
3150−-- lCompactGeAs ps n = FL.many (fCompactGeAs ps n)
3151−lCompactGeAs ps minElems (Fold step1 initial1 _ final1) =
3152− Fold step initial extract final
3153−
3154− where
3155−
3156− minBytes = minElems * SIZE_OF(a)
3157−
3158− functionName = "Streamly.Internal.Data.MutArray.lCompactGE"
3159−
3160− initial = do
3161− when (minElems <= 0) $
3162− -- XXX we can pass the module string from the higher level API
3163− error $ functionName ++ ": the size of arrays ["
3164− ++ show minElems ++ "] must be a natural number"
3165−
3166− r <- initial1
3167− return $ first (Tuple' Nothing) r
3168−
3169− {-# INLINE runInner #-}
3170− runInner len acc buf =
3171− if len >= minBytes
3172− then do
3173− r <- step1 acc buf
3174− case r of
3175− FL.Done _ -> return $ FL.Done ()
3176− FL.Partial s -> do
3177− _ <- final1 s
3178− res <- initial1
3179− return $ first (Tuple' Nothing) res
3180− else return $ FL.Partial $ Tuple' (Just buf) acc
3181−
3182− step (Tuple' Nothing r1) arr =
3183− runInner (byteLength arr) r1 arr
3184−
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
3191− else return buf
3192− buf2 <- spliceUnsafe buf1 arr
3193− runInner len r1 buf2
3194−
3195− -- XXX Several folds do extract >=> final, therefore, we need to make final
3196− -- return "m b" rather than using extract post it if we want extract to be
3197− -- partial.
3198− --
3199− -- extract forces the pending buffer to be sent to the fold which is not
3200− -- what we want.
3201− extract _ = error "lCompactGE: not designed for scanning"
3202−
3203− final (Tuple' Nothing r1) = final1 r1
3204− final (Tuple' (Just buf) r1) = do
3205− r <- step1 r1 buf
3206− case r of
3207− FL.Partial rr -> final1 rr
3208− FL.Done _ -> return ()
3209−
3210−-- | Like 'compactGE' but for transforming folds instead of stream.
3211−--
3212−-- >>> lCompactGE n = Fold.many (MutArray.fCompactGE n)
3213−--
3214−-- Generates unpinned arrays irrespective of the pinning status of input
3215−-- arrays.
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
3220−
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
3226−
3227−-- | @compactGE n stream@ coalesces adjacent arrays in the @stream@ until
3228−-- the size becomes greater than or equal to @n@.
3229−--
3230−-- >>> compactGE n = Stream.foldMany (MutArray.fCompactGE n)
3231−--
3232−{-# INLINE compactGE #-}
3233−compactGE ::
3234− (MonadIO m, Unbox a)
3235− => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
3236−compactGE n = D.foldMany (fCompactGE n)
3237−
3238−-- | 'compactEQ n' coalesces adajacent arrays in the input stream to
3239−-- arrays of exact size @n@.
3240−--
3241−-- /Unimplemented/
3242−{-# INLINE compactEQ #-}
3243−compactEQ :: -- (MonadIO m, Unbox a) =>
3244− Int -> Stream m (MutArray a) -> Stream m (MutArray a)
3245−compactEQ _n = undefined -- D.parseManyD (pCompactEQ n)
2370+cmp arr1 arr2 =
2371+ liftIO
2372+ $ do
2373+ let marr1 = getMutableByteArray# (arrContents arr1)
2374+ marr2 = getMutableByteArray# (arrContents arr2)
2375+ !(I# st1#) = arrStart arr1
2376+ !(I# st2#) = arrStart arr2
2377+ !(I# len#) = byteLength arr1
2378+ case compare (byteLength arr1) (byteLength arr2) of
2379+ EQ -> do
2380+ r <- liftIO $ IO $ \s# ->
2381+ let res =
2382+ I#
2383+ (compareByteArrays#
2384+ (unsafeCoerce# marr1)
2385+ st1#
2386+ (unsafeCoerce# marr2)
2387+ st2#
2388+ len#)
2389+ in (# s#, res #)
2390+ return $ compare r 0
2391+ x -> return x
32462392
32472393-------------------------------------------------------------------------------
3248−-- In-place mutation algorithms
2394+-- NFData
32492395-------------------------------------------------------------------------------
32502396
32512397-- | Strip elements which match with predicate from both ends.
@@ -3274,7 +2420,7 @@ strip eq arr@MutArray{..} = liftIO $ do
32742420 getStart cur = do
32752421 if cur < arrEnd
32762422 then do
3277− r <- peekAt cur arrContents
2423+ r <- peekByteIndex cur arrContents
32782424 if eq r
32792425 then getStart (INDEX_NEXT(cur,a))
32802426 else return cur
@@ -3284,7 +2430,7 @@ strip eq arr@MutArray{..} = liftIO $ do
32842430 if cur > low
32852431 then do
32862432 let prev = INDEX_PREV(cur,a)
3287− r <- peekAt prev arrContents
2433+ r <- peekByteIndex prev arrContents
32882434 if eq r
32892435 then getLast prev low
32902436 else return cur