fgf 1.1.1

Faster Galois Fields: SIMD and portable finite-field arithmetic (binary towers and prime fields) and vector kernels
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

//! Measurement variants for the GF(2^8) x86 kernels.
//!
//! Nothing here is reachable from production dispatch: these variants are
//! exposed through the internals facade to price one decision
//! against the production body it is paired with. Variants are grouped by
//! what they measure — `tile` for tile width and store policy, `shuffle` for
//! the nibble alternative to the GFNI multiply, `resolve` for per-call
//! coefficient resolution, `grouped` for the multi-row crossed panel, and
//! `gather` for the gather tile and remainder controls.
//!
//! Every entry is a safe [`archmage`] capability-token function. The
//! externally-resolved chunk loop below is shared by `resolve` and `grouped`.

mod gather;
mod grouped;
mod resolve;
mod shuffle;
mod tile;

pub use gather::*;
pub use grouped::*;
pub use resolve::*;
pub use shuffle::*;
pub use tile::*;

use super::Affine8D;
use super::rows::rows_body;

/// Run the production tile body over externally resolved map words, in chunks
/// of `chunk` terms (`0` folds every term into one pass).
///
/// The first chunk overwrites; later chunks accumulate, exactly as the
/// resolved path's chunk loop. The rows are runtime-offset windows of one
/// region — the offset-addressed-row residue — bounded by the caller's row
/// geometry.
#[archmage::rite(v3_gfni_crypto)]
fn rows_external_chunked<const ROWS: usize, const LANES: usize>(
    ptrs: [*mut u8; ROWS],
    vector_len: usize,
    maps: &[[u64; ROWS]],
    srcs: &[&[u8]],
    chunk: usize,
) {
    let terms = maps.len();
    let step = if chunk == 0 { terms.max(1) } else { chunk };
    let mut start = 0;
    let mut first = true;
    while start < terms {
        let taken = (terms - start).min(step);
        if first {
            rows_body::<Affine8D, ROWS, LANES, true>(
                ptrs,
                vector_len,
                &maps[start..start + taken],
                &srcs[start..start + taken],
            );
        } else {
            rows_body::<Affine8D, ROWS, LANES, false>(
                ptrs,
                vector_len,
                &maps[start..start + taken],
                &srcs[start..start + taken],
            );
        }
        first = false;
        start += taken;
    }
}