Struct rendy_memory::MappedRange

pub struct MappedRange<'a, B: Backend, C = MaybeCoherent> { /* fields omitted */ }

Represents range of the memory mapped to the host. Provides methods for safer host access to the memory.

Methods

impl<'a, B> MappedRange<'a, B> where
    B: Backend, 

pub unsafe fn from_raw(
    memory: &'a Memory<B>,
    ptr: NonNull<u8>,
    range: Range<u64>
) -> Self

Construct mapped range from raw mapping

Safety

memory range must be mapped to host memory region pointer by ptr. range is in memory object space. ptr points to the range.start offset from memory origin.

pub fn ptr(&self) -> NonNull<u8>

Get pointer to beginning of memory region. i.e. to range().start offset from memory origin.

pub fn range(&self) -> Range<u64>

Get mapped range.

pub unsafe fn read<'b, T>(
    &'b mut self,
    device: &B::Device,
    range: Range<u64>
) -> Result<&'b [T], Error> where
    'a: 'b,
    T: Copy, 

Fetch readable slice of sub-range to be read. Invalidating range if memory is not coherent. range.end - range.start must be multiple of size_of::(). mapping offset + range.start must be multiple of align_of::().

Safety

• Caller must ensure that device won't write to the memory region until the borrowing ends.
• T Must be plain-old-data type compatible with data in mapped region.

pub unsafe fn write<'b, T: 'b>(
    &'b mut self,
    device: &'b B::Device,
    range: Range<u64>
) -> Result<impl Write<T> + 'b, Error> where
    'a: 'b,
    T: Copy, 

Fetch writer to the sub-region. This writer will flush data on drop if written at least once.

Safety

• Caller must ensure that device won't write to or read from the memory region.

pub fn coherent(
    self
) -> Result<MappedRange<'a, B, Coherent>, MappedRange<'a, B, NonCoherent>>

Convert into mapped range with statically known coherency.

impl<'a, B> MappedRange<'a, B, Coherent> where
    B: Backend, 

pub unsafe fn write<'b, U: 'b>(
    &'b mut self,
    range: Range<u64>
) -> Result<impl Write<U> + 'b, Error> where
    U: Copy, 

Fetch writer to the sub-region.

Safety

• Caller must ensure that device won't write to or read from the memory region.

Trait Implementations

impl<'a, B> From<MappedRange<'a, B, Coherent>> for MappedRange<'a, B> where
    B: Backend, 

fn from(range: MappedRange<'a, B, Coherent>) -> Self

Performs the conversion.

impl<'a, B> From<MappedRange<'a, B, NonCoherent>> for MappedRange<'a, B> where
    B: Backend, 

fn from(range: MappedRange<'a, B, NonCoherent>) -> Self

Performs the conversion.

impl<'a, B: Debug + Backend, C: Debug> Debug for MappedRange<'a, B, C>

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

Formats the value using the given formatter.