Data.Prim.Memory.PArray

Documentation

newtype PArray (p :: Pinned) e

An immutable array with elements of type e

Constructors

PArray (Bytes p)

Instances

PtrAccess s (PArray 'Pin e)

Read-only access, but it is not enforced.

Defined in Data.Prim.Memory.PArray

Methods

toForeignPtr :: MonadPrim s m => PArray 'Pin e -> m (ForeignPtr a)

withPtrAccess :: MonadPrim s m => PArray 'Pin e -> (Ptr a -> m b) -> m b

withNoHaltPtrAccess :: MonadUnliftPrim s m => PArray 'Pin e -> (Ptr a -> m b) -> m b

(Typeable p, Prim e) => IsList (PArray p e)

Defined in Data.Prim.Memory.PArray

Associated Types

type Item (PArray p e)

Methods

fromList :: [Item (PArray p e)] -> PArray p e

fromListN :: Int -> [Item (PArray p e)] -> PArray p e

toList :: PArray p e -> [Item (PArray p e)]

(Prim e, Eq e) => Eq (PArray p e)

Defined in Data.Prim.Memory.PArray

Methods

(==) :: PArray p e -> PArray p e -> Bool

(/=) :: PArray p e -> PArray p e -> Bool

(Prim e, Ord e) => Ord (PArray p e)

Defined in Data.Prim.Memory.PArray

Methods

compare :: PArray p e -> PArray p e -> Ordering

(<) :: PArray p e -> PArray p e -> Bool

(<=) :: PArray p e -> PArray p e -> Bool

(>) :: PArray p e -> PArray p e -> Bool

(>=) :: PArray p e -> PArray p e -> Bool

max :: PArray p e -> PArray p e -> PArray p e

min :: PArray p e -> PArray p e -> PArray p e

(Show e, Prim e) => Show (PArray p e)

Defined in Data.Prim.Memory.PArray

Methods

showsPrec :: Int -> PArray p e -> ShowS

show :: PArray p e -> String

showList :: [PArray p e] -> ShowS

Typeable p => IsString (PArray p Char)

Defined in Data.Prim.Memory.PArray

Methods

fromString :: String -> PArray p Char

Typeable p => Semigroup (PArray p e)

Defined in Data.Prim.Memory.PArray

Methods

(<>) :: PArray p e -> PArray p e -> PArray p e

sconcat :: NonEmpty (PArray p e) -> PArray p e

stimes :: Integral b => b -> PArray p e -> PArray p e

Typeable p => Monoid (PArray p e)

Defined in Data.Prim.Memory.PArray

Methods

mempty :: PArray p e

mappend :: PArray p e -> PArray p e -> PArray p e

mconcat :: [PArray p e] -> PArray p e

NFData (PArray p e)

Defined in Data.Prim.Memory.PArray

Methods

rnf :: PArray p e -> ()

MemRead (PArray p e)

Defined in Data.Prim.Memory.PArray

Methods

isSameMem :: PArray p e -> PArray p e -> Bool

byteCountMem :: PArray p e -> Count Word8

indexOffMem :: Prim e0 => PArray p e -> Off e0 -> e0

indexByteOffMem :: Prim e0 => PArray p e -> Off Word8 -> e0

copyByteOffToMBytesMem :: forall s m e0 (p0 :: Pinned). (MonadPrim s m, Prim e0) => PArray p e -> Off Word8 -> MBytes p0 s -> Off Word8 -> Count e0 -> m ()

copyByteOffToPtrMem :: (MonadPrim s m, Prim e0) => PArray p e -> Off Word8 -> Ptr e0 -> Off Word8 -> Count e0 -> m ()

compareByteOffToPtrMem :: (MonadPrim s m, Prim e0) => PArray p e -> Off Word8 -> Ptr e0 -> Off Word8 -> Count e0 -> m Ordering

compareByteOffToBytesMem :: forall e0 (p0 :: Pinned). Prim e0 => PArray p e -> Off Word8 -> Bytes p0 -> Off Word8 -> Count e0 -> Ordering

compareByteOffMem :: (MemRead mr', Prim e0) => mr' -> Off Word8 -> PArray p e -> Off Word8 -> Count e0 -> Ordering

type Item (PArray p e)

Defined in Data.Prim.Memory.PArray

type Item (PArray p e) = e

newtype PMArray (p :: Pinned) e s

A mutable array with elements of type e

Constructors

PMArray (MBytes p s)

Instances

PtrAccess s (PMArray 'Pin e s)

Defined in Data.Prim.Memory.PArray

Methods

toForeignPtr :: MonadPrim s m => PMArray 'Pin e s -> m (ForeignPtr a)

withPtrAccess :: MonadPrim s m => PMArray 'Pin e s -> (Ptr a -> m b) -> m b

withNoHaltPtrAccess :: MonadUnliftPrim s m => PMArray 'Pin e s -> (Ptr a -> m b) -> m b

Typeable p => MemAlloc (PMArray p e)

Defined in Data.Prim.Memory.PArray

Associated Types

type FrozenMem (PMArray p e) = (fm :: Type)

Methods

getByteCountMutMem :: MonadPrim s m => PMArray p e s -> m (Count Word8)

allocMutMem :: (Prim e0, MonadPrim s m) => Count e0 -> m (PMArray p e s)

thawMem :: MonadPrim s m => FrozenMem (PMArray p e) -> m (PMArray p e s)

freezeMutMem :: MonadPrim s m => PMArray p e s -> m (FrozenMem (PMArray p e))

reallocMutMem :: (MonadPrim s m, Prim e0) => PMArray p e s -> Count e0 -> m (PMArray p e s)

MemWrite (PMArray p e)

Defined in Data.Prim.Memory.PArray

Methods

isSameMutMem :: PMArray p e s -> PMArray p e s -> Bool

readOffMutMem :: (MonadPrim s m, Prim e0) => PMArray p e s -> Off e0 -> m e0

readByteOffMutMem :: (MonadPrim s m, Prim e0) => PMArray p e s -> Off Word8 -> m e0

writeOffMutMem :: (MonadPrim s m, Prim e0) => PMArray p e s -> Off e0 -> e0 -> m ()

writeByteOffMutMem :: (MonadPrim s m, Prim e0) => PMArray p e s -> Off Word8 -> e0 -> m ()

moveByteOffToMBytesMutMem :: forall s m e0 (p0 :: Pinned). (MonadPrim s m, Prim e0) => PMArray p e s -> Off Word8 -> MBytes p0 s -> Off Word8 -> Count e0 -> m ()

moveByteOffToPtrMutMem :: (MonadPrim s m, Prim e0) => PMArray p e s -> Off Word8 -> Ptr e0 -> Off Word8 -> Count e0 -> m ()

copyByteOffMem :: (MonadPrim s m, MemRead mr, Prim e0) => mr -> Off Word8 -> PMArray p e s -> Off Word8 -> Count e0 -> m ()

moveByteOffMutMem :: (MonadPrim s m, MemWrite mw', Prim e0) => mw' s -> Off Word8 -> PMArray p e s -> Off Word8 -> Count e0 -> m ()

setMutMem :: (MonadPrim s m, Prim e0) => PMArray p e s -> Off e0 -> Count e0 -> e0 -> m ()

NFData (PMArray p e s)

Defined in Data.Prim.Memory.PArray

Methods

rnf :: PMArray p e s -> ()

type FrozenMem (PMArray p e)

Defined in Data.Prim.Memory.PArray

type FrozenMem (PMArray p e) = PArray p e

data Pinned

In GHC there is a distinction between pinned and unpinned memory.

Pinned memory is such that when allocated, it is guaranteed not to move throughout the lifetime of a program. In other words the address pointer that refers to allocated bytes will not change until the associated ByteArray# or MutableByteArray# is no longer referenced anywhere in the program at which point it gets garbage collected. On the other hand unpinned memory can be moved around during GC, which helps to reduce memory fragmentation.

Pinned/unpinnned choice during allocation is a bit of a lie, because when attempt is made to allocate memory as unpinned, but requested size is a bit more than a certain threshold (somewhere around 3KiB) it might still be allocated as pinned. Because of that fact through out the "primal" universe there is a distinction between memory that is either Pinned or Inconclusive.

It is possible to use one of toPinnedBytes or toPinnedMBytes to get a conclusive type.

Since: 0.1.0

Constructors

Pin

Pinned, which indicates that allocated memory will not move

Inc

Inconclusive, thus memory could be pinned or unpinned

fromBytesPArray :: Bytes p -> PArray p e

toBytesPArray :: PArray p e -> Bytes p

fromUArrayPArray :: UArray e -> PArray 'Inc e

O(1) - Cast UArray to PArray

Since: 0.3.0

toUArrayPArray :: PArray p e -> UArray e

O(1) - Cast PArray to UArray

Since: 0.3.0

castPArray :: PArray p e' -> PArray p e

fromMBytesPMArray :: MBytes p s -> PMArray p e s

toMBytesPMArray :: PMArray p e s -> MBytes p s

fromUMArrayPMArray :: UMArray e s -> PMArray 'Inc e s

O(1) - Cast UMArray to PMArray

Since: 0.3.0

toUMArrayPMArray :: PMArray p e s -> UMArray e s

O(1) - Cast PMArray to UMArray

Since: 0.3.0

castPMArray :: PMArray p e' s -> PMArray p e s

allocPMArray :: forall e p m s. (Typeable p, Prim e, MonadPrim s m) => Size -> m (PMArray p e s)

allocPinnedPMArray :: forall e m s. (MonadPrim s m, Prim e) => Size -> m (PMArray 'Pin e s)

allocAlignedPMArray

Arguments

:: (MonadPrim s m, Prim e)

=> Count e

Size in number of bytes

-> m (PMArray 'Pin e s)

allocUnpinnedPMArray :: forall e m s. (MonadPrim s m, Prim e) => Size -> m (PMArray 'Inc e s)

shrinkPMArray :: forall e p m s. (MonadPrim s m, Prim e) => PMArray p e s -> Size -> m ()

Shrink mutable bytes to new specified count of elements. The new count must be less than or equal to the current count as reported by getCountPMArray.

resizePMArray :: forall e p m s. (MonadPrim s m, Prim e) => PMArray p e s -> Size -> m (PMArray 'Inc e s)

Attempt to resize mutable bytes in place.

• New bytes might be allocated, with the copy of an old one.
• Old references should not be kept around to allow GC to claim it
• Old references should not be used to avoid undefined behavior

reallocPMArray :: forall e p m s. (MonadPrim s m, Typeable p, Prim e) => PMArray p e s -> Size -> m (PMArray p e s)

isPinnedPArray :: PArray p e -> Bool

isPinnedPMArray :: PMArray p e s -> Bool

thawPArray :: MonadPrim s m => PArray p e -> m (PMArray p e s)

freezePMArray :: MonadPrim s m => PMArray p e s -> m (PArray p e)

sizePArray :: forall e p. Prim e => PArray p e -> Size

getSizePMArray :: forall e p m s. (MonadPrim s m, Prim e) => PMArray p e s -> m Size

readPMArray :: (MonadPrim s m, Prim e) => PMArray p e s -> Int -> m e

writePMArray :: (MonadPrim s m, Prim e) => PMArray p e s -> Int -> e -> m ()

setPMArray

Arguments

:: forall e p m s. (MonadPrim s m, Prim e)

=> PMArray p e s

Chunk of memory to fill

-> Int

Offset in number of elements

-> Size

Number of cells to fill

-> e

A value to fill the cells with

-> m ()

copyPArrayToPMArray :: forall e p m s. (MonadPrim s m, Prim e) => PArray p e -> Int -> PMArray p e s -> Int -> Size -> m ()

movePMArrayToPMArray :: forall e p m s. (MonadPrim s m, Prim e) => PMArray p e s -> Int -> PMArray p e s -> Int -> Size -> m ()