More INLINE pragmas
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Mon, 16 Nov 2009 03:24:04 +0000 (03:24 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Mon, 16 Nov 2009 03:24:04 +0000 (03:24 +0000)
Data/Primitive/Array.hs
Data/Primitive/ByteArray.hs

index 11d06ba..f085cf1 100644 (file)
@@ -83,6 +83,7 @@ indexArrayM (Array arr#) (I# i#)
 -- | Convert a mutable array to an immutable one without copying. The
 -- array should not be modified after the conversion.
 unsafeFreezeArray :: PrimMonad m => MutableArray m a -> m (Array a)
+{-# INLINE unsafeFreezeArray #-}
 unsafeFreezeArray (MutableArray arr#)
   = primitive (\s# -> case unsafeFreezeArray# arr# s# of
                         (# s'#, arr'# #) -> (# s'#, Array arr'# #))
@@ -90,12 +91,14 @@ unsafeFreezeArray (MutableArray arr#)
 -- | Convert an immutable array to an mutable one without copying. The
 -- immutable array should not be used after the conversion.
 unsafeThawArray :: PrimMonad m => Array a -> m (MutableArray m a)
+{-# INLINE unsafeThawArray #-}
 unsafeThawArray (Array arr#)
   = primitive (\s# -> case unsafeThawArray# arr# s# of
                         (# s'#, arr'# #) -> (# s'#, MutableArray arr'# #))
 
 -- | Check whether the two arrays refer to the same memory block.
 sameMutableArray :: MutableArray m a -> MutableArray m a -> Bool
+{-# INLINE sameMutableArray #-}
 sameMutableArray (MutableArray arr#) (MutableArray brr#)
   = sameMutableArray# arr# brr#
 
index 4a7f2b1..ad919ef 100644 (file)
@@ -35,6 +35,7 @@ data MutableByteArray m = MutableByteArray (MutableByteArray# (PrimState m))
 
 -- | Create a new mutable byte array of the specified size.
 newByteArray :: PrimMonad m => Int -> m (MutableByteArray m)
+{-# INLINE newByteArray #-}
 newByteArray (I# n#)
   = primitive (\s# -> case newByteArray# n# s# of
                         (# s'#, arr# #) -> (# s'#, MutableByteArray arr# #))
@@ -42,6 +43,7 @@ newByteArray (I# n#)
 -- | Create a /pinned/ byte array of the specified size. The garbage collector
 -- is guaranteed not to move it.
 newPinnedByteArray :: PrimMonad m => Int -> m (MutableByteArray m)
+{-# INLINE newPinnedByteArray #-}
 newPinnedByteArray (I# n#)
   = primitive (\s# -> case newPinnedByteArray# n# s# of
                         (# s'#, arr# #) -> (# s'#, MutableByteArray arr# #))
@@ -49,6 +51,7 @@ newPinnedByteArray (I# n#)
 -- | Create a /pinned/ byte array of the specified size and with the give
 -- alignment. The garbage collector is guaranteed not to move it.
 newAlignedPinnedByteArray :: PrimMonad m => Int -> Int -> m (MutableByteArray m)
+{-# INLINE newAlignedPinnedByteArray #-}
 newAlignedPinnedByteArray (I# n#) (I# k#)
   = primitive (\s# -> case newAlignedPinnedByteArray# n# k# s# of
                         (# s'#, arr# #) -> (# s'#, MutableByteArray arr# #))
@@ -57,36 +60,43 @@ newAlignedPinnedByteArray (I# n#) (I# k#)
 -- /pinned/ byte arrays allocated by 'newPinnedByteArray' or
 -- 'newAlignedPinnedByteArray'.
 byteArrayContents :: ByteArray -> Addr
+{-# INLINE byteArrayContents #-}
 byteArrayContents (ByteArray arr#) = Addr (byteArrayContents# arr#)
 
 -- | Check if the two arrays refer to the same memory block.
 sameMutableByteArray :: MutableByteArray m -> MutableByteArray m -> Bool
+{-# INLINE sameMutableByteArray #-}
 sameMutableByteArray (MutableByteArray arr#) (MutableByteArray brr#)
   = sameMutableByteArray# arr# brr#
 
 -- | Convert a mutable byte array to an immutable one without copying. The
 -- array should not be modified after the conversion.
 unsafeFreezeByteArray :: PrimMonad m => MutableByteArray m -> m ByteArray
+{-# INLINE unsafeFreezeByteArray #-}
 unsafeFreezeByteArray (MutableByteArray arr#)
   = primitive (\s# -> case unsafeFreezeByteArray# arr# s# of
                         (# s'#, arr'# #) -> (# s'#, ByteArray arr'# #))
 
 -- | Size of the byte array.
 sizeofByteArray :: ByteArray -> Int
+{-# INLINE sizeofByteArray #-}
 sizeofByteArray (ByteArray arr#) = I# (sizeofByteArray# arr#)
 
 -- | Size of the mutable byte array.
 sizeofMutableByteArray :: MutableByteArray s -> Int
+{-# INLINE sizeofMutableByteArray #-}
 sizeofMutableByteArray (MutableByteArray arr#) = I# (sizeofMutableByteArray# arr#)
 
 -- | Read a primitive value from the byte array. The offset is given in
 -- elements of type @a@ rather than in bytes.
 indexByteArray :: Prim a => ByteArray -> Int -> a
+{-# INLINE indexByteArray #-}
 indexByteArray (ByteArray arr#) (I# i#) = indexByteArray# arr# i#
 
 -- | Read a primitive value from the byte array. The offset is given in
 -- elements of type @a@ rather than in bytes.
 readByteArray :: (Prim a, PrimMonad m) => MutableByteArray m -> Int -> m a
+{-# INLINE readByteArray #-}
 readByteArray (MutableByteArray arr#) (I# i#)
   = primitive (readByteArray# arr# i#)
 
@@ -94,6 +104,7 @@ readByteArray (MutableByteArray arr#) (I# i#)
 -- elements of type @a@ rather than in bytes.
 writeByteArray :: (Prim a, PrimMonad m)
                => MutableByteArray m -> Int -> a -> m ()
+{-# INLINE writeByteArray #-}
 writeByteArray (MutableByteArray arr#) (I# i#) x
   = primitive_ (writeByteArray# arr# i# x)