updated repo for publishing (#74)

poulpy-core/benches/external_product_glwe_fft64.rs

@@ -0,0 +1,216 @@
+use poulpy_core::layouts::{
+    GGSWCiphertext, GLWECiphertext, GLWESecret, Infos,
+    prepared::{GGSWCiphertextPrepared, GLWESecretPrepared, PrepareAlloc},
+};
+use std::hint::black_box;
+
+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
+use poulpy_backend::{
+    hal::{
+        api::{ModuleNew, ScratchOwnedAlloc, ScratchOwnedBorrow},
+        layouts::{Module, ScalarZnx, ScratchOwned},
+        source::Source,
+    },
+    implementation::cpu_spqlios::FFT64,
+};
+
+fn bench_external_product_glwe_fft64(c: &mut Criterion) {
+    let mut group = c.benchmark_group("external_product_glwe_fft64");
+
+    struct Params {
+        log_n: usize,
+        basek: usize,
+        k_ct_in: usize,
+        k_ct_out: usize,
+        k_ggsw: usize,
+        rank: usize,
+    }
+
+    fn runner(p: Params) -> impl FnMut() {
+        let module: Module<FFT64> = Module::<FFT64>::new(1 << p.log_n);
+
+        let n: usize = module.n();
+        let basek: usize = p.basek;
+        let k_ct_in: usize = p.k_ct_in;
+        let k_ct_out: usize = p.k_ct_out;
+        let k_ggsw: usize = p.k_ggsw;
+        let rank: usize = p.rank;
+        let digits: usize = 1;
+
+        let rows: usize = 1; //(p.k_ct_in.div_ceil(p.basek);
+        let sigma: f64 = 3.2;
+
+        let mut ct_ggsw: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_ggsw, rows, digits, rank);
+        let mut ct_glwe_in: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_ct_in, rank);
+        let mut ct_glwe_out: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_ct_out, rank);
+        let pt_rgsw: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
+
+        let mut scratch: ScratchOwned<FFT64> = ScratchOwned::alloc(
+            GGSWCiphertext::encrypt_sk_scratch_space(&module, n, basek, ct_ggsw.k(), rank)
+                | GLWECiphertext::encrypt_sk_scratch_space(&module, n, basek, ct_glwe_in.k())
+                | GLWECiphertext::external_product_scratch_space(
+                    &module,
+                    n,
+                    basek,
+                    ct_glwe_out.k(),
+                    ct_glwe_in.k(),
+                    ct_ggsw.k(),
+                    digits,
+                    rank,
+                ),
+        );
+
+        let mut source_xs = Source::new([0u8; 32]);
+        let mut source_xe = Source::new([0u8; 32]);
+        let mut source_xa = Source::new([0u8; 32]);
+
+        let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+        sk.fill_ternary_prob(0.5, &mut source_xs);
+        let sk_dft: GLWESecretPrepared<Vec<u8>, FFT64> = sk.prepare_alloc(&module, scratch.borrow());
+
+        ct_ggsw.encrypt_sk(
+            &module,
+            &pt_rgsw,
+            &sk_dft,
+            &mut source_xa,
+            &mut source_xe,
+            sigma,
+            scratch.borrow(),
+        );
+
+        ct_glwe_in.encrypt_zero_sk(
+            &module,
+            &sk_dft,
+            &mut source_xa,
+            &mut source_xe,
+            sigma,
+            scratch.borrow(),
+        );
+
+        let ggsw_prepared: GGSWCiphertextPrepared<Vec<u8>, FFT64> = ct_ggsw.prepare_alloc(&module, scratch.borrow());
+
+        move || {
+            ct_glwe_out.external_product(&module, &ct_glwe_in, &ggsw_prepared, scratch.borrow());
+            black_box(());
+        }
+    }
+
+    let params_set: Vec<Params> = vec![Params {
+        log_n: 11,
+        basek: 22,
+        k_ct_in: 44,
+        k_ct_out: 44,
+        k_ggsw: 54,
+        rank: 1,
+    }];
+
+    for params in params_set {
+        let id = BenchmarkId::new("EXTERNAL_PRODUCT_GLWE_FFT64", "");
+        let mut runner = runner(params);
+        group.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
+    }
+
+    group.finish();
+}
+
+fn bench_external_product_glwe_inplace_fft64(c: &mut Criterion) {
+    let mut group = c.benchmark_group("external_product_glwe_inplace_fft64");
+
+    struct Params {
+        log_n: usize,
+        basek: usize,
+        k_ct: usize,
+        k_ggsw: usize,
+        rank: usize,
+    }
+
+    fn runner(p: Params) -> impl FnMut() {
+        let module: Module<FFT64> = Module::<FFT64>::new(1 << p.log_n);
+
+        let n = module.n();
+        let basek: usize = p.basek;
+        let k_glwe: usize = p.k_ct;
+        let k_ggsw: usize = p.k_ggsw;
+        let rank: usize = p.rank;
+        let digits: usize = 1;
+
+        let rows: usize = p.k_ct.div_ceil(p.basek);
+        let sigma: f64 = 3.2;
+
+        let mut ct_ggsw: GGSWCiphertext<Vec<u8>> = GGSWCiphertext::alloc(n, basek, k_ggsw, rows, digits, rank);
+        let mut ct_glwe: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_glwe, rank);
+        let pt_rgsw: ScalarZnx<Vec<u8>> = ScalarZnx::alloc(n, 1);
+
+        let mut scratch: ScratchOwned<FFT64> = ScratchOwned::alloc(
+            GGSWCiphertext::encrypt_sk_scratch_space(&module, n, basek, ct_ggsw.k(), rank)
+                | GLWECiphertext::encrypt_sk_scratch_space(&module, n, basek, ct_glwe.k())
+                | GLWECiphertext::external_product_inplace_scratch_space(
+                    &module,
+                    n,
+                    basek,
+                    ct_glwe.k(),
+                    ct_ggsw.k(),
+                    digits,
+                    rank,
+                ),
+        );
+
+        let mut source_xs = Source::new([0u8; 32]);
+        let mut source_xe = Source::new([0u8; 32]);
+        let mut source_xa = Source::new([0u8; 32]);
+
+        let mut sk: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+        sk.fill_ternary_prob(0.5, &mut source_xs);
+        let sk_dft: GLWESecretPrepared<Vec<u8>, FFT64> = sk.prepare_alloc(&module, scratch.borrow());
+
+        ct_ggsw.encrypt_sk(
+            &module,
+            &pt_rgsw,
+            &sk_dft,
+            &mut source_xa,
+            &mut source_xe,
+            sigma,
+            scratch.borrow(),
+        );
+
+        ct_glwe.encrypt_zero_sk(
+            &module,
+            &sk_dft,
+            &mut source_xa,
+            &mut source_xe,
+            sigma,
+            scratch.borrow(),
+        );
+
+        let ggsw_prepared: GGSWCiphertextPrepared<Vec<u8>, FFT64> = ct_ggsw.prepare_alloc(&module, scratch.borrow());
+
+        move || {
+            let scratch_borrow = scratch.borrow();
+            ct_glwe.external_product_inplace(&module, &ggsw_prepared, scratch_borrow);
+            black_box(());
+        }
+    }
+
+    let params_set: Vec<Params> = vec![Params {
+        log_n: 12,
+        basek: 18,
+        k_ct: 54,
+        k_ggsw: 54,
+        rank: 1,
+    }];
+
+    for params in params_set {
+        let id = BenchmarkId::new("EXTERNAL_PRODUCT_GLWE_INPLACE_FFT64", "");
+        let mut runner = runner(params);
+        group.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
+    }
+
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    bench_external_product_glwe_fft64,
+    bench_external_product_glwe_inplace_fft64
+);
+criterion_main!(benches);

