1use base2k::{
  2    Encoding, FFT64, Infos, Module, Sampling, Scalar, SvpPPolOps, VecZnx, VecZnxBig, VecZnxDft,
  3    VecZnxOps,
  4};
  5use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
  6use rlwe::{
  7    ciphertext::{Ciphertext, GadgetCiphertext},
  8    decryptor::{Decryptor, decrypt_rlwe_thread_safe, decrypt_rlwe_thread_safe_tmp_byte},
  9    elem::Elem,
 10    encryptor::{
 11        EncryptorSk, encrypt_grlwe_sk_thread_safe, encrypt_grlwe_sk_tmp_bytes,
 12        encrypt_rlwe_sk_tmp_bytes,
 13    },
 14    evaluator::{gadget_product_inplace_thread_safe, gadget_product_tmp_bytes},
 15    key_generator::{gen_switching_key_thread_safe, gen_switching_key_thread_safe_tmp_bytes},
 16    keys::{SecretKey, SwitchingKey},
 17    parameters::{Parameters, ParametersLiteral},
 18    plaintext::Plaintext,
 19};
 20use sampling::source::{Source, new_seed};
 21
 22fn gadget_product_inplace(c: &mut Criterion) {
 23    fn gadget_product<'a>(
 24        module: &'a Module,
 25        elem: &'a mut Elem,
 26        gadget_ct: &'a GadgetCiphertext,
 27        tmp_bytes: &'a mut [u8],
 28    ) -> Box<dyn FnMut() + 'a> {
 29        Box::new(move || {
 30            gadget_product_inplace_thread_safe::<true>(module, elem, gadget_ct, tmp_bytes)
 31        })
 32    }
 33
 34    let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
 35        c.benchmark_group("gadget_product_inplace");
 36
 37    for log_n in 10..11 {
 38        let params_lit: ParametersLiteral = ParametersLiteral {
 39            log_n: log_n,
 40            log_q: 54,
 41            log_p: 0,
 42            log_base2k: 7,
 43            log_scale: 20,
 44            xe: 3.2,
 45            xs: 128,
 46        };
 47
 48        let params: Parameters = Parameters::new::<FFT64>(&params_lit);
 49
 50        let mut tmp_bytes: Vec<u8> = vec![
 51            0u8;
 52            params.decrypt_rlwe_thread_safe_tmp_byte(params.log_q())
 53                | params.encrypt_rlwe_sk_tmp_bytes(params.log_q())
 54                | gen_switching_key_thread_safe_tmp_bytes(
 55                    params.module(),
 56                    params.log_base2k(),
 57                    params.limbs_q(),
 58                    params.log_q()
 59                )
 60                | gadget_product_tmp_bytes(
 61                    params.module(),
 62                    params.log_base2k(),
 63                    params.log_q(),
 64                    params.log_q(),
 65                    params.limbs_q(),
 66                    params.log_qp()
 67                )
 68                | encrypt_grlwe_sk_tmp_bytes(
 69                    params.module(),
 70                    params.log_base2k(),
 71                    params.limbs_qp(),
 72                    params.log_qp()
 73                )
 74        ];
 75
 76        let mut source: Source = Source::new([3; 32]);
 77
 78        let mut sk0: SecretKey = SecretKey::new(params.module());
 79        let mut sk1: SecretKey = SecretKey::new(params.module());
 80
 81        let mut source_xe: Source = Source::new([4; 32]);
 82        let mut source_xa: Source = Source::new([5; 32]);
 83
 84        let mut sk0_svp_ppol: base2k::SvpPPol = params.module().new_svp_ppol();
 85        params.module().svp_prepare(&mut sk0_svp_ppol, &sk0.0);
 86
 87        let mut sk1_svp_ppol: base2k::SvpPPol = params.module().new_svp_ppol();
 88        params.module().svp_prepare(&mut sk1_svp_ppol, &sk1.0);
 89
 90        let mut gadget_ct: GadgetCiphertext = GadgetCiphertext::new(
 91            params.module(),
 92            params.log_base2k(),
 93            params.limbs_q(),
 94            params.log_qp(),
 95        );
 96
 97        encrypt_grlwe_sk_thread_safe(
 98            params.module(),
 99            &mut gadget_ct,
100            &sk0.0,
101            &sk1_svp_ppol,
102            &mut source_xa,
103            &mut source_xe,
104            params.xe(),
105            &mut tmp_bytes,
106        );
107
108        let mut ct: Ciphertext = params.new_ciphertext(params.log_q());
109
110        params.encrypt_rlwe_sk_thread_safe(
111            &mut ct,
112            None,
113            &sk0_svp_ppol,
114            &mut source_xa,
115            &mut source_xe,
116            &mut tmp_bytes,
117        );
118
119        let runners: [(String, Box<dyn FnMut()>); 1] = [(format!("gadget_product"), {
120            gadget_product(params.module(), &mut ct.0, &gadget_ct, &mut tmp_bytes)
121        })];
122
123        for (name, mut runner) in runners {
124            let id: BenchmarkId = BenchmarkId::new(name, format!("n={}", 1 << log_n));
125            b.bench_with_input(id, &(), |b: &mut criterion::Bencher<'_>, _| {
126                b.iter(&mut runner)
127            });
128        }
129    }
130}
131
132criterion_group!(benches, gadget_product_inplace);
133criterion_main!(benches);