From 7e9a9501b5334804b136f81d0bb27e279d8747ff Mon Sep 17 00:00:00 2001 From: Jean-Philippe Bossuat Date: Fri, 24 Jan 2025 11:19:04 +0100 Subject: [PATCH] reworked NTT benchmarks --- math/benches/ntt.rs | 141 +++++++++++++++++++------------------------- 1 file changed, 62 insertions(+), 79 deletions(-) diff --git a/math/benches/ntt.rs b/math/benches/ntt.rs index c287389..0521d36 100644 --- a/math/benches/ntt.rs +++ b/math/benches/ntt.rs @@ -1,104 +1,87 @@ use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion}; -use math::dft::DFT; -use math::{dft::ntt::Table, modulus::prime::Prime}; +use math::modulus::WordOps; +use math::ring::Ring; +use math::poly::Poly; -fn forward_inplace(c: &mut Criterion) { - fn runner(prime_instance: Prime, nth_root: usize) -> Box { - let ntt_table: Table = Table::::new(prime_instance, nth_root); - let mut a: Vec = vec![0; (nth_root >> 1) as usize]; - for i in 0..a.len() { - a[i] = i as u64; +fn ntt(c: &mut Criterion) { + + fn runner<'a, const INPLACE: bool, const LAZY:bool>(ring: &'a Ring) -> Box { + let mut a: Poly = ring.new_poly(); + for i in 0..a.n() { + a.0[i] = i as u64; + } + if INPLACE{ + Box::new(move || ring.ntt_inplace::(&mut a)) + }else{ + let mut b: Poly = ring.new_poly(); + Box::new(move || ring.ntt::(&a, &mut b)) } - Box::new(move || ntt_table.forward_inplace::(&mut a)) } - let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = - c.benchmark_group("forward_inplace"); - for log_nth_root in 11..18 { - let prime_instance: Prime = Prime::::new(0x1fffffffffe00001, 1); + let q: u64 = 0x1fffffffffe00001u64; + + let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = + c.benchmark_group("ntt"); + + for log_n in 10..17 { + + let ring = Ring::new(1<); 4] = [ + (format!("inplace=true/LAZY=true/q={}", q.log2()), { runner::(&ring) }), + (format!("inplace=true/LAZY=false/q={}", q.log2()), { runner::(&ring) }), + (format!("inplace=false/LAZY=true/q={}", q.log2()), { runner::(&ring) }), + (format!("inplace=false/LAZY=false/q={}", q.log2()), { runner::(&ring) }), + ]; - let runners = [("prime", { runner(prime_instance, 1 << log_nth_root) })]; for (name, mut runner) in runners { - let id = BenchmarkId::new(name, 1 << (log_nth_root - 1)); - b.bench_with_input(id, &(), |b, _| b.iter(&mut runner)); + let id: BenchmarkId = BenchmarkId::new(name, format!("n={}", 1 << log_n)); + b.bench_with_input(id, &(), |b: &mut criterion::Bencher<'_>, _| b.iter(&mut runner)); } } } -fn forward_inplace_lazy(c: &mut Criterion) { - fn runner(prime_instance: Prime, nth_root: usize) -> Box { - let ntt_table: Table = Table::::new(prime_instance, nth_root); - let mut a: Vec = vec![0; (nth_root >> 1) as usize]; - for i in 0..a.len() { - a[i] = i as u64; +fn intt(c: &mut Criterion) { + + fn runner<'a, const INPLACE: bool, const LAZY:bool>(ring: &'a Ring) -> Box { + let mut a: Poly = ring.new_poly(); + for i in 0..a.n() { + a.0[i] = i as u64; + } + if INPLACE{ + Box::new(move || ring.intt_inplace::(&mut a)) + }else{ + let mut b: Poly = ring.new_poly(); + Box::new(move || ring.intt::(&a, &mut b)) } - Box::new(move || ntt_table.forward_inplace_lazy(&mut a)) } + let q: u64 = 0x1fffffffffe00001u64; + let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = - c.benchmark_group("forward_inplace_lazy"); - for log_nth_root in 11..17 { - let prime_instance: Prime = Prime::::new(0x1fffffffffe00001, 1); + c.benchmark_group("intt"); + + for log_n in 10..17 { + + let ring = Ring::new(1<); 4] = [ + (format!("inplace=true/LAZY=true/q={}", q.log2()), { runner::(&ring) }), + (format!("inplace=true/LAZY=false/q={}", q.log2()), { runner::(&ring) }), + (format!("inplace=false/LAZY=true/q={}", q.log2()), { runner::(&ring) }), + (format!("inplace=false/LAZY=false/q={}", q.log2()), { runner::(&ring) }), + ]; - let runners = [("prime", { runner(prime_instance, 1 << log_nth_root) })]; for (name, mut runner) in runners { - let id = BenchmarkId::new(name, 1 << (log_nth_root - 1)); - b.bench_with_input(id, &(), |b, _| b.iter(&mut runner)); - } - } -} - -fn backward_inplace(c: &mut Criterion) { - fn runner(prime_instance: Prime, nth_root: usize) -> Box { - let ntt_table: Table = Table::::new(prime_instance, nth_root); - let mut a: Vec = vec![0; (nth_root >> 1) as usize]; - for i in 0..a.len() { - a[i] = i as u64; - } - Box::new(move || ntt_table.backward_inplace::(&mut a)) - } - - let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = - c.benchmark_group("backward_inplace"); - for log_nth_root in 11..18 { - let prime_instance: Prime = Prime::::new(0x1fffffffffe00001, 1); - - let runners = [("prime", { runner(prime_instance, 1 << log_nth_root) })]; - for (name, mut runner) in runners { - let id = BenchmarkId::new(name, 1 << (log_nth_root - 1)); - b.bench_with_input(id, &(), |b, _| b.iter(&mut runner)); - } - } -} - -fn backward_inplace_lazy(c: &mut Criterion) { - fn runner(prime_instance: Prime, nth_root: usize) -> Box { - let ntt_table: Table = Table::::new(prime_instance, nth_root); - let mut a: Vec = vec![0; (nth_root >> 1) as usize]; - for i in 0..a.len() { - a[i] = i as u64; - } - Box::new(move || ntt_table.backward_inplace::(&mut a)) - } - - let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = - c.benchmark_group("backward_inplace_lazy"); - for log_nth_root in 11..17 { - let prime_instance: Prime = Prime::::new(0x1fffffffffe00001, 1); - - let runners = [("prime", { runner(prime_instance, 1 << log_nth_root) })]; - for (name, mut runner) in runners { - let id = BenchmarkId::new(name, 1 << (log_nth_root - 1)); - b.bench_with_input(id, &(), |b, _| b.iter(&mut runner)); + let id: BenchmarkId = BenchmarkId::new(name, format!("n={}", 1 << log_n)); + b.bench_with_input(id, &(), |b: &mut criterion::Bencher<'_>, _| b.iter(&mut runner)); } } } criterion_group!( benches, - forward_inplace, - forward_inplace_lazy, - backward_inplace, - backward_inplace_lazy + ntt, + intt, ); criterion_main!(benches);