From 27a5395ce28a0bc4f727ea9ac174b0cfb3b97897 Mon Sep 17 00:00:00 2001 From: Jean-Philippe Bossuat Date: Wed, 21 May 2025 16:54:29 +0200 Subject: [PATCH 01/10] Added trace operation + test and renamed base2k to backend --- .gitmodules | 4 +- .vscode/settings.json | 140 +++---- Cargo.lock | 26 +- Cargo.toml | 2 +- {base2k => backend}/.vscode/settings.json | 20 +- {base2k => backend}/Cargo.toml | 34 +- {base2k => backend}/README.md | 22 +- {base2k => backend}/benches/fft.rs | 112 +++--- {base2k => backend}/build.rs | 26 +- {base2k => backend}/examples/fft.rs | 112 +++--- {base2k => backend}/examples/rlwe_encrypt.rs | 24 +- {base2k => backend}/spqlios-arithmetic | 0 {base2k => backend}/src/encoding.rs | 150 ++++---- {base2k => backend}/src/ffi/cnv.rs | 14 +- {base2k => backend}/src/ffi/mod.rs | 16 +- {base2k => backend}/src/ffi/module.rs | 36 +- {base2k => backend}/src/ffi/reim.rs | 344 +++++++++--------- {base2k => backend}/src/ffi/svp.rs | 96 ++--- {base2k => backend}/src/ffi/vec_znx.rs | 202 +++++----- {base2k => backend}/src/ffi/vec_znx_big.rs | 322 ++++++++-------- {base2k => backend}/src/ffi/vec_znx_dft.rs | 172 ++++----- {base2k => backend}/src/ffi/vmp.rs | 330 ++++++++--------- {base2k => backend}/src/ffi/znx.rs | 152 ++++---- {base2k => backend}/src/lib.rs | 0 {base2k => backend}/src/mat_znx_dft.rs | 0 {base2k => backend}/src/mat_znx_dft_ops.rs | 19 +- {base2k => backend}/src/module.rs | 0 {base2k => backend}/src/sampling.rs | 112 +++--- {base2k => backend}/src/scalar_znx.rs | 0 {base2k => backend}/src/scalar_znx_dft.rs | 0 {base2k => backend}/src/scalar_znx_dft_ops.rs | 0 {base2k => backend}/src/stats.rs | 64 ++-- {base2k => backend}/src/vec_znx.rs | 54 ++- {base2k => backend}/src/vec_znx_big.rs | 0 {base2k => backend}/src/vec_znx_big_ops.rs | 8 +- {base2k => backend}/src/vec_znx_dft.rs | 0 {base2k => backend}/src/vec_znx_dft_ops.rs | 0 {base2k => backend}/src/vec_znx_ops.rs | 12 +- {base2k => backend}/src/znx_base.rs | 10 +- core/Cargo.toml | 4 +- core/benches/external_product_glwe_fft64.rs | 24 +- core/benches/keyswitch_glwe_fft64.rs | 28 +- core/src/automorphism.rs | 26 +- core/src/elem.rs | 2 +- core/src/gglwe_ciphertext.rs | 10 +- core/src/ggsw_ciphertext.rs | 4 +- core/src/glwe_ciphertext.rs | 90 ++++- core/src/glwe_ciphertext_fourier.rs | 4 +- core/src/glwe_plaintext.rs | 4 +- core/src/keys.rs | 14 +- core/src/keyswitch_key.rs | 16 +- core/src/lib.rs | 1 + core/src/tensor_key.rs | 6 +- core/src/test_fft64/automorphism_key.rs | 48 +-- core/src/test_fft64/gglwe.rs | 92 ++--- core/src/test_fft64/ggsw.rs | 128 +++---- core/src/test_fft64/glwe.rs | 122 +++---- core/src/test_fft64/glwe_fourier.rs | 74 ++-- core/src/test_fft64/mod.rs | 2 + core/src/test_fft64/tensor_key.rs | 14 +- core/src/test_fft64/trace.rs | 116 ++++++ core/src/trace.rs | 82 +++++ 62 files changed, 1926 insertions(+), 1620 deletions(-) rename {base2k => backend}/.vscode/settings.json (95%) rename {base2k => backend}/Cargo.toml (90%) rename {base2k => backend}/README.md (89%) rename {base2k => backend}/benches/fft.rs (96%) rename {base2k => backend}/build.rs (96%) rename {base2k => backend}/examples/fft.rs (95%) rename {base2k => backend}/examples/rlwe_encrypt.rs (85%) rename {base2k => backend}/spqlios-arithmetic (100%) rename {base2k => backend}/src/encoding.rs (59%) rename {base2k => backend}/src/ffi/cnv.rs (95%) rename {base2k => backend}/src/ffi/mod.rs (94%) rename {base2k => backend}/src/ffi/module.rs (96%) rename {base2k => backend}/src/ffi/reim.rs (97%) rename {base2k => backend}/src/ffi/svp.rs (95%) rename {base2k => backend}/src/ffi/vec_znx.rs (94%) rename {base2k => backend}/src/ffi/vec_znx_big.rs (95%) rename {base2k => backend}/src/ffi/vec_znx_dft.rs (96%) rename {base2k => backend}/src/ffi/vmp.rs (95%) rename {base2k => backend}/src/ffi/znx.rs (97%) rename {base2k => backend}/src/lib.rs (100%) rename {base2k => backend}/src/mat_znx_dft.rs (100%) rename {base2k => backend}/src/mat_znx_dft_ops.rs (97%) rename {base2k => backend}/src/module.rs (100%) rename {base2k => backend}/src/sampling.rs (73%) rename {base2k => backend}/src/scalar_znx.rs (100%) rename {base2k => backend}/src/scalar_znx_dft.rs (100%) rename {base2k => backend}/src/scalar_znx_dft_ops.rs (100%) rename {base2k => backend}/src/stats.rs (80%) rename {base2k => backend}/src/vec_znx.rs (83%) rename {base2k => backend}/src/vec_znx_big.rs (100%) rename {base2k => backend}/src/vec_znx_big_ops.rs (99%) rename {base2k => backend}/src/vec_znx_dft.rs (100%) rename {base2k => backend}/src/vec_znx_dft_ops.rs (100%) rename {base2k => backend}/src/vec_znx_ops.rs (97%) rename {base2k => backend}/src/znx_base.rs (95%) create mode 100644 core/src/test_fft64/trace.rs create mode 100644 core/src/trace.rs diff --git a/.gitmodules b/.gitmodules index 0fa69b7..a7f9b93 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +1,3 @@ -[submodule "base2k/spqlios-arithmetic"] - path = base2k/spqlios-arithmetic +[submodule "backend/spqlios-arithmetic"] + path = backend/spqlios-arithmetic url = https://github.com/phantomzone-org/spqlios-arithmetic diff --git a/.vscode/settings.json b/.vscode/settings.json index d32c5df..5ce22a6 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -1,71 +1,71 @@ -{ - "cmake.sourceDirectory": "C:/Users/boss_/go/src/github.com/gausslabs/fhe/base2k/spqlios-arithmetic", - "files.associations": { - "vector": "cpp", - "xstring": "cpp", - "xutility": "cpp", - "algorithm": "cpp", - "atomic": "cpp", - "bit": "cpp", - "cctype": "cpp", - "charconv": "cpp", - "cinttypes": "cpp", - "clocale": "cpp", - "cmath": "cpp", - "compare": "cpp", - "complex": "cpp", - "concepts": "cpp", - "cstddef": "cpp", - "cstdint": "cpp", - "cstdio": "cpp", - "cstdlib": "cpp", - "cstring": "cpp", - "ctime": "cpp", - "cwchar": "cpp", - "exception": "cpp", - "format": "cpp", - "initializer_list": "cpp", - "ios": "cpp", - "iosfwd": "cpp", - "iostream": "cpp", - "istream": "cpp", - "iterator": "cpp", - "limits": "cpp", - "locale": "cpp", - "memory": "cpp", - "new": "cpp", - "optional": "cpp", - "ostream": "cpp", - "random": "cpp", - "sstream": "cpp", - "stdexcept": "cpp", - "streambuf": "cpp", - "string": "cpp", - "system_error": "cpp", - "tuple": "cpp", - "type_traits": "cpp", - "typeinfo": "cpp", - "utility": "cpp", - "xfacet": "cpp", - "xiosbase": "cpp", - "xlocale": "cpp", - "xlocbuf": "cpp", - "xlocinfo": "cpp", - "xlocmes": "cpp", - "xlocmon": "cpp", - "xlocnum": "cpp", - "xloctime": "cpp", - "xmemory": "cpp", - "xtr1common": "cpp", - "vec_znx_arithmetic_private.h": "c", - "reim4_arithmetic.h": "c", - "array": "c", - "string_view": "c" - }, - "github.copilot.enable": { - "*": false, - "plaintext": false, - "markdown": false, - "scminput": false - } +{ + "cmake.sourceDirectory": "C:/Users/boss_/go/src/github.com/gausslabs/poulpy/backend/spqlios-arithmetic", + "files.associations": { + "vector": "cpp", + "xstring": "cpp", + "xutility": "cpp", + "algorithm": "cpp", + "atomic": "cpp", + "bit": "cpp", + "cctype": "cpp", + "charconv": "cpp", + "cinttypes": "cpp", + "clocale": "cpp", + "cmath": "cpp", + "compare": "cpp", + "complex": "cpp", + "concepts": "cpp", + "cstddef": "cpp", + "cstdint": "cpp", + "cstdio": "cpp", + "cstdlib": "cpp", + "cstring": "cpp", + "ctime": "cpp", + "cwchar": "cpp", + "exception": "cpp", + "format": "cpp", + "initializer_list": "cpp", + "ios": "cpp", + "iosfwd": "cpp", + "iostream": "cpp", + "istream": "cpp", + "iterator": "cpp", + "limits": "cpp", + "locale": "cpp", + "memory": "cpp", + "new": "cpp", + "optional": "cpp", + "ostream": "cpp", + "random": "cpp", + "sstream": "cpp", + "stdexcept": "cpp", + "streambuf": "cpp", + "string": "cpp", + "system_error": "cpp", + "tuple": "cpp", + "type_traits": "cpp", + "typeinfo": "cpp", + "utility": "cpp", + "xfacet": "cpp", + "xiosbase": "cpp", + "xlocale": "cpp", + "xlocbuf": "cpp", + "xlocinfo": "cpp", + "xlocmes": "cpp", + "xlocmon": "cpp", + "xlocnum": "cpp", + "xloctime": "cpp", + "xmemory": "cpp", + "xtr1common": "cpp", + "vec_znx_arithmetic_private.h": "c", + "reim4_arithmetic.h": "c", + "array": "c", + "string_view": "c" + }, + "github.copilot.enable": { + "*": false, + "plaintext": false, + "markdown": false, + "scminput": false + } } \ No newline at end of file diff --git a/Cargo.lock b/Cargo.lock index b9225bf..1b4ded4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -36,7 +36,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7b7e4c2464d97fe331d41de9d5db0def0a96f4d823b8b32a2efd503578988973" [[package]] -name = "base2k" +name = "backend" version = "0.1.0" dependencies = [ "criterion", @@ -131,6 +131,18 @@ version = "0.7.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f46ad14479a25103f283c0f10005961cf086d8dc42205bb44c46ac563475dca6" +[[package]] +name = "core" +version = "0.1.0" +dependencies = [ + "backend", + "criterion", + "itertools 0.14.0", + "rand_distr", + "rug", + "sampling", +] + [[package]] name = "criterion" version = "0.5.1" @@ -488,18 +500,6 @@ version = "0.8.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c" -[[package]] -name = "rlwe" -version = "0.1.0" -dependencies = [ - "base2k", - "criterion", - "itertools 0.14.0", - "rand_distr", - "rug", - "sampling", -] - [[package]] name = "rug" version = "1.27.0" diff --git a/Cargo.toml b/Cargo.toml index 6f2a91e..dd3a518 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,5 +1,5 @@ [workspace] -members = ["base2k", "core", "sampling", "utils"] +members = ["backend", "core", "sampling", "utils"] resolver = "3" [workspace.dependencies] diff --git a/base2k/.vscode/settings.json b/backend/.vscode/settings.json similarity index 95% rename from base2k/.vscode/settings.json rename to backend/.vscode/settings.json index c38916e..cfbd8eb 100644 --- a/base2k/.vscode/settings.json +++ b/backend/.vscode/settings.json @@ -1,11 +1,11 @@ -{ - "github.copilot.enable": { - "*": false, - "plaintext": false, - "markdown": false, - "scminput": false - }, - "files.associations": { - "random": "c" - } +{ + "github.copilot.enable": { + "*": false, + "plaintext": false, + "markdown": false, + "scminput": false + }, + "files.associations": { + "random": "c" + } } \ No newline at end of file diff --git a/base2k/Cargo.toml b/backend/Cargo.toml similarity index 90% rename from base2k/Cargo.toml rename to backend/Cargo.toml index 089cbde..d0ca857 100644 --- a/base2k/Cargo.toml +++ b/backend/Cargo.toml @@ -1,18 +1,18 @@ -[package] -name = "base2k" -version = "0.1.0" -edition = "2024" - -[dependencies] -rug = {workspace = true} -criterion = {workspace = true} -itertools = {workspace = true} -rand = {workspace = true} -rand_distr = {workspace = true} -rand_core = {workspace = true} -sampling = { path = "../sampling" } -utils = { path = "../utils" } - -[[bench]] -name = "fft" +[package] +name = "backend" +version = "0.1.0" +edition = "2024" + +[dependencies] +rug = {workspace = true} +criterion = {workspace = true} +itertools = {workspace = true} +rand = {workspace = true} +rand_distr = {workspace = true} +rand_core = {workspace = true} +sampling = { path = "../sampling" } +utils = { path = "../utils" } + +[[bench]] +name = "fft" harness = false \ No newline at end of file diff --git a/base2k/README.md b/backend/README.md similarity index 89% rename from base2k/README.md rename to backend/README.md index 08a49e9..86c8c65 100644 --- a/base2k/README.md +++ b/backend/README.md @@ -1,12 +1,12 @@ - -## WSL/Ubuntu -To use this crate you need to build spqlios-arithmetic, which is provided a as a git submodule: -1) Initialize the sub-module -2) $ cd base2k/spqlios-arithmetic -3) mdkir build -4) cd build -5) cmake .. -6) make - -## Others + +## WSL/Ubuntu +To use this crate you need to build spqlios-arithmetic, which is provided a as a git submodule: +1) Initialize the sub-module +2) $ cd backend/spqlios-arithmetic +3) mdkir build +4) cd build +5) cmake .. +6) make + +## Others Steps 3 to 6 might change depending of your platform. See [spqlios-arithmetic/wiki/build](https://github.com/tfhe/spqlios-arithmetic/wiki/build) for additional information and build options. \ No newline at end of file diff --git a/base2k/benches/fft.rs b/backend/benches/fft.rs similarity index 96% rename from base2k/benches/fft.rs rename to backend/benches/fft.rs index a02dc4c..8106a2d 100644 --- a/base2k/benches/fft.rs +++ b/backend/benches/fft.rs @@ -1,56 +1,56 @@ -use base2k::ffi::reim::*; -use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main}; -use std::ffi::c_void; - -fn fft(c: &mut Criterion) { - fn forward<'a>(m: u32, log_bound: u32, reim_fft_precomp: *mut reim_fft_precomp, a: &'a [i64]) -> Box { - unsafe { - let buf_a: *mut f64 = reim_fft_precomp_get_buffer(reim_fft_precomp, 0); - reim_from_znx64_simple(m as u32, log_bound as u32, buf_a as *mut c_void, a.as_ptr()); - Box::new(move || reim_fft(reim_fft_precomp, buf_a)) - } - } - - fn backward<'a>(m: u32, log_bound: u32, reim_ifft_precomp: *mut reim_ifft_precomp, a: &'a [i64]) -> Box { - Box::new(move || unsafe { - let buf_a: *mut f64 = reim_ifft_precomp_get_buffer(reim_ifft_precomp, 0); - reim_from_znx64_simple(m as u32, log_bound as u32, buf_a as *mut c_void, a.as_ptr()); - reim_ifft(reim_ifft_precomp, buf_a); - }) - } - - let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = c.benchmark_group("fft"); - - for log_n in 10..17 { - let n: usize = 1 << log_n; - let m: usize = n >> 1; - let log_bound: u32 = 19; - - let mut a: Vec = vec![i64::default(); n]; - a.iter_mut().enumerate().for_each(|(i, x)| *x = i as i64); - - unsafe { - let reim_fft_precomp: *mut reim_fft_precomp = new_reim_fft_precomp(m as u32, 1); - let reim_ifft_precomp: *mut reim_ifft_precomp = new_reim_ifft_precomp(m as u32, 1); - - let runners: [(String, Box); 2] = [ - (format!("forward"), { - forward(m as u32, log_bound, reim_fft_precomp, &a) - }), - (format!("backward"), { - backward(m as u32, log_bound, reim_ifft_precomp, &a) - }), - ]; - - for (name, mut runner) in runners { - 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, fft,); -criterion_main!(benches); +use backend::ffi::reim::*; +use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main}; +use std::ffi::c_void; + +fn fft(c: &mut Criterion) { + fn forward<'a>(m: u32, log_bound: u32, reim_fft_precomp: *mut reim_fft_precomp, a: &'a [i64]) -> Box { + unsafe { + let buf_a: *mut f64 = reim_fft_precomp_get_buffer(reim_fft_precomp, 0); + reim_from_znx64_simple(m as u32, log_bound as u32, buf_a as *mut c_void, a.as_ptr()); + Box::new(move || reim_fft(reim_fft_precomp, buf_a)) + } + } + + fn backward<'a>(m: u32, log_bound: u32, reim_ifft_precomp: *mut reim_ifft_precomp, a: &'a [i64]) -> Box { + Box::new(move || unsafe { + let buf_a: *mut f64 = reim_ifft_precomp_get_buffer(reim_ifft_precomp, 0); + reim_from_znx64_simple(m as u32, log_bound as u32, buf_a as *mut c_void, a.as_ptr()); + reim_ifft(reim_ifft_precomp, buf_a); + }) + } + + let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = c.benchmark_group("fft"); + + for log_n in 10..17 { + let n: usize = 1 << log_n; + let m: usize = n >> 1; + let log_bound: u32 = 19; + + let mut a: Vec = vec![i64::default(); n]; + a.iter_mut().enumerate().for_each(|(i, x)| *x = i as i64); + + unsafe { + let reim_fft_precomp: *mut reim_fft_precomp = new_reim_fft_precomp(m as u32, 1); + let reim_ifft_precomp: *mut reim_ifft_precomp = new_reim_ifft_precomp(m as u32, 1); + + let runners: [(String, Box); 2] = [ + (format!("forward"), { + forward(m as u32, log_bound, reim_fft_precomp, &a) + }), + (format!("backward"), { + backward(m as u32, log_bound, reim_ifft_precomp, &a) + }), + ]; + + for (name, mut runner) in runners { + 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, fft,); +criterion_main!(benches); diff --git a/base2k/build.rs b/backend/build.rs similarity index 96% rename from base2k/build.rs rename to backend/build.rs index f592b15..93e4098 100644 --- a/base2k/build.rs +++ b/backend/build.rs @@ -1,13 +1,13 @@ -use std::path::absolute; - -fn main() { - println!( - "cargo:rustc-link-search=native={}", - absolute("spqlios-arithmetic/build/spqlios") - .unwrap() - .to_str() - .unwrap() - ); - println!("cargo:rustc-link-lib=static=spqlios"); - // println!("cargo:rustc-link-lib=dylib=spqlios") -} +use std::path::absolute; + +fn main() { + println!( + "cargo:rustc-link-search=native={}", + absolute("spqlios-arithmetic/build/spqlios") + .unwrap() + .to_str() + .unwrap() + ); + println!("cargo:rustc-link-lib=static=spqlios"); + // println!("cargo:rustc-link-lib=dylib=spqlios") +} diff --git a/base2k/examples/fft.rs b/backend/examples/fft.rs similarity index 95% rename from base2k/examples/fft.rs rename to backend/examples/fft.rs index 181d066..63e243c 100644 --- a/base2k/examples/fft.rs +++ b/backend/examples/fft.rs @@ -1,56 +1,56 @@ -use base2k::ffi::reim::*; -use std::ffi::c_void; -use std::time::Instant; - -fn main() { - let log_bound: usize = 19; - - let n: usize = 2048; - let m: usize = n >> 1; - - let mut a: Vec = vec![i64::default(); n]; - let mut b: Vec = vec![i64::default(); n]; - let mut c: Vec = vec![i64::default(); n]; - - a.iter_mut().enumerate().for_each(|(i, x)| *x = i as i64); - b[1] = 1; - - println!("{:?}", b); - - unsafe { - let reim_fft_precomp = new_reim_fft_precomp(m as u32, 2); - let reim_ifft_precomp = new_reim_ifft_precomp(m as u32, 1); - - let buf_a = reim_fft_precomp_get_buffer(reim_fft_precomp, 0); - let buf_b = reim_fft_precomp_get_buffer(reim_fft_precomp, 1); - let buf_c = reim_ifft_precomp_get_buffer(reim_ifft_precomp, 0); - - let now = Instant::now(); - (0..1024).for_each(|_| { - reim_from_znx64_simple(m as u32, log_bound as u32, buf_a as *mut c_void, a.as_ptr()); - reim_fft(reim_fft_precomp, buf_a); - - reim_from_znx64_simple(m as u32, log_bound as u32, buf_b as *mut c_void, b.as_ptr()); - reim_fft(reim_fft_precomp, buf_b); - - reim_fftvec_mul_simple( - m as u32, - buf_c as *mut c_void, - buf_a as *mut c_void, - buf_b as *mut c_void, - ); - reim_ifft(reim_ifft_precomp, buf_c); - - reim_to_znx64_simple( - m as u32, - m as f64, - log_bound as u32, - c.as_mut_ptr(), - buf_c as *mut c_void, - ) - }); - - println!("time: {}us", now.elapsed().as_micros()); - println!("{:?}", &c[..16]); - } -} +use backend::ffi::reim::*; +use std::ffi::c_void; +use std::time::Instant; + +fn main() { + let log_bound: usize = 19; + + let n: usize = 2048; + let m: usize = n >> 1; + + let mut a: Vec = vec![i64::default(); n]; + let mut b: Vec = vec![i64::default(); n]; + let mut c: Vec = vec![i64::default(); n]; + + a.iter_mut().enumerate().for_each(|(i, x)| *x = i as i64); + b[1] = 1; + + println!("{:?}", b); + + unsafe { + let reim_fft_precomp = new_reim_fft_precomp(m as u32, 2); + let reim_ifft_precomp = new_reim_ifft_precomp(m as u32, 1); + + let buf_a = reim_fft_precomp_get_buffer(reim_fft_precomp, 0); + let buf_b = reim_fft_precomp_get_buffer(reim_fft_precomp, 1); + let buf_c = reim_ifft_precomp_get_buffer(reim_ifft_precomp, 0); + + let now = Instant::now(); + (0..1024).for_each(|_| { + reim_from_znx64_simple(m as u32, log_bound as u32, buf_a as *mut c_void, a.as_ptr()); + reim_fft(reim_fft_precomp, buf_a); + + reim_from_znx64_simple(m as u32, log_bound as u32, buf_b as *mut c_void, b.as_ptr()); + reim_fft(reim_fft_precomp, buf_b); + + reim_fftvec_mul_simple( + m as u32, + buf_c as *mut c_void, + buf_a as *mut c_void, + buf_b as *mut c_void, + ); + reim_ifft(reim_ifft_precomp, buf_c); + + reim_to_znx64_simple( + m as u32, + m as f64, + log_bound as u32, + c.as_mut_ptr(), + buf_c as *mut c_void, + ) + }); + + println!("time: {}us", now.elapsed().as_micros()); + println!("{:?}", &c[..16]); + } +} diff --git a/base2k/examples/rlwe_encrypt.rs b/backend/examples/rlwe_encrypt.rs similarity index 85% rename from base2k/examples/rlwe_encrypt.rs rename to backend/examples/rlwe_encrypt.rs index e73db89..a16437f 100644 --- a/base2k/examples/rlwe_encrypt.rs +++ b/backend/examples/rlwe_encrypt.rs @@ -1,4 +1,4 @@ -use base2k::{ +use backend::{ AddNormal, Decoding, Encoding, FFT64, FillUniform, Module, ScalarZnx, ScalarZnxAlloc, ScalarZnxDft, ScalarZnxDftAlloc, ScalarZnxDftOps, ScratchOwned, VecZnx, VecZnxAlloc, VecZnxBig, VecZnxBigAlloc, VecZnxBigOps, VecZnxBigScratch, VecZnxDft, VecZnxDftAlloc, VecZnxDftOps, VecZnxOps, ZnxInfos, @@ -8,10 +8,10 @@ use sampling::source::Source; fn main() { let n: usize = 16; - let log_base2k: usize = 18; + let basek: usize = 18; let ct_size: usize = 3; let msg_size: usize = 2; - let log_scale: usize = msg_size * log_base2k - 5; + let log_scale: usize = msg_size * basek - 5; let module: Module = Module::::new(n); let mut scratch: ScratchOwned = ScratchOwned::new(module.vec_znx_big_normalize_tmp_bytes()); @@ -36,7 +36,7 @@ fn main() { ); // Fill the second column with random values: ct = (0, a) - ct.fill_uniform(log_base2k, 1, ct_size, &mut source); + ct.fill_uniform(basek, 1, ct_size, &mut source); let mut buf_dft: VecZnxDft, FFT64> = module.new_vec_znx_dft(1, ct_size); @@ -64,8 +64,8 @@ fn main() { let mut want: Vec = vec![0; n]; want.iter_mut() .for_each(|x| *x = source.next_u64n(16, 15) as i64); - m.encode_vec_i64(0, log_base2k, log_scale, &want, 4); - module.vec_znx_normalize_inplace(log_base2k, &mut m, 0, scratch.borrow()); + m.encode_vec_i64(0, basek, log_scale, &want, 4); + module.vec_znx_normalize_inplace(basek, &mut m, 0, scratch.borrow()); // m - BIG(ct[1] * s) module.vec_znx_big_sub_small_b_inplace( @@ -78,7 +78,7 @@ fn main() { // Normalizes back to VecZnx // ct[0] <- m - BIG(c1 * s) module.vec_znx_big_normalize( - log_base2k, + basek, &mut ct, 0, // Selects the first column of ct (ct[0]) &buf_big, @@ -89,9 +89,9 @@ fn main() { // Add noise to ct[0] // ct[0] <- ct[0] + e ct.add_normal( - log_base2k, + basek, 0, // Selects the first column of ct (ct[0]) - log_base2k * ct_size, // Scaling of the noise: 2^{-log_base2k * limbs} + basek * ct_size, // Scaling of the noise: 2^{-basek * limbs} &mut source, 3.2, // Standard deviation 19.0, // Truncatation bound @@ -118,13 +118,13 @@ fn main() { // m + e <- BIG(ct[1] * s + ct[0]) let mut res = module.new_vec_znx(1, ct_size); - module.vec_znx_big_normalize(log_base2k, &mut res, 0, &buf_big, 0, scratch.borrow()); + module.vec_znx_big_normalize(basek, &mut res, 0, &buf_big, 0, scratch.borrow()); // have = m * 2^{log_scale} + e let mut have: Vec = vec![i64::default(); n]; - res.decode_vec_i64(0, log_base2k, res.size() * log_base2k, &mut have); + res.decode_vec_i64(0, basek, res.size() * basek, &mut have); - let scale: f64 = (1 << (res.size() * log_base2k - log_scale)) as f64; + let scale: f64 = (1 << (res.size() * basek - log_scale)) as f64; izip!(want.iter(), have.iter()) .enumerate() .for_each(|(i, (a, b))| { diff --git a/base2k/spqlios-arithmetic b/backend/spqlios-arithmetic similarity index 100% rename from base2k/spqlios-arithmetic rename to backend/spqlios-arithmetic diff --git a/base2k/src/encoding.rs b/backend/src/encoding.rs similarity index 59% rename from base2k/src/encoding.rs rename to backend/src/encoding.rs index 45214c6..dc423f9 100644 --- a/base2k/src/encoding.rs +++ b/backend/src/encoding.rs @@ -11,23 +11,23 @@ pub trait Encoding { /// # Arguments /// /// * `col_i`: the index of the poly where to encode the data. - /// * `log_base2k`: base two negative logarithm decomposition of the receiver. - /// * `log_k`: base two negative logarithm of the scaling of the data. + /// * `basek`: base two negative logarithm decomposition of the receiver. + /// * `k`: base two negative logarithm of the scaling of the data. /// * `data`: data to encode on the receiver. /// * `log_max`: base two logarithm of the infinity norm of the input data. - fn encode_vec_i64(&mut self, col_i: usize, log_base2k: usize, log_k: usize, data: &[i64], log_max: usize); + fn encode_vec_i64(&mut self, col_i: usize, basek: usize, k: usize, data: &[i64], log_max: usize); /// encodes a single i64 on the receiver at the given index. /// /// # Arguments /// /// * `col_i`: the index of the poly where to encode the data. - /// * `log_base2k`: base two negative logarithm decomposition of the receiver. - /// * `log_k`: base two negative logarithm of the scaling of the data. + /// * `basek`: base two negative logarithm decomposition of the receiver. + /// * `k`: base two negative logarithm of the scaling of the data. /// * `i`: index of the coefficient on which to encode the data. /// * `data`: data to encode on the receiver. /// * `log_max`: base two logarithm of the infinity norm of the input data. - fn encode_coeff_i64(&mut self, col_i: usize, log_base2k: usize, log_k: usize, i: usize, data: i64, log_max: usize); + fn encode_coeff_i64(&mut self, col_i: usize, basek: usize, k: usize, i: usize, data: i64, log_max: usize); } pub trait Decoding { @@ -36,70 +36,70 @@ pub trait Decoding { /// # Arguments /// /// * `col_i`: the index of the poly where to encode the data. - /// * `log_base2k`: base two negative logarithm decomposition of the receiver. - /// * `log_k`: base two logarithm of the scaling of the data. + /// * `basek`: base two negative logarithm decomposition of the receiver. + /// * `k`: base two logarithm of the scaling of the data. /// * `data`: data to decode from the receiver. - fn decode_vec_i64(&self, col_i: usize, log_base2k: usize, log_k: usize, data: &mut [i64]); + fn decode_vec_i64(&self, col_i: usize, basek: usize, k: usize, data: &mut [i64]); /// decode a vector of Float from the receiver. /// /// # Arguments /// * `col_i`: the index of the poly where to encode the data. - /// * `log_base2k`: base two negative logarithm decomposition of the receiver. + /// * `basek`: base two negative logarithm decomposition of the receiver. /// * `data`: data to decode from the receiver. - fn decode_vec_float(&self, col_i: usize, log_base2k: usize, data: &mut [Float]); + fn decode_vec_float(&self, col_i: usize, basek: usize, data: &mut [Float]); /// decode a single of i64 from the receiver at the given index. /// /// # Arguments /// /// * `col_i`: the index of the poly where to encode the data. - /// * `log_base2k`: base two negative logarithm decomposition of the receiver. - /// * `log_k`: base two negative logarithm of the scaling of the data. + /// * `basek`: base two negative logarithm decomposition of the receiver. + /// * `k`: base two negative logarithm of the scaling of the data. /// * `i`: index of the coefficient to decode. /// * `data`: data to decode from the receiver. - fn decode_coeff_i64(&self, col_i: usize, log_base2k: usize, log_k: usize, i: usize) -> i64; + fn decode_coeff_i64(&self, col_i: usize, basek: usize, k: usize, i: usize) -> i64; } impl + AsRef<[u8]>> Encoding for VecZnx { - fn encode_vec_i64(&mut self, col_i: usize, log_base2k: usize, log_k: usize, data: &[i64], log_max: usize) { - encode_vec_i64(self, col_i, log_base2k, log_k, data, log_max) + fn encode_vec_i64(&mut self, col_i: usize, basek: usize, k: usize, data: &[i64], log_max: usize) { + encode_vec_i64(self, col_i, basek, k, data, log_max) } - fn encode_coeff_i64(&mut self, col_i: usize, log_base2k: usize, log_k: usize, i: usize, value: i64, log_max: usize) { - encode_coeff_i64(self, col_i, log_base2k, log_k, i, value, log_max) + fn encode_coeff_i64(&mut self, col_i: usize, basek: usize, k: usize, i: usize, value: i64, log_max: usize) { + encode_coeff_i64(self, col_i, basek, k, i, value, log_max) } } impl> Decoding for VecZnx { - fn decode_vec_i64(&self, col_i: usize, log_base2k: usize, log_k: usize, data: &mut [i64]) { - decode_vec_i64(self, col_i, log_base2k, log_k, data) + fn decode_vec_i64(&self, col_i: usize, basek: usize, k: usize, data: &mut [i64]) { + decode_vec_i64(self, col_i, basek, k, data) } - fn decode_vec_float(&self, col_i: usize, log_base2k: usize, data: &mut [Float]) { - decode_vec_float(self, col_i, log_base2k, data) + fn decode_vec_float(&self, col_i: usize, basek: usize, data: &mut [Float]) { + decode_vec_float(self, col_i, basek, data) } - fn decode_coeff_i64(&self, col_i: usize, log_base2k: usize, log_k: usize, i: usize) -> i64 { - decode_coeff_i64(self, col_i, log_base2k, log_k, i) + fn decode_coeff_i64(&self, col_i: usize, basek: usize, k: usize, i: usize) -> i64 { + decode_coeff_i64(self, col_i, basek, k, i) } } fn encode_vec_i64 + AsRef<[u8]>>( a: &mut VecZnx, col_i: usize, - log_base2k: usize, - log_k: usize, + basek: usize, + k: usize, data: &[i64], log_max: usize, ) { - let size: usize = (log_k + log_base2k - 1) / log_base2k; + let size: usize = (k + basek - 1) / basek; #[cfg(debug_assertions)] { assert!( size <= a.size(), - "invalid argument log_k: (log_k + a.log_base2k - 1)/a.log_base2k={} > a.size()={}", + "invalid argument k: (k + a.basek - 1)/a.basek={} > a.size()={}", size, a.size() ); @@ -108,43 +108,43 @@ fn encode_vec_i64 + AsRef<[u8]>>( } let data_len: usize = data.len(); - let log_k_rem: usize = log_base2k - (log_k % log_base2k); + let k_rem: usize = basek - (k % basek); // Zeroes coefficients of the i-th column (0..a.size()).for_each(|i| unsafe { znx_zero_i64_ref(a.n() as u64, a.at_mut_ptr(col_i, i)); }); - // If 2^{log_base2k} * 2^{k_rem} < 2^{63}-1, then we can simply copy + // If 2^{basek} * 2^{k_rem} < 2^{63}-1, then we can simply copy // values on the last limb. // Else we decompose values base2k. - if log_max + log_k_rem < 63 || log_k_rem == log_base2k { + if log_max + k_rem < 63 || k_rem == basek { a.at_mut(col_i, size - 1)[..data_len].copy_from_slice(&data[..data_len]); } else { - let mask: i64 = (1 << log_base2k) - 1; - let steps: usize = min(size, (log_max + log_base2k - 1) / log_base2k); + let mask: i64 = (1 << basek) - 1; + let steps: usize = min(size, (log_max + basek - 1) / basek); (size - steps..size) .rev() .enumerate() .for_each(|(i, i_rev)| { - let shift: usize = i * log_base2k; + let shift: usize = i * basek; izip!(a.at_mut(col_i, i_rev).iter_mut(), data.iter()).for_each(|(y, x)| *y = (x >> shift) & mask); }) } // Case where self.prec % self.k != 0. - if log_k_rem != log_base2k { - let steps: usize = min(size, (log_max + log_base2k - 1) / log_base2k); + if k_rem != basek { + let steps: usize = min(size, (log_max + basek - 1) / basek); (size - steps..size).rev().for_each(|i| { a.at_mut(col_i, i)[..data_len] .iter_mut() - .for_each(|x| *x <<= log_k_rem); + .for_each(|x| *x <<= k_rem); }) } } -fn decode_vec_i64>(a: &VecZnx, col_i: usize, log_base2k: usize, log_k: usize, data: &mut [i64]) { - let size: usize = (log_k + log_base2k - 1) / log_base2k; +fn decode_vec_i64>(a: &VecZnx, col_i: usize, basek: usize, k: usize, data: &mut [i64]) { + let size: usize = (k + basek - 1) / basek; #[cfg(debug_assertions)] { assert!( @@ -156,22 +156,22 @@ fn decode_vec_i64>(a: &VecZnx, col_i: usize, log_base2k: usize assert!(col_i < a.cols()); } data.copy_from_slice(a.at(col_i, 0)); - let rem: usize = log_base2k - (log_k % log_base2k); + let rem: usize = basek - (k % basek); (1..size).for_each(|i| { - if i == size - 1 && rem != log_base2k { - let k_rem: usize = log_base2k - rem; + if i == size - 1 && rem != basek { + let k_rem: usize = basek - rem; izip!(a.at(col_i, i).iter(), data.iter_mut()).for_each(|(x, y)| { *y = (*y << k_rem) + (x >> rem); }); } else { izip!(a.at(col_i, i).iter(), data.iter_mut()).for_each(|(x, y)| { - *y = (*y << log_base2k) + x; + *y = (*y << basek) + x; }); } }) } -fn decode_vec_float>(a: &VecZnx, col_i: usize, log_base2k: usize, data: &mut [Float]) { +fn decode_vec_float>(a: &VecZnx, col_i: usize, basek: usize, data: &mut [Float]) { let size: usize = a.size(); #[cfg(debug_assertions)] { @@ -184,12 +184,12 @@ fn decode_vec_float>(a: &VecZnx, col_i: usize, log_base2k: usi assert!(col_i < a.cols()); } - let prec: u32 = (log_base2k * size) as u32; + let prec: u32 = (basek * size) as u32; - // 2^{log_base2k} - let base = Float::with_val(prec, (1 << log_base2k) as f64); + // 2^{basek} + let base = Float::with_val(prec, (1 << basek) as f64); - // y[i] = sum x[j][i] * 2^{-log_base2k*j} + // y[i] = sum x[j][i] * 2^{-basek*j} (0..size).for_each(|i| { if i == 0 { izip!(a.at(col_i, size - i - 1).iter(), data.iter_mut()).for_each(|(x, y)| { @@ -208,73 +208,73 @@ fn decode_vec_float>(a: &VecZnx, col_i: usize, log_base2k: usi fn encode_coeff_i64 + AsRef<[u8]>>( a: &mut VecZnx, col_i: usize, - log_base2k: usize, - log_k: usize, + basek: usize, + k: usize, i: usize, value: i64, log_max: usize, ) { - let size: usize = (log_k + log_base2k - 1) / log_base2k; + let size: usize = (k + basek - 1) / basek; #[cfg(debug_assertions)] { assert!(i < a.n()); assert!( size <= a.size(), - "invalid argument log_k: (log_k + a.log_base2k - 1)/a.log_base2k={} > a.size()={}", + "invalid argument k: (k + a.basek - 1)/a.basek={} > a.size()={}", size, a.size() ); assert!(col_i < a.cols()); } - let log_k_rem: usize = log_base2k - (log_k % log_base2k); + let k_rem: usize = basek - (k % basek); (0..a.size()).for_each(|j| a.at_mut(col_i, j)[i] = 0); - // If 2^{log_base2k} * 2^{log_k_rem} < 2^{63}-1, then we can simply copy + // If 2^{basek} * 2^{k_rem} < 2^{63}-1, then we can simply copy // values on the last limb. // Else we decompose values base2k. - if log_max + log_k_rem < 63 || log_k_rem == log_base2k { + if log_max + k_rem < 63 || k_rem == basek { a.at_mut(col_i, size - 1)[i] = value; } else { - let mask: i64 = (1 << log_base2k) - 1; - let steps: usize = min(size, (log_max + log_base2k - 1) / log_base2k); + let mask: i64 = (1 << basek) - 1; + let steps: usize = min(size, (log_max + basek - 1) / basek); (size - steps..size) .rev() .enumerate() .for_each(|(j, j_rev)| { - a.at_mut(col_i, j_rev)[i] = (value >> (j * log_base2k)) & mask; + a.at_mut(col_i, j_rev)[i] = (value >> (j * basek)) & mask; }) } // Case where prec % k != 0. - if log_k_rem != log_base2k { - let steps: usize = min(size, (log_max + log_base2k - 1) / log_base2k); + if k_rem != basek { + let steps: usize = min(size, (log_max + basek - 1) / basek); (size - steps..size).rev().for_each(|j| { - a.at_mut(col_i, j)[i] <<= log_k_rem; + a.at_mut(col_i, j)[i] <<= k_rem; }) } } -fn decode_coeff_i64>(a: &VecZnx, col_i: usize, log_base2k: usize, log_k: usize, i: usize) -> i64 { +fn decode_coeff_i64>(a: &VecZnx, col_i: usize, basek: usize, k: usize, i: usize) -> i64 { #[cfg(debug_assertions)] { assert!(i < a.n()); assert!(col_i < a.cols()) } - let cols: usize = (log_k + log_base2k - 1) / log_base2k; + let cols: usize = (k + basek - 1) / basek; let data: &[i64] = a.raw(); let mut res: i64 = data[i]; - let rem: usize = log_base2k - (log_k % log_base2k); + let rem: usize = basek - (k % basek); let slice_size: usize = a.n() * a.size(); (1..cols).for_each(|i| { let x = data[i * slice_size]; - if i == cols - 1 && rem != log_base2k { - let k_rem: usize = log_base2k - rem; + if i == cols - 1 && rem != basek { + let k_rem: usize = basek - rem; res = (res << k_rem) + (x >> rem); } else { - res = (res << log_base2k) + x; + res = (res << basek) + x; } }); res @@ -292,9 +292,9 @@ mod tests { fn test_set_get_i64_lo_norm() { let n: usize = 8; let module: Module = Module::::new(n); - let log_base2k: usize = 17; + let basek: usize = 17; let size: usize = 5; - let log_k: usize = size * log_base2k - 5; + let k: usize = size * basek - 5; let mut a: VecZnx<_> = module.new_vec_znx(2, size); let mut source: Source = Source::new([0u8; 32]); let raw: &mut [i64] = a.raw_mut(); @@ -303,9 +303,9 @@ mod tests { let mut have: Vec = vec![i64::default(); n]; have.iter_mut() .for_each(|x| *x = (source.next_i64() << 56) >> 56); - a.encode_vec_i64(col_i, log_base2k, log_k, &have, 10); + a.encode_vec_i64(col_i, basek, k, &have, 10); let mut want: Vec = vec![i64::default(); n]; - a.decode_vec_i64(col_i, log_base2k, log_k, &mut want); + a.decode_vec_i64(col_i, basek, k, &mut want); izip!(want, have).for_each(|(a, b)| assert_eq!(a, b, "{} != {}", a, b)); }); } @@ -314,9 +314,9 @@ mod tests { fn test_set_get_i64_hi_norm() { let n: usize = 8; let module: Module = Module::::new(n); - let log_base2k: usize = 17; + let basek: usize = 17; let size: usize = 5; - let log_k: usize = size * log_base2k - 5; + let k: usize = size * basek - 5; let mut a: VecZnx<_> = module.new_vec_znx(2, size); let mut source = Source::new([0u8; 32]); let raw: &mut [i64] = a.raw_mut(); @@ -324,9 +324,9 @@ mod tests { (0..a.cols()).for_each(|col_i| { let mut have: Vec = vec![i64::default(); n]; have.iter_mut().for_each(|x| *x = source.next_i64()); - a.encode_vec_i64(col_i, log_base2k, log_k, &have, 64); + a.encode_vec_i64(col_i, basek, k, &have, 64); let mut want = vec![i64::default(); n]; - a.decode_vec_i64(col_i, log_base2k, log_k, &mut want); + a.decode_vec_i64(col_i, basek, k, &mut want); izip!(want, have).for_each(|(a, b)| assert_eq!(a, b, "{} != {}", a, b)); }) } diff --git a/base2k/src/ffi/cnv.rs b/backend/src/ffi/cnv.rs similarity index 95% rename from base2k/src/ffi/cnv.rs rename to backend/src/ffi/cnv.rs index be8aae3..07b4f7f 100644 --- a/base2k/src/ffi/cnv.rs +++ b/backend/src/ffi/cnv.rs @@ -1,7 +1,7 @@ -pub type CNV_PVEC_L = cnv_pvec_l_t; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct cnv_pvec_r_t { - _unused: [u8; 0], -} -pub type CNV_PVEC_R = cnv_pvec_r_t; +pub type CNV_PVEC_L = cnv_pvec_l_t; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct cnv_pvec_r_t { + _unused: [u8; 0], +} +pub type CNV_PVEC_R = cnv_pvec_r_t; diff --git a/base2k/src/ffi/mod.rs b/backend/src/ffi/mod.rs similarity index 94% rename from base2k/src/ffi/mod.rs rename to backend/src/ffi/mod.rs index 57e9291..4213310 100644 --- a/base2k/src/ffi/mod.rs +++ b/backend/src/ffi/mod.rs @@ -1,8 +1,8 @@ -pub mod module; -pub mod reim; -pub mod svp; -pub mod vec_znx; -pub mod vec_znx_big; -pub mod vec_znx_dft; -pub mod vmp; -pub mod znx; +pub mod module; +pub mod reim; +pub mod svp; +pub mod vec_znx; +pub mod vec_znx_big; +pub mod vec_znx_dft; +pub mod vmp; +pub mod znx; diff --git a/base2k/src/ffi/module.rs b/backend/src/ffi/module.rs similarity index 96% rename from base2k/src/ffi/module.rs rename to backend/src/ffi/module.rs index e35d4c0..011c419 100644 --- a/base2k/src/ffi/module.rs +++ b/backend/src/ffi/module.rs @@ -1,18 +1,18 @@ -pub struct module_info_t { - _unused: [u8; 0], -} - -pub type module_type_t = ::std::os::raw::c_uint; -pub use self::module_type_t as MODULE_TYPE; - -pub type MODULE = module_info_t; - -unsafe extern "C" { - pub unsafe fn new_module_info(N: u64, mode: MODULE_TYPE) -> *mut MODULE; -} -unsafe extern "C" { - pub unsafe fn delete_module_info(module_info: *mut MODULE); -} -unsafe extern "C" { - pub unsafe fn module_get_n(module: *const MODULE) -> u64; -} +pub struct module_info_t { + _unused: [u8; 0], +} + +pub type module_type_t = ::std::os::raw::c_uint; +pub use self::module_type_t as MODULE_TYPE; + +pub type MODULE = module_info_t; + +unsafe extern "C" { + pub unsafe fn new_module_info(N: u64, mode: MODULE_TYPE) -> *mut MODULE; +} +unsafe extern "C" { + pub unsafe fn delete_module_info(module_info: *mut MODULE); +} +unsafe extern "C" { + pub unsafe fn module_get_n(module: *const MODULE) -> u64; +} diff --git a/base2k/src/ffi/reim.rs b/backend/src/ffi/reim.rs similarity index 97% rename from base2k/src/ffi/reim.rs rename to backend/src/ffi/reim.rs index eb2fae7..a3ce548 100644 --- a/base2k/src/ffi/reim.rs +++ b/backend/src/ffi/reim.rs @@ -1,172 +1,172 @@ -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct reim_fft_precomp { - _unused: [u8; 0], -} -pub type REIM_FFT_PRECOMP = reim_fft_precomp; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct reim_ifft_precomp { - _unused: [u8; 0], -} -pub type REIM_IFFT_PRECOMP = reim_ifft_precomp; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct reim_mul_precomp { - _unused: [u8; 0], -} -pub type REIM_FFTVEC_MUL_PRECOMP = reim_mul_precomp; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct reim_addmul_precomp { - _unused: [u8; 0], -} -pub type REIM_FFTVEC_ADDMUL_PRECOMP = reim_addmul_precomp; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct reim_from_znx32_precomp { - _unused: [u8; 0], -} -pub type REIM_FROM_ZNX32_PRECOMP = reim_from_znx32_precomp; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct reim_from_znx64_precomp { - _unused: [u8; 0], -} -pub type REIM_FROM_ZNX64_PRECOMP = reim_from_znx64_precomp; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct reim_from_tnx32_precomp { - _unused: [u8; 0], -} -pub type REIM_FROM_TNX32_PRECOMP = reim_from_tnx32_precomp; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct reim_to_tnx32_precomp { - _unused: [u8; 0], -} -pub type REIM_TO_TNX32_PRECOMP = reim_to_tnx32_precomp; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct reim_to_tnx_precomp { - _unused: [u8; 0], -} -pub type REIM_TO_TNX_PRECOMP = reim_to_tnx_precomp; -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct reim_to_znx64_precomp { - _unused: [u8; 0], -} -pub type REIM_TO_ZNX64_PRECOMP = reim_to_znx64_precomp; -unsafe extern "C" { - pub unsafe fn new_reim_fft_precomp(m: u32, num_buffers: u32) -> *mut REIM_FFT_PRECOMP; -} -unsafe extern "C" { - pub unsafe fn reim_fft_precomp_get_buffer(tables: *const REIM_FFT_PRECOMP, buffer_index: u32) -> *mut f64; -} -unsafe extern "C" { - pub unsafe fn new_reim_fft_buffer(m: u32) -> *mut f64; -} -unsafe extern "C" { - pub unsafe fn delete_reim_fft_buffer(buffer: *mut f64); -} -unsafe extern "C" { - pub unsafe fn reim_fft(tables: *const REIM_FFT_PRECOMP, data: *mut f64); -} -unsafe extern "C" { - pub unsafe fn new_reim_ifft_precomp(m: u32, num_buffers: u32) -> *mut REIM_IFFT_PRECOMP; -} -unsafe extern "C" { - pub unsafe fn reim_ifft_precomp_get_buffer(tables: *const REIM_IFFT_PRECOMP, buffer_index: u32) -> *mut f64; -} -unsafe extern "C" { - pub unsafe fn reim_ifft(tables: *const REIM_IFFT_PRECOMP, data: *mut f64); -} -unsafe extern "C" { - pub unsafe fn new_reim_fftvec_mul_precomp(m: u32) -> *mut REIM_FFTVEC_MUL_PRECOMP; -} -unsafe extern "C" { - pub unsafe fn reim_fftvec_mul(tables: *const REIM_FFTVEC_MUL_PRECOMP, r: *mut f64, a: *const f64, b: *const f64); -} -unsafe extern "C" { - pub unsafe fn new_reim_fftvec_addmul_precomp(m: u32) -> *mut REIM_FFTVEC_ADDMUL_PRECOMP; -} -unsafe extern "C" { - pub unsafe fn reim_fftvec_addmul(tables: *const REIM_FFTVEC_ADDMUL_PRECOMP, r: *mut f64, a: *const f64, b: *const f64); -} -unsafe extern "C" { - pub unsafe fn new_reim_from_znx32_precomp(m: u32, log2bound: u32) -> *mut REIM_FROM_ZNX32_PRECOMP; -} -unsafe extern "C" { - pub unsafe fn reim_from_znx32(tables: *const REIM_FROM_ZNX32_PRECOMP, r: *mut ::std::os::raw::c_void, a: *const i32); -} -unsafe extern "C" { - pub unsafe fn reim_from_znx64(tables: *const REIM_FROM_ZNX64_PRECOMP, r: *mut ::std::os::raw::c_void, a: *const i64); -} -unsafe extern "C" { - pub unsafe fn new_reim_from_znx64_precomp(m: u32, maxbnd: u32) -> *mut REIM_FROM_ZNX64_PRECOMP; -} -unsafe extern "C" { - pub unsafe fn reim_from_znx64_simple(m: u32, log2bound: u32, r: *mut ::std::os::raw::c_void, a: *const i64); -} -unsafe extern "C" { - pub unsafe fn new_reim_from_tnx32_precomp(m: u32) -> *mut REIM_FROM_TNX32_PRECOMP; -} -unsafe extern "C" { - pub unsafe fn reim_from_tnx32(tables: *const REIM_FROM_TNX32_PRECOMP, r: *mut ::std::os::raw::c_void, a: *const i32); -} -unsafe extern "C" { - pub unsafe fn new_reim_to_tnx32_precomp(m: u32, divisor: f64, log2overhead: u32) -> *mut REIM_TO_TNX32_PRECOMP; -} -unsafe extern "C" { - pub unsafe fn reim_to_tnx32(tables: *const REIM_TO_TNX32_PRECOMP, r: *mut i32, a: *const ::std::os::raw::c_void); -} -unsafe extern "C" { - pub unsafe fn new_reim_to_tnx_precomp(m: u32, divisor: f64, log2overhead: u32) -> *mut REIM_TO_TNX_PRECOMP; -} -unsafe extern "C" { - pub unsafe fn reim_to_tnx(tables: *const REIM_TO_TNX_PRECOMP, r: *mut f64, a: *const f64); -} -unsafe extern "C" { - pub unsafe fn reim_to_tnx_simple(m: u32, divisor: f64, log2overhead: u32, r: *mut f64, a: *const f64); -} -unsafe extern "C" { - pub unsafe fn new_reim_to_znx64_precomp(m: u32, divisor: f64, log2bound: u32) -> *mut REIM_TO_ZNX64_PRECOMP; -} -unsafe extern "C" { - pub unsafe fn reim_to_znx64(precomp: *const REIM_TO_ZNX64_PRECOMP, r: *mut i64, a: *const ::std::os::raw::c_void); -} -unsafe extern "C" { - pub unsafe fn reim_to_znx64_simple(m: u32, divisor: f64, log2bound: u32, r: *mut i64, a: *const ::std::os::raw::c_void); -} -unsafe extern "C" { - pub unsafe fn reim_fft_simple(m: u32, data: *mut ::std::os::raw::c_void); -} -unsafe extern "C" { - pub unsafe fn reim_ifft_simple(m: u32, data: *mut ::std::os::raw::c_void); -} -unsafe extern "C" { - pub unsafe fn reim_fftvec_mul_simple( - m: u32, - r: *mut ::std::os::raw::c_void, - a: *const ::std::os::raw::c_void, - b: *const ::std::os::raw::c_void, - ); -} -unsafe extern "C" { - pub unsafe fn reim_fftvec_addmul_simple( - m: u32, - r: *mut ::std::os::raw::c_void, - a: *const ::std::os::raw::c_void, - b: *const ::std::os::raw::c_void, - ); -} -unsafe extern "C" { - pub unsafe fn reim_from_znx32_simple(m: u32, log2bound: u32, r: *mut ::std::os::raw::c_void, x: *const i32); -} -unsafe extern "C" { - pub unsafe fn reim_from_tnx32_simple(m: u32, r: *mut ::std::os::raw::c_void, x: *const i32); -} -unsafe extern "C" { - pub unsafe fn reim_to_tnx32_simple(m: u32, divisor: f64, log2overhead: u32, r: *mut i32, x: *const ::std::os::raw::c_void); -} +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct reim_fft_precomp { + _unused: [u8; 0], +} +pub type REIM_FFT_PRECOMP = reim_fft_precomp; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct reim_ifft_precomp { + _unused: [u8; 0], +} +pub type REIM_IFFT_PRECOMP = reim_ifft_precomp; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct reim_mul_precomp { + _unused: [u8; 0], +} +pub type REIM_FFTVEC_MUL_PRECOMP = reim_mul_precomp; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct reim_addmul_precomp { + _unused: [u8; 0], +} +pub type REIM_FFTVEC_ADDMUL_PRECOMP = reim_addmul_precomp; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct reim_from_znx32_precomp { + _unused: [u8; 0], +} +pub type REIM_FROM_ZNX32_PRECOMP = reim_from_znx32_precomp; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct reim_from_znx64_precomp { + _unused: [u8; 0], +} +pub type REIM_FROM_ZNX64_PRECOMP = reim_from_znx64_precomp; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct reim_from_tnx32_precomp { + _unused: [u8; 0], +} +pub type REIM_FROM_TNX32_PRECOMP = reim_from_tnx32_precomp; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct reim_to_tnx32_precomp { + _unused: [u8; 0], +} +pub type REIM_TO_TNX32_PRECOMP = reim_to_tnx32_precomp; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct reim_to_tnx_precomp { + _unused: [u8; 0], +} +pub type REIM_TO_TNX_PRECOMP = reim_to_tnx_precomp; +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct reim_to_znx64_precomp { + _unused: [u8; 0], +} +pub type REIM_TO_ZNX64_PRECOMP = reim_to_znx64_precomp; +unsafe extern "C" { + pub unsafe fn new_reim_fft_precomp(m: u32, num_buffers: u32) -> *mut REIM_FFT_PRECOMP; +} +unsafe extern "C" { + pub unsafe fn reim_fft_precomp_get_buffer(tables: *const REIM_FFT_PRECOMP, buffer_index: u32) -> *mut f64; +} +unsafe extern "C" { + pub unsafe fn new_reim_fft_buffer(m: u32) -> *mut f64; +} +unsafe extern "C" { + pub unsafe fn delete_reim_fft_buffer(buffer: *mut f64); +} +unsafe extern "C" { + pub unsafe fn reim_fft(tables: *const REIM_FFT_PRECOMP, data: *mut f64); +} +unsafe extern "C" { + pub unsafe fn new_reim_ifft_precomp(m: u32, num_buffers: u32) -> *mut REIM_IFFT_PRECOMP; +} +unsafe extern "C" { + pub unsafe fn reim_ifft_precomp_get_buffer(tables: *const REIM_IFFT_PRECOMP, buffer_index: u32) -> *mut f64; +} +unsafe extern "C" { + pub unsafe fn reim_ifft(tables: *const REIM_IFFT_PRECOMP, data: *mut f64); +} +unsafe extern "C" { + pub unsafe fn new_reim_fftvec_mul_precomp(m: u32) -> *mut REIM_FFTVEC_MUL_PRECOMP; +} +unsafe extern "C" { + pub unsafe fn reim_fftvec_mul(tables: *const REIM_FFTVEC_MUL_PRECOMP, r: *mut f64, a: *const f64, b: *const f64); +} +unsafe extern "C" { + pub unsafe fn new_reim_fftvec_addmul_precomp(m: u32) -> *mut REIM_FFTVEC_ADDMUL_PRECOMP; +} +unsafe extern "C" { + pub unsafe fn reim_fftvec_addmul(tables: *const REIM_FFTVEC_ADDMUL_PRECOMP, r: *mut f64, a: *const f64, b: *const f64); +} +unsafe extern "C" { + pub unsafe fn new_reim_from_znx32_precomp(m: u32, log2bound: u32) -> *mut REIM_FROM_ZNX32_PRECOMP; +} +unsafe extern "C" { + pub unsafe fn reim_from_znx32(tables: *const REIM_FROM_ZNX32_PRECOMP, r: *mut ::std::os::raw::c_void, a: *const i32); +} +unsafe extern "C" { + pub unsafe fn reim_from_znx64(tables: *const REIM_FROM_ZNX64_PRECOMP, r: *mut ::std::os::raw::c_void, a: *const i64); +} +unsafe extern "C" { + pub unsafe fn new_reim_from_znx64_precomp(m: u32, maxbnd: u32) -> *mut REIM_FROM_ZNX64_PRECOMP; +} +unsafe extern "C" { + pub unsafe fn reim_from_znx64_simple(m: u32, log2bound: u32, r: *mut ::std::os::raw::c_void, a: *const i64); +} +unsafe extern "C" { + pub unsafe fn new_reim_from_tnx32_precomp(m: u32) -> *mut REIM_FROM_TNX32_PRECOMP; +} +unsafe extern "C" { + pub unsafe fn reim_from_tnx32(tables: *const REIM_FROM_TNX32_PRECOMP, r: *mut ::std::os::raw::c_void, a: *const i32); +} +unsafe extern "C" { + pub unsafe fn new_reim_to_tnx32_precomp(m: u32, divisor: f64, log2overhead: u32) -> *mut REIM_TO_TNX32_PRECOMP; +} +unsafe extern "C" { + pub unsafe fn reim_to_tnx32(tables: *const REIM_TO_TNX32_PRECOMP, r: *mut i32, a: *const ::std::os::raw::c_void); +} +unsafe extern "C" { + pub unsafe fn new_reim_to_tnx_precomp(m: u32, divisor: f64, log2overhead: u32) -> *mut REIM_TO_TNX_PRECOMP; +} +unsafe extern "C" { + pub unsafe fn reim_to_tnx(tables: *const REIM_TO_TNX_PRECOMP, r: *mut f64, a: *const f64); +} +unsafe extern "C" { + pub unsafe fn reim_to_tnx_simple(m: u32, divisor: f64, log2overhead: u32, r: *mut f64, a: *const f64); +} +unsafe extern "C" { + pub unsafe fn new_reim_to_znx64_precomp(m: u32, divisor: f64, log2bound: u32) -> *mut REIM_TO_ZNX64_PRECOMP; +} +unsafe extern "C" { + pub unsafe fn reim_to_znx64(precomp: *const REIM_TO_ZNX64_PRECOMP, r: *mut i64, a: *const ::std::os::raw::c_void); +} +unsafe extern "C" { + pub unsafe fn reim_to_znx64_simple(m: u32, divisor: f64, log2bound: u32, r: *mut i64, a: *const ::std::os::raw::c_void); +} +unsafe extern "C" { + pub unsafe fn reim_fft_simple(m: u32, data: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub unsafe fn reim_ifft_simple(m: u32, data: *mut ::std::os::raw::c_void); +} +unsafe extern "C" { + pub unsafe fn reim_fftvec_mul_simple( + m: u32, + r: *mut ::std::os::raw::c_void, + a: *const ::std::os::raw::c_void, + b: *const ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub unsafe fn reim_fftvec_addmul_simple( + m: u32, + r: *mut ::std::os::raw::c_void, + a: *const ::std::os::raw::c_void, + b: *const ::std::os::raw::c_void, + ); +} +unsafe extern "C" { + pub unsafe fn reim_from_znx32_simple(m: u32, log2bound: u32, r: *mut ::std::os::raw::c_void, x: *const i32); +} +unsafe extern "C" { + pub unsafe fn reim_from_tnx32_simple(m: u32, r: *mut ::std::os::raw::c_void, x: *const i32); +} +unsafe extern "C" { + pub unsafe fn reim_to_tnx32_simple(m: u32, divisor: f64, log2overhead: u32, r: *mut i32, x: *const ::std::os::raw::c_void); +} diff --git a/base2k/src/ffi/svp.rs b/backend/src/ffi/svp.rs similarity index 95% rename from base2k/src/ffi/svp.rs rename to backend/src/ffi/svp.rs index 08b2da1..8c994c9 100644 --- a/base2k/src/ffi/svp.rs +++ b/backend/src/ffi/svp.rs @@ -1,48 +1,48 @@ -use crate::ffi::module::MODULE; -use crate::ffi::vec_znx_dft::VEC_ZNX_DFT; - -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct svp_ppol_t { - _unused: [u8; 0], -} -pub type SVP_PPOL = svp_ppol_t; - -unsafe extern "C" { - pub unsafe fn bytes_of_svp_ppol(module: *const MODULE) -> u64; -} -unsafe extern "C" { - pub unsafe fn new_svp_ppol(module: *const MODULE) -> *mut SVP_PPOL; -} -unsafe extern "C" { - pub unsafe fn delete_svp_ppol(res: *mut SVP_PPOL); -} - -unsafe extern "C" { - pub unsafe fn svp_prepare(module: *const MODULE, ppol: *mut SVP_PPOL, pol: *const i64); -} - -unsafe extern "C" { - pub unsafe fn svp_apply_dft( - module: *const MODULE, - res: *const VEC_ZNX_DFT, - res_size: u64, - ppol: *const SVP_PPOL, - a: *const i64, - a_size: u64, - a_sl: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn svp_apply_dft_to_dft( - module: *const MODULE, - res: *const VEC_ZNX_DFT, - res_size: u64, - res_cols: u64, - ppol: *const SVP_PPOL, - a: *const VEC_ZNX_DFT, - a_size: u64, - a_cols: u64, - ); -} +use crate::ffi::module::MODULE; +use crate::ffi::vec_znx_dft::VEC_ZNX_DFT; + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct svp_ppol_t { + _unused: [u8; 0], +} +pub type SVP_PPOL = svp_ppol_t; + +unsafe extern "C" { + pub unsafe fn bytes_of_svp_ppol(module: *const MODULE) -> u64; +} +unsafe extern "C" { + pub unsafe fn new_svp_ppol(module: *const MODULE) -> *mut SVP_PPOL; +} +unsafe extern "C" { + pub unsafe fn delete_svp_ppol(res: *mut SVP_PPOL); +} + +unsafe extern "C" { + pub unsafe fn svp_prepare(module: *const MODULE, ppol: *mut SVP_PPOL, pol: *const i64); +} + +unsafe extern "C" { + pub unsafe fn svp_apply_dft( + module: *const MODULE, + res: *const VEC_ZNX_DFT, + res_size: u64, + ppol: *const SVP_PPOL, + a: *const i64, + a_size: u64, + a_sl: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn svp_apply_dft_to_dft( + module: *const MODULE, + res: *const VEC_ZNX_DFT, + res_size: u64, + res_cols: u64, + ppol: *const SVP_PPOL, + a: *const VEC_ZNX_DFT, + a_size: u64, + a_cols: u64, + ); +} diff --git a/base2k/src/ffi/vec_znx.rs b/backend/src/ffi/vec_znx.rs similarity index 94% rename from base2k/src/ffi/vec_znx.rs rename to backend/src/ffi/vec_znx.rs index 26dec8c..b377fd1 100644 --- a/base2k/src/ffi/vec_znx.rs +++ b/backend/src/ffi/vec_znx.rs @@ -1,101 +1,101 @@ -use crate::ffi::module::MODULE; - -unsafe extern "C" { - pub unsafe fn vec_znx_add( - module: *const MODULE, - res: *mut i64, - res_size: u64, - res_sl: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - b: *const i64, - b_size: u64, - b_sl: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_automorphism( - module: *const MODULE, - p: i64, - res: *mut i64, - res_size: u64, - res_sl: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_negate( - module: *const MODULE, - res: *mut i64, - res_size: u64, - res_sl: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_rotate( - module: *const MODULE, - p: i64, - res: *mut i64, - res_size: u64, - res_sl: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_sub( - module: *const MODULE, - res: *mut i64, - res_size: u64, - res_sl: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - b: *const i64, - b_size: u64, - b_sl: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_zero(module: *const MODULE, res: *mut i64, res_size: u64, res_sl: u64); -} -unsafe extern "C" { - pub unsafe fn vec_znx_copy( - module: *const MODULE, - res: *mut i64, - res_size: u64, - res_sl: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_normalize_base2k( - module: *const MODULE, - log2_base2k: u64, - res: *mut i64, - res_size: u64, - res_sl: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - tmp_space: *mut u8, - ); -} -unsafe extern "C" { - pub unsafe fn vec_znx_normalize_base2k_tmp_bytes(module: *const MODULE) -> u64; -} +use crate::ffi::module::MODULE; + +unsafe extern "C" { + pub unsafe fn vec_znx_add( + module: *const MODULE, + res: *mut i64, + res_size: u64, + res_sl: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + b: *const i64, + b_size: u64, + b_sl: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_automorphism( + module: *const MODULE, + p: i64, + res: *mut i64, + res_size: u64, + res_sl: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_negate( + module: *const MODULE, + res: *mut i64, + res_size: u64, + res_sl: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_rotate( + module: *const MODULE, + p: i64, + res: *mut i64, + res_size: u64, + res_sl: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_sub( + module: *const MODULE, + res: *mut i64, + res_size: u64, + res_sl: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + b: *const i64, + b_size: u64, + b_sl: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_zero(module: *const MODULE, res: *mut i64, res_size: u64, res_sl: u64); +} +unsafe extern "C" { + pub unsafe fn vec_znx_copy( + module: *const MODULE, + res: *mut i64, + res_size: u64, + res_sl: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_normalize_base2k( + module: *const MODULE, + base2k: u64, + res: *mut i64, + res_size: u64, + res_sl: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + tmp_space: *mut u8, + ); +} +unsafe extern "C" { + pub unsafe fn vec_znx_normalize_base2k_tmp_bytes(module: *const MODULE) -> u64; +} diff --git a/base2k/src/ffi/vec_znx_big.rs b/backend/src/ffi/vec_znx_big.rs similarity index 95% rename from base2k/src/ffi/vec_znx_big.rs rename to backend/src/ffi/vec_znx_big.rs index 8c06e90..1353051 100644 --- a/base2k/src/ffi/vec_znx_big.rs +++ b/backend/src/ffi/vec_znx_big.rs @@ -1,161 +1,161 @@ -use crate::ffi::module::MODULE; - -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct vec_znx_big_t { - _unused: [u8; 0], -} -pub type VEC_ZNX_BIG = vec_znx_big_t; - -unsafe extern "C" { - pub unsafe fn bytes_of_vec_znx_big(module: *const MODULE, size: u64) -> u64; -} -unsafe extern "C" { - pub unsafe fn new_vec_znx_big(module: *const MODULE, size: u64) -> *mut VEC_ZNX_BIG; -} -unsafe extern "C" { - pub unsafe fn delete_vec_znx_big(res: *mut VEC_ZNX_BIG); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_big_add( - module: *const MODULE, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a: *const VEC_ZNX_BIG, - a_size: u64, - b: *const VEC_ZNX_BIG, - b_size: u64, - ); -} -unsafe extern "C" { - pub unsafe fn vec_znx_big_add_small( - module: *const MODULE, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a: *const VEC_ZNX_BIG, - a_size: u64, - b: *const i64, - b_size: u64, - b_sl: u64, - ); -} -unsafe extern "C" { - pub unsafe fn vec_znx_big_add_small2( - module: *const MODULE, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - b: *const i64, - b_size: u64, - b_sl: u64, - ); -} -unsafe extern "C" { - pub unsafe fn vec_znx_big_sub( - module: *const MODULE, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a: *const VEC_ZNX_BIG, - a_size: u64, - b: *const VEC_ZNX_BIG, - b_size: u64, - ); -} -unsafe extern "C" { - pub unsafe fn vec_znx_big_sub_small_b( - module: *const MODULE, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a: *const VEC_ZNX_BIG, - a_size: u64, - b: *const i64, - b_size: u64, - b_sl: u64, - ); -} -unsafe extern "C" { - pub unsafe fn vec_znx_big_sub_small_a( - module: *const MODULE, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - b: *const VEC_ZNX_BIG, - b_size: u64, - ); -} -unsafe extern "C" { - pub unsafe fn vec_znx_big_sub_small2( - module: *const MODULE, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - b: *const i64, - b_size: u64, - b_sl: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_big_normalize_base2k_tmp_bytes(module: *const MODULE) -> u64; -} - -unsafe extern "C" { - pub unsafe fn vec_znx_big_normalize_base2k( - module: *const MODULE, - log2_base2k: u64, - res: *mut i64, - res_size: u64, - res_sl: u64, - a: *const VEC_ZNX_BIG, - a_size: u64, - tmp_space: *mut u8, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_big_range_normalize_base2k( - module: *const MODULE, - log2_base2k: u64, - res: *mut i64, - res_size: u64, - res_sl: u64, - a: *const VEC_ZNX_BIG, - a_range_begin: u64, - a_range_xend: u64, - a_range_step: u64, - tmp_space: *mut u8, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_big_range_normalize_base2k_tmp_bytes(module: *const MODULE) -> u64; -} - -unsafe extern "C" { - pub unsafe fn vec_znx_big_automorphism( - module: *const MODULE, - p: i64, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a: *const VEC_ZNX_BIG, - a_size: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_big_rotate( - module: *const MODULE, - p: i64, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a: *const VEC_ZNX_BIG, - a_size: u64, - ); -} +use crate::ffi::module::MODULE; + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct vec_znx_big_t { + _unused: [u8; 0], +} +pub type VEC_ZNX_BIG = vec_znx_big_t; + +unsafe extern "C" { + pub unsafe fn bytes_of_vec_znx_big(module: *const MODULE, size: u64) -> u64; +} +unsafe extern "C" { + pub unsafe fn new_vec_znx_big(module: *const MODULE, size: u64) -> *mut VEC_ZNX_BIG; +} +unsafe extern "C" { + pub unsafe fn delete_vec_znx_big(res: *mut VEC_ZNX_BIG); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_big_add( + module: *const MODULE, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a: *const VEC_ZNX_BIG, + a_size: u64, + b: *const VEC_ZNX_BIG, + b_size: u64, + ); +} +unsafe extern "C" { + pub unsafe fn vec_znx_big_add_small( + module: *const MODULE, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a: *const VEC_ZNX_BIG, + a_size: u64, + b: *const i64, + b_size: u64, + b_sl: u64, + ); +} +unsafe extern "C" { + pub unsafe fn vec_znx_big_add_small2( + module: *const MODULE, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + b: *const i64, + b_size: u64, + b_sl: u64, + ); +} +unsafe extern "C" { + pub unsafe fn vec_znx_big_sub( + module: *const MODULE, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a: *const VEC_ZNX_BIG, + a_size: u64, + b: *const VEC_ZNX_BIG, + b_size: u64, + ); +} +unsafe extern "C" { + pub unsafe fn vec_znx_big_sub_small_b( + module: *const MODULE, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a: *const VEC_ZNX_BIG, + a_size: u64, + b: *const i64, + b_size: u64, + b_sl: u64, + ); +} +unsafe extern "C" { + pub unsafe fn vec_znx_big_sub_small_a( + module: *const MODULE, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + b: *const VEC_ZNX_BIG, + b_size: u64, + ); +} +unsafe extern "C" { + pub unsafe fn vec_znx_big_sub_small2( + module: *const MODULE, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + b: *const i64, + b_size: u64, + b_sl: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_big_normalize_base2k_tmp_bytes(module: *const MODULE) -> u64; +} + +unsafe extern "C" { + pub unsafe fn vec_znx_big_normalize_base2k( + module: *const MODULE, + log2_base2k: u64, + res: *mut i64, + res_size: u64, + res_sl: u64, + a: *const VEC_ZNX_BIG, + a_size: u64, + tmp_space: *mut u8, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_big_range_normalize_base2k( + module: *const MODULE, + log2_base2k: u64, + res: *mut i64, + res_size: u64, + res_sl: u64, + a: *const VEC_ZNX_BIG, + a_range_begin: u64, + a_range_xend: u64, + a_range_step: u64, + tmp_space: *mut u8, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_big_range_normalize_base2k_tmp_bytes(module: *const MODULE) -> u64; +} + +unsafe extern "C" { + pub unsafe fn vec_znx_big_automorphism( + module: *const MODULE, + p: i64, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a: *const VEC_ZNX_BIG, + a_size: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_big_rotate( + module: *const MODULE, + p: i64, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a: *const VEC_ZNX_BIG, + a_size: u64, + ); +} diff --git a/base2k/src/ffi/vec_znx_dft.rs b/backend/src/ffi/vec_znx_dft.rs similarity index 96% rename from base2k/src/ffi/vec_znx_dft.rs rename to backend/src/ffi/vec_znx_dft.rs index 71583f7..8f427bd 100644 --- a/base2k/src/ffi/vec_znx_dft.rs +++ b/backend/src/ffi/vec_znx_dft.rs @@ -1,86 +1,86 @@ -use crate::ffi::module::MODULE; -use crate::ffi::vec_znx_big::VEC_ZNX_BIG; - -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct vec_znx_dft_t { - _unused: [u8; 0], -} -pub type VEC_ZNX_DFT = vec_znx_dft_t; - -unsafe extern "C" { - pub unsafe fn bytes_of_vec_znx_dft(module: *const MODULE, size: u64) -> u64; -} -unsafe extern "C" { - pub unsafe fn new_vec_znx_dft(module: *const MODULE, size: u64) -> *mut VEC_ZNX_DFT; -} -unsafe extern "C" { - pub unsafe fn delete_vec_znx_dft(res: *mut VEC_ZNX_DFT); -} - -unsafe extern "C" { - pub unsafe fn vec_dft_zero(module: *const MODULE, res: *mut VEC_ZNX_DFT, res_size: u64); -} -unsafe extern "C" { - pub unsafe fn vec_dft_add( - module: *const MODULE, - res: *mut VEC_ZNX_DFT, - res_size: u64, - a: *const VEC_ZNX_DFT, - a_size: u64, - b: *const VEC_ZNX_DFT, - b_size: u64, - ); -} -unsafe extern "C" { - pub unsafe fn vec_dft_sub( - module: *const MODULE, - res: *mut VEC_ZNX_DFT, - res_size: u64, - a: *const VEC_ZNX_DFT, - a_size: u64, - b: *const VEC_ZNX_DFT, - b_size: u64, - ); -} -unsafe extern "C" { - pub unsafe fn vec_znx_dft(module: *const MODULE, res: *mut VEC_ZNX_DFT, res_size: u64, a: *const i64, a_size: u64, a_sl: u64); -} -unsafe extern "C" { - pub unsafe fn vec_znx_idft( - module: *const MODULE, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a_dft: *const VEC_ZNX_DFT, - a_size: u64, - tmp: *mut u8, - ); -} -unsafe extern "C" { - pub unsafe fn vec_znx_idft_tmp_bytes(module: *const MODULE) -> u64; -} -unsafe extern "C" { - pub unsafe fn vec_znx_idft_tmp_a( - module: *const MODULE, - res: *mut VEC_ZNX_BIG, - res_size: u64, - a_dft: *mut VEC_ZNX_DFT, - a_size: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_dft_automorphism( - module: *const MODULE, - d: i64, - res_dft: *mut VEC_ZNX_DFT, - res_size: u64, - a_dft: *const VEC_ZNX_DFT, - a_size: u64, - tmp: *mut u8, - ); -} - -unsafe extern "C" { - pub unsafe fn vec_znx_dft_automorphism_tmp_bytes(module: *const MODULE) -> u64; -} +use crate::ffi::module::MODULE; +use crate::ffi::vec_znx_big::VEC_ZNX_BIG; + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct vec_znx_dft_t { + _unused: [u8; 0], +} +pub type VEC_ZNX_DFT = vec_znx_dft_t; + +unsafe extern "C" { + pub unsafe fn bytes_of_vec_znx_dft(module: *const MODULE, size: u64) -> u64; +} +unsafe extern "C" { + pub unsafe fn new_vec_znx_dft(module: *const MODULE, size: u64) -> *mut VEC_ZNX_DFT; +} +unsafe extern "C" { + pub unsafe fn delete_vec_znx_dft(res: *mut VEC_ZNX_DFT); +} + +unsafe extern "C" { + pub unsafe fn vec_dft_zero(module: *const MODULE, res: *mut VEC_ZNX_DFT, res_size: u64); +} +unsafe extern "C" { + pub unsafe fn vec_dft_add( + module: *const MODULE, + res: *mut VEC_ZNX_DFT, + res_size: u64, + a: *const VEC_ZNX_DFT, + a_size: u64, + b: *const VEC_ZNX_DFT, + b_size: u64, + ); +} +unsafe extern "C" { + pub unsafe fn vec_dft_sub( + module: *const MODULE, + res: *mut VEC_ZNX_DFT, + res_size: u64, + a: *const VEC_ZNX_DFT, + a_size: u64, + b: *const VEC_ZNX_DFT, + b_size: u64, + ); +} +unsafe extern "C" { + pub unsafe fn vec_znx_dft(module: *const MODULE, res: *mut VEC_ZNX_DFT, res_size: u64, a: *const i64, a_size: u64, a_sl: u64); +} +unsafe extern "C" { + pub unsafe fn vec_znx_idft( + module: *const MODULE, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a_dft: *const VEC_ZNX_DFT, + a_size: u64, + tmp: *mut u8, + ); +} +unsafe extern "C" { + pub unsafe fn vec_znx_idft_tmp_bytes(module: *const MODULE) -> u64; +} +unsafe extern "C" { + pub unsafe fn vec_znx_idft_tmp_a( + module: *const MODULE, + res: *mut VEC_ZNX_BIG, + res_size: u64, + a_dft: *mut VEC_ZNX_DFT, + a_size: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_dft_automorphism( + module: *const MODULE, + d: i64, + res_dft: *mut VEC_ZNX_DFT, + res_size: u64, + a_dft: *const VEC_ZNX_DFT, + a_size: u64, + tmp: *mut u8, + ); +} + +unsafe extern "C" { + pub unsafe fn vec_znx_dft_automorphism_tmp_bytes(module: *const MODULE) -> u64; +} diff --git a/base2k/src/ffi/vmp.rs b/backend/src/ffi/vmp.rs similarity index 95% rename from base2k/src/ffi/vmp.rs rename to backend/src/ffi/vmp.rs index 1d8f47c..fc8a7ae 100644 --- a/base2k/src/ffi/vmp.rs +++ b/backend/src/ffi/vmp.rs @@ -1,165 +1,165 @@ -use crate::ffi::module::MODULE; -use crate::ffi::vec_znx_big::VEC_ZNX_BIG; -use crate::ffi::vec_znx_dft::VEC_ZNX_DFT; - -#[repr(C)] -#[derive(Debug, Copy, Clone)] -pub struct vmp_pmat_t { - _unused: [u8; 0], -} - -// [rows][cols] = [#Decomposition][#Limbs] -pub type VMP_PMAT = vmp_pmat_t; - -unsafe extern "C" { - pub unsafe fn bytes_of_vmp_pmat(module: *const MODULE, nrows: u64, ncols: u64) -> u64; -} -unsafe extern "C" { - pub unsafe fn new_vmp_pmat(module: *const MODULE, nrows: u64, ncols: u64) -> *mut VMP_PMAT; -} -unsafe extern "C" { - pub unsafe fn delete_vmp_pmat(res: *mut VMP_PMAT); -} - -unsafe extern "C" { - pub unsafe fn vmp_apply_dft( - module: *const MODULE, - res: *mut VEC_ZNX_DFT, - res_size: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - pmat: *const VMP_PMAT, - nrows: u64, - ncols: u64, - tmp_space: *mut u8, - ); -} - -unsafe extern "C" { - pub unsafe fn vmp_apply_dft_add( - module: *const MODULE, - res: *mut VEC_ZNX_DFT, - res_size: u64, - a: *const i64, - a_size: u64, - a_sl: u64, - pmat: *const VMP_PMAT, - nrows: u64, - ncols: u64, - tmp_space: *mut u8, - ); -} - -unsafe extern "C" { - pub unsafe fn vmp_apply_dft_tmp_bytes(module: *const MODULE, res_size: u64, a_size: u64, nrows: u64, ncols: u64) -> u64; -} - -unsafe extern "C" { - pub unsafe fn vmp_apply_dft_to_dft( - module: *const MODULE, - res: *mut VEC_ZNX_DFT, - res_size: u64, - a_dft: *const VEC_ZNX_DFT, - a_size: u64, - pmat: *const VMP_PMAT, - nrows: u64, - ncols: u64, - tmp_space: *mut u8, - ); -} - -unsafe extern "C" { - pub unsafe fn vmp_apply_dft_to_dft_add( - module: *const MODULE, - res: *mut VEC_ZNX_DFT, - res_size: u64, - a_dft: *const VEC_ZNX_DFT, - a_size: u64, - pmat: *const VMP_PMAT, - nrows: u64, - ncols: u64, - tmp_space: *mut u8, - ); -} - -unsafe extern "C" { - pub unsafe fn vmp_apply_dft_to_dft_tmp_bytes( - module: *const MODULE, - res_size: u64, - a_size: u64, - nrows: u64, - ncols: u64, - ) -> u64; -} - -unsafe extern "C" { - pub unsafe fn vmp_prepare_contiguous( - module: *const MODULE, - pmat: *mut VMP_PMAT, - mat: *const i64, - nrows: u64, - ncols: u64, - tmp_space: *mut u8, - ); -} - -unsafe extern "C" { - pub unsafe fn vmp_prepare_dblptr( - module: *const MODULE, - pmat: *mut VMP_PMAT, - mat: *const *const i64, - nrows: u64, - ncols: u64, - tmp_space: *mut u8, - ); -} - -unsafe extern "C" { - pub unsafe fn vmp_prepare_row( - module: *const MODULE, - pmat: *mut VMP_PMAT, - row: *const i64, - row_i: u64, - nrows: u64, - ncols: u64, - tmp_space: *mut u8, - ); -} - -unsafe extern "C" { - pub unsafe fn vmp_prepare_row_dft( - module: *const MODULE, - pmat: *mut VMP_PMAT, - row: *const VEC_ZNX_DFT, - row_i: u64, - nrows: u64, - ncols: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vmp_extract_row_dft( - module: *const MODULE, - res: *mut VEC_ZNX_DFT, - pmat: *const VMP_PMAT, - row_i: u64, - nrows: u64, - ncols: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vmp_extract_row( - module: *const MODULE, - res: *mut VEC_ZNX_BIG, - pmat: *const VMP_PMAT, - row_i: u64, - nrows: u64, - ncols: u64, - ); -} - -unsafe extern "C" { - pub unsafe fn vmp_prepare_tmp_bytes(module: *const MODULE, nrows: u64, ncols: u64) -> u64; -} +use crate::ffi::module::MODULE; +use crate::ffi::vec_znx_big::VEC_ZNX_BIG; +use crate::ffi::vec_znx_dft::VEC_ZNX_DFT; + +#[repr(C)] +#[derive(Debug, Copy, Clone)] +pub struct vmp_pmat_t { + _unused: [u8; 0], +} + +// [rows][cols] = [#Decomposition][#Limbs] +pub type VMP_PMAT = vmp_pmat_t; + +unsafe extern "C" { + pub unsafe fn bytes_of_vmp_pmat(module: *const MODULE, nrows: u64, ncols: u64) -> u64; +} +unsafe extern "C" { + pub unsafe fn new_vmp_pmat(module: *const MODULE, nrows: u64, ncols: u64) -> *mut VMP_PMAT; +} +unsafe extern "C" { + pub unsafe fn delete_vmp_pmat(res: *mut VMP_PMAT); +} + +unsafe extern "C" { + pub unsafe fn vmp_apply_dft( + module: *const MODULE, + res: *mut VEC_ZNX_DFT, + res_size: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + pmat: *const VMP_PMAT, + nrows: u64, + ncols: u64, + tmp_space: *mut u8, + ); +} + +unsafe extern "C" { + pub unsafe fn vmp_apply_dft_add( + module: *const MODULE, + res: *mut VEC_ZNX_DFT, + res_size: u64, + a: *const i64, + a_size: u64, + a_sl: u64, + pmat: *const VMP_PMAT, + nrows: u64, + ncols: u64, + tmp_space: *mut u8, + ); +} + +unsafe extern "C" { + pub unsafe fn vmp_apply_dft_tmp_bytes(module: *const MODULE, res_size: u64, a_size: u64, nrows: u64, ncols: u64) -> u64; +} + +unsafe extern "C" { + pub unsafe fn vmp_apply_dft_to_dft( + module: *const MODULE, + res: *mut VEC_ZNX_DFT, + res_size: u64, + a_dft: *const VEC_ZNX_DFT, + a_size: u64, + pmat: *const VMP_PMAT, + nrows: u64, + ncols: u64, + tmp_space: *mut u8, + ); +} + +unsafe extern "C" { + pub unsafe fn vmp_apply_dft_to_dft_add( + module: *const MODULE, + res: *mut VEC_ZNX_DFT, + res_size: u64, + a_dft: *const VEC_ZNX_DFT, + a_size: u64, + pmat: *const VMP_PMAT, + nrows: u64, + ncols: u64, + tmp_space: *mut u8, + ); +} + +unsafe extern "C" { + pub unsafe fn vmp_apply_dft_to_dft_tmp_bytes( + module: *const MODULE, + res_size: u64, + a_size: u64, + nrows: u64, + ncols: u64, + ) -> u64; +} + +unsafe extern "C" { + pub unsafe fn vmp_prepare_contiguous( + module: *const MODULE, + pmat: *mut VMP_PMAT, + mat: *const i64, + nrows: u64, + ncols: u64, + tmp_space: *mut u8, + ); +} + +unsafe extern "C" { + pub unsafe fn vmp_prepare_dblptr( + module: *const MODULE, + pmat: *mut VMP_PMAT, + mat: *const *const i64, + nrows: u64, + ncols: u64, + tmp_space: *mut u8, + ); +} + +unsafe extern "C" { + pub unsafe fn vmp_prepare_row( + module: *const MODULE, + pmat: *mut VMP_PMAT, + row: *const i64, + row_i: u64, + nrows: u64, + ncols: u64, + tmp_space: *mut u8, + ); +} + +unsafe extern "C" { + pub unsafe fn vmp_prepare_row_dft( + module: *const MODULE, + pmat: *mut VMP_PMAT, + row: *const VEC_ZNX_DFT, + row_i: u64, + nrows: u64, + ncols: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vmp_extract_row_dft( + module: *const MODULE, + res: *mut VEC_ZNX_DFT, + pmat: *const VMP_PMAT, + row_i: u64, + nrows: u64, + ncols: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vmp_extract_row( + module: *const MODULE, + res: *mut VEC_ZNX_BIG, + pmat: *const VMP_PMAT, + row_i: u64, + nrows: u64, + ncols: u64, + ); +} + +unsafe extern "C" { + pub unsafe fn vmp_prepare_tmp_bytes(module: *const MODULE, nrows: u64, ncols: u64) -> u64; +} diff --git a/base2k/src/ffi/znx.rs b/backend/src/ffi/znx.rs similarity index 97% rename from base2k/src/ffi/znx.rs rename to backend/src/ffi/znx.rs index f4bbeca..dc30db6 100644 --- a/base2k/src/ffi/znx.rs +++ b/backend/src/ffi/znx.rs @@ -1,76 +1,76 @@ -use crate::ffi::module::MODULE; - -unsafe extern "C" { - pub unsafe fn znx_add_i64_ref(nn: u64, res: *mut i64, a: *const i64, b: *const i64); -} -unsafe extern "C" { - pub unsafe fn znx_add_i64_avx(nn: u64, res: *mut i64, a: *const i64, b: *const i64); -} -unsafe extern "C" { - pub unsafe fn znx_sub_i64_ref(nn: u64, res: *mut i64, a: *const i64, b: *const i64); -} -unsafe extern "C" { - pub unsafe fn znx_sub_i64_avx(nn: u64, res: *mut i64, a: *const i64, b: *const i64); -} -unsafe extern "C" { - pub unsafe fn znx_negate_i64_ref(nn: u64, res: *mut i64, a: *const i64); -} -unsafe extern "C" { - pub unsafe fn znx_negate_i64_avx(nn: u64, res: *mut i64, a: *const i64); -} -unsafe extern "C" { - pub unsafe fn znx_copy_i64_ref(nn: u64, res: *mut i64, a: *const i64); -} -unsafe extern "C" { - pub unsafe fn znx_zero_i64_ref(nn: u64, res: *mut i64); -} -unsafe extern "C" { - pub unsafe fn rnx_divide_by_m_ref(nn: u64, m: f64, res: *mut f64, a: *const f64); -} -unsafe extern "C" { - pub unsafe fn rnx_divide_by_m_avx(nn: u64, m: f64, res: *mut f64, a: *const f64); -} -unsafe extern "C" { - pub unsafe fn rnx_rotate_f64(nn: u64, p: i64, res: *mut f64, in_: *const f64); -} -unsafe extern "C" { - pub unsafe fn znx_rotate_i64(nn: u64, p: i64, res: *mut i64, in_: *const i64); -} -unsafe extern "C" { - pub unsafe fn rnx_rotate_inplace_f64(nn: u64, p: i64, res: *mut f64); -} -unsafe extern "C" { - pub unsafe fn znx_rotate_inplace_i64(nn: u64, p: i64, res: *mut i64); -} -unsafe extern "C" { - pub unsafe fn rnx_automorphism_f64(nn: u64, p: i64, res: *mut f64, in_: *const f64); -} -unsafe extern "C" { - pub unsafe fn znx_automorphism_i64(nn: u64, p: i64, res: *mut i64, in_: *const i64); -} -unsafe extern "C" { - pub unsafe fn rnx_automorphism_inplace_f64(nn: u64, p: i64, res: *mut f64); -} -unsafe extern "C" { - pub unsafe fn znx_automorphism_inplace_i64(nn: u64, p: i64, res: *mut i64); -} -unsafe extern "C" { - pub unsafe fn rnx_mul_xp_minus_one(nn: u64, p: i64, res: *mut f64, in_: *const f64); -} -unsafe extern "C" { - pub unsafe fn znx_mul_xp_minus_one(nn: u64, p: i64, res: *mut i64, in_: *const i64); -} -unsafe extern "C" { - pub unsafe fn rnx_mul_xp_minus_one_inplace(nn: u64, p: i64, res: *mut f64); -} -unsafe extern "C" { - pub unsafe fn znx_normalize(nn: u64, base_k: u64, out: *mut i64, carry_out: *mut i64, in_: *const i64, carry_in: *const i64); -} - -unsafe extern "C" { - pub unsafe fn znx_small_single_product(module: *const MODULE, res: *mut i64, a: *const i64, b: *const i64, tmp: *mut u8); -} - -unsafe extern "C" { - pub unsafe fn znx_small_single_product_tmp_bytes(module: *const MODULE) -> u64; -} +use crate::ffi::module::MODULE; + +unsafe extern "C" { + pub unsafe fn znx_add_i64_ref(nn: u64, res: *mut i64, a: *const i64, b: *const i64); +} +unsafe extern "C" { + pub unsafe fn znx_add_i64_avx(nn: u64, res: *mut i64, a: *const i64, b: *const i64); +} +unsafe extern "C" { + pub unsafe fn znx_sub_i64_ref(nn: u64, res: *mut i64, a: *const i64, b: *const i64); +} +unsafe extern "C" { + pub unsafe fn znx_sub_i64_avx(nn: u64, res: *mut i64, a: *const i64, b: *const i64); +} +unsafe extern "C" { + pub unsafe fn znx_negate_i64_ref(nn: u64, res: *mut i64, a: *const i64); +} +unsafe extern "C" { + pub unsafe fn znx_negate_i64_avx(nn: u64, res: *mut i64, a: *const i64); +} +unsafe extern "C" { + pub unsafe fn znx_copy_i64_ref(nn: u64, res: *mut i64, a: *const i64); +} +unsafe extern "C" { + pub unsafe fn znx_zero_i64_ref(nn: u64, res: *mut i64); +} +unsafe extern "C" { + pub unsafe fn rnx_divide_by_m_ref(nn: u64, m: f64, res: *mut f64, a: *const f64); +} +unsafe extern "C" { + pub unsafe fn rnx_divide_by_m_avx(nn: u64, m: f64, res: *mut f64, a: *const f64); +} +unsafe extern "C" { + pub unsafe fn rnx_rotate_f64(nn: u64, p: i64, res: *mut f64, in_: *const f64); +} +unsafe extern "C" { + pub unsafe fn znx_rotate_i64(nn: u64, p: i64, res: *mut i64, in_: *const i64); +} +unsafe extern "C" { + pub unsafe fn rnx_rotate_inplace_f64(nn: u64, p: i64, res: *mut f64); +} +unsafe extern "C" { + pub unsafe fn znx_rotate_inplace_i64(nn: u64, p: i64, res: *mut i64); +} +unsafe extern "C" { + pub unsafe fn rnx_automorphism_f64(nn: u64, p: i64, res: *mut f64, in_: *const f64); +} +unsafe extern "C" { + pub unsafe fn znx_automorphism_i64(nn: u64, p: i64, res: *mut i64, in_: *const i64); +} +unsafe extern "C" { + pub unsafe fn rnx_automorphism_inplace_f64(nn: u64, p: i64, res: *mut f64); +} +unsafe extern "C" { + pub unsafe fn znx_automorphism_inplace_i64(nn: u64, p: i64, res: *mut i64); +} +unsafe extern "C" { + pub unsafe fn rnx_mul_xp_minus_one(nn: u64, p: i64, res: *mut f64, in_: *const f64); +} +unsafe extern "C" { + pub unsafe fn znx_mul_xp_minus_one(nn: u64, p: i64, res: *mut i64, in_: *const i64); +} +unsafe extern "C" { + pub unsafe fn rnx_mul_xp_minus_one_inplace(nn: u64, p: i64, res: *mut f64); +} +unsafe extern "C" { + pub unsafe fn znx_normalize(nn: u64, base_k: u64, out: *mut i64, carry_out: *mut i64, in_: *const i64, carry_in: *const i64); +} + +unsafe extern "C" { + pub unsafe fn znx_small_single_product(module: *const MODULE, res: *mut i64, a: *const i64, b: *const i64, tmp: *mut u8); +} + +unsafe extern "C" { + pub unsafe fn znx_small_single_product_tmp_bytes(module: *const MODULE) -> u64; +} diff --git a/base2k/src/lib.rs b/backend/src/lib.rs similarity index 100% rename from base2k/src/lib.rs rename to backend/src/lib.rs diff --git a/base2k/src/mat_znx_dft.rs b/backend/src/mat_znx_dft.rs similarity index 100% rename from base2k/src/mat_znx_dft.rs rename to backend/src/mat_znx_dft.rs diff --git a/base2k/src/mat_znx_dft_ops.rs b/backend/src/mat_znx_dft_ops.rs similarity index 97% rename from base2k/src/mat_znx_dft_ops.rs rename to backend/src/mat_znx_dft_ops.rs index 24be2e2..e73b782 100644 --- a/base2k/src/mat_znx_dft_ops.rs +++ b/backend/src/mat_znx_dft_ops.rs @@ -310,10 +310,11 @@ impl MatZnxDftOps for Module { } fn vmp_apply_add(&self, res: &mut R, a: &A, b: &B, scratch: &mut Scratch) - where - R: VecZnxDftToMut, - A: VecZnxDftToRef, - B: MatZnxDftToRef { + where + R: VecZnxDftToMut, + A: VecZnxDftToRef, + B: MatZnxDftToRef, + { let mut res: VecZnxDft<&mut [u8], _> = res.to_mut(); let a: VecZnxDft<&[u8], _> = a.to_ref(); let b: MatZnxDft<&[u8], _> = b.to_ref(); @@ -375,7 +376,7 @@ mod tests { #[test] fn vmp_prepare_row() { let module: Module = Module::::new(16); - let log_base2k: usize = 8; + let basek: usize = 8; let mat_rows: usize = 4; let mat_cols_in: usize = 2; let mat_cols_out: usize = 2; @@ -389,7 +390,7 @@ mod tests { for row_i in 0..mat_rows { let mut source: Source = Source::new([0u8; 32]); (0..mat_cols_out).for_each(|col_out| { - a.fill_uniform(log_base2k, col_out, mat_size, &mut source); + a.fill_uniform(basek, col_out, mat_size, &mut source); module.vec_znx_dft(&mut a_dft, col_out, &a, col_out); }); module.vmp_prepare_row(&mut mat, row_i, col_in, &a_dft); @@ -405,7 +406,7 @@ mod tests { let n: usize = 1 << log_n; let module: Module = Module::::new(n); - let log_base2k: usize = 15; + let basek: usize = 15; let a_size: usize = 5; let mat_size: usize = 6; let res_size: usize = 5; @@ -470,7 +471,7 @@ mod tests { let mut res_have: VecZnx> = module.new_vec_znx(res_cols, res_size); (0..mat_cols_out).for_each(|i| { module.vec_znx_idft_tmp_a(&mut c_big, i, &mut c_dft, i); - module.vec_znx_big_normalize(log_base2k, &mut res_have, i, &c_big, i, scratch.borrow()); + module.vec_znx_big_normalize(basek, &mut res_have, i, &c_big, i, scratch.borrow()); }); (0..mat_cols_out).for_each(|col_i| { @@ -478,7 +479,7 @@ mod tests { (0..a_cols).for_each(|i| { res_want_vi64[(i + 1) + (1 + i * mat_cols_out + col_i)] = 1; }); - res_have.decode_vec_i64(col_i, log_base2k, log_base2k * 3, &mut res_have_vi64); + res_have.decode_vec_i64(col_i, basek, basek * 3, &mut res_have_vi64); assert_eq!(res_have_vi64, res_want_vi64); }); }); diff --git a/base2k/src/module.rs b/backend/src/module.rs similarity index 100% rename from base2k/src/module.rs rename to backend/src/module.rs diff --git a/base2k/src/sampling.rs b/backend/src/sampling.rs similarity index 73% rename from base2k/src/sampling.rs rename to backend/src/sampling.rs index b4e1489..fd8c577 100644 --- a/base2k/src/sampling.rs +++ b/backend/src/sampling.rs @@ -4,16 +4,16 @@ use rand_distr::{Distribution, Normal}; use sampling::source::Source; pub trait FillUniform { - /// Fills the first `size` size with uniform values in \[-2^{log_base2k-1}, 2^{log_base2k-1}\] - fn fill_uniform(&mut self, log_base2k: usize, col_i: usize, size: usize, source: &mut Source); + /// Fills the first `size` size with uniform values in \[-2^{basek-1}, 2^{basek-1}\] + fn fill_uniform(&mut self, basek: usize, col_i: usize, size: usize, source: &mut Source); } pub trait FillDistF64 { fn fill_dist_f64>( &mut self, - log_base2k: usize, + basek: usize, col_i: usize, - log_k: usize, + k: usize, source: &mut Source, dist: D, bound: f64, @@ -21,12 +21,12 @@ pub trait FillDistF64 { } pub trait AddDistF64 { - /// Adds vector sampled according to the provided distribution, scaled by 2^{-log_k} and bounded to \[-bound, bound\]. + /// Adds vector sampled according to the provided distribution, scaled by 2^{-k} and bounded to \[-bound, bound\]. fn add_dist_f64>( &mut self, - log_base2k: usize, + basek: usize, col_i: usize, - log_k: usize, + k: usize, source: &mut Source, dist: D, bound: f64, @@ -34,21 +34,21 @@ pub trait AddDistF64 { } pub trait FillNormal { - fn fill_normal(&mut self, log_base2k: usize, col_i: usize, log_k: usize, source: &mut Source, sigma: f64, bound: f64); + fn fill_normal(&mut self, basek: usize, col_i: usize, k: usize, source: &mut Source, sigma: f64, bound: f64); } pub trait AddNormal { - /// Adds a discrete normal vector scaled by 2^{-log_k} with the provided standard deviation and bounded to \[-bound, bound\]. - fn add_normal(&mut self, log_base2k: usize, col_i: usize, log_k: usize, source: &mut Source, sigma: f64, bound: f64); + /// Adds a discrete normal vector scaled by 2^{-k} with the provided standard deviation and bounded to \[-bound, bound\]. + fn add_normal(&mut self, basek: usize, col_i: usize, k: usize, source: &mut Source, sigma: f64, bound: f64); } impl FillUniform for VecZnx where VecZnx: VecZnxToMut, { - fn fill_uniform(&mut self, log_base2k: usize, col_i: usize, size: usize, source: &mut Source) { + fn fill_uniform(&mut self, basek: usize, col_i: usize, size: usize, source: &mut Source) { let mut a: VecZnx<&mut [u8]> = self.to_mut(); - let base2k: u64 = 1 << log_base2k; + let base2k: u64 = 1 << basek; let mask: u64 = base2k - 1; let base2k_half: i64 = (base2k >> 1) as i64; (0..size).for_each(|j| { @@ -65,9 +65,9 @@ where { fn fill_dist_f64>( &mut self, - log_base2k: usize, + basek: usize, col_i: usize, - log_k: usize, + k: usize, source: &mut Source, dist: D, bound: f64, @@ -79,16 +79,16 @@ where (bound.log2().ceil() as i64) ); - let limb: usize = (log_k + log_base2k - 1) / log_base2k - 1; - let log_base2k_rem: usize = (limb + 1) * log_base2k - log_k; + let limb: usize = (k + basek - 1) / basek - 1; + let basek_rem: usize = (limb + 1) * basek - k; - if log_base2k_rem != 0 { + if basek_rem != 0 { a.at_mut(col_i, limb).iter_mut().for_each(|a| { let mut dist_f64: f64 = dist.sample(source); while dist_f64.abs() > bound { dist_f64 = dist.sample(source) } - *a = (dist_f64.round() as i64) << log_base2k_rem; + *a = (dist_f64.round() as i64) << basek_rem; }); } else { a.at_mut(col_i, limb).iter_mut().for_each(|a| { @@ -108,9 +108,9 @@ where { fn add_dist_f64>( &mut self, - log_base2k: usize, + basek: usize, col_i: usize, - log_k: usize, + k: usize, source: &mut Source, dist: D, bound: f64, @@ -122,16 +122,16 @@ where (bound.log2().ceil() as i64) ); - let limb: usize = (log_k + log_base2k - 1) / log_base2k - 1; - let log_base2k_rem: usize = (limb + 1) * log_base2k - log_k; + let limb: usize = (k + basek - 1) / basek - 1; + let basek_rem: usize = (limb + 1) * basek - k; - if log_base2k_rem != 0 { + if basek_rem != 0 { a.at_mut(col_i, limb).iter_mut().for_each(|a| { let mut dist_f64: f64 = dist.sample(source); while dist_f64.abs() > bound { dist_f64 = dist.sample(source) } - *a += (dist_f64.round() as i64) << log_base2k_rem; + *a += (dist_f64.round() as i64) << basek_rem; }); } else { a.at_mut(col_i, limb).iter_mut().for_each(|a| { @@ -149,11 +149,11 @@ impl FillNormal for VecZnx where VecZnx: VecZnxToMut, { - fn fill_normal(&mut self, log_base2k: usize, col_i: usize, log_k: usize, source: &mut Source, sigma: f64, bound: f64) { + fn fill_normal(&mut self, basek: usize, col_i: usize, k: usize, source: &mut Source, sigma: f64, bound: f64) { self.fill_dist_f64( - log_base2k, + basek, col_i, - log_k, + k, source, Normal::new(0.0, sigma).unwrap(), bound, @@ -165,11 +165,11 @@ impl AddNormal for VecZnx where VecZnx: VecZnxToMut, { - fn add_normal(&mut self, log_base2k: usize, col_i: usize, log_k: usize, source: &mut Source, sigma: f64, bound: f64) { + fn add_normal(&mut self, basek: usize, col_i: usize, k: usize, source: &mut Source, sigma: f64, bound: f64) { self.add_dist_f64( - log_base2k, + basek, col_i, - log_k, + k, source, Normal::new(0.0, sigma).unwrap(), bound, @@ -183,9 +183,9 @@ where { fn fill_dist_f64>( &mut self, - log_base2k: usize, + basek: usize, col_i: usize, - log_k: usize, + k: usize, source: &mut Source, dist: D, bound: f64, @@ -197,16 +197,16 @@ where (bound.log2().ceil() as i64) ); - let limb: usize = (log_k + log_base2k - 1) / log_base2k - 1; - let log_base2k_rem: usize = (limb + 1) * log_base2k - log_k; + let limb: usize = (k + basek - 1) / basek - 1; + let basek_rem: usize = (limb + 1) * basek - k; - if log_base2k_rem != 0 { + if basek_rem != 0 { a.at_mut(col_i, limb).iter_mut().for_each(|a| { let mut dist_f64: f64 = dist.sample(source); while dist_f64.abs() > bound { dist_f64 = dist.sample(source) } - *a = (dist_f64.round() as i64) << log_base2k_rem; + *a = (dist_f64.round() as i64) << basek_rem; }); } else { a.at_mut(col_i, limb).iter_mut().for_each(|a| { @@ -226,9 +226,9 @@ where { fn add_dist_f64>( &mut self, - log_base2k: usize, + basek: usize, col_i: usize, - log_k: usize, + k: usize, source: &mut Source, dist: D, bound: f64, @@ -240,16 +240,16 @@ where (bound.log2().ceil() as i64) ); - let limb: usize = (log_k + log_base2k - 1) / log_base2k - 1; - let log_base2k_rem: usize = (limb + 1) * log_base2k - log_k; + let limb: usize = (k + basek - 1) / basek - 1; + let basek_rem: usize = (limb + 1) * basek - k; - if log_base2k_rem != 0 { + if basek_rem != 0 { a.at_mut(col_i, limb).iter_mut().for_each(|a| { let mut dist_f64: f64 = dist.sample(source); while dist_f64.abs() > bound { dist_f64 = dist.sample(source) } - *a += (dist_f64.round() as i64) << log_base2k_rem; + *a += (dist_f64.round() as i64) << basek_rem; }); } else { a.at_mut(col_i, limb).iter_mut().for_each(|a| { @@ -267,11 +267,11 @@ impl FillNormal for VecZnxBig where VecZnxBig: VecZnxBigToMut, { - fn fill_normal(&mut self, log_base2k: usize, col_i: usize, log_k: usize, source: &mut Source, sigma: f64, bound: f64) { + fn fill_normal(&mut self, basek: usize, col_i: usize, k: usize, source: &mut Source, sigma: f64, bound: f64) { self.fill_dist_f64( - log_base2k, + basek, col_i, - log_k, + k, source, Normal::new(0.0, sigma).unwrap(), bound, @@ -283,11 +283,11 @@ impl AddNormal for VecZnxBig where VecZnxBig: VecZnxBigToMut, { - fn add_normal(&mut self, log_base2k: usize, col_i: usize, log_k: usize, source: &mut Source, sigma: f64, bound: f64) { + fn add_normal(&mut self, basek: usize, col_i: usize, k: usize, source: &mut Source, sigma: f64, bound: f64) { self.add_dist_f64( - log_base2k, + basek, col_i, - log_k, + k, source, Normal::new(0.0, sigma).unwrap(), bound, @@ -307,7 +307,7 @@ mod tests { fn vec_znx_fill_uniform() { let n: usize = 4096; let module: Module = Module::::new(n); - let log_base2k: usize = 17; + let basek: usize = 17; let size: usize = 5; let mut source: Source = Source::new([0u8; 32]); let cols: usize = 2; @@ -315,14 +315,14 @@ mod tests { let one_12_sqrt: f64 = 0.28867513459481287; (0..cols).for_each(|col_i| { let mut a: VecZnx<_> = module.new_vec_znx(cols, size); - a.fill_uniform(log_base2k, col_i, size, &mut source); + a.fill_uniform(basek, col_i, size, &mut source); (0..cols).for_each(|col_j| { if col_j != col_i { (0..size).for_each(|limb_i| { assert_eq!(a.at(col_j, limb_i), zero); }) } else { - let std: f64 = a.std(col_i, log_base2k); + let std: f64 = a.std(col_i, basek); assert!( (std - one_12_sqrt).abs() < 0.01, "std={} ~!= {}", @@ -338,25 +338,25 @@ mod tests { fn vec_znx_add_normal() { let n: usize = 4096; let module: Module = Module::::new(n); - let log_base2k: usize = 17; - let log_k: usize = 2 * 17; + let basek: usize = 17; + let k: usize = 2 * 17; let size: usize = 5; let sigma: f64 = 3.2; let bound: f64 = 6.0 * sigma; let mut source: Source = Source::new([0u8; 32]); let cols: usize = 2; let zero: Vec = vec![0; n]; - let k_f64: f64 = (1u64 << log_k as u64) as f64; + let k_f64: f64 = (1u64 << k as u64) as f64; (0..cols).for_each(|col_i| { let mut a: VecZnx<_> = module.new_vec_znx(cols, size); - a.add_normal(log_base2k, col_i, log_k, &mut source, sigma, bound); + a.add_normal(basek, col_i, k, &mut source, sigma, bound); (0..cols).for_each(|col_j| { if col_j != col_i { (0..size).for_each(|limb_i| { assert_eq!(a.at(col_j, limb_i), zero); }) } else { - let std: f64 = a.std(col_i, log_base2k) * k_f64; + let std: f64 = a.std(col_i, basek) * k_f64; assert!((std - sigma).abs() < 0.1, "std={} ~!= {}", std, sigma); } }) diff --git a/base2k/src/scalar_znx.rs b/backend/src/scalar_znx.rs similarity index 100% rename from base2k/src/scalar_znx.rs rename to backend/src/scalar_znx.rs diff --git a/base2k/src/scalar_znx_dft.rs b/backend/src/scalar_znx_dft.rs similarity index 100% rename from base2k/src/scalar_znx_dft.rs rename to backend/src/scalar_znx_dft.rs diff --git a/base2k/src/scalar_znx_dft_ops.rs b/backend/src/scalar_znx_dft_ops.rs similarity index 100% rename from base2k/src/scalar_znx_dft_ops.rs rename to backend/src/scalar_znx_dft_ops.rs diff --git a/base2k/src/stats.rs b/backend/src/stats.rs similarity index 80% rename from base2k/src/stats.rs rename to backend/src/stats.rs index 8db40f2..f5aa26a 100644 --- a/base2k/src/stats.rs +++ b/backend/src/stats.rs @@ -1,32 +1,32 @@ -use crate::znx_base::ZnxInfos; -use crate::{Decoding, VecZnx}; -use rug::Float; -use rug::float::Round; -use rug::ops::{AddAssignRound, DivAssignRound, SubAssignRound}; - -pub trait Stats { - /// Returns the standard devaition of the i-th polynomial. - fn std(&self, col_i: usize, log_base2k: usize) -> f64; -} - -impl> Stats for VecZnx { - fn std(&self, col_i: usize, log_base2k: usize) -> f64 { - let prec: u32 = (self.size() * log_base2k) as u32; - let mut data: Vec = (0..self.n()).map(|_| Float::with_val(prec, 0)).collect(); - self.decode_vec_float(col_i, log_base2k, &mut data); - // std = sqrt(sum((xi - avg)^2) / n) - let mut avg: Float = Float::with_val(prec, 0); - data.iter().for_each(|x| { - avg.add_assign_round(x, Round::Nearest); - }); - avg.div_assign_round(Float::with_val(prec, data.len()), Round::Nearest); - data.iter_mut().for_each(|x| { - x.sub_assign_round(&avg, Round::Nearest); - }); - let mut std: Float = Float::with_val(prec, 0); - data.iter().for_each(|x| std += x * x); - std.div_assign_round(Float::with_val(prec, data.len()), Round::Nearest); - std = std.sqrt(); - std.to_f64() - } -} +use crate::znx_base::ZnxInfos; +use crate::{Decoding, VecZnx}; +use rug::Float; +use rug::float::Round; +use rug::ops::{AddAssignRound, DivAssignRound, SubAssignRound}; + +pub trait Stats { + /// Returns the standard devaition of the i-th polynomial. + fn std(&self, col_i: usize, basek: usize) -> f64; +} + +impl> Stats for VecZnx { + fn std(&self, col_i: usize, basek: usize) -> f64 { + let prec: u32 = (self.size() * basek) as u32; + let mut data: Vec = (0..self.n()).map(|_| Float::with_val(prec, 0)).collect(); + self.decode_vec_float(col_i, basek, &mut data); + // std = sqrt(sum((xi - avg)^2) / n) + let mut avg: Float = Float::with_val(prec, 0); + data.iter().for_each(|x| { + avg.add_assign_round(x, Round::Nearest); + }); + avg.div_assign_round(Float::with_val(prec, data.len()), Round::Nearest); + data.iter_mut().for_each(|x| { + x.sub_assign_round(&avg, Round::Nearest); + }); + let mut std: Float = Float::with_val(prec, 0); + data.iter().for_each(|x| std += x * x); + std.div_assign_round(Float::with_val(prec, data.len()), Round::Nearest); + std = std.sqrt(); + std.to_f64() + } +} diff --git a/base2k/src/vec_znx.rs b/backend/src/vec_znx.rs similarity index 83% rename from base2k/src/vec_znx.rs rename to backend/src/vec_znx.rs index d4b0b9c..950fae9 100644 --- a/base2k/src/vec_znx.rs +++ b/backend/src/vec_znx.rs @@ -1,6 +1,9 @@ +use itertools::izip; + use crate::DataView; use crate::DataViewMut; use crate::ScalarZnx; +use crate::Scratch; use crate::ZnxSliceSize; use crate::ZnxZero; use crate::alloc_aligned; @@ -68,29 +71,66 @@ impl> ZnxView for VecZnx { type Scalar = i64; } +impl> VecZnx { + pub fn rsh_scratch_space(n: usize) -> usize { + n * std::mem::size_of::() + } +} + impl + AsRef<[u8]>> VecZnx { /// Truncates the precision of the [VecZnx] by k bits. /// /// # Arguments /// - /// * `log_base2k`: the base two logarithm of the coefficients decomposition. + /// * `basek`: the base two logarithm of the coefficients decomposition. /// * `k`: the number of bits of precision to drop. - pub fn trunc_pow2(&mut self, log_base2k: usize, k: usize, col: usize) { + pub fn trunc_pow2(&mut self, basek: usize, k: usize, col: usize) { if k == 0 { return; } - self.size -= k / log_base2k; + self.size -= k / basek; - let k_rem: usize = k % log_base2k; + let k_rem: usize = k % basek; if k_rem != 0 { - let mask: i64 = ((1 << (log_base2k - k_rem - 1)) - 1) << k_rem; + let mask: i64 = ((1 << (basek - k_rem - 1)) - 1) << k_rem; self.at_mut(col, self.size() - 1) .iter_mut() .for_each(|x: &mut i64| *x &= mask) } } + + pub fn rsh(&mut self, basek: usize, k: usize, scratch: &mut Scratch) { + let n: usize = self.n(); + let cols: usize = self.cols(); + let size: usize = self.size(); + let steps: usize = k / basek; + + self.raw_mut().rotate_right(n * steps * cols); + (0..cols).for_each(|i| { + (0..steps).for_each(|j| { + self.zero_at(i, j); + }) + }); + + let k_rem: usize = k % basek; + + if k_rem != 0 { + let (carry, _) = scratch.tmp_slice::(n); + let shift = i64::BITS as usize - k_rem; + (0..cols).for_each(|i| { + carry.fill(0); + (steps..size).for_each(|j| { + izip!(carry.iter_mut(), self.at_mut(i, j).iter_mut()).for_each(|(ci, xi)| { + *xi += *ci << basek; + *ci = (*xi << shift) >> shift; + *xi = (*xi - *ci) >> k_rem; + }); + }); + }) + } + } } impl>> VecZnx { @@ -165,7 +205,7 @@ fn normalize_tmp_bytes(n: usize) -> usize { } #[allow(dead_code)] -fn normalize + AsRef<[u8]>>(log_base2k: usize, a: &mut VecZnx, a_col: usize, tmp_bytes: &mut [u8]) { +fn normalize + AsRef<[u8]>>(basek: usize, a: &mut VecZnx, a_col: usize, tmp_bytes: &mut [u8]) { let n: usize = a.n(); debug_assert!( @@ -187,7 +227,7 @@ fn normalize + AsRef<[u8]>>(log_base2k: usize, a: &mut VecZnx, (0..a.size()).rev().for_each(|i| { znx::znx_normalize( n as u64, - log_base2k as u64, + basek as u64, a.at_mut_ptr(a_col, i), carry_i64.as_mut_ptr(), a.at_mut_ptr(a_col, i), diff --git a/base2k/src/vec_znx_big.rs b/backend/src/vec_znx_big.rs similarity index 100% rename from base2k/src/vec_znx_big.rs rename to backend/src/vec_znx_big.rs diff --git a/base2k/src/vec_znx_big_ops.rs b/backend/src/vec_znx_big_ops.rs similarity index 99% rename from base2k/src/vec_znx_big_ops.rs rename to backend/src/vec_znx_big_ops.rs index 8208c97..d23dc22 100644 --- a/base2k/src/vec_znx_big_ops.rs +++ b/backend/src/vec_znx_big_ops.rs @@ -123,11 +123,11 @@ pub trait VecZnxBigOps { /// /// # Arguments /// - /// * `log_base2k`: normalization basis. + /// * `basek`: normalization basis. /// * `tmp_bytes`: scratch space of size at least [VecZnxBigOps::vec_znx_big_normalize]. fn vec_znx_big_normalize( &self, - log_base2k: usize, + basek: usize, res: &mut R, res_col: usize, a: &A, @@ -532,7 +532,7 @@ impl VecZnxBigOps for Module { fn vec_znx_big_normalize( &self, - log_base2k: usize, + basek: usize, res: &mut R, res_col: usize, a: &A, @@ -561,7 +561,7 @@ impl VecZnxBigOps for Module { unsafe { vec_znx::vec_znx_normalize_base2k( self.ptr, - log_base2k as u64, + basek as u64, res.at_mut_ptr(res_col, 0), res.size() as u64, res.sl() as u64, diff --git a/base2k/src/vec_znx_dft.rs b/backend/src/vec_znx_dft.rs similarity index 100% rename from base2k/src/vec_znx_dft.rs rename to backend/src/vec_znx_dft.rs diff --git a/base2k/src/vec_znx_dft_ops.rs b/backend/src/vec_znx_dft_ops.rs similarity index 100% rename from base2k/src/vec_znx_dft_ops.rs rename to backend/src/vec_znx_dft_ops.rs diff --git a/base2k/src/vec_znx_ops.rs b/backend/src/vec_znx_ops.rs similarity index 97% rename from base2k/src/vec_znx_ops.rs rename to backend/src/vec_znx_ops.rs index b97e6b7..90321a5 100644 --- a/base2k/src/vec_znx_ops.rs +++ b/backend/src/vec_znx_ops.rs @@ -35,13 +35,13 @@ pub trait VecZnxAlloc { pub trait VecZnxOps { /// Normalizes the selected column of `a` and stores the result into the selected column of `res`. - fn vec_znx_normalize(&self, log_base2k: usize, res: &mut R, res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch) + fn vec_znx_normalize(&self, basek: usize, res: &mut R, res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch) where R: VecZnxToMut, A: VecZnxToRef; /// Normalizes the selected column of `a`. - fn vec_znx_normalize_inplace(&self, log_base2k: usize, a: &mut A, a_col: usize, scratch: &mut Scratch) + fn vec_znx_normalize_inplace(&self, basek: usize, a: &mut A, a_col: usize, scratch: &mut Scratch) where A: VecZnxToMut; @@ -174,7 +174,7 @@ impl VecZnxAlloc for Module { } impl VecZnxOps for Module { - fn vec_znx_normalize(&self, log_base2k: usize, res: &mut R, res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch) + fn vec_znx_normalize(&self, basek: usize, res: &mut R, res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch) where R: VecZnxToMut, A: VecZnxToRef, @@ -193,7 +193,7 @@ impl VecZnxOps for Module { unsafe { vec_znx::vec_znx_normalize_base2k( self.ptr, - log_base2k as u64, + basek as u64, res.at_mut_ptr(res_col, 0), res.size() as u64, res.sl() as u64, @@ -205,7 +205,7 @@ impl VecZnxOps for Module { } } - fn vec_znx_normalize_inplace(&self, log_base2k: usize, a: &mut A, a_col: usize, scratch: &mut Scratch) + fn vec_znx_normalize_inplace(&self, basek: usize, a: &mut A, a_col: usize, scratch: &mut Scratch) where A: VecZnxToMut, { @@ -221,7 +221,7 @@ impl VecZnxOps for Module { unsafe { vec_znx::vec_znx_normalize_base2k( self.ptr, - log_base2k as u64, + basek as u64, a.at_mut_ptr(a_col, 0), a.size() as u64, a.sl() as u64, diff --git a/base2k/src/znx_base.rs b/backend/src/znx_base.rs similarity index 95% rename from base2k/src/znx_base.rs rename to backend/src/znx_base.rs index f618446..daa313d 100644 --- a/base2k/src/znx_base.rs +++ b/backend/src/znx_base.rs @@ -150,7 +150,7 @@ impl Integer for i128 { } //(Jay)Note: `rsh` impl. ignores the column -pub fn rsh(k: usize, log_base2k: usize, a: &mut V, _a_col: usize, scratch: &mut Scratch) +pub fn rsh(k: usize, basek: usize, a: &mut V, _a_col: usize, scratch: &mut Scratch) where V::Scalar: From + Integer + Zero, { @@ -159,7 +159,7 @@ where let cols: usize = a.cols(); let size: usize = a.size(); - let steps: usize = k / log_base2k; + let steps: usize = k / basek; a.raw_mut().rotate_right(n * steps * cols); (0..cols).for_each(|i| { @@ -168,7 +168,7 @@ where }) }); - let k_rem: usize = k % log_base2k; + let k_rem: usize = k % basek; if k_rem != 0 { let (carry, _) = scratch.tmp_slice::(rsh_tmp_bytes::(n)); @@ -177,14 +177,14 @@ where std::ptr::write_bytes(carry.as_mut_ptr(), 0, n * size_of::()); } - let log_base2k_t = V::Scalar::from(log_base2k); + let basek_t = V::Scalar::from(basek); let shift = V::Scalar::from(V::Scalar::BITS as usize - k_rem); let k_rem_t = V::Scalar::from(k_rem); (0..cols).for_each(|i| { (steps..size).for_each(|j| { izip!(carry.iter_mut(), a.at_mut(i, j).iter_mut()).for_each(|(ci, xi)| { - *xi += *ci << log_base2k_t; + *xi += *ci << basek_t; *ci = (*xi << shift) >> shift; *xi = (*xi - *ci) >> k_rem_t; }); diff --git a/core/Cargo.toml b/core/Cargo.toml index a54bd5a..22b8f81 100644 --- a/core/Cargo.toml +++ b/core/Cargo.toml @@ -1,12 +1,12 @@ [package] -name = "rlwe" +name = "core" version = "0.1.0" edition = "2024" [dependencies] rug = {workspace = true} criterion = {workspace = true} -base2k = {path="../base2k"} +backend = {path="../backend"} sampling = {path="../sampling"} rand_distr = {workspace = true} itertools = {workspace = true} diff --git a/core/benches/external_product_glwe_fft64.rs b/core/benches/external_product_glwe_fft64.rs index 1739211..5e7e07c 100644 --- a/core/benches/external_product_glwe_fft64.rs +++ b/core/benches/external_product_glwe_fft64.rs @@ -1,4 +1,4 @@ -use base2k::{FFT64, Module, ScalarZnxAlloc, ScratchOwned}; +use backend::{Module, ScalarZnx, ScalarZnxAlloc, ScratchOwned, FFT64}; use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main}; use rlwe::{ elem::Infos, @@ -32,10 +32,10 @@ fn bench_external_product_glwe_fft64(c: &mut Criterion) { let rows: usize = (p.k_ct_in + p.basek - 1) / p.basek; let sigma: f64 = 3.2; - let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); - let mut ct_rlwe_in: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_in, rank); - let mut ct_rlwe_out: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_out, rank); - let pt_rgsw: base2k::ScalarZnx> = module.new_scalar_znx(1); + let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); + let mut ct_rlwe_in: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_in, rank); + let mut ct_rlwe_out: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_out, rank); + let pt_rgsw: ScalarZnx> = module.new_scalar_znx(1); let mut scratch = ScratchOwned::new( GGSWCiphertext::encrypt_sk_scratch_space(&module, rank, ct_rgsw.size()) @@ -53,9 +53,9 @@ fn bench_external_product_glwe_fft64(c: &mut Criterion) { let mut source_xe = Source::new([0u8; 32]); let mut source_xa = Source::new([0u8; 32]); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); ct_rgsw.encrypt_sk( @@ -127,9 +127,9 @@ fn bench_external_product_glwe_inplace_fft64(c: &mut Criterion) { let rows: usize = (p.k_ct + p.basek - 1) / p.basek; let sigma: f64 = 3.2; - let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); - let mut ct_rlwe: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_glwe, rank); - let pt_rgsw: base2k::ScalarZnx> = module.new_scalar_znx(1); + let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); + let mut ct_rlwe: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_glwe, rank); + let pt_rgsw: ScalarZnx> = module.new_scalar_znx(1); let mut scratch = ScratchOwned::new( GGSWCiphertext::encrypt_sk_scratch_space(&module, rank, ct_rgsw.size()) @@ -141,9 +141,9 @@ fn bench_external_product_glwe_inplace_fft64(c: &mut Criterion) { let mut source_xe = Source::new([0u8; 32]); let mut source_xa = Source::new([0u8; 32]); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); ct_rgsw.encrypt_sk( diff --git a/core/benches/keyswitch_glwe_fft64.rs b/core/benches/keyswitch_glwe_fft64.rs index 1c1b7f8..3dae4f8 100644 --- a/core/benches/keyswitch_glwe_fft64.rs +++ b/core/benches/keyswitch_glwe_fft64.rs @@ -1,4 +1,4 @@ -use base2k::{FFT64, Module, ScratchOwned}; +use backend::{FFT64, Module, ScratchOwned}; use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main}; use rlwe::{ elem::Infos, @@ -34,9 +34,9 @@ fn bench_keyswitch_glwe_fft64(c: &mut Criterion) { let rows: usize = (p.k_ct_in + p.basek - 1) / p.basek; let sigma: f64 = 3.2; - let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k_grlwe, rows, rank_in, rank_out); - let mut ct_in: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_rlwe_in, rank_in); - let mut ct_out: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_rlwe_out, rank_out); + let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k_grlwe, rows, rank_in, rank_out); + let mut ct_in: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_rlwe_in, rank_in); + let mut ct_out: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_rlwe_out, rank_out); let mut scratch = ScratchOwned::new( GLWESwitchingKey::encrypt_sk_scratch_space(&module, rank_out, ksk.size()) @@ -55,14 +55,14 @@ fn bench_keyswitch_glwe_fft64(c: &mut Criterion) { let mut source_xe = Source::new([0u8; 32]); let mut source_xa = Source::new([0u8; 32]); - let mut sk_in: SecretKey> = SecretKey::new(&module, rank_in); + let mut sk_in: SecretKey> = SecretKey::alloc(&module, rank_in); sk_in.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_in); + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_in); sk_in_dft.dft(&module, &sk_in); - let mut sk_out: SecretKey> = SecretKey::new(&module, rank_out); + let mut sk_out: SecretKey> = SecretKey::alloc(&module, rank_out); sk_out.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out); + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out); sk_out_dft.dft(&module, &sk_out); ksk.encrypt_sk( @@ -135,8 +135,8 @@ fn bench_keyswitch_glwe_inplace_fft64(c: &mut Criterion) { let rows: usize = (p.k_ct + p.basek - 1) / p.basek; let sigma: f64 = 3.2; - let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank, rank); - let mut ct: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct, rank); + let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank, rank); + let mut ct: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct, rank); let mut scratch = ScratchOwned::new( GLWESwitchingKey::encrypt_sk_scratch_space(&module, rank, ksk.size()) @@ -148,14 +148,14 @@ fn bench_keyswitch_glwe_inplace_fft64(c: &mut Criterion) { let mut source_xe: Source = Source::new([0u8; 32]); let mut source_xa: Source = Source::new([0u8; 32]); - let mut sk_in: SecretKey> = SecretKey::new(&module, rank); + let mut sk_in: SecretKey> = SecretKey::alloc(&module, rank); sk_in.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_in_dft.dft(&module, &sk_in); - let mut sk_out: SecretKey> = SecretKey::new(&module, rank); + let mut sk_out: SecretKey> = SecretKey::alloc(&module, rank); sk_out.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_out_dft.dft(&module, &sk_out); ksk.encrypt_sk( diff --git a/core/src/automorphism.rs b/core/src/automorphism.rs index 8dca7ec..a120594 100644 --- a/core/src/automorphism.rs +++ b/core/src/automorphism.rs @@ -1,4 +1,4 @@ -use base2k::{ +use backend::{ Backend, FFT64, MatZnxDft, MatZnxDftOps, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx, ScalarZnxDftOps, ScalarZnxOps, ScalarZnxToRef, Scratch, VecZnx, VecZnxBigAlloc, VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, VecZnxDftToRef, VecZnxOps, ZnxZero, @@ -21,9 +21,9 @@ pub struct AutomorphismKey { } impl AutomorphismKey, FFT64> { - pub fn new(module: &Module, basek: usize, k: usize, rows: usize, rank: usize) -> Self { + pub fn alloc(module: &Module, basek: usize, k: usize, rows: usize, rank: usize) -> Self { AutomorphismKey { - key: GLWESwitchingKey::new(module, basek, k, rows, rank, rank), + key: GLWESwitchingKey::alloc(module, basek, k, rows, rank, rank), p: 0, } } @@ -106,12 +106,12 @@ where } impl AutomorphismKey, FFT64> { - pub fn encrypt_sk_scratch_space(module: &Module, rank: usize, size: usize) -> usize { - GGLWECiphertext::encrypt_sk_scratch_space(module, rank, size) + pub fn generate_from_sk_scratch_space(module: &Module, rank: usize, size: usize) -> usize { + GGLWECiphertext::generate_from_sk_scratch_space(module, rank, size) } - pub fn encrypt_pk_scratch_space(module: &Module, rank: usize, pk_size: usize) -> usize { - GGLWECiphertext::encrypt_pk_scratch_space(module, rank, pk_size) + pub fn generate_from_pk_scratch_space(module: &Module, rank: usize, pk_size: usize) -> usize { + GGLWECiphertext::generate_from_pk_scratch_space(module, rank, pk_size) } pub fn keyswitch_scratch_space( @@ -170,7 +170,7 @@ impl AutomorphismKey where MatZnxDft: MatZnxDftToMut + MatZnxDftToRef, { - pub fn encrypt_sk( + pub fn generate_from_sk( &mut self, module: &Module, p: i64, @@ -228,7 +228,7 @@ where module: &Module, lhs: &AutomorphismKey, rhs: &AutomorphismKey, - scratch: &mut base2k::Scratch, + scratch: &mut Scratch, ) where MatZnxDft: MatZnxDftToRef, MatZnxDft: MatZnxDftToRef, @@ -341,7 +341,7 @@ where module: &Module, lhs: &AutomorphismKey, rhs: &GLWESwitchingKey, - scratch: &mut base2k::Scratch, + scratch: &mut Scratch, ) where MatZnxDft: MatZnxDftToRef, MatZnxDft: MatZnxDftToRef, @@ -352,12 +352,12 @@ where pub fn keyswitch_inplace( &mut self, module: &Module, - rhs: &GLWESwitchingKey, - scratch: &mut base2k::Scratch, + rhs: &AutomorphismKey, + scratch: &mut Scratch, ) where MatZnxDft: MatZnxDftToRef, { - self.key.keyswitch_inplace(module, &rhs, scratch); + self.key.keyswitch_inplace(module, &rhs.key, scratch); } pub fn external_product( diff --git a/core/src/elem.rs b/core/src/elem.rs index 66cb1d0..554b743 100644 --- a/core/src/elem.rs +++ b/core/src/elem.rs @@ -1,4 +1,4 @@ -use base2k::{Backend, Module, VecZnxDftToMut, VecZnxDftToRef, ZnxInfos}; +use backend::{Backend, Module, VecZnxDftToMut, VecZnxDftToRef, ZnxInfos}; use crate::utils::derive_size; diff --git a/core/src/gglwe_ciphertext.rs b/core/src/gglwe_ciphertext.rs index f8983c8..d5621c9 100644 --- a/core/src/gglwe_ciphertext.rs +++ b/core/src/gglwe_ciphertext.rs @@ -1,4 +1,4 @@ -use base2k::{ +use backend::{ Backend, FFT64, MatZnxDft, MatZnxDftAlloc, MatZnxDftOps, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx, ScalarZnxDft, ScalarZnxDftToRef, ScalarZnxToRef, Scratch, VecZnxAlloc, VecZnxDftAlloc, VecZnxDftToMut, VecZnxDftToRef, VecZnxOps, ZnxInfos, ZnxZero, @@ -21,7 +21,7 @@ pub struct GGLWECiphertext { } impl GGLWECiphertext, B> { - pub fn new(module: &Module, basek: usize, k: usize, rows: usize, rank_in: usize, rank_out: usize) -> Self { + pub fn alloc(module: &Module, basek: usize, k: usize, rows: usize, rank_in: usize, rank_out: usize) -> Self { Self { data: module.new_mat_znx_dft(rows, rank_in, rank_out + 1, derive_size(basek, k)), basek: basek, @@ -79,14 +79,14 @@ where } impl GGLWECiphertext, FFT64> { - pub fn encrypt_sk_scratch_space(module: &Module, rank: usize, size: usize) -> usize { + pub fn generate_from_sk_scratch_space(module: &Module, rank: usize, size: usize) -> usize { GLWECiphertext::encrypt_sk_scratch_space(module, size) + module.bytes_of_vec_znx(rank + 1, size) + module.bytes_of_vec_znx(1, size) + module.bytes_of_vec_znx_dft(rank + 1, size) } - pub fn encrypt_pk_scratch_space(_module: &Module, _rank: usize, _pk_size: usize) -> usize { + pub fn generate_from_pk_scratch_space(_module: &Module, _rank: usize, _pk_size: usize) -> usize { unimplemented!() } } @@ -95,7 +95,7 @@ impl GGLWECiphertext where MatZnxDft: MatZnxDftToMut + ZnxInfos, { - pub fn encrypt_sk( + pub fn generate_from_sk( &mut self, module: &Module, pt: &ScalarZnx, diff --git a/core/src/ggsw_ciphertext.rs b/core/src/ggsw_ciphertext.rs index 8955b7a..fdbc225 100644 --- a/core/src/ggsw_ciphertext.rs +++ b/core/src/ggsw_ciphertext.rs @@ -1,4 +1,4 @@ -use base2k::{ +use backend::{ Backend, FFT64, MatZnxDft, MatZnxDftAlloc, MatZnxDftOps, MatZnxDftScratch, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx, ScalarZnxDft, ScalarZnxDftToRef, ScalarZnxToRef, Scratch, VecZnx, VecZnxAlloc, VecZnxBigAlloc, VecZnxBigOps, VecZnxBigScratch, VecZnxDft, VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, VecZnxDftToRef, VecZnxOps, VecZnxToMut, @@ -25,7 +25,7 @@ pub struct GGSWCiphertext { } impl GGSWCiphertext, B> { - pub fn new(module: &Module, basek: usize, k: usize, rows: usize, rank: usize) -> Self { + pub fn alloc(module: &Module, basek: usize, k: usize, rows: usize, rank: usize) -> Self { Self { data: module.new_mat_znx_dft(rows, rank + 1, rank + 1, derive_size(basek, k)), basek: basek, diff --git a/core/src/glwe_ciphertext.rs b/core/src/glwe_ciphertext.rs index e319d21..155eca4 100644 --- a/core/src/glwe_ciphertext.rs +++ b/core/src/glwe_ciphertext.rs @@ -1,8 +1,8 @@ -use base2k::{ +use backend::{ AddNormal, Backend, FFT64, FillUniform, MatZnxDft, MatZnxDftOps, MatZnxDftScratch, MatZnxDftToRef, Module, ScalarZnxAlloc, ScalarZnxDft, ScalarZnxDftAlloc, ScalarZnxDftOps, ScalarZnxDftToRef, Scratch, VecZnx, VecZnxAlloc, VecZnxBig, VecZnxBigAlloc, VecZnxBigOps, VecZnxBigScratch, VecZnxDft, VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, VecZnxDftToRef, VecZnxOps, - VecZnxToMut, VecZnxToRef, ZnxInfos, ZnxZero, + VecZnxToMut, VecZnxToRef, ZnxInfos, ZnxZero, copy_vec_znx_from, }; use sampling::source::Source; @@ -25,7 +25,7 @@ pub struct GLWECiphertext { } impl GLWECiphertext> { - pub fn new(module: &Module, basek: usize, k: usize, rank: usize) -> Self { + pub fn alloc(module: &Module, basek: usize, k: usize, rank: usize) -> Self { Self { data: module.new_vec_znx(rank + 1, derive_size(basek, k)), basek, @@ -281,6 +281,21 @@ where self.encrypt_pk_private(module, None, pk, source_xu, source_xe, sigma, scratch); } + pub fn copy(&mut self, other: &GLWECiphertext) + where + VecZnx: VecZnxToRef, + { + copy_vec_znx_from(&mut self.data.to_mut(), &other.to_ref()); + self.k = other.k; + self.basek = other.basek; + } + + pub fn rsh(&mut self, k: usize, scratch: &mut Scratch) { + let basek: usize = self.basek(); + let mut self_mut: VecZnx<&mut [u8]> = self.data.to_mut(); + self_mut.rsh(basek, k, scratch); + } + pub fn automorphism( &mut self, module: &Module, @@ -311,6 +326,33 @@ where }) } + pub fn automorphism_add( + &mut self, + module: &Module, + lhs: &GLWECiphertext, + rhs: &AutomorphismKey, + scratch: &mut Scratch, + ) where + VecZnx: VecZnxToRef, + MatZnxDft: MatZnxDftToRef, + { + Self::keyswitch_private(self, true, rhs.p(), module, lhs, &rhs.key, scratch); + } + + pub fn automorphism_add_inplace( + &mut self, + module: &Module, + rhs: &AutomorphismKey, + scratch: &mut Scratch, + ) where + MatZnxDft: MatZnxDftToRef, + { + unsafe { + let self_ptr: *mut GLWECiphertext = self as *mut GLWECiphertext; + Self::keyswitch_private(self, true, rhs.p(), module, &*self_ptr, &rhs.key, scratch); + } + } + pub(crate) fn keyswitch_from_fourier( &mut self, module: &Module, @@ -379,6 +421,21 @@ where ) where VecZnx: VecZnxToRef, MatZnxDft: MatZnxDftToRef, + { + Self::keyswitch_private(self, false, 0, module, lhs, rhs, scratch); + } + + pub(crate) fn keyswitch_private( + &mut self, + add_self: bool, + apply_auto: i64, + module: &Module, + lhs: &GLWECiphertext, + rhs: &GLWESwitchingKey, + scratch: &mut Scratch, + ) where + VecZnx: VecZnxToRef, + MatZnxDft: MatZnxDftToRef, { let basek: usize = self.basek(); @@ -422,6 +479,13 @@ where module.vec_znx_big_add_small_inplace(&mut res_big, 0, lhs, 0); (0..cols_out).for_each(|i| { + if apply_auto != 0 { + module.vec_znx_big_automorphism_inplace(apply_auto, &mut res_big, i); + } + + if add_self { + module.vec_znx_big_add_small_inplace(&mut res_big, i, lhs, i); + } module.vec_znx_big_normalize(basek, self, i, &res_big, i, scratch1); }); } @@ -520,8 +584,8 @@ where } } - let log_base2k: usize = self.basek(); - let log_k: usize = self.k(); + let basek: usize = self.basek(); + let k: usize = self.k(); let size: usize = self.size(); let cols: usize = self.rank() + 1; @@ -535,7 +599,7 @@ where let (mut ci_dft, scratch_2) = scratch_1.tmp_vec_znx_dft(module, 1, size); // c[i] = uniform - self.data.fill_uniform(log_base2k, i, size, source_xa); + self.data.fill_uniform(basek, i, size, source_xa); // c[i] = norm(IDFT(DFT(c[i]) * DFT(s[i]))) module.vec_znx_dft(&mut ci_dft, 0, self, i); @@ -543,7 +607,7 @@ where let ci_big: VecZnxBig<&mut [u8], FFT64> = module.vec_znx_idft_consume(ci_dft); // use c[0] as buffer, which is overwritten later by the normalization step - module.vec_znx_big_normalize(log_base2k, self, 0, &ci_big, 0, scratch_2); + module.vec_znx_big_normalize(basek, self, 0, &ci_big, 0, scratch_2); // c0_tmp = -c[i] * s[i] (use c[0] as buffer) module.vec_znx_sub_ab_inplace(&mut c0_big, 0, self, 0); @@ -552,14 +616,14 @@ where if let Some((pt, col)) = pt { if i == col { module.vec_znx_add_inplace(self, i, pt, 0); - module.vec_znx_normalize_inplace(log_base2k, self, i, scratch_2); + module.vec_znx_normalize_inplace(basek, self, i, scratch_2); } } }); } // c[0] += e - c0_big.add_normal(log_base2k, 0, log_k, source_xe, sigma, sigma * SIX_SIGMA); + c0_big.add_normal(basek, 0, k, source_xe, sigma, sigma * SIX_SIGMA); // c[0] += m if col = 0 if let Some((pt, col)) = pt { @@ -569,7 +633,7 @@ where } // c[0] = norm(c[0]) - module.vec_znx_normalize(log_base2k, self, 0, &c0_big, 0, scratch_1); + module.vec_znx_normalize(basek, self, 0, &c0_big, 0, scratch_1); } pub(crate) fn encrypt_pk_private( @@ -597,7 +661,7 @@ where } } - let log_base2k: usize = pk.basek(); + let basek: usize = pk.basek(); let size_pk: usize = pk.size(); let cols: usize = self.rank() + 1; @@ -629,7 +693,7 @@ where let mut ci_big = module.vec_znx_idft_consume(ci_dft); // ci_big = u * pk[i] + e - ci_big.add_normal(log_base2k, 0, pk.k(), source_xe, sigma, sigma * SIX_SIGMA); + ci_big.add_normal(basek, 0, pk.k(), source_xe, sigma, sigma * SIX_SIGMA); // ci_big = u * pk[i] + e + m (if col = i) if let Some((pt, col)) = pt { @@ -639,7 +703,7 @@ where } // ct[i] = norm(ci_big) - module.vec_znx_big_normalize(log_base2k, self, i, &ci_big, 0, scratch_2); + module.vec_znx_big_normalize(basek, self, i, &ci_big, 0, scratch_2); }); } } diff --git a/core/src/glwe_ciphertext_fourier.rs b/core/src/glwe_ciphertext_fourier.rs index 135a2dd..20b4f72 100644 --- a/core/src/glwe_ciphertext_fourier.rs +++ b/core/src/glwe_ciphertext_fourier.rs @@ -1,4 +1,4 @@ -use base2k::{ +use backend::{ Backend, FFT64, MatZnxDft, MatZnxDftOps, MatZnxDftScratch, MatZnxDftToRef, Module, ScalarZnxDft, ScalarZnxDftOps, ScalarZnxDftToRef, Scratch, VecZnx, VecZnxAlloc, VecZnxBig, VecZnxBigAlloc, VecZnxBigOps, VecZnxBigScratch, VecZnxDft, VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, VecZnxDftToRef, VecZnxToMut, VecZnxToRef, ZnxZero, @@ -17,7 +17,7 @@ pub struct GLWECiphertextFourier { } impl GLWECiphertextFourier, B> { - pub fn new(module: &Module, basek: usize, k: usize, rank: usize) -> Self { + pub fn alloc(module: &Module, basek: usize, k: usize, rank: usize) -> Self { Self { data: module.new_vec_znx_dft(rank + 1, derive_size(basek, k)), basek: basek, diff --git a/core/src/glwe_plaintext.rs b/core/src/glwe_plaintext.rs index 4900fa0..ed4826d 100644 --- a/core/src/glwe_plaintext.rs +++ b/core/src/glwe_plaintext.rs @@ -1,4 +1,4 @@ -use base2k::{Backend, Module, VecZnx, VecZnxAlloc, VecZnxToMut, VecZnxToRef}; +use backend::{Backend, Module, VecZnx, VecZnxAlloc, VecZnxToMut, VecZnxToRef}; use crate::{elem::Infos, utils::derive_size}; @@ -43,7 +43,7 @@ where } impl GLWEPlaintext> { - pub fn new(module: &Module, basek: usize, k: usize) -> Self { + pub fn alloc(module: &Module, basek: usize, k: usize) -> Self { Self { data: module.new_vec_znx(1, derive_size(basek, k)), basek: basek, diff --git a/core/src/keys.rs b/core/src/keys.rs index 8a4d5e1..3b0af56 100644 --- a/core/src/keys.rs +++ b/core/src/keys.rs @@ -1,4 +1,4 @@ -use base2k::{ +use backend::{ Backend, FFT64, Module, ScalarZnx, ScalarZnxAlloc, ScalarZnxDft, ScalarZnxDftAlloc, ScalarZnxDftOps, ScalarZnxDftToMut, ScalarZnxDftToRef, ScalarZnxToMut, ScalarZnxToRef, ScratchOwned, VecZnxDft, VecZnxDftToMut, VecZnxDftToRef, ZnxInfos, ZnxZero, @@ -21,7 +21,7 @@ pub struct SecretKey { } impl SecretKey> { - pub fn new(module: &Module, rank: usize) -> Self { + pub fn alloc(module: &Module, rank: usize) -> Self { Self { data: module.new_scalar_znx(rank), dist: SecretDistribution::NONE, @@ -105,7 +105,7 @@ impl SecretKeyFourier { } impl SecretKeyFourier, B> { - pub fn new(module: &Module, rank: usize) -> Self { + pub fn alloc(module: &Module, rank: usize) -> Self { Self { data: module.new_scalar_znx_dft(rank), dist: SecretDistribution::NONE, @@ -114,7 +114,7 @@ impl SecretKeyFourier, B> { pub fn dft(&mut self, module: &Module, sk: &SecretKey) where - SecretKeyFourier, B>: ScalarZnxDftToMut, + SecretKeyFourier, B>: ScalarZnxDftToMut, SecretKey: ScalarZnxToRef, { #[cfg(debug_assertions)] @@ -160,9 +160,9 @@ pub struct GLWEPublicKey { } impl GLWEPublicKey, B> { - pub fn new(module: &Module, log_base2k: usize, log_k: usize, rank: usize) -> Self { + pub fn alloc(module: &Module, basek: usize, k: usize, rank: usize) -> Self { Self { - data: GLWECiphertextFourier::new(module, log_base2k, log_k, rank), + data: GLWECiphertextFourier::alloc(module, basek, k, rank), dist: SecretDistribution::NONE, } } @@ -209,7 +209,7 @@ where } impl GLWEPublicKey { - pub fn generate( + pub fn generate_from_sk( &mut self, module: &Module, sk_dft: &SecretKeyFourier, diff --git a/core/src/keyswitch_key.rs b/core/src/keyswitch_key.rs index cade469..a4ace4a 100644 --- a/core/src/keyswitch_key.rs +++ b/core/src/keyswitch_key.rs @@ -1,4 +1,4 @@ -use base2k::{ +use backend::{ Backend, FFT64, MatZnxDft, MatZnxDftOps, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx, ScalarZnxDft, ScalarZnxDftToRef, ScalarZnxToRef, Scratch, VecZnxDftAlloc, VecZnxDftToMut, VecZnxDftToRef, ZnxZero, }; @@ -15,8 +15,8 @@ use crate::{ pub struct GLWESwitchingKey(pub(crate) GGLWECiphertext); impl GLWESwitchingKey, FFT64> { - pub fn new(module: &Module, basek: usize, k: usize, rows: usize, rank_in: usize, rank_out: usize) -> Self { - GLWESwitchingKey(GGLWECiphertext::new( + pub fn alloc(module: &Module, basek: usize, k: usize, rows: usize, rank_in: usize, rank_out: usize) -> Self { + GLWESwitchingKey(GGLWECiphertext::alloc( module, basek, k, rows, rank_in, rank_out, )) } @@ -96,11 +96,11 @@ where impl GLWESwitchingKey, FFT64> { pub fn encrypt_sk_scratch_space(module: &Module, rank: usize, size: usize) -> usize { - GGLWECiphertext::encrypt_sk_scratch_space(module, rank, size) + GGLWECiphertext::generate_from_sk_scratch_space(module, rank, size) } pub fn encrypt_pk_scratch_space(module: &Module, rank: usize, pk_size: usize) -> usize { - GGLWECiphertext::encrypt_pk_scratch_space(module, rank, pk_size) + GGLWECiphertext::generate_from_pk_scratch_space(module, rank, pk_size) } pub fn keyswitch_scratch_space( @@ -164,7 +164,7 @@ where ScalarZnx: ScalarZnxToRef, ScalarZnxDft: ScalarZnxDftToRef, { - self.0.encrypt_sk( + self.0.generate_from_sk( module, &sk_in.data, sk_out_dft, @@ -180,7 +180,7 @@ where module: &Module, lhs: &GLWESwitchingKey, rhs: &GLWESwitchingKey, - scratch: &mut base2k::Scratch, + scratch: &mut Scratch, ) where MatZnxDft: MatZnxDftToRef, MatZnxDft: MatZnxDftToRef, @@ -247,7 +247,7 @@ where &mut self, module: &Module, rhs: &GLWESwitchingKey, - scratch: &mut base2k::Scratch, + scratch: &mut Scratch, ) where MatZnxDft: MatZnxDftToRef, { diff --git a/core/src/lib.rs b/core/src/lib.rs index 74ed7ef..249ad94 100644 --- a/core/src/lib.rs +++ b/core/src/lib.rs @@ -10,6 +10,7 @@ pub mod keyswitch_key; pub mod tensor_key; #[cfg(test)] mod test_fft64; +pub mod trace; mod utils; pub(crate) const SIX_SIGMA: f64 = 6.0; diff --git a/core/src/tensor_key.rs b/core/src/tensor_key.rs index 158274d..ee31c8d 100644 --- a/core/src/tensor_key.rs +++ b/core/src/tensor_key.rs @@ -1,4 +1,4 @@ -use base2k::{ +use backend::{ Backend, FFT64, MatZnxDft, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx, ScalarZnxDft, ScalarZnxDftAlloc, ScalarZnxDftOps, ScalarZnxDftToRef, Scratch, VecZnxDftOps, VecZnxDftToRef, }; @@ -15,11 +15,11 @@ pub struct TensorKey { } impl TensorKey, FFT64> { - pub fn new(module: &Module, basek: usize, k: usize, rows: usize, rank: usize) -> Self { + pub fn alloc(module: &Module, basek: usize, k: usize, rows: usize, rank: usize) -> Self { let mut keys: Vec, FFT64>> = Vec::new(); let pairs: usize = ((rank + 1) * rank) >> 1; (0..pairs).for_each(|_| { - keys.push(GLWESwitchingKey::new(module, basek, k, rows, 1, rank)); + keys.push(GLWESwitchingKey::alloc(module, basek, k, rows, 1, rank)); }); Self { keys: keys } } diff --git a/core/src/test_fft64/automorphism_key.rs b/core/src/test_fft64/automorphism_key.rs index ea63550..d469660 100644 --- a/core/src/test_fft64/automorphism_key.rs +++ b/core/src/test_fft64/automorphism_key.rs @@ -1,4 +1,4 @@ -use base2k::{FFT64, Module, ScalarZnxOps, ScratchOwned, Stats, VecZnxOps}; +use backend::{FFT64, Module, ScalarZnxOps, ScratchOwned, Stats, VecZnxOps}; use sampling::source::Source; use crate::{ @@ -30,16 +30,16 @@ fn test_automorphism(p0: i64, p1: i64, log_n: usize, basek: usize, k_ksk: usize, let module: Module = Module::::new(1 << log_n); let rows = (k_ksk + basek - 1) / basek; - let mut auto_key_in: AutomorphismKey, FFT64> = AutomorphismKey::new(&module, basek, k_ksk, rows, rank); - let mut auto_key_out: AutomorphismKey, FFT64> = AutomorphismKey::new(&module, basek, k_ksk, rows, rank); - let mut auto_key_apply: AutomorphismKey, FFT64> = AutomorphismKey::new(&module, basek, k_ksk, rows, rank); + let mut auto_key_in: AutomorphismKey, FFT64> = AutomorphismKey::alloc(&module, basek, k_ksk, rows, rank); + let mut auto_key_out: AutomorphismKey, FFT64> = AutomorphismKey::alloc(&module, basek, k_ksk, rows, rank); + let mut auto_key_apply: AutomorphismKey, FFT64> = AutomorphismKey::alloc(&module, basek, k_ksk, rows, 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 scratch: ScratchOwned = ScratchOwned::new( - AutomorphismKey::encrypt_sk_scratch_space(&module, rank, auto_key_in.size()) + AutomorphismKey::generate_from_sk_scratch_space(&module, rank, auto_key_in.size()) | GLWECiphertextFourier::decrypt_scratch_space(&module, auto_key_out.size()) | AutomorphismKey::automorphism_scratch_space( &module, @@ -50,14 +50,14 @@ fn test_automorphism(p0: i64, p1: i64, log_n: usize, basek: usize, k_ksk: usize, ), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); // gglwe_{s1}(s0) = s0 -> s1 - auto_key_in.encrypt_sk( + auto_key_in.generate_from_sk( &module, p0, &sk, @@ -68,7 +68,7 @@ fn test_automorphism(p0: i64, p1: i64, log_n: usize, basek: usize, k_ksk: usize, ); // gglwe_{s2}(s1) -> s1 -> s2 - auto_key_apply.encrypt_sk( + auto_key_apply.generate_from_sk( &module, p1, &sk, @@ -81,16 +81,16 @@ fn test_automorphism(p0: i64, p1: i64, log_n: usize, basek: usize, k_ksk: usize, // gglwe_{s1}(s0) (x) gglwe_{s2}(s1) = gglwe_{s2}(s0) auto_key_out.automorphism(&module, &auto_key_in, &auto_key_apply, scratch.borrow()); - let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ksk, rank); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ksk); + let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ksk, rank); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ksk); - let mut sk_auto: SecretKey> = SecretKey::new(&module, rank); + let mut sk_auto: SecretKey> = SecretKey::alloc(&module, rank); sk_auto.fill_zero(); // Necessary to avoid panic of unfilled sk (0..rank).for_each(|i| { module.scalar_znx_automorphism(module.galois_element_inv(p0 * p1), &mut sk_auto, i, &sk, i); }); - let mut sk_auto_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_auto_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_auto_dft.dft(&module, &sk_auto); (0..auto_key_out.rank_in()).for_each(|col_i| { @@ -128,27 +128,27 @@ fn test_automorphism_inplace(p0: i64, p1: i64, log_n: usize, basek: usize, k_ksk let module: Module = Module::::new(1 << log_n); let rows = (k_ksk + basek - 1) / basek; - let mut auto_key: AutomorphismKey, FFT64> = AutomorphismKey::new(&module, basek, k_ksk, rows, rank); - let mut auto_key_apply: AutomorphismKey, FFT64> = AutomorphismKey::new(&module, basek, k_ksk, rows, rank); + let mut auto_key: AutomorphismKey, FFT64> = AutomorphismKey::alloc(&module, basek, k_ksk, rows, rank); + let mut auto_key_apply: AutomorphismKey, FFT64> = AutomorphismKey::alloc(&module, basek, k_ksk, rows, 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 scratch: ScratchOwned = ScratchOwned::new( - AutomorphismKey::encrypt_sk_scratch_space(&module, rank, auto_key.size()) + AutomorphismKey::generate_from_sk_scratch_space(&module, rank, auto_key.size()) | GLWECiphertextFourier::decrypt_scratch_space(&module, auto_key.size()) | AutomorphismKey::automorphism_inplace_scratch_space(&module, auto_key.size(), auto_key_apply.size(), rank), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); // gglwe_{s1}(s0) = s0 -> s1 - auto_key.encrypt_sk( + auto_key.generate_from_sk( &module, p0, &sk, @@ -159,7 +159,7 @@ fn test_automorphism_inplace(p0: i64, p1: i64, log_n: usize, basek: usize, k_ksk ); // gglwe_{s2}(s1) -> s1 -> s2 - auto_key_apply.encrypt_sk( + auto_key_apply.generate_from_sk( &module, p1, &sk, @@ -172,16 +172,16 @@ fn test_automorphism_inplace(p0: i64, p1: i64, log_n: usize, basek: usize, k_ksk // gglwe_{s1}(s0) (x) gglwe_{s2}(s1) = gglwe_{s2}(s0) auto_key.automorphism_inplace(&module, &auto_key_apply, scratch.borrow()); - let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ksk, rank); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ksk); + let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ksk, rank); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ksk); - let mut sk_auto: SecretKey> = SecretKey::new(&module, rank); + let mut sk_auto: SecretKey> = SecretKey::alloc(&module, rank); sk_auto.fill_zero(); // Necessary to avoid panic of unfilled sk (0..rank).for_each(|i| { module.scalar_znx_automorphism(module.galois_element_inv(p0 * p1), &mut sk_auto, i, &sk, i); }); - let mut sk_auto_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_auto_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_auto_dft.dft(&module, &sk_auto); (0..auto_key.rank_in()).for_each(|col_i| { diff --git a/core/src/test_fft64/gglwe.rs b/core/src/test_fft64/gglwe.rs index d497dbf..5324a02 100644 --- a/core/src/test_fft64/gglwe.rs +++ b/core/src/test_fft64/gglwe.rs @@ -1,4 +1,4 @@ -use base2k::{FFT64, Module, ScalarZnx, ScalarZnxAlloc, ScalarZnxToMut, ScratchOwned, Stats, VecZnxOps, ZnxViewMut}; +use backend::{FFT64, Module, ScalarZnx, ScalarZnxAlloc, ScalarZnxToMut, ScratchOwned, Stats, VecZnxOps, ZnxViewMut}; use sampling::source::Source; use crate::{ @@ -76,8 +76,8 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ksk: usize, sigma: f64, rank_in let module: Module = Module::::new(1 << log_n); let rows = (k_ksk + basek - 1) / basek; - let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank_in, rank_out); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ksk); + let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank_in, rank_out); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ksk); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -88,16 +88,16 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ksk: usize, sigma: f64, rank_in | GLWECiphertextFourier::decrypt_scratch_space(&module, ksk.size()), ); - let mut sk_in: SecretKey> = SecretKey::new(&module, rank_in); + let mut sk_in: SecretKey> = SecretKey::alloc(&module, rank_in); sk_in.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_in); + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_in); sk_in_dft.dft(&module, &sk_in); - let mut sk_out: SecretKey> = SecretKey::new(&module, rank_out); + let mut sk_out: SecretKey> = SecretKey::alloc(&module, rank_out); sk_out.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out); + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out); sk_out_dft.dft(&module, &sk_out); ksk.encrypt_sk( @@ -110,7 +110,7 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ksk: usize, sigma: f64, rank_in scratch.borrow(), ); - let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ksk, rank_out); + let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ksk, rank_out); (0..ksk.rank_in()).for_each(|col_i| { (0..ksk.rows()).for_each(|row_i| { @@ -136,11 +136,11 @@ fn test_key_switch( let rows = (k_ksk + basek - 1) / basek; let mut ct_gglwe_s0s1: GLWESwitchingKey, FFT64> = - GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank_in_s0s1, rank_out_s0s1); + GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank_in_s0s1, rank_out_s0s1); let mut ct_gglwe_s1s2: GLWESwitchingKey, FFT64> = - GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank_out_s0s1, rank_out_s1s2); + GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank_out_s0s1, rank_out_s1s2); let mut ct_gglwe_s0s2: GLWESwitchingKey, FFT64> = - GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank_in_s0s1, rank_out_s1s2); + GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank_in_s0s1, rank_out_s1s2); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -159,22 +159,22 @@ fn test_key_switch( ), ); - let mut sk0: SecretKey> = SecretKey::new(&module, rank_in_s0s1); + let mut sk0: SecretKey> = SecretKey::alloc(&module, rank_in_s0s1); sk0.fill_ternary_prob(0.5, &mut source_xs); - let mut sk0_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_in_s0s1); + let mut sk0_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_in_s0s1); sk0_dft.dft(&module, &sk0); - let mut sk1: SecretKey> = SecretKey::new(&module, rank_out_s0s1); + let mut sk1: SecretKey> = SecretKey::alloc(&module, rank_out_s0s1); sk1.fill_ternary_prob(0.5, &mut source_xs); - let mut sk1_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out_s0s1); + let mut sk1_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out_s0s1); sk1_dft.dft(&module, &sk1); - let mut sk2: SecretKey> = SecretKey::new(&module, rank_out_s1s2); + let mut sk2: SecretKey> = SecretKey::alloc(&module, rank_out_s1s2); sk2.fill_ternary_prob(0.5, &mut source_xs); - let mut sk2_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out_s1s2); + let mut sk2_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out_s1s2); sk2_dft.dft(&module, &sk2); // gglwe_{s1}(s0) = s0 -> s1 @@ -202,8 +202,8 @@ fn test_key_switch( // gglwe_{s1}(s0) (x) gglwe_{s2}(s1) = gglwe_{s2}(s0) ct_gglwe_s0s2.keyswitch(&module, &ct_gglwe_s0s1, &ct_gglwe_s1s2, scratch.borrow()); - let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ksk, rank_out_s1s2); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ksk); + let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ksk, rank_out_s1s2); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ksk); (0..ct_gglwe_s0s2.rank_in()).for_each(|col_i| { (0..ct_gglwe_s0s2.rows()).for_each(|row_i| { @@ -240,9 +240,9 @@ fn test_key_switch_inplace(log_n: usize, basek: usize, k_ksk: usize, sigma: f64, let rows: usize = (k_ksk + basek - 1) / basek; let mut ct_gglwe_s0s1: GLWESwitchingKey, FFT64> = - GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank_in_s0s1, rank_out_s0s1); + GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank_in_s0s1, rank_out_s0s1); let mut ct_gglwe_s1s2: GLWESwitchingKey, FFT64> = - GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank_out_s0s1, rank_out_s0s1); + GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank_out_s0s1, rank_out_s0s1); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -259,22 +259,22 @@ fn test_key_switch_inplace(log_n: usize, basek: usize, k_ksk: usize, sigma: f64, ), ); - let mut sk0: SecretKey> = SecretKey::new(&module, rank_in_s0s1); + let mut sk0: SecretKey> = SecretKey::alloc(&module, rank_in_s0s1); sk0.fill_ternary_prob(0.5, &mut source_xs); - let mut sk0_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_in_s0s1); + let mut sk0_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_in_s0s1); sk0_dft.dft(&module, &sk0); - let mut sk1: SecretKey> = SecretKey::new(&module, rank_out_s0s1); + let mut sk1: SecretKey> = SecretKey::alloc(&module, rank_out_s0s1); sk1.fill_ternary_prob(0.5, &mut source_xs); - let mut sk1_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out_s0s1); + let mut sk1_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out_s0s1); sk1_dft.dft(&module, &sk1); - let mut sk2: SecretKey> = SecretKey::new(&module, rank_out_s0s1); + let mut sk2: SecretKey> = SecretKey::alloc(&module, rank_out_s0s1); sk2.fill_ternary_prob(0.5, &mut source_xs); - let mut sk2_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out_s0s1); + let mut sk2_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out_s0s1); sk2_dft.dft(&module, &sk2); // gglwe_{s1}(s0) = s0 -> s1 @@ -304,8 +304,8 @@ fn test_key_switch_inplace(log_n: usize, basek: usize, k_ksk: usize, sigma: f64, let ct_gglwe_s0s2: GLWESwitchingKey, FFT64> = ct_gglwe_s0s1; - let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ksk, rank_out_s0s1); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ksk); + let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ksk, rank_out_s0s1); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ksk); (0..ct_gglwe_s0s2.rank_in()).for_each(|col_i| { (0..ct_gglwe_s0s2.rows()).for_each(|row_i| { @@ -342,9 +342,9 @@ fn test_external_product(log_n: usize, basek: usize, k: usize, sigma: f64, rank_ let rows: usize = (k + basek - 1) / basek; - let mut ct_gglwe_in: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k, rows, rank_in, rank_out); - let mut ct_gglwe_out: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k, rows, rank_in, rank_out); - let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k, rows, rank_out); + let mut ct_gglwe_in: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k, rows, rank_in, rank_out); + let mut ct_gglwe_out: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k, rows, rank_in, rank_out); + let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k, rows, rank_out); let mut pt_rgsw: ScalarZnx> = module.new_scalar_znx(1); @@ -369,16 +369,16 @@ fn test_external_product(log_n: usize, basek: usize, k: usize, sigma: f64, rank_ pt_rgsw.to_mut().raw_mut()[r] = 1; // X^{r} - let mut sk_in: SecretKey> = SecretKey::new(&module, rank_in); + let mut sk_in: SecretKey> = SecretKey::alloc(&module, rank_in); sk_in.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_in); + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_in); sk_in_dft.dft(&module, &sk_in); - let mut sk_out: SecretKey> = SecretKey::new(&module, rank_out); + let mut sk_out: SecretKey> = SecretKey::alloc(&module, rank_out); sk_out.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out); + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out); sk_out_dft.dft(&module, &sk_out); // gglwe_{s1}(s0) = s0 -> s1 @@ -418,8 +418,8 @@ fn test_external_product(log_n: usize, basek: usize, k: usize, sigma: f64, rank_ | GGSWCiphertext::encrypt_sk_scratch_space(&module, rank_out, ct_rgsw.size()), ); - let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k, rank_out); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); + let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k, rank_out); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); (0..rank_in).for_each(|i| { module.vec_znx_rotate_inplace(r as i64, &mut sk_in.data, i); // * X^{r} @@ -469,8 +469,8 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k: usize, sigma: f6 let rows: usize = (k + basek - 1) / basek; - let mut ct_gglwe: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k, rows, rank_in, rank_out); - let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k, rows, rank_out); + let mut ct_gglwe: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k, rows, rank_in, rank_out); + let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k, rows, rank_out); let mut pt_rgsw: ScalarZnx> = module.new_scalar_znx(1); @@ -489,16 +489,16 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k: usize, sigma: f6 pt_rgsw.to_mut().raw_mut()[r] = 1; // X^{r} - let mut sk_in: SecretKey> = SecretKey::new(&module, rank_in); + let mut sk_in: SecretKey> = SecretKey::alloc(&module, rank_in); sk_in.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_in); + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_in); sk_in_dft.dft(&module, &sk_in); - let mut sk_out: SecretKey> = SecretKey::new(&module, rank_out); + let mut sk_out: SecretKey> = SecretKey::alloc(&module, rank_out); sk_out.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out); + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out); sk_out_dft.dft(&module, &sk_out); // gglwe_{s1}(s0) = s0 -> s1 @@ -525,8 +525,8 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k: usize, sigma: f6 // gglwe_(m) (x) RGSW_(X^k) = gglwe_(m * X^k) ct_gglwe.external_product_inplace(&module, &ct_rgsw, scratch.borrow()); - let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k, rank_out); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); + let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k, rank_out); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); (0..rank_in).for_each(|i| { module.vec_znx_rotate_inplace(r as i64, &mut sk_in.data, i); // * X^{r} diff --git a/core/src/test_fft64/ggsw.rs b/core/src/test_fft64/ggsw.rs index f02bd87..45855a5 100644 --- a/core/src/test_fft64/ggsw.rs +++ b/core/src/test_fft64/ggsw.rs @@ -1,4 +1,4 @@ -use base2k::{ +use backend::{ FFT64, Module, ScalarZnx, ScalarZnxAlloc, ScalarZnxDftOps, ScalarZnxOps, ScratchOwned, Stats, VecZnxBig, VecZnxBigAlloc, VecZnxBigOps, VecZnxDft, VecZnxDftAlloc, VecZnxDftOps, VecZnxOps, VecZnxToMut, ZnxViewMut, ZnxZero, }; @@ -78,9 +78,9 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ggsw: usize, sigma: f64, rank: let rows: usize = (k_ggsw + basek - 1) / basek; - let mut ct: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ggsw); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ggsw); + let mut ct: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ggsw); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ggsw); let mut pt_scalar: ScalarZnx> = module.new_scalar_znx(1); let mut source_xs: Source = Source::new([0u8; 32]); @@ -94,10 +94,10 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ggsw: usize, sigma: f64, rank: | GLWECiphertextFourier::decrypt_scratch_space(&module, ct.size()), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); ct.encrypt_sk( @@ -110,7 +110,7 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ggsw: usize, sigma: f64, rank: scratch.borrow(), ); - let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ggsw, rank); + let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ggsw, rank); let mut pt_dft: VecZnxDft, FFT64> = module.new_vec_znx_dft(1, ct.size()); let mut pt_big: VecZnxBig, FFT64> = module.new_vec_znx_big(1, ct.size()); @@ -144,12 +144,12 @@ fn test_keyswitch(log_n: usize, basek: usize, k: usize, rank: usize, sigma: f64) let module: Module = Module::::new(1 << log_n); let rows: usize = (k + basek - 1) / basek; - let mut ct_in: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k, rows, rank); - let mut ct_out: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k, rows, rank); - let mut tsk: TensorKey, FFT64> = TensorKey::new(&module, basek, k, rows, rank); - let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k, rows, rank, rank); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); + let mut ct_in: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k, rows, rank); + let mut ct_out: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k, rows, rank); + let mut tsk: TensorKey, FFT64> = TensorKey::alloc(&module, basek, k, rows, rank); + let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k, rows, rank, rank); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); let mut pt_scalar: ScalarZnx> = module.new_scalar_znx(1); let mut source_xs: Source = Source::new([0u8; 32]); @@ -173,16 +173,16 @@ fn test_keyswitch(log_n: usize, basek: usize, k: usize, rank: usize, sigma: f64) let var_xs: f64 = 0.5; - let mut sk_in: SecretKey> = SecretKey::new(&module, rank); + let mut sk_in: SecretKey> = SecretKey::alloc(&module, rank); sk_in.fill_ternary_prob(var_xs, &mut source_xs); - let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_in_dft.dft(&module, &sk_in); - let mut sk_out: SecretKey> = SecretKey::new(&module, rank); + let mut sk_out: SecretKey> = SecretKey::alloc(&module, rank); sk_out.fill_ternary_prob(var_xs, &mut source_xs); - let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_out_dft.dft(&module, &sk_out); ksk.encrypt_sk( @@ -217,7 +217,7 @@ fn test_keyswitch(log_n: usize, basek: usize, k: usize, rank: usize, sigma: f64) ct_out.keyswitch(&module, &ct_in, &ksk, &tsk, scratch.borrow()); - let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k, rank); + let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k, rank); let mut pt_dft: VecZnxDft, FFT64> = module.new_vec_znx_dft(1, ct_out.size()); let mut pt_big: VecZnxBig, FFT64> = module.new_vec_znx_big(1, ct_out.size()); @@ -271,11 +271,11 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k: usize, rank: usize, sig let module: Module = Module::::new(1 << log_n); let rows: usize = (k + basek - 1) / basek; - let mut ct: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k, rows, rank); - let mut tsk: TensorKey, FFT64> = TensorKey::new(&module, basek, k, rows, rank); - let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k, rows, rank, rank); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); + let mut ct: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k, rows, rank); + let mut tsk: TensorKey, FFT64> = TensorKey::alloc(&module, basek, k, rows, rank); + let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k, rows, rank, rank); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); let mut pt_scalar: ScalarZnx> = module.new_scalar_znx(1); let mut source_xs: Source = Source::new([0u8; 32]); @@ -292,16 +292,16 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k: usize, rank: usize, sig let var_xs: f64 = 0.5; - let mut sk_in: SecretKey> = SecretKey::new(&module, rank); + let mut sk_in: SecretKey> = SecretKey::alloc(&module, rank); sk_in.fill_ternary_prob(var_xs, &mut source_xs); - let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_in_dft.dft(&module, &sk_in); - let mut sk_out: SecretKey> = SecretKey::new(&module, rank); + let mut sk_out: SecretKey> = SecretKey::alloc(&module, rank); sk_out.fill_ternary_prob(var_xs, &mut source_xs); - let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_out_dft.dft(&module, &sk_out); ksk.encrypt_sk( @@ -336,7 +336,7 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k: usize, rank: usize, sig ct.keyswitch_inplace(&module, &ksk, &tsk, scratch.borrow()); - let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k, rank); + let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k, rank); let mut pt_dft: VecZnxDft, FFT64> = module.new_vec_znx_dft(1, ct.size()); let mut pt_big: VecZnxBig, FFT64> = module.new_vec_znx_big(1, ct.size()); @@ -439,12 +439,12 @@ fn test_automorphism(p: i64, log_n: usize, basek: usize, k: usize, rank: usize, let module: Module = Module::::new(1 << log_n); let rows: usize = (k + basek - 1) / basek; - let mut ct_in: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k, rows, rank); - let mut ct_out: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k, rows, rank); - let mut tensor_key: TensorKey, FFT64> = TensorKey::new(&module, basek, k, rows, rank); - let mut auto_key: AutomorphismKey, FFT64> = AutomorphismKey::new(&module, basek, k, rows, rank); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); + let mut ct_in: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k, rows, rank); + let mut ct_out: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k, rows, rank); + let mut tensor_key: TensorKey, FFT64> = TensorKey::alloc(&module, basek, k, rows, rank); + let mut auto_key: AutomorphismKey, FFT64> = AutomorphismKey::alloc(&module, basek, k, rows, rank); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); let mut pt_scalar: ScalarZnx> = module.new_scalar_znx(1); let mut source_xs: Source = Source::new([0u8; 32]); @@ -454,7 +454,7 @@ fn test_automorphism(p: i64, log_n: usize, basek: usize, k: usize, rank: usize, let mut scratch: ScratchOwned = ScratchOwned::new( GGSWCiphertext::encrypt_sk_scratch_space(&module, rank, ct_in.size()) | GLWECiphertextFourier::decrypt_scratch_space(&module, ct_out.size()) - | AutomorphismKey::encrypt_sk_scratch_space(&module, rank, auto_key.size()) + | AutomorphismKey::generate_from_sk_scratch_space(&module, rank, auto_key.size()) | TensorKey::encrypt_sk_scratch_space(&module, rank, tensor_key.size()) | GGSWCiphertext::automorphism_scratch_space( &module, @@ -468,13 +468,13 @@ fn test_automorphism(p: i64, log_n: usize, basek: usize, k: usize, rank: usize, let var_xs: f64 = 0.5; - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(var_xs, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); - auto_key.encrypt_sk( + auto_key.generate_from_sk( &module, p, &sk, @@ -508,7 +508,7 @@ fn test_automorphism(p: i64, log_n: usize, basek: usize, k: usize, rank: usize, module.scalar_znx_automorphism_inplace(p, &mut pt_scalar, 0); - let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k, rank); + let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k, rank); let mut pt_dft: VecZnxDft, FFT64> = module.new_vec_znx_dft(1, ct_out.size()); let mut pt_big: VecZnxBig, FFT64> = module.new_vec_znx_big(1, ct_out.size()); @@ -560,11 +560,11 @@ fn test_automorphism_inplace(p: i64, log_n: usize, basek: usize, k: usize, rank: let module: Module = Module::::new(1 << log_n); let rows: usize = (k + basek - 1) / basek; - let mut ct: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k, rows, rank); - let mut tensor_key: TensorKey, FFT64> = TensorKey::new(&module, basek, k, rows, rank); - let mut auto_key: AutomorphismKey, FFT64> = AutomorphismKey::new(&module, basek, k, rows, rank); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); + let mut ct: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k, rows, rank); + let mut tensor_key: TensorKey, FFT64> = TensorKey::alloc(&module, basek, k, rows, rank); + let mut auto_key: AutomorphismKey, FFT64> = AutomorphismKey::alloc(&module, basek, k, rows, rank); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); let mut pt_scalar: ScalarZnx> = module.new_scalar_znx(1); let mut source_xs: Source = Source::new([0u8; 32]); @@ -574,20 +574,20 @@ fn test_automorphism_inplace(p: i64, log_n: usize, basek: usize, k: usize, rank: let mut scratch: ScratchOwned = ScratchOwned::new( GGSWCiphertext::encrypt_sk_scratch_space(&module, rank, ct.size()) | GLWECiphertextFourier::decrypt_scratch_space(&module, ct.size()) - | AutomorphismKey::encrypt_sk_scratch_space(&module, rank, auto_key.size()) + | AutomorphismKey::generate_from_sk_scratch_space(&module, rank, auto_key.size()) | TensorKey::encrypt_sk_scratch_space(&module, rank, tensor_key.size()) | GGSWCiphertext::automorphism_inplace_scratch_space(&module, ct.size(), auto_key.size(), tensor_key.size(), rank), ); let var_xs: f64 = 0.5; - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(var_xs, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); - auto_key.encrypt_sk( + auto_key.generate_from_sk( &module, p, &sk, @@ -621,7 +621,7 @@ fn test_automorphism_inplace(p: i64, log_n: usize, basek: usize, k: usize, rank: module.scalar_znx_automorphism_inplace(p, &mut pt_scalar, 0); - let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k, rank); + let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k, rank); let mut pt_dft: VecZnxDft, FFT64> = module.new_vec_znx_dft(1, ct.size()); let mut pt_big: VecZnxBig, FFT64> = module.new_vec_znx_big(1, ct.size()); @@ -674,9 +674,9 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, rank: usize, let rows: usize = (k_ggsw + basek - 1) / basek; - let mut ct_ggsw_rhs: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); - let mut ct_ggsw_lhs_in: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); - let mut ct_ggsw_lhs_out: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); + let mut ct_ggsw_rhs: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); + let mut ct_ggsw_lhs_in: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); + let mut ct_ggsw_lhs_out: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); let mut pt_ggsw_lhs: ScalarZnx> = module.new_scalar_znx(1); let mut pt_ggsw_rhs: ScalarZnx> = module.new_scalar_znx(1); @@ -702,10 +702,10 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, rank: usize, ), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); ct_ggsw_rhs.encrypt_sk( @@ -730,11 +730,11 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, rank: usize, ct_ggsw_lhs_out.external_product(&module, &ct_ggsw_lhs_in, &ct_ggsw_rhs, scratch.borrow()); - let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ggsw, rank); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ggsw); + let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ggsw, rank); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ggsw); let mut pt_dft: VecZnxDft, FFT64> = module.new_vec_znx_dft(1, ct_ggsw_lhs_out.size()); let mut pt_big: VecZnxBig, FFT64> = module.new_vec_znx_big(1, ct_ggsw_lhs_out.size()); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ggsw); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ggsw); module.vec_znx_rotate_inplace(k as i64, &mut pt_ggsw_lhs, 0); @@ -793,8 +793,8 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, rank let module: Module = Module::::new(1 << log_n); let rows: usize = (k_ggsw + basek - 1) / basek; - let mut ct_ggsw_rhs: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); - let mut ct_ggsw_lhs: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); + let mut ct_ggsw_rhs: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); + let mut ct_ggsw_lhs: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); let mut pt_ggsw_lhs: ScalarZnx> = module.new_scalar_znx(1); let mut pt_ggsw_rhs: ScalarZnx> = module.new_scalar_znx(1); @@ -815,10 +815,10 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, rank | GGSWCiphertext::external_product_inplace_scratch_space(&module, ct_ggsw_lhs.size(), ct_ggsw_rhs.size(), rank), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); ct_ggsw_rhs.encrypt_sk( @@ -843,11 +843,11 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, rank ct_ggsw_lhs.external_product_inplace(&module, &ct_ggsw_rhs, scratch.borrow()); - let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ggsw, rank); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ggsw); + let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ggsw, rank); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ggsw); let mut pt_dft: VecZnxDft, FFT64> = module.new_vec_znx_dft(1, ct_ggsw_lhs.size()); let mut pt_big: VecZnxBig, FFT64> = module.new_vec_znx_big(1, ct_ggsw_lhs.size()); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ggsw); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ggsw); module.vec_znx_rotate_inplace(k as i64, &mut pt_ggsw_lhs, 0); diff --git a/core/src/test_fft64/glwe.rs b/core/src/test_fft64/glwe.rs index 0f7fcc1..91bb300 100644 --- a/core/src/test_fft64/glwe.rs +++ b/core/src/test_fft64/glwe.rs @@ -1,4 +1,4 @@ -use base2k::{ +use backend::{ Decoding, Encoding, FFT64, FillUniform, Module, ScalarZnx, ScalarZnxAlloc, ScratchOwned, Stats, VecZnxOps, VecZnxToMut, ZnxViewMut, ZnxZero, }; @@ -94,8 +94,8 @@ fn automorphism() { fn test_encrypt_sk(log_n: usize, basek: usize, k_ct: usize, k_pt: usize, sigma: f64, rank: usize) { let module: Module = Module::::new(1 << log_n); - let mut ct: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct, rank); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_pt); + let mut ct: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct, rank); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_pt); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -105,10 +105,10 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ct: usize, k_pt: usize, sigma: GLWECiphertext::encrypt_sk_scratch_space(&module, ct.size()) | GLWECiphertext::decrypt_scratch_space(&module, ct.size()), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); let mut data_want: Vec = vec![0i64; module.n()]; @@ -154,18 +154,18 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ct: usize, k_pt: usize, sigma: fn test_encrypt_zero_sk(log_n: usize, basek: usize, k_ct: usize, sigma: f64, rank: usize) { let module: Module = Module::::new(1 << log_n); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([1u8; 32]); let mut source_xa: Source = Source::new([0u8; 32]); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); - let mut ct_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ct, rank); + let mut ct_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ct, rank); let mut scratch: ScratchOwned = ScratchOwned::new( GLWECiphertextFourier::decrypt_scratch_space(&module, ct_dft.size()) @@ -188,21 +188,21 @@ fn test_encrypt_zero_sk(log_n: usize, basek: usize, k_ct: usize, sigma: f64, ran fn test_encrypt_pk(log_n: usize, basek: usize, k_ct: usize, k_pk: usize, sigma: f64, rank: usize) { let module: Module = Module::::new(1 << log_n); - let mut ct: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct, rank); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); + let mut ct: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct, rank); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); 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 source_xu: Source = Source::new([0u8; 32]); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); - let mut pk: GLWEPublicKey, FFT64> = GLWEPublicKey::new(&module, basek, k_pk, rank); - pk.generate(&module, &sk_dft, &mut source_xa, &mut source_xe, sigma); + let mut pk: GLWEPublicKey, FFT64> = GLWEPublicKey::alloc(&module, basek, k_pk, rank); + pk.generate_from_sk(&module, &sk_dft, &mut source_xa, &mut source_xe, sigma); let mut scratch: ScratchOwned = ScratchOwned::new( GLWECiphertext::encrypt_sk_scratch_space(&module, ct.size()) @@ -228,7 +228,7 @@ fn test_encrypt_pk(log_n: usize, basek: usize, k_ct: usize, k_pk: usize, sigma: scratch.borrow(), ); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); ct.decrypt(&module, &mut pt_have, &sk_dft, scratch.borrow()); @@ -258,11 +258,11 @@ fn test_keyswitch( let module: Module = Module::::new(1 << log_n); let rows: usize = (k_ct_in + basek - 1) / basek; - let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k_keyswitch, rows, rank_in, rank_out); - let mut ct_in: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_in, rank_in); - let mut ct_out: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_out, rank_out); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_in); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_out); + let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k_keyswitch, rows, rank_in, rank_out); + let mut ct_in: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_in, rank_in); + let mut ct_out: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_out, rank_out); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct_in); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct_out); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -287,16 +287,16 @@ fn test_keyswitch( ), ); - let mut sk_in: SecretKey> = SecretKey::new(&module, rank_in); + let mut sk_in: SecretKey> = SecretKey::alloc(&module, rank_in); sk_in.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_in); + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_in); sk_in_dft.dft(&module, &sk_in); - let mut sk_out: SecretKey> = SecretKey::new(&module, rank_out); + let mut sk_out: SecretKey> = SecretKey::alloc(&module, rank_out); sk_out.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out); + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out); sk_out_dft.dft(&module, &sk_out); ksk.encrypt_sk( @@ -351,10 +351,10 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k_ksk: usize, k_ct: usize, let module: Module = Module::::new(1 << log_n); let rows: usize = (k_ct + basek - 1) / basek; - let mut ct_grlwe: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank, rank); - let mut ct_rlwe: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct, rank); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); + let mut ct_grlwe: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank, rank); + let mut ct_rlwe: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct, rank); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -372,16 +372,16 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k_ksk: usize, k_ct: usize, | GLWECiphertext::keyswitch_inplace_scratch_space(&module, ct_rlwe.size(), rank, ct_grlwe.size()), ); - let mut sk0: SecretKey> = SecretKey::new(&module, rank); + let mut sk0: SecretKey> = SecretKey::alloc(&module, rank); sk0.fill_ternary_prob(0.5, &mut source_xs); - let mut sk0_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk0_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk0_dft.dft(&module, &sk0); - let mut sk1: SecretKey> = SecretKey::new(&module, rank); + let mut sk1: SecretKey> = SecretKey::alloc(&module, rank); sk1.fill_ternary_prob(0.5, &mut source_xs); - let mut sk1_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk1_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk1_dft.dft(&module, &sk1); ct_grlwe.encrypt_sk( @@ -445,11 +445,11 @@ fn test_automorphism( let module: Module = Module::::new(1 << log_n); let rows: usize = (k_ct_in + basek - 1) / basek; - let mut autokey: AutomorphismKey, FFT64> = AutomorphismKey::new(&module, basek, k_autokey, rows, rank); - let mut ct_in: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_in, rank); - let mut ct_out: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_out, rank); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_in); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_out); + let mut autokey: AutomorphismKey, FFT64> = AutomorphismKey::alloc(&module, basek, k_autokey, rows, rank); + let mut ct_in: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_in, rank); + let mut ct_out: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_out, rank); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct_in); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct_out); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -466,13 +466,13 @@ fn test_automorphism( | GLWECiphertext::automorphism_scratch_space(&module, ct_out.size(), rank, ct_in.size(), autokey.size()), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); - autokey.encrypt_sk( + autokey.generate_from_sk( &module, p, &sk, @@ -527,10 +527,10 @@ fn test_automorphism_inplace(log_n: usize, basek: usize, p: i64, k_autokey: usiz let module: Module = Module::::new(1 << log_n); let rows: usize = (k_ct + basek - 1) / basek; - let mut autokey: AutomorphismKey, FFT64> = AutomorphismKey::new(&module, basek, k_autokey, rows, rank); - let mut ct: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct, rank); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); + let mut autokey: AutomorphismKey, FFT64> = AutomorphismKey::alloc(&module, basek, k_autokey, rows, rank); + let mut ct: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct, rank); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -548,13 +548,13 @@ fn test_automorphism_inplace(log_n: usize, basek: usize, p: i64, k_autokey: usiz | GLWECiphertext::automorphism_inplace_scratch_space(&module, ct.size(), rank, autokey.size()), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); - autokey.encrypt_sk( + autokey.generate_from_sk( &module, p, &sk, @@ -607,12 +607,12 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, k_ct_in: usi let rows: usize = (k_ct_in + basek - 1) / basek; - let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); - let mut ct_rlwe_in: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_in, rank); - let mut ct_rlwe_out: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_out, rank); + let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); + let mut ct_rlwe_in: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_in, rank); + let mut ct_rlwe_out: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_out, rank); let mut pt_rgsw: ScalarZnx> = module.new_scalar_znx(1); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_in); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_out); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct_in); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct_out); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -642,10 +642,10 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, k_ct_in: usi ), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); ct_rgsw.encrypt_sk( @@ -711,11 +711,11 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, k_ct let module: Module = Module::::new(1 << log_n); let rows: usize = (k_ct + basek - 1) / basek; - let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); - let mut ct_rlwe: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct, rank); + let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); + let mut ct_rlwe: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct, rank); let mut pt_rgsw: ScalarZnx> = module.new_scalar_znx(1); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -739,10 +739,10 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, k_ct | GLWECiphertext::external_product_inplace_scratch_space(&module, ct_rlwe.size(), ct_rgsw.size(), rank), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); ct_rgsw.encrypt_sk( diff --git a/core/src/test_fft64/glwe_fourier.rs b/core/src/test_fft64/glwe_fourier.rs index d8bd11c..4a8c7c1 100644 --- a/core/src/test_fft64/glwe_fourier.rs +++ b/core/src/test_fft64/glwe_fourier.rs @@ -8,7 +8,7 @@ use crate::{ keyswitch_key::GLWESwitchingKey, test_fft64::{gglwe::log2_std_noise_gglwe_product, ggsw::noise_ggsw_product}, }; -use base2k::{FFT64, FillUniform, Module, ScalarZnx, ScalarZnxAlloc, ScratchOwned, Stats, VecZnxOps, VecZnxToMut, ZnxViewMut}; +use backend::{FFT64, FillUniform, Module, ScalarZnx, ScalarZnxAlloc, ScratchOwned, Stats, VecZnxOps, VecZnxToMut, ZnxViewMut}; use sampling::source::Source; #[test] @@ -59,14 +59,14 @@ fn test_keyswitch( let rows: usize = (k_ct_in + basek - 1) / basek; - let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank_in, rank_out); - let mut ct_glwe_in: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_in, rank_in); - let mut ct_glwe_dft_in: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ct_in, rank_in); - let mut ct_glwe_out: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_out, rank_out); + let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank_in, rank_out); + let mut ct_glwe_in: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_in, rank_in); + let mut ct_glwe_dft_in: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ct_in, rank_in); + let mut ct_glwe_out: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_out, rank_out); let mut ct_glwe_dft_out: GLWECiphertextFourier, FFT64> = - GLWECiphertextFourier::new(&module, basek, k_ct_out, rank_out); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_in); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_out); + GLWECiphertextFourier::alloc(&module, basek, k_ct_out, rank_out); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct_in); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct_out); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -91,16 +91,16 @@ fn test_keyswitch( ), ); - let mut sk_in: SecretKey> = SecretKey::new(&module, rank_in); + let mut sk_in: SecretKey> = SecretKey::alloc(&module, rank_in); sk_in.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_in); + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_in); sk_in_dft.dft(&module, &sk_in); - let mut sk_out: SecretKey> = SecretKey::new(&module, rank_out); + let mut sk_out: SecretKey> = SecretKey::alloc(&module, rank_out); sk_out.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank_out); + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out); sk_out_dft.dft(&module, &sk_out); ksk.encrypt_sk( @@ -157,11 +157,11 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k_ksk: usize, k_ct: usize, let module: Module = Module::::new(1 << log_n); let rows: usize = (k_ct + basek - 1) / basek; - let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::new(&module, basek, k_ksk, rows, rank, rank); - let mut ct_glwe: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct, rank); - let mut ct_rlwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ct, rank); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); + let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank, rank); + let mut ct_glwe: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct, rank); + let mut ct_rlwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ct, rank); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -179,16 +179,16 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k_ksk: usize, k_ct: usize, | GLWECiphertextFourier::keyswitch_inplace_scratch_space(&module, ct_rlwe_dft.size(), ksk.size(), rank), ); - let mut sk_in: SecretKey> = SecretKey::new(&module, rank); + let mut sk_in: SecretKey> = SecretKey::alloc(&module, rank); sk_in.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_in_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_in_dft.dft(&module, &sk_in); - let mut sk_out: SecretKey> = SecretKey::new(&module, rank); + let mut sk_out: SecretKey> = SecretKey::alloc(&module, rank); sk_out.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_out_dft.dft(&module, &sk_out); ksk.encrypt_sk( @@ -246,14 +246,14 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, k_ct_in: usi let rows: usize = (k_ct_in + basek - 1) / basek; - let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); - let mut ct_in: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_in, rank); - let mut ct_out: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct_out, rank); - let mut ct_in_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ct_in, rank); - let mut ct_out_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ct_out, rank); + let mut ct_rgsw: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); + let mut ct_in: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_in, rank); + let mut ct_out: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_out, rank); + let mut ct_in_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ct_in, rank); + let mut ct_out_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ct_out, rank); let mut pt_rgsw: ScalarZnx> = module.new_scalar_znx(1); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_in); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct_out); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct_in); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct_out); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -277,10 +277,10 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, k_ct_in: usi | GLWECiphertextFourier::external_product_scratch_space(&module, ct_out.size(), ct_in.size(), ct_rgsw.size(), rank), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); ct_rgsw.encrypt_sk( @@ -348,12 +348,12 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, k_ct let module: Module = Module::::new(1 << log_n); let rows: usize = (k_ct + basek - 1) / basek; - let mut ct_ggsw: GGSWCiphertext, FFT64> = GGSWCiphertext::new(&module, basek, k_ggsw, rows, rank); - let mut ct: GLWECiphertext> = GLWECiphertext::new(&module, basek, k_ct, rank); - let mut ct_rlwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k_ct, rank); + let mut ct_ggsw: GGSWCiphertext, FFT64> = GGSWCiphertext::alloc(&module, basek, k_ggsw, rows, rank); + let mut ct: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct, rank); + let mut ct_rlwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ct, rank); let mut pt_rgsw: ScalarZnx> = module.new_scalar_znx(1); - let mut pt_want: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); - let mut pt_have: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k_ct); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ct); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -377,10 +377,10 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, k_ct | GLWECiphertextFourier::external_product_inplace_scratch_space(&module, ct.size(), ct_ggsw.size(), rank), ); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); ct_ggsw.encrypt_sk( diff --git a/core/src/test_fft64/mod.rs b/core/src/test_fft64/mod.rs index fb2129e..912cdfd 100644 --- a/core/src/test_fft64/mod.rs +++ b/core/src/test_fft64/mod.rs @@ -4,3 +4,5 @@ mod ggsw; mod glwe; mod glwe_fourier; mod tensor_key; + +mod trace; diff --git a/core/src/test_fft64/tensor_key.rs b/core/src/test_fft64/tensor_key.rs index 920341b..ea90413 100644 --- a/core/src/test_fft64/tensor_key.rs +++ b/core/src/test_fft64/tensor_key.rs @@ -1,4 +1,4 @@ -use base2k::{FFT64, Module, ScalarZnx, ScalarZnxDftAlloc, ScalarZnxDftOps, ScratchOwned, Stats, VecZnxDftOps, VecZnxOps}; +use backend::{Module, ScalarZnx, ScalarZnxDft, ScalarZnxDftAlloc, ScalarZnxDftOps, ScratchOwned, Stats, VecZnxDftOps, VecZnxOps, FFT64}; use sampling::source::Source; use crate::{ @@ -22,7 +22,7 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k: usize, sigma: f64, rank: usize let rows: usize = (k + basek - 1) / basek; - let mut tensor_key: TensorKey, FFT64> = TensorKey::new(&module, basek, k, rows, rank); + let mut tensor_key: TensorKey, FFT64> = TensorKey::alloc(&module, basek, k, rows, rank); let mut source_xs: Source = Source::new([0u8; 32]); let mut source_xe: Source = Source::new([0u8; 32]); @@ -34,10 +34,10 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k: usize, sigma: f64, rank: usize tensor_key.size(), )); - let mut sk: SecretKey> = SecretKey::new(&module, rank); + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); sk.fill_ternary_prob(0.5, &mut source_xs); - let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::new(&module, rank); + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_dft.dft(&module, &sk); tensor_key.encrypt_sk( @@ -49,12 +49,12 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k: usize, sigma: f64, rank: usize scratch.borrow(), ); - let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::new(&module, basek, k, rank); - let mut pt: GLWEPlaintext> = GLWEPlaintext::new(&module, basek, k); + let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k, rank); + let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); (0..rank).for_each(|i| { (0..rank).for_each(|j| { - let mut sk_ij_dft: base2k::ScalarZnxDft, FFT64> = module.new_scalar_znx_dft(1); + let mut sk_ij_dft: ScalarZnxDft, FFT64> = module.new_scalar_znx_dft(1); module.svp_apply(&mut sk_ij_dft, 0, &sk_dft.data, i, &sk_dft.data, j); let sk_ij: ScalarZnx> = module .vec_znx_idft_consume(sk_ij_dft.as_vec_znx_dft()) diff --git a/core/src/test_fft64/trace.rs b/core/src/test_fft64/trace.rs new file mode 100644 index 0000000..34f466a --- /dev/null +++ b/core/src/test_fft64/trace.rs @@ -0,0 +1,116 @@ +use std::collections::HashMap; + +use backend::{FFT64, FillUniform, Module, ScratchOwned, Stats, VecZnxOps, ZnxView, ZnxViewMut}; +use sampling::source::Source; + +use crate::{ + automorphism::AutomorphismKey, + elem::Infos, + glwe_ciphertext::GLWECiphertext, + glwe_plaintext::GLWEPlaintext, + keys::{SecretKey, SecretKeyFourier}, + test_fft64::gglwe::var_noise_gglwe_product, +}; + +#[test] +fn trace_inplace() { + (1..4).for_each(|rank| { + println!("test trace_inplace rank: {}", rank); + test_trace_inplace(11, 8, 54, 3.2, rank); + }); +} + +fn test_trace_inplace(log_n: usize, basek: usize, k: usize, sigma: f64, rank: usize) { + let module: Module = Module::::new(1 << log_n); + + let k_autokey: usize = k + basek; + + let rows: usize = (k + basek - 1) / basek; + + let mut ct: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k, rank); + let mut pt_want: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); + let mut pt_have: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k); + + 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 scratch: ScratchOwned = ScratchOwned::new( + GLWECiphertext::encrypt_sk_scratch_space(&module, ct.size()) + | GLWECiphertext::decrypt_scratch_space(&module, ct.size()) + | AutomorphismKey::generate_from_sk_scratch_space(&module, rank, k_autokey) + | GLWECiphertext::trace_inplace_scratch_space(&module, ct.size(), k_autokey, rank), + ); + + let mut sk: SecretKey> = SecretKey::alloc(&module, rank); + sk.fill_ternary_prob(0.5, &mut source_xs); + + let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); + sk_dft.dft(&module, &sk); + + let mut data_want: Vec = vec![0i64; module.n()]; + + data_want + .iter_mut() + .for_each(|x| *x = source_xa.next_i64() & 0xFF); + + pt_have + .data + .fill_uniform(basek, 0, pt_have.size(), &mut source_xa); + + ct.encrypt_sk( + &module, + &pt_have, + &sk_dft, + &mut source_xa, + &mut source_xe, + sigma, + scratch.borrow(), + ); + + let mut auto_keys: HashMap, FFT64>> = HashMap::new(); + let gal_els: Vec = GLWECiphertext::trace_galois_elements(&module); + gal_els.iter().for_each(|gal_el| { + let mut key: AutomorphismKey, FFT64> = AutomorphismKey::alloc(&module, basek, k_autokey, rows, rank); + key.generate_from_sk( + &module, + *gal_el, + &sk, + &mut source_xa, + &mut source_xe, + sigma, + scratch.borrow(), + ); + auto_keys.insert(*gal_el, key); + }); + + ct.trace_inplace(&module, 0, 5, &auto_keys, scratch.borrow()); + ct.trace_inplace(&module, 5, log_n, &auto_keys, scratch.borrow()); + + (0..pt_want.size()).for_each(|i| pt_want.data.at_mut(0, i)[0] = pt_have.data.at(0, i)[0]); + + ct.decrypt(&module, &mut pt_have, &sk_dft, scratch.borrow()); + + module.vec_znx_sub_ab_inplace(&mut pt_want, 0, &pt_have, 0); + module.vec_znx_normalize_inplace(basek, &mut pt_want, 0, scratch.borrow()); + + let noise_have = pt_want.data.std(0, basek).log2(); + + let mut noise_want: f64 = var_noise_gglwe_product( + module.n() as f64, + basek, + 0.5, + 0.5, + 1.0 / 12.0, + sigma * sigma, + 0.0, + rank as f64, + k, + k_autokey, + ); + noise_want += sigma * sigma * (-2.0 * (k) as f64).exp2(); + noise_want += module.n() as f64 * 1.0 / 12.0 * 0.5 * rank as f64 * (-2.0 * (k) as f64).exp2(); + noise_want = noise_want.sqrt().log2(); + + assert!((noise_have - noise_want).abs() < 1.0); +} diff --git a/core/src/trace.rs b/core/src/trace.rs new file mode 100644 index 0000000..1169795 --- /dev/null +++ b/core/src/trace.rs @@ -0,0 +1,82 @@ +use std::collections::HashMap; + +use backend::{FFT64, MatZnxDft, MatZnxDftToRef, Module, Scratch, VecZnx, VecZnxToMut, VecZnxToRef}; + +use crate::{automorphism::AutomorphismKey, glwe_ciphertext::GLWECiphertext}; + +impl GLWECiphertext> { + pub fn trace_galois_elements(module: &Module) -> Vec { + let mut gal_els: Vec = Vec::new(); + (0..module.log_n()).for_each(|i| { + if i == 0 { + gal_els.push(-1); + } else { + gal_els.push(module.galois_element(1 << (i - 1))); + } + }); + gal_els + } + + pub fn trace_scratch_space( + module: &Module, + out_size: usize, + in_size: usize, + autokey_size: usize, + rank: usize, + ) -> usize { + Self::automorphism_inplace_scratch_space(module, out_size.max(in_size), rank, autokey_size) + } + + pub fn trace_inplace_scratch_space(module: &Module, out_size: usize, autokey_size: usize, rank: usize) -> usize { + Self::automorphism_inplace_scratch_space(module, out_size, rank, autokey_size) + } +} + +impl GLWECiphertext +where + VecZnx: VecZnxToMut + VecZnxToRef, +{ + pub fn trace( + &mut self, + module: &Module, + start: usize, + end: usize, + lhs: &GLWECiphertext, + auto_keys: &HashMap>, + scratch: &mut Scratch, + ) where + VecZnx: VecZnxToRef, + MatZnxDft: MatZnxDftToRef, + { + self.copy(lhs); + self.trace_inplace(module, start, end, auto_keys, scratch); + } + + pub fn trace_inplace( + &mut self, + module: &Module, + start: usize, + end: usize, + auto_keys: &HashMap>, + scratch: &mut Scratch, + ) where + MatZnxDft: MatZnxDftToRef, + { + (start..end).for_each(|i| { + self.rsh(1, scratch); + + let p: i64; + if i == 0 { + p = -1; + } else { + p = module.galois_element(1 << (i - 1)); + } + + if let Some(key) = auto_keys.get(&p) { + self.automorphism_add_inplace(module, key, scratch); + } else { + panic!("auto_keys[{}] is empty", p) + } + }); + } +} From dbbbe2bd92fd22352769fa0fccb497a5830e024b Mon Sep 17 00:00:00 2001 From: Jean-Philippe Bossuat Date: Thu, 22 May 2025 09:46:29 +0200 Subject: [PATCH 02/10] fixed benches --- core/benches/external_product_glwe_fft64.rs | 2 +- core/benches/keyswitch_glwe_fft64.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/core/benches/external_product_glwe_fft64.rs b/core/benches/external_product_glwe_fft64.rs index 5e7e07c..b99e875 100644 --- a/core/benches/external_product_glwe_fft64.rs +++ b/core/benches/external_product_glwe_fft64.rs @@ -1,6 +1,6 @@ use backend::{Module, ScalarZnx, ScalarZnxAlloc, ScratchOwned, FFT64}; use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main}; -use rlwe::{ +use core::{ elem::Infos, ggsw_ciphertext::GGSWCiphertext, glwe_ciphertext::GLWECiphertext, diff --git a/core/benches/keyswitch_glwe_fft64.rs b/core/benches/keyswitch_glwe_fft64.rs index 3dae4f8..16ea862 100644 --- a/core/benches/keyswitch_glwe_fft64.rs +++ b/core/benches/keyswitch_glwe_fft64.rs @@ -1,6 +1,6 @@ use backend::{FFT64, Module, ScratchOwned}; use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main}; -use rlwe::{ +use core::{ elem::Infos, glwe_ciphertext::GLWECiphertext, keys::{SecretKey, SecretKeyFourier}, From 30849789764e2ee5f96d97e5ef349f056ec84f13 Mon Sep 17 00:00:00 2001 From: Jean-Philippe Bossuat Date: Thu, 22 May 2025 16:08:44 +0200 Subject: [PATCH 03/10] Added basic GLWE ops --- backend/examples/rlwe_encrypt.rs | 2 +- backend/src/mat_znx_dft.rs | 464 ++++++++++---------- backend/src/vec_znx.rs | 2 +- backend/src/vec_znx_big_ops.rs | 22 +- backend/src/vec_znx_dft.rs | 2 +- backend/src/vec_znx_ops.rs | 25 ++ core/benches/external_product_glwe_fft64.rs | 4 +- core/benches/keyswitch_glwe_fft64.rs | 2 +- core/src/automorphism.rs | 4 +- core/src/elem.rs | 9 + core/src/ggsw_ciphertext.rs | 8 +- core/src/glwe_ciphertext.rs | 37 +- core/src/glwe_ciphertext_fourier.rs | 6 +- core/src/glwe_ops.rs | 213 +++++++++ core/src/keys.rs | 2 +- core/src/keyswitch_key.rs | 2 +- core/src/lib.rs | 1 + core/src/tensor_key.rs | 2 +- core/src/test_fft64/gglwe.rs | 9 +- core/src/test_fft64/glwe_fourier.rs | 3 +- core/src/test_fft64/tensor_key.rs | 4 +- core/src/trace.rs | 6 +- 22 files changed, 535 insertions(+), 294 deletions(-) create mode 100644 core/src/glwe_ops.rs diff --git a/backend/examples/rlwe_encrypt.rs b/backend/examples/rlwe_encrypt.rs index a16437f..84f85ad 100644 --- a/backend/examples/rlwe_encrypt.rs +++ b/backend/examples/rlwe_encrypt.rs @@ -90,7 +90,7 @@ fn main() { // ct[0] <- ct[0] + e ct.add_normal( basek, - 0, // Selects the first column of ct (ct[0]) + 0, // Selects the first column of ct (ct[0]) basek * ct_size, // Scaling of the noise: 2^{-basek * limbs} &mut source, 3.2, // Standard deviation diff --git a/backend/src/mat_znx_dft.rs b/backend/src/mat_znx_dft.rs index 209c696..1fe67eb 100644 --- a/backend/src/mat_znx_dft.rs +++ b/backend/src/mat_znx_dft.rs @@ -1,232 +1,232 @@ -use crate::znx_base::ZnxInfos; -use crate::{Backend, DataView, DataViewMut, FFT64, Module, ZnxSliceSize, ZnxView, alloc_aligned}; -use std::marker::PhantomData; - -/// Vector Matrix Product Prepared Matrix: a vector of [VecZnx], -/// stored as a 3D matrix in the DFT domain in a single contiguous array. -/// Each col of the [MatZnxDft] can be seen as a collection of [VecZnxDft]. -/// -/// [MatZnxDft] is used to permform a vector matrix product between a [VecZnx]/[VecZnxDft] and a [MatZnxDft]. -/// See the trait [MatZnxDftOps] for additional information. -pub struct MatZnxDft { - data: D, - n: usize, - size: usize, - rows: usize, - cols_in: usize, - cols_out: usize, - _phantom: PhantomData, -} - -impl ZnxInfos for MatZnxDft { - fn cols(&self) -> usize { - self.cols_in - } - - fn rows(&self) -> usize { - self.rows - } - - fn n(&self) -> usize { - self.n - } - - fn size(&self) -> usize { - self.size - } -} - -impl ZnxSliceSize for MatZnxDft { - fn sl(&self) -> usize { - self.n() * self.cols_out() - } -} - -impl DataView for MatZnxDft { - type D = D; - fn data(&self) -> &Self::D { - &self.data - } -} - -impl DataViewMut for MatZnxDft { - fn data_mut(&mut self) -> &mut Self::D { - &mut self.data - } -} - -impl> ZnxView for MatZnxDft { - type Scalar = f64; -} - -impl MatZnxDft { - pub fn cols_in(&self) -> usize { - self.cols_in - } - - pub fn cols_out(&self) -> usize { - self.cols_out - } -} - -impl>, B: Backend> MatZnxDft { - pub(crate) fn bytes_of(module: &Module, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> usize { - unsafe { - crate::ffi::vmp::bytes_of_vmp_pmat( - module.ptr, - (rows * cols_in) as u64, - (size * cols_out) as u64, - ) as usize - } - } - - pub(crate) fn new(module: &Module, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> Self { - let data: Vec = alloc_aligned(Self::bytes_of(module, rows, cols_in, cols_out, size)); - Self { - data: data.into(), - n: module.n(), - size, - rows, - cols_in, - cols_out, - _phantom: PhantomData, - } - } - - pub(crate) fn new_from_bytes( - module: &Module, - rows: usize, - cols_in: usize, - cols_out: usize, - size: usize, - bytes: impl Into>, - ) -> Self { - let data: Vec = bytes.into(); - assert!(data.len() == Self::bytes_of(module, rows, cols_in, cols_out, size)); - Self { - data: data.into(), - n: module.n(), - size, - rows, - cols_in, - cols_out, - _phantom: PhantomData, - } - } -} - -impl> MatZnxDft { - /// Returns a copy of the backend array at index (i, j) of the [MatZnxDft]. - /// - /// # Arguments - /// - /// * `row`: row index (i). - /// * `col`: col index (j). - #[allow(dead_code)] - fn at(&self, row: usize, col: usize) -> Vec { - let n: usize = self.n(); - - let mut res: Vec = alloc_aligned(n); - - if n < 8 { - res.copy_from_slice(&self.raw()[(row + col * self.rows()) * n..(row + col * self.rows()) * (n + 1)]); - } else { - (0..n >> 3).for_each(|blk| { - res[blk * 8..(blk + 1) * 8].copy_from_slice(&self.at_block(row, col, blk)[..8]); - }); - } - - res - } - - #[allow(dead_code)] - fn at_block(&self, row: usize, col: usize, blk: usize) -> &[f64] { - let nrows: usize = self.rows(); - let nsize: usize = self.size(); - if col == (nsize - 1) && (nsize & 1 == 1) { - &self.raw()[blk * nrows * nsize * 8 + col * nrows * 8 + row * 8..] - } else { - &self.raw()[blk * nrows * nsize * 8 + (col / 2) * (2 * nrows) * 8 + row * 2 * 8 + (col % 2) * 8..] - } - } -} - -pub type MatZnxDftOwned = MatZnxDft, B>; - -pub trait MatZnxDftToRef { - fn to_ref(&self) -> MatZnxDft<&[u8], B>; -} - -pub trait MatZnxDftToMut { - fn to_mut(&mut self) -> MatZnxDft<&mut [u8], B>; -} - -impl MatZnxDftToMut for MatZnxDft, B> { - fn to_mut(&mut self) -> MatZnxDft<&mut [u8], B> { - MatZnxDft { - data: self.data.as_mut_slice(), - n: self.n, - rows: self.rows, - cols_in: self.cols_in, - cols_out: self.cols_out, - size: self.size, - _phantom: PhantomData, - } - } -} - -impl MatZnxDftToRef for MatZnxDft, B> { - fn to_ref(&self) -> MatZnxDft<&[u8], B> { - MatZnxDft { - data: self.data.as_slice(), - n: self.n, - rows: self.rows, - cols_in: self.cols_in, - cols_out: self.cols_out, - size: self.size, - _phantom: PhantomData, - } - } -} - -impl MatZnxDftToMut for MatZnxDft<&mut [u8], B> { - fn to_mut(&mut self) -> MatZnxDft<&mut [u8], B> { - MatZnxDft { - data: self.data, - n: self.n, - rows: self.rows, - cols_in: self.cols_in, - cols_out: self.cols_out, - size: self.size, - _phantom: PhantomData, - } - } -} - -impl MatZnxDftToRef for MatZnxDft<&mut [u8], B> { - fn to_ref(&self) -> MatZnxDft<&[u8], B> { - MatZnxDft { - data: self.data, - n: self.n, - rows: self.rows, - cols_in: self.cols_in, - cols_out: self.cols_out, - size: self.size, - _phantom: PhantomData, - } - } -} - -impl MatZnxDftToRef for MatZnxDft<&[u8], B> { - fn to_ref(&self) -> MatZnxDft<&[u8], B> { - MatZnxDft { - data: self.data, - n: self.n, - rows: self.rows, - cols_in: self.cols_in, - cols_out: self.cols_out, - size: self.size, - _phantom: PhantomData, - } - } -} +use crate::znx_base::ZnxInfos; +use crate::{Backend, DataView, DataViewMut, FFT64, Module, ZnxSliceSize, ZnxView, alloc_aligned}; +use std::marker::PhantomData; + +/// Vector Matrix Product Prepared Matrix: a vector of [VecZnx], +/// stored as a 3D matrix in the DFT domain in a single contiguous array. +/// Each col of the [MatZnxDft] can be seen as a collection of [VecZnxDft]. +/// +/// [MatZnxDft] is used to permform a vector matrix product between a [VecZnx]/[VecZnxDft] and a [MatZnxDft]. +/// See the trait [MatZnxDftOps] for additional information. +pub struct MatZnxDft { + data: D, + n: usize, + size: usize, + rows: usize, + cols_in: usize, + cols_out: usize, + _phantom: PhantomData, +} + +impl ZnxInfos for MatZnxDft { + fn cols(&self) -> usize { + self.cols_in + } + + fn rows(&self) -> usize { + self.rows + } + + fn n(&self) -> usize { + self.n + } + + fn size(&self) -> usize { + self.size + } +} + +impl ZnxSliceSize for MatZnxDft { + fn sl(&self) -> usize { + self.n() * self.cols_out() + } +} + +impl DataView for MatZnxDft { + type D = D; + fn data(&self) -> &Self::D { + &self.data + } +} + +impl DataViewMut for MatZnxDft { + fn data_mut(&mut self) -> &mut Self::D { + &mut self.data + } +} + +impl> ZnxView for MatZnxDft { + type Scalar = f64; +} + +impl MatZnxDft { + pub fn cols_in(&self) -> usize { + self.cols_in + } + + pub fn cols_out(&self) -> usize { + self.cols_out + } +} + +impl>, B: Backend> MatZnxDft { + pub(crate) fn bytes_of(module: &Module, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> usize { + unsafe { + crate::ffi::vmp::bytes_of_vmp_pmat( + module.ptr, + (rows * cols_in) as u64, + (size * cols_out) as u64, + ) as usize + } + } + + pub(crate) fn new(module: &Module, rows: usize, cols_in: usize, cols_out: usize, size: usize) -> Self { + let data: Vec = alloc_aligned(Self::bytes_of(module, rows, cols_in, cols_out, size)); + Self { + data: data.into(), + n: module.n(), + size, + rows, + cols_in, + cols_out, + _phantom: PhantomData, + } + } + + pub(crate) fn new_from_bytes( + module: &Module, + rows: usize, + cols_in: usize, + cols_out: usize, + size: usize, + bytes: impl Into>, + ) -> Self { + let data: Vec = bytes.into(); + assert!(data.len() == Self::bytes_of(module, rows, cols_in, cols_out, size)); + Self { + data: data.into(), + n: module.n(), + size, + rows, + cols_in, + cols_out, + _phantom: PhantomData, + } + } +} + +impl> MatZnxDft { + /// Returns a copy of the backend array at index (i, j) of the [MatZnxDft]. + /// + /// # Arguments + /// + /// * `row`: row index (i). + /// * `col`: col index (j). + #[allow(dead_code)] + fn at(&self, row: usize, col: usize) -> Vec { + let n: usize = self.n(); + + let mut res: Vec = alloc_aligned(n); + + if n < 8 { + res.copy_from_slice(&self.raw()[(row + col * self.rows()) * n..(row + col * self.rows()) * (n + 1)]); + } else { + (0..n >> 3).for_each(|blk| { + res[blk * 8..(blk + 1) * 8].copy_from_slice(&self.at_block(row, col, blk)[..8]); + }); + } + + res + } + + #[allow(dead_code)] + fn at_block(&self, row: usize, col: usize, blk: usize) -> &[f64] { + let nrows: usize = self.rows(); + let nsize: usize = self.size(); + if col == (nsize - 1) && (nsize & 1 == 1) { + &self.raw()[blk * nrows * nsize * 8 + col * nrows * 8 + row * 8..] + } else { + &self.raw()[blk * nrows * nsize * 8 + (col / 2) * (2 * nrows) * 8 + row * 2 * 8 + (col % 2) * 8..] + } + } +} + +pub type MatZnxDftOwned = MatZnxDft, B>; + +pub trait MatZnxDftToRef { + fn to_ref(&self) -> MatZnxDft<&[u8], B>; +} + +pub trait MatZnxDftToMut: MatZnxDftToRef { + fn to_mut(&mut self) -> MatZnxDft<&mut [u8], B>; +} + +impl MatZnxDftToMut for MatZnxDft, B> { + fn to_mut(&mut self) -> MatZnxDft<&mut [u8], B> { + MatZnxDft { + data: self.data.as_mut_slice(), + n: self.n, + rows: self.rows, + cols_in: self.cols_in, + cols_out: self.cols_out, + size: self.size, + _phantom: PhantomData, + } + } +} + +impl MatZnxDftToRef for MatZnxDft, B> { + fn to_ref(&self) -> MatZnxDft<&[u8], B> { + MatZnxDft { + data: self.data.as_slice(), + n: self.n, + rows: self.rows, + cols_in: self.cols_in, + cols_out: self.cols_out, + size: self.size, + _phantom: PhantomData, + } + } +} + +impl MatZnxDftToMut for MatZnxDft<&mut [u8], B> { + fn to_mut(&mut self) -> MatZnxDft<&mut [u8], B> { + MatZnxDft { + data: self.data, + n: self.n, + rows: self.rows, + cols_in: self.cols_in, + cols_out: self.cols_out, + size: self.size, + _phantom: PhantomData, + } + } +} + +impl MatZnxDftToRef for MatZnxDft<&mut [u8], B> { + fn to_ref(&self) -> MatZnxDft<&[u8], B> { + MatZnxDft { + data: self.data, + n: self.n, + rows: self.rows, + cols_in: self.cols_in, + cols_out: self.cols_out, + size: self.size, + _phantom: PhantomData, + } + } +} + +impl MatZnxDftToRef for MatZnxDft<&[u8], B> { + fn to_ref(&self) -> MatZnxDft<&[u8], B> { + MatZnxDft { + data: self.data, + n: self.n, + rows: self.rows, + cols_in: self.cols_in, + cols_out: self.cols_out, + size: self.size, + _phantom: PhantomData, + } + } +} diff --git a/backend/src/vec_znx.rs b/backend/src/vec_znx.rs index 950fae9..feba7ce 100644 --- a/backend/src/vec_znx.rs +++ b/backend/src/vec_znx.rs @@ -313,7 +313,7 @@ pub trait VecZnxToRef { fn to_ref(&self) -> VecZnx<&[u8]>; } -pub trait VecZnxToMut { +pub trait VecZnxToMut: VecZnxToRef { fn to_mut(&mut self) -> VecZnx<&mut [u8]>; } diff --git a/backend/src/vec_znx_big_ops.rs b/backend/src/vec_znx_big_ops.rs index d23dc22..a88dd27 100644 --- a/backend/src/vec_znx_big_ops.rs +++ b/backend/src/vec_znx_big_ops.rs @@ -125,15 +125,8 @@ pub trait VecZnxBigOps { /// /// * `basek`: normalization basis. /// * `tmp_bytes`: scratch space of size at least [VecZnxBigOps::vec_znx_big_normalize]. - fn vec_znx_big_normalize( - &self, - basek: usize, - res: &mut R, - res_col: usize, - a: &A, - a_col: usize, - scratch: &mut Scratch, - ) where + fn vec_znx_big_normalize(&self, basek: usize, res: &mut R, res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch) + where R: VecZnxToMut, A: VecZnxBigToRef; @@ -530,15 +523,8 @@ impl VecZnxBigOps for Module { } } - fn vec_znx_big_normalize( - &self, - basek: usize, - res: &mut R, - res_col: usize, - a: &A, - a_col: usize, - scratch: &mut Scratch, - ) where + fn vec_znx_big_normalize(&self, basek: usize, res: &mut R, res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch) + where R: VecZnxToMut, A: VecZnxBigToRef, { diff --git a/backend/src/vec_znx_dft.rs b/backend/src/vec_znx_dft.rs index 7b4ec29..c304089 100644 --- a/backend/src/vec_znx_dft.rs +++ b/backend/src/vec_znx_dft.rs @@ -142,7 +142,7 @@ pub trait VecZnxDftToRef { fn to_ref(&self) -> VecZnxDft<&[u8], B>; } -pub trait VecZnxDftToMut { +pub trait VecZnxDftToMut: VecZnxDftToRef { fn to_mut(&mut self) -> VecZnxDft<&mut [u8], B>; } diff --git a/backend/src/vec_znx_ops.rs b/backend/src/vec_znx_ops.rs index 90321a5..106f777 100644 --- a/backend/src/vec_znx_ops.rs +++ b/backend/src/vec_znx_ops.rs @@ -152,6 +152,11 @@ pub trait VecZnxOps { where R: VecZnxToMut, A: VecZnxToRef; + + fn vec_znx_copy(&self, res: &mut R, res_col: usize, a: &A, a_col: usize) + where + R: VecZnxToMut, + A: VecZnxToRef; } pub trait VecZnxScratch { @@ -174,6 +179,26 @@ impl VecZnxAlloc for Module { } impl VecZnxOps for Module { + fn vec_znx_copy(&self, res: &mut R, res_col: usize, a: &A, a_col: usize) + where + R: VecZnxToMut, + A: VecZnxToRef, + { + let mut res_mut: VecZnx<&mut [u8]> = res.to_mut(); + let a_ref: VecZnx<&[u8]> = a.to_ref(); + + let min_size: usize = min(res_mut.size(), a_ref.size()); + + (0..min_size).for_each(|j| { + res_mut + .at_mut(res_col, j) + .copy_from_slice(a_ref.at(a_col, j)); + }); + (min_size..res_mut.size()).for_each(|j| { + res_mut.zero_at(res_col, j); + }) + } + fn vec_znx_normalize(&self, basek: usize, res: &mut R, res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch) where R: VecZnxToMut, diff --git a/core/benches/external_product_glwe_fft64.rs b/core/benches/external_product_glwe_fft64.rs index b99e875..7c57a2f 100644 --- a/core/benches/external_product_glwe_fft64.rs +++ b/core/benches/external_product_glwe_fft64.rs @@ -1,11 +1,11 @@ -use backend::{Module, ScalarZnx, ScalarZnxAlloc, ScratchOwned, FFT64}; -use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main}; +use backend::{FFT64, Module, ScalarZnx, ScalarZnxAlloc, ScratchOwned}; use core::{ elem::Infos, ggsw_ciphertext::GGSWCiphertext, glwe_ciphertext::GLWECiphertext, keys::{SecretKey, SecretKeyFourier}, }; +use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main}; use sampling::source::Source; fn bench_external_product_glwe_fft64(c: &mut Criterion) { diff --git a/core/benches/keyswitch_glwe_fft64.rs b/core/benches/keyswitch_glwe_fft64.rs index 16ea862..0d30b80 100644 --- a/core/benches/keyswitch_glwe_fft64.rs +++ b/core/benches/keyswitch_glwe_fft64.rs @@ -1,11 +1,11 @@ use backend::{FFT64, Module, ScratchOwned}; -use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main}; use core::{ elem::Infos, glwe_ciphertext::GLWECiphertext, keys::{SecretKey, SecretKeyFourier}, keyswitch_key::GLWESwitchingKey, }; +use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main}; use sampling::source::Source; fn bench_keyswitch_glwe_fft64(c: &mut Criterion) { diff --git a/core/src/automorphism.rs b/core/src/automorphism.rs index a120594..91f13e5 100644 --- a/core/src/automorphism.rs +++ b/core/src/automorphism.rs @@ -168,7 +168,7 @@ impl AutomorphismKey, FFT64> { impl AutomorphismKey where - MatZnxDft: MatZnxDftToMut + MatZnxDftToRef, + MatZnxDft: MatZnxDftToMut, { pub fn generate_from_sk( &mut self, @@ -221,7 +221,7 @@ where impl AutomorphismKey where - MatZnxDft: MatZnxDftToMut + MatZnxDftToRef, + MatZnxDft: MatZnxDftToMut, { pub fn automorphism( &mut self, diff --git a/core/src/elem.rs b/core/src/elem.rs index 554b743..426e23d 100644 --- a/core/src/elem.rs +++ b/core/src/elem.rs @@ -27,6 +27,10 @@ pub trait Infos { self.inner().cols() } + fn rank(&self) -> usize { + self.cols() - 1 + } + /// Returns the number of size per polynomial. fn size(&self) -> usize { let size: usize = self.inner().size(); @@ -46,6 +50,11 @@ pub trait Infos { fn k(&self) -> usize; } +pub trait SetMetaData { + fn set_basek(&mut self, basek: usize); + fn set_k(&mut self, k: usize); +} + pub trait GetRow { fn get_row(&self, module: &Module, row_i: usize, col_j: usize, res: &mut R) where diff --git a/core/src/ggsw_ciphertext.rs b/core/src/ggsw_ciphertext.rs index fdbc225..ca22faf 100644 --- a/core/src/ggsw_ciphertext.rs +++ b/core/src/ggsw_ciphertext.rs @@ -1,8 +1,8 @@ use backend::{ Backend, FFT64, MatZnxDft, MatZnxDftAlloc, MatZnxDftOps, MatZnxDftScratch, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx, ScalarZnxDft, ScalarZnxDftToRef, ScalarZnxToRef, Scratch, VecZnx, VecZnxAlloc, VecZnxBigAlloc, VecZnxBigOps, - VecZnxBigScratch, VecZnxDft, VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, VecZnxDftToRef, VecZnxOps, VecZnxToMut, - VecZnxToRef, ZnxInfos, ZnxZero, + VecZnxBigScratch, VecZnxDft, VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, VecZnxDftToRef, VecZnxOps, VecZnxToMut, ZnxInfos, + ZnxZero, }; use sampling::source::Source; @@ -196,7 +196,7 @@ impl GGSWCiphertext, FFT64> { impl GGSWCiphertext where - MatZnxDft: MatZnxDftToMut + MatZnxDftToRef, + MatZnxDft: MatZnxDftToMut, { pub fn encrypt_sk( &mut self, @@ -639,7 +639,7 @@ where ksk: &GLWESwitchingKey, scratch: &mut Scratch, ) where - VecZnx: VecZnxToMut + VecZnxToRef, + VecZnx: VecZnxToMut, MatZnxDft: MatZnxDftToRef, { #[cfg(debug_assertions)] diff --git a/core/src/glwe_ciphertext.rs b/core/src/glwe_ciphertext.rs index 155eca4..18c2ce0 100644 --- a/core/src/glwe_ciphertext.rs +++ b/core/src/glwe_ciphertext.rs @@ -2,16 +2,17 @@ use backend::{ AddNormal, Backend, FFT64, FillUniform, MatZnxDft, MatZnxDftOps, MatZnxDftScratch, MatZnxDftToRef, Module, ScalarZnxAlloc, ScalarZnxDft, ScalarZnxDftAlloc, ScalarZnxDftOps, ScalarZnxDftToRef, Scratch, VecZnx, VecZnxAlloc, VecZnxBig, VecZnxBigAlloc, VecZnxBigOps, VecZnxBigScratch, VecZnxDft, VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, VecZnxDftToRef, VecZnxOps, - VecZnxToMut, VecZnxToRef, ZnxInfos, ZnxZero, copy_vec_znx_from, + VecZnxToMut, VecZnxToRef, ZnxInfos, ZnxZero, }; use sampling::source::Source; use crate::{ SIX_SIGMA, automorphism::AutomorphismKey, - elem::Infos, + elem::{Infos, SetMetaData}, ggsw_ciphertext::GGSWCiphertext, glwe_ciphertext_fourier::GLWECiphertextFourier, + glwe_ops::GLWEOps, glwe_plaintext::GLWEPlaintext, keys::{GLWEPublicKey, SecretDistribution, SecretKeyFourier}, keyswitch_key::GLWESwitchingKey, @@ -201,9 +202,24 @@ impl GLWECiphertext> { } } +impl SetMetaData for GLWECiphertext +where + VecZnx: VecZnxToMut, +{ + fn set_k(&mut self, k: usize) { + self.k = k + } + + fn set_basek(&mut self, basek: usize) { + self.basek = basek + } +} + +impl GLWEOps for GLWECiphertext where VecZnx: VecZnxToMut {} + impl GLWECiphertext where - VecZnx: VecZnxToMut + VecZnxToRef, + VecZnx: VecZnxToMut, { pub fn encrypt_sk( &mut self, @@ -281,21 +297,6 @@ where self.encrypt_pk_private(module, None, pk, source_xu, source_xe, sigma, scratch); } - pub fn copy(&mut self, other: &GLWECiphertext) - where - VecZnx: VecZnxToRef, - { - copy_vec_znx_from(&mut self.data.to_mut(), &other.to_ref()); - self.k = other.k; - self.basek = other.basek; - } - - pub fn rsh(&mut self, k: usize, scratch: &mut Scratch) { - let basek: usize = self.basek(); - let mut self_mut: VecZnx<&mut [u8]> = self.data.to_mut(); - self_mut.rsh(basek, k, scratch); - } - pub fn automorphism( &mut self, module: &Module, diff --git a/core/src/glwe_ciphertext_fourier.rs b/core/src/glwe_ciphertext_fourier.rs index 20b4f72..921fd55 100644 --- a/core/src/glwe_ciphertext_fourier.rs +++ b/core/src/glwe_ciphertext_fourier.rs @@ -1,7 +1,7 @@ use backend::{ Backend, FFT64, MatZnxDft, MatZnxDftOps, MatZnxDftScratch, MatZnxDftToRef, Module, ScalarZnxDft, ScalarZnxDftOps, ScalarZnxDftToRef, Scratch, VecZnx, VecZnxAlloc, VecZnxBig, VecZnxBigAlloc, VecZnxBigOps, VecZnxBigScratch, VecZnxDft, - VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, VecZnxDftToRef, VecZnxToMut, VecZnxToRef, ZnxZero, + VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, VecZnxDftToRef, VecZnxToMut, ZnxZero, }; use sampling::source::Source; @@ -126,7 +126,7 @@ impl GLWECiphertextFourier, FFT64> { impl GLWECiphertextFourier where - VecZnxDft: VecZnxDftToMut + VecZnxDftToRef, + VecZnxDft: VecZnxDftToMut, { pub fn encrypt_zero_sk( &mut self, @@ -261,7 +261,7 @@ where sk_dft: &SecretKeyFourier, scratch: &mut Scratch, ) where - VecZnx: VecZnxToMut + VecZnxToRef, + VecZnx: VecZnxToMut, ScalarZnxDft: ScalarZnxDftToRef, { #[cfg(debug_assertions)] diff --git a/core/src/glwe_ops.rs b/core/src/glwe_ops.rs new file mode 100644 index 0000000..691e34d --- /dev/null +++ b/core/src/glwe_ops.rs @@ -0,0 +1,213 @@ +use backend::{Backend, Module, Scratch, VecZnx, VecZnxOps, VecZnxToMut, VecZnxToRef, ZnxZero}; + +use crate::elem::{Infos, SetMetaData}; + +pub trait GLWEOps +where + Self: Sized + VecZnxToMut + SetMetaData + Infos, +{ + fn add(&mut self, module: &Module, a: &A, b: &B) + where + A: VecZnxToRef + Infos, + B: VecZnxToRef + Infos, + { + #[cfg(debug_assertions)] + { + assert_eq!(a.n(), module.n()); + assert_eq!(b.n(), module.n()); + assert_eq!(self.n(), module.n()); + assert_eq!(a.basek(), b.basek()); + assert!(self.rank() >= a.rank().max(b.rank())); + } + + let min_col: usize = a.rank().min(b.rank()) + 1; + let max_col: usize = a.rank().max(b.rank() + 1); + let self_col: usize = self.rank() + 1; + + (0..min_col).for_each(|i| { + module.vec_znx_add(self, i, a, i, b, i); + }); + + if a.rank() > b.rank() { + (min_col..max_col).for_each(|i| { + module.vec_znx_copy(self, i, a, i); + }); + } else { + (min_col..max_col).for_each(|i| { + module.vec_znx_copy(self, i, b, i); + }); + } + + let size: usize = self.size(); + let mut self_mut: VecZnx<&mut [u8]> = self.to_mut(); + (max_col..self_col).for_each(|i| { + (0..size).for_each(|j| { + self_mut.zero_at(i, j); + }); + }); + + self.set_basek(a.basek()); + self.set_k(a.k().max(b.k())); + } + + fn add_inplace(&mut self, module: &Module, a: &A) + where + A: VecZnxToRef + Infos, + { + #[cfg(debug_assertions)] + { + assert_eq!(a.n(), module.n()); + assert_eq!(self.n(), module.n()); + assert_eq!(self.basek(), a.basek()); + assert!(self.rank() >= a.rank()) + } + + (0..a.rank() + 1).for_each(|i| { + module.vec_znx_add_inplace(self, i, a, i); + }); + + self.set_k(a.k().max(self.k())); + } + + fn sub(&mut self, module: &Module, a: &A, b: &B) + where + A: VecZnxToRef + Infos, + B: VecZnxToRef + Infos, + { + #[cfg(debug_assertions)] + { + assert_eq!(a.n(), module.n()); + assert_eq!(b.n(), module.n()); + assert_eq!(self.n(), module.n()); + assert_eq!(a.basek(), b.basek()); + assert!(self.rank() >= a.rank().max(b.rank())); + } + + let min_col: usize = a.rank().min(b.rank()) + 1; + let max_col: usize = a.rank().max(b.rank() + 1); + let self_col: usize = self.rank() + 1; + + (0..min_col).for_each(|i| { + module.vec_znx_sub(self, i, a, i, b, i); + }); + + if a.rank() > b.rank() { + (min_col..max_col).for_each(|i| { + module.vec_znx_copy(self, i, a, i); + }); + } else { + (min_col..max_col).for_each(|i| { + module.vec_znx_copy(self, i, b, i); + module.vec_znx_negate_inplace(self, i); + }); + } + + let size: usize = self.size(); + let mut self_mut: VecZnx<&mut [u8]> = self.to_mut(); + (max_col..self_col).for_each(|i| { + (0..size).for_each(|j| { + self_mut.zero_at(i, j); + }); + }); + + self.set_basek(a.basek()); + self.set_k(a.k().max(b.k())); + } + + fn sub_inplace_ab(&mut self, module: &Module, a: &A) + where + A: VecZnxToRef + Infos, + { + #[cfg(debug_assertions)] + { + assert_eq!(a.n(), module.n()); + assert_eq!(self.n(), module.n()); + assert_eq!(self.basek(), a.basek()); + assert!(self.rank() >= a.rank()) + } + + (0..a.rank() + 1).for_each(|i| { + module.vec_znx_sub_ab_inplace(self, i, a, i); + }); + + self.set_k(a.k().max(self.k())); + } + + fn sub_inplace_ba(&mut self, module: &Module, a: &A) + where + A: VecZnxToRef + Infos, + { + #[cfg(debug_assertions)] + { + assert_eq!(a.n(), module.n()); + assert_eq!(self.n(), module.n()); + assert_eq!(self.basek(), a.basek()); + assert!(self.rank() >= a.rank()) + } + + (0..a.rank() + 1).for_each(|i| { + module.vec_znx_sub_ba_inplace(self, i, a, i); + }); + + self.set_k(a.k().max(self.k())); + } + + fn rotate(&mut self, module: &Module, k: i64, a: &A) + where + A: VecZnxToRef + Infos, + { + #[cfg(debug_assertions)] + { + assert_eq!(a.n(), module.n()); + assert_eq!(self.n(), module.n()); + assert_eq!(self.basek(), a.basek()); + assert_eq!(self.rank(), a.rank()) + } + + (0..a.rank() + 1).for_each(|i| { + module.vec_znx_rotate(k, self, i, a, i); + }); + + self.set_k(a.k()); + } + + fn rotate_inplace(&mut self, module: &Module, k: i64) + where + A: VecZnxToRef + Infos, + { + #[cfg(debug_assertions)] + { + assert_eq!(self.n(), module.n()); + } + + (0..self.rank() + 1).for_each(|i| { + module.vec_znx_rotate_inplace(k, self, i); + }); + } + + fn copy(&mut self, module: &Module, a: &A) + where + A: VecZnxToRef + Infos, + { + #[cfg(debug_assertions)] + { + assert_eq!(self.n(), module.n()); + assert_eq!(a.n(), module.n()); + } + + let cols: usize = self.rank().min(a.rank()) + 1; + + (0..cols).for_each(|i| { + module.vec_znx_copy(self, i, a, i); + }); + + self.set_k(a.k()); + self.set_basek(a.basek()); + } + + fn rsh(&mut self, k: usize, scratch: &mut Scratch) { + let basek: usize = self.basek(); + let mut self_mut: VecZnx<&mut [u8]> = self.to_mut(); + self_mut.rsh(basek, k, scratch); + } +} diff --git a/core/src/keys.rs b/core/src/keys.rs index 3b0af56..e8af9b1 100644 --- a/core/src/keys.rs +++ b/core/src/keys.rs @@ -217,7 +217,7 @@ impl GLWEPublicKey { source_xe: &mut Source, sigma: f64, ) where - VecZnxDft: VecZnxDftToMut + VecZnxDftToRef, + VecZnxDft: VecZnxDftToMut, ScalarZnxDft: ScalarZnxDftToRef + ZnxInfos, { #[cfg(debug_assertions)] diff --git a/core/src/keyswitch_key.rs b/core/src/keyswitch_key.rs index a4ace4a..2ee24ed 100644 --- a/core/src/keyswitch_key.rs +++ b/core/src/keyswitch_key.rs @@ -149,7 +149,7 @@ impl GLWESwitchingKey, FFT64> { } impl GLWESwitchingKey where - MatZnxDft: MatZnxDftToMut + MatZnxDftToRef, + MatZnxDft: MatZnxDftToMut, { pub fn encrypt_sk( &mut self, diff --git a/core/src/lib.rs b/core/src/lib.rs index 249ad94..82b3c4b 100644 --- a/core/src/lib.rs +++ b/core/src/lib.rs @@ -4,6 +4,7 @@ pub mod gglwe_ciphertext; pub mod ggsw_ciphertext; pub mod glwe_ciphertext; pub mod glwe_ciphertext_fourier; +pub mod glwe_ops; pub mod glwe_plaintext; pub mod keys; pub mod keyswitch_key; diff --git a/core/src/tensor_key.rs b/core/src/tensor_key.rs index ee31c8d..985f90d 100644 --- a/core/src/tensor_key.rs +++ b/core/src/tensor_key.rs @@ -63,7 +63,7 @@ impl TensorKey, FFT64> { impl TensorKey where - MatZnxDft: MatZnxDftToMut + MatZnxDftToRef, + MatZnxDft: MatZnxDftToMut, { pub fn encrypt_sk( &mut self, diff --git a/core/src/test_fft64/gglwe.rs b/core/src/test_fft64/gglwe.rs index 5324a02..52339f5 100644 --- a/core/src/test_fft64/gglwe.rs +++ b/core/src/test_fft64/gglwe.rs @@ -110,7 +110,8 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ksk: usize, sigma: f64, rank_in scratch.borrow(), ); - let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ksk, rank_out); + let mut ct_glwe_fourier: GLWECiphertextFourier, FFT64> = + GLWECiphertextFourier::alloc(&module, basek, k_ksk, rank_out); (0..ksk.rank_in()).for_each(|col_i| { (0..ksk.rows()).for_each(|row_i| { @@ -202,7 +203,8 @@ fn test_key_switch( // gglwe_{s1}(s0) (x) gglwe_{s2}(s1) = gglwe_{s2}(s0) ct_gglwe_s0s2.keyswitch(&module, &ct_gglwe_s0s1, &ct_gglwe_s1s2, scratch.borrow()); - let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ksk, rank_out_s1s2); + let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = + GLWECiphertextFourier::alloc(&module, basek, k_ksk, rank_out_s1s2); let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ksk); (0..ct_gglwe_s0s2.rank_in()).for_each(|col_i| { @@ -304,7 +306,8 @@ fn test_key_switch_inplace(log_n: usize, basek: usize, k_ksk: usize, sigma: f64, let ct_gglwe_s0s2: GLWESwitchingKey, FFT64> = ct_gglwe_s0s1; - let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ksk, rank_out_s0s1); + let mut ct_glwe_dft: GLWECiphertextFourier, FFT64> = + GLWECiphertextFourier::alloc(&module, basek, k_ksk, rank_out_s0s1); let mut pt: GLWEPlaintext> = GLWEPlaintext::alloc(&module, basek, k_ksk); (0..ct_gglwe_s0s2.rank_in()).for_each(|col_i| { diff --git a/core/src/test_fft64/glwe_fourier.rs b/core/src/test_fft64/glwe_fourier.rs index 4a8c7c1..4532fb8 100644 --- a/core/src/test_fft64/glwe_fourier.rs +++ b/core/src/test_fft64/glwe_fourier.rs @@ -61,7 +61,8 @@ fn test_keyswitch( let mut ksk: GLWESwitchingKey, FFT64> = GLWESwitchingKey::alloc(&module, basek, k_ksk, rows, rank_in, rank_out); let mut ct_glwe_in: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_in, rank_in); - let mut ct_glwe_dft_in: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ct_in, rank_in); + let mut ct_glwe_dft_in: GLWECiphertextFourier, FFT64> = + GLWECiphertextFourier::alloc(&module, basek, k_ct_in, rank_in); let mut ct_glwe_out: GLWECiphertext> = GLWECiphertext::alloc(&module, basek, k_ct_out, rank_out); let mut ct_glwe_dft_out: GLWECiphertextFourier, FFT64> = GLWECiphertextFourier::alloc(&module, basek, k_ct_out, rank_out); diff --git a/core/src/test_fft64/tensor_key.rs b/core/src/test_fft64/tensor_key.rs index ea90413..a897253 100644 --- a/core/src/test_fft64/tensor_key.rs +++ b/core/src/test_fft64/tensor_key.rs @@ -1,4 +1,6 @@ -use backend::{Module, ScalarZnx, ScalarZnxDft, ScalarZnxDftAlloc, ScalarZnxDftOps, ScratchOwned, Stats, VecZnxDftOps, VecZnxOps, FFT64}; +use backend::{ + FFT64, Module, ScalarZnx, ScalarZnxDft, ScalarZnxDftAlloc, ScalarZnxDftOps, ScratchOwned, Stats, VecZnxDftOps, VecZnxOps, +}; use sampling::source::Source; use crate::{ diff --git a/core/src/trace.rs b/core/src/trace.rs index 1169795..07ce1b3 100644 --- a/core/src/trace.rs +++ b/core/src/trace.rs @@ -2,7 +2,7 @@ use std::collections::HashMap; use backend::{FFT64, MatZnxDft, MatZnxDftToRef, Module, Scratch, VecZnx, VecZnxToMut, VecZnxToRef}; -use crate::{automorphism::AutomorphismKey, glwe_ciphertext::GLWECiphertext}; +use crate::{automorphism::AutomorphismKey, glwe_ciphertext::GLWECiphertext, glwe_ops::GLWEOps}; impl GLWECiphertext> { pub fn trace_galois_elements(module: &Module) -> Vec { @@ -34,7 +34,7 @@ impl GLWECiphertext> { impl GLWECiphertext where - VecZnx: VecZnxToMut + VecZnxToRef, + VecZnx: VecZnxToMut, { pub fn trace( &mut self, @@ -48,7 +48,7 @@ where VecZnx: VecZnxToRef, MatZnxDft: MatZnxDftToRef, { - self.copy(lhs); + self.copy(module, lhs); self.trace_inplace(module, start, end, auto_keys, scratch); } From 43c7f21033cdb3dbf363f0346f66cf9934f316a5 Mon Sep 17 00:00:00 2001 From: Jean-Philippe Bossuat Date: Thu, 22 May 2025 17:40:01 +0200 Subject: [PATCH 04/10] some fixes --- backend/src/vec_znx.rs | 16 +++++++++ core/src/glwe_ciphertext.rs | 11 +++++-- core/src/glwe_ops.rs | 65 +++++++++++++++++++++++++++---------- core/src/trace.rs | 2 +- 4 files changed, 73 insertions(+), 21 deletions(-) diff --git a/backend/src/vec_znx.rs b/backend/src/vec_znx.rs index feba7ce..b397adb 100644 --- a/backend/src/vec_znx.rs +++ b/backend/src/vec_znx.rs @@ -371,3 +371,19 @@ impl VecZnxToRef for VecZnx<&[u8]> { } } } + +impl VecZnx +where + VecZnx: VecZnxToRef, +{ + pub fn clone(&self) -> VecZnx> { + let self_ref: VecZnx<&[u8]> = self.to_ref(); + + VecZnx { + data: self_ref.data.to_vec(), + n: self_ref.n, + cols: self_ref.cols, + size: self_ref.size, + } + } +} diff --git a/core/src/glwe_ciphertext.rs b/core/src/glwe_ciphertext.rs index 18c2ce0..4205637 100644 --- a/core/src/glwe_ciphertext.rs +++ b/core/src/glwe_ciphertext.rs @@ -12,7 +12,6 @@ use crate::{ elem::{Infos, SetMetaData}, ggsw_ciphertext::GGSWCiphertext, glwe_ciphertext_fourier::GLWECiphertextFourier, - glwe_ops::GLWEOps, glwe_plaintext::GLWEPlaintext, keys::{GLWEPublicKey, SecretDistribution, SecretKeyFourier}, keyswitch_key::GLWESwitchingKey, @@ -215,8 +214,6 @@ where } } -impl GLWEOps for GLWECiphertext where VecZnx: VecZnxToMut {} - impl GLWECiphertext where VecZnx: VecZnxToMut, @@ -713,6 +710,14 @@ impl GLWECiphertext where VecZnx: VecZnxToRef, { + pub fn clone(&self) -> GLWECiphertext> { + GLWECiphertext { + data: self.data.clone(), + basek: self.basek(), + k: self.k(), + } + } + pub fn decrypt( &self, module: &Module, diff --git a/core/src/glwe_ops.rs b/core/src/glwe_ops.rs index 691e34d..95357ed 100644 --- a/core/src/glwe_ops.rs +++ b/core/src/glwe_ops.rs @@ -1,12 +1,16 @@ -use backend::{Backend, Module, Scratch, VecZnx, VecZnxOps, VecZnxToMut, VecZnxToRef, ZnxZero}; +use backend::{FFT64, Module, Scratch, VecZnx, VecZnxOps, VecZnxToMut, VecZnxToRef, ZnxZero}; -use crate::elem::{Infos, SetMetaData}; +use crate::{ + elem::{Infos, SetMetaData}, + glwe_ciphertext::GLWECiphertext, +}; -pub trait GLWEOps +impl GLWECiphertext where - Self: Sized + VecZnxToMut + SetMetaData + Infos, + Self: Infos, + VecZnx: VecZnxToMut, { - fn add(&mut self, module: &Module, a: &A, b: &B) + pub fn add(&mut self, module: &Module, a: &A, b: &B) where A: VecZnxToRef + Infos, B: VecZnxToRef + Infos, @@ -50,7 +54,7 @@ where self.set_k(a.k().max(b.k())); } - fn add_inplace(&mut self, module: &Module, a: &A) + pub fn add_inplace(&mut self, module: &Module, a: &A) where A: VecZnxToRef + Infos, { @@ -69,7 +73,7 @@ where self.set_k(a.k().max(self.k())); } - fn sub(&mut self, module: &Module, a: &A, b: &B) + pub fn sub(&mut self, module: &Module, a: &A, b: &B) where A: VecZnxToRef + Infos, B: VecZnxToRef + Infos, @@ -114,7 +118,7 @@ where self.set_k(a.k().max(b.k())); } - fn sub_inplace_ab(&mut self, module: &Module, a: &A) + pub fn sub_inplace_ab(&mut self, module: &Module, a: &A) where A: VecZnxToRef + Infos, { @@ -133,7 +137,7 @@ where self.set_k(a.k().max(self.k())); } - fn sub_inplace_ba(&mut self, module: &Module, a: &A) + pub fn sub_inplace_ba(&mut self, module: &Module, a: &A) where A: VecZnxToRef + Infos, { @@ -152,7 +156,7 @@ where self.set_k(a.k().max(self.k())); } - fn rotate(&mut self, module: &Module, k: i64, a: &A) + pub fn rotate(&mut self, module: &Module, k: i64, a: &A) where A: VecZnxToRef + Infos, { @@ -160,7 +164,6 @@ where { assert_eq!(a.n(), module.n()); assert_eq!(self.n(), module.n()); - assert_eq!(self.basek(), a.basek()); assert_eq!(self.rank(), a.rank()) } @@ -168,10 +171,11 @@ where module.vec_znx_rotate(k, self, i, a, i); }); + self.set_basek(a.basek()); self.set_k(a.k()); } - fn rotate_inplace(&mut self, module: &Module, k: i64) + pub fn rotate_inplace(&mut self, module: &Module, k: i64) where A: VecZnxToRef + Infos, { @@ -185,7 +189,7 @@ where }); } - fn copy(&mut self, module: &Module, a: &A) + pub fn copy(&mut self, module: &Module, a: &A) where A: VecZnxToRef + Infos, { @@ -193,11 +197,10 @@ where { assert_eq!(self.n(), module.n()); assert_eq!(a.n(), module.n()); + assert_eq!(self.rank(), a.rank()); } - let cols: usize = self.rank().min(a.rank()) + 1; - - (0..cols).for_each(|i| { + (0..self.rank() + 1).for_each(|i| { module.vec_znx_copy(self, i, a, i); }); @@ -205,9 +208,37 @@ where self.set_basek(a.basek()); } - fn rsh(&mut self, k: usize, scratch: &mut Scratch) { + pub fn rsh(&mut self, k: usize, scratch: &mut Scratch) { let basek: usize = self.basek(); let mut self_mut: VecZnx<&mut [u8]> = self.to_mut(); self_mut.rsh(basek, k, scratch); } + + pub fn normalize(&mut self, module: &Module, a: &A, scratch: &mut Scratch) + where + A: VecZnxToMut + Infos, + { + #[cfg(debug_assertions)] + { + assert_eq!(self.n(), module.n()); + assert_eq!(a.n(), module.n()); + assert_eq!(self.rank(), a.rank()); + } + + (0..self.rank() + 1).for_each(|i| { + module.vec_znx_normalize(a.basek(), self, i, a, i, scratch); + }); + self.set_basek(a.basek()); + self.set_k(a.k()); + } + + pub fn normalize_inplace(&mut self, module: &Module, scratch: &mut Scratch) { + #[cfg(debug_assertions)] + { + assert_eq!(self.n(), module.n()); + } + (0..self.rank() + 1).for_each(|i| { + module.vec_znx_normalize_inplace(self.basek(), self, i, scratch); + }); + } } diff --git a/core/src/trace.rs b/core/src/trace.rs index 07ce1b3..40bd8b7 100644 --- a/core/src/trace.rs +++ b/core/src/trace.rs @@ -2,7 +2,7 @@ use std::collections::HashMap; use backend::{FFT64, MatZnxDft, MatZnxDftToRef, Module, Scratch, VecZnx, VecZnxToMut, VecZnxToRef}; -use crate::{automorphism::AutomorphismKey, glwe_ciphertext::GLWECiphertext, glwe_ops::GLWEOps}; +use crate::{automorphism::AutomorphismKey, glwe_ciphertext::GLWECiphertext}; impl GLWECiphertext> { pub fn trace_galois_elements(module: &Module) -> Vec { From cb284a4c4c50736c2e1d62912689f94c12b708a3 Mon Sep 17 00:00:00 2001 From: Jean-Philippe Bossuat Date: Sun, 25 May 2025 11:15:59 +0200 Subject: [PATCH 05/10] wip --- backend/src/vec_znx.rs | 2 +- core/src/glwe_ciphertext.rs | 70 +++++++++++++++++++++++++++---- core/src/glwe_ops.rs | 11 +++-- core/src/tensor_key.rs | 4 +- core/src/test_fft64/ggsw.rs | 16 +++---- core/src/test_fft64/tensor_key.rs | 4 +- 6 files changed, 83 insertions(+), 24 deletions(-) diff --git a/backend/src/vec_znx.rs b/backend/src/vec_znx.rs index b397adb..a4de563 100644 --- a/backend/src/vec_znx.rs +++ b/backend/src/vec_znx.rs @@ -71,7 +71,7 @@ impl> ZnxView for VecZnx { type Scalar = i64; } -impl> VecZnx { +impl VecZnx> { pub fn rsh_scratch_space(n: usize) -> usize { n * std::mem::size_of::() } diff --git a/core/src/glwe_ciphertext.rs b/core/src/glwe_ciphertext.rs index 4205637..9c3f32e 100644 --- a/core/src/glwe_ciphertext.rs +++ b/core/src/glwe_ciphertext.rs @@ -334,7 +334,7 @@ where VecZnx: VecZnxToRef, MatZnxDft: MatZnxDftToRef, { - Self::keyswitch_private(self, true, rhs.p(), module, lhs, &rhs.key, scratch); + Self::keyswitch_private::<_, _, 1>(self, rhs.p(), module, lhs, &rhs.key, scratch); } pub fn automorphism_add_inplace( @@ -347,7 +347,61 @@ where { unsafe { let self_ptr: *mut GLWECiphertext = self as *mut GLWECiphertext; - Self::keyswitch_private(self, true, rhs.p(), module, &*self_ptr, &rhs.key, scratch); + Self::keyswitch_private::<_, _, 1>(self, rhs.p(), module, &*self_ptr, &rhs.key, scratch); + } + } + + pub fn automorphism_sub_ab( + &mut self, + module: &Module, + lhs: &GLWECiphertext, + rhs: &AutomorphismKey, + scratch: &mut Scratch, + ) where + VecZnx: VecZnxToRef, + MatZnxDft: MatZnxDftToRef, + { + Self::keyswitch_private::<_, _, 2>(self, rhs.p(), module, lhs, &rhs.key, scratch); + } + + pub fn automorphism_sub_ab_inplace( + &mut self, + module: &Module, + rhs: &AutomorphismKey, + scratch: &mut Scratch, + ) where + MatZnxDft: MatZnxDftToRef, + { + unsafe { + let self_ptr: *mut GLWECiphertext = self as *mut GLWECiphertext; + Self::keyswitch_private::<_, _, 2>(self, rhs.p(), module, &*self_ptr, &rhs.key, scratch); + } + } + + pub fn automorphism_sub_ba( + &mut self, + module: &Module, + lhs: &GLWECiphertext, + rhs: &AutomorphismKey, + scratch: &mut Scratch, + ) where + VecZnx: VecZnxToRef, + MatZnxDft: MatZnxDftToRef, + { + Self::keyswitch_private::<_, _, 3>(self, rhs.p(), module, lhs, &rhs.key, scratch); + } + + pub fn automorphism_sub_ba_inplace( + &mut self, + module: &Module, + rhs: &AutomorphismKey, + scratch: &mut Scratch, + ) where + MatZnxDft: MatZnxDftToRef, + { + unsafe { + let self_ptr: *mut GLWECiphertext = self as *mut GLWECiphertext; + Self::keyswitch_private::<_, _, 3>(self, rhs.p(), module, &*self_ptr, &rhs.key, scratch); } } @@ -420,12 +474,11 @@ where VecZnx: VecZnxToRef, MatZnxDft: MatZnxDftToRef, { - Self::keyswitch_private(self, false, 0, module, lhs, rhs, scratch); + Self::keyswitch_private::<_, _, 0>(self, 0, module, lhs, rhs, scratch); } - pub(crate) fn keyswitch_private( + pub(crate) fn keyswitch_private( &mut self, - add_self: bool, apply_auto: i64, module: &Module, lhs: &GLWECiphertext, @@ -481,8 +534,11 @@ where module.vec_znx_big_automorphism_inplace(apply_auto, &mut res_big, i); } - if add_self { - module.vec_znx_big_add_small_inplace(&mut res_big, i, lhs, i); + match OP{ + 1=> module.vec_znx_big_add_small_inplace(&mut res_big, i, lhs, i), + 2=> module.vec_znx_big_sub_small_a_inplace(&mut res_big, i, lhs, i), + 3=> module.vec_znx_big_sub_small_b_inplace(&mut res_big, i, lhs, i), + _=>{}, } module.vec_znx_big_normalize(basek, self, i, &res_big, i, scratch1); }); diff --git a/core/src/glwe_ops.rs b/core/src/glwe_ops.rs index 95357ed..61f9ad2 100644 --- a/core/src/glwe_ops.rs +++ b/core/src/glwe_ops.rs @@ -175,10 +175,7 @@ where self.set_k(a.k()); } - pub fn rotate_inplace(&mut self, module: &Module, k: i64) - where - A: VecZnxToRef + Infos, - { + pub fn rotate_inplace(&mut self, module: &Module, k: i64){ #[cfg(debug_assertions)] { assert_eq!(self.n(), module.n()); @@ -242,3 +239,9 @@ where }); } } + +impl GLWECiphertext>{ + pub fn rsh_scratch_space(module: &Module) -> usize{ + VecZnx::rsh_scratch_space(module.n()) + } +} \ No newline at end of file diff --git a/core/src/tensor_key.rs b/core/src/tensor_key.rs index 985f90d..105dace 100644 --- a/core/src/tensor_key.rs +++ b/core/src/tensor_key.rs @@ -56,7 +56,7 @@ impl TensorKey { } impl TensorKey, FFT64> { - pub fn encrypt_sk_scratch_space(module: &Module, rank: usize, size: usize) -> usize { + pub fn generate_from_sk_scratch_space(module: &Module, rank: usize, size: usize) -> usize { module.bytes_of_scalar_znx_dft(1) + GLWESwitchingKey::encrypt_sk_scratch_space(module, rank, size) } } @@ -65,7 +65,7 @@ impl TensorKey where MatZnxDft: MatZnxDftToMut, { - pub fn encrypt_sk( + pub fn generate_from_sk( &mut self, module: &Module, sk_dft: &SecretKeyFourier, diff --git a/core/src/test_fft64/ggsw.rs b/core/src/test_fft64/ggsw.rs index 45855a5..5a244ba 100644 --- a/core/src/test_fft64/ggsw.rs +++ b/core/src/test_fft64/ggsw.rs @@ -160,7 +160,7 @@ fn test_keyswitch(log_n: usize, basek: usize, k: usize, rank: usize, sigma: f64) GGSWCiphertext::encrypt_sk_scratch_space(&module, rank, ct_in.size()) | GLWECiphertextFourier::decrypt_scratch_space(&module, ct_out.size()) | GLWESwitchingKey::encrypt_sk_scratch_space(&module, rank, ksk.size()) - | TensorKey::encrypt_sk_scratch_space(&module, rank, ksk.size()) + | TensorKey::generate_from_sk_scratch_space(&module, rank, ksk.size()) | GGSWCiphertext::keyswitch_scratch_space( &module, ct_out.size(), @@ -194,7 +194,7 @@ fn test_keyswitch(log_n: usize, basek: usize, k: usize, rank: usize, sigma: f64) sigma, scratch.borrow(), ); - tsk.encrypt_sk( + tsk.generate_from_sk( &module, &sk_out_dft, &mut source_xa, @@ -286,7 +286,7 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k: usize, rank: usize, sig GGSWCiphertext::encrypt_sk_scratch_space(&module, rank, ct.size()) | GLWECiphertextFourier::decrypt_scratch_space(&module, ct.size()) | GLWESwitchingKey::encrypt_sk_scratch_space(&module, rank, ksk.size()) - | TensorKey::encrypt_sk_scratch_space(&module, rank, ksk.size()) + | TensorKey::generate_from_sk_scratch_space(&module, rank, ksk.size()) | GGSWCiphertext::keyswitch_inplace_scratch_space(&module, ct.size(), ksk.size(), tsk.size(), rank), ); @@ -313,7 +313,7 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k: usize, rank: usize, sig sigma, scratch.borrow(), ); - tsk.encrypt_sk( + tsk.generate_from_sk( &module, &sk_out_dft, &mut source_xa, @@ -455,7 +455,7 @@ fn test_automorphism(p: i64, log_n: usize, basek: usize, k: usize, rank: usize, GGSWCiphertext::encrypt_sk_scratch_space(&module, rank, ct_in.size()) | GLWECiphertextFourier::decrypt_scratch_space(&module, ct_out.size()) | AutomorphismKey::generate_from_sk_scratch_space(&module, rank, auto_key.size()) - | TensorKey::encrypt_sk_scratch_space(&module, rank, tensor_key.size()) + | TensorKey::generate_from_sk_scratch_space(&module, rank, tensor_key.size()) | GGSWCiphertext::automorphism_scratch_space( &module, ct_out.size(), @@ -483,7 +483,7 @@ fn test_automorphism(p: i64, log_n: usize, basek: usize, k: usize, rank: usize, sigma, scratch.borrow(), ); - tensor_key.encrypt_sk( + tensor_key.generate_from_sk( &module, &sk_dft, &mut source_xa, @@ -575,7 +575,7 @@ fn test_automorphism_inplace(p: i64, log_n: usize, basek: usize, k: usize, rank: GGSWCiphertext::encrypt_sk_scratch_space(&module, rank, ct.size()) | GLWECiphertextFourier::decrypt_scratch_space(&module, ct.size()) | AutomorphismKey::generate_from_sk_scratch_space(&module, rank, auto_key.size()) - | TensorKey::encrypt_sk_scratch_space(&module, rank, tensor_key.size()) + | TensorKey::generate_from_sk_scratch_space(&module, rank, tensor_key.size()) | GGSWCiphertext::automorphism_inplace_scratch_space(&module, ct.size(), auto_key.size(), tensor_key.size(), rank), ); @@ -596,7 +596,7 @@ fn test_automorphism_inplace(p: i64, log_n: usize, basek: usize, k: usize, rank: sigma, scratch.borrow(), ); - tensor_key.encrypt_sk( + tensor_key.generate_from_sk( &module, &sk_dft, &mut source_xa, diff --git a/core/src/test_fft64/tensor_key.rs b/core/src/test_fft64/tensor_key.rs index a897253..2a3d40d 100644 --- a/core/src/test_fft64/tensor_key.rs +++ b/core/src/test_fft64/tensor_key.rs @@ -30,7 +30,7 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k: usize, sigma: f64, rank: usize let mut source_xe: Source = Source::new([0u8; 32]); let mut source_xa: Source = Source::new([0u8; 32]); - let mut scratch: ScratchOwned = ScratchOwned::new(TensorKey::encrypt_sk_scratch_space( + let mut scratch: ScratchOwned = ScratchOwned::new(TensorKey::generate_from_sk_scratch_space( &module, rank, tensor_key.size(), @@ -40,7 +40,7 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k: usize, sigma: f64, rank: usize sk.fill_ternary_prob(0.5, &mut source_xs); let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); - sk_dft.dft(&module, &sk); + sk_dft.dft(generate_from_sksk); tensor_key.encrypt_sk( &module, From 4c3a56810818903f65adee5eafb1613052e21f1c Mon Sep 17 00:00:00 2001 From: Jean-Philippe Bossuat Date: Mon, 26 May 2025 13:55:21 +0200 Subject: [PATCH 06/10] bug fixes --- Cargo.lock | 35 ++++++++++++----------------------- Cargo.toml | 2 +- backend/src/encoding.rs | 8 ++++---- core/src/automorphism.rs | 17 +++++++++++++---- core/src/gglwe_ciphertext.rs | 13 +++++++++++-- core/src/glwe_ciphertext.rs | 20 ++++++++++++-------- core/src/glwe_ops.rs | 8 ++++---- 7 files changed, 57 insertions(+), 46 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 1b4ded4..ab139e4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -145,25 +145,22 @@ dependencies = [ [[package]] name = "criterion" -version = "0.5.1" +version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f" +checksum = "3bf7af66b0989381bd0be551bd7cc91912a655a58c6918420c9527b1fd8b4679" dependencies = [ "anes", "cast", "ciborium", "clap", "criterion-plot", - "is-terminal", - "itertools 0.10.5", + "itertools 0.13.0", "num-traits", - "once_cell", "oorandom", "plotters", "rayon", "regex", "serde", - "serde_derive", "serde_json", "tinytemplate", "walkdir", @@ -254,23 +251,6 @@ dependencies = [ "crunchy", ] -[[package]] -name = "hermit-abi" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc" - -[[package]] -name = "is-terminal" -version = "0.4.13" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "261f68e344040fbd0edea105bef17c66edf46f984ddb1115b775ce31be948f4b" -dependencies = [ - "hermit-abi", - "libc", - "windows-sys 0.52.0", -] - [[package]] name = "itertools" version = "0.10.5" @@ -280,6 +260,15 @@ dependencies = [ "either", ] +[[package]] +name = "itertools" +version = "0.13.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186" +dependencies = [ + "either", +] + [[package]] name = "itertools" version = "0.14.0" diff --git a/Cargo.toml b/Cargo.toml index dd3a518..4852656 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,4 +9,4 @@ rand_chacha = "0.9.0" rand_core = "0.9.3" rand_distr = "0.5.1" itertools = "0.14.0" -criterion = "0.5.1" +criterion = "0.6.0" diff --git a/backend/src/encoding.rs b/backend/src/encoding.rs index dc423f9..48501b6 100644 --- a/backend/src/encoding.rs +++ b/backend/src/encoding.rs @@ -263,14 +263,14 @@ fn decode_coeff_i64>(a: &VecZnx, col_i: usize, basek: usize, k assert!(col_i < a.cols()) } - let cols: usize = (k + basek - 1) / basek; + let size: usize = (k + basek - 1) / basek; let data: &[i64] = a.raw(); let mut res: i64 = data[i]; let rem: usize = basek - (k % basek); let slice_size: usize = a.n() * a.size(); - (1..cols).for_each(|i| { - let x = data[i * slice_size]; - if i == cols - 1 && rem != basek { + (1..size).for_each(|i| { + let x: i64 = data[i * slice_size]; + if i == size - 1 && rem != basek { let k_rem: usize = basek - rem; res = (res << k_rem) + (x >> rem); } else { diff --git a/core/src/automorphism.rs b/core/src/automorphism.rs index 91f13e5..8c00744 100644 --- a/core/src/automorphism.rs +++ b/core/src/automorphism.rs @@ -1,7 +1,7 @@ use backend::{ - Backend, FFT64, MatZnxDft, MatZnxDftOps, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx, ScalarZnxDftOps, ScalarZnxOps, - ScalarZnxToRef, Scratch, VecZnx, VecZnxBigAlloc, VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, VecZnxDftToRef, VecZnxOps, - ZnxZero, + Backend, FFT64, MatZnxDft, MatZnxDftOps, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx, ScalarZnxDftAlloc, + ScalarZnxDftOps, ScalarZnxOps, ScalarZnxToRef, Scratch, VecZnx, VecZnxBigAlloc, VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, + VecZnxDftToRef, VecZnxOps, ZnxZero, }; use sampling::source::Source; @@ -107,7 +107,7 @@ where impl AutomorphismKey, FFT64> { pub fn generate_from_sk_scratch_space(module: &Module, rank: usize, size: usize) -> usize { - GGLWECiphertext::generate_from_sk_scratch_space(module, rank, size) + GGLWECiphertext::generate_from_sk_scratch_space(module, rank, size) + module.bytes_of_scalar_znx_dft(rank) } pub fn generate_from_pk_scratch_space(module: &Module, rank: usize, pk_size: usize) -> usize { @@ -188,6 +188,15 @@ where assert_eq!(sk.n(), module.n()); assert_eq!(self.rank_out(), self.rank_in()); assert_eq!(sk.rank(), self.rank()); + assert!( + scratch.available() >= AutomorphismKey::generate_from_sk_scratch_space(module, self.rank(), self.size()), + "scratch.available(): {} < AutomorphismKey::generate_from_sk_scratch_space(module, self.rank()={}, \ + self.size()={}): {}", + scratch.available(), + self.rank(), + self.size(), + AutomorphismKey::generate_from_sk_scratch_space(module, self.rank(), self.size()) + ) } let (sk_out_dft_data, scratch_1) = scratch.tmp_scalar_znx_dft(module, sk.rank()); diff --git a/core/src/gglwe_ciphertext.rs b/core/src/gglwe_ciphertext.rs index d5621c9..b7a798e 100644 --- a/core/src/gglwe_ciphertext.rs +++ b/core/src/gglwe_ciphertext.rs @@ -1,7 +1,7 @@ use backend::{ Backend, FFT64, MatZnxDft, MatZnxDftAlloc, MatZnxDftOps, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx, ScalarZnxDft, - ScalarZnxDftToRef, ScalarZnxToRef, Scratch, VecZnxAlloc, VecZnxDftAlloc, VecZnxDftToMut, VecZnxDftToRef, VecZnxOps, ZnxInfos, - ZnxZero, + ScalarZnxDftToRef, ScalarZnxToRef, Scratch, VecZnxAlloc, VecZnxBigScratch, VecZnxDftAlloc, VecZnxDftToMut, VecZnxDftToRef, + VecZnxOps, ZnxInfos, ZnxZero, }; use sampling::source::Source; @@ -115,6 +115,15 @@ where assert_eq!(self.n(), module.n()); assert_eq!(sk_dft.n(), module.n()); assert_eq!(pt.n(), module.n()); + assert!( + scratch.available() >= GGLWECiphertext::generate_from_sk_scratch_space(module, self.rank(), self.size()), + "scratch.available: {} < GGLWECiphertext::generate_from_sk_scratch_space(module, self.rank()={}, \ + self.size()={}): {}", + scratch.available(), + self.rank(), + self.size(), + GGLWECiphertext::generate_from_sk_scratch_space(module, self.rank(), self.size()) + ) } let rows: usize = self.rows(); diff --git a/core/src/glwe_ciphertext.rs b/core/src/glwe_ciphertext.rs index 9c3f32e..8adb7e7 100644 --- a/core/src/glwe_ciphertext.rs +++ b/core/src/glwe_ciphertext.rs @@ -97,9 +97,7 @@ where impl GLWECiphertext> { pub fn encrypt_sk_scratch_space(module: &Module, ct_size: usize) -> usize { - module.vec_znx_big_normalize_tmp_bytes() - + module.bytes_of_vec_znx_dft(1, ct_size) - + module.bytes_of_vec_znx_big(1, ct_size) + module.vec_znx_big_normalize_tmp_bytes() + module.bytes_of_vec_znx_dft(1, ct_size) + module.bytes_of_vec_znx(1, ct_size) } pub fn encrypt_pk_scratch_space(module: &Module, pk_size: usize) -> usize { ((module.bytes_of_vec_znx_dft(1, pk_size) + module.bytes_of_vec_znx_big(1, pk_size)) | module.bytes_of_scalar_znx(1)) @@ -534,11 +532,11 @@ where module.vec_znx_big_automorphism_inplace(apply_auto, &mut res_big, i); } - match OP{ - 1=> module.vec_znx_big_add_small_inplace(&mut res_big, i, lhs, i), - 2=> module.vec_znx_big_sub_small_a_inplace(&mut res_big, i, lhs, i), - 3=> module.vec_znx_big_sub_small_b_inplace(&mut res_big, i, lhs, i), - _=>{}, + match OP { + 1 => module.vec_znx_big_add_small_inplace(&mut res_big, i, lhs, i), + 2 => module.vec_znx_big_sub_small_a_inplace(&mut res_big, i, lhs, i), + 3 => module.vec_znx_big_sub_small_b_inplace(&mut res_big, i, lhs, i), + _ => {} } module.vec_znx_big_normalize(basek, self, i, &res_big, i, scratch1); }); @@ -636,6 +634,12 @@ where assert_eq!(pt.n(), module.n()); assert!(col < self.rank() + 1); } + assert!( + scratch.available() >= GLWECiphertext::encrypt_sk_scratch_space(module, self.size()), + "scratch.available(): {} < GLWECiphertext::encrypt_sk_scratch_space: {}", + scratch.available(), + GLWECiphertext::encrypt_sk_scratch_space(module, self.size()) + ) } let basek: usize = self.basek(); diff --git a/core/src/glwe_ops.rs b/core/src/glwe_ops.rs index 61f9ad2..834e357 100644 --- a/core/src/glwe_ops.rs +++ b/core/src/glwe_ops.rs @@ -175,7 +175,7 @@ where self.set_k(a.k()); } - pub fn rotate_inplace(&mut self, module: &Module, k: i64){ + pub fn rotate_inplace(&mut self, module: &Module, k: i64) { #[cfg(debug_assertions)] { assert_eq!(self.n(), module.n()); @@ -240,8 +240,8 @@ where } } -impl GLWECiphertext>{ - pub fn rsh_scratch_space(module: &Module) -> usize{ +impl GLWECiphertext> { + pub fn rsh_scratch_space(module: &Module) -> usize { VecZnx::rsh_scratch_space(module.n()) } -} \ No newline at end of file +} From e5d6a6f828a7cdd9095f5a88d1119b915d31d6bc Mon Sep 17 00:00:00 2001 From: Jean-Philippe Bossuat Date: Mon, 26 May 2025 13:57:19 +0200 Subject: [PATCH 07/10] fixed tests --- core/src/gglwe_ciphertext.rs | 4 ++-- core/src/test_fft64/tensor_key.rs | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/core/src/gglwe_ciphertext.rs b/core/src/gglwe_ciphertext.rs index b7a798e..6cbab5d 100644 --- a/core/src/gglwe_ciphertext.rs +++ b/core/src/gglwe_ciphertext.rs @@ -1,7 +1,7 @@ use backend::{ Backend, FFT64, MatZnxDft, MatZnxDftAlloc, MatZnxDftOps, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx, ScalarZnxDft, - ScalarZnxDftToRef, ScalarZnxToRef, Scratch, VecZnxAlloc, VecZnxBigScratch, VecZnxDftAlloc, VecZnxDftToMut, VecZnxDftToRef, - VecZnxOps, ZnxInfos, ZnxZero, + ScalarZnxDftToRef, ScalarZnxToRef, Scratch, VecZnxAlloc, VecZnxDftAlloc, VecZnxDftToMut, VecZnxDftToRef, VecZnxOps, ZnxInfos, + ZnxZero, }; use sampling::source::Source; diff --git a/core/src/test_fft64/tensor_key.rs b/core/src/test_fft64/tensor_key.rs index 2a3d40d..b7e0b86 100644 --- a/core/src/test_fft64/tensor_key.rs +++ b/core/src/test_fft64/tensor_key.rs @@ -40,9 +40,9 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k: usize, sigma: f64, rank: usize sk.fill_ternary_prob(0.5, &mut source_xs); let mut sk_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); - sk_dft.dft(generate_from_sksk); + sk_dft.dft(&module, &sk); - tensor_key.encrypt_sk( + tensor_key.generate_from_sk( &module, &sk_dft, &mut source_xa, From dec3481a6f6729a4ec669d7453914ef98327a3f7 Mon Sep 17 00:00:00 2001 From: Jean-Philippe Bossuat Date: Mon, 26 May 2025 19:16:43 +0200 Subject: [PATCH 08/10] bug fixes --- backend/src/encoding.rs | 2 +- core/src/ggsw_ciphertext.rs | 21 ++++++++++++--------- core/src/tensor_key.rs | 2 +- 3 files changed, 14 insertions(+), 11 deletions(-) diff --git a/backend/src/encoding.rs b/backend/src/encoding.rs index 48501b6..73b86a3 100644 --- a/backend/src/encoding.rs +++ b/backend/src/encoding.rs @@ -267,7 +267,7 @@ fn decode_coeff_i64>(a: &VecZnx, col_i: usize, basek: usize, k let data: &[i64] = a.raw(); let mut res: i64 = data[i]; let rem: usize = basek - (k % basek); - let slice_size: usize = a.n() * a.size(); + let slice_size: usize = a.n() * a.cols(); (1..size).for_each(|i| { let x: i64 = data[i * slice_size]; if i == size - 1 && rem != basek { diff --git a/core/src/ggsw_ciphertext.rs b/core/src/ggsw_ciphertext.rs index ca22faf..7215adf 100644 --- a/core/src/ggsw_ciphertext.rs +++ b/core/src/ggsw_ciphertext.rs @@ -142,14 +142,13 @@ impl GGSWCiphertext, FFT64> { tensor_key_size: usize, rank: usize, ) -> usize { - GGSWCiphertext::keyswitch_scratch_space( - module, - out_size, - in_size, - auto_key_size, - tensor_key_size, - rank, - ) + let cols: usize = rank + 1; + let res: usize = module.bytes_of_vec_znx(cols, out_size); + let res_dft: usize = module.bytes_of_vec_znx_dft(cols, out_size); + let ci_dft: usize = module.bytes_of_vec_znx_dft(cols, out_size); + let ks_internal: usize = GGSWCiphertext::keyswitch_internal_col0_scratch_space(module, out_size, in_size, auto_key_size, rank); + let expand: usize = GGSWCiphertext::expand_row_scratch_space(module, out_size, tensor_key_size, rank); + res + ci_dft + (ks_internal | expand | res_dft) } pub fn automorphism_inplace_scratch_space( @@ -288,6 +287,8 @@ where { let cols: usize = self.rank() + 1; + assert!(scratch.available() >= GGSWCiphertext::expand_row_scratch_space(module, self.size(), tsk.size(), tsk.rank())); + // Example for rank 3: // // Note: M is a vector (m, Bm, B^2m, B^3m, ...), so each column is @@ -383,7 +384,7 @@ where k: self.k(), }; - let (mut ci_dft, scratch2) = scratch1.tmp_vec_znx_dft(module, cols, self.size()); + let (mut ci_dft, scratch2) = scratch1.tmp_vec_znx_dft(module, cols, lhs.size()); // Keyswitch the j-th row of the col 0 (0..lhs.rows()).for_each(|row_i| { @@ -467,6 +468,7 @@ where self.rank(), tensor_key.rank() ); + assert!(scratch.available() >= GGSWCiphertext::automorphism_scratch_space(module, self.size(), lhs.size(), auto_key.size(), tensor_key.size(), self.rank())) }; let cols: usize = self.rank() + 1; @@ -646,6 +648,7 @@ where { assert_eq!(self.rank(), ksk.rank()); assert_eq!(res.rank(), ksk.rank()); + assert!(scratch.available() >= GGSWCiphertext::keyswitch_internal_col0_scratch_space(module, res.size(), self.size(), ksk.size(), ksk.rank())) } let (tmp_dft_in_data, scratch2) = scratch.tmp_vec_znx_dft(module, self.rank() + 1, self.size()); diff --git a/core/src/tensor_key.rs b/core/src/tensor_key.rs index 105dace..89ce299 100644 --- a/core/src/tensor_key.rs +++ b/core/src/tensor_key.rs @@ -17,7 +17,7 @@ pub struct TensorKey { impl TensorKey, FFT64> { pub fn alloc(module: &Module, basek: usize, k: usize, rows: usize, rank: usize) -> Self { let mut keys: Vec, FFT64>> = Vec::new(); - let pairs: usize = ((rank + 1) * rank) >> 1; + let pairs: usize = (((rank + 1) * rank) >> 1).max(1); (0..pairs).for_each(|_| { keys.push(GLWESwitchingKey::alloc(module, basek, k, rows, 1, rank)); }); From a295085724578780db3870773774c798adfe5f8b Mon Sep 17 00:00:00 2001 From: Jean-Philippe Bossuat Date: Tue, 27 May 2025 17:49:43 +0200 Subject: [PATCH 09/10] refactor --- backend/src/mat_znx_dft.rs | 90 ++---- backend/src/mat_znx_dft_ops.rs | 38 +-- backend/src/sampling.rs | 18 +- backend/src/scalar_znx.rs | 125 +++----- backend/src/scalar_znx_dft.rs | 129 +++----- backend/src/scalar_znx_dft_ops.rs | 208 ++++++------- backend/src/vec_znx.rs | 94 ++---- backend/src/vec_znx_big.rs | 80 ++--- backend/src/vec_znx_big_ops.rs | 8 +- backend/src/vec_znx_dft.rs | 84 ++---- backend/src/vec_znx_ops.rs | 2 +- core/benches/external_product_glwe_fft64.rs | 3 +- core/benches/keyswitch_glwe_fft64.rs | 7 +- core/src/automorphism.rs | 130 +++----- core/src/elem.rs | 12 +- core/src/gglwe_ciphertext.rs | 77 ++--- core/src/ggsw_ciphertext.rs | 194 +++++------- core/src/glwe_ciphertext.rs | 309 +++++++++----------- core/src/glwe_ciphertext_fourier.rs | 98 ++----- core/src/glwe_ops.rs | 133 +++++---- core/src/glwe_plaintext.rs | 20 +- core/src/keys.rs | 83 +----- core/src/keyswitch_key.rs | 99 ++----- core/src/tensor_key.rs | 23 +- core/src/test_fft64/automorphism_key.rs | 20 +- core/src/test_fft64/gglwe.rs | 24 +- core/src/test_fft64/ggsw.rs | 74 ++--- core/src/test_fft64/glwe.rs | 38 +-- core/src/test_fft64/glwe_fourier.rs | 22 +- core/src/test_fft64/tensor_key.rs | 2 +- core/src/test_fft64/trace.rs | 4 +- core/src/trace.rs | 24 +- 32 files changed, 897 insertions(+), 1375 deletions(-) diff --git a/backend/src/mat_znx_dft.rs b/backend/src/mat_znx_dft.rs index 1fe67eb..a717f4b 100644 --- a/backend/src/mat_znx_dft.rs +++ b/backend/src/mat_znx_dft.rs @@ -152,81 +152,49 @@ impl> MatZnxDft { } pub type MatZnxDftOwned = MatZnxDft, B>; +pub type MatZnxDftMut<'a, B> = MatZnxDft<&'a mut [u8], B>; +pub type MatZnxDftRef<'a, B> = MatZnxDft<&'a [u8], B>; -pub trait MatZnxDftToRef { +pub trait MatZnxToRef { fn to_ref(&self) -> MatZnxDft<&[u8], B>; } -pub trait MatZnxDftToMut: MatZnxDftToRef { +impl MatZnxToRef for MatZnxDft +where + D: AsRef<[u8]>, + B: Backend, +{ + fn to_ref(&self) -> MatZnxDft<&[u8], B> { + MatZnxDft { + data: self.data.as_ref(), + n: self.n, + rows: self.rows, + cols_in: self.cols_in, + cols_out: self.cols_out, + size: self.size, + _phantom: std::marker::PhantomData, + } + } +} + +pub trait MatZnxToMut { fn to_mut(&mut self) -> MatZnxDft<&mut [u8], B>; } -impl MatZnxDftToMut for MatZnxDft, B> { +impl MatZnxToMut for MatZnxDft +where + D: AsRef<[u8]> + AsMut<[u8]>, + B: Backend, +{ fn to_mut(&mut self) -> MatZnxDft<&mut [u8], B> { MatZnxDft { - data: self.data.as_mut_slice(), + data: self.data.as_mut(), n: self.n, rows: self.rows, cols_in: self.cols_in, cols_out: self.cols_out, size: self.size, - _phantom: PhantomData, - } - } -} - -impl MatZnxDftToRef for MatZnxDft, B> { - fn to_ref(&self) -> MatZnxDft<&[u8], B> { - MatZnxDft { - data: self.data.as_slice(), - n: self.n, - rows: self.rows, - cols_in: self.cols_in, - cols_out: self.cols_out, - size: self.size, - _phantom: PhantomData, - } - } -} - -impl MatZnxDftToMut for MatZnxDft<&mut [u8], B> { - fn to_mut(&mut self) -> MatZnxDft<&mut [u8], B> { - MatZnxDft { - data: self.data, - n: self.n, - rows: self.rows, - cols_in: self.cols_in, - cols_out: self.cols_out, - size: self.size, - _phantom: PhantomData, - } - } -} - -impl MatZnxDftToRef for MatZnxDft<&mut [u8], B> { - fn to_ref(&self) -> MatZnxDft<&[u8], B> { - MatZnxDft { - data: self.data, - n: self.n, - rows: self.rows, - cols_in: self.cols_in, - cols_out: self.cols_out, - size: self.size, - _phantom: PhantomData, - } - } -} - -impl MatZnxDftToRef for MatZnxDft<&[u8], B> { - fn to_ref(&self) -> MatZnxDft<&[u8], B> { - MatZnxDft { - data: self.data, - n: self.n, - rows: self.rows, - cols_in: self.cols_in, - cols_out: self.cols_out, - size: self.size, - _phantom: PhantomData, + _phantom: std::marker::PhantomData, } } } diff --git a/backend/src/mat_znx_dft_ops.rs b/backend/src/mat_znx_dft_ops.rs index e73b782..5ad724f 100644 --- a/backend/src/mat_znx_dft_ops.rs +++ b/backend/src/mat_znx_dft_ops.rs @@ -2,7 +2,7 @@ use crate::ffi::vec_znx_dft::vec_znx_dft_t; use crate::ffi::vmp; use crate::znx_base::{ZnxInfos, ZnxView, ZnxViewMut}; use crate::{ - Backend, FFT64, MatZnxDft, MatZnxDftOwned, MatZnxDftToMut, MatZnxDftToRef, Module, Scratch, VecZnxDft, VecZnxDftToMut, + Backend, FFT64, MatZnxDft, MatZnxDftOwned, MatZnxToMut, MatZnxToRef, Module, Scratch, VecZnxDft, VecZnxDftToMut, VecZnxDftToRef, }; @@ -47,27 +47,27 @@ pub trait MatZnxDftOps { /// /// # Arguments /// - /// * `b`: [MatZnxDft] on which the values are encoded. + /// * `res`: [MatZnxDft] on which the values are encoded. /// * `a`: the [VecZnxDft] to encode on the [MatZnxDft]. /// * `row_i`: the index of the row to prepare. /// /// The size of buf can be obtained with [MatZnxDftOps::vmp_prepare_tmp_bytes]. fn vmp_prepare_row(&self, res: &mut R, res_row: usize, res_col_in: usize, a: &A) where - R: MatZnxDftToMut, - A: VecZnxDftToRef; + R: MatZnxToMut, + A: VecZnxDftToRef; /// Extracts the ith-row of [MatZnxDft] into a [VecZnxDft]. /// /// # Arguments /// - /// * `b`: the [VecZnxDft] to on which to extract the row of the [MatZnxDft]. + /// * `res`: the [VecZnxDft] to on which to extract the row of the [MatZnxDft]. /// * `a`: [MatZnxDft] on which the values are encoded. /// * `row_i`: the index of the row to extract. fn vmp_extract_row(&self, res: &mut R, a: &A, a_row: usize, a_col_in: usize) where - R: VecZnxDftToMut, - A: MatZnxDftToRef; + R: VecZnxDftToMut, + A: MatZnxToRef; /// Applies the vector matrix product [VecZnxDft] x [MatZnxDft]. /// The size of `buf` is given by [MatZnxDftOps::vmp_apply_dft_to_dft_tmp_bytes]. @@ -96,16 +96,16 @@ pub trait MatZnxDftOps { /// * `buf`: scratch space, the size can be obtained with [MatZnxDftOps::vmp_apply_dft_to_dft_tmp_bytes]. fn vmp_apply(&self, res: &mut R, a: &A, b: &B, scratch: &mut Scratch) where - R: VecZnxDftToMut, - A: VecZnxDftToRef, - B: MatZnxDftToRef; + R: VecZnxDftToMut, + A: VecZnxDftToRef, + B: MatZnxToRef; // Same as [MatZnxDftOps::vmp_apply] except result is added on R instead of overwritting R. fn vmp_apply_add(&self, res: &mut R, a: &A, b: &B, scratch: &mut Scratch) where - R: VecZnxDftToMut, - A: VecZnxDftToRef, - B: MatZnxDftToRef; + R: VecZnxDftToMut, + A: VecZnxDftToRef, + B: MatZnxToRef; } impl MatZnxDftAlloc for Module { @@ -154,10 +154,10 @@ impl MatZnxDftScratch for Module { impl MatZnxDftOps for Module { fn vmp_prepare_row(&self, res: &mut R, res_row: usize, res_col_in: usize, a: &A) where - R: MatZnxDftToMut, + R: MatZnxToMut, A: VecZnxDftToRef, { - let mut res: MatZnxDft<&mut [u8], _> = res.to_mut(); + let mut res: MatZnxDft<&mut [u8], FFT64> = res.to_mut(); let a: VecZnxDft<&[u8], _> = a.to_ref(); #[cfg(debug_assertions)] @@ -207,9 +207,9 @@ impl MatZnxDftOps for Module { fn vmp_extract_row(&self, res: &mut R, a: &A, a_row: usize, a_col_in: usize) where R: VecZnxDftToMut, - A: MatZnxDftToRef, + A: MatZnxToRef, { - let mut res: VecZnxDft<&mut [u8], _> = res.to_mut(); + let mut res: VecZnxDft<&mut [u8], FFT64> = res.to_mut(); let a: MatZnxDft<&[u8], _> = a.to_ref(); #[cfg(debug_assertions)] @@ -259,7 +259,7 @@ impl MatZnxDftOps for Module { where R: VecZnxDftToMut, A: VecZnxDftToRef, - B: MatZnxDftToRef, + B: MatZnxToRef, { let mut res: VecZnxDft<&mut [u8], _> = res.to_mut(); let a: VecZnxDft<&[u8], _> = a.to_ref(); @@ -313,7 +313,7 @@ impl MatZnxDftOps for Module { where R: VecZnxDftToMut, A: VecZnxDftToRef, - B: MatZnxDftToRef, + B: MatZnxToRef, { let mut res: VecZnxDft<&mut [u8], _> = res.to_mut(); let a: VecZnxDft<&[u8], _> = a.to_ref(); diff --git a/backend/src/sampling.rs b/backend/src/sampling.rs index fd8c577..071adcf 100644 --- a/backend/src/sampling.rs +++ b/backend/src/sampling.rs @@ -42,7 +42,7 @@ pub trait AddNormal { fn add_normal(&mut self, basek: usize, col_i: usize, k: usize, source: &mut Source, sigma: f64, bound: f64); } -impl FillUniform for VecZnx +impl + AsRef<[u8]>> FillUniform for VecZnx where VecZnx: VecZnxToMut, { @@ -59,7 +59,7 @@ where } } -impl FillDistF64 for VecZnx +impl + AsRef<[u8]>> FillDistF64 for VecZnx where VecZnx: VecZnxToMut, { @@ -102,7 +102,7 @@ where } } -impl AddDistF64 for VecZnx +impl + AsRef<[u8]>> AddDistF64 for VecZnx where VecZnx: VecZnxToMut, { @@ -145,7 +145,7 @@ where } } -impl FillNormal for VecZnx +impl + AsRef<[u8]>> FillNormal for VecZnx where VecZnx: VecZnxToMut, { @@ -161,7 +161,7 @@ where } } -impl AddNormal for VecZnx +impl + AsRef<[u8]>> AddNormal for VecZnx where VecZnx: VecZnxToMut, { @@ -177,7 +177,7 @@ where } } -impl FillDistF64 for VecZnxBig +impl + AsRef<[u8]>> FillDistF64 for VecZnxBig where VecZnxBig: VecZnxBigToMut, { @@ -220,7 +220,7 @@ where } } -impl AddDistF64 for VecZnxBig +impl + AsRef<[u8]>> AddDistF64 for VecZnxBig where VecZnxBig: VecZnxBigToMut, { @@ -263,7 +263,7 @@ where } } -impl FillNormal for VecZnxBig +impl + AsRef<[u8]>> FillNormal for VecZnxBig where VecZnxBig: VecZnxBigToMut, { @@ -279,7 +279,7 @@ where } } -impl AddNormal for VecZnxBig +impl + AsRef<[u8]>> AddNormal for VecZnxBig where VecZnxBig: VecZnxBigToMut, { diff --git a/backend/src/scalar_znx.rs b/backend/src/scalar_znx.rs index 4c981c1..cb51e0d 100644 --- a/backend/src/scalar_znx.rs +++ b/backend/src/scalar_znx.rs @@ -196,108 +196,57 @@ pub trait ScalarZnxToRef { fn to_ref(&self) -> ScalarZnx<&[u8]>; } +impl ScalarZnxToRef for ScalarZnx +where + D: AsRef<[u8]>, +{ + fn to_ref(&self) -> ScalarZnx<&[u8]> { + ScalarZnx { + data: self.data.as_ref(), + n: self.n, + cols: self.cols, + } + } +} + pub trait ScalarZnxToMut { fn to_mut(&mut self) -> ScalarZnx<&mut [u8]>; } -impl ScalarZnxToMut for ScalarZnx> { +impl ScalarZnxToMut for ScalarZnx +where + D: AsRef<[u8]> + AsMut<[u8]>, +{ fn to_mut(&mut self) -> ScalarZnx<&mut [u8]> { ScalarZnx { - data: self.data.as_mut_slice(), + data: self.data.as_mut(), n: self.n, cols: self.cols, } } } -impl VecZnxToMut for ScalarZnx> { +impl VecZnxToRef for ScalarZnx +where + D: AsRef<[u8]>, +{ + fn to_ref(&self) -> VecZnx<&[u8]> { + VecZnx { + data: self.data.as_ref(), + n: self.n, + cols: self.cols, + size: 1, + } + } +} + +impl VecZnxToMut for ScalarZnx +where + D: AsRef<[u8]> + AsMut<[u8]>, +{ fn to_mut(&mut self) -> VecZnx<&mut [u8]> { VecZnx { - data: self.data.as_mut_slice(), - n: self.n, - cols: self.cols, - size: 1, - } - } -} - -impl ScalarZnxToRef for ScalarZnx> { - fn to_ref(&self) -> ScalarZnx<&[u8]> { - ScalarZnx { - data: self.data.as_slice(), - n: self.n, - cols: self.cols, - } - } -} - -impl VecZnxToRef for ScalarZnx> { - fn to_ref(&self) -> VecZnx<&[u8]> { - VecZnx { - data: self.data.as_slice(), - n: self.n, - cols: self.cols, - size: 1, - } - } -} - -impl ScalarZnxToMut for ScalarZnx<&mut [u8]> { - fn to_mut(&mut self) -> ScalarZnx<&mut [u8]> { - ScalarZnx { - data: self.data, - n: self.n, - cols: self.cols, - } - } -} - -impl VecZnxToMut for ScalarZnx<&mut [u8]> { - fn to_mut(&mut self) -> VecZnx<&mut [u8]> { - VecZnx { - data: self.data, - n: self.n, - cols: self.cols, - size: 1, - } - } -} - -impl ScalarZnxToRef for ScalarZnx<&mut [u8]> { - fn to_ref(&self) -> ScalarZnx<&[u8]> { - ScalarZnx { - data: self.data, - n: self.n, - cols: self.cols, - } - } -} - -impl VecZnxToRef for ScalarZnx<&mut [u8]> { - fn to_ref(&self) -> VecZnx<&[u8]> { - VecZnx { - data: self.data, - n: self.n, - cols: self.cols, - size: 1, - } - } -} - -impl ScalarZnxToRef for ScalarZnx<&[u8]> { - fn to_ref(&self) -> ScalarZnx<&[u8]> { - ScalarZnx { - data: self.data, - n: self.n, - cols: self.cols, - } - } -} - -impl VecZnxToRef for ScalarZnx<&[u8]> { - fn to_ref(&self) -> VecZnx<&[u8]> { - VecZnx { - data: self.data, + data: self.data.as_mut(), n: self.n, cols: self.cols, size: 1, diff --git a/backend/src/scalar_znx_dft.rs b/backend/src/scalar_znx_dft.rs index fa4ab10..d2ecb4f 100644 --- a/backend/src/scalar_znx_dft.rs +++ b/backend/src/scalar_znx_dft.rs @@ -113,14 +113,33 @@ pub trait ScalarZnxDftToRef { fn to_ref(&self) -> ScalarZnxDft<&[u8], B>; } +impl ScalarZnxDftToRef for ScalarZnxDft +where + D: AsRef<[u8]>, + B: Backend, +{ + fn to_ref(&self) -> ScalarZnxDft<&[u8], B> { + ScalarZnxDft { + data: self.data.as_ref(), + n: self.n, + cols: self.cols, + _phantom: PhantomData, + } + } +} + pub trait ScalarZnxDftToMut { fn to_mut(&mut self) -> ScalarZnxDft<&mut [u8], B>; } -impl ScalarZnxDftToMut for ScalarZnxDft, B> { +impl ScalarZnxDftToMut for ScalarZnxDft +where + D: AsMut<[u8]> + AsRef<[u8]>, + B: Backend, +{ fn to_mut(&mut self) -> ScalarZnxDft<&mut [u8], B> { ScalarZnxDft { - data: self.data.as_mut_slice(), + data: self.data.as_mut(), n: self.n, cols: self.cols, _phantom: PhantomData, @@ -128,106 +147,34 @@ impl ScalarZnxDftToMut for ScalarZnxDft, B> { } } -impl ScalarZnxDftToRef for ScalarZnxDft, B> { - fn to_ref(&self) -> ScalarZnxDft<&[u8], B> { - ScalarZnxDft { - data: self.data.as_slice(), +impl VecZnxDftToRef for ScalarZnxDft +where + D: AsRef<[u8]>, + B: Backend, +{ + fn to_ref(&self) -> VecZnxDft<&[u8], B> { + VecZnxDft { + data: self.data.as_ref(), n: self.n, cols: self.cols, - _phantom: PhantomData, + size: 1, + _phantom: std::marker::PhantomData, } } } -impl ScalarZnxDftToMut for ScalarZnxDft<&mut [u8], B> { - fn to_mut(&mut self) -> ScalarZnxDft<&mut [u8], B> { - ScalarZnxDft { - data: self.data, - n: self.n, - cols: self.cols, - _phantom: PhantomData, - } - } -} - -impl ScalarZnxDftToRef for ScalarZnxDft<&mut [u8], B> { - fn to_ref(&self) -> ScalarZnxDft<&[u8], B> { - ScalarZnxDft { - data: self.data, - n: self.n, - cols: self.cols, - _phantom: PhantomData, - } - } -} - -impl ScalarZnxDftToRef for ScalarZnxDft<&[u8], B> { - fn to_ref(&self) -> ScalarZnxDft<&[u8], B> { - ScalarZnxDft { - data: self.data, - n: self.n, - cols: self.cols, - _phantom: PhantomData, - } - } -} - -impl VecZnxDftToMut for ScalarZnxDft, B> { +impl VecZnxDftToMut for ScalarZnxDft +where + D: AsRef<[u8]> + AsMut<[u8]>, + B: Backend, +{ fn to_mut(&mut self) -> VecZnxDft<&mut [u8], B> { VecZnxDft { - data: self.data.as_mut_slice(), + data: self.data.as_mut(), n: self.n, cols: self.cols, size: 1, - _phantom: PhantomData, - } - } -} - -impl VecZnxDftToRef for ScalarZnxDft, B> { - fn to_ref(&self) -> VecZnxDft<&[u8], B> { - VecZnxDft { - data: self.data.as_slice(), - n: self.n, - cols: self.cols, - size: 1, - _phantom: PhantomData, - } - } -} - -impl VecZnxDftToMut for ScalarZnxDft<&mut [u8], B> { - fn to_mut(&mut self) -> VecZnxDft<&mut [u8], B> { - VecZnxDft { - data: self.data, - n: self.n, - cols: self.cols, - size: 1, - _phantom: PhantomData, - } - } -} - -impl VecZnxDftToRef for ScalarZnxDft<&mut [u8], B> { - fn to_ref(&self) -> VecZnxDft<&[u8], B> { - VecZnxDft { - data: self.data, - n: self.n, - cols: self.cols, - size: 1, - _phantom: PhantomData, - } - } -} - -impl VecZnxDftToRef for ScalarZnxDft<&[u8], B> { - fn to_ref(&self) -> VecZnxDft<&[u8], B> { - VecZnxDft { - data: self.data, - n: self.n, - cols: self.cols, - size: 1, - _phantom: PhantomData, + _phantom: std::marker::PhantomData, } } } diff --git a/backend/src/scalar_znx_dft_ops.rs b/backend/src/scalar_znx_dft_ops.rs index 1e0313a..6bb7039 100644 --- a/backend/src/scalar_znx_dft_ops.rs +++ b/backend/src/scalar_znx_dft_ops.rs @@ -1,103 +1,105 @@ -use crate::ffi::svp; -use crate::ffi::vec_znx_dft::vec_znx_dft_t; -use crate::znx_base::{ZnxInfos, ZnxView, ZnxViewMut}; -use crate::{ - Backend, FFT64, Module, ScalarZnxDft, ScalarZnxDftOwned, ScalarZnxDftToMut, ScalarZnxDftToRef, ScalarZnxToRef, VecZnxDft, - VecZnxDftToMut, VecZnxDftToRef, -}; - -pub trait ScalarZnxDftAlloc { - fn new_scalar_znx_dft(&self, cols: usize) -> ScalarZnxDftOwned; - fn bytes_of_scalar_znx_dft(&self, cols: usize) -> usize; - fn new_scalar_znx_dft_from_bytes(&self, cols: usize, bytes: Vec) -> ScalarZnxDftOwned; -} - -pub trait ScalarZnxDftOps { - fn svp_prepare(&self, res: &mut R, res_col: usize, a: &A, a_col: usize) - where - R: ScalarZnxDftToMut, - A: ScalarZnxToRef; - fn svp_apply(&self, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &B, b_col: usize) - where - R: VecZnxDftToMut, - A: ScalarZnxDftToRef, - B: VecZnxDftToRef; - fn svp_apply_inplace(&self, res: &mut R, res_col: usize, a: &A, a_col: usize) - where - R: VecZnxDftToMut, - A: ScalarZnxDftToRef; -} - -impl ScalarZnxDftAlloc for Module { - fn new_scalar_znx_dft(&self, cols: usize) -> ScalarZnxDftOwned { - ScalarZnxDftOwned::new(self, cols) - } - - fn bytes_of_scalar_znx_dft(&self, cols: usize) -> usize { - ScalarZnxDftOwned::bytes_of(self, cols) - } - - fn new_scalar_znx_dft_from_bytes(&self, cols: usize, bytes: Vec) -> ScalarZnxDftOwned { - ScalarZnxDftOwned::new_from_bytes(self, cols, bytes) - } -} - -impl ScalarZnxDftOps for Module { - fn svp_prepare(&self, res: &mut R, res_col: usize, a: &A, a_col: usize) - where - R: ScalarZnxDftToMut, - A: ScalarZnxToRef, - { - unsafe { - svp::svp_prepare( - self.ptr, - res.to_mut().at_mut_ptr(res_col, 0) as *mut svp::svp_ppol_t, - a.to_ref().at_ptr(a_col, 0), - ) - } - } - - fn svp_apply(&self, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &B, b_col: usize) - where - R: VecZnxDftToMut, - A: ScalarZnxDftToRef, - B: VecZnxDftToRef, - { - let mut res: VecZnxDft<&mut [u8], FFT64> = res.to_mut(); - let a: ScalarZnxDft<&[u8], FFT64> = a.to_ref(); - let b: VecZnxDft<&[u8], FFT64> = b.to_ref(); - unsafe { - svp::svp_apply_dft_to_dft( - self.ptr, - res.at_mut_ptr(res_col, 0) as *mut vec_znx_dft_t, - res.size() as u64, - res.cols() as u64, - a.at_ptr(a_col, 0) as *const svp::svp_ppol_t, - b.at_ptr(b_col, 0) as *const vec_znx_dft_t, - b.size() as u64, - b.cols() as u64, - ) - } - } - - fn svp_apply_inplace(&self, res: &mut R, res_col: usize, a: &A, a_col: usize) - where - R: VecZnxDftToMut, - A: ScalarZnxDftToRef, - { - let mut res: VecZnxDft<&mut [u8], FFT64> = res.to_mut(); - let a: ScalarZnxDft<&[u8], FFT64> = a.to_ref(); - unsafe { - svp::svp_apply_dft_to_dft( - self.ptr, - res.at_mut_ptr(res_col, 0) as *mut vec_znx_dft_t, - res.size() as u64, - res.cols() as u64, - a.at_ptr(a_col, 0) as *const svp::svp_ppol_t, - res.at_ptr(res_col, 0) as *const vec_znx_dft_t, - res.size() as u64, - res.cols() as u64, - ) - } - } -} +use crate::ffi::svp; +use crate::ffi::vec_znx_dft::vec_znx_dft_t; +use crate::znx_base::{ZnxInfos, ZnxView, ZnxViewMut}; +use crate::{ + Backend, FFT64, Module, ScalarZnxDft, ScalarZnxDftOwned, ScalarZnxDftToMut, ScalarZnxDftToRef, ScalarZnxToRef, VecZnxDft, + VecZnxDftToMut, VecZnxDftToRef, +}; + +pub trait ScalarZnxDftAlloc { + fn new_scalar_znx_dft(&self, cols: usize) -> ScalarZnxDftOwned; + fn bytes_of_scalar_znx_dft(&self, cols: usize) -> usize; + fn new_scalar_znx_dft_from_bytes(&self, cols: usize, bytes: Vec) -> ScalarZnxDftOwned; +} + +pub trait ScalarZnxDftOps { + fn svp_prepare(&self, res: &mut R, res_col: usize, a: &A, a_col: usize) + where + R: ScalarZnxDftToMut, + A: ScalarZnxToRef; + + fn svp_apply(&self, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &B, b_col: usize) + where + R: VecZnxDftToMut, + A: ScalarZnxDftToRef, + B: VecZnxDftToRef; + + fn svp_apply_inplace(&self, res: &mut R, res_col: usize, a: &A, a_col: usize) + where + R: VecZnxDftToMut, + A: ScalarZnxDftToRef; +} + +impl ScalarZnxDftAlloc for Module { + fn new_scalar_znx_dft(&self, cols: usize) -> ScalarZnxDftOwned { + ScalarZnxDftOwned::new(self, cols) + } + + fn bytes_of_scalar_znx_dft(&self, cols: usize) -> usize { + ScalarZnxDftOwned::bytes_of(self, cols) + } + + fn new_scalar_znx_dft_from_bytes(&self, cols: usize, bytes: Vec) -> ScalarZnxDftOwned { + ScalarZnxDftOwned::new_from_bytes(self, cols, bytes) + } +} + +impl ScalarZnxDftOps for Module { + fn svp_prepare(&self, res: &mut R, res_col: usize, a: &A, a_col: usize) + where + R: ScalarZnxDftToMut, + A: ScalarZnxToRef, + { + unsafe { + svp::svp_prepare( + self.ptr, + res.to_mut().at_mut_ptr(res_col, 0) as *mut svp::svp_ppol_t, + a.to_ref().at_ptr(a_col, 0), + ) + } + } + + fn svp_apply(&self, res: &mut R, res_col: usize, a: &A, a_col: usize, b: &B, b_col: usize) + where + R: VecZnxDftToMut, + A: ScalarZnxDftToRef, + B: VecZnxDftToRef, + { + let mut res: VecZnxDft<&mut [u8], FFT64> = res.to_mut(); + let a: ScalarZnxDft<&[u8], FFT64> = a.to_ref(); + let b: VecZnxDft<&[u8], FFT64> = b.to_ref(); + unsafe { + svp::svp_apply_dft_to_dft( + self.ptr, + res.at_mut_ptr(res_col, 0) as *mut vec_znx_dft_t, + res.size() as u64, + res.cols() as u64, + a.at_ptr(a_col, 0) as *const svp::svp_ppol_t, + b.at_ptr(b_col, 0) as *const vec_znx_dft_t, + b.size() as u64, + b.cols() as u64, + ) + } + } + + fn svp_apply_inplace(&self, res: &mut R, res_col: usize, a: &A, a_col: usize) + where + R: VecZnxDftToMut, + A: ScalarZnxDftToRef, + { + let mut res: VecZnxDft<&mut [u8], FFT64> = res.to_mut(); + let a: ScalarZnxDft<&[u8], FFT64> = a.to_ref(); + unsafe { + svp::svp_apply_dft_to_dft( + self.ptr, + res.at_mut_ptr(res_col, 0) as *mut vec_znx_dft_t, + res.size() as u64, + res.cols() as u64, + a.at_ptr(a_col, 0) as *const svp::svp_ppol_t, + res.at_ptr(res_col, 0) as *const vec_znx_dft_t, + res.size() as u64, + res.cols() as u64, + ) + } + } +} diff --git a/backend/src/vec_znx.rs b/backend/src/vec_znx.rs index a4de563..35ee483 100644 --- a/backend/src/vec_znx.rs +++ b/backend/src/vec_znx.rs @@ -237,14 +237,15 @@ fn normalize + AsRef<[u8]>>(basek: usize, a: &mut VecZnx, a_co } } -impl VecZnx +impl + AsRef<[u8]>> VecZnx where VecZnx: VecZnxToMut + ZnxInfos, { /// Extracts the a_col-th column of 'a' and stores it on the self_col-th column [Self]. - pub fn extract_column(&mut self, self_col: usize, a: &R, a_col: usize) + pub fn extract_column(&mut self, self_col: usize, a: &VecZnx, a_col: usize) where - R: VecZnxToRef + ZnxInfos, + R: AsRef<[u8]>, + VecZnx: VecZnxToRef + ZnxInfos, { #[cfg(debug_assertions)] { @@ -313,72 +314,41 @@ pub trait VecZnxToRef { fn to_ref(&self) -> VecZnx<&[u8]>; } -pub trait VecZnxToMut: VecZnxToRef { +impl VecZnxToRef for VecZnx +where + D: AsRef<[u8]>, +{ + fn to_ref(&self) -> VecZnx<&[u8]> { + VecZnx { + data: self.data.as_ref(), + n: self.n, + cols: self.cols, + size: self.size, + } + } +} + +pub trait VecZnxToMut { fn to_mut(&mut self) -> VecZnx<&mut [u8]>; } -impl VecZnxToMut for VecZnx> { - fn to_mut(&mut self) -> VecZnx<&mut [u8]> { - VecZnx { - data: self.data.as_mut_slice(), - n: self.n, - cols: self.cols, - size: self.size, - } - } -} - -impl VecZnxToRef for VecZnx> { - fn to_ref(&self) -> VecZnx<&[u8]> { - VecZnx { - data: self.data.as_slice(), - n: self.n, - cols: self.cols, - size: self.size, - } - } -} - -impl VecZnxToMut for VecZnx<&mut [u8]> { - fn to_mut(&mut self) -> VecZnx<&mut [u8]> { - VecZnx { - data: self.data, - n: self.n, - cols: self.cols, - size: self.size, - } - } -} - -impl VecZnxToRef for VecZnx<&mut [u8]> { - fn to_ref(&self) -> VecZnx<&[u8]> { - VecZnx { - data: self.data, - n: self.n, - cols: self.cols, - size: self.size, - } - } -} - -impl VecZnxToRef for VecZnx<&[u8]> { - fn to_ref(&self) -> VecZnx<&[u8]> { - VecZnx { - data: self.data, - n: self.n, - cols: self.cols, - size: self.size, - } - } -} - -impl VecZnx +impl VecZnxToMut for VecZnx where - VecZnx: VecZnxToRef, + D: AsRef<[u8]> + AsMut<[u8]>, { + fn to_mut(&mut self) -> VecZnx<&mut [u8]> { + VecZnx { + data: self.data.as_mut(), + n: self.n, + cols: self.cols, + size: self.size, + } + } +} + +impl> VecZnx { pub fn clone(&self) -> VecZnx> { let self_ref: VecZnx<&[u8]> = self.to_ref(); - VecZnx { data: self_ref.data.to_vec(), n: self_ref.n, diff --git a/backend/src/vec_znx_big.rs b/backend/src/vec_znx_big.rs index 2bf4dcc..90c3de2 100644 --- a/backend/src/vec_znx_big.rs +++ b/backend/src/vec_znx_big.rs @@ -94,7 +94,7 @@ impl VecZnxBig { } } -impl VecZnxBig +impl + AsRef<[u8]>> VecZnxBig where VecZnxBig: VecZnxBigToMut + ZnxInfos, { @@ -110,9 +110,9 @@ where } /// Extracts the a_col-th column of 'a' and stores it on the self_col-th column [Self]. - pub fn extract_column(&mut self, self_col: usize, a: &VecZnxBig, a_col: usize) + pub fn extract_column(&mut self, self_col: usize, a: &C, a_col: usize) where - VecZnxBig: VecZnxBigToRef + ZnxInfos, + C: VecZnxBigToRef + ZnxInfos, { #[cfg(debug_assertions)] { @@ -144,66 +144,38 @@ pub trait VecZnxBigToRef { fn to_ref(&self) -> VecZnxBig<&[u8], B>; } +impl VecZnxBigToRef for VecZnxBig +where + D: AsRef<[u8]>, + B: Backend, +{ + fn to_ref(&self) -> VecZnxBig<&[u8], B> { + VecZnxBig { + data: self.data.as_ref(), + n: self.n, + cols: self.cols, + size: self.size, + _phantom: std::marker::PhantomData, + } + } +} + pub trait VecZnxBigToMut { fn to_mut(&mut self) -> VecZnxBig<&mut [u8], B>; } -impl VecZnxBigToMut for VecZnxBig, B> { +impl VecZnxBigToMut for VecZnxBig +where + D: AsRef<[u8]> + AsMut<[u8]>, + B: Backend, +{ fn to_mut(&mut self) -> VecZnxBig<&mut [u8], B> { VecZnxBig { - data: self.data.as_mut_slice(), + data: self.data.as_mut(), n: self.n, cols: self.cols, size: self.size, - _phantom: PhantomData, - } - } -} - -impl VecZnxBigToRef for VecZnxBig, B> { - fn to_ref(&self) -> VecZnxBig<&[u8], B> { - VecZnxBig { - data: self.data.as_slice(), - n: self.n, - cols: self.cols, - size: self.size, - _phantom: PhantomData, - } - } -} - -impl VecZnxBigToMut for VecZnxBig<&mut [u8], B> { - fn to_mut(&mut self) -> VecZnxBig<&mut [u8], B> { - VecZnxBig { - data: self.data, - n: self.n, - cols: self.cols, - size: self.size, - _phantom: PhantomData, - } - } -} - -impl VecZnxBigToRef for VecZnxBig<&mut [u8], B> { - fn to_ref(&self) -> VecZnxBig<&[u8], B> { - VecZnxBig { - data: self.data, - n: self.n, - cols: self.cols, - size: self.size, - _phantom: PhantomData, - } - } -} - -impl VecZnxBigToRef for VecZnxBig<&[u8], B> { - fn to_ref(&self) -> VecZnxBig<&[u8], B> { - VecZnxBig { - data: self.data, - n: self.n, - cols: self.cols, - size: self.size, - _phantom: PhantomData, + _phantom: std::marker::PhantomData, } } } diff --git a/backend/src/vec_znx_big_ops.rs b/backend/src/vec_znx_big_ops.rs index a88dd27..b0b09e7 100644 --- a/backend/src/vec_znx_big_ops.rs +++ b/backend/src/vec_znx_big_ops.rs @@ -128,7 +128,7 @@ pub trait VecZnxBigOps { fn vec_znx_big_normalize(&self, basek: usize, res: &mut R, res_col: usize, a: &A, a_col: usize, scratch: &mut Scratch) where R: VecZnxToMut, - A: VecZnxBigToRef; + A: VecZnxBigToRef; /// Applies the automorphism X^i -> X^ik on `a` and stores the result on `b`. fn vec_znx_big_automorphism(&self, k: i64, res: &mut R, res_col: usize, a: &A, a_col: usize) @@ -501,7 +501,7 @@ impl VecZnxBigOps for Module { } } - fn vec_znx_big_negate_inplace(&self, a: &mut A, res_col: usize) + fn vec_znx_big_negate_inplace(&self, a: &mut A, a_col: usize) where A: VecZnxBigToMut, { @@ -513,10 +513,10 @@ impl VecZnxBigOps for Module { unsafe { vec_znx::vec_znx_negate( self.ptr, - a.at_mut_ptr(res_col, 0), + a.at_mut_ptr(a_col, 0), a.size() as u64, a.sl() as u64, - a.at_ptr(res_col, 0), + a.at_ptr(a_col, 0), a.size() as u64, a.sl() as u64, ) diff --git a/backend/src/vec_znx_dft.rs b/backend/src/vec_znx_dft.rs index c304089..516228a 100644 --- a/backend/src/vec_znx_dft.rs +++ b/backend/src/vec_znx_dft.rs @@ -91,14 +91,14 @@ impl>, B: Backend> VecZnxDft { } } -impl VecZnxDft +impl + AsRef<[u8]>> VecZnxDft where - VecZnxDft: VecZnxDftToMut + ZnxInfos, + VecZnxDft: VecZnxDftToMut, { /// Extracts the a_col-th column of 'a' and stores it on the self_col-th column [Self]. - pub fn extract_column(&mut self, self_col: usize, a: &VecZnxDft, a_col: usize) + pub fn extract_column>(&mut self, self_col: usize, a: &VecZnxDft, a_col: usize) where - VecZnxDft: VecZnxDftToRef + ZnxInfos, + VecZnxDft: VecZnxDftToRef, { #[cfg(debug_assertions)] { @@ -142,66 +142,38 @@ pub trait VecZnxDftToRef { fn to_ref(&self) -> VecZnxDft<&[u8], B>; } -pub trait VecZnxDftToMut: VecZnxDftToRef { +impl VecZnxDftToRef for VecZnxDft +where + D: AsRef<[u8]>, + B: Backend, +{ + fn to_ref(&self) -> VecZnxDft<&[u8], B> { + VecZnxDft { + data: self.data.as_ref(), + n: self.n, + cols: self.cols, + size: self.size, + _phantom: std::marker::PhantomData, + } + } +} + +pub trait VecZnxDftToMut { fn to_mut(&mut self) -> VecZnxDft<&mut [u8], B>; } -impl VecZnxDftToMut for VecZnxDft, B> { +impl VecZnxDftToMut for VecZnxDft +where + D: AsRef<[u8]> + AsMut<[u8]>, + B: Backend, +{ fn to_mut(&mut self) -> VecZnxDft<&mut [u8], B> { VecZnxDft { - data: self.data.as_mut_slice(), + data: self.data.as_mut(), n: self.n, cols: self.cols, size: self.size, - _phantom: PhantomData, - } - } -} - -impl VecZnxDftToRef for VecZnxDft, B> { - fn to_ref(&self) -> VecZnxDft<&[u8], B> { - VecZnxDft { - data: self.data.as_slice(), - n: self.n, - cols: self.cols, - size: self.size, - _phantom: PhantomData, - } - } -} - -impl VecZnxDftToMut for VecZnxDft<&mut [u8], B> { - fn to_mut(&mut self) -> VecZnxDft<&mut [u8], B> { - VecZnxDft { - data: self.data, - n: self.n, - cols: self.cols, - size: self.size, - _phantom: PhantomData, - } - } -} - -impl VecZnxDftToRef for VecZnxDft<&mut [u8], B> { - fn to_ref(&self) -> VecZnxDft<&[u8], B> { - VecZnxDft { - data: self.data, - n: self.n, - cols: self.cols, - size: self.size, - _phantom: PhantomData, - } - } -} - -impl VecZnxDftToRef for VecZnxDft<&[u8], B> { - fn to_ref(&self) -> VecZnxDft<&[u8], B> { - VecZnxDft { - data: self.data, - n: self.n, - cols: self.cols, - size: self.size, - _phantom: PhantomData, + _phantom: std::marker::PhantomData, } } } diff --git a/backend/src/vec_znx_ops.rs b/backend/src/vec_znx_ops.rs index 106f777..55b1136 100644 --- a/backend/src/vec_znx_ops.rs +++ b/backend/src/vec_znx_ops.rs @@ -59,7 +59,7 @@ pub trait VecZnxOps { A: VecZnxToRef; /// Adds the selected column of `a` on the selected column and limb of `res`. - fn vec_znx_add_scalar_inplace(&self, res: &mut R, res_col: usize, res_limb: usize, a: &A, b_col: usize) + fn vec_znx_add_scalar_inplace(&self, res: &mut R, res_col: usize, res_limb: usize, a: &A, a_col: usize) where R: VecZnxToMut, A: ScalarZnxToRef; diff --git a/core/benches/external_product_glwe_fft64.rs b/core/benches/external_product_glwe_fft64.rs index 7c57a2f..7f4800d 100644 --- a/core/benches/external_product_glwe_fft64.rs +++ b/core/benches/external_product_glwe_fft64.rs @@ -5,8 +5,9 @@ use core::{ glwe_ciphertext::GLWECiphertext, keys::{SecretKey, SecretKeyFourier}, }; -use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main}; +use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main}; use sampling::source::Source; +use std::hint::black_box; fn bench_external_product_glwe_fft64(c: &mut Criterion) { let mut group = c.benchmark_group("external_product_glwe_fft64"); diff --git a/core/benches/keyswitch_glwe_fft64.rs b/core/benches/keyswitch_glwe_fft64.rs index 0d30b80..688da18 100644 --- a/core/benches/keyswitch_glwe_fft64.rs +++ b/core/benches/keyswitch_glwe_fft64.rs @@ -5,8 +5,9 @@ use core::{ keys::{SecretKey, SecretKeyFourier}, keyswitch_key::GLWESwitchingKey, }; -use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main}; +use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main}; use sampling::source::Source; +use std::hint::black_box; fn bench_keyswitch_glwe_fft64(c: &mut Criterion) { let mut group = c.benchmark_group("keyswitch_glwe_fft64"); @@ -65,7 +66,7 @@ fn bench_keyswitch_glwe_fft64(c: &mut Criterion) { let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out); sk_out_dft.dft(&module, &sk_out); - ksk.encrypt_sk( + ksk.generate_from_sk( &module, &sk_in, &sk_out_dft, @@ -158,7 +159,7 @@ fn bench_keyswitch_glwe_inplace_fft64(c: &mut Criterion) { let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_out_dft.dft(&module, &sk_out); - ksk.encrypt_sk( + ksk.generate_from_sk( &module, &sk_in, &sk_out_dft, diff --git a/core/src/automorphism.rs b/core/src/automorphism.rs index 8c00744..9be5a8a 100644 --- a/core/src/automorphism.rs +++ b/core/src/automorphism.rs @@ -1,7 +1,6 @@ use backend::{ - Backend, FFT64, MatZnxDft, MatZnxDftOps, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx, ScalarZnxDftAlloc, - ScalarZnxDftOps, ScalarZnxOps, ScalarZnxToRef, Scratch, VecZnx, VecZnxBigAlloc, VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, - VecZnxDftToRef, VecZnxOps, ZnxZero, + Backend, FFT64, MatZnxDft, MatZnxDftOps, Module, ScalarZnxDftAlloc, ScalarZnxDftOps, ScalarZnxOps, Scratch, VecZnx, + VecZnxBigAlloc, VecZnxDftAlloc, VecZnxDftOps, VecZnxOps, ZnxZero, }; use sampling::source::Source; @@ -63,45 +62,27 @@ impl AutomorphismKey { } } -impl MatZnxDftToMut for AutomorphismKey -where - MatZnxDft: MatZnxDftToMut, -{ - fn to_mut(&mut self) -> MatZnxDft<&mut [u8], B> { - self.key.to_mut() +impl> GetRow for AutomorphismKey { + fn get_row + AsRef<[u8]>>( + &self, + module: &Module, + row_i: usize, + col_j: usize, + res: &mut GLWECiphertextFourier, + ) { + module.vmp_extract_row(&mut res.data, &self.key.0.data, row_i, col_j); } } -impl MatZnxDftToRef for AutomorphismKey -where - MatZnxDft: MatZnxDftToRef, -{ - fn to_ref(&self) -> MatZnxDft<&[u8], B> { - self.key.to_ref() - } -} - -impl GetRow for AutomorphismKey -where - MatZnxDft: MatZnxDftToRef, -{ - fn get_row(&self, module: &Module, row_i: usize, col_j: usize, res: &mut R) - where - R: VecZnxDftToMut, - { - module.vmp_extract_row(res, self, row_i, col_j); - } -} - -impl SetRow for AutomorphismKey -where - MatZnxDft: MatZnxDftToMut, -{ - fn set_row(&mut self, module: &Module, row_i: usize, col_j: usize, a: &R) - where - R: VecZnxDftToRef, - { - module.vmp_prepare_row(self, row_i, col_j, a); +impl + AsRef<[u8]>> SetRow for AutomorphismKey { + fn set_row>( + &mut self, + module: &Module, + row_i: usize, + col_j: usize, + a: &GLWECiphertextFourier, + ) { + module.vmp_prepare_row(&mut self.key.0.data, row_i, col_j, &a.data); } } @@ -166,11 +147,8 @@ impl AutomorphismKey, FFT64> { } } -impl AutomorphismKey -where - MatZnxDft: MatZnxDftToMut, -{ - pub fn generate_from_sk( +impl + AsRef<[u8]>> AutomorphismKey { + pub fn generate_from_sk>( &mut self, module: &Module, p: i64, @@ -179,9 +157,7 @@ where source_xe: &mut Source, sigma: f64, scratch: &mut Scratch, - ) where - ScalarZnx: ScalarZnxToRef, - { + ) { #[cfg(debug_assertions)] { assert_eq!(self.n(), module.n()); @@ -209,12 +185,18 @@ where { (0..self.rank()).for_each(|i| { let (mut sk_inv_auto, _) = scratch_1.tmp_scalar_znx(module, 1); - module.scalar_znx_automorphism(module.galois_element_inv(p), &mut sk_inv_auto, 0, sk, i); - module.svp_prepare(&mut sk_out_dft, i, &sk_inv_auto, 0); + module.scalar_znx_automorphism( + module.galois_element_inv(p), + &mut sk_inv_auto, + 0, + &sk.data, + i, + ); + module.svp_prepare(&mut sk_out_dft.data, i, &sk_inv_auto, 0); }); } - self.key.encrypt_sk( + self.key.generate_from_sk( module, &sk, &sk_out_dft, @@ -228,20 +210,14 @@ where } } -impl AutomorphismKey -where - MatZnxDft: MatZnxDftToMut, -{ - pub fn automorphism( +impl + AsRef<[u8]>> AutomorphismKey { + pub fn automorphism, DataRhs: AsRef<[u8]>>( &mut self, module: &Module, lhs: &AutomorphismKey, rhs: &AutomorphismKey, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - MatZnxDft: MatZnxDftToRef, - { + ) { #[cfg(debug_assertions)] { assert_eq!( @@ -311,8 +287,8 @@ where // Applies back the automorphism X^{k}: (-pi^{-1}_{k'}(s)a + pi_{k}(s), a) -> (-pi^{-1}_{k'+k}(s)a + s, a) // and switches back to DFT domain (0..self.rank_out() + 1).for_each(|i| { - module.vec_znx_automorphism_inplace(lhs.p(), &mut tmp_idft, i); - module.vec_znx_dft(&mut tmp_dft, i, &tmp_idft, i); + module.vec_znx_automorphism_inplace(lhs.p(), &mut tmp_idft.data, i); + module.vec_znx_dft(&mut tmp_dft.data, i, &tmp_idft.data, i); }); // Sets back the relevant row @@ -331,65 +307,53 @@ where self.p = (lhs.p * rhs.p) % (module.cyclotomic_order() as i64); } - pub fn automorphism_inplace( + pub fn automorphism_inplace>( &mut self, module: &Module, rhs: &AutomorphismKey, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - { + ) { unsafe { let self_ptr: *mut AutomorphismKey = self as *mut AutomorphismKey; self.automorphism(&module, &*self_ptr, rhs, scratch); } } - pub fn keyswitch( + pub fn keyswitch, DataRhs: AsRef<[u8]>>( &mut self, module: &Module, lhs: &AutomorphismKey, rhs: &GLWESwitchingKey, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - MatZnxDft: MatZnxDftToRef, - { + ) { self.key.keyswitch(module, &lhs.key, rhs, scratch); } - pub fn keyswitch_inplace( + pub fn keyswitch_inplace>( &mut self, module: &Module, rhs: &AutomorphismKey, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - { + ) { self.key.keyswitch_inplace(module, &rhs.key, scratch); } - pub fn external_product( + pub fn external_product, DataRhs: AsRef<[u8]>>( &mut self, module: &Module, lhs: &AutomorphismKey, rhs: &GGSWCiphertext, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - MatZnxDft: MatZnxDftToRef, - { + ) { self.key.external_product(module, &lhs.key, rhs, scratch); } - pub fn external_product_inplace( + pub fn external_product_inplace>( &mut self, module: &Module, rhs: &GGSWCiphertext, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - { + ) { self.key.external_product_inplace(module, rhs, scratch); } } diff --git a/core/src/elem.rs b/core/src/elem.rs index 426e23d..131e9d7 100644 --- a/core/src/elem.rs +++ b/core/src/elem.rs @@ -1,6 +1,6 @@ -use backend::{Backend, Module, VecZnxDftToMut, VecZnxDftToRef, ZnxInfos}; +use backend::{Backend, Module, ZnxInfos}; -use crate::utils::derive_size; +use crate::{glwe_ciphertext_fourier::GLWECiphertextFourier, utils::derive_size}; pub trait Infos { type Inner: ZnxInfos; @@ -56,13 +56,13 @@ pub trait SetMetaData { } pub trait GetRow { - fn get_row(&self, module: &Module, row_i: usize, col_j: usize, res: &mut R) + fn get_row(&self, module: &Module, row_i: usize, col_j: usize, res: &mut GLWECiphertextFourier) where - R: VecZnxDftToMut; + R: AsMut<[u8]> + AsRef<[u8]>; } pub trait SetRow { - fn set_row(&mut self, module: &Module, row_i: usize, col_j: usize, a: &R) + fn set_row(&mut self, module: &Module, row_i: usize, col_j: usize, a: &GLWECiphertextFourier) where - R: VecZnxDftToRef; + R: AsRef<[u8]>; } diff --git a/core/src/gglwe_ciphertext.rs b/core/src/gglwe_ciphertext.rs index 6cbab5d..23d74e0 100644 --- a/core/src/gglwe_ciphertext.rs +++ b/core/src/gglwe_ciphertext.rs @@ -1,7 +1,6 @@ use backend::{ - Backend, FFT64, MatZnxDft, MatZnxDftAlloc, MatZnxDftOps, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx, ScalarZnxDft, - ScalarZnxDftToRef, ScalarZnxToRef, Scratch, VecZnxAlloc, VecZnxDftAlloc, VecZnxDftToMut, VecZnxDftToRef, VecZnxOps, ZnxInfos, - ZnxZero, + Backend, FFT64, MatZnxDft, MatZnxDftAlloc, MatZnxDftOps, Module, ScalarZnx, Scratch, VecZnxAlloc, VecZnxDftAlloc, VecZnxOps, + ZnxInfos, ZnxZero, }; use sampling::source::Source; @@ -60,24 +59,6 @@ impl GGLWECiphertext { } } -impl MatZnxDftToMut for GGLWECiphertext -where - MatZnxDft: MatZnxDftToMut, -{ - fn to_mut(&mut self) -> MatZnxDft<&mut [u8], B> { - self.data.to_mut() - } -} - -impl MatZnxDftToRef for GGLWECiphertext -where - MatZnxDft: MatZnxDftToRef, -{ - fn to_ref(&self) -> MatZnxDft<&[u8], B> { - self.data.to_ref() - } -} - impl GGLWECiphertext, FFT64> { pub fn generate_from_sk_scratch_space(module: &Module, rank: usize, size: usize) -> usize { GLWECiphertext::encrypt_sk_scratch_space(module, size) @@ -91,11 +72,8 @@ impl GGLWECiphertext, FFT64> { } } -impl GGLWECiphertext -where - MatZnxDft: MatZnxDftToMut + ZnxInfos, -{ - pub fn generate_from_sk( +impl + AsRef<[u8]>> GGLWECiphertext { + pub fn encrypt_sk, DataSk: AsRef<[u8]>>( &mut self, module: &Module, pt: &ScalarZnx, @@ -104,10 +82,7 @@ where source_xe: &mut Source, sigma: f64, scratch: &mut Scratch, - ) where - ScalarZnx: ScalarZnxToRef, - ScalarZnxDft: ScalarZnxDftToRef, - { + ) { #[cfg(debug_assertions)] { assert_eq!(self.rank_in(), pt.cols()); @@ -171,8 +146,8 @@ where (0..rows).for_each(|row_i| { // Adds the scalar_znx_pt to the i-th limb of the vec_znx_pt vec_znx_pt.data.zero(); // zeroes for next iteration - module.vec_znx_add_scalar_inplace(&mut vec_znx_pt, 0, row_i, pt, col_i); // Selects the i-th - module.vec_znx_normalize_inplace(basek, &mut vec_znx_pt, 0, scratch_3); + module.vec_znx_add_scalar_inplace(&mut vec_znx_pt.data, 0, row_i, pt, col_i); // Selects the i-th + module.vec_znx_normalize_inplace(basek, &mut vec_znx_pt.data, 0, scratch_3); // rlwe encrypt of vec_znx_pt into vec_znx_ct vec_znx_ct.encrypt_sk( @@ -189,32 +164,32 @@ where vec_znx_ct.dft(module, &mut vec_znx_ct_dft); // Stores vec_znx_dft_ct into thw i-th row of the MatZnxDft - module.vmp_prepare_row(self, row_i, col_i, &vec_znx_ct_dft); + module.vmp_prepare_row(&mut self.data, row_i, col_i, &vec_znx_ct_dft.data); }); }); } } -impl GetRow for GGLWECiphertext -where - MatZnxDft: MatZnxDftToRef, -{ - fn get_row(&self, module: &Module, row_i: usize, col_j: usize, res: &mut R) - where - R: VecZnxDftToMut, - { - module.vmp_extract_row(res, self, row_i, col_j); +impl> GetRow for GGLWECiphertext { + fn get_row + AsRef<[u8]>>( + &self, + module: &Module, + row_i: usize, + col_j: usize, + res: &mut GLWECiphertextFourier, + ) { + module.vmp_extract_row(&mut res.data, &self.data, row_i, col_j); } } -impl SetRow for GGLWECiphertext -where - MatZnxDft: MatZnxDftToMut, -{ - fn set_row(&mut self, module: &Module, row_i: usize, col_j: usize, a: &R) - where - R: VecZnxDftToRef, - { - module.vmp_prepare_row(self, row_i, col_j, a); +impl + AsRef<[u8]>> SetRow for GGLWECiphertext { + fn set_row>( + &mut self, + module: &Module, + row_i: usize, + col_j: usize, + a: &GLWECiphertextFourier, + ) { + module.vmp_prepare_row(&mut self.data, row_i, col_j, &a.data); } } diff --git a/core/src/ggsw_ciphertext.rs b/core/src/ggsw_ciphertext.rs index 7215adf..1d4d3e4 100644 --- a/core/src/ggsw_ciphertext.rs +++ b/core/src/ggsw_ciphertext.rs @@ -1,7 +1,6 @@ use backend::{ - Backend, FFT64, MatZnxDft, MatZnxDftAlloc, MatZnxDftOps, MatZnxDftScratch, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx, - ScalarZnxDft, ScalarZnxDftToRef, ScalarZnxToRef, Scratch, VecZnx, VecZnxAlloc, VecZnxBigAlloc, VecZnxBigOps, - VecZnxBigScratch, VecZnxDft, VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, VecZnxDftToRef, VecZnxOps, VecZnxToMut, ZnxInfos, + Backend, FFT64, MatZnxDft, MatZnxDftAlloc, MatZnxDftOps, MatZnxDftScratch, Module, ScalarZnx, Scratch, VecZnxAlloc, + VecZnxBigAlloc, VecZnxBigOps, VecZnxBigScratch, VecZnxDft, VecZnxDftAlloc, VecZnxDftOps, VecZnxOps, VecZnxToMut, ZnxInfos, ZnxZero, }; use sampling::source::Source; @@ -56,24 +55,6 @@ impl GGSWCiphertext { } } -impl MatZnxDftToMut for GGSWCiphertext -where - MatZnxDft: MatZnxDftToMut, -{ - fn to_mut(&mut self) -> MatZnxDft<&mut [u8], B> { - self.data.to_mut() - } -} - -impl MatZnxDftToRef for GGSWCiphertext -where - MatZnxDft: MatZnxDftToRef, -{ - fn to_ref(&self) -> MatZnxDft<&[u8], B> { - self.data.to_ref() - } -} - impl GGSWCiphertext, FFT64> { pub fn encrypt_sk_scratch_space(module: &Module, rank: usize, size: usize) -> usize { GLWECiphertext::encrypt_sk_scratch_space(module, size) @@ -146,7 +127,8 @@ impl GGSWCiphertext, FFT64> { let res: usize = module.bytes_of_vec_znx(cols, out_size); let res_dft: usize = module.bytes_of_vec_znx_dft(cols, out_size); let ci_dft: usize = module.bytes_of_vec_znx_dft(cols, out_size); - let ks_internal: usize = GGSWCiphertext::keyswitch_internal_col0_scratch_space(module, out_size, in_size, auto_key_size, rank); + let ks_internal: usize = + GGSWCiphertext::keyswitch_internal_col0_scratch_space(module, out_size, in_size, auto_key_size, rank); let expand: usize = GGSWCiphertext::expand_row_scratch_space(module, out_size, tensor_key_size, rank); res + ci_dft + (ks_internal | expand | res_dft) } @@ -193,11 +175,8 @@ impl GGSWCiphertext, FFT64> { } } -impl GGSWCiphertext -where - MatZnxDft: MatZnxDftToMut, -{ - pub fn encrypt_sk( +impl + AsRef<[u8]>> GGSWCiphertext { + pub fn encrypt_sk, DataSk: AsRef<[u8]>>( &mut self, module: &Module, pt: &ScalarZnx, @@ -206,10 +185,7 @@ where source_xe: &mut Source, sigma: f64, scratch: &mut Scratch, - ) where - ScalarZnx: ScalarZnxToRef, - ScalarZnxDft: ScalarZnxDftToRef, - { + ) { #[cfg(debug_assertions)] { assert_eq!(self.rank(), sk_dft.rank()); @@ -242,8 +218,8 @@ where vec_znx_pt.data.zero(); // Adds the scalar_znx_pt to the i-th limb of the vec_znx_pt - module.vec_znx_add_scalar_inplace(&mut vec_znx_pt, 0, row_i, pt, 0); - module.vec_znx_normalize_inplace(basek, &mut vec_znx_pt, 0, scrach_2); + module.vec_znx_add_scalar_inplace(&mut vec_znx_pt.data, 0, row_i, pt, 0); + module.vec_znx_normalize_inplace(basek, &mut vec_znx_pt.data, 0, scrach_2); (0..cols).for_each(|col_j| { // rlwe encrypt of vec_znx_pt into vec_znx_ct @@ -263,16 +239,16 @@ where let (mut vec_znx_dft_ct, _) = scrach_2.tmp_vec_znx_dft(module, cols, size); (0..cols).for_each(|i| { - module.vec_znx_dft(&mut vec_znx_dft_ct, i, &vec_znx_ct, i); + module.vec_znx_dft(&mut vec_znx_dft_ct, i, &vec_znx_ct.data, i); }); - self.set_row(module, row_i, col_j, &vec_znx_dft_ct); + module.vmp_prepare_row(&mut self.data, row_i, col_j, &vec_znx_dft_ct); } }); }); } - pub(crate) fn expand_row( + pub(crate) fn expand_row, DataTsk: AsRef<[u8]>>( &mut self, module: &Module, col_j: usize, @@ -282,8 +258,6 @@ where scratch: &mut Scratch, ) where R: VecZnxToMut, - VecZnxDft: VecZnxDftToRef, - MatZnxDft: MatZnxDftToRef, { let cols: usize = self.rank() + 1; @@ -332,14 +306,14 @@ where module.vmp_apply( &mut tmp_dft_i, &tmp_dft_col_data, - tsk.at(col_i - 1, col_j - 1), // Selects Enc(s[i]s[j]) + &tsk.at(col_i - 1, col_j - 1).0.data, // Selects Enc(s[i]s[j]) scratch2, ); } else { module.vmp_apply_add( &mut tmp_dft_i, &tmp_dft_col_data, - tsk.at(col_i - 1, col_j - 1), // Selects Enc(s[i]s[j]) + &tsk.at(col_i - 1, col_j - 1).0.data, // Selects Enc(s[i]s[j]) scratch2, ); } @@ -363,18 +337,14 @@ where }); } - pub fn keyswitch( + pub fn keyswitch, DataKsk: AsRef<[u8]>, DataTsk: AsRef<[u8]>>( &mut self, module: &Module, lhs: &GGSWCiphertext, ksk: &GLWESwitchingKey, tsk: &TensorKey, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - MatZnxDft: MatZnxDftToRef, - MatZnxDft: MatZnxDftToRef, - { + ) { let cols: usize = self.rank() + 1; let (res_data, scratch1) = scratch.tmp_vec_znx(&module, cols, self.size()); @@ -394,10 +364,10 @@ where // Isolates DFT(a[i]) (0..cols).for_each(|col_i| { - module.vec_znx_dft(&mut ci_dft, col_i, &res, col_i); + module.vec_znx_dft(&mut ci_dft, col_i, &res.data, col_i); }); - self.set_row(module, row_i, 0, &ci_dft); + module.vmp_prepare_row(&mut self.data, row_i, 0, &ci_dft); // Generates // @@ -405,46 +375,39 @@ where // col 2: (-(c0s0' + c1s1' + c2s2') , c0 , c1 + M[i], c2 ) // col 3: (-(d0s0' + d1s1' + d2s2') , d0 , d1 , d2 + M[i]) (1..cols).for_each(|col_j| { - self.expand_row(module, col_j, &mut res, &ci_dft, tsk, scratch2); + self.expand_row(module, col_j, &mut res.data, &ci_dft, tsk, scratch2); let (mut res_dft, _) = scratch2.tmp_vec_znx_dft(module, cols, self.size()); (0..cols).for_each(|i| { - module.vec_znx_dft(&mut res_dft, i, &res, i); + module.vec_znx_dft(&mut res_dft, i, &res.data, i); }); - self.set_row(module, row_i, col_j, &res_dft); - }) + module.vmp_prepare_row(&mut self.data, row_i, col_j, &res_dft); + }); }) } - pub fn keyswitch_inplace( + pub fn keyswitch_inplace, DataTsk: AsRef<[u8]>>( &mut self, module: &Module, ksk: &GLWESwitchingKey, tsk: &TensorKey, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - MatZnxDft: MatZnxDftToRef, - { + ) { unsafe { let self_ptr: *mut GGSWCiphertext = self as *mut GGSWCiphertext; self.keyswitch(module, &*self_ptr, ksk, tsk, scratch); } } - pub fn automorphism( + pub fn automorphism, DataAk: AsRef<[u8]>, DataTsk: AsRef<[u8]>>( &mut self, module: &Module, lhs: &GGSWCiphertext, auto_key: &AutomorphismKey, tensor_key: &TensorKey, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - MatZnxDft: MatZnxDftToRef, - MatZnxDft: MatZnxDftToRef, - { + ) { #[cfg(debug_assertions)] { assert_eq!( @@ -468,7 +431,17 @@ where self.rank(), tensor_key.rank() ); - assert!(scratch.available() >= GGSWCiphertext::automorphism_scratch_space(module, self.size(), lhs.size(), auto_key.size(), tensor_key.size(), self.rank())) + assert!( + scratch.available() + >= GGSWCiphertext::automorphism_scratch_space( + module, + self.size(), + lhs.size(), + auto_key.size(), + tensor_key.size(), + self.rank() + ) + ) }; let cols: usize = self.rank() + 1; @@ -491,11 +464,11 @@ where // Isolates DFT(AUTO(a[i])) (0..cols).for_each(|col_i| { // (-(a0pi^-1(s0) + a1pi^-1(s1) + a2pi^-1(s2)) + M[i], a0, a1, a2) -> (-(a0s0 + a1s1 + a2s2) + pi(M[i]), a0, a1, a2) - module.vec_znx_automorphism_inplace(auto_key.p(), &mut res, col_i); - module.vec_znx_dft(&mut ci_dft, col_i, &res, col_i); + module.vec_znx_automorphism_inplace(auto_key.p(), &mut res.data, col_i); + module.vec_znx_dft(&mut ci_dft, col_i, &res.data, col_i); }); - self.set_row(module, row_i, 0, &ci_dft); + module.vmp_prepare_row(&mut self.data, row_i, 0, &ci_dft); // Generates // @@ -503,44 +476,38 @@ where // col 2: (-(c0s0 + c1s1 + c2s2) , c0 , c1 + pi(M[i]), c2 ) // col 3: (-(d0s0 + d1s1 + d2s2) , d0 , d1 , d2 + pi(M[i])) (1..cols).for_each(|col_j| { - self.expand_row(module, col_j, &mut res, &ci_dft, tensor_key, scratch2); + self.expand_row(module, col_j, &mut res.data, &ci_dft, tensor_key, scratch2); let (mut res_dft, _) = scratch2.tmp_vec_znx_dft(module, cols, self.size()); (0..cols).for_each(|i| { - module.vec_znx_dft(&mut res_dft, i, &res, i); + module.vec_znx_dft(&mut res_dft, i, &res.data, i); }); - self.set_row(module, row_i, col_j, &res_dft); - }) + module.vmp_prepare_row(&mut self.data, row_i, col_j, &res_dft); + }); }) } - pub fn automorphism_inplace( + pub fn automorphism_inplace, DataTsk: AsRef<[u8]>>( &mut self, module: &Module, auto_key: &AutomorphismKey, tensor_key: &TensorKey, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - MatZnxDft: MatZnxDftToRef, - { + ) { unsafe { let self_ptr: *mut GGSWCiphertext = self as *mut GGSWCiphertext; self.automorphism(module, &*self_ptr, auto_key, tensor_key, scratch); } } - pub fn external_product( + pub fn external_product, DataRhs: AsRef<[u8]>>( &mut self, module: &Module, lhs: &GGSWCiphertext, rhs: &GGSWCiphertext, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - MatZnxDft: MatZnxDftToRef, - { + ) { #[cfg(debug_assertions)] { assert_eq!( @@ -592,14 +559,12 @@ where }); } - pub fn external_product_inplace( + pub fn external_product_inplace>( &mut self, module: &Module, rhs: &GGSWCiphertext, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - { + ) { #[cfg(debug_assertions)] { assert_eq!( @@ -629,26 +594,29 @@ where } } -impl GGSWCiphertext -where - MatZnxDft: MatZnxDftToRef, -{ - pub(crate) fn keyswitch_internal_col0( +impl> GGSWCiphertext { + pub(crate) fn keyswitch_internal_col0 + AsRef<[u8]>, DataKsk: AsRef<[u8]>>( &self, module: &Module, row_i: usize, res: &mut GLWECiphertext, ksk: &GLWESwitchingKey, scratch: &mut Scratch, - ) where - VecZnx: VecZnxToMut, - MatZnxDft: MatZnxDftToRef, - { + ) { #[cfg(debug_assertions)] { assert_eq!(self.rank(), ksk.rank()); assert_eq!(res.rank(), ksk.rank()); - assert!(scratch.available() >= GGSWCiphertext::keyswitch_internal_col0_scratch_space(module, res.size(), self.size(), ksk.size(), ksk.rank())) + assert!( + scratch.available() + >= GGSWCiphertext::keyswitch_internal_col0_scratch_space( + module, + res.size(), + self.size(), + ksk.size(), + ksk.rank() + ) + ) } let (tmp_dft_in_data, scratch2) = scratch.tmp_vec_znx_dft(module, self.rank() + 1, self.size()); @@ -662,26 +630,26 @@ where } } -impl GetRow for GGSWCiphertext -where - MatZnxDft: MatZnxDftToRef, -{ - fn get_row(&self, module: &Module, row_i: usize, col_j: usize, res: &mut R) - where - R: VecZnxDftToMut, - { - module.vmp_extract_row(res, self, row_i, col_j); +impl> GetRow for GGSWCiphertext { + fn get_row + AsRef<[u8]>>( + &self, + module: &Module, + row_i: usize, + col_j: usize, + res: &mut GLWECiphertextFourier, + ) { + module.vmp_extract_row(&mut res.data, &self.data, row_i, col_j); } } -impl SetRow for GGSWCiphertext -where - MatZnxDft: MatZnxDftToMut, -{ - fn set_row(&mut self, module: &Module, row_i: usize, col_j: usize, a: &R) - where - R: VecZnxDftToRef, - { - module.vmp_prepare_row(self, row_i, col_j, a); +impl + AsRef<[u8]>> SetRow for GGSWCiphertext { + fn set_row>( + &mut self, + module: &Module, + row_i: usize, + col_j: usize, + a: &GLWECiphertextFourier, + ) { + module.vmp_prepare_row(&mut self.data, row_i, col_j, &a.data); } } diff --git a/core/src/glwe_ciphertext.rs b/core/src/glwe_ciphertext.rs index 8adb7e7..8870af9 100644 --- a/core/src/glwe_ciphertext.rs +++ b/core/src/glwe_ciphertext.rs @@ -1,8 +1,7 @@ use backend::{ - AddNormal, Backend, FFT64, FillUniform, MatZnxDft, MatZnxDftOps, MatZnxDftScratch, MatZnxDftToRef, Module, ScalarZnxAlloc, - ScalarZnxDft, ScalarZnxDftAlloc, ScalarZnxDftOps, ScalarZnxDftToRef, Scratch, VecZnx, VecZnxAlloc, VecZnxBig, VecZnxBigAlloc, - VecZnxBigOps, VecZnxBigScratch, VecZnxDft, VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, VecZnxDftToRef, VecZnxOps, - VecZnxToMut, VecZnxToRef, ZnxInfos, ZnxZero, + AddNormal, Backend, FFT64, FillUniform, MatZnxDftOps, MatZnxDftScratch, Module, ScalarZnxAlloc, ScalarZnxDftAlloc, + ScalarZnxDftOps, Scratch, VecZnx, VecZnxAlloc, VecZnxBig, VecZnxBigAlloc, VecZnxBigOps, VecZnxBigScratch, VecZnxDftAlloc, + VecZnxDftOps, VecZnxOps, VecZnxToMut, VecZnxToRef, ZnxZero, }; use sampling::source::Source; @@ -12,6 +11,7 @@ use crate::{ elem::{Infos, SetMetaData}, ggsw_ciphertext::GGSWCiphertext, glwe_ciphertext_fourier::GLWECiphertextFourier, + glwe_ops::GLWEOps, glwe_plaintext::GLWEPlaintext, keys::{GLWEPublicKey, SecretDistribution, SecretKeyFourier}, keyswitch_key::GLWESwitchingKey, @@ -56,33 +56,9 @@ impl GLWECiphertext { } } -impl VecZnxToMut for GLWECiphertext -where - VecZnx: VecZnxToMut, -{ - fn to_mut(&mut self) -> VecZnx<&mut [u8]> { - self.data.to_mut() - } -} - -impl VecZnxToRef for GLWECiphertext -where - VecZnx: VecZnxToRef, -{ - fn to_ref(&self) -> VecZnx<&[u8]> { - self.data.to_ref() - } -} - -impl GLWECiphertext -where - VecZnx: VecZnxToRef, -{ +impl> GLWECiphertext { #[allow(dead_code)] - pub(crate) fn dft(&self, module: &Module, res: &mut GLWECiphertextFourier) - where - VecZnxDft: VecZnxDftToMut + ZnxInfos, - { + pub(crate) fn dft + AsRef<[u8]>>(&self, module: &Module, res: &mut GLWECiphertextFourier) { #[cfg(debug_assertions)] { assert_eq!(self.rank(), res.rank()); @@ -90,7 +66,7 @@ where } (0..self.rank() + 1).for_each(|i| { - module.vec_znx_dft(res, i, self, i); + module.vec_znx_dft(&mut res.data, i, &self.data, i); }) } } @@ -199,10 +175,7 @@ impl GLWECiphertext> { } } -impl SetMetaData for GLWECiphertext -where - VecZnx: VecZnxToMut, -{ +impl + AsRef<[u8]>> SetMetaData for GLWECiphertext { fn set_k(&mut self, k: usize) { self.k = k } @@ -212,11 +185,8 @@ where } } -impl GLWECiphertext -where - VecZnx: VecZnxToMut, -{ - pub fn encrypt_sk( +impl + AsMut<[u8]>> GLWECiphertext { + pub fn encrypt_sk, DataSk: AsRef<[u8]>>( &mut self, module: &Module, pt: &GLWEPlaintext, @@ -225,10 +195,7 @@ where source_xe: &mut Source, sigma: f64, scratch: &mut Scratch, - ) where - VecZnx: VecZnxToRef, - ScalarZnxDft: ScalarZnxDftToRef, - { + ) { self.encrypt_sk_private( module, Some((pt, 0)), @@ -240,7 +207,7 @@ where ); } - pub fn encrypt_zero_sk( + pub fn encrypt_zero_sk>( &mut self, module: &Module, sk_dft: &SecretKeyFourier, @@ -248,13 +215,19 @@ where source_xe: &mut Source, sigma: f64, scratch: &mut Scratch, - ) where - ScalarZnxDft: ScalarZnxDftToRef, - { - self.encrypt_sk_private(module, None, sk_dft, source_xa, source_xe, sigma, scratch); + ) { + self.encrypt_sk_private( + module, + None::<(&GLWEPlaintext>, usize)>, + sk_dft, + source_xa, + source_xe, + sigma, + scratch, + ); } - pub fn encrypt_pk( + pub fn encrypt_pk, DataPk: AsRef<[u8]>>( &mut self, module: &Module, pt: &GLWEPlaintext, @@ -263,10 +236,7 @@ where source_xe: &mut Source, sigma: f64, scratch: &mut Scratch, - ) where - VecZnx: VecZnxToRef, - VecZnxDft: VecZnxDftToRef, - { + ) { self.encrypt_pk_private( module, Some((pt, 0)), @@ -278,7 +248,7 @@ where ); } - pub fn encrypt_zero_pk( + pub fn encrypt_zero_pk>( &mut self, module: &Module, pk: &GLWEPublicKey, @@ -286,133 +256,116 @@ where source_xe: &mut Source, sigma: f64, scratch: &mut Scratch, - ) where - VecZnxDft: VecZnxDftToRef, - { - self.encrypt_pk_private(module, None, pk, source_xu, source_xe, sigma, scratch); + ) { + self.encrypt_pk_private( + module, + None::<(&GLWEPlaintext>, usize)>, + pk, + source_xu, + source_xe, + sigma, + scratch, + ); } - pub fn automorphism( + pub fn automorphism, DataRhs: AsRef<[u8]>>( &mut self, module: &Module, lhs: &GLWECiphertext, rhs: &AutomorphismKey, scratch: &mut Scratch, - ) where - VecZnx: VecZnxToRef, - MatZnxDft: MatZnxDftToRef, - { + ) { self.keyswitch(module, lhs, &rhs.key, scratch); (0..self.rank() + 1).for_each(|i| { - module.vec_znx_automorphism_inplace(rhs.p(), self, i); + module.vec_znx_automorphism_inplace(rhs.p(), &mut self.data, i); }) } - pub fn automorphism_inplace( + pub fn automorphism_inplace>( &mut self, module: &Module, rhs: &AutomorphismKey, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - { + ) { self.keyswitch_inplace(module, &rhs.key, scratch); (0..self.rank() + 1).for_each(|i| { - module.vec_znx_automorphism_inplace(rhs.p(), self, i); + module.vec_znx_automorphism_inplace(rhs.p(), &mut self.data, i); }) } - pub fn automorphism_add( + pub fn automorphism_add, DataRhs: AsRef<[u8]>>( &mut self, module: &Module, lhs: &GLWECiphertext, rhs: &AutomorphismKey, scratch: &mut Scratch, - ) where - VecZnx: VecZnxToRef, - MatZnxDft: MatZnxDftToRef, - { + ) { Self::keyswitch_private::<_, _, 1>(self, rhs.p(), module, lhs, &rhs.key, scratch); } - pub fn automorphism_add_inplace( + pub fn automorphism_add_inplace>( &mut self, module: &Module, rhs: &AutomorphismKey, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - { + ) { unsafe { let self_ptr: *mut GLWECiphertext = self as *mut GLWECiphertext; Self::keyswitch_private::<_, _, 1>(self, rhs.p(), module, &*self_ptr, &rhs.key, scratch); } } - pub fn automorphism_sub_ab( + pub fn automorphism_sub_ab, DataRhs: AsRef<[u8]>>( &mut self, module: &Module, lhs: &GLWECiphertext, rhs: &AutomorphismKey, scratch: &mut Scratch, - ) where - VecZnx: VecZnxToRef, - MatZnxDft: MatZnxDftToRef, - { + ) { Self::keyswitch_private::<_, _, 2>(self, rhs.p(), module, lhs, &rhs.key, scratch); } - pub fn automorphism_sub_ab_inplace( + pub fn automorphism_sub_ab_inplace>( &mut self, module: &Module, rhs: &AutomorphismKey, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - { + ) { unsafe { let self_ptr: *mut GLWECiphertext = self as *mut GLWECiphertext; Self::keyswitch_private::<_, _, 2>(self, rhs.p(), module, &*self_ptr, &rhs.key, scratch); } } - pub fn automorphism_sub_ba( + pub fn automorphism_sub_ba, DataRhs: AsRef<[u8]>>( &mut self, module: &Module, lhs: &GLWECiphertext, rhs: &AutomorphismKey, scratch: &mut Scratch, - ) where - VecZnx: VecZnxToRef, - MatZnxDft: MatZnxDftToRef, - { + ) { Self::keyswitch_private::<_, _, 3>(self, rhs.p(), module, lhs, &rhs.key, scratch); } - pub fn automorphism_sub_ba_inplace( + pub fn automorphism_sub_ba_inplace>( &mut self, module: &Module, rhs: &AutomorphismKey, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - { + ) { unsafe { let self_ptr: *mut GLWECiphertext = self as *mut GLWECiphertext; Self::keyswitch_private::<_, _, 3>(self, rhs.p(), module, &*self_ptr, &rhs.key, scratch); } } - pub(crate) fn keyswitch_from_fourier( + pub(crate) fn keyswitch_from_fourier, DataRhs: AsRef<[u8]>>( &mut self, module: &Module, lhs: &GLWECiphertextFourier, rhs: &GLWESwitchingKey, scratch: &mut Scratch, - ) where - VecZnxDft: VecZnxDftToRef, - MatZnxDft: MatZnxDftToRef, - { + ) { let basek: usize = self.basek(); #[cfg(debug_assertions)] @@ -447,45 +400,39 @@ where // Applies VMP let (mut ai_dft, scratch2) = scratch1.tmp_vec_znx_dft(module, cols_in, lhs.size()); (0..cols_in).for_each(|col_i| { - module.vec_znx_dft_copy(&mut ai_dft, col_i, lhs, col_i + 1); + module.vec_znx_dft_copy(&mut ai_dft, col_i, &lhs.data, col_i + 1); }); - module.vmp_apply(&mut res_dft, &ai_dft, rhs, scratch2); + module.vmp_apply(&mut res_dft, &ai_dft, &rhs.0.data, scratch2); } - module.vec_znx_dft_add_inplace(&mut res_dft, 0, lhs, 0); + module.vec_znx_dft_add_inplace(&mut res_dft, 0, &lhs.data, 0); // Switches result of VMP outside of DFT let res_big: VecZnxBig<&mut [u8], FFT64> = module.vec_znx_idft_consume::<&mut [u8]>(res_dft); (0..cols_out).for_each(|i| { - module.vec_znx_big_normalize(basek, self, i, &res_big, i, scratch1); + module.vec_znx_big_normalize(basek, &mut self.data, i, &res_big, i, scratch1); }); } - pub fn keyswitch( + pub fn keyswitch, DataRhs: AsRef<[u8]>>( &mut self, module: &Module, lhs: &GLWECiphertext, rhs: &GLWESwitchingKey, scratch: &mut Scratch, - ) where - VecZnx: VecZnxToRef, - MatZnxDft: MatZnxDftToRef, - { + ) { Self::keyswitch_private::<_, _, 0>(self, 0, module, lhs, rhs, scratch); } - pub(crate) fn keyswitch_private( + pub(crate) fn keyswitch_private, DataRhs: AsRef<[u8]>, const OP: u8>( &mut self, apply_auto: i64, module: &Module, lhs: &GLWECiphertext, rhs: &GLWESwitchingKey, scratch: &mut Scratch, - ) where - VecZnx: VecZnxToRef, - MatZnxDft: MatZnxDftToRef, - { + ) { let basek: usize = self.basek(); #[cfg(debug_assertions)] @@ -518,14 +465,14 @@ where { let (mut ai_dft, scratch2) = scratch1.tmp_vec_znx_dft(module, cols_in, lhs.size()); (0..cols_in).for_each(|col_i| { - module.vec_znx_dft(&mut ai_dft, col_i, lhs, col_i + 1); + module.vec_znx_dft(&mut ai_dft, col_i, &lhs.data, col_i + 1); }); - module.vmp_apply(&mut res_dft, &ai_dft, rhs, scratch2); + module.vmp_apply(&mut res_dft, &ai_dft, &rhs.0.data, scratch2); } let mut res_big: VecZnxBig<&mut [u8], FFT64> = module.vec_znx_idft_consume(res_dft); - module.vec_znx_big_add_small_inplace(&mut res_big, 0, lhs, 0); + module.vec_znx_big_add_small_inplace(&mut res_big, 0, &lhs.data, 0); (0..cols_out).for_each(|i| { if apply_auto != 0 { @@ -533,39 +480,34 @@ where } match OP { - 1 => module.vec_znx_big_add_small_inplace(&mut res_big, i, lhs, i), - 2 => module.vec_znx_big_sub_small_a_inplace(&mut res_big, i, lhs, i), - 3 => module.vec_znx_big_sub_small_b_inplace(&mut res_big, i, lhs, i), + 1 => module.vec_znx_big_add_small_inplace(&mut res_big, i, &lhs.data, i), + 2 => module.vec_znx_big_sub_small_a_inplace(&mut res_big, i, &lhs.data, i), + 3 => module.vec_znx_big_sub_small_b_inplace(&mut res_big, i, &lhs.data, i), _ => {} } - module.vec_znx_big_normalize(basek, self, i, &res_big, i, scratch1); + module.vec_znx_big_normalize(basek, &mut self.data, i, &res_big, i, scratch1); }); } - pub fn keyswitch_inplace( + pub fn keyswitch_inplace>( &mut self, module: &Module, rhs: &GLWESwitchingKey, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - { + ) { unsafe { let self_ptr: *mut GLWECiphertext = self as *mut GLWECiphertext; self.keyswitch(&module, &*self_ptr, rhs, scratch); } } - pub fn external_product( + pub fn external_product, DataRhs: AsRef<[u8]>>( &mut self, module: &Module, lhs: &GLWECiphertext, rhs: &GGSWCiphertext, scratch: &mut Scratch, - ) where - VecZnx: VecZnxToRef, - MatZnxDft: MatZnxDftToRef, - { + ) { let basek: usize = self.basek(); #[cfg(debug_assertions)] @@ -586,33 +528,31 @@ where { let (mut a_dft, scratch2) = scratch1.tmp_vec_znx_dft(module, cols, lhs.size()); (0..cols).for_each(|col_i| { - module.vec_znx_dft(&mut a_dft, col_i, lhs, col_i); + module.vec_znx_dft(&mut a_dft, col_i, &lhs.data, col_i); }); - module.vmp_apply(&mut res_dft, &a_dft, rhs, scratch2); + module.vmp_apply(&mut res_dft, &a_dft, &rhs.data, scratch2); } let res_big: VecZnxBig<&mut [u8], FFT64> = module.vec_znx_idft_consume(res_dft); (0..cols).for_each(|i| { - module.vec_znx_big_normalize(basek, self, i, &res_big, i, scratch1); + module.vec_znx_big_normalize(basek, &mut self.data, i, &res_big, i, scratch1); }); } - pub fn external_product_inplace( + pub fn external_product_inplace>( &mut self, module: &Module, rhs: &GGSWCiphertext, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - { + ) { unsafe { let self_ptr: *mut GLWECiphertext = self as *mut GLWECiphertext; self.external_product(&module, &*self_ptr, rhs, scratch); } } - pub(crate) fn encrypt_sk_private( + pub(crate) fn encrypt_sk_private, DataSk: AsRef<[u8]>>( &mut self, module: &Module, pt: Option<(&GLWEPlaintext, usize)>, @@ -621,10 +561,7 @@ where source_xe: &mut Source, sigma: f64, scratch: &mut Scratch, - ) where - VecZnx: VecZnxToRef, - ScalarZnxDft: ScalarZnxDftToRef, - { + ) { #[cfg(debug_assertions)] { assert_eq!(self.rank(), sk_dft.rank()); @@ -660,21 +597,21 @@ where self.data.fill_uniform(basek, i, size, source_xa); // c[i] = norm(IDFT(DFT(c[i]) * DFT(s[i]))) - module.vec_znx_dft(&mut ci_dft, 0, self, i); - module.svp_apply_inplace(&mut ci_dft, 0, sk_dft, i - 1); + module.vec_znx_dft(&mut ci_dft, 0, &self.data, i); + module.svp_apply_inplace(&mut ci_dft, 0, &sk_dft.data, i - 1); let ci_big: VecZnxBig<&mut [u8], FFT64> = module.vec_znx_idft_consume(ci_dft); // use c[0] as buffer, which is overwritten later by the normalization step - module.vec_znx_big_normalize(basek, self, 0, &ci_big, 0, scratch_2); + module.vec_znx_big_normalize(basek, &mut self.data, 0, &ci_big, 0, scratch_2); // c0_tmp = -c[i] * s[i] (use c[0] as buffer) - module.vec_znx_sub_ab_inplace(&mut c0_big, 0, self, 0); + module.vec_znx_sub_ab_inplace(&mut c0_big, 0, &self.data, 0); // c[i] += m if col = i if let Some((pt, col)) = pt { if i == col { - module.vec_znx_add_inplace(self, i, pt, 0); - module.vec_znx_normalize_inplace(basek, self, i, scratch_2); + module.vec_znx_add_inplace(&mut self.data, i, &pt.data, 0); + module.vec_znx_normalize_inplace(basek, &mut self.data, i, scratch_2); } } }); @@ -686,15 +623,15 @@ where // c[0] += m if col = 0 if let Some((pt, col)) = pt { if col == 0 { - module.vec_znx_add_inplace(&mut c0_big, 0, pt, 0); + module.vec_znx_add_inplace(&mut c0_big, 0, &pt.data, 0); } } // c[0] = norm(c[0]) - module.vec_znx_normalize(basek, self, 0, &c0_big, 0, scratch_1); + module.vec_znx_normalize(basek, &mut self.data, 0, &c0_big, 0, scratch_1); } - pub(crate) fn encrypt_pk_private( + pub(crate) fn encrypt_pk_private, DataPk: AsRef<[u8]>>( &mut self, module: &Module, pt: Option<(&GLWEPlaintext, usize)>, @@ -703,10 +640,7 @@ where source_xe: &mut Source, sigma: f64, scratch: &mut Scratch, - ) where - VecZnx: VecZnxToRef, - VecZnxDft: VecZnxDftToRef, - { + ) { #[cfg(debug_assertions)] { assert_eq!(self.basek(), pk.basek()); @@ -745,7 +679,7 @@ where (0..cols).for_each(|i| { let (mut ci_dft, scratch_2) = scratch_1.tmp_vec_znx_dft(module, 1, size_pk); // ci_dft = DFT(u) * DFT(pk[i]) - module.svp_apply(&mut ci_dft, 0, &u_dft, 0, pk, i); + module.svp_apply(&mut ci_dft, 0, &u_dft, 0, &pk.data.data, i); // ci_big = u * p[i] let mut ci_big = module.vec_znx_idft_consume(ci_dft); @@ -756,20 +690,17 @@ where // ci_big = u * pk[i] + e + m (if col = i) if let Some((pt, col)) = pt { if col == i { - module.vec_znx_big_add_small_inplace(&mut ci_big, 0, pt, 0); + module.vec_znx_big_add_small_inplace(&mut ci_big, 0, &pt.data, 0); } } // ct[i] = norm(ci_big) - module.vec_znx_big_normalize(basek, self, i, &ci_big, 0, scratch_2); + module.vec_znx_big_normalize(basek, &mut self.data, i, &ci_big, 0, scratch_2); }); } } -impl GLWECiphertext -where - VecZnx: VecZnxToRef, -{ +impl> GLWECiphertext { pub fn clone(&self) -> GLWECiphertext> { GLWECiphertext { data: self.data.clone(), @@ -778,16 +709,13 @@ where } } - pub fn decrypt( + pub fn decrypt + AsRef<[u8]>, DataSk: AsRef<[u8]>>( &self, module: &Module, pt: &mut GLWEPlaintext, sk_dft: &SecretKeyFourier, scratch: &mut Scratch, - ) where - VecZnx: VecZnxToMut, - ScalarZnxDft: ScalarZnxDftToRef, - { + ) { #[cfg(debug_assertions)] { assert_eq!(self.rank(), sk_dft.rank()); @@ -805,8 +733,8 @@ where (1..cols).for_each(|i| { // ci_dft = DFT(a[i]) * DFT(s[i]) let (mut ci_dft, _) = scratch_1.tmp_vec_znx_dft(module, 1, self.size()); // TODO optimize size when pt << ct - module.vec_znx_dft(&mut ci_dft, 0, self, i); - module.svp_apply_inplace(&mut ci_dft, 0, sk_dft, i - 1); + module.vec_znx_dft(&mut ci_dft, 0, &self.data, i); + module.svp_apply_inplace(&mut ci_dft, 0, &sk_dft.data, i - 1); let ci_big = module.vec_znx_idft_consume(ci_dft); // c0_big += a[i] * s[i] @@ -815,12 +743,47 @@ where } // c0_big = (a * s) + (-a * s + m + e) = BIG(m + e) - module.vec_znx_big_add_small_inplace(&mut c0_big, 0, self, 0); + module.vec_znx_big_add_small_inplace(&mut c0_big, 0, &self.data, 0); // pt = norm(BIG(m + e)) - module.vec_znx_big_normalize(self.basek(), pt, 0, &mut c0_big, 0, scratch_1); + module.vec_znx_big_normalize(self.basek(), &mut pt.data, 0, &mut c0_big, 0, scratch_1); pt.basek = self.basek(); pt.k = pt.k().min(self.k()); } } + +pub trait GLWECiphertextToRef { + fn to_ref(&self) -> GLWECiphertext<&[u8]>; +} + +impl> GLWECiphertextToRef for GLWECiphertext { + fn to_ref(&self) -> GLWECiphertext<&[u8]> { + GLWECiphertext { + data: self.data.to_ref(), + basek: self.basek, + k: self.k, + } + } +} + +pub trait GLWECiphertextToMut { + fn to_mut(&mut self) -> GLWECiphertext<&mut [u8]>; +} + +impl + AsRef<[u8]>> GLWECiphertextToMut for GLWECiphertext { + fn to_mut(&mut self) -> GLWECiphertext<&mut [u8]> { + GLWECiphertext { + data: self.data.to_mut(), + basek: self.basek, + k: self.k, + } + } +} + +impl GLWEOps for GLWECiphertext +where + D: AsRef<[u8]> + AsMut<[u8]>, + GLWECiphertext: GLWECiphertextToMut + Infos + SetMetaData, +{ +} diff --git a/core/src/glwe_ciphertext_fourier.rs b/core/src/glwe_ciphertext_fourier.rs index 921fd55..811eab1 100644 --- a/core/src/glwe_ciphertext_fourier.rs +++ b/core/src/glwe_ciphertext_fourier.rs @@ -1,7 +1,6 @@ use backend::{ - Backend, FFT64, MatZnxDft, MatZnxDftOps, MatZnxDftScratch, MatZnxDftToRef, Module, ScalarZnxDft, ScalarZnxDftOps, - ScalarZnxDftToRef, Scratch, VecZnx, VecZnxAlloc, VecZnxBig, VecZnxBigAlloc, VecZnxBigOps, VecZnxBigScratch, VecZnxDft, - VecZnxDftAlloc, VecZnxDftOps, VecZnxDftToMut, VecZnxDftToRef, VecZnxToMut, ZnxZero, + Backend, FFT64, MatZnxDftOps, MatZnxDftScratch, Module, ScalarZnxDftOps, Scratch, VecZnxAlloc, VecZnxBig, VecZnxBigAlloc, + VecZnxBigOps, VecZnxBigScratch, VecZnxDft, VecZnxDftAlloc, VecZnxDftOps, ZnxZero, }; use sampling::source::Source; @@ -48,24 +47,6 @@ impl GLWECiphertextFourier { } } -impl VecZnxDftToMut for GLWECiphertextFourier -where - VecZnxDft: VecZnxDftToMut, -{ - fn to_mut(&mut self) -> VecZnxDft<&mut [u8], B> { - self.data.to_mut() - } -} - -impl VecZnxDftToRef for GLWECiphertextFourier -where - VecZnxDft: VecZnxDftToRef, -{ - fn to_ref(&self) -> VecZnxDft<&[u8], B> { - self.data.to_ref() - } -} - impl GLWECiphertextFourier, FFT64> { #[allow(dead_code)] pub(crate) fn idft_scratch_space(module: &Module, size: usize) -> usize { @@ -124,11 +105,8 @@ impl GLWECiphertextFourier, FFT64> { } } -impl GLWECiphertextFourier -where - VecZnxDft: VecZnxDftToMut, -{ - pub fn encrypt_zero_sk( +impl + AsRef<[u8]>> GLWECiphertextFourier { + pub fn encrypt_zero_sk>( &mut self, module: &Module, sk_dft: &SecretKeyFourier, @@ -136,9 +114,7 @@ where source_xe: &mut Source, sigma: f64, scratch: &mut Scratch, - ) where - ScalarZnxDft: ScalarZnxDftToRef, - { + ) { let (vec_znx_tmp, scratch_1) = scratch.tmp_vec_znx(module, self.rank() + 1, self.size()); let mut ct_idft = GLWECiphertext { data: vec_znx_tmp, @@ -150,16 +126,13 @@ where ct_idft.dft(module, self); } - pub fn keyswitch( + pub fn keyswitch, DataRhs: AsRef<[u8]>>( &mut self, module: &Module, lhs: &GLWECiphertextFourier, rhs: &GLWESwitchingKey, scratch: &mut Scratch, - ) where - VecZnxDft: VecZnxDftToRef, - MatZnxDft: MatZnxDftToRef, - { + ) { let cols_out: usize = rhs.rank_out() + 1; // Space fr normalized VMP result outside of DFT domain @@ -174,34 +147,29 @@ where res_idft.keyswitch_from_fourier(module, lhs, rhs, scratch1); (0..cols_out).for_each(|i| { - module.vec_znx_dft(self, i, &res_idft, i); + module.vec_znx_dft(&mut self.data, i, &res_idft.data, i); }); } - pub fn keyswitch_inplace( + pub fn keyswitch_inplace>( &mut self, module: &Module, rhs: &GLWESwitchingKey, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - { + ) { unsafe { let self_ptr: *mut GLWECiphertextFourier = self as *mut GLWECiphertextFourier; self.keyswitch(&module, &*self_ptr, rhs, scratch); } } - pub fn external_product( + pub fn external_product, DataRhs: AsRef<[u8]>>( &mut self, module: &Module, lhs: &GLWECiphertextFourier, rhs: &GGSWCiphertext, scratch: &mut Scratch, - ) where - VecZnxDft: VecZnxDftToRef, - MatZnxDft: MatZnxDftToRef, - { + ) { let basek: usize = self.basek(); #[cfg(debug_assertions)] @@ -221,7 +189,7 @@ where let (mut res_dft, scratch1) = scratch.tmp_vec_znx_dft(module, cols, rhs.size()); { - module.vmp_apply(&mut res_dft, lhs, rhs, scratch1); + module.vmp_apply(&mut res_dft, &lhs.data, &rhs.data, scratch1); } // VMP result in high precision @@ -231,18 +199,16 @@ where let (mut res_small, scratch2) = scratch1.tmp_vec_znx(module, cols, rhs.size()); (0..cols).for_each(|i| { module.vec_znx_big_normalize(basek, &mut res_small, i, &res_big, i, scratch2); - module.vec_znx_dft(self, i, &res_small, i); + module.vec_znx_dft(&mut self.data, i, &res_small, i); }); } - pub fn external_product_inplace( + pub fn external_product_inplace>( &mut self, module: &Module, rhs: &GGSWCiphertext, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - { + ) { unsafe { let self_ptr: *mut GLWECiphertextFourier = self as *mut GLWECiphertextFourier; self.external_product(&module, &*self_ptr, rhs, scratch); @@ -250,20 +216,14 @@ where } } -impl GLWECiphertextFourier -where - VecZnxDft: VecZnxDftToRef, -{ - pub fn decrypt( +impl> GLWECiphertextFourier { + pub fn decrypt + AsMut<[u8]>, DataSk: AsRef<[u8]>>( &self, module: &Module, pt: &mut GLWEPlaintext, sk_dft: &SecretKeyFourier, scratch: &mut Scratch, - ) where - VecZnx: VecZnxToMut, - ScalarZnxDft: ScalarZnxDftToRef, - { + ) { #[cfg(debug_assertions)] { assert_eq!(self.rank(), sk_dft.rank()); @@ -280,7 +240,7 @@ where { (1..cols).for_each(|i| { let (mut ci_dft, _) = scratch_1.tmp_vec_znx_dft(module, 1, self.size()); // TODO optimize size when pt << ct - module.svp_apply(&mut ci_dft, 0, sk_dft, i - 1, self, i); + module.svp_apply(&mut ci_dft, 0, &sk_dft.data, i - 1, &self.data, i); let ci_big: VecZnxBig<&mut [u8], FFT64> = module.vec_znx_idft_consume(ci_dft); module.vec_znx_big_add_inplace(&mut pt_big, 0, &ci_big, 0); }); @@ -289,22 +249,24 @@ where { let (mut c0_big, scratch_2) = scratch_1.tmp_vec_znx_big(module, 1, self.size()); // c0_big = (a * s) + (-a * s + m + e) = BIG(m + e) - module.vec_znx_idft(&mut c0_big, 0, self, 0, scratch_2); + module.vec_znx_idft(&mut c0_big, 0, &self.data, 0, scratch_2); module.vec_znx_big_add_inplace(&mut pt_big, 0, &c0_big, 0); } // pt = norm(BIG(m + e)) - module.vec_znx_big_normalize(self.basek(), pt, 0, &mut pt_big, 0, scratch_1); + module.vec_znx_big_normalize(self.basek(), &mut pt.data, 0, &mut pt_big, 0, scratch_1); pt.basek = self.basek(); pt.k = pt.k().min(self.k()); } #[allow(dead_code)] - pub(crate) fn idft(&self, module: &Module, res: &mut GLWECiphertext, scratch: &mut Scratch) - where - GLWECiphertext: VecZnxToMut, - { + pub(crate) fn idft + AsMut<[u8]>>( + &self, + module: &Module, + res: &mut GLWECiphertext, + scratch: &mut Scratch, + ) { #[cfg(debug_assertions)] { assert_eq!(self.rank(), res.rank()); @@ -316,8 +278,8 @@ where let (mut res_big, scratch1) = scratch.tmp_vec_znx_big(module, 1, min_size); (0..self.rank() + 1).for_each(|i| { - module.vec_znx_idft(&mut res_big, 0, self, i, scratch1); - module.vec_znx_big_normalize(self.basek(), res, i, &res_big, 0, scratch1); + module.vec_znx_idft(&mut res_big, 0, &self.data, i, scratch1); + module.vec_znx_big_normalize(self.basek(), &mut res.data, i, &res_big, 0, scratch1); }); } } diff --git a/core/src/glwe_ops.rs b/core/src/glwe_ops.rs index 834e357..d3c5648 100644 --- a/core/src/glwe_ops.rs +++ b/core/src/glwe_ops.rs @@ -1,19 +1,15 @@ -use backend::{FFT64, Module, Scratch, VecZnx, VecZnxOps, VecZnxToMut, VecZnxToRef, ZnxZero}; +use backend::{FFT64, Module, Scratch, VecZnx, VecZnxOps, ZnxZero}; use crate::{ elem::{Infos, SetMetaData}, - glwe_ciphertext::GLWECiphertext, + glwe_ciphertext::{GLWECiphertext, GLWECiphertextToMut, GLWECiphertextToRef}, }; -impl GLWECiphertext -where - Self: Infos, - VecZnx: VecZnxToMut, -{ - pub fn add(&mut self, module: &Module, a: &A, b: &B) +pub trait GLWEOps: GLWECiphertextToMut + Infos + SetMetaData { + fn add(&mut self, module: &Module, a: &A, b: &B) where - A: VecZnxToRef + Infos, - B: VecZnxToRef + Infos, + A: GLWECiphertextToRef + Infos, + B: GLWECiphertextToRef + Infos, { #[cfg(debug_assertions)] { @@ -28,25 +24,28 @@ where let max_col: usize = a.rank().max(b.rank() + 1); let self_col: usize = self.rank() + 1; + let self_mut: &mut GLWECiphertext<&mut [u8]> = &mut self.to_mut(); + let a_ref: &GLWECiphertext<&[u8]> = &a.to_ref(); + let b_ref: &GLWECiphertext<&[u8]> = &b.to_ref(); + (0..min_col).for_each(|i| { - module.vec_znx_add(self, i, a, i, b, i); + module.vec_znx_add(&mut self_mut.data, i, &a_ref.data, i, &b_ref.data, i); }); if a.rank() > b.rank() { (min_col..max_col).for_each(|i| { - module.vec_znx_copy(self, i, a, i); + module.vec_znx_copy(&mut self_mut.data, i, &a_ref.data, i); }); } else { (min_col..max_col).for_each(|i| { - module.vec_znx_copy(self, i, b, i); + module.vec_znx_copy(&mut self_mut.data, i, &b_ref.data, i); }); } - let size: usize = self.size(); - let mut self_mut: VecZnx<&mut [u8]> = self.to_mut(); + let size: usize = self_mut.size(); (max_col..self_col).for_each(|i| { (0..size).for_each(|j| { - self_mut.zero_at(i, j); + self_mut.data.zero_at(i, j); }); }); @@ -54,9 +53,9 @@ where self.set_k(a.k().max(b.k())); } - pub fn add_inplace(&mut self, module: &Module, a: &A) + fn add_inplace(&mut self, module: &Module, a: &A) where - A: VecZnxToRef + Infos, + A: GLWECiphertextToRef + Infos, { #[cfg(debug_assertions)] { @@ -66,17 +65,20 @@ where assert!(self.rank() >= a.rank()) } + let self_mut: &mut GLWECiphertext<&mut [u8]> = &mut self.to_mut(); + let a_ref: &GLWECiphertext<&[u8]> = &a.to_ref(); + (0..a.rank() + 1).for_each(|i| { - module.vec_znx_add_inplace(self, i, a, i); + module.vec_znx_add_inplace(&mut self_mut.data, i, &a_ref.data, i); }); self.set_k(a.k().max(self.k())); } - pub fn sub(&mut self, module: &Module, a: &A, b: &B) + fn sub(&mut self, module: &Module, a: &A, b: &B) where - A: VecZnxToRef + Infos, - B: VecZnxToRef + Infos, + A: GLWECiphertextToRef + Infos, + B: GLWECiphertextToRef + Infos, { #[cfg(debug_assertions)] { @@ -91,26 +93,29 @@ where let max_col: usize = a.rank().max(b.rank() + 1); let self_col: usize = self.rank() + 1; + let self_mut: &mut GLWECiphertext<&mut [u8]> = &mut self.to_mut(); + let a_ref: &GLWECiphertext<&[u8]> = &a.to_ref(); + let b_ref: &GLWECiphertext<&[u8]> = &b.to_ref(); + (0..min_col).for_each(|i| { - module.vec_znx_sub(self, i, a, i, b, i); + module.vec_znx_sub(&mut self_mut.data, i, &a_ref.data, i, &b_ref.data, i); }); if a.rank() > b.rank() { (min_col..max_col).for_each(|i| { - module.vec_znx_copy(self, i, a, i); + module.vec_znx_copy(&mut self_mut.data, i, &a_ref.data, i); }); } else { (min_col..max_col).for_each(|i| { - module.vec_znx_copy(self, i, b, i); - module.vec_znx_negate_inplace(self, i); + module.vec_znx_copy(&mut self_mut.data, i, &b_ref.data, i); + module.vec_znx_negate_inplace(&mut self_mut.data, i); }); } - let size: usize = self.size(); - let mut self_mut: VecZnx<&mut [u8]> = self.to_mut(); + let size: usize = self_mut.size(); (max_col..self_col).for_each(|i| { (0..size).for_each(|j| { - self_mut.zero_at(i, j); + self_mut.data.zero_at(i, j); }); }); @@ -118,9 +123,9 @@ where self.set_k(a.k().max(b.k())); } - pub fn sub_inplace_ab(&mut self, module: &Module, a: &A) + fn sub_inplace_ab(&mut self, module: &Module, a: &A) where - A: VecZnxToRef + Infos, + A: GLWECiphertextToRef + Infos, { #[cfg(debug_assertions)] { @@ -130,16 +135,19 @@ where assert!(self.rank() >= a.rank()) } + let self_mut: &mut GLWECiphertext<&mut [u8]> = &mut self.to_mut(); + let a_ref: &GLWECiphertext<&[u8]> = &a.to_ref(); + (0..a.rank() + 1).for_each(|i| { - module.vec_znx_sub_ab_inplace(self, i, a, i); + module.vec_znx_sub_ab_inplace(&mut self_mut.data, i, &a_ref.data, i); }); self.set_k(a.k().max(self.k())); } - pub fn sub_inplace_ba(&mut self, module: &Module, a: &A) + fn sub_inplace_ba(&mut self, module: &Module, a: &A) where - A: VecZnxToRef + Infos, + A: GLWECiphertextToRef + Infos, { #[cfg(debug_assertions)] { @@ -149,16 +157,19 @@ where assert!(self.rank() >= a.rank()) } + let self_mut: &mut GLWECiphertext<&mut [u8]> = &mut self.to_mut(); + let a_ref: &GLWECiphertext<&[u8]> = &a.to_ref(); + (0..a.rank() + 1).for_each(|i| { - module.vec_znx_sub_ba_inplace(self, i, a, i); + module.vec_znx_sub_ba_inplace(&mut self_mut.data, i, &a_ref.data, i); }); self.set_k(a.k().max(self.k())); } - pub fn rotate(&mut self, module: &Module, k: i64, a: &A) + fn rotate(&mut self, module: &Module, k: i64, a: &A) where - A: VecZnxToRef + Infos, + A: GLWECiphertextToRef + Infos, { #[cfg(debug_assertions)] { @@ -167,28 +178,33 @@ where assert_eq!(self.rank(), a.rank()) } + let self_mut: &mut GLWECiphertext<&mut [u8]> = &mut self.to_mut(); + let a_ref: &GLWECiphertext<&[u8]> = &a.to_ref(); + (0..a.rank() + 1).for_each(|i| { - module.vec_znx_rotate(k, self, i, a, i); + module.vec_znx_rotate(k, &mut self_mut.data, i, &a_ref.data, i); }); self.set_basek(a.basek()); self.set_k(a.k()); } - pub fn rotate_inplace(&mut self, module: &Module, k: i64) { + fn rotate_inplace(&mut self, module: &Module, k: i64) { #[cfg(debug_assertions)] { assert_eq!(self.n(), module.n()); } - (0..self.rank() + 1).for_each(|i| { - module.vec_znx_rotate_inplace(k, self, i); + let self_mut: &mut GLWECiphertext<&mut [u8]> = &mut self.to_mut(); + + (0..self_mut.rank() + 1).for_each(|i| { + module.vec_znx_rotate_inplace(k, &mut self_mut.data, i); }); } - pub fn copy(&mut self, module: &Module, a: &A) + fn copy(&mut self, module: &Module, a: &A) where - A: VecZnxToRef + Infos, + A: GLWECiphertextToRef + Infos, { #[cfg(debug_assertions)] { @@ -197,23 +213,26 @@ where assert_eq!(self.rank(), a.rank()); } - (0..self.rank() + 1).for_each(|i| { - module.vec_znx_copy(self, i, a, i); + let self_mut: &mut GLWECiphertext<&mut [u8]> = &mut self.to_mut(); + let a_ref: &GLWECiphertext<&[u8]> = &a.to_ref(); + + (0..self_mut.rank() + 1).for_each(|i| { + module.vec_znx_copy(&mut self_mut.data, i, &a_ref.data, i); }); self.set_k(a.k()); self.set_basek(a.basek()); } - pub fn rsh(&mut self, k: usize, scratch: &mut Scratch) { + fn rsh(&mut self, k: usize, scratch: &mut Scratch) { let basek: usize = self.basek(); - let mut self_mut: VecZnx<&mut [u8]> = self.to_mut(); - self_mut.rsh(basek, k, scratch); + let mut self_mut: GLWECiphertext<&mut [u8]> = self.to_mut(); + self_mut.data.rsh(basek, k, scratch); } - pub fn normalize(&mut self, module: &Module, a: &A, scratch: &mut Scratch) + fn normalize(&mut self, module: &Module, a: &A, scratch: &mut Scratch) where - A: VecZnxToMut + Infos, + A: GLWECiphertextToRef + Infos, { #[cfg(debug_assertions)] { @@ -222,20 +241,24 @@ where assert_eq!(self.rank(), a.rank()); } - (0..self.rank() + 1).for_each(|i| { - module.vec_znx_normalize(a.basek(), self, i, a, i, scratch); + let self_mut: &mut GLWECiphertext<&mut [u8]> = &mut self.to_mut(); + let a_ref: &GLWECiphertext<&[u8]> = &a.to_ref(); + + (0..self_mut.rank() + 1).for_each(|i| { + module.vec_znx_normalize(a.basek(), &mut self_mut.data, i, &a_ref.data, i, scratch); }); self.set_basek(a.basek()); self.set_k(a.k()); } - pub fn normalize_inplace(&mut self, module: &Module, scratch: &mut Scratch) { + fn normalize_inplace(&mut self, module: &Module, scratch: &mut Scratch) { #[cfg(debug_assertions)] { assert_eq!(self.n(), module.n()); } - (0..self.rank() + 1).for_each(|i| { - module.vec_znx_normalize_inplace(self.basek(), self, i, scratch); + let self_mut: &mut GLWECiphertext<&mut [u8]> = &mut self.to_mut(); + (0..self_mut.rank() + 1).for_each(|i| { + module.vec_znx_normalize_inplace(self_mut.basek(), &mut self_mut.data, i, scratch); }); } } diff --git a/core/src/glwe_plaintext.rs b/core/src/glwe_plaintext.rs index ed4826d..dd4aa2e 100644 --- a/core/src/glwe_plaintext.rs +++ b/core/src/glwe_plaintext.rs @@ -1,4 +1,4 @@ -use backend::{Backend, Module, VecZnx, VecZnxAlloc, VecZnxToMut, VecZnxToRef}; +use backend::{Backend, Module, VecZnx, VecZnxAlloc}; use crate::{elem::Infos, utils::derive_size}; @@ -24,24 +24,6 @@ impl Infos for GLWEPlaintext { } } -impl VecZnxToMut for GLWEPlaintext -where - VecZnx: VecZnxToMut, -{ - fn to_mut(&mut self) -> VecZnx<&mut [u8]> { - self.data.to_mut() - } -} - -impl VecZnxToRef for GLWEPlaintext -where - VecZnx: VecZnxToRef, -{ - fn to_ref(&self) -> VecZnx<&[u8]> { - self.data.to_ref() - } -} - impl GLWEPlaintext> { pub fn alloc(module: &Module, basek: usize, k: usize) -> Self { Self { diff --git a/core/src/keys.rs b/core/src/keys.rs index e8af9b1..a6eb46c 100644 --- a/core/src/keys.rs +++ b/core/src/keys.rs @@ -1,7 +1,6 @@ use backend::{ - Backend, FFT64, Module, ScalarZnx, ScalarZnxAlloc, ScalarZnxDft, ScalarZnxDftAlloc, ScalarZnxDftOps, ScalarZnxDftToMut, - ScalarZnxDftToRef, ScalarZnxToMut, ScalarZnxToRef, ScratchOwned, VecZnxDft, VecZnxDftToMut, VecZnxDftToRef, ZnxInfos, - ZnxZero, + Backend, FFT64, Module, ScalarZnx, ScalarZnxAlloc, ScalarZnxDft, ScalarZnxDftAlloc, ScalarZnxDftOps, ScratchOwned, VecZnxDft, + ZnxInfos, ZnxZero, }; use sampling::source::Source; @@ -43,10 +42,7 @@ impl SecretKey { } } -impl SecretKey -where - S: AsMut<[u8]> + AsRef<[u8]>, -{ +impl + AsRef<[u8]>> SecretKey { pub fn fill_ternary_prob(&mut self, prob: f64, source: &mut Source) { (0..self.rank()).for_each(|i| { self.data.fill_ternary_prob(i, prob, source); @@ -67,24 +63,6 @@ where } } -impl ScalarZnxToMut for SecretKey -where - ScalarZnx: ScalarZnxToMut, -{ - fn to_mut(&mut self) -> ScalarZnx<&mut [u8]> { - self.data.to_mut() - } -} - -impl ScalarZnxToRef for SecretKey -where - ScalarZnx: ScalarZnxToRef, -{ - fn to_ref(&self) -> ScalarZnx<&[u8]> { - self.data.to_ref() - } -} - pub struct SecretKeyFourier { pub data: ScalarZnxDft, pub dist: SecretDistribution, @@ -111,12 +89,10 @@ impl SecretKeyFourier, B> { dist: SecretDistribution::NONE, } } +} - pub fn dft(&mut self, module: &Module, sk: &SecretKey) - where - SecretKeyFourier, B>: ScalarZnxDftToMut, - SecretKey: ScalarZnxToRef, - { +impl + AsMut<[u8]>> SecretKeyFourier { + pub fn dft>(&mut self, module: &Module, sk: &SecretKey) { #[cfg(debug_assertions)] { match sk.dist { @@ -130,30 +106,12 @@ impl SecretKeyFourier, B> { } (0..self.rank()).for_each(|i| { - module.svp_prepare(self, i, sk, i); + module.svp_prepare(&mut self.data, i, &sk.data, i); }); self.dist = sk.dist; } } -impl ScalarZnxDftToMut for SecretKeyFourier -where - ScalarZnxDft: ScalarZnxDftToMut, -{ - fn to_mut(&mut self) -> ScalarZnxDft<&mut [u8], B> { - self.data.to_mut() - } -} - -impl ScalarZnxDftToRef for SecretKeyFourier -where - ScalarZnxDft: ScalarZnxDftToRef, -{ - fn to_ref(&self) -> ScalarZnxDft<&[u8], B> { - self.data.to_ref() - } -} - pub struct GLWEPublicKey { pub data: GLWECiphertextFourier, pub dist: SecretDistribution, @@ -190,36 +148,15 @@ impl GLWEPublicKey { } } -impl VecZnxDftToMut for GLWEPublicKey -where - VecZnxDft: VecZnxDftToMut, -{ - fn to_mut(&mut self) -> VecZnxDft<&mut [u8], B> { - self.data.to_mut() - } -} - -impl VecZnxDftToRef for GLWEPublicKey -where - VecZnxDft: VecZnxDftToRef, -{ - fn to_ref(&self) -> VecZnxDft<&[u8], B> { - self.data.to_ref() - } -} - -impl GLWEPublicKey { - pub fn generate_from_sk( +impl + AsMut<[u8]>> GLWEPublicKey { + pub fn generate_from_sk>( &mut self, module: &Module, sk_dft: &SecretKeyFourier, source_xa: &mut Source, source_xe: &mut Source, sigma: f64, - ) where - VecZnxDft: VecZnxDftToMut, - ScalarZnxDft: ScalarZnxDftToRef + ZnxInfos, - { + ) { #[cfg(debug_assertions)] { match sk_dft.dist { diff --git a/core/src/keyswitch_key.rs b/core/src/keyswitch_key.rs index 2ee24ed..a68a39e 100644 --- a/core/src/keyswitch_key.rs +++ b/core/src/keyswitch_key.rs @@ -1,7 +1,4 @@ -use backend::{ - Backend, FFT64, MatZnxDft, MatZnxDftOps, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx, ScalarZnxDft, ScalarZnxDftToRef, - ScalarZnxToRef, Scratch, VecZnxDftAlloc, VecZnxDftToMut, VecZnxDftToRef, ZnxZero, -}; +use backend::{Backend, FFT64, MatZnxDft, MatZnxDftOps, Module, Scratch, VecZnxDftAlloc, ZnxZero}; use sampling::source::Source; use crate::{ @@ -52,45 +49,27 @@ impl GLWESwitchingKey { } } -impl MatZnxDftToMut for GLWESwitchingKey -where - MatZnxDft: MatZnxDftToMut, -{ - fn to_mut(&mut self) -> MatZnxDft<&mut [u8], B> { - self.0.data.to_mut() +impl> GetRow for GLWESwitchingKey { + fn get_row + AsRef<[u8]>>( + &self, + module: &Module, + row_i: usize, + col_j: usize, + res: &mut GLWECiphertextFourier, + ) { + module.vmp_extract_row(&mut res.data, &self.0.data, row_i, col_j); } } -impl MatZnxDftToRef for GLWESwitchingKey -where - MatZnxDft: MatZnxDftToRef, -{ - fn to_ref(&self) -> MatZnxDft<&[u8], B> { - self.0.data.to_ref() - } -} - -impl GetRow for GLWESwitchingKey -where - MatZnxDft: MatZnxDftToRef, -{ - fn get_row(&self, module: &Module, row_i: usize, col_j: usize, res: &mut R) - where - R: VecZnxDftToMut, - { - module.vmp_extract_row(res, self, row_i, col_j); - } -} - -impl SetRow for GLWESwitchingKey -where - MatZnxDft: MatZnxDftToMut, -{ - fn set_row(&mut self, module: &Module, row_i: usize, col_j: usize, a: &R) - where - R: VecZnxDftToRef, - { - module.vmp_prepare_row(self, row_i, col_j, a); +impl + AsRef<[u8]>> SetRow for GLWESwitchingKey { + fn set_row>( + &mut self, + module: &Module, + row_i: usize, + col_j: usize, + a: &GLWECiphertextFourier, + ) { + module.vmp_prepare_row(&mut self.0.data, row_i, col_j, &a.data); } } @@ -147,11 +126,8 @@ impl GLWESwitchingKey, FFT64> { tmp + ggsw } } -impl GLWESwitchingKey -where - MatZnxDft: MatZnxDftToMut, -{ - pub fn encrypt_sk( +impl + AsRef<[u8]>> GLWESwitchingKey { + pub fn generate_from_sk, DataSkOut: AsRef<[u8]>>( &mut self, module: &Module, sk_in: &SecretKey, @@ -160,11 +136,8 @@ where source_xe: &mut Source, sigma: f64, scratch: &mut Scratch, - ) where - ScalarZnx: ScalarZnxToRef, - ScalarZnxDft: ScalarZnxDftToRef, - { - self.0.generate_from_sk( + ) { + self.0.encrypt_sk( module, &sk_in.data, sk_out_dft, @@ -175,16 +148,13 @@ where ); } - pub fn keyswitch( + pub fn keyswitch, DataRhs: AsRef<[u8]>>( &mut self, module: &Module, lhs: &GLWESwitchingKey, rhs: &GLWESwitchingKey, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - MatZnxDft: MatZnxDftToRef, - { + ) { #[cfg(debug_assertions)] { assert_eq!( @@ -243,14 +213,12 @@ where }); } - pub fn keyswitch_inplace( + pub fn keyswitch_inplace>( &mut self, module: &Module, rhs: &GLWESwitchingKey, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - { + ) { #[cfg(debug_assertions)] { assert_eq!( @@ -279,16 +247,13 @@ where }); } - pub fn external_product( + pub fn external_product, DataRhs: AsRef<[u8]>>( &mut self, module: &Module, lhs: &GLWESwitchingKey, rhs: &GGSWCiphertext, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - MatZnxDft: MatZnxDftToRef, - { + ) { #[cfg(debug_assertions)] { assert_eq!( @@ -347,14 +312,12 @@ where }); } - pub fn external_product_inplace( + pub fn external_product_inplace>( &mut self, module: &Module, rhs: &GGSWCiphertext, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - { + ) { #[cfg(debug_assertions)] { assert_eq!( diff --git a/core/src/tensor_key.rs b/core/src/tensor_key.rs index 89ce299..d8cc459 100644 --- a/core/src/tensor_key.rs +++ b/core/src/tensor_key.rs @@ -1,7 +1,4 @@ -use backend::{ - Backend, FFT64, MatZnxDft, MatZnxDftToMut, MatZnxDftToRef, Module, ScalarZnx, ScalarZnxDft, ScalarZnxDftAlloc, - ScalarZnxDftOps, ScalarZnxDftToRef, Scratch, VecZnxDftOps, VecZnxDftToRef, -}; +use backend::{Backend, FFT64, MatZnxDft, Module, ScalarZnx, ScalarZnxDftAlloc, ScalarZnxDftOps, Scratch, VecZnxDftOps}; use sampling::source::Source; use crate::{ @@ -61,11 +58,8 @@ impl TensorKey, FFT64> { } } -impl TensorKey -where - MatZnxDft: MatZnxDftToMut, -{ - pub fn generate_from_sk( +impl + AsRef<[u8]>> TensorKey { + pub fn generate_from_sk>( &mut self, module: &Module, sk_dft: &SecretKeyFourier, @@ -73,9 +67,7 @@ where source_xe: &mut Source, sigma: f64, scratch: &mut Scratch, - ) where - ScalarZnxDft: VecZnxDftToRef + ScalarZnxDftToRef, - { + ) { #[cfg(debug_assertions)] { assert_eq!(self.rank(), sk_dft.rank()); @@ -98,7 +90,7 @@ where dist: sk_dft.dist, }; - self.at_mut(i, j).encrypt_sk( + self.at_mut(i, j).generate_from_sk( module, &sk_ij, sk_dft, source_xa, source_xe, sigma, scratch1, ); }); @@ -115,10 +107,7 @@ where } } -impl TensorKey -where - MatZnxDft: MatZnxDftToRef, -{ +impl> TensorKey { // Returns a reference to GLWESwitchingKey_{s}(s[i] * s[j]) pub fn at(&self, mut i: usize, mut j: usize) -> &GLWESwitchingKey { if i > j { diff --git a/core/src/test_fft64/automorphism_key.rs b/core/src/test_fft64/automorphism_key.rs index d469660..cf4e983 100644 --- a/core/src/test_fft64/automorphism_key.rs +++ b/core/src/test_fft64/automorphism_key.rs @@ -87,7 +87,13 @@ fn test_automorphism(p0: i64, p1: i64, log_n: usize, basek: usize, k_ksk: usize, let mut sk_auto: SecretKey> = SecretKey::alloc(&module, rank); sk_auto.fill_zero(); // Necessary to avoid panic of unfilled sk (0..rank).for_each(|i| { - module.scalar_znx_automorphism(module.galois_element_inv(p0 * p1), &mut sk_auto, i, &sk, i); + module.scalar_znx_automorphism( + module.galois_element_inv(p0 * p1), + &mut sk_auto.data, + i, + &sk.data, + i, + ); }); let mut sk_auto_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); @@ -98,7 +104,7 @@ fn test_automorphism(p0: i64, p1: i64, log_n: usize, basek: usize, k_ksk: usize, auto_key_out.get_row(&module, row_i, col_i, &mut ct_glwe_dft); ct_glwe_dft.decrypt(&module, &mut pt, &sk_auto_dft, scratch.borrow()); - module.vec_znx_sub_scalar_inplace(&mut pt, 0, row_i, &sk, col_i); + module.vec_znx_sub_scalar_inplace(&mut pt.data, 0, row_i, &sk.data, col_i); let noise_have: f64 = pt.data.std(0, basek).log2(); let noise_want: f64 = log2_std_noise_gglwe_product( @@ -178,7 +184,13 @@ fn test_automorphism_inplace(p0: i64, p1: i64, log_n: usize, basek: usize, k_ksk let mut sk_auto: SecretKey> = SecretKey::alloc(&module, rank); sk_auto.fill_zero(); // Necessary to avoid panic of unfilled sk (0..rank).for_each(|i| { - module.scalar_znx_automorphism(module.galois_element_inv(p0 * p1), &mut sk_auto, i, &sk, i); + module.scalar_znx_automorphism( + module.galois_element_inv(p0 * p1), + &mut sk_auto.data, + i, + &sk.data, + i, + ); }); let mut sk_auto_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); @@ -189,7 +201,7 @@ fn test_automorphism_inplace(p0: i64, p1: i64, log_n: usize, basek: usize, k_ksk auto_key.get_row(&module, row_i, col_i, &mut ct_glwe_dft); ct_glwe_dft.decrypt(&module, &mut pt, &sk_auto_dft, scratch.borrow()); - module.vec_znx_sub_scalar_inplace(&mut pt, 0, row_i, &sk, col_i); + module.vec_znx_sub_scalar_inplace(&mut pt.data, 0, row_i, &sk.data, col_i); let noise_have: f64 = pt.data.std(0, basek).log2(); let noise_want: f64 = log2_std_noise_gglwe_product( diff --git a/core/src/test_fft64/gglwe.rs b/core/src/test_fft64/gglwe.rs index 52339f5..06be1b3 100644 --- a/core/src/test_fft64/gglwe.rs +++ b/core/src/test_fft64/gglwe.rs @@ -100,7 +100,7 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ksk: usize, sigma: f64, rank_in let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out); sk_out_dft.dft(&module, &sk_out); - ksk.encrypt_sk( + ksk.generate_from_sk( &module, &sk_in, &sk_out_dft, @@ -117,7 +117,7 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ksk: usize, sigma: f64, rank_in (0..ksk.rows()).for_each(|row_i| { ksk.get_row(&module, row_i, col_i, &mut ct_glwe_fourier); ct_glwe_fourier.decrypt(&module, &mut pt, &sk_out_dft, scratch.borrow()); - module.vec_znx_sub_scalar_inplace(&mut pt, 0, row_i, &sk_in, col_i); + module.vec_znx_sub_scalar_inplace(&mut pt.data, 0, row_i, &sk_in.data, col_i); let std_pt: f64 = pt.data.std(0, basek) * (k_ksk as f64).exp2(); assert!((sigma - std_pt).abs() <= 0.2, "{} {}", sigma, std_pt); }); @@ -179,7 +179,7 @@ fn test_key_switch( sk2_dft.dft(&module, &sk2); // gglwe_{s1}(s0) = s0 -> s1 - ct_gglwe_s0s1.encrypt_sk( + ct_gglwe_s0s1.generate_from_sk( &module, &sk0, &sk1_dft, @@ -190,7 +190,7 @@ fn test_key_switch( ); // gglwe_{s2}(s1) -> s1 -> s2 - ct_gglwe_s1s2.encrypt_sk( + ct_gglwe_s1s2.generate_from_sk( &module, &sk1, &sk2_dft, @@ -211,7 +211,7 @@ fn test_key_switch( (0..ct_gglwe_s0s2.rows()).for_each(|row_i| { ct_gglwe_s0s2.get_row(&module, row_i, col_i, &mut ct_glwe_dft); ct_glwe_dft.decrypt(&module, &mut pt, &sk2_dft, scratch.borrow()); - module.vec_znx_sub_scalar_inplace(&mut pt, 0, row_i, &sk0, col_i); + module.vec_znx_sub_scalar_inplace(&mut pt.data, 0, row_i, &sk0.data, col_i); let noise_have: f64 = pt.data.std(0, basek).log2(); let noise_want: f64 = log2_std_noise_gglwe_product( @@ -280,7 +280,7 @@ fn test_key_switch_inplace(log_n: usize, basek: usize, k_ksk: usize, sigma: f64, sk2_dft.dft(&module, &sk2); // gglwe_{s1}(s0) = s0 -> s1 - ct_gglwe_s0s1.encrypt_sk( + ct_gglwe_s0s1.generate_from_sk( &module, &sk0, &sk1_dft, @@ -291,7 +291,7 @@ fn test_key_switch_inplace(log_n: usize, basek: usize, k_ksk: usize, sigma: f64, ); // gglwe_{s2}(s1) -> s1 -> s2 - ct_gglwe_s1s2.encrypt_sk( + ct_gglwe_s1s2.generate_from_sk( &module, &sk1, &sk2_dft, @@ -314,7 +314,7 @@ fn test_key_switch_inplace(log_n: usize, basek: usize, k_ksk: usize, sigma: f64, (0..ct_gglwe_s0s2.rows()).for_each(|row_i| { ct_gglwe_s0s2.get_row(&module, row_i, col_i, &mut ct_glwe_dft); ct_glwe_dft.decrypt(&module, &mut pt, &sk2_dft, scratch.borrow()); - module.vec_znx_sub_scalar_inplace(&mut pt, 0, row_i, &sk0, col_i); + module.vec_znx_sub_scalar_inplace(&mut pt.data, 0, row_i, &sk0.data, col_i); let noise_have: f64 = pt.data.std(0, basek).log2(); let noise_want: f64 = log2_std_noise_gglwe_product( @@ -385,7 +385,7 @@ fn test_external_product(log_n: usize, basek: usize, k: usize, sigma: f64, rank_ sk_out_dft.dft(&module, &sk_out); // gglwe_{s1}(s0) = s0 -> s1 - ct_gglwe_in.encrypt_sk( + ct_gglwe_in.generate_from_sk( &module, &sk_in, &sk_out_dft, @@ -432,7 +432,7 @@ fn test_external_product(log_n: usize, basek: usize, k: usize, sigma: f64, rank_ (0..ct_gglwe_out.rows()).for_each(|row_i| { ct_gglwe_out.get_row(&module, row_i, col_i, &mut ct_glwe_dft); ct_glwe_dft.decrypt(&module, &mut pt, &sk_out_dft, scratch.borrow()); - module.vec_znx_sub_scalar_inplace(&mut pt, 0, row_i, &sk_in, col_i); + module.vec_znx_sub_scalar_inplace(&mut pt.data, 0, row_i, &sk_in.data, col_i); let noise_have: f64 = pt.data.std(0, basek).log2(); @@ -505,7 +505,7 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k: usize, sigma: f6 sk_out_dft.dft(&module, &sk_out); // gglwe_{s1}(s0) = s0 -> s1 - ct_gglwe.encrypt_sk( + ct_gglwe.generate_from_sk( &module, &sk_in, &sk_out_dft, @@ -539,7 +539,7 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k: usize, sigma: f6 (0..ct_gglwe.rows()).for_each(|row_i| { ct_gglwe.get_row(&module, row_i, col_i, &mut ct_glwe_dft); ct_glwe_dft.decrypt(&module, &mut pt, &sk_out_dft, scratch.borrow()); - module.vec_znx_sub_scalar_inplace(&mut pt, 0, row_i, &sk_in, col_i); + module.vec_znx_sub_scalar_inplace(&mut pt.data, 0, row_i, &sk_in.data, col_i); let noise_have: f64 = pt.data.std(0, basek).log2(); diff --git a/core/src/test_fft64/ggsw.rs b/core/src/test_fft64/ggsw.rs index 5a244ba..639b90f 100644 --- a/core/src/test_fft64/ggsw.rs +++ b/core/src/test_fft64/ggsw.rs @@ -116,21 +116,21 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k_ggsw: usize, sigma: f64, rank: (0..ct.rank() + 1).for_each(|col_j| { (0..ct.rows()).for_each(|row_i| { - module.vec_znx_add_scalar_inplace(&mut pt_want, 0, row_i, &pt_scalar, 0); + module.vec_znx_add_scalar_inplace(&mut pt_want.data, 0, row_i, &pt_scalar, 0); // mul with sk[col_j-1] if col_j > 0 { - module.vec_znx_dft(&mut pt_dft, 0, &pt_want, 0); - module.svp_apply_inplace(&mut pt_dft, 0, &sk_dft, col_j - 1); + module.vec_znx_dft(&mut pt_dft, 0, &pt_want.data, 0); + module.svp_apply_inplace(&mut pt_dft, 0, &sk_dft.data, col_j - 1); module.vec_znx_idft_tmp_a(&mut pt_big, 0, &mut pt_dft, 0); - module.vec_znx_big_normalize(basek, &mut pt_want, 0, &pt_big, 0, scratch.borrow()); + module.vec_znx_big_normalize(basek, &mut pt_want.data, 0, &pt_big, 0, scratch.borrow()); } ct.get_row(&module, row_i, col_j, &mut ct_glwe_fourier); ct_glwe_fourier.decrypt(&module, &mut pt_have, &sk_dft, scratch.borrow()); - module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); + module.vec_znx_sub_ab_inplace(&mut pt_have.data, 0, &pt_want.data, 0); let std_pt: f64 = pt_have.data.std(0, basek) * (k_ggsw as f64).exp2(); assert!((sigma - std_pt).abs() <= 0.2, "{} {}", sigma, std_pt); @@ -185,7 +185,7 @@ fn test_keyswitch(log_n: usize, basek: usize, k: usize, rank: usize, sigma: f64) let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_out_dft.dft(&module, &sk_out); - ksk.encrypt_sk( + ksk.generate_from_sk( &module, &sk_in, &sk_out_dft, @@ -223,21 +223,21 @@ fn test_keyswitch(log_n: usize, basek: usize, k: usize, rank: usize, sigma: f64) (0..ct_out.rank() + 1).for_each(|col_j| { (0..ct_out.rows()).for_each(|row_i| { - module.vec_znx_add_scalar_inplace(&mut pt_want, 0, row_i, &pt_scalar, 0); + module.vec_znx_add_scalar_inplace(&mut pt_want.data, 0, row_i, &pt_scalar, 0); // mul with sk[col_j-1] if col_j > 0 { - module.vec_znx_dft(&mut pt_dft, 0, &pt_want, 0); - module.svp_apply_inplace(&mut pt_dft, 0, &sk_out_dft, col_j - 1); + module.vec_znx_dft(&mut pt_dft, 0, &pt_want.data, 0); + module.svp_apply_inplace(&mut pt_dft, 0, &sk_out_dft.data, col_j - 1); module.vec_znx_idft_tmp_a(&mut pt_big, 0, &mut pt_dft, 0); - module.vec_znx_big_normalize(basek, &mut pt_want, 0, &pt_big, 0, scratch.borrow()); + module.vec_znx_big_normalize(basek, &mut pt_want.data, 0, &pt_big, 0, scratch.borrow()); } ct_out.get_row(&module, row_i, col_j, &mut ct_glwe_fourier); ct_glwe_fourier.decrypt(&module, &mut pt_have, &sk_out_dft, scratch.borrow()); - module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); + module.vec_znx_sub_ab_inplace(&mut pt_have.data, 0, &pt_want.data, 0); let noise_have: f64 = pt_have.data.std(0, basek).log2(); let noise_want: f64 = noise_ggsw_keyswitch( @@ -304,7 +304,7 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k: usize, rank: usize, sig let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_out_dft.dft(&module, &sk_out); - ksk.encrypt_sk( + ksk.generate_from_sk( &module, &sk_in, &sk_out_dft, @@ -342,21 +342,21 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k: usize, rank: usize, sig (0..ct.rank() + 1).for_each(|col_j| { (0..ct.rows()).for_each(|row_i| { - module.vec_znx_add_scalar_inplace(&mut pt_want, 0, row_i, &pt_scalar, 0); + module.vec_znx_add_scalar_inplace(&mut pt_want.data, 0, row_i, &pt_scalar, 0); // mul with sk[col_j-1] if col_j > 0 { - module.vec_znx_dft(&mut pt_dft, 0, &pt_want, 0); - module.svp_apply_inplace(&mut pt_dft, 0, &sk_out_dft, col_j - 1); + module.vec_znx_dft(&mut pt_dft, 0, &pt_want.data, 0); + module.svp_apply_inplace(&mut pt_dft, 0, &sk_out_dft.data, col_j - 1); module.vec_znx_idft_tmp_a(&mut pt_big, 0, &mut pt_dft, 0); - module.vec_znx_big_normalize(basek, &mut pt_want, 0, &pt_big, 0, scratch.borrow()); + module.vec_znx_big_normalize(basek, &mut pt_want.data, 0, &pt_big, 0, scratch.borrow()); } ct.get_row(&module, row_i, col_j, &mut ct_glwe_fourier); ct_glwe_fourier.decrypt(&module, &mut pt_have, &sk_out_dft, scratch.borrow()); - module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); + module.vec_znx_sub_ab_inplace(&mut pt_have.data, 0, &pt_want.data, 0); let noise_have: f64 = pt_have.data.std(0, basek).log2(); let noise_want: f64 = noise_ggsw_keyswitch( @@ -514,21 +514,21 @@ fn test_automorphism(p: i64, log_n: usize, basek: usize, k: usize, rank: usize, (0..ct_out.rank() + 1).for_each(|col_j| { (0..ct_out.rows()).for_each(|row_i| { - module.vec_znx_add_scalar_inplace(&mut pt_want, 0, row_i, &pt_scalar, 0); + module.vec_znx_add_scalar_inplace(&mut pt_want.data, 0, row_i, &pt_scalar, 0); // mul with sk[col_j-1] if col_j > 0 { - module.vec_znx_dft(&mut pt_dft, 0, &pt_want, 0); - module.svp_apply_inplace(&mut pt_dft, 0, &sk_dft, col_j - 1); + module.vec_znx_dft(&mut pt_dft, 0, &pt_want.data, 0); + module.svp_apply_inplace(&mut pt_dft, 0, &sk_dft.data, col_j - 1); module.vec_znx_idft_tmp_a(&mut pt_big, 0, &mut pt_dft, 0); - module.vec_znx_big_normalize(basek, &mut pt_want, 0, &pt_big, 0, scratch.borrow()); + module.vec_znx_big_normalize(basek, &mut pt_want.data, 0, &pt_big, 0, scratch.borrow()); } ct_out.get_row(&module, row_i, col_j, &mut ct_glwe_fourier); ct_glwe_fourier.decrypt(&module, &mut pt_have, &sk_dft, scratch.borrow()); - module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); + module.vec_znx_sub_ab_inplace(&mut pt_have.data, 0, &pt_want.data, 0); let noise_have: f64 = pt_have.data.std(0, basek).log2(); let noise_want: f64 = noise_ggsw_keyswitch( @@ -627,21 +627,21 @@ fn test_automorphism_inplace(p: i64, log_n: usize, basek: usize, k: usize, rank: (0..ct.rank() + 1).for_each(|col_j| { (0..ct.rows()).for_each(|row_i| { - module.vec_znx_add_scalar_inplace(&mut pt_want, 0, row_i, &pt_scalar, 0); + module.vec_znx_add_scalar_inplace(&mut pt_want.data, 0, row_i, &pt_scalar, 0); // mul with sk[col_j-1] if col_j > 0 { - module.vec_znx_dft(&mut pt_dft, 0, &pt_want, 0); - module.svp_apply_inplace(&mut pt_dft, 0, &sk_dft, col_j - 1); + module.vec_znx_dft(&mut pt_dft, 0, &pt_want.data, 0); + module.svp_apply_inplace(&mut pt_dft, 0, &sk_dft.data, col_j - 1); module.vec_znx_idft_tmp_a(&mut pt_big, 0, &mut pt_dft, 0); - module.vec_znx_big_normalize(basek, &mut pt_want, 0, &pt_big, 0, scratch.borrow()); + module.vec_znx_big_normalize(basek, &mut pt_want.data, 0, &pt_big, 0, scratch.borrow()); } ct.get_row(&module, row_i, col_j, &mut ct_glwe_fourier); ct_glwe_fourier.decrypt(&module, &mut pt_have, &sk_dft, scratch.borrow()); - module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); + module.vec_znx_sub_ab_inplace(&mut pt_have.data, 0, &pt_want.data, 0); let noise_have: f64 = pt_have.data.std(0, basek).log2(); let noise_want: f64 = noise_ggsw_keyswitch( @@ -740,19 +740,19 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, rank: usize, (0..ct_ggsw_lhs_out.rank() + 1).for_each(|col_j| { (0..ct_ggsw_lhs_out.rows()).for_each(|row_i| { - module.vec_znx_add_scalar_inplace(&mut pt_want, 0, row_i, &pt_ggsw_lhs, 0); + module.vec_znx_add_scalar_inplace(&mut pt_want.data, 0, row_i, &pt_ggsw_lhs, 0); if col_j > 0 { - module.vec_znx_dft(&mut pt_dft, 0, &pt_want, 0); - module.svp_apply_inplace(&mut pt_dft, 0, &sk_dft, col_j - 1); + module.vec_znx_dft(&mut pt_dft, 0, &pt_want.data, 0); + module.svp_apply_inplace(&mut pt_dft, 0, &sk_dft.data, col_j - 1); module.vec_znx_idft_tmp_a(&mut pt_big, 0, &mut pt_dft, 0); - module.vec_znx_big_normalize(basek, &mut pt_want, 0, &pt_big, 0, scratch.borrow()); + module.vec_znx_big_normalize(basek, &mut pt_want.data, 0, &pt_big, 0, scratch.borrow()); } ct_ggsw_lhs_out.get_row(&module, row_i, col_j, &mut ct_glwe_fourier); ct_glwe_fourier.decrypt(&module, &mut pt, &sk_dft, scratch.borrow()); - module.vec_znx_sub_ab_inplace(&mut pt, 0, &pt_want, 0); + module.vec_znx_sub_ab_inplace(&mut pt.data, 0, &pt_want.data, 0); let noise_have: f64 = pt.data.std(0, basek).log2(); @@ -853,19 +853,19 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, rank (0..ct_ggsw_lhs.rank() + 1).for_each(|col_j| { (0..ct_ggsw_lhs.rows()).for_each(|row_i| { - module.vec_znx_add_scalar_inplace(&mut pt_want, 0, row_i, &pt_ggsw_lhs, 0); + module.vec_znx_add_scalar_inplace(&mut pt_want.data, 0, row_i, &pt_ggsw_lhs, 0); if col_j > 0 { - module.vec_znx_dft(&mut pt_dft, 0, &pt_want, 0); - module.svp_apply_inplace(&mut pt_dft, 0, &sk_dft, col_j - 1); + module.vec_znx_dft(&mut pt_dft, 0, &pt_want.data, 0); + module.svp_apply_inplace(&mut pt_dft, 0, &sk_dft.data, col_j - 1); module.vec_znx_idft_tmp_a(&mut pt_big, 0, &mut pt_dft, 0); - module.vec_znx_big_normalize(basek, &mut pt_want, 0, &pt_big, 0, scratch.borrow()); + module.vec_znx_big_normalize(basek, &mut pt_want.data, 0, &pt_big, 0, scratch.borrow()); } ct_ggsw_lhs.get_row(&module, row_i, col_j, &mut ct_glwe_fourier); ct_glwe_fourier.decrypt(&module, &mut pt, &sk_dft, scratch.borrow()); - module.vec_znx_sub_ab_inplace(&mut pt, 0, &pt_want, 0); + module.vec_znx_sub_ab_inplace(&mut pt.data, 0, &pt_want.data, 0); let noise_have: f64 = pt.data.std(0, basek).log2(); diff --git a/core/src/test_fft64/glwe.rs b/core/src/test_fft64/glwe.rs index 91bb300..753783e 100644 --- a/core/src/test_fft64/glwe.rs +++ b/core/src/test_fft64/glwe.rs @@ -1,6 +1,6 @@ use backend::{ - Decoding, Encoding, FFT64, FillUniform, Module, ScalarZnx, ScalarZnxAlloc, ScratchOwned, Stats, VecZnxOps, VecZnxToMut, - ZnxViewMut, ZnxZero, + Decoding, Encoding, FFT64, FillUniform, Module, ScalarZnx, ScalarZnxAlloc, ScratchOwned, Stats, VecZnxOps, ZnxViewMut, + ZnxZero, }; use itertools::izip; use sampling::source::Source; @@ -232,7 +232,7 @@ fn test_encrypt_pk(log_n: usize, basek: usize, k_ct: usize, k_pk: usize, sigma: ct.decrypt(&module, &mut pt_have, &sk_dft, scratch.borrow()); - module.vec_znx_sub_ab_inplace(&mut pt_want, 0, &pt_have, 0); + module.vec_znx_sub_ab_inplace(&mut pt_want.data, 0, &pt_have.data, 0); let noise_have: f64 = pt_want.data.std(0, basek).log2(); let noise_want: f64 = ((((rank as f64) + 1.0) * module.n() as f64 * 0.5 * sigma * sigma).sqrt()).log2() - (k_ct as f64); @@ -299,7 +299,7 @@ fn test_keyswitch( let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out); sk_out_dft.dft(&module, &sk_out); - ksk.encrypt_sk( + ksk.generate_from_sk( &module, &sk_in, &sk_out_dft, @@ -323,7 +323,7 @@ fn test_keyswitch( ct_out.decrypt(&module, &mut pt_have, &sk_out_dft, scratch.borrow()); - module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); + module.vec_znx_sub_ab_inplace(&mut pt_have.data, 0, &pt_want.data, 0); let noise_have: f64 = pt_have.data.std(0, basek).log2(); let noise_want: f64 = log2_std_noise_gglwe_product( @@ -384,7 +384,7 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k_ksk: usize, k_ct: usize, let mut sk1_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk1_dft.dft(&module, &sk1); - ct_grlwe.encrypt_sk( + ct_grlwe.generate_from_sk( &module, &sk0, &sk1_dft, @@ -408,7 +408,7 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k_ksk: usize, k_ct: usize, ct_rlwe.decrypt(&module, &mut pt_have, &sk1_dft, scratch.borrow()); - module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); + module.vec_znx_sub_ab_inplace(&mut pt_have.data, 0, &pt_want.data, 0); let noise_have: f64 = pt_have.data.std(0, basek).log2(); let noise_want: f64 = log2_std_noise_gglwe_product( @@ -494,9 +494,9 @@ fn test_automorphism( ct_out.automorphism(&module, &ct_in, &autokey, scratch.borrow()); ct_out.decrypt(&module, &mut pt_have, &sk_dft, scratch.borrow()); - module.vec_znx_automorphism_inplace(p, &mut pt_want, 0); - module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); - module.vec_znx_normalize_inplace(basek, &mut pt_have, 0, scratch.borrow()); + module.vec_znx_automorphism_inplace(p, &mut pt_want.data, 0); + module.vec_znx_sub_ab_inplace(&mut pt_have.data, 0, &pt_want.data, 0); + module.vec_znx_normalize_inplace(basek, &mut pt_have.data, 0, scratch.borrow()); let noise_have: f64 = pt_have.data.std(0, basek).log2(); @@ -576,9 +576,9 @@ fn test_automorphism_inplace(log_n: usize, basek: usize, p: i64, k_autokey: usiz ct.automorphism_inplace(&module, &autokey, scratch.borrow()); ct.decrypt(&module, &mut pt_have, &sk_dft, scratch.borrow()); - module.vec_znx_automorphism_inplace(p, &mut pt_want, 0); - module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); - module.vec_znx_normalize_inplace(basek, &mut pt_have, 0, scratch.borrow()); + module.vec_znx_automorphism_inplace(p, &mut pt_want.data, 0); + module.vec_znx_sub_ab_inplace(&mut pt_have.data, 0, &pt_want.data, 0); + module.vec_znx_normalize_inplace(basek, &mut pt_have.data, 0, scratch.borrow()); let noise_have: f64 = pt_have.data.std(0, basek).log2(); let noise_want: f64 = log2_std_noise_gglwe_product( @@ -623,7 +623,7 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, k_ct_in: usi .data .fill_uniform(basek, 0, pt_want.size(), &mut source_xa); - pt_want.to_mut().at_mut(0, 0)[1] = 1; + pt_want.data.at_mut(0, 0)[1] = 1; let k: usize = 1; @@ -672,9 +672,9 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, k_ct_in: usi ct_rlwe_out.decrypt(&module, &mut pt_have, &sk_dft, scratch.borrow()); - module.vec_znx_rotate_inplace(k as i64, &mut pt_want, 0); + module.vec_znx_rotate_inplace(k as i64, &mut pt_want.data, 0); - module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); + module.vec_znx_sub_ab_inplace(&mut pt_have.data, 0, &pt_want.data, 0); let noise_have: f64 = pt_have.data.std(0, basek).log2(); @@ -726,7 +726,7 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, k_ct .data .fill_uniform(basek, 0, pt_want.size(), &mut source_xa); - pt_want.to_mut().at_mut(0, 0)[1] = 1; + pt_want.data.at_mut(0, 0)[1] = 1; let k: usize = 1; @@ -769,9 +769,9 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, k_ct ct_rlwe.decrypt(&module, &mut pt_have, &sk_dft, scratch.borrow()); - module.vec_znx_rotate_inplace(k as i64, &mut pt_want, 0); + module.vec_znx_rotate_inplace(k as i64, &mut pt_want.data, 0); - module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); + module.vec_znx_sub_ab_inplace(&mut pt_have.data, 0, &pt_want.data, 0); let noise_have: f64 = pt_have.data.std(0, basek).log2(); diff --git a/core/src/test_fft64/glwe_fourier.rs b/core/src/test_fft64/glwe_fourier.rs index 4532fb8..85ccb1a 100644 --- a/core/src/test_fft64/glwe_fourier.rs +++ b/core/src/test_fft64/glwe_fourier.rs @@ -8,7 +8,7 @@ use crate::{ keyswitch_key::GLWESwitchingKey, test_fft64::{gglwe::log2_std_noise_gglwe_product, ggsw::noise_ggsw_product}, }; -use backend::{FFT64, FillUniform, Module, ScalarZnx, ScalarZnxAlloc, ScratchOwned, Stats, VecZnxOps, VecZnxToMut, ZnxViewMut}; +use backend::{FFT64, FillUniform, Module, ScalarZnx, ScalarZnxAlloc, ScratchOwned, Stats, VecZnxOps, ZnxViewMut}; use sampling::source::Source; #[test] @@ -104,7 +104,7 @@ fn test_keyswitch( let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank_out); sk_out_dft.dft(&module, &sk_out); - ksk.encrypt_sk( + ksk.generate_from_sk( &module, &sk_in, &sk_out_dft, @@ -130,7 +130,7 @@ fn test_keyswitch( ct_glwe_out.decrypt(&module, &mut pt_have, &sk_out_dft, scratch.borrow()); - module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); + module.vec_znx_sub_ab_inplace(&mut pt_have.data, 0, &pt_want.data, 0); let noise_have: f64 = pt_have.data.std(0, basek).log2(); let noise_want: f64 = log2_std_noise_gglwe_product( @@ -192,7 +192,7 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k_ksk: usize, k_ct: usize, let mut sk_out_dft: SecretKeyFourier, FFT64> = SecretKeyFourier::alloc(&module, rank); sk_out_dft.dft(&module, &sk_out); - ksk.encrypt_sk( + ksk.generate_from_sk( &module, &sk_in, &sk_out_dft, @@ -218,7 +218,7 @@ fn test_keyswitch_inplace(log_n: usize, basek: usize, k_ksk: usize, k_ct: usize, ct_glwe.decrypt(&module, &mut pt_have, &sk_out_dft, scratch.borrow()); - module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); + module.vec_znx_sub_ab_inplace(&mut pt_have.data, 0, &pt_want.data, 0); let noise_have: f64 = pt_have.data.std(0, basek).log2(); let noise_want: f64 = log2_std_noise_gglwe_product( @@ -265,7 +265,7 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, k_ct_in: usi .data .fill_uniform(basek, 0, pt_want.size(), &mut source_xa); - pt_want.to_mut().at_mut(0, 0)[1] = 1; + pt_want.data.at_mut(0, 0)[1] = 1; let k: usize = 1; @@ -310,9 +310,9 @@ fn test_external_product(log_n: usize, basek: usize, k_ggsw: usize, k_ct_in: usi ct_out.decrypt(&module, &mut pt_have, &sk_dft, scratch.borrow()); - module.vec_znx_rotate_inplace(k as i64, &mut pt_want, 0); + module.vec_znx_rotate_inplace(k as i64, &mut pt_want.data, 0); - module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); + module.vec_znx_sub_ab_inplace(&mut pt_have.data, 0, &pt_want.data, 0); let noise_have: f64 = pt_have.data.std(0, basek).log2(); @@ -365,7 +365,7 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, k_ct .data .fill_uniform(basek, 0, pt_want.size(), &mut source_xa); - pt_want.to_mut().at_mut(0, 0)[1] = 1; + pt_want.data.at_mut(0, 0)[1] = 1; let k: usize = 1; @@ -410,9 +410,9 @@ fn test_external_product_inplace(log_n: usize, basek: usize, k_ggsw: usize, k_ct ct.decrypt(&module, &mut pt_have, &sk_dft, scratch.borrow()); - module.vec_znx_rotate_inplace(k as i64, &mut pt_want, 0); + module.vec_znx_rotate_inplace(k as i64, &mut pt_want.data, 0); - module.vec_znx_sub_ab_inplace(&mut pt_have, 0, &pt_want, 0); + module.vec_znx_sub_ab_inplace(&mut pt_have.data, 0, &pt_want.data, 0); let noise_have: f64 = pt_have.data.std(0, basek).log2(); diff --git a/core/src/test_fft64/tensor_key.rs b/core/src/test_fft64/tensor_key.rs index b7e0b86..de4447c 100644 --- a/core/src/test_fft64/tensor_key.rs +++ b/core/src/test_fft64/tensor_key.rs @@ -69,7 +69,7 @@ fn test_encrypt_sk(log_n: usize, basek: usize, k: usize, sigma: f64, rank: usize .at(i, j) .get_row(&module, row_i, col_i, &mut ct_glwe_fourier); ct_glwe_fourier.decrypt(&module, &mut pt, &sk_dft, scratch.borrow()); - module.vec_znx_sub_scalar_inplace(&mut pt, 0, row_i, &sk_ij, col_i); + module.vec_znx_sub_scalar_inplace(&mut pt.data, 0, row_i, &sk_ij, col_i); let std_pt: f64 = pt.data.std(0, basek) * (k as f64).exp2(); assert!((sigma - std_pt).abs() <= 0.2, "{} {}", sigma, std_pt); }); diff --git a/core/src/test_fft64/trace.rs b/core/src/test_fft64/trace.rs index 34f466a..8e72468 100644 --- a/core/src/test_fft64/trace.rs +++ b/core/src/test_fft64/trace.rs @@ -91,8 +91,8 @@ fn test_trace_inplace(log_n: usize, basek: usize, k: usize, sigma: f64, rank: us ct.decrypt(&module, &mut pt_have, &sk_dft, scratch.borrow()); - module.vec_znx_sub_ab_inplace(&mut pt_want, 0, &pt_have, 0); - module.vec_znx_normalize_inplace(basek, &mut pt_want, 0, scratch.borrow()); + module.vec_znx_sub_ab_inplace(&mut pt_want.data, 0, &pt_have.data, 0); + module.vec_znx_normalize_inplace(basek, &mut pt_want.data, 0, scratch.borrow()); let noise_have = pt_want.data.std(0, basek).log2(); diff --git a/core/src/trace.rs b/core/src/trace.rs index 40bd8b7..301453a 100644 --- a/core/src/trace.rs +++ b/core/src/trace.rs @@ -1,8 +1,13 @@ use std::collections::HashMap; -use backend::{FFT64, MatZnxDft, MatZnxDftToRef, Module, Scratch, VecZnx, VecZnxToMut, VecZnxToRef}; +use backend::{FFT64, Module, Scratch}; -use crate::{automorphism::AutomorphismKey, glwe_ciphertext::GLWECiphertext}; +use crate::{ + automorphism::AutomorphismKey, + elem::{Infos, SetMetaData}, + glwe_ciphertext::{GLWECiphertext, GLWECiphertextToMut, GLWECiphertextToRef}, + glwe_ops::GLWEOps, +}; impl GLWECiphertext> { pub fn trace_galois_elements(module: &Module) -> Vec { @@ -32,11 +37,11 @@ impl GLWECiphertext> { } } -impl GLWECiphertext +impl + AsMut<[u8]>> GLWECiphertext where - VecZnx: VecZnxToMut, + GLWECiphertext: GLWECiphertextToMut + Infos + SetMetaData, { - pub fn trace( + pub fn trace, DataAK: AsRef<[u8]>>( &mut self, module: &Module, start: usize, @@ -45,23 +50,20 @@ where auto_keys: &HashMap>, scratch: &mut Scratch, ) where - VecZnx: VecZnxToRef, - MatZnxDft: MatZnxDftToRef, + GLWECiphertext: GLWECiphertextToRef + Infos, { self.copy(module, lhs); self.trace_inplace(module, start, end, auto_keys, scratch); } - pub fn trace_inplace( + pub fn trace_inplace>( &mut self, module: &Module, start: usize, end: usize, auto_keys: &HashMap>, scratch: &mut Scratch, - ) where - MatZnxDft: MatZnxDftToRef, - { + ) { (start..end).for_each(|i| { self.rsh(1, scratch); From fa1a1fc49b50018b7df4cb7d3f153f4bff7e0551 Mon Sep 17 00:00:00 2001 From: Jean-Philippe Bossuat Date: Tue, 27 May 2025 23:40:17 +0200 Subject: [PATCH 10/10] added glwe ops on plaintext --- core/src/glwe_plaintext.rs | 41 ++++++++++++++++++++++++++++++++++++-- 1 file changed, 39 insertions(+), 2 deletions(-) diff --git a/core/src/glwe_plaintext.rs b/core/src/glwe_plaintext.rs index dd4aa2e..82bcac7 100644 --- a/core/src/glwe_plaintext.rs +++ b/core/src/glwe_plaintext.rs @@ -1,6 +1,6 @@ -use backend::{Backend, Module, VecZnx, VecZnxAlloc}; +use backend::{Backend, Module, VecZnx, VecZnxAlloc, VecZnxToMut, VecZnxToRef}; -use crate::{elem::Infos, utils::derive_size}; +use crate::{elem::{Infos, SetMetaData}, glwe_ciphertext::{GLWECiphertext, GLWECiphertextToMut, GLWECiphertextToRef}, glwe_ops::GLWEOps, utils::derive_size}; pub struct GLWEPlaintext { pub data: VecZnx, @@ -24,6 +24,16 @@ impl Infos for GLWEPlaintext { } } +impl + AsRef<[u8]>> SetMetaData for GLWEPlaintext { + fn set_k(&mut self, k: usize) { + self.k = k + } + + fn set_basek(&mut self, basek: usize) { + self.basek = basek + } +} + impl GLWEPlaintext> { pub fn alloc(module: &Module, basek: usize, k: usize) -> Self { Self { @@ -33,3 +43,30 @@ impl GLWEPlaintext> { } } } + +impl> GLWECiphertextToRef for GLWEPlaintext { + fn to_ref(&self) -> GLWECiphertext<&[u8]> { + GLWECiphertext { + data: self.data.to_ref(), + basek: self.basek, + k: self.k, + } + } +} + +impl + AsRef<[u8]>> GLWECiphertextToMut for GLWEPlaintext { + fn to_mut(&mut self) -> GLWECiphertext<&mut [u8]> { + GLWECiphertext { + data: self.data.to_mut(), + basek: self.basek, + k: self.k, + } + } +} + +impl GLWEOps for GLWEPlaintext +where + D: AsRef<[u8]> + AsMut<[u8]>, + GLWEPlaintext: GLWECiphertextToMut + Infos + SetMetaData, +{ +}