Data.Prim.Memory.Addr

Immutable Addr

data Addr e

Constructors

Addr

Fields

• addrAddr# :: Addr#
• addrBytes :: !(Bytes Pin)

Instances

PtrAccess s (Addr e)

Read-only access, but it is not enforced.

Defined in Data.Prim.Memory.Addr

Methods

toForeignPtr :: MonadPrim s m => Addr e -> m (ForeignPtr a)

withPtrAccess :: MonadPrim s m => Addr e -> (Ptr a -> m b) -> m b

withNoHaltPtrAccess :: MonadUnliftPrim s m => Addr e -> (Ptr a -> m b) -> m b

Prim e => IsList (Addr e)

Defined in Data.Prim.Memory.Addr

Associated Types

type Item (Addr e) :: Type

Methods

fromList :: [Item (Addr e)] -> Addr e

fromListN :: Int -> [Item (Addr e)] -> Addr e

toList :: Addr e -> [Item (Addr e)]

Eq (Addr e)

Defined in Data.Prim.Memory.Addr

Methods

(==) :: Addr e -> Addr e -> Bool

(/=) :: Addr e -> Addr e -> Bool

(Show e, Prim e) => Show (Addr e)

Defined in Data.Prim.Memory.Addr

Methods

showsPrec :: Int -> Addr e -> ShowS

show :: Addr e -> String

showList :: [Addr e] -> ShowS

IsString (Addr Char)

Defined in Data.Prim.Memory.Addr

Methods

fromString :: String -> Addr Char

Semigroup (Addr e)

Defined in Data.Prim.Memory.Addr

Methods

(<>) :: Addr e -> Addr e -> Addr e

sconcat :: NonEmpty (Addr e) -> Addr e

stimes :: Integral b => b -> Addr e -> Addr e

Monoid (Addr e)

Defined in Data.Prim.Memory.Addr

Methods

mempty :: Addr e

mappend :: Addr e -> Addr e -> Addr e

mconcat :: [Addr e] -> Addr e

NFData (Addr e)

Defined in Data.Prim.Memory.Addr

Methods

rnf :: Addr e -> ()

MemRead (Addr e)

Defined in Data.Prim.Memory.Addr

Methods

byteCountMem :: Addr e -> Count Word8

indexOffMem :: Prim e0 => Addr e -> Off e0 -> e0

indexByteOffMem :: Prim e0 => Addr e -> Off Word8 -> e0

copyByteOffToMBytesMem :: (MonadPrim s m, Prim e0) => Addr e -> Off Word8 -> MBytes p s -> Off Word8 -> Count e0 -> m ()

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

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

compareByteOffToBytesMem :: (MonadPrim s m, Prim e0) => Addr e -> Off Word8 -> Bytes p -> Off Word8 -> Count e0 -> m Ordering

