Struct KeepaliveLocalMemory 

pub struct KeepaliveLocalMemory { /* private fields */ }

Local memory handle that keeps its backing allocation alive via an Arc<dyn Keepalive>.

Detects at construction time whether the address is a CUDA device pointer and dispatches read_at/write_at accordingly.

All three access methods are unsafe: the Keepalive only guarantees the allocation stays mapped, not that this handle has unique ownership. The internal [AccessLock] coordinates concurrent callers that share the same clone of this handle (readers run in parallel, exclusive writers run alone, disjoint writers run in parallel with one another but exclude readers and exclusive writers), but callers must additionally rule out concurrent access through other views of the same allocation.

The direct_access_host_bandwidth and direct_access_device_bandwidth fields indicate the speed of reading the memory via pointer dereference on a host or device thread, respectively. A value of None means the memory is not directly accessible from that context.

Implementations

impl KeepaliveLocalMemory

pub fn new(addr: usize, size: usize, keepalive: Arc<dyn Keepalive>) -> Self

Create a new handle. Probes the CUDA driver to determine whether addr is a device pointer and sets the bandwidth fields accordingly.

pub fn addr(&self) -> usize

Starting virtual address of the memory region.

pub fn size(&self) -> usize

Size of the memory region in bytes.

pub unsafe fn read_at(&self, offset: usize, dst: &mut [u8]) -> Result<(), Error>

Copy dst.len() bytes from this memory region starting at offset into dst.

Mutually exclusive with both write_at and write_at_disjoint across clones of this handle: the [AccessLock] guarantees a reader and any writer (exclusive or disjoint) that share the same lock never observe each other’s partial state. Multiple concurrent read_at calls on shared clones are permitted and run in parallel.

Safety

The Keepalive guarantees the allocation stays mapped, but it does not imply unique ownership: another component may hold its own view of the same allocation and read or write it concurrently outside this handle’s [AccessLock]. The caller must ensure that no such external access produces a torn read of offset..offset + dst.len() for the duration of this call.

pub unsafe fn write_at(&self, offset: usize, src: &[u8]) -> Result<(), Error>

Copy src.len() bytes from src into this memory region starting at offset.

Mutually exclusive with every other read and write against this region across clones of this handle: the [AccessLock] blocks concurrent readers and writers that share the same lock. Use KeepaliveLocalMemory::write_at_disjoint when multiple writers can be proven to target disjoint byte ranges.

Safety

See KeepaliveLocalMemory::read_at. The Keepalive guarantee covers liveness only; the caller must ensure no concurrent external reader or writer observes an overlapping byte range.

pub unsafe fn write_at_disjoint( &self, offset: usize, src: &[u8], ) -> Result<(), Error>

Like KeepaliveLocalMemory::write_at, but allows other concurrent write_at_disjoint calls (across clones of this handle) to proceed in parallel. Still mutually exclusive with read_at and write_at through the [AccessLock].

Safety

In addition to the obligations of KeepaliveLocalMemory::write_at (no external concurrent reader or writer of the same byte range), the caller must ensure that no other concurrent call to this method targets a byte range that overlaps offset..offset + src.len(). Disjoint byte ranges across concurrent disjoint callers are sound.

Trait Implementations

impl Clone for KeepaliveLocalMemory

fn clone(&self) -> KeepaliveLocalMemory

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for KeepaliveLocalMemory

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.