Struct memflow::mem::cache::cached_vat::CachedVirtualTranslate

pub struct CachedVirtualTranslate<V, Q> {
    pub hitc: usize,
    pub misc: usize,
    // some fields omitted
}

CachedVirtualTranslate trasnaparently caches virtual addresss translations.

Using a VAT cache can provide significant speedups, since page table walks perform a number of memory reads, which induces noticeable latency, especially on slow memory backends.

Using the builder function is the recommended way to create such a cache.

Examples

use memflow::mem::cache::CachedVirtualTranslate;
let mut cached_vat = CachedVirtualTranslate::builder(&mut vat)
    .arch(x64::ARCH)
    .build()
    .unwrap();

Testing that cached translation is 4x faster than uncached translation when having a cache hit:

use std::time::{Duration, Instant};

let translation_address = virt_base;

let iter_count = 512;

let avg_cached = (0..iter_count).map(|_| {
        let timer = Instant::now();
        cached_vat
            .virt_to_phys(&mut mem, &translator, translation_address)
            .unwrap();
        timer.elapsed()
    })
    .sum::<Duration>() / iter_count;

println!("{:?}", avg_cached);

std::mem::drop(cached_vat);

let avg_uncached = (0..iter_count).map(|_| {
        let timer = Instant::now();
        vat
            .virt_to_phys(&mut mem, &translator, translation_address)
            .unwrap();
        timer.elapsed()
    })
    .sum::<Duration>() / iter_count;

println!("{:?}", avg_uncached);

assert!(avg_cached * 4 <= avg_uncached);

Fields

hitc: usize

misc: usize

Implementations

impl<V: VirtualTranslate, Q: CacheValidator> CachedVirtualTranslate<V, Q>

pub fn new(vat: V, tlb: TLBCache<Q>, arch: ArchitectureObj) -> Self

impl<V: VirtualTranslate> CachedVirtualTranslate<V, DefaultCacheValidator>

pub fn builder(
    vat: V
) -> CachedVirtualTranslateBuilder<V, DefaultCacheValidator>

Trait Implementations

impl<V: VirtualTranslate + Clone, Q: CacheValidator + Clone> Clone for CachedVirtualTranslate<V, Q>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: VirtualTranslate, Q: CacheValidator> VirtualTranslate for CachedVirtualTranslate<V, Q>

fn virt_to_phys_iter<T: ?Sized, B, D, VI, VO, FO>(
    &mut self,
    phys_mem: &mut T,
    translator: &D,
    addrs: VI,
    out: &mut VO,
    out_fail: &mut FO
) where
    T: PhysicalMemory,
    B: SplitAtIndex,
    D: ScopedVirtualTranslate,
    VI: Iterator<Item = (Address, B)>,
    VO: Extend<(PhysicalAddress, B)>,
    FO: Extend<(Error, Address, B)>, 

This function will do a virtual to physical memory translation for the ScopedVirtualTranslate over multiple elements.

fn virt_to_phys<T: PhysicalMemory + ?Sized, D: ScopedVirtualTranslate>(
    &mut self,
    phys_mem: &mut T,
    translator: &D,
    vaddr: Address
) -> Result<PhysicalAddress>