compareByteOffMem :: (MemRead r', Prim e0) => r' -> Off Word8 -> Addr e -> Off Word8 -> Count e0 -> Ordering

type Item (Addr e)

Defined in Data.Prim.Memory.Addr

type Item (Addr e) = e

castAddr :: Addr e -> Addr b

fromBytesAddr :: Bytes Pin -> Addr e

curOffAddr :: Prim e => Addr e -> Off e

byteCountAddr :: Addr e -> Count Word8

countAddr :: forall e. Prim e => Addr e -> Count e

plusOffAddr :: Prim e => Addr e -> Off e -> Addr e

indexAddr :: Prim e => Addr e -> e

indexOffAddr :: Prim e => Addr e -> Off e -> e

indexByteOffAddr :: Prim e => Addr e -> Off Word8 -> e

readAddr :: (MonadPrim s m, Prim e) => Addr e -> m e

readOffAddr :: (MonadPrim s m, Prim e) => Addr e -> Off e -> m e

readByteOffAddr :: (MonadPrim s m, Prim e) => Addr e -> Off Word8 -> m e

thawAddr :: MonadPrim s m => Addr e -> m (MAddr e s)

freezeMAddr :: MonadPrim s m => MAddr e s -> m (Addr e)

withPtrAddr :: MonadPrim s m => Addr e -> (Ptr e -> m b) -> m b

withAddrAddr# :: MonadPrim s m => Addr e -> (Addr# -> m b) -> m b

withNoHaltPtrAddr :: MonadUnliftPrim s m => Addr e -> (Ptr e -> m b) -> m b

Mutable MAddr

data MAddr e s

Constructors

MAddr

Fields

• mAddrAddr# :: Addr#
• mAddrMBytes :: !(MBytes Pin s)

Instances

PtrAccess s (MAddr e s)

Defined in Data.Prim.Memory.Addr

Methods

toForeignPtr :: MonadPrim s m => MAddr e s -> m (ForeignPtr a)

withPtrAccess :: MonadPrim s m => MAddr e s -> (Ptr a -> m b) -> m b

withNoHaltPtrAccess :: MonadUnliftPrim s m => MAddr e s -> (Ptr a -> m b) -> m b

MemWrite (MAddr e)

Defined in Data.Prim.Memory.Addr

Methods

readOffMem :: (MonadPrim s m, Prim e0) => MAddr e s -> Off e0 -> m e0

readByteOffMem :: (MonadPrim s m, Prim e0) => MAddr e s -> Off Word8 -> m e0

writeOffMem :: (MonadPrim s m, Prim e0) => MAddr e s -> Off e0 -> e0 -> m ()

writeByteOffMem :: (MonadPrim s m, Prim e0) => MAddr e s -> Off Word8 -> e0 -> m ()

moveByteOffToMBytesMem :: (MonadPrim s m, Prim e0) => MAddr e s -> Off Word8 -> MBytes p s -> Off Word8 -> Count e0 -> m ()

moveByteOffToPtrMem :: (MonadPrim s m, Prim e0) => MAddr e s -> Off Word8 -> Ptr e0 -> Off Word8 -> Count e0 -> m ()

copyByteOffMem :: (MonadPrim s m, MemRead r, Prim e0) => r -> Off Word8 -> MAddr e s -> Off Word8 -> Count e0 -> m ()

moveByteOffMem :: (MonadPrim s m, MemWrite w', Prim e0) => w' s -> Off Word8 -> MAddr e s -> Off Word8 -> Count e0 -> m ()

setMem :: (MonadPrim s m, Prim e0) => MAddr e s -> Off e0 -> Count e0 -> e0 -> m ()

MemAlloc (MAddr e)

Defined in Data.Prim.Memory.Addr

Associated Types

type FrozenMem (MAddr e) = (fa :: Type)

Methods

getByteCountMem :: MonadPrim s m => MAddr e s -> m (Count Word8)

allocByteCountMem :: MonadPrim s m => Count Word8 -> m (MAddr e s)

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

freezeMem :: MonadPrim s m => MAddr e s -> m (FrozenMem (MAddr e))

resizeMem :: (MonadPrim s m, Prim e0) => MAddr e s -> Count e0 -> m (MAddr e s)

NFData (MAddr e s)

Defined in Data.Prim.Memory.Addr

Methods

rnf :: MAddr e s -> ()

type FrozenMem (MAddr e)

Defined in Data.Prim.Memory.Addr

type FrozenMem (MAddr e) = Addr e

castMAddr :: MAddr e s -> MAddr b s

allocMAddr :: (MonadPrim s m, Prim e) => Count e -> m (MAddr e s)

callocMAddr :: (MonadPrim s m, Prim e) => Count e -> m (MAddr e s)

reallocMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> Count e -> m (MAddr e s)

shrinkMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> Count e -> m ()

Shrink mutable address to new specified size in number of elements. The new count must be less than or equal to the current as reported by getCountMAddr.

shrinkByteCountMAddr :: MonadPrim s m => MAddr e s -> Count Word8 -> m ()

Shrink mutable address to new specified size in bytes. The new count must be less than or equal to the current as reported by getByteCountMAddr.

setMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> Off e -> Count e -> e -> m ()

curOffMAddr :: forall e s. Prim e => MAddr e s -> Off e

getByteCountMAddr :: MonadPrim s m => MAddr e s -> m (Count Word8)

getCountMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> m (Count e)

plusOffMAddr :: Prim e => MAddr e s -> Off e -> MAddr e s

readMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> m e

readOffMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> Off e -> m e

readByteOffMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> Off Word8 -> m e

writeMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> e -> m ()

writeOffMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> Off e -> e -> m ()

writeByteOffMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> Off Word8 -> e -> m ()

copyAddrToMAddr :: (MonadPrim s m, Prim e) => Addr e -> Off e -> MAddr e s -> Off e -> Count e -> m ()

moveMAddrToMAddr :: (MonadPrim s m, Prim e) => MAddr e s -> Off e -> MAddr e s -> Off e -> Count e -> m ()

withPtrMAddr :: MonadPrim s m => MAddr e s -> (Ptr e -> m b) -> m b

withAddrMAddr# :: MonadPrim s m => MAddr e s -> (Addr# -> m b) -> m b

withNoHaltPtrMAddr :: MonadUnliftPrim s m => MAddr e s -> (Ptr e -> m b) -> m b

toForeignPtrAddr :: Addr e -> ForeignPtr e

toForeignPtrMAddr :: MAddr e s -> ForeignPtr e

fromForeignPtrAddr :: ForeignPtr e -> Maybe (Addr e)

Discarding the original ForeignPtr will trigger finalizers that were attached to it, because Addr does not retain any finalizers. This is a unsafe cast therefore modification of ForeignPtr will be reflected in resulting immutable Addr. Pointer created with malloc cannot be converted to Addr and will result in Nothing

Since: 0.1.0

fromForeignPtrMAddr :: ForeignPtr e -> Maybe (MAddr e s)

Discarding the original ForeignPtr will trigger finalizers that were attached to it, because MAddr does not retain any finalizers. Pointer created with malloc cannot be converted to MAddr and will result in Nothing

Since: 0.1.0

Conversion

ByteString

toByteStringAddr :: Addr Word8 -> ByteString

O(1) - Cast an immutable Addr to an immutable ByteString

Since: 0.1.0

toShortByteStringAddr :: Addr Word8 -> (ShortByteString, Off Word8)

O(1) - Cast an immutable Addr to an immutable ShortByteString

Since: 0.1.0

fromShortByteStringAddr :: ShortByteString -> Addr Word8

O(1) - Cast an immutable ShortByteString to an immutable Addr. In a most common case when ShortByteString is not backed by pinned memory, this function will return Nothing.

Since: 0.1.0

fromByteStringAddr :: ByteString -> (Addr Word8, Count Word8)

O(1) - Cast an immutable ByteString to Addr. Also returns the original length of ByteString, which will be less or equal to countOfAddr in the produced Addr.

Since: 0.1.0

fromByteStringMAddr :: ByteString -> (MAddr Word8 s, Count Word8)

O(1) - Cast an immutable ByteString to a mutable MAddr. Also returns the original length of ByteString, which will be less or equal to getCountOfMAddr in the produced MAddr.

Unsafe - Further modification of MAddr will affect the source ByteString

Since: 0.1.0

Atomic

casOffMAddr

Arguments

:: (MonadPrim s m, Atomic e)

=> MAddr e s

Array to be mutated

-> Off e

Index is in elements of e, rather than bytes.

-> e

Expected old value

-> e

New value

-> m e

Perform atomic modification of an element in the MAddr at the supplied index. Returns the artifact of computation b. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

casBoolOffMAddr

Arguments

:: (MonadPrim s m, Atomic e)

=> MAddr e s

Array to be mutated

-> Off e

Index is in elements of e, rather than bytes.

-> e

Expected old value

-> e

New value

-> m Bool

Perform atomic modification of an element in the MAddr at the supplied index. Returns True if swap was successfull and false otherwise. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

casBoolFetchOffMAddr

Arguments

:: (MonadPrim s m, Atomic e)

=> MAddr e s

Array to be mutated

-> Off e

Index is in elements of e, rather than bytes.

-> e

Expected old value

-> e

New value

-> m (Bool, e)

Just like casBoolOffMAddr, but also returns the actual value, which will match the supplied expected value if the returned flag is True

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicReadOffMAddr

Arguments

:: (MonadPrim s m, Atomic e)

=> MAddr e s

Array to be mutated

-> Off e

Index is in elements of e, rather than bytes.

-> m e

Perform atomic read of an element in the MAddr at the supplied offset. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicWriteOffMAddr

Arguments

:: (MonadPrim s m, Atomic e)

=> MAddr e s

Array to be mutated

-> Off e

Index is in elements of e, rather than bytes.

-> e

-> m ()

Perform atomic write of an element in the MAddr at the supplied offset. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicModifyOffMAddr

Arguments

:: (MonadPrim s m, Atomic e)

=> MAddr e s

Array to be mutated

-> Off e

Index is in elements of e, rather than bytes.

-> (e -> (e, b))

Function that is applied to the old value and returns new value and some artifact of computation b

-> m b

Perform atomic modification of an element in the MAddr at the supplied index. Returns the artifact of computation b. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicModifyOffMAddr_

Arguments

:: (MonadPrim s m, Atomic e)

=> MAddr e s

Array to be mutated

-> Off e

Index is in elements of e, rather than bytes.

-> (e -> e)

Function that is applied to the current value

-> m ()

Perform atomic modification of an element in the MAddr at the supplied index. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicModifyFetchOldOffMAddr

Arguments

:: (MonadPrim s m, Atomic e)

=> MAddr e s

Array to be mutated

-> Off e

Index is in elements of e, rather than bytes.

-> (e -> e)

Function that is applied to the old value

-> m e

Returns the old value

Perform atomic modification of an element in the MAddr at the supplied index. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicModifyFetchNewOffMAddr

Arguments

:: (MonadPrim s m, Atomic e)

=> MAddr e s

Array to be mutated

-> Off e

Index is in elements of e, rather than bytes

-> (e -> e)

Function that is applied to the old value

-> m e

Returns the new value

Perform atomic modification of an element in the MAddr at the supplied index. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

Numeric

atomicAddFetchOldOffMAddr :: (MonadPrim s m, AtomicCount e) => MAddr e s -> Off e -> e -> m e

Add a numeric value to an element of a MAddr, corresponds to (+) done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicAddFetchNewOffMAddr :: (MonadPrim s m, AtomicCount e) => MAddr e s -> Off e -> e -> m e

Add a numeric value to an element of a MAddr, corresponds to (+) done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicSubFetchOldOffMAddr :: (MonadPrim s m, AtomicCount e) => MAddr e s -> Off e -> e -> m e

Subtract a numeric value from an element of a MAddr, corresponds to (-) done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicSubFetchNewOffMAddr :: (MonadPrim s m, AtomicCount e) => MAddr e s -> Off e -> e -> m e

Subtract a numeric value from an element of a MAddr, corresponds to (-) done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

Binary

atomicAndFetchOldOffMAddr :: (MonadPrim s m, AtomicBits e) => MAddr e s -> Off e -> e -> m e

Binary conjunction (AND) of an element of a MAddr with the supplied value, corresponds to (.&.) done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicAndFetchNewOffMAddr :: (MonadPrim s m, AtomicBits e) => MAddr e s -> Off e -> e -> m e

Binary conjunction (AND) of an element of a MAddr with the supplied value, corresponds to (.&.) done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicNandFetchOldOffMAddr :: (MonadPrim s m, AtomicBits e) => MAddr e s -> Off e -> e -> m e

Negation of binary conjunction (NAND) of an element of a MAddr with the supplied value, corresponds to \x y -> complement (x .&. y) done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicNandFetchNewOffMAddr :: (MonadPrim s m, AtomicBits e) => MAddr e s -> Off e -> e -> m e

Negation of binary conjunction (NAND) of an element of a MAddr with the supplied value, corresponds to \x y -> complement (x .&. y) done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicOrFetchOldOffMAddr :: (MonadPrim s m, AtomicBits e) => MAddr e s -> Off e -> e -> m e

Binary disjunction (OR) of an element of a MAddr with the supplied value, corresponds to (.|.) done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicOrFetchNewOffMAddr :: (MonadPrim s m, AtomicBits e) => MAddr e s -> Off e -> e -> m e

Binary disjunction (OR) of an element of a MAddr with the supplied value, corresponds to (.|.) done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicXorFetchOldOffMAddr :: (MonadPrim s m, AtomicBits e) => MAddr e s -> Off e -> e -> m e

Binary exclusive disjunction (XOR) of an element of a MAddr with the supplied value, corresponds to xor done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicXorFetchNewOffMAddr :: (MonadPrim s m, AtomicBits e) => MAddr e s -> Off e -> e -> m e

Binary exclusive disjunction (XOR) of an element of a MAddr with the supplied value, corresponds to xor done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicNotFetchOldOffMAddr :: (MonadPrim s m, AtomicBits e) => MAddr e s -> Off e -> m e

Binary negation (NOT) of an element of a MAddr, corresponds to (complement) done atomically. Returns the previous value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

atomicNotFetchNewOffMAddr :: (MonadPrim s m, AtomicBits e) => MAddr e s -> Off e -> m e

Binary negation (NOT) of an element of a MAddr, corresponds to (complement) done atomically. Returns the new value. Offset is in number of elements, rather than bytes. Implies a full memory barrier.

Note - Bounds are not checked, therefore this function is unsafe.

Since: 0.1.0

Prefetch

Directly

prefetchAddr0 :: MonadPrim s m => Addr e -> m ()

prefetchMAddr0 :: MonadPrim s m => MAddr e s -> m ()

prefetchAddr1 :: MonadPrim s m => Addr e -> m ()

prefetchMAddr1 :: MonadPrim s m => MAddr e s -> m ()

prefetchAddr2 :: MonadPrim s m => Addr e -> m ()

prefetchMAddr2 :: MonadPrim s m => MAddr e s -> m ()

prefetchAddr3 :: MonadPrim s m => Addr e -> m ()

prefetchMAddr3 :: MonadPrim s m => MAddr e s -> m ()

With offset

prefetchOffAddr0 :: (MonadPrim s m, Prim e) => Addr e -> Off e -> m ()

prefetchOffMAddr0 :: (MonadPrim s m, Prim e) => MAddr e s -> Off e -> m ()

prefetchOffAddr1 :: (MonadPrim s m, Prim e) => Addr e -> Off e -> m ()

prefetchOffMAddr1 :: (MonadPrim s m, Prim e) => MAddr e s -> Off e -> m ()

prefetchOffAddr2 :: (MonadPrim s m, Prim e) => Addr e -> Off e -> m ()

prefetchOffMAddr2 :: (MonadPrim s m, Prim e) => MAddr e s -> Off e -> m ()

prefetchOffAddr3 :: (MonadPrim s m, Prim e) => Addr e -> Off e -> m ()

prefetchOffMAddr3 :: (MonadPrim s m, Prim e) => MAddr e s -> Off e -> m ()

Re-export

module Data.Prim