Botan 3.14.1
Crypto and TLS for C&
Botan::Kyber_AVX2 Namespace Reference

Functions

BOTAN_FN_ISA_AVX2 void inverse_ntt (std::span< int16_t, 256 > p)
BOTAN_FN_ISA_AVX2 void ntt (std::span< int16_t, 256 > p)
BOTAN_FN_ISA_AVX2 void poly_pointwise_montgomery (std::span< int16_t, 256 > result, std::span< const int16_t, 256 > lhs, std::span< const int16_t, 256 > rhs)

Function Documentation

◆ inverse_ntt()

BOTAN_TEST_API void Botan::Kyber_AVX2::inverse_ntt ( std::span< int16_t, 256 > p)

Definition at line 390 of file kyber_avx2.cpp.

390 {
391 int16_t* c = p.data();
392 const auto q = SIMD_16x16::splat(KyberConstants::Q);
393 const auto v = SIMD_16x16::splat(KyberPolyTraits::BARRETT_V);
394
395 for(size_t blk = 0; blk < 8; ++blk) {
396 int16_t* cb = c + 32 * blk;
397 auto a = SIMD_16x16::load(cb);
398 auto b = SIMD_16x16::load(cb + 16);
399
400 swap_halves(a, b);
401 interleave64(a, b);
402 distance_4_to_2(a, b);
403 gs_butterfly(a, b, TABLES.inverse_2(blk), q);
404 distance_2_to_4(a, b);
405 gs_butterfly(a, b, TABLES.inverse_4(blk), q);
406 a = barrett(a, v, q);
407 interleave64(a, b);
408 gs_butterfly(a, b, TABLES.inverse_8(blk), q);
409 swap_halves(a, b);
410
411 a.store(cb);
412 b.store(cb + 16);
413 }
414
415 const Zeta scale = TABLES.final_scale();
416
417 size_t k = 15;
418 for(size_t len = 16; len <= 128; len <<= 1) {
419 const bool reduce = (len == 16 || len == 64);
420 const bool last = (len == 128);
421
422 for(size_t start = 0; start < 256; start += 2 * len, --k) {
423 const Zeta zeta = last ? TABLES.final_zeta() : TABLES.zeta(k);
424 for(size_t j = start; j < start + len; j += 16) {
425 auto a = SIMD_16x16::load(c + j);
426 auto b = SIMD_16x16::load(c + j + len);
427 gs_butterfly(a, b, zeta, q);
428 if(reduce) {
429 a = barrett(a, v, q);
430 }
431 if(last) {
432 a = fqmul_const(a, scale, q);
433 }
434 a.store(c + j);
435 b.store(c + j + len);
436 }
437 }
438 }
439}
static constexpr T Q
modulus
RetT reduce(const std::vector< KeyT > &keys, RetT acc, ReducerT reducer)
Definition stl_util.h:30

References Botan::CRYSTALS::Trait_Base< KyberConstants, KyberPolyTraits >::BARRETT_V, Botan::KyberConstants::Q, and Botan::reduce().

Referenced by Botan::KyberPolyTraits::inverse_ntt().

◆ ntt()

BOTAN_TEST_API void Botan::Kyber_AVX2::ntt ( std::span< int16_t, 256 > p)

AVX2 versions of the KyberPolyTraits operations of the same name.

The polynomials use the standard coefficient order in memory, so the results are interchangeable with the scalar implementations: ntt and poly_pointwise_montgomery produce identical values, inverse_ntt values that are congruent mod q and within (-q, q).

Definition at line 343 of file kyber_avx2.cpp.

343 {
344 int16_t* c = p.data();
345 const auto q = SIMD_16x16::splat(KyberConstants::Q);
346
347 size_t k = 1;
348 for(size_t len = 128; len >= 16; len >>= 1) {
349 for(size_t start = 0; start < 256; start += 2 * len, ++k) {
350 const Zeta zeta = TABLES.zeta(k);
351 for(size_t j = start; j < start + len; j += 16) {
352 auto a = SIMD_16x16::load(c + j);
353 auto b = SIMD_16x16::load(c + j + len);
354 ct_butterfly(a, b, zeta, q);
355 a.store(c + j);
356 b.store(c + j + len);
357 }
358 }
359 }
360
361 const auto v = SIMD_16x16::splat(KyberPolyTraits::BARRETT_V);
362 for(size_t blk = 0; blk < 8; ++blk) {
363 int16_t* cb = c + 32 * blk;
364 auto a = SIMD_16x16::load(cb);
365 auto b = SIMD_16x16::load(cb + 16);
366
367 swap_halves(a, b);
368 ct_butterfly(a, b, TABLES.forward_8(blk), q);
369 interleave64(a, b);
370 ct_butterfly(a, b, TABLES.forward_4(blk), q);
371 distance_4_to_2(a, b);
372 ct_butterfly(a, b, TABLES.forward_2(blk), q);
373 distance_2_to_4(a, b);
374 interleave64(a, b);
375 swap_halves(a, b);
376
377 barrett(a, v, q).store(cb);
378 barrett(b, v, q).store(cb + 16);
379 }
380}

References Botan::CRYSTALS::Trait_Base< KyberConstants, KyberPolyTraits >::BARRETT_V, and Botan::KyberConstants::Q.

Referenced by Botan::KyberPolyTraits::ntt().

◆ poly_pointwise_montgomery()

BOTAN_TEST_API void Botan::Kyber_AVX2::poly_pointwise_montgomery ( std::span< int16_t, 256 > result,
std::span< const int16_t, 256 > lhs,
std::span< const int16_t, 256 > rhs )

Definition at line 446 of file kyber_avx2.cpp.

448 {
449 const auto q = SIMD_16x16::splat(KyberConstants::Q);
450 const auto qinv = SIMD_16x16::splat(KyberPolyTraits::q_inverse());
451
452 for(size_t i = 0; i < 16; ++i) {
453 const auto a = SIMD_16x16::load(lhs.data() + 16 * i);
454 const auto b = SIMD_16x16::load(rhs.data() + 16 * i);
455
456 const auto ab = fqmul(a, b, qinv, q);
457 const auto ab_swapped = fqmul(a, b.swap_16_halves(), qinv, q);
458
459 const auto zeta_a1b1 = fqmul_const(ab.swap_16_halves(), TABLES.basemul(i), q);
460
461 const auto r0 = ab + zeta_a1b1;
462 const auto r1 = ab_swapped + ab_swapped.swap_16_halves();
463
464 r0.blend<0xAA>(r1).store(result.data() + 16 * i);
465 }
466}
static constexpr T q_inverse()

References Botan::KyberConstants::Q, and Botan::KyberPolyTraits::q_inverse().

Referenced by Botan::KyberPolyTraits::poly_pointwise_montgomery().