Trait MainLoop 

pub trait MainLoop {
    const BLOCK_SIZE: usize;

    // Required method
    unsafe fn main<S, L, R, A>(
        loader: &Loader<S, L, R, A>,
        trip_count: usize,
        epilogues: usize,
    ) -> S::Accumulator
       where A: Architecture,
             S: SIMDSchema<L, R, A>;
}

A representation of the main unrolled-loop for SIMD kernels.

Required Associated Constants

const BLOCK_SIZE: usize

The effective number of unrolling (in terms of SIMD vectors) performed by this kernel. For example, if BLOCK_SIZE = 4 and the SIMD width is 8, than each iteration of the main loop will process 4 * 8 = 32 elements.

This parameter will be used to compute the number of full-width epilogues that need to be executed.

Required Methods

unsafe fn main<S, L, R, A>( loader: &Loader<S, L, R, A>, trip_count: usize, epilogues: usize, ) -> S::Accumulator

where A: Architecture, S: SIMDSchema<L, R, A>,

Perform the main unrolled loops of a SIMD kernel. This loop is expected to process all elements in the range [0, trip_count * S::get_simd_width() * Self::BLOCK_SIZE) and return an accumulator consisting of the result.

Arguments

• loader: A SIMD loader to emit loads to the two source spans.
• trip_count: The number of blocks of size BLOCK_SIZE to process. A single “trip” will process S::get_simd_width() * Self::BLOCK_SIZE elements. So, computation of trip_count should be computed as:

  let trip_count = len / (S::get_simd_width() * <_ as MainLoop>::BLOCK_SIZE);

• epilogues: The number of S::get_simd_width() vectors remaining after all the main blocks have been processed. This is guaranteed to be less than Self::BLOCK_SIZE.

Safety

All elements in the accessed range must be valid. The memory addresses touched are

let block_size = Self::BLOCK_SIZE;
let simd_width = S::get_simd_width();
[
    loader.left,
    loader.left + trip_count * simd_width + block_size + epilogues * simd_width
)
[
    loader.right,
    loader.right + trip_count * simd_width + block_size + epilogues * simd_width
)

The loader will ensure that all accesses are in-bounds in debug builds.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl MainLoop for Strategy1x1

const BLOCK_SIZE: usize = 1

impl MainLoop for Strategy2x1

const BLOCK_SIZE: usize = 2

impl MainLoop for Strategy2x4

const BLOCK_SIZE: usize = 4

impl MainLoop for Strategy4x1

const BLOCK_SIZE: usize = 4

impl MainLoop for Strategy4x2

const BLOCK_SIZE: usize = 4