cc44d97 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Replace unsafeWithArrayContents with unsafeWithArray

cc44d97Adithya Kumar5 years ago

src/Streamly/Internal/Data/Array/Foreign.hs+8−7

compare with master

unifiedsplit

@@ -132,7 +132,8 @@ import Prelude hiding (length, null, last, map, (!!), read, concat)

132import GHC.Ptr (Ptr(..))

133

134import Streamly.Internal.Data.Array.Foreign.Mut.Type (ReadUState(..), touch)

135−import Streamly.Internal.Data.Array.Foreign.Type (Array(..), length)

135+import Streamly.Internal.Data.Array.Foreign.Type

136+ (Array(..), length, unsafeWithArray)

136import Streamly.Internal.Data.Fold.Type (Fold(..))

137import Streamly.Internal.Data.Fold.Type (Fold(..))

137import Streamly.Internal.Data.Producer.Type (Producer(..))

138import Streamly.Internal.Data.Producer.Type (Producer(..))

138import Streamly.Internal.Data.Stream.Serial (SerialT(..))

139import Streamly.Internal.Data.Stream.Serial (SerialT(..))

@@ -269,7 +270,7 @@ null arr = A.byteLength arr == 0

269getIndexRev :: forall a. Storable a => Int -> Array a -> Maybe a

270getIndexRev :: forall a. Storable a => Int -> Array a -> Maybe a

270getIndexRev i arr =

271getIndexRev i arr =

271 unsafeInlineIO

272 unsafeInlineIO

272− $ MA.unsafeWithArrayContents (arrContents arr) (arrStart arr)

273+ $ unsafeWithArray arr

273 $ \ptr -> do

274 $ \ptr -> do

274 let elemPtr = PTR_RINDEX(aEnd arr,i,a)

275 let elemPtr = PTR_RINDEX(aEnd arr,i,a)

275 if i >= 0 && elemPtr >= ptr

276 if i >= 0 && elemPtr >= ptr

@@ -436,7 +437,7 @@ getSlicesFromLen from len =

436getIndex :: forall a. Storable a => Array a -> Int -> Maybe a

437getIndex :: forall a. Storable a => Array a -> Int -> Maybe a

437getIndex arr i =

438getIndex arr i =

438 unsafeInlineIO

439 unsafeInlineIO

439− $ MA.unsafeWithArrayContents (arrContents arr) (arrStart arr)

440+ $ unsafeWithArray arr

440 $ \ptr -> do

441 $ \ptr -> do

441 let elemPtr = PTR_INDEX(ptr,i,a)

442 let elemPtr = PTR_INDEX(ptr,i,a)

442 if i >= 0 && PTR_VALID(elemPtr,aEnd arr,a)

443 if i >= 0 && PTR_VALID(elemPtr,aEnd arr,a)

@@ -561,8 +562,8 @@ cast arr =

561-- /Pre-release/

562-- /Pre-release/

562--

563--

563unsafeAsPtr :: Array a -> (Ptr b -> IO c) -> IO c

564unsafeAsPtr :: Array a -> (Ptr b -> IO c) -> IO c

564−unsafeAsPtr Array{..} act = do

565+unsafeAsPtr arr act = do

565− MA.unsafeWithArrayContents arrContents arrStart $ \ptr -> act (castPtr ptr)

566+ unsafeWithArray arr $ \ptr -> act (castPtr ptr)

566

567

567-- | Convert an array of any type into a null terminated CString Ptr.

568-- | Convert an array of any type into a null terminated CString Ptr.

568--

569--

@@ -574,8 +575,8 @@ unsafeAsPtr Array{..} act = do

574--

575--

575unsafeAsCString :: Array a -> (CString -> IO b) -> IO b

576unsafeAsCString :: Array a -> (CString -> IO b) -> IO b

576unsafeAsCString arr act = do

577unsafeAsCString arr act = do

577− let Array{..} = asBytes arr <> A.fromList [0]

