Struct MemoryProbe 

pub struct MemoryProbe {
    pub pool_lines: usize,
    pub window_lines: usize,
    pub buffer_bytes: usize,
    pub cube_count: usize,
    pub blocked: bool,
}

The buffer geometry and launch shape a memory probe uses to move a working set of a given size in one pass.

Shared by the copy and read probes: both walk one line per thread per step over buffers of identical size, and both measure a small working set by moving a small window over a large buffer rather than by allocating a small buffer.

The window is what makes a small working set mean anything. A small buffer read over and over stays in cache after the first pass, so the probe would report cache bandwidth for every size below the cache and the curve would describe residency instead of size. Reading a fresh window each pass keeps the data cold — by the time the window comes back around, a whole buffer of traffic has evicted it — so what varies across the sweep is how much a pass moves, which is the thing being measured.

Fields

pool_lines: usize

Lines in each buffer: as much as the device will allocate, whatever the working set, so a window has somewhere cold to come back to.

window_lines: usize

Lines one pass moves through, per buffer. Never more than pool_lines; equal to it at the top of the sweep, where the working set is the whole buffer.

buffer_bytes: usize

Bytes in each buffer.

cube_count: usize

Cubes to dispatch, which is LaunchConfig::cube_count unless the window is too small to give every thread a line.

blocked: bool

Whether the probe kernels address lines as per-thread contiguous runs rather than coalesced across threads. Set on plane-1 runtimes, where a worker has no plane neighbour to coalesce with.

Implementations

impl MemoryProbe

pub fn new<R: Runtime>( client: &ComputeClient<R>, config: LaunchConfig, line_bytes: usize, access: MemoryAccess, working_set: usize, ) -> Self

Sizes a probe moving working_set bytes per pass, split evenly across the buffers access touches.

A blocked probe pins the launch to one cube: on the backend that addressing is for, a cube position is a loop wrapped around the whole kernel body, n_iter included, so more than one turns the window rotation between passes into a replay of the same narrow, blocked-addressed slice instead of a walk across the buffer, and cache serves it. A coalesced launch spreads one cube position’s addresses across the full window regardless of cube count, so it has no such limit.

Trait Implementations

impl Clone for MemoryProbe

fn clone(&self) -> MemoryProbe

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for MemoryProbe

impl Debug for MemoryProbe

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

Formats the value using the given formatter.