Compiler Explorer

Source code

#![feature(bench_black_box)]

use std::hint::black_box;

pub fn bench_gf128_mul_box() {
    let test_value = GF128([!0; 2]);
    let x = test_value;
    let y = test_value;
    for _ in 0..1024 {
        black_box(GF128::mul(&x, &y));
    }
}

pub fn bench_gf128_mul_2box() {
    let test_value = GF128([!0; 2]);
    let x = test_value;
    let y = test_value;
    for _ in 0..1024 {
        black_box(GF128::mul(&black_box(x), &black_box(y)));
    }
}

#[derive(Clone, Copy)]
struct GF128([u64; 2]);

const A: usize = 7;
const B: usize = 2;
const C: usize = 1;

impl GF128 {
    #[cfg(all(
        target_arch = "x86_64",
        target_feature = "sse2",
        target_feature = "pclmulqdq"
    ))]
    fn mul(x: &Self, y: &Self) -> Self {
        use std::arch::x86_64::{__m128i, _mm_clmulepi64_si128, _mm_set_epi64x, _mm_storeu_si128};

let mut words = [0u64; 2];
        let mut carry = [0u64; 2];

for i in 0..2 {
            // Safety: target_feature "sse2" is available in this function.
            let xi: __m128i = unsafe { _mm_set_epi64x(0, x.0[i] as i64) };
            for j in 0..2 {
                // Safety: target_feature "sse2" is available in this function.
                let yj: __m128i = unsafe { _mm_set_epi64x(0, y.0[j] as i64) };
                // Safety: target_feature "pclmulqdq" is available in this function.
                let clmul: __m128i = unsafe { _mm_clmulepi64_si128(xi, yj, 0) };
                let mut cc: [u64; 2] = [0u64, 0u64];
                // Safety:
                // - target_feature "sse2" is available in this function,
                // - cc points to 128 bits (no alignment required by this function).
                unsafe { _mm_storeu_si128(&mut cc as *mut _ as *mut __m128i, clmul) };

let ij = i + j;
                if ij < 2 {
                    words[ij] ^= cc[0];
                } else {
                    carry[ij - 2] ^= cc[0];
                }

let ij1 = ij + 1;
                if ij1 < 2 {
                    words[ij1] ^= cc[1];
                } else {
                    carry[ij1 - 2] ^= cc[1];
                }
            }
        }

Self::propagate_carries(words, carry)
    }

fn propagate_carries(mut words: [u64; 2], carry: [u64; 2]) -> Self {
        for i in 0..2 {
            let c = carry[i];
            words[i] ^= c ^ (c << A) ^ (c << B) ^ (c << C);
            if i + 1 < 2 {
                words[i + 1] ^=
                    (c >> (64 - A)) ^ (c >> (64 - B)) ^ (c >> (64 - C));
            } else {
                let c = (c >> (64 - A)) ^ (c >> (64 - B)) ^ (c >> (64 - C));
                words[0] ^= c ^ (c << A) ^ (c << B) ^ (c << C);
                words[1] ^=
                    (c >> (64 - A)) ^ (c >> (64 - B)) ^ (c >> (64 - C));
            }
        }

Self(words)
    }

fn add_assign(&mut self, other: &Self) {
        for i in 0..2 {
            self.0[i] ^= other.0[i];
        }
    }
}