1use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
  2use math::{modulus::prime::Prime,dft::ntt::Table};
  3use math::dft::DFT;
  4
  5fn forward_inplace(c: &mut Criterion) {
  6    fn runner(prime_instance: Prime<u64>, nth_root: u64) -> Box<dyn FnMut()> {
  7        let ntt_table: Table<u64> = Table::<u64>::new(prime_instance, nth_root);
  8        let mut a: Vec<u64> = vec![0; (nth_root >> 1) as usize];
  9        for i in 0..a.len(){
 10            a[i] = i as u64;
 11        }
 12        Box::new(move || {
 13            ntt_table.forward_inplace::<false>(&mut a)
 14        })
 15    }
 16
 17    let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = c.benchmark_group("forward_inplace");
 18    for log_nth_root in 11..18 {
 19
 20        let prime_instance: Prime<u64> = Prime::<u64>::new(0x1fffffffffe00001, 1);
 21
 22        let runners = [
 23            ("prime", {
 24                runner(prime_instance, 1<<log_nth_root)
 25            }),
 26        ];
 27        for (name, mut runner) in runners {
 28            let id = BenchmarkId::new(name, 1<<(log_nth_root-1));
 29            b.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
 30        }
 31    }
 32}
 33
 34fn forward_inplace_lazy(c: &mut Criterion) {
 35    fn runner(prime_instance: Prime<u64>, nth_root: u64) -> Box<dyn FnMut()> {
 36        let ntt_table: Table<u64> = Table::<u64>::new(prime_instance, nth_root);
 37        let mut a: Vec<u64> = vec![0; (nth_root >> 1) as usize];
 38        for i in 0..a.len(){
 39            a[i] = i as u64;
 40        }
 41        Box::new(move || {
 42            ntt_table.forward_inplace_lazy(&mut a)
 43        })
 44    }
 45
 46    let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = c.benchmark_group("forward_inplace_lazy");
 47    for log_nth_root in 11..17 {
 48
 49        let prime_instance: Prime<u64> = Prime::<u64>::new(0x1fffffffffe00001, 1);
 50
 51        let runners = [
 52            ("prime", {
 53                runner(prime_instance, 1<<log_nth_root)
 54            }),
 55        ];
 56        for (name, mut runner) in runners {
 57            let id = BenchmarkId::new(name, 1<<(log_nth_root-1));
 58            b.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
 59        }
 60    }
 61}
 62
 63fn backward_inplace(c: &mut Criterion) {
 64    fn runner(prime_instance: Prime<u64>, nth_root: u64) -> Box<dyn FnMut()> {
 65        let ntt_table: Table<u64> = Table::<u64>::new(prime_instance, nth_root);
 66        let mut a: Vec<u64> = vec![0; (nth_root >> 1) as usize];
 67        for i in 0..a.len(){
 68            a[i] = i as u64;
 69        }
 70        Box::new(move || {
 71            ntt_table.backward_inplace::<false>(&mut a)
 72        })
 73    }
 74
 75    let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = c.benchmark_group("backward_inplace");
 76    for log_nth_root in 11..18 {
 77
 78        let prime_instance: Prime<u64> = Prime::<u64>::new(0x1fffffffffe00001, 1);
 79
 80        let runners = [
 81            ("prime", {
 82                runner(prime_instance, 1<<log_nth_root)
 83            }),
 84        ];
 85        for (name, mut runner) in runners {
 86            let id = BenchmarkId::new(name, 1<<(log_nth_root-1));
 87            b.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
 88        }
 89    }
 90}
 91
 92fn backward_inplace_lazy(c: &mut Criterion) {
 93    fn runner(prime_instance: Prime<u64>, nth_root: u64) -> Box<dyn FnMut()> {
 94        let ntt_table: Table<u64> = Table::<u64>::new(prime_instance, nth_root);
 95        let mut a: Vec<u64> = vec![0; (nth_root >> 1) as usize];
 96        for i in 0..a.len(){
 97            a[i] = i as u64;
 98        }
 99        Box::new(move || {
100            ntt_table.backward_inplace::<true>(&mut a)
101        })
102    }
103
104    let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = c.benchmark_group("backward_inplace_lazy");
105    for log_nth_root in 11..17 {
106
107        let prime_instance: Prime<u64> = Prime::<u64>::new(0x1fffffffffe00001, 1);
108
109        let runners = [
110            ("prime", {
111                runner(prime_instance, 1<<log_nth_root)
112            }),
113        ];
114        for (name, mut runner) in runners {
115            let id = BenchmarkId::new(name, 1<<(log_nth_root-1));
116            b.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
117        }
118    }
119}
120
121criterion_group!(benches, forward_inplace, forward_inplace_lazy, backward_inplace, backward_inplace_lazy);
122criterion_main!(benches);