1use super::*;
2
3#[inline]
4#[target_feature(enable = "avx2")]
5unsafe fn load_ntt_avx2(p: *const u32, step: usize) -> __m256i {
6 if step == 4 {
7 _mm256_castsi128_si256(_mm_loadu_si128(p.cast()))
8 } else {
9 _mm256_loadu_si256(p.cast())
10 }
11}
12#[inline]
13#[target_feature(enable = "avx2")]
14unsafe fn store_ntt_avx2(p: *mut u32, value: __m256i, step: usize) {
15 if step == 4 {
16 _mm_storeu_si128(p.cast(), _mm256_castsi256_si128(value));
17 } else {
18 _mm256_storeu_si256(p.cast(), value);
19 }
20}
21
22#[target_feature(enable = "avx2")]
23pub unsafe fn ntt_four_avx2<M, const INVERSE: bool>(a: &mut [u32])
24where
25 M: Montgomery32NttModulus,
26{
27 let roots = if INVERSE {
28 &M::INFO.inv_root
29 } else {
30 &M::INFO.root
31 };
32 let rates = &const {
33 let info = M::INFO;
34 let (roots, rates) = if INVERSE {
35 (info.inv_root, info.inv_rate3_packed)
36 } else {
37 (info.root, info.rate3_packed)
38 };
39 let mut result = [[0u32; 4]; 32];
40 let mut i = 0;
41 while i < 32 {
42 let r = mod_mul(rates[i][1], roots[3], M::MOD, M::R);
43 let r2 = mod_mul(r, r, M::MOD, M::R);
44 result[i] = [M::N1, r, r2, mod_mul(r2, r, M::MOD, M::R)];
45 i += 1;
46 }
47 result
48 };
49 let one = _mm256_set1_epi32(M::N1 as i32);
50 let modulus = _mm256_set1_epi32(M::MOD as i32);
51 let modulus2 = _mm256_set1_epi32((M::MOD * 2) as i32);
52 let r = _mm256_set1_epi32(M::R as i32);
53 let root3 = M::mod_mul(roots[2], roots[3]) as i32;
54 let step = _mm256_setr_epi32(
55 M::N1 as i32,
56 roots[3] as i32,
57 roots[2] as i32,
58 root3,
59 M::N1 as i32,
60 roots[3] as i32,
61 roots[2] as i32,
62 root3,
63 );
64 let mut twiddle = _mm256_blend_epi32::<0xf0>(one, step);
65 let imag = if INVERSE {
66 _mm256_setr_epi32(
67 M::N1 as i32,
68 roots[2] as i32,
69 M::N1 as i32,
70 roots[2] as i32,
71 M::N1 as i32,
72 roots[2] as i32,
73 M::N1 as i32,
74 roots[2] as i32,
75 )
76 } else {
77 _mm256_setr_epi32(
78 M::N1 as i32,
79 M::N1 as i32,
80 roots[2] as i32,
81 roots[2] as i32,
82 M::N1 as i32,
83 M::N1 as i32,
84 roots[2] as i32,
85 roots[2] as i32,
86 )
87 };
88 for (s, a) in a.as_chunks_mut::<8>().0.iter_mut().enumerate() {
89 let mut x = _mm256_loadu_si256(a.as_ptr().cast());
90 if !INVERSE {
91 x = montgomery_simd::montgomery_mul_256(x, twiddle, r, modulus);
92 }
93 let pair = if INVERSE {
94 let y = _mm256_shuffle_epi32::<0xb1>(x);
95 let sum = montgomery_simd::montgomery_add_256(x, y, modulus2);
96 let diff = montgomery_simd::montgomery_sub_256(x, y, modulus2);
97 let sum = _mm256_shuffle_epi32::<0x88>(sum);
98 let diff = _mm256_shuffle_epi32::<0x88>(diff);
99 let diff = montgomery_simd::montgomery_mul_256(diff, imag, r, modulus);
100 _mm256_unpacklo_epi64(sum, diff)
101 } else {
102 let y = _mm256_shuffle_epi32::<0x4e>(x);
103 let sum = montgomery_simd::montgomery_add_256(x, y, modulus2);
104 let diff = montgomery_simd::montgomery_sub_256(x, y, modulus2);
105 _mm256_unpacklo_epi64(sum, diff)
106 };
107 let left = _mm256_shuffle_epi32::<0xa0>(pair);
108 let mut right = _mm256_shuffle_epi32::<0xf5>(pair);
109 if !INVERSE {
110 right = montgomery_simd::montgomery_mul_256(right, imag, r, modulus);
111 }
112 let sum = montgomery_simd::montgomery_add_256(left, right, modulus2);
113 let diff = montgomery_simd::montgomery_sub_256(left, right, modulus2);
114 let mut value = _mm256_blend_epi32::<0xaa>(sum, diff);
115 if INVERSE {
116 value = _mm256_shuffle_epi32::<0xd8>(value);
117 value = montgomery_simd::montgomery_mul_256(value, twiddle, r, modulus);
118 }
119 _mm256_storeu_si256(a.as_mut_ptr().cast(), value);
120 let rate = _mm256_broadcastsi128_si256(_mm_loadu_si128(
121 rates[s.trailing_ones() as usize + 1].as_ptr().cast(),
122 ));
123 twiddle = montgomery_simd::montgomery_mul_256(twiddle, rate, r, modulus);
124 }
125}
126
127#[target_feature(enable = "avx2")]
128unsafe fn normalize_avx2<M>(a: &mut [u32])
129where
130 M: Montgomery32NttModulus,
131{
132 let mod_vec = _mm256_set1_epi32(M::MOD as i32);
133 let mut i = 0;
134 while i + 8 <= a.len() {
135 let x = _mm256_loadu_si256(a.as_ptr().add(i) as *const __m256i);
136 let y = _mm256_min_epu32(x, _mm256_sub_epi32(x, mod_vec));
137 _mm256_storeu_si256(a.as_mut_ptr().add(i) as *mut __m256i, y);
138 i += 8;
139 }
140 while i < a.len() {
141 a[i] = normalize_scalar::<M>(a[i]);
142 i += 1;
143 }
144}
145
146pub unsafe fn add_vec_avx2<M>(
147 a: __m256i,
148 b: __m256i,
149 mod_vec: __m256i,
150 mod2_vec: __m256i,
151) -> __m256i
152where
153 M: Montgomery32NttModulus,
154{
155 if M::MOD < LAZY_THRESHOLD {
156 montgomery_simd::montgomery_add_256(a, b, mod2_vec)
157 } else {
158 montgomery_simd::add_mod_256(a, b, mod_vec)
159 }
160}
161
162pub unsafe fn sub_vec_avx2<M>(
163 a: __m256i,
164 b: __m256i,
165 mod_vec: __m256i,
166 mod2_vec: __m256i,
167) -> __m256i
168where
169 M: Montgomery32NttModulus,
170{
171 if M::MOD < LAZY_THRESHOLD {
172 montgomery_simd::montgomery_sub_256(a, b, mod2_vec)
173 } else {
174 montgomery_simd::sub_mod_256(a, b, mod_vec)
175 }
176}
177
178unsafe fn mul_vec_avx2<M>(a: __m256i, b: __m256i, r_vec: __m256i, mod_vec: __m256i) -> __m256i
179where
180 M: Montgomery32NttModulus,
181{
182 if M::MOD < LAZY_THRESHOLD {
183 montgomery_simd::montgomery_mul_256(a, b, r_vec, mod_vec)
184 } else {
185 montgomery_simd::montgomery_mul_256_canon(a, b, r_vec, mod_vec)
186 }
187}
188
189#[target_feature(enable = "avx2")]
190pub unsafe fn pointwise_multiply_avx2<M>(f: &mut [MInt<M>], g: &[MInt<M>])
191where
192 M: Montgomery32NttModulus,
193{
194 let r_vec = _mm256_set1_epi32(M::R as i32);
195 let mod_vec = _mm256_set1_epi32(M::MOD as i32);
196 let mut i = 0;
197 while i + 8 <= f.len() {
198 let a = _mm256_loadu_si256(f.as_ptr().add(i) as *const __m256i);
199 let b = _mm256_loadu_si256(g.as_ptr().add(i) as *const __m256i);
200 let x = montgomery_simd::montgomery_mul_256_canon(a, b, r_vec, mod_vec);
201 _mm256_storeu_si256(f.as_mut_ptr().add(i) as *mut __m256i, x);
202 i += 8;
203 }
204 while i < f.len() {
205 f[i] *= g[i];
206 i += 1;
207 }
208}
209
210#[target_feature(enable = "avx2")]
211pub unsafe fn pointwise_multiply_add_avx2<M>(sum: &mut [MInt<M>], f: &[MInt<M>], g: &[MInt<M>])
212where
213 M: Montgomery32NttModulus,
214{
215 let r_vec = _mm256_set1_epi32(M::R as i32);
216 let mod_vec = _mm256_set1_epi32(M::MOD as i32);
217 let mut i = 0;
218 while i + 8 <= sum.len() {
219 let s = _mm256_loadu_si256(sum.as_ptr().add(i).cast());
220 let f = _mm256_loadu_si256(f.as_ptr().add(i).cast());
221 let g = _mm256_loadu_si256(g.as_ptr().add(i).cast());
222 let product = montgomery_simd::montgomery_mul_256_canon(f, g, r_vec, mod_vec);
223 _mm256_storeu_si256(
224 sum.as_mut_ptr().add(i).cast(),
225 montgomery_simd::add_mod_256(s, product, mod_vec),
226 );
227 i += 8;
228 }
229 while i < sum.len() {
230 sum[i] += f[i] * g[i];
231 i += 1;
232 }
233}
234
235#[inline]
236#[target_feature(enable = "avx2")]
237pub unsafe fn ntt_batch_avx2<M, const PARTIAL: bool>(a: &mut [MInt<M>], width: usize)
238where
239 M: Montgomery32NttModulus,
240{
241 let n = a.len() / width;
242 if n <= 1 {
243 return;
244 }
245 let ptr = a.as_mut_ptr() as *mut u32;
246 let a = std::slice::from_raw_parts_mut(ptr, a.len());
247 let mod_vec = _mm256_set1_epi32(M::MOD as i32);
248 let mod2_vec = _mm256_set1_epi32(M::MOD.wrapping_add(M::MOD) as i32);
249 let r_vec = _mm256_set1_epi32(M::R as i32);
250 let imag = M::INFO.root[2];
251 let imag_vec = _mm256_set1_epi32(imag as i32);
252
253 let mut v = n / 2;
254 if n.trailing_zeros() & 1 == 1 {
255 let half = v * width;
256 let step = if PARTIAL && half == 4 { 4 } else { 8 };
257 let mut i = 0;
258 while i + step <= half {
259 let x0 = load_ntt_avx2(a.as_ptr().add(i), step);
260 let x1 = load_ntt_avx2(a.as_ptr().add(half + i), step);
261 let y0 = add_vec_avx2::<M>(x0, x1, mod_vec, mod2_vec);
262 let y1 = sub_vec_avx2::<M>(x0, x1, mod_vec, mod2_vec);
263 store_ntt_avx2(a.as_mut_ptr().add(i), y0, step);
264 store_ntt_avx2(a.as_mut_ptr().add(half + i), y1, step);
265 i += step;
266 }
267 while i < half {
268 let x0 = a[i];
269 let x1 = a[half + i];
270 a[i] = add_scalar::<M>(x0, x1);
271 a[half + i] = sub_scalar::<M>(x0, x1);
272 i += 1;
273 }
274 v >>= 1;
275 }
276 while v > 1 {
277 if width == 1 && v == 2 && a.len() >= 8 && M::MOD < LAZY_THRESHOLD {
278 ntt_four_avx2::<M, false>(a);
279 break;
280 }
281 let half = (v >> 1) * width;
282 let step = if PARTIAL && half == 4 { 4 } else { 8 };
283 let mut w1 = M::N1;
284 let mut w2 = w1;
285 let mut w3 = w1;
286 for (s, block) in a.chunks_exact_mut((v << 1) * width).enumerate() {
287 let base = block.as_mut_ptr();
288 let ll = base;
289 let lr = base.add(half);
290 let rl = base.add(v * width);
291 let rr = base.add(v * width + half);
292
293 let w1v = _mm256_set1_epi32(w1 as i32);
294 let w2v = _mm256_set1_epi32(w2 as i32);
295 let w3v = _mm256_set1_epi32(w3 as i32);
296
297 let mut i = 0;
298 while i + step <= half {
299 let x0 = load_ntt_avx2(ll.add(i), step);
300 let x1 = load_ntt_avx2(lr.add(i), step);
301 let x2 = load_ntt_avx2(rl.add(i), step);
302 let x3 = load_ntt_avx2(rr.add(i), step);
303
304 let (a1, a2, a3) = if s == 0 {
305 (x1, x2, x3)
306 } else {
307 (
308 mul_vec_avx2::<M>(x1, w1v, r_vec, mod_vec),
309 mul_vec_avx2::<M>(x2, w2v, r_vec, mod_vec),
310 mul_vec_avx2::<M>(x3, w3v, r_vec, mod_vec),
311 )
312 };
313
314 let a0pa2 = add_vec_avx2::<M>(x0, a2, mod_vec, mod2_vec);
315 let a0na2 = sub_vec_avx2::<M>(x0, a2, mod_vec, mod2_vec);
316 let a1pa3 = add_vec_avx2::<M>(a1, a3, mod_vec, mod2_vec);
317 let a1na3 = sub_vec_avx2::<M>(a1, a3, mod_vec, mod2_vec);
318 let a1na3imag = mul_vec_avx2::<M>(a1na3, imag_vec, r_vec, mod_vec);
319
320 let y0 = add_vec_avx2::<M>(a0pa2, a1pa3, mod_vec, mod2_vec);
321 let y1 = sub_vec_avx2::<M>(a0pa2, a1pa3, mod_vec, mod2_vec);
322 let y2 = add_vec_avx2::<M>(a0na2, a1na3imag, mod_vec, mod2_vec);
323 let y3 = sub_vec_avx2::<M>(a0na2, a1na3imag, mod_vec, mod2_vec);
324
325 store_ntt_avx2(ll.add(i), y0, step);
326 store_ntt_avx2(lr.add(i), y1, step);
327 store_ntt_avx2(rl.add(i), y2, step);
328 store_ntt_avx2(rr.add(i), y3, step);
329 i += step;
330 }
331 while i < half {
332 let a0 = *ll.add(i);
333 let a1 = mul_scalar::<M>(*lr.add(i), w1);
334 let a2 = mul_scalar::<M>(*rl.add(i), w2);
335 let a3 = mul_scalar::<M>(*rr.add(i), w3);
336 let a0pa2 = add_scalar::<M>(a0, a2);
337 let a0na2 = sub_scalar::<M>(a0, a2);
338 let a1pa3 = add_scalar::<M>(a1, a3);
339 let a1na3 = sub_scalar::<M>(a1, a3);
340 let a1na3imag = mul_scalar::<M>(a1na3, imag);
341 *ll.add(i) = add_scalar::<M>(a0pa2, a1pa3);
342 *lr.add(i) = sub_scalar::<M>(a0pa2, a1pa3);
343 *rl.add(i) = add_scalar::<M>(a0na2, a1na3imag);
344 *rr.add(i) = sub_scalar::<M>(a0na2, a1na3imag);
345 i += 1;
346 }
347 let rate = &M::INFO.rate3_packed[s.trailing_ones() as usize];
348 w1 = M::mod_mul(w1, rate[1]);
349 w2 = M::mod_mul(w2, rate[3]);
350 w3 = M::mod_mul(w3, rate[5]);
351 }
352 v >>= 2;
353 }
354 normalize_avx2::<M>(a);
355}
356
357#[inline]
358#[target_feature(enable = "avx2")]
359pub unsafe fn intt_batch_avx2<M, const PARTIAL: bool>(a: &mut [MInt<M>], width: usize)
360where
361 M: Montgomery32NttModulus,
362{
363 let n = a.len() / width;
364 if n <= 1 {
365 return;
366 }
367 let ptr = a.as_mut_ptr() as *mut u32;
368 let a = std::slice::from_raw_parts_mut(ptr, a.len());
369 let mod_vec = _mm256_set1_epi32(M::MOD as i32);
370 let mod2_vec = _mm256_set1_epi32(M::MOD.wrapping_add(M::MOD) as i32);
371 let r_vec = _mm256_set1_epi32(M::R as i32);
372 let iimag = M::INFO.inv_root[2];
373 let iimag_vec = _mm256_set1_epi32(iimag as i32);
374
375 let mut v = 1;
376 if width == 1 && a.len() >= 8 && M::MOD < LAZY_THRESHOLD {
377 ntt_four_avx2::<M, true>(a);
378 v = 4;
379 }
380 let limit = if n.trailing_zeros() & 1 == 1 {
381 n / 2
382 } else {
383 n
384 };
385 while v < limit {
386 let quarter = v * width;
387 let step = if PARTIAL && quarter == 4 { 4 } else { 8 };
388 let mut w1 = M::N1;
389 let mut w2 = w1;
390 let mut w3 = w1;
391 for (s, block) in a.chunks_exact_mut((v << 2) * width).enumerate() {
392 let base = block.as_mut_ptr();
393 let ll = base;
394 let lr = base.add(quarter);
395 let rl = base.add(quarter * 2);
396 let rr = base.add(quarter * 3);
397
398 let w1v = _mm256_set1_epi32(w1 as i32);
399 let w2v = _mm256_set1_epi32(w2 as i32);
400 let w3v = _mm256_set1_epi32(w3 as i32);
401
402 let mut i = 0;
403 while i + step <= quarter {
404 let x0 = load_ntt_avx2(ll.add(i), step);
405 let x1 = load_ntt_avx2(lr.add(i), step);
406 let x2 = load_ntt_avx2(rl.add(i), step);
407 let x3 = load_ntt_avx2(rr.add(i), step);
408
409 let a0pa1 = add_vec_avx2::<M>(x0, x1, mod_vec, mod2_vec);
410 let a0na1 = sub_vec_avx2::<M>(x0, x1, mod_vec, mod2_vec);
411 let a2pa3 = add_vec_avx2::<M>(x2, x3, mod_vec, mod2_vec);
412 let a2na3 = sub_vec_avx2::<M>(x2, x3, mod_vec, mod2_vec);
413 let a2na3iimag = mul_vec_avx2::<M>(a2na3, iimag_vec, r_vec, mod_vec);
414
415 let y0 = add_vec_avx2::<M>(a0pa1, a2pa3, mod_vec, mod2_vec);
416 let y1 = add_vec_avx2::<M>(a0na1, a2na3iimag, mod_vec, mod2_vec);
417 let y2 = sub_vec_avx2::<M>(a0pa1, a2pa3, mod_vec, mod2_vec);
418 let y3 = sub_vec_avx2::<M>(a0na1, a2na3iimag, mod_vec, mod2_vec);
419
420 let (y1, y2, y3) = if s == 0 {
421 (y1, y2, y3)
422 } else {
423 (
424 mul_vec_avx2::<M>(y1, w1v, r_vec, mod_vec),
425 mul_vec_avx2::<M>(y2, w2v, r_vec, mod_vec),
426 mul_vec_avx2::<M>(y3, w3v, r_vec, mod_vec),
427 )
428 };
429
430 store_ntt_avx2(ll.add(i), y0, step);
431 store_ntt_avx2(lr.add(i), y1, step);
432 store_ntt_avx2(rl.add(i), y2, step);
433 store_ntt_avx2(rr.add(i), y3, step);
434 i += step;
435 }
436 while i < quarter {
437 let a0 = *ll.add(i);
438 let a1 = *lr.add(i);
439 let a2 = *rl.add(i);
440 let a3 = *rr.add(i);
441 let a0pa1 = add_scalar::<M>(a0, a1);
442 let a0na1 = sub_scalar::<M>(a0, a1);
443 let a2pa3 = add_scalar::<M>(a2, a3);
444 let a2na3iimag = mul_scalar::<M>(sub_scalar::<M>(a2, a3), iimag);
445 *ll.add(i) = add_scalar::<M>(a0pa1, a2pa3);
446 *lr.add(i) = mul_scalar::<M>(add_scalar::<M>(a0na1, a2na3iimag), w1);
447 *rl.add(i) = mul_scalar::<M>(sub_scalar::<M>(a0pa1, a2pa3), w2);
448 *rr.add(i) = mul_scalar::<M>(sub_scalar::<M>(a0na1, a2na3iimag), w3);
449 i += 1;
450 }
451 let rate = &M::INFO.inv_rate3_packed[s.trailing_ones() as usize];
452 w1 = M::mod_mul(w1, rate[1]);
453 w2 = M::mod_mul(w2, rate[3]);
454 w3 = M::mod_mul(w3, rate[5]);
455 }
456 v <<= 2;
457 }
458 if n.trailing_zeros() & 1 == 1 {
459 let half = (n >> 1) * width;
460 let step = if PARTIAL && half == 4 { 4 } else { 8 };
461 let mut i = 0;
462 while i + step <= half {
463 let x0 = load_ntt_avx2(a.as_ptr().add(i), step);
464 let x1 = load_ntt_avx2(a.as_ptr().add(half + i), step);
465 let y0 = add_vec_avx2::<M>(x0, x1, mod_vec, mod2_vec);
466 let y1 = sub_vec_avx2::<M>(x0, x1, mod_vec, mod2_vec);
467 store_ntt_avx2(a.as_mut_ptr().add(i), y0, step);
468 store_ntt_avx2(a.as_mut_ptr().add(half + i), y1, step);
469 i += step;
470 }
471 while i < half {
472 let x0 = a[i];
473 let x1 = a[half + i];
474 a[i] = add_scalar::<M>(x0, x1);
475 a[half + i] = sub_scalar::<M>(x0, x1);
476 i += 1;
477 }
478 }
479 let inv = M::mod_inv(<M as MIntConvert<u32>>::from(n as u32));
480 let inv_vec = _mm256_set1_epi32(inv as i32);
481 let mut i = 0;
482 while i + 8 <= a.len() {
483 let x = _mm256_loadu_si256(a.as_ptr().add(i) as *const __m256i);
484 let y = montgomery_simd::montgomery_mul_256_canon(x, inv_vec, r_vec, mod_vec);
485 _mm256_storeu_si256(a.as_mut_ptr().add(i) as *mut __m256i, y);
486 i += 8;
487 }
488 while i < a.len() {
489 a[i] = M::mod_mul(a[i], inv);
490 i += 1;
491 }
492}