Struct microbench::tlb_latency::gpu_tlb_latency::GpuTlbLatency

pub(super) struct GpuTlbLatency {
    module: Module,
    _context: Context,
    device_id: u32,
    template: DataPoint,
    nvml: NVML,
}

Fields

module: Module

_context: Context

device_id: u32

template: DataPoint

nvml: NVML

Implementations

impl GpuTlbLatency

pub(super) fn new(device_id: u32, template: DataPoint) -> Result<Self, Error>

fn load_module() -> Result<Module, Error>

pub(super) fn measure(
    &self,
    mem_type: MemType,
    ranges: RangeInclusive<usize>,
    strides: &[usize],
    do_iotlb_flush: bool
) -> Result<Vec<DataPoint>, Error>

fn cycle_counter_overhead(&self) -> Result<u32, Error>

Measures the overhead of get_clock() in cycles

get_clock() is implemented as a native special register on each architecture. See the documentation in the CUDA module for details.

fn write_strides(
    data: &mut [u64],
    stride_bytes: usize,
    old_len: Option<usize>
) -> usize

Initializes a slice with strides

After initialization, each element of the slice contains the position of its successor. For example, element 4 points to element 8 if the stride is 4 (as measured in size_of::<Position>()).

If the slice is being resized without changing the stride, then old_len may be set to specify the previous slice length to reduce initialization time.

fn flush_cpu_tlb(data: &[u64]) -> Result<(), Error>

Flushes the CPU’s TLB

The flush is atomic and system-wide. The flush also includes the IOTLB.

For a high-level description, refer to the book Gorman “Understanding the Linux Virtual Memory Manager” p. 44, Table 3.2“

For the code, see the Linux kernel: https://code.woboq.org/linux/linux/mm/hugetlb.c.html#hugetlb_change_protection

Trait Implementations

impl Debug for GpuTlbLatency

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

Formats the value using the given formatter.

impl Drop for GpuTlbLatency

fn drop(&mut self)

Executes the destructor for this type.