Struct PipelinedSingleTableU32U8Lookup 

pub struct PipelinedSingleTableU32U8Lookup<'a> { /* private fields */ }

Pipelined single table lookup kernel - u32 to u8 lookup table kernel with prefetch pipelining

This version pipelines prefetch operations with the actual lookup work to hide memory latency. The algorithm works as follows:

1. Read values from current chunk addresses
2. Prefetch next chunk addresses while processing current values
3. Call SIMD lookup function on current values
4. Loop to next chunk

This pipelining allows memory prefetch latency to be hidden behind computation work.

Results: End Nov 2025: On Intel boxes this gives slight advantage - maybe up to 5%. Regular scalar reads though, even with large random Lookup tables, are done well enough that this doesn’t help much.

Implementations

impl<'a> PipelinedSingleTableU32U8Lookup<'a>

pub fn new(lookup_table: &'a [u8]) -> Self

pub fn lookup_func<F>(&self, values: &[u32], f: &mut F)

where F: FnMut(u8x16, usize),

Pipelined lookup function that prefetches the next chunk while processing the current one

The pipelining strategy:

• Process chunks of 16 u32 values at a time
• For each chunk: prefetch next chunk addresses, then process current chunk
• This hides prefetch latency behind the lookup computation work

pub fn lookup_into_vec(&self, values: &[u32], buffer: &mut Vec<u8>)

Convenience function which does lookup and writes the results into a Vec

Trait Implementations

impl<'a> Clone for PipelinedSingleTableU32U8Lookup<'a>

fn clone(&self) -> PipelinedSingleTableU32U8Lookup<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for PipelinedSingleTableU32U8Lookup<'a>

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

Formats the value using the given formatter.