578+ let arr1 = asBytes arr <> A.fromList [0]

578− MA.unsafeWithArrayContents arrContents arrStart $ \ptr -> act (castPtr ptr)

579+ unsafeWithArray arr1 $ \ptr -> act (castPtr ptr)

579

580

580-------------------------------------------------------------------------------

581-------------------------------------------------------------------------------

581-- Folds

582-- Folds

src/Streamly/Internal/Data/Array/Foreign/Mut/Type.hs+23−25

@@ -20,7 +20,7 @@ module Streamly.Internal.Data.Array.Foreign.Mut.Type

20 , ArrayContents

21 , arrayToFptrContents

22 , fptrToArrayContents

23− , unsafeWithArrayContents

23+ , unsafeWithArray

24 , nilArrayContents

25 , touch

@@ -333,12 +333,10 @@ arrayToFptrContents (ArrayContents contents) = PlainPtr contents

333#endif

334

335-- | Similar to unsafeWithForeignPtr.

336−{-# INLINE unsafeWithArrayContents #-}

336+unsafeWithArray :: MonadIO m => Array a -> (Ptr a -> m b) -> m b

337−unsafeWithArrayContents :: MonadIO m =>

337+unsafeWithArray Array{..} f = do

338− ArrayContents -> Ptr a -> (Ptr a -> m b) -> m b

338+ r <- f arrStart

339−unsafeWithArrayContents contents ptr f = do

340− r <- f ptr

341− liftIO $ touch contents

339+ liftIO $ touch arrContents

342 return r

340 return r

343

341

344-------------------------------------------------------------------------------

342-------------------------------------------------------------------------------

@@ -532,7 +530,7 @@ withNewArrayUnsafe ::

532 (MonadIO m, Storable a) => Int -> (Ptr a -> m ()) -> m (Array a)

530 (MonadIO m, Storable a) => Int -> (Ptr a -> m ()) -> m (Array a)

533withNewArrayUnsafe count f = do

531withNewArrayUnsafe count f = do

534 arr <- newArray count

532 arr <- newArray count

535− unsafeWithArrayContents (arrContents arr) (arrStart arr)

533+ unsafeWithArray arr

536 $ \p -> f p >> return arr

534 $ \p -> f p >> return arr

537

535

538-------------------------------------------------------------------------------

536-------------------------------------------------------------------------------

@@ -546,8 +544,8 @@ withNewArrayUnsafe count f = do

546{-# INLINE putIndexUnsafe #-}

544{-# INLINE putIndexUnsafe #-}

547putIndexUnsafe :: forall m a. (MonadIO m, Storable a)

545putIndexUnsafe :: forall m a. (MonadIO m, Storable a)

548 => Int -> a -> Array a -> m ()

546 => Int -> a -> Array a -> m ()

549−putIndexUnsafe i x Array{..} =

547+putIndexUnsafe i x arr@(Array{..}) =

550− unsafeWithArrayContents arrContents arrStart $ \ptr -> do

548+ unsafeWithArray arr $ \ptr -> do

551 let elemPtr = PTR_INDEX(ptr,i,a)

549 let elemPtr = PTR_INDEX(ptr,i,a)

552 assert (i >= 0 && PTR_VALID(elemPtr,aEnd,a)) (return ())

550 assert (i >= 0 && PTR_VALID(elemPtr,aEnd,a)) (return ())

553 liftIO $ poke elemPtr x

551 liftIO $ poke elemPtr x

@@ -576,7 +574,7 @@ putIndexPtr start end i x = do

576{-# INLINE putIndex #-}

574{-# INLINE putIndex #-}

577putIndex :: (MonadIO m, Storable a) => Int -> a -> Array a -> m ()

575putIndex :: (MonadIO m, Storable a) => Int -> a -> Array a -> m ()

578putIndex i x arr =

576putIndex i x arr =

579− unsafeWithArrayContents (arrContents arr) (arrStart arr)

577+ unsafeWithArray arr

580 $ \p -> putIndexPtr p (aEnd arr) i x

578 $ \p -> putIndexPtr p (aEnd arr) i x

581

579

582-- | Write an input stream of (index, value) pairs to an array. Throws an

580-- | Write an input stream of (index, value) pairs to an array. Throws an

@@ -601,8 +599,8 @@ putIndices Array{..} = FL.mkFoldM step initial extract

601-- /Pre-release/

599-- /Pre-release/

602modifyIndexUnsafe :: forall m a b. (MonadIO m, Storable a) =>

600modifyIndexUnsafe :: forall m a b. (MonadIO m, Storable a) =>

603 Int -> (a -> (a, b)) -> Array a -> m b

601 Int -> (a -> (a, b)) -> Array a -> m b

604−modifyIndexUnsafe i f Array{..} = do

602+modifyIndexUnsafe i f arr@(Array{..}) = do

605− liftIO $ unsafeWithArrayContents arrContents arrStart $ \ptr -> do

603+ liftIO $ unsafeWithArray arr $ \ptr -> do

606 let elemPtr = PTR_INDEX(ptr,i,a)

604 let elemPtr = PTR_INDEX(ptr,i,a)

607 assert (i >= 0 && PTR_NEXT(elemPtr,a) <= aEnd) (return ())

605 assert (i >= 0 && PTR_NEXT(elemPtr,a) <= aEnd) (return ())

608 r <- peek elemPtr

606 r <- peek elemPtr

@@ -628,8 +626,8 @@ modifyIndexPtr i f start end = liftIO $ do

628-- /Pre-release/

626-- /Pre-release/

629modifyIndex :: forall m a b. (MonadIO m, Storable a) =>

627modifyIndex :: forall m a b. (MonadIO m, Storable a) =>

630 Int -> (a -> (a, b)) -> Array a -> m b

628 Int -> (a -> (a, b)) -> Array a -> m b

631−modifyIndex i f Array{..} = do

629+modifyIndex i f arr@(Array{..}) = do

632− liftIO $ unsafeWithArrayContents arrContents arrStart $ \ptr -> do

630+ liftIO $ unsafeWithArray arr $ \ptr -> do

633 modifyIndexPtr i f ptr aEnd

631 modifyIndexPtr i f ptr aEnd

634

632

635-- | Modify the array indices generated by the supplied stream.

633-- | Modify the array indices generated by the supplied stream.

@@ -655,8 +653,8 @@ modifyIndices f Array{..} = Fold step initial extract

655-- /Pre-release/

653-- /Pre-release/

656modify :: forall m a. (MonadIO m, Storable a)

654modify :: forall m a. (MonadIO m, Storable a)

657 => (a -> a) -> Array a -> m ()

655 => (a -> a) -> Array a -> m ()

658−modify f Array{..} = liftIO $

656+modify f arr@Array{..} = liftIO $

659− unsafeWithArrayContents arrContents arrStart go

657+ unsafeWithArray arr go

660

658

661 where

659 where

662

660

@@ -682,8 +680,8 @@ swapPtrs ptr1 ptr2 = do

682{-# INLINE unsafeSwapIndices #-}

680{-# INLINE unsafeSwapIndices #-}

683unsafeSwapIndices :: forall m a. (MonadIO m, Storable a)

681unsafeSwapIndices :: forall m a. (MonadIO m, Storable a)

684 => Int -> Int -> Array a -> m ()

682 => Int -> Int -> Array a -> m ()

685−unsafeSwapIndices i1 i2 Array{..} = liftIO $ do

683+unsafeSwapIndices i1 i2 arr = liftIO $ do

686− unsafeWithArrayContents arrContents arrStart $ \ptr -> do

684+ unsafeWithArray arr $ \ptr -> do

687 let ptr1 = PTR_INDEX(ptr,i1,a)

685 let ptr1 = PTR_INDEX(ptr,i1,a)

688 ptr2 = PTR_INDEX(ptr,i2,a)

686 ptr2 = PTR_INDEX(ptr,i2,a)

689 swapPtrs ptr1 (ptr2 :: Ptr a)

687 swapPtrs ptr1 (ptr2 :: Ptr a)

@@ -1049,8 +1047,8 @@ snoc = snocWith f

1049-- Unsafe because it does not check the bounds of the array.

1047-- Unsafe because it does not check the bounds of the array.

1050{-# INLINE_NORMAL getIndexUnsafe #-}

1048{-# INLINE_NORMAL getIndexUnsafe #-}

1051getIndexUnsafe :: forall m a. (MonadIO m, Storable a) => Int -> Array a -> m a

1049getIndexUnsafe :: forall m a. (MonadIO m, Storable a) => Int -> Array a -> m a

1052−getIndexUnsafe i Array {..} =

1050+getIndexUnsafe i arr@(Array {..}) =

1053− unsafeWithArrayContents arrContents arrStart $ \ptr -> do

1051+ unsafeWithArray arr $ \ptr -> do

1054 let elemPtr = PTR_INDEX(ptr,i,a)

1052 let elemPtr = PTR_INDEX(ptr,i,a)

1055 assert (i >= 0 && PTR_VALID(elemPtr,aEnd,a)) (return ())

1053 assert (i >= 0 && PTR_VALID(elemPtr,aEnd,a)) (return ())

1056 liftIO $ peek elemPtr

1054 liftIO $ peek elemPtr

@@ -1069,7 +1067,7 @@ getIndexPtr start end i = do

1069{-# INLINE getIndex #-}

1067{-# INLINE getIndex #-}

1070getIndex :: (MonadIO m, Storable a) => Int -> Array a -> m a

1068getIndex :: (MonadIO m, Storable a) => Int -> Array a -> m a

1071getIndex i arr =

1069getIndex i arr =

1072− unsafeWithArrayContents (arrContents arr) (arrStart arr)

1070+ unsafeWithArray arr

1073 $ \p -> getIndexPtr p (aEnd arr) i

1071 $ \p -> getIndexPtr p (aEnd arr) i

1074

1072

1075{-# INLINE getIndexPtrRev #-}

1073{-# INLINE getIndexPtrRev #-}

@@ -1089,7 +1087,7 @@ getIndexPtrRev start end i = do

1089{-# INLINE getIndexRev #-}

1087{-# INLINE getIndexRev #-}

1090getIndexRev :: (MonadIO m, Storable a) => Int -> Array a -> m a

1088getIndexRev :: (MonadIO m, Storable a) => Int -> Array a -> m a

1091getIndexRev i arr =

1089getIndexRev i arr =

1092− unsafeWithArrayContents (arrContents arr) (arrStart arr)

1090+ unsafeWithArray arr

1093 $ \p -> getIndexPtrRev p (aEnd arr) i

1091 $ \p -> getIndexPtrRev p (aEnd arr) i

1094

1092

1095data GetIndicesState contents start end st =

1093data GetIndicesState contents start end st =

@@ -2250,8 +2248,8 @@ cast arr =

2250-- /Pre-release/

2248-- /Pre-release/

2251--

2249--

2252asPtrUnsafe :: Array a -> (Ptr b -> IO c) -> IO c

2250asPtrUnsafe :: Array a -> (Ptr b -> IO c) -> IO c

2253−asPtrUnsafe Array{..} act = do

2251+asPtrUnsafe arr act = do

2254− unsafeWithArrayContents arrContents arrStart $ \ptr -> act (castPtr ptr)

2252+ unsafeWithArray arr $ \ptr -> act (castPtr ptr)

2255

2253

2256-------------------------------------------------------------------------------

2254-------------------------------------------------------------------------------

2257-- Equality

2255-- Equality

src/Streamly/Internal/Data/Array/Foreign/Type.hs+8

@@ -13,6 +13,7 @@ module Streamly.Internal.Data.Array.Foreign.Type

13 (

14 -- $arrayNotes

15 Array (..)

16+ , unsafeWithArray

17 -- * Freezing and Thawing

18 -- * Freezing and Thawing

18 , unsafeFreeze

19 , unsafeFreeze

@@ -158,6 +159,13 @@ data Array a =

158foreign import ccall unsafe "string.h strlen" c_strlen

159foreign import ccall unsafe "string.h strlen" c_strlen

159 :: CString -> IO CSize

160 :: CString -> IO CSize

160

161

162+-- | Similar to unsafeWithForeignPtr.

163+unsafeWithArray :: MonadIO m => Array a -> (Ptr a -> m b) -> m b

164+unsafeWithArray Array{..} f = do

165+ r <- f arrStart

166+ liftIO $ touch arrContents

167+ return r

168+

161-------------------------------------------------------------------------------

169-------------------------------------------------------------------------------

162-- Freezing and Thawing

170-- Freezing and Thawing

163-------------------------------------------------------------------------------

171-------------------------------------------------------------------------------

src/Streamly/Internal/FileSystem/FD.hs+4−5

@@ -131,9 +131,8 @@ import qualified GHC.IO.FD as FD

131import qualified GHC.IO.Device as RawIO

132

133import Streamly.Internal.Data.Array.Foreign.Type

134− (Array(..), byteLength, unsafeFreeze)

134+ (Array(..), byteLength, unsafeFreeze, unsafeWithArray)

135−import Streamly.Internal.Data.Array.Foreign.Mut.Type

135+import Streamly.Internal.Data.Array.Foreign.Mut.Type (fromForeignPtrUnsafe)

136− (fromForeignPtrUnsafe, unsafeWithArrayContents)

137import Streamly.Internal.System.IO (defaultChunkSize)

136import Streamly.Internal.System.IO (defaultChunkSize)

138import Streamly.Internal.Data.Stream.Serial (SerialT)

137import Streamly.Internal.Data.Stream.Serial (SerialT)

139import Streamly.Internal.Data.Stream.IsStream.Type

138import Streamly.Internal.Data.Stream.IsStream.Type

@@ -241,7 +240,7 @@ readArrayUpto size (Handle fd) = do

241writeArray :: Storable a => Handle -> Array a -> IO ()

240writeArray :: Storable a => Handle -> Array a -> IO ()

242writeArray _ arr | A.length arr == 0 = return ()

241writeArray _ arr | A.length arr == 0 = return ()

243writeArray (Handle fd) arr =

242writeArray (Handle fd) arr =

244− unsafeWithArrayContents (arrContents arr) (arrStart arr) $ \p ->

243+ unsafeWithArray arr $ \p ->

245 -- RawIO.writeAll fd (castPtr p) aLen

244 -- RawIO.writeAll fd (castPtr p) aLen

246#if MIN_VERSION_base(4,15,0)

245#if MIN_VERSION_base(4,15,0)

247 RawIO.write fd (castPtr p) 0 aLen

246 RawIO.write fd (castPtr p) 0 aLen

@@ -266,7 +265,7 @@ writeArray (Handle fd) arr =

266writeIOVec :: Handle -> Array RawIO.IOVec -> IO ()

265writeIOVec :: Handle -> Array RawIO.IOVec -> IO ()

267writeIOVec _ iov | A.length iov == 0 = return ()

266writeIOVec _ iov | A.length iov == 0 = return ()

268writeIOVec (Handle fd) iov =

267writeIOVec (Handle fd) iov =

269− unsafeWithArrayContents (arrContents iov) (arrStart iov) $ \p ->

268+ unsafeWithArray iov $ \p ->

270 RawIO.writevAll fd p (A.length iov)

269 RawIO.writevAll fd p (A.length iov)

271#endif

270#endif

272

271