af57e26 · streamly · git.iko.soy

git.iko.soy/streamly

Rename asUnpinnedPtrUnsafe and deprecate asPtrUnsafe

asUnpinnedPtrUnsafe -> unsafeAsPtr asPtrUnsafe -> unsafePinnedAsPtr

commitaf57e26270a71c924a4256851b5c0ac81e65554a authorAdithya Kumar <adithya@composewell.com> dateWed 17 Jan 2024, 18:43 (3 years ago) parent6efb087

11 files changed+67−43

compare with master

unifiedsplit

core/docs/ApiChangelogs/0.2.0-0.2.2.txt+8−2

@@ -111,9 +111,11 @@ Internal API diff

111111 [D] sliceOnSuffix :: Monad m => (a -> Bool) -> Stream m a -> Stream m (Int, Int)

112112 [A] indexOnSuffix :: Monad m => (a -> Bool) -> Stream m a -> Stream m (Int, Int)

113113[C] Streamly.Internal.Data.MutByteArray

114+ [A] unsafePinnedAsPtr :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b

115+ [A] unsafeAsPtr :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b

114116 [D] nil :: MutByteArray

115117 [A] empty :: MutByteArray

116− [A] asUnpinnedPtrUnsafe :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b

118+ [D] asPtrUnsafe :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b

117119[D] Streamly.Internal.Data.MutArray.Stream

118120 [D] writeChunks :: (MonadIO m, Unbox a) => Int -> Fold m a (StreamK n (MutArray a))

119121 [D] fromArrayStreamK :: (Unbox a, MonadIO m) => StreamK m (MutArray a) -> m (MutArray a)

@@ -142,8 +144,10 @@ Internal API diff

142144 [D] writeAppendWith :: forall m a. (MonadIO m, Unbox a) => (Int -> Int) -> m (MutArray a) -> Fold m a (MutArray a)

143145 [D] writeAppendNUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)

144146 [A] unsafePinnedCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)

147+ [A] unsafePinnedAsPtr :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b

145148 [A] unsafeCreateOfWith :: forall m a. (MonadIO m, Unbox a) => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)

146149 [A] unsafeCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)

150+ [A] unsafeAsPtr :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b

147151 [A] unsafeAppendN :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)

148152 [A] toStreamWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> MutArray a -> Stream m a

149153 [A] toStreamRevWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> MutArray a -> Stream m a

@@ -210,7 +214,7 @@ Internal API diff

210214 [A] byteEq :: MonadIO m => MutArray a -> MutArray a -> m Bool

211215 [A] byteCmp :: MonadIO m => MutArray a -> MutArray a -> m Ordering

212216 [A] buildChunks :: (MonadIO m, Unbox a) => Int -> Fold m a (StreamK n (MutArray a))

213− [A] asUnpinnedPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b

217+ [D] asPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b

214218 [A] appendWith :: forall m a. (MonadIO m, Unbox a) => (Int -> Int) -> m (MutArray a) -> Fold m a (MutArray a)

215219 [A] appendN :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)

216220 [A] append :: forall m a. (MonadIO m, Unbox a) => m (MutArray a) -> Fold m a (MutArray a)

@@ -229,6 +233,7 @@ Internal API diff

229233 [A] create :: MonadIO m => Fold m a (Array a)

230234[C] Streamly.Internal.Data.Array

231235 [R] ArrayUnsafe

236+ [A] unsafePinnedAsPtr :: MonadIO m => Array a -> (Ptr a -> m b) -> m b

232237 [D] toStreamDRev :: forall m a. (Monad m, Unbox a) => Array a -> Stream m a

233238 [D] toStreamD :: forall m a. (Monad m, Unbox a) => Array a -> Stream m a

234239 [C] splice

@@ -276,3 +281,4 @@ Internal API diff

276281 [A] byteCmp :: Array a -> Array a -> Ordering

277282 [A] buildChunks :: (MonadIO m, Unbox a) => Stream m a -> m (StreamK m (Array a))

278283 [D] bufferChunks :: (MonadIO m, Unbox a) => Stream m a -> m (StreamK m (Array a))

284+ [D] asPtrUnsafe :: MonadIO m => Array a -> (Ptr a -> m b) -> m b

core/src/Streamly/Internal/Data/Array.hs+2−2

