1use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
  2use math::modulus::montgomery::Montgomery;
  3use math::modulus::VectorOperations;
  4use math::modulus::ONCE;
  5use math::ring::Ring;
  6use math::CHUNK;
  7
  8fn va_add_vb_into_vb(c: &mut Criterion) {
  9    fn runner(r: Ring<u64>) -> Box<dyn FnMut()> {
 10        let mut p0: math::poly::Poly<u64> = r.new_poly();
 11        let mut p1: math::poly::Poly<u64> = r.new_poly();
 12        for i in 0..p0.n() {
 13            p0.0[i] = i as u64;
 14            p1.0[i] = i as u64;
 15        }
 16        Box::new(move || {
 17            r.modulus.va_add_vb_into_vb::<CHUNK, ONCE>(&p0.0, &mut p1.0);
 18        })
 19    }
 20
 21    let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
 22        c.benchmark_group("va_add_vb_into_vb");
 23    for log_n in 11..17 {
 24        let n: usize = 1 << log_n as usize;
 25        let q_base: u64 = 0x1fffffffffe00001u64;
 26        let q_power: usize = 1usize;
 27        let r: Ring<u64> = Ring::<u64>::new(n, q_base, q_power);
 28        let runners = [("prime", { runner(r) })];
 29        for (name, mut runner) in runners {
 30            let id = BenchmarkId::new(name, n);
 31            b.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
 32        }
 33    }
 34}
 35
 36fn va_mont_mul_vb_into_vb(c: &mut Criterion) {
 37    fn runner(r: Ring<u64>) -> Box<dyn FnMut()> {
 38        let mut p0: math::poly::Poly<Montgomery<u64>> = r.new_poly();
 39        let mut p1: math::poly::Poly<u64> = r.new_poly();
 40        for i in 0..p0.n() {
 41            p0.0[i] = r.modulus.montgomery.prepare::<ONCE>(i as u64);
 42            p1.0[i] = i as u64;
 43        }
 44        Box::new(move || {
 45            r.modulus
 46                .va_mont_mul_vb_into_vb::<CHUNK, ONCE>(&p0.0, &mut p1.0);
 47        })
 48    }
 49
 50    let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
 51        c.benchmark_group("va_mont_mul_vb_into_vb");
 52    for log_n in 11..17 {
 53        let n: usize = 1 << log_n as usize;
 54        let q_base: u64 = 0x1fffffffffe00001u64;
 55        let q_power: usize = 1usize;
 56        let r: Ring<u64> = Ring::<u64>::new(n, q_base, q_power);
 57        let runners = [("prime", { runner(r) })];
 58        for (name, mut runner) in runners {
 59            let id = BenchmarkId::new(name, n);
 60            b.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
 61        }
 62    }
 63}
 64
 65fn va_mont_mul_vb_into_vc(c: &mut Criterion) {
 66    fn runner(r: Ring<u64>) -> Box<dyn FnMut()> {
 67        let mut p0: math::poly::Poly<Montgomery<u64>> = r.new_poly();
 68        let mut p1: math::poly::Poly<u64> = r.new_poly();
 69        let mut p2: math::poly::Poly<u64> = r.new_poly();
 70        for i in 0..p0.n() {
 71            p0.0[i] = r.modulus.montgomery.prepare::<ONCE>(i as u64);
 72            p1.0[i] = i as u64;
 73        }
 74        Box::new(move || {
 75            r.modulus
 76                .va_mont_mul_vb_into_vc::<CHUNK, ONCE>(&p0.0, &p1.0, &mut p2.0);
 77        })
 78    }
 79
 80    let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
 81        c.benchmark_group("va_mont_mul_vb_into_vc");
 82    for log_n in 11..17 {
 83        let n: usize = 1 << log_n as usize;
 84        let q_base: u64 = 0x1fffffffffe00001u64;
 85        let q_power: usize = 1usize;
 86        let r: Ring<u64> = Ring::<u64>::new(n, q_base, q_power);
 87        let runners = [("prime", { runner(r) })];
 88        for (name, mut runner) in runners {
 89            let id = BenchmarkId::new(name, n);
 90            b.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
 91        }
 92    }
 93}
 94
 95criterion_group!(
 96    benches,
 97    va_add_vb_into_vb,
 98    va_mont_mul_vb_into_vb,
 99    va_mont_mul_vb_into_vc
100);
101criterion_main!(benches);