poulpy-core/benches/keyswitch_glwe_fft64.rs

@@ -0,0 +1,222 @@
+use poulpy_core::layouts::{
+    GGLWEAutomorphismKey, GGLWESwitchingKey, GLWECiphertext, GLWESecret, Infos,
+    prepared::{GGLWEAutomorphismKeyPrepared, GGLWESwitchingKeyPrepared, GLWESecretPrepared, PrepareAlloc},
+};
+use std::{hint::black_box, time::Duration};
+
+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
+use poulpy_backend::{
+    hal::{
+        api::{ModuleNew, ScratchOwnedAlloc, ScratchOwnedBorrow},
+        layouts::{Module, ScratchOwned},
+        source::Source,
+    },
+    implementation::cpu_spqlios::FFT64,
+};
+
+fn bench_keyswitch_glwe_fft64(c: &mut Criterion) {
+    let mut group = c.benchmark_group("keyswitch_glwe_fft64");
+
+    struct Params {
+        log_n: usize,
+        basek: usize,
+        k_ct_in: usize,
+        k_ct_out: usize,
+        k_ksk: usize,
+        digits: usize,
+        rank_in: usize,
+        rank_out: usize,
+    }
+
+    fn runner(p: Params) -> impl FnMut() {
+        let module: Module<FFT64> = Module::<FFT64>::new(1 << p.log_n);
+
+        let n = module.n();
+        let basek: usize = p.basek;
+        let k_rlwe_in: usize = p.k_ct_in;
+        let k_rlwe_out: usize = p.k_ct_out;
+        let k_grlwe: usize = p.k_ksk;
+        let rank_in: usize = p.rank_in;
+        let rank_out: usize = p.rank_out;
+        let digits: usize = p.digits;
+
+        let rows: usize = p.k_ct_in.div_ceil(p.basek * digits);
+        let sigma: f64 = 3.2;
+
+        let mut ksk: GGLWEAutomorphismKey<Vec<u8>> = GGLWEAutomorphismKey::alloc(n, basek, k_grlwe, rows, digits, rank_out);
+        let mut ct_in: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_rlwe_in, rank_in);
+        let mut ct_out: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_rlwe_out, rank_out);
+
+        let mut scratch: ScratchOwned<FFT64> = ScratchOwned::alloc(
+            GGLWESwitchingKey::encrypt_sk_scratch_space(&module, n, basek, ksk.k(), rank_in, rank_out)
+                | GLWECiphertext::encrypt_sk_scratch_space(&module, n, basek, ct_in.k())
+                | GLWECiphertext::keyswitch_scratch_space(
+                    &module,
+                    n,
+                    basek,
+                    ct_out.k(),
+                    ct_in.k(),
+                    ksk.k(),
+                    digits,
+                    rank_in,
+                    rank_out,
+                ),
+        );
+
+        let mut source_xs = Source::new([0u8; 32]);
+        let mut source_xe = Source::new([0u8; 32]);
+        let mut source_xa = Source::new([0u8; 32]);
+
+        let mut sk_in: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_in);
+        sk_in.fill_ternary_prob(0.5, &mut source_xs);
+        let sk_in_dft: GLWESecretPrepared<Vec<u8>, FFT64> = sk_in.prepare_alloc(&module, scratch.borrow());
+
+        let mut sk_out: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank_out);
+        sk_out.fill_ternary_prob(0.5, &mut source_xs);
+
+        ksk.encrypt_sk(
+            &module,
+            -1,
+            &sk_in,
+            &mut source_xa,
+            &mut source_xe,
+            sigma,
+            scratch.borrow(),
+        );
+
+        ct_in.encrypt_zero_sk(
+            &module,
+            &sk_in_dft,
+            &mut source_xa,
+            &mut source_xe,
+            sigma,
+            scratch.borrow(),
+        );
+
+        let ksk_prepared: GGLWEAutomorphismKeyPrepared<Vec<u8>, _> = ksk.prepare_alloc(&module, scratch.borrow());
+
+        move || {
+            ct_out.automorphism(&module, &ct_in, &ksk_prepared, scratch.borrow());
+            black_box(());
+        }
+    }
+
+    let digits: usize = 1;
+    let basek: usize = 19;
+
+    let params_set: Vec<Params> = vec![Params {
+        log_n: 15,
+        basek,
+        k_ct_in: 874 - digits * basek,
+        k_ct_out: 874 - digits * basek,
+        k_ksk: 874,
+        digits,
+        rank_in: 1,
+        rank_out: 1,
+    }];
+
+    for params in params_set {
+        let id = BenchmarkId::new("KEYSWITCH_GLWE_FFT64", "");
+        let mut runner = runner(params);
+        group.sample_size(500);
+        group.measurement_time(Duration::from_secs(40));
+        group.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
+    }
+
+    group.finish();
+}
+
+fn bench_keyswitch_glwe_inplace_fft64(c: &mut Criterion) {
+    let mut group = c.benchmark_group("keyswitch_glwe_inplace_fft64");
+
+    struct Params {
+        log_n: usize,
+        basek: usize,
+        k_ct: usize,
+        k_ksk: usize,
+        rank: usize,
+    }
+
+    fn runner(p: Params) -> impl FnMut() {
+        let module: Module<FFT64> = Module::<FFT64>::new(1 << p.log_n);
+
+        let n = module.n();
+        let basek: usize = p.basek;
+        let k_ct: usize = p.k_ct;
+        let k_ksk: usize = p.k_ksk;
+        let rank: usize = p.rank;
+        let digits: usize = 1;
+
+        let rows: usize = p.k_ct.div_ceil(p.basek);
+        let sigma: f64 = 3.2;
+
+        let mut ksk: GGLWESwitchingKey<Vec<u8>> = GGLWESwitchingKey::alloc(n, basek, k_ksk, rows, digits, rank, rank);
+        let mut ct: GLWECiphertext<Vec<u8>> = GLWECiphertext::alloc(n, basek, k_ct, rank);
+
+        let mut scratch: ScratchOwned<FFT64> = ScratchOwned::alloc(
+            GGLWESwitchingKey::encrypt_sk_scratch_space(&module, n, basek, ksk.k(), rank, rank)
+                | GLWECiphertext::encrypt_sk_scratch_space(&module, n, basek, ct.k())
+                | GLWECiphertext::keyswitch_inplace_scratch_space(&module, n, basek, ct.k(), ksk.k(), digits, rank),
+        );
+
+        let mut source_xs: Source = Source::new([0u8; 32]);
+        let mut source_xe: Source = Source::new([0u8; 32]);
+        let mut source_xa: Source = Source::new([0u8; 32]);
+
+        let mut sk_in: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+        sk_in.fill_ternary_prob(0.5, &mut source_xs);
+        let sk_in_dft: GLWESecretPrepared<Vec<u8>, FFT64> = sk_in.prepare_alloc(&module, scratch.borrow());
+
+        let mut sk_out: GLWESecret<Vec<u8>> = GLWESecret::alloc(n, rank);
+        sk_out.fill_ternary_prob(0.5, &mut source_xs);
+
+        ksk.encrypt_sk(
+            &module,
+            &sk_in,
+            &sk_out,
+            &mut source_xa,
+            &mut source_xe,
+            sigma,
+            scratch.borrow(),
+        );
+
+        ct.encrypt_zero_sk(
+            &module,
+            &sk_in_dft,
+            &mut source_xa,
+            &mut source_xe,
+            sigma,
+            scratch.borrow(),
+        );
+
+        let ksk_prepared: GGLWESwitchingKeyPrepared<Vec<u8>, FFT64> = ksk.prepare_alloc(&module, scratch.borrow());
+
+        move || {
+            ct.keyswitch_inplace(&module, &ksk_prepared, scratch.borrow());
+            black_box(());
+        }
+    }
+
+    let params_set: Vec<Params> = vec![Params {
+        log_n: 9,
+        basek: 18,
+        k_ct: 27,
+        k_ksk: 27,
+        rank: 1,
+    }];
+
+    for params in params_set {
+        let id = BenchmarkId::new("KEYSWITCH_GLWE_INPLACE_FFT64", "");
+        let mut runner = runner(params);
+        group.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
+    }
+
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    bench_keyswitch_glwe_fft64,
+    bench_keyswitch_glwe_inplace_fft64
+);
+criterion_main!(benches);