Struct memflow::mem::memory_view::batcher::MemoryViewBatcher
source · pub struct MemoryViewBatcher<'a, T: MemoryView> { /* private fields */ }
Expand description
A structure for batching memory reads and writes.
Examples
use memflow::prelude::v1::*;
use memflow::dummy::DummyMemory;
let mut virt_mem = VirtualDma::new(phys_mem, x64::ARCH, translator);
let mut batcher = MemoryViewBatcher::new(&mut virt_mem);
Implementations§
source§impl<'a, T: MemoryView> MemoryViewBatcher<'a, T>
impl<'a, T: MemoryView> MemoryViewBatcher<'a, T>
sourcepub fn new(vmem: &'a mut T) -> Self
pub fn new(vmem: &'a mut T) -> Self
Creates a new MemoryViewBatcher
instance.
Examples
use memflow::prelude::v1::*;
use memflow::dummy::DummyMemory;
let mut virt_mem = VirtualDma::new(phys_mem, x64::ARCH, translator);
let mut batcher = MemoryViewBatcher::new(&mut virt_mem);
sourcepub fn reserve(&mut self, capacity: usize) -> &mut Self
pub fn reserve(&mut self, capacity: usize) -> &mut Self
Reserves capacity for the read list.
Reserves capacity for at least additional
more elements to be handled
in the given MemoryViewBatcher<'a, T>
. The internal collection may reserve
more space to speculatively avoid frequent reallocations.
Arguments
capacity
: The number of operations to reserve space for.
Examples
use memflow::prelude::v1::*;
use memflow::dummy::DummyMemory;
let mut virt_mem = VirtualDma::new(phys_mem, x64::ARCH, translator);
let mut batcher = MemoryViewBatcher::new(&mut virt_mem);
// Reserve space 10 operations
batcher.reserve(10);
Panics
Panics if the new capacity exceeds isize::MAX
bytes.
sourcepub fn commit_rw(&mut self) -> PartialResult<()>
pub fn commit_rw(&mut self) -> PartialResult<()>
Executes all pending operations in this batch.
This also consumes and discards this batcher so it cannot be used anymore.
The same behavior can be achieved by implicitly calling drop
on the batcher
(for example, when going out of scope).
Examples
use memflow::prelude::v1::*;
use memflow::dummy::DummyMemory;
let mut virt_mem = VirtualDma::new(phys_mem, x64::ARCH, translator);
let mut batcher = MemoryViewBatcher::new(&mut virt_mem);
// commit the batch to memory, this is optional and just used to check if the operations succeed
batcher.commit_rw().unwrap();
sourcepub fn read_raw_iter(&mut self, iter: impl ReadIterator<'a>) -> &mut Self
pub fn read_raw_iter(&mut self, iter: impl ReadIterator<'a>) -> &mut Self
Appends an iterator over read operations ReadIter
to this batch.
Arguments
iter
: An iterator overReadData
instances.
Examples
use memflow::prelude::v1::*;
use memflow::dummy::DummyMemory;
let mut virt_mem = VirtualDma::new(phys_mem, x64::ARCH, translator);
let addr = virt_base; // some arbitrary address
let mut buf = [0u8; 8];
// create the batcher
let mut batcher = MemoryViewBatcher::new(&mut virt_mem);
// append the read command
batcher.read_raw_iter(std::iter::once(CTup2(addr, buf.as_mut().into())).into_iter());
// commit the batch to memory, this is optional and just used to check if the operations succeed
assert!(batcher.commit_rw().is_ok());
sourcepub fn write_raw_iter(&mut self, iter: impl WriteIterator<'a>) -> &mut Self
pub fn write_raw_iter(&mut self, iter: impl WriteIterator<'a>) -> &mut Self
Reads data from memory and stores it in the provided buffer.
Arguments
addr
: The starting address to read from.out
: A mutable reference to the buffer where the data will be stored.
Example
use memflow::prelude::v1::*;
use memflow::dummy::DummyMemory;
let mut virt_mem = VirtualDma::new(phys_mem, x64::ARCH, translator);
let addr = virt_base; // some arbitrary address
let write_data = [0x10, 0x20, 0x30, 0x40];
let mut read_data = [0u8; 4];
{
// create batcher in a new scope
let mut batcher = MemoryViewBatcher::new(&mut virt_mem);
// write the `write_data` array to memory
batcher.write_raw_into(addr, &write_data);
// commit the batch to memory, this is optional and just used to check if the operations succeed
assert!(batcher.commit_rw().is_ok());
}
// check if the batched write was successful
virt_mem.read_raw_into(addr, &mut read_data).unwrap();
assert_eq!(read_data, write_data);
sourcepub fn read_raw_into<'b: 'a>(
&mut self,
addr: Address,
out: &'b mut [u8]
) -> &mut Self
pub fn read_raw_into<'b: 'a>( &mut self, addr: Address, out: &'b mut [u8] ) -> &mut Self
Reads data from memory and stores it in the provided buffer.
Arguments
addr
- The address to start reading from.out
- The buffer to store the read data in.
Examples
use memflow::prelude::v1::*;
use memflow::dummy::DummyMemory;
let mut virt_mem = VirtualDma::new(phys_mem, x64::ARCH, translator);
let addr = virt_base; // some arbitrary address
let mut buffer = [0u8; 4];
let mut batcher = MemoryViewBatcher::new(&mut virt_mem);
// read 4 bytes from some address and store the result in `buffer`
batcher.read_raw_into(addr, &mut buffer);
// commit the batch to memory, this is optional and just used to check if the operations succeed
batcher.commit_rw().unwrap();
sourcepub fn read_into<'b: 'a, F: Pod + ?Sized>(
&mut self,
addr: Address,
out: &'b mut F
) -> &mut Self
pub fn read_into<'b: 'a, F: Pod + ?Sized>( &mut self, addr: Address, out: &'b mut F ) -> &mut Self
Reads data from memory and stores it in the provided buffer.
Arguments
addr
- The address to read from.out
- The buffer to store the read data.
Example
use memflow::prelude::v1::*;
use memflow::dummy::DummyMemory;
let mut virt_mem = VirtualDma::new(phys_mem, x64::ARCH, translator);
let addr = virt_base; // some arbitrary address
// writes the text 'hello world' to the specified address in memory
virt_mem.write(addr, b"hello world").unwrap();
let mut buffer = [0u8; 11];
{
// creates a batcher and reads 11 bytes from memory
let mut batcher = MemoryViewBatcher::new(&mut virt_mem);
batcher.read_into(addr, &mut buffer);
// commit the batch to memory, this is optional and just used to check if the operations succeed
batcher.commit_rw().unwrap();
}
// compare the memory
assert_eq!(&buffer, b"hello world");
sourcepub fn write_raw_into<'b: 'a>(
&mut self,
addr: Address,
out: &'b [u8]
) -> &mut Self
pub fn write_raw_into<'b: 'a>( &mut self, addr: Address, out: &'b [u8] ) -> &mut Self
Writes data to memory from the provided buffer.
Example
use memflow::prelude::v1::*;
use memflow::dummy::DummyMemory;
let mut virt_mem = VirtualDma::new(phys_mem, x64::ARCH, translator);
let addr = virt_base; // some arbitrary address
let write_data = [0x10, 0x20, 0x30, 0x40];
let mut read_data = [0u8; 4];
{
// create batcher in a new scope
let mut batcher = MemoryViewBatcher::new(&mut virt_mem);
// writes the block to memory at the specified address
batcher.write_raw_into(addr, &write_data);
// commit the batch to memory, this is optional and just used to check if the operations succeed
assert!(batcher.commit_rw().is_ok());
}
// check if the write succeeded
virt_mem.read_raw_into(addr, &mut read_data).unwrap();
assert_eq!(read_data, write_data);
sourcepub fn write_into<'b: 'a, F: Pod + ?Sized>(
&mut self,
addr: Address,
out: &'b F
) -> &mut Self
pub fn write_into<'b: 'a, F: Pod + ?Sized>( &mut self, addr: Address, out: &'b F ) -> &mut Self
Serializes data and writes it to memory.
Example
use memflow::prelude::v1::*;
use memflow::dummy::DummyMemory;
let mut virt_mem = VirtualDma::new(phys_mem, x64::ARCH, translator);
let addr = virt_base; // some arbitrary address
let write_data = 0xdeadbeefu64;
let mut read_data = 0u64;
{
// create batcher in a new scope
let mut batcher = MemoryViewBatcher::new(&mut virt_mem);
// writes the block to memory at the specified address
batcher.write_into(addr, &write_data);
// commit the batch to memory, this is optional and just used to check if the operations succeed
assert!(batcher.commit_rw().is_ok());
}
// check if the write succeeded
virt_mem.read_into(addr, &mut read_data).unwrap();
assert_eq!(read_data, write_data);
Trait Implementations§
source§impl<'a, T: MemoryView> Drop for MemoryViewBatcher<'a, T>
impl<'a, T: MemoryView> Drop for MemoryViewBatcher<'a, T>
Auto Trait Implementations§
impl<'a, T> RefUnwindSafe for MemoryViewBatcher<'a, T>where
T: RefUnwindSafe,
impl<'a, T> Send for MemoryViewBatcher<'a, T>
impl<'a, T> Sync for MemoryViewBatcher<'a, T>where
T: Sync,
impl<'a, T> Unpin for MemoryViewBatcher<'a, T>
impl<'a, T> !UnwindSafe for MemoryViewBatcher<'a, T>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> GetWithMetadata for T
impl<T> GetWithMetadata for T
§type ForSelf = WithMetadata_<T, T>
type ForSelf = WithMetadata_<T, T>
WithMetadata_<Self, Self>
§impl<S> ROExtAcc for S
impl<S> ROExtAcc for S
§fn f_get<F>(&self, offset: FieldOffset<S, F, Aligned>) -> &F
fn f_get<F>(&self, offset: FieldOffset<S, F, Aligned>) -> &F
offset
. Read more§fn f_get_mut<F>(&mut self, offset: FieldOffset<S, F, Aligned>) -> &mut F
fn f_get_mut<F>(&mut self, offset: FieldOffset<S, F, Aligned>) -> &mut F
offset
. Read more§fn f_get_ptr<F, A>(&self, offset: FieldOffset<S, F, A>) -> *const F
fn f_get_ptr<F, A>(&self, offset: FieldOffset<S, F, A>) -> *const F
offset
. Read more§fn f_get_mut_ptr<F, A>(&mut self, offset: FieldOffset<S, F, A>) -> *mut F
fn f_get_mut_ptr<F, A>(&mut self, offset: FieldOffset<S, F, A>) -> *mut F
offset
. Read more§impl<S> ROExtOps<Aligned> for S
impl<S> ROExtOps<Aligned> for S
§fn f_replace<F>(&mut self, offset: FieldOffset<S, F, Aligned>, value: F) -> F
fn f_replace<F>(&mut self, offset: FieldOffset<S, F, Aligned>, value: F) -> F
offset
) with value
,
returning the previous value of the field. Read more§fn f_get_copy<F>(&self, offset: FieldOffset<S, F, Aligned>) -> Fwhere
F: Copy,
fn f_get_copy<F>(&self, offset: FieldOffset<S, F, Aligned>) -> Fwhere
F: Copy,
§impl<S> ROExtOps<Unaligned> for S
impl<S> ROExtOps<Unaligned> for S
§fn f_replace<F>(&mut self, offset: FieldOffset<S, F, Unaligned>, value: F) -> F
fn f_replace<F>(&mut self, offset: FieldOffset<S, F, Unaligned>, value: F) -> F
offset
) with value
,
returning the previous value of the field. Read more§fn f_get_copy<F>(&self, offset: FieldOffset<S, F, Unaligned>) -> Fwhere
F: Copy,
fn f_get_copy<F>(&self, offset: FieldOffset<S, F, Unaligned>) -> Fwhere
F: Copy,
§impl<T> SelfOps for Twhere
T: ?Sized,
impl<T> SelfOps for Twhere
T: ?Sized,
§fn piped<F, U>(self, f: F) -> U
fn piped<F, U>(self, f: F) -> U
§fn piped_ref<'a, F, U>(&'a self, f: F) -> U
fn piped_ref<'a, F, U>(&'a self, f: F) -> U
piped
except that the function takes &Self
Useful for functions that take &Self
instead of Self
. Read more§fn piped_mut<'a, F, U>(&'a mut self, f: F) -> Uwhere
F: FnOnce(&'a mut Self) -> U,
fn piped_mut<'a, F, U>(&'a mut self, f: F) -> Uwhere
F: FnOnce(&'a mut Self) -> U,
piped
, except that the function takes &mut Self
.
Useful for functions that take &mut Self
instead of Self
.§fn mutated<F>(self, f: F) -> Self
fn mutated<F>(self, f: F) -> Self
§fn observe<F>(self, f: F) -> Self
fn observe<F>(self, f: F) -> Self
§fn as_ref_<T>(&self) -> &T
fn as_ref_<T>(&self) -> &T
AsRef
,
using the turbofish .as_ref_::<_>()
syntax. Read more