@@ -498,8 +498,8 @@ cast arr =

498498asCStringUnsafe :: Array a -> (CString -> IO b) -> IO b

499499asCStringUnsafe arr act = do

500500 let arr1 = asBytes arr <> fromList [0]

501− -- asPtrUnsafe makes sure the array is pinned

502− asPtrUnsafe arr1 $ \ptr -> act (castPtr ptr)

501+ -- unsafePinnedAsPtr makes sure the array is pinned

502+ unsafePinnedAsPtr arr1 $ \ptr -> act (castPtr ptr)

503503

504504-------------------------------------------------------------------------------

505505-- Folds

core/src/Streamly/Internal/Data/Array/Type.hs+9−3

@@ -28,7 +28,7 @@ module Streamly.Internal.Data.Array.Type

2828 , isPinned

2929

3030 -- *** Casting

31− , asPtrUnsafe

31+ , unsafePinnedAsPtr

3232

3333 -- ** Construction

3434 , empty

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

129129 , compactGE

130130

131131 -- ** Deprecated

132+ , asPtrUnsafe

132133 , unsafeIndex

133134 , bufferChunks

134135 , flattenArrays

@@ -231,15 +232,20 @@ data Array a =

231232

232233-- | Use an @Array a@ as @Ptr a@.

233234--

234−-- See 'MA.asPtrUnsafe' in the Mutable array module for more details.

235+-- See 'MA.unsafePinnedAsPtr' in the Mutable array module for more details.

235236--

236237-- /Unsafe/

237238--

238239-- /Pre-release/

239240--

241+{-# INLINE unsafePinnedAsPtr #-}

242+unsafePinnedAsPtr :: MonadIO m => Array a -> (Ptr a -> m b) -> m b

243+unsafePinnedAsPtr arr = MA.unsafePinnedAsPtr (unsafeThaw arr)

244+

245+{-# DEPRECATED asPtrUnsafe "Please use unsafePinnedAsPtr instead." #-}

240246{-# INLINE asPtrUnsafe #-}

241247asPtrUnsafe :: MonadIO m => Array a -> (Ptr a -> m b) -> m b

242−asPtrUnsafe arr = MA.asPtrUnsafe (unsafeThaw arr)

248+asPtrUnsafe = unsafePinnedAsPtr

243249

244250-------------------------------------------------------------------------------

245251-- Freezing and Thawing

core/src/Streamly/Internal/Data/MutArray/Type.hs+18−12

@@ -42,8 +42,8 @@ module Streamly.Internal.Data.MutArray.Type

4242 , cast

4343 , castUnsafe -- XXX unsafeCast

4444 , asBytes

45− , asPtrUnsafe -- XXX rename to unsafePinnedAsPtr?

46− , asUnpinnedPtrUnsafe -- XXX rename to unsafeAsPtr

45+ , unsafePinnedAsPtr

46+ , unsafeAsPtr

4747

4848 -- ** Construction

4949 , empty

@@ -264,6 +264,7 @@ module Streamly.Internal.Data.MutArray.Type

264264 , c_memchr

265265

266266 -- * Deprecated

267+ , asPtrUnsafe

267268 , writeChunks

268269 , flattenArrays

269270 , flattenArraysRev

@@ -2431,7 +2432,7 @@ fromPtrN len addr = do

24312432 -- XXX We can implement a stream copy in a similar way by streaming Word64

24322433 -- first and then remaining Word8.

24332434 arr <- new len

2434− _ <- asUnpinnedPtrUnsafe arr

2435+ _ <- unsafeAsPtr arr

24352436 (\ptr -> liftIO $ c_memcpy ptr addr (fromIntegral len))

24362437 return (arr {arrEnd = len})

24372438

@@ -2447,7 +2448,7 @@ fromByteStr# addr = do

24472448 len <- liftIO $ c_strlen (Ptr addr)

24482449 let lenInt = fromIntegral len

24492450 arr <- new lenInt

2450− _ <- asUnpinnedPtrUnsafe arr (\ptr -> liftIO $ c_memcpy ptr (Ptr addr) len)

2451+ _ <- unsafeAsPtr arr (\ptr -> liftIO $ c_memcpy ptr (Ptr addr) len)

24512452 return (arr {arrEnd = lenInt})

24522453

24532454-------------------------------------------------------------------------------

@@ -2735,7 +2736,7 @@ splitOn predicate arr =

27352736{-# INLINE breakOn #-}

27362737breakOn :: MonadIO m

27372738 => Word8 -> MutArray Word8 -> m (MutArray Word8, Maybe (MutArray Word8))

2738−breakOn sep arr@MutArray{..} = asUnpinnedPtrUnsafe arr $ \p -> liftIO $ do

2739+breakOn sep arr@MutArray{..} = unsafeAsPtr arr $ \p -> liftIO $ do

27392740 -- XXX We do not need memchr here, we can use a Haskell equivalent.

27402741 -- Need efficient stream based primitives that work on Word64.

27412742 loc <- c_memchr p sep (fromIntegral $ byteLength arr)

@@ -2866,16 +2867,21 @@ cast arr =

28662867--

28672868-- /Pre-release/

28682869--

2870+{-# INLINE unsafePinnedAsPtr #-}

2871+unsafePinnedAsPtr :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b

2872+unsafePinnedAsPtr arr f =

2873+ Unboxed.unsafePinnedAsPtr

2874+ (arrContents arr) (\ptr -> f (ptr `plusPtr` arrStart arr))

2875+

2876+{-# DEPRECATED asPtrUnsafe "Please use unsafePinnedAsPtr instead." #-}

28692877{-# INLINE asPtrUnsafe #-}

28702878asPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b

2871−asPtrUnsafe arr f =

2872− Unboxed.asPtrUnsafe

2873− (arrContents arr) (\ptr -> f (ptr `plusPtr` arrStart arr))

2879+asPtrUnsafe = unsafePinnedAsPtr

28742880

2875−{-# INLINE asUnpinnedPtrUnsafe #-}

2876−asUnpinnedPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b

2877−asUnpinnedPtrUnsafe arr f =

2878− Unboxed.asUnpinnedPtrUnsafe

2881+{-# INLINE unsafeAsPtr #-}

2882+unsafeAsPtr :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b

2883+unsafeAsPtr arr f =

2884+ Unboxed.unsafeAsPtr

28792885 (arrContents arr) (\ptr -> f (ptr `plusPtr` arrStart arr))

28802886

28812887-------------------------------------------------------------------------------

core/src/Streamly/Internal/Data/MutByteArray/Type.hs+14−8

@@ -34,10 +34,11 @@ module Streamly.Internal.Data.MutByteArray.Type

3434 , cloneSliceUnsafeAs

3535 , cloneSliceUnsafe

3636 , pinnedCloneSliceUnsafe

37− , asPtrUnsafe -- XXX unsafePinnedAsPtr

38− , asUnpinnedPtrUnsafe -- XXX unsafeAsPtr

37+ , unsafePinnedAsPtr

38+ , unsafeAsPtr

3939

4040 -- ** Deprecated

41+ , asPtrUnsafe

4142 , nil

4243 ) where

4344

@@ -117,9 +118,9 @@ touch (MutByteArray contents) =

117118--

118119-- /Pre-release/

119120--

120−{-# INLINE asPtrUnsafe #-}

121−asPtrUnsafe :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b

122−asPtrUnsafe arr f = do

121+{-# INLINE unsafePinnedAsPtr #-}

122+unsafePinnedAsPtr :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b

123+unsafePinnedAsPtr arr f = do

123124 contents <- liftIO $ pin arr

124125 let !ptr = Ptr (byteArrayContents#

125126 (unsafeCoerce# (getMutableByteArray# contents)))

@@ -127,10 +128,15 @@ asPtrUnsafe arr f = do

127128 liftIO $ touch contents

128129 return r

129130

131+{-# DEPRECATED asPtrUnsafe "Please use unsafePinnedAsPtr instead." #-}

132+{-# INLINE asPtrUnsafe #-}

133+asPtrUnsafe :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b

134+asPtrUnsafe = unsafePinnedAsPtr

135+

130136-- | For use with unsafe FFI functions. Does not force pin the array memory.

131−{-# INLINE asUnpinnedPtrUnsafe #-}

132−asUnpinnedPtrUnsafe :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b

133−asUnpinnedPtrUnsafe arr f = do

137+{-# INLINE unsafeAsPtr #-}

138+unsafeAsPtr :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b

139+unsafeAsPtr arr f = do

134140 let !ptr = Ptr (byteArrayContents#

135141 (unsafeCoerce# (getMutableByteArray# arr)))

136142 r <- f ptr

core/src/Streamly/Internal/FileSystem/Handle.hs+3−3

@@ -180,7 +180,7 @@ getChunk :: MonadIO m => Int -> Handle -> m (Array Word8)

180180getChunk size h = liftIO $ do

181181 arr :: MArray.MutArray Word8 <- MArray.pinnedEmptyOf size

182182 -- ptr <- mallocPlainForeignPtrAlignedBytes size (alignment (undefined :: Word8))

183− MArray.asPtrUnsafe arr $ \p -> do

183+ MArray.unsafePinnedAsPtr arr $ \p -> do

184184 n <- hGetBufSome h p size

185185 -- XXX shrink only if the diff is significant

186186 return $

@@ -380,12 +380,12 @@ read = A.concat . readChunks

380380{-# INLINABLE putChunk #-}

381381putChunk :: MonadIO m => Handle -> Array a -> m ()

382382putChunk _ arr | byteLength arr == 0 = return ()

383−putChunk h arr = A.asPtrUnsafe arr $ \ptr ->

383+putChunk h arr = A.unsafePinnedAsPtr arr $ \ptr ->

384384 liftIO $ hPutBuf h ptr aLen

385385

386386 where

387387

388− -- XXX We should have the length passed by asPtrUnsafe itself.

388+ -- XXX We should have the length passed by unsafePinnedAsPtr itself.

389389 aLen = A.byteLength arr

390390

391391-------------------------------------------------------------------------------

src/Streamly/Internal/FileSystem/Event/Darwin.hs+1−1

@@ -451,7 +451,7 @@ openWatch Config{..} paths = do

451451

452452 withPathName :: Array Word8 -> (PathName -> IO a) -> IO a

453453 withPathName arr act = do

454− A.asPtrUnsafe arr $ \ptr ->

454+ A.unsafePinnedAsPtr arr $ \ptr ->

455455 let pname = PathName (castPtr ptr) (fromIntegral (A.length arr))

456456 in act pname

457457

src/Streamly/Internal/FileSystem/Event/Linux.hs+2−2

@@ -188,7 +188,7 @@ import qualified Streamly.FileSystem.Handle as FH

188188import qualified Streamly.Unicode.Stream as U

189189

190190import qualified Streamly.Internal.Data.Array as A

191− ( fromStream, asCStringUnsafe, asPtrUnsafe

191+ ( fromStream, asCStringUnsafe, unsafePinnedAsPtr

192192 , getSliceUnsafe, read

193193 )

194194import qualified Streamly.Internal.FileSystem.Dir as Dir (readDirs)

@@ -809,7 +809,7 @@ readOneEvent :: Config -> Watch -> Parser Word8 IO Event

809809readOneEvent cfg wt@(Watch _ wdMap) = do

810810 let headerLen = sizeOf (undefined :: CInt) + 12

811811 arr <- PR.takeEQ headerLen (A.writeN headerLen)

812− (ewd, eflags, cookie, pathLen) <- PR.fromEffect $ A.asPtrUnsafe arr readHeader

812+ (ewd, eflags, cookie, pathLen) <- PR.fromEffect $ A.unsafePinnedAsPtr arr readHeader

813813 -- XXX need the "initial" in parsers to return a step type so that "take 0"

814814 -- can return without an input. otherwise if pathLen is 0 we will keep

815815 -- waiting to read one more char before we return this event.

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

@@ -130,7 +130,7 @@ import qualified GHC.IO.Device as RawIO

130130import Streamly.Data.Array (Array, Unbox)

131131import Streamly.Data.Stream (Stream)

132132

133−import Streamly.Internal.Data.Array (byteLength, unsafeFreeze, asPtrUnsafe)

133+import Streamly.Internal.Data.Array (byteLength, unsafeFreeze, unsafePinnedAsPtr)

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

135135

136136#if !defined(mingw32_HOST_OS)

@@ -147,7 +147,7 @@ import qualified Streamly.Internal.System.IOVec.Type as RawIO

147147import qualified Streamly.Data.Array as A

148148import qualified Streamly.Data.Fold as FL

149149import qualified Streamly.Internal.Data.MutArray as MArray

150− (MutArray(..), asPtrUnsafe, pinnedNewBytes)

150+ (MutArray(..), unsafePinnedAsPtr, pinnedNewBytes)

151151import qualified Streamly.Internal.Data.Array.Stream as AS

152152import qualified Streamly.Internal.Data.Stream as S

153153import qualified Streamly.Internal.Data.Stream as D

@@ -220,7 +220,7 @@ readArrayUpto :: Int -> Handle -> IO (Array Word8)

220220readArrayUpto size (Handle fd) = do

221221 arr <- MArray.pinnedNewBytes size

222222 -- ptr <- mallocPlainForeignPtrAlignedBytes size (alignment (undefined :: Word8))

223− MArray.asPtrUnsafe arr $ \p -> do

223+ MArray.unsafePinnedAsPtr arr $ \p -> do

224224 -- n <- hGetBufSome h p size

225225#if MIN_VERSION_base(4,15,0)

226226 n <- RawIO.read fd p 0 size

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

244244writeArray :: Unbox a => Handle -> Array a -> IO ()

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

246246writeArray (Handle fd) arr =

247− asPtrUnsafe arr $ \p ->

247+ unsafePinnedAsPtr arr $ \p ->

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

249249#if MIN_VERSION_base(4,15,0)

250250 RawIO.write fd (castPtr p) 0 aLen

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

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

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

272272writeIOVec (Handle fd) iov =

273− asPtrUnsafe iov $ \p ->

273+ unsafePinnedAsPtr iov $ \p ->

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

275275-}

276276#endif

src/Streamly/Internal/Network/Socket.hs+4−4

@@ -98,10 +98,10 @@ import qualified Streamly.Data.Fold as FL

9898import qualified Streamly.Data.Stream as S

9999import qualified Streamly.Data.Unfold as UF

100100import qualified Streamly.Internal.Data.Array as A

101− ( unsafeFreeze, asPtrUnsafe, byteLength, pinnedChunksOf,

101+ ( unsafeFreeze, unsafePinnedAsPtr, byteLength, pinnedChunksOf,

102102 pinnedWriteN, pinnedWriteNUnsafe, lCompactGE )

103103import qualified Streamly.Internal.Data.MutArray as MArray

104− (MutArray(..), asPtrUnsafe, pinnedEmptyOf)

104+ (MutArray(..), unsafePinnedAsPtr, pinnedEmptyOf)

105105import qualified Streamly.Internal.Data.Stream as S (fromStreamK, Stream(..), Step(..))

106106import qualified Streamly.Internal.Data.StreamK as K (mkStream)

107107

@@ -263,7 +263,7 @@ readArrayUptoWith

263263readArrayUptoWith f size h = do

264264 arr <- MArray.pinnedEmptyOf size

265265 -- ptr <- mallocPlainForeignPtrAlignedBytes size (alignment (undefined :: Word8))

266− MArray.asPtrUnsafe arr $ \p -> do

266+ MArray.unsafePinnedAsPtr arr $ \p -> do

267267 n <- f h p size

268268 let v = A.unsafeFreeze

269269 $ arr { MArray.arrEnd = n, MArray.arrBound = size }

@@ -311,7 +311,7 @@ writeArrayWith :: Unbox a

311311 -> Array a

312312 -> IO ()

313313writeArrayWith _ _ arr | A.length arr == 0 = return ()

314−writeArrayWith f h arr = A.asPtrUnsafe arr $ \ptr -> f h (castPtr ptr) aLen

314+writeArrayWith f h arr = A.unsafePinnedAsPtr arr $ \ptr -> f h (castPtr ptr) aLen

315315

316316 where

317317

test/Streamly/Test/Data/Array.hs+1−1

@@ -185,7 +185,7 @@ testUnsafeIndxedFromList inp =

185185testAsPtrUnsafeMA :: IO ()

186186testAsPtrUnsafeMA = do

187187 arr <- MA.fromList ([0 .. 99] :: [Int])

188− MA.asPtrUnsafe arr (getList (0 :: Int)) `shouldReturn` [0 .. 99]

188+ MA.unsafePinnedAsPtr arr (getList (0 :: Int)) `shouldReturn` [0 .. 99]

189189

190190 where

191191