From 3bdddd3857c8b2a6293fc4e1676bdf6768bfd5c9 Mon Sep 17 00:00:00 2001 From: Jean-Philippe Bossuat Date: Fri, 25 Apr 2025 09:19:47 +0200 Subject: [PATCH] Added size and memory layout to VecZnxBig, VecZnxDft and VmpPmat --- base2k/examples/rlwe_encrypt.rs | 2 +- base2k/examples/vector_matrix_product.rs | 4 +- base2k/src/encoding.rs | 2 +- base2k/src/infos.rs | 8 ++++ base2k/src/lib.rs | 1 - base2k/src/svp.rs | 2 +- base2k/src/vec_znx.rs | 15 ++++--- base2k/src/vec_znx_big.rs | 52 +++++++++++++++------- base2k/src/vec_znx_dft.rs | 56 ++++++++++++++++-------- base2k/src/vmp.rs | 47 +++++++++++++------- rlwe/benches/gadget_product.rs | 4 +- rlwe/src/automorphism.rs | 10 ++--- rlwe/src/ciphertext.rs | 6 ++- rlwe/src/decryptor.rs | 8 ++-- rlwe/src/elem.rs | 9 +++- rlwe/src/encryptor.rs | 6 +-- rlwe/src/gadget_product.rs | 24 +++++----- rlwe/src/key_switching.rs | 12 ++--- rlwe/src/plaintext.rs | 6 ++- rlwe/src/rgsw_product.rs | 28 ++++++------ rlwe/src/trace.rs | 10 ++--- sampling/src/source.rs | 2 +- 22 files changed, 195 insertions(+), 119 deletions(-) diff --git a/base2k/examples/rlwe_encrypt.rs b/base2k/examples/rlwe_encrypt.rs index 1dea72d..f66a4d1 100644 --- a/base2k/examples/rlwe_encrypt.rs +++ b/base2k/examples/rlwe_encrypt.rs @@ -35,7 +35,7 @@ fn main() { module.fill_uniform(log_base2k, &mut a, cols, &mut source); // Scratch space for DFT values - let mut buf_dft: VecZnxDft = module.new_vec_znx_dft(a.cols()); + let mut buf_dft: VecZnxDft = module.new_vec_znx_dft(1, a.cols()); // Applies buf_dft <- s * a module.svp_apply_dft(&mut buf_dft, &s_ppol, &a); diff --git a/base2k/examples/vector_matrix_product.rs b/base2k/examples/vector_matrix_product.rs index be4f189..a69c857 100644 --- a/base2k/examples/vector_matrix_product.rs +++ b/base2k/examples/vector_matrix_product.rs @@ -30,7 +30,7 @@ fn main() { a.print(0, a.cols(), n); println!(); - let mut vmp_pmat: VmpPMat = module.new_vmp_pmat(rows, cols); + let mut vmp_pmat: VmpPMat = module.new_vmp_pmat(1, rows, cols); (0..a.cols()).for_each(|row_i| { let mut tmp: VecZnx = module.new_vec_znx(1, cols); @@ -38,7 +38,7 @@ fn main() { module.vmp_prepare_row(&mut vmp_pmat, tmp.raw(), row_i, &mut buf); }); - let mut c_dft: VecZnxDft = module.new_vec_znx_dft(cols); + let mut c_dft: VecZnxDft = module.new_vec_znx_dft(1, cols); module.vmp_apply_dft(&mut c_dft, &a, &vmp_pmat, &mut buf); let mut c_big: VecZnxBig = c_dft.as_vec_znx_big(); diff --git a/base2k/src/encoding.rs b/base2k/src/encoding.rs index c293190..c8c08e9 100644 --- a/base2k/src/encoding.rs +++ b/base2k/src/encoding.rs @@ -261,7 +261,7 @@ fn decode_coeff_i64(a: &VecZnx, poly_idx: usize, log_base2k: usize, log_k: usize #[cfg(test)] mod tests { - use crate::{Encoding, VecZnx}; + use crate::{Encoding, Infos, VecZnx}; use itertools::izip; use sampling::source::Source; diff --git a/base2k/src/infos.rs b/base2k/src/infos.rs index 6898c94..08472d9 100644 --- a/base2k/src/infos.rs +++ b/base2k/src/infos.rs @@ -1,3 +1,5 @@ +use crate::LAYOUT; + pub trait Infos { /// Returns the ring degree of the receiver. fn n(&self) -> usize; @@ -5,6 +7,12 @@ pub trait Infos { /// Returns the base two logarithm of the ring dimension of the receiver. fn log_n(&self) -> usize; + /// Returns the number of stacked polynomials. + fn size(&self) -> usize; + + /// Returns the memory layout of the stacked polynomials. + fn layout(&self) -> LAYOUT; + /// Returns the number of columns of the receiver. /// This method is equivalent to [Infos::cols]. fn cols(&self) -> usize; diff --git a/base2k/src/lib.rs b/base2k/src/lib.rs index 86cd1fd..7e97b00 100644 --- a/base2k/src/lib.rs +++ b/base2k/src/lib.rs @@ -34,7 +34,6 @@ pub enum LAYOUT { COL, } - pub fn is_aligned_custom(ptr: *const T, align: usize) -> bool { (ptr as usize) % align == 0 } diff --git a/base2k/src/svp.rs b/base2k/src/svp.rs index 7dfebbc..0e85a31 100644 --- a/base2k/src/svp.rs +++ b/base2k/src/svp.rs @@ -1,6 +1,6 @@ use crate::ffi::svp::{self, svp_ppol_t}; use crate::ffi::vec_znx_dft::vec_znx_dft_t; -use crate::{assert_alignement, Module, VecZnx, VecZnxDft, BACKEND, LAYOUT}; +use crate::{BACKEND, LAYOUT, Module, VecZnx, VecZnxDft, assert_alignement}; use crate::{Infos, alloc_aligned, cast_mut}; use rand::seq::SliceRandom; diff --git a/base2k/src/vec_znx.rs b/base2k/src/vec_znx.rs index 9d78dfa..7445b5b 100644 --- a/base2k/src/vec_znx.rs +++ b/base2k/src/vec_znx.rs @@ -1,7 +1,7 @@ +use crate::LAYOUT; use crate::cast_mut; use crate::ffi::vec_znx; use crate::ffi::znx; -use crate::LAYOUT; use crate::{Infos, Module}; use crate::{alloc_aligned, assert_alignement}; use itertools::izip; @@ -99,11 +99,6 @@ impl VecZnx { self.data.len() == 0 } - /// TODO: when SML refactoring is done, move this to the [Infos] trait. - pub fn size(&self) -> usize { - self.size - } - /// Total size is [VecZnx::n()] * [VecZnx::size()] * [VecZnx::cols()]. pub fn raw(&self) -> &[i64] { unsafe { std::slice::from_raw_parts(self.ptr, self.n * self.size * self.cols) } @@ -225,6 +220,14 @@ impl Infos for VecZnx { self.n } + fn size(&self) -> usize { + self.size + } + + fn layout(&self) -> LAYOUT { + self.layout + } + /// Returns the number of cols of the [VecZnx]. fn cols(&self) -> usize { self.cols diff --git a/base2k/src/vec_znx_big.rs b/base2k/src/vec_znx_big.rs index 0de9c8c..705a5ec 100644 --- a/base2k/src/vec_znx_big.rs +++ b/base2k/src/vec_znx_big.rs @@ -1,11 +1,13 @@ use crate::ffi::vec_znx_big::{self, vec_znx_big_t}; -use crate::{BACKEND, Infos, Module, VecZnx, VecZnxDft, alloc_aligned, assert_alignement}; +use crate::{BACKEND, Infos, LAYOUT, Module, VecZnx, VecZnxDft, alloc_aligned, assert_alignement}; pub struct VecZnxBig { pub data: Vec, pub ptr: *mut u8, pub n: usize, + pub size: usize, pub cols: usize, + pub layout: LAYOUT, pub backend: BACKEND, } @@ -13,10 +15,10 @@ impl VecZnxBig { /// Returns a new [VecZnxBig] with the provided data as backing array. /// User must ensure that data is properly alligned and that /// the size of data is at least equal to [Module::bytes_of_vec_znx_big]. - pub fn from_bytes(module: &Module, cols: usize, bytes: &mut [u8]) -> Self { + pub fn from_bytes(module: &Module, size: usize, cols: usize, bytes: &mut [u8]) -> Self { #[cfg(debug_assertions)] { - assert_eq!(bytes.len(), module.bytes_of_vec_znx_big(cols)); + assert_eq!(bytes.len(), module.bytes_of_vec_znx_big(size, cols)); assert_alignement(bytes.as_ptr()) }; unsafe { @@ -24,22 +26,26 @@ impl VecZnxBig { data: Vec::from_raw_parts(bytes.as_mut_ptr(), bytes.len(), bytes.len()), ptr: bytes.as_mut_ptr(), n: module.n(), + size: size, + layout: LAYOUT::COL, cols: cols, backend: module.backend, } } } - pub fn from_bytes_borrow(module: &Module, cols: usize, bytes: &mut [u8]) -> Self { + pub fn from_bytes_borrow(module: &Module, size: usize, cols: usize, bytes: &mut [u8]) -> Self { #[cfg(debug_assertions)] { - assert_eq!(bytes.len(), module.bytes_of_vec_znx_big(cols)); + assert_eq!(bytes.len(), module.bytes_of_vec_znx_big(size, cols)); assert_alignement(bytes.as_ptr()); } Self { data: Vec::new(), ptr: bytes.as_mut_ptr(), n: module.n(), + size: size, + layout: LAYOUT::COL, cols: cols, backend: module.backend, } @@ -50,6 +56,8 @@ impl VecZnxBig { data: Vec::new(), ptr: self.ptr, n: self.n, + size: self.size, + layout: LAYOUT::COL, cols: self.cols, backend: self.backend, } @@ -81,6 +89,14 @@ impl Infos for VecZnxBig { self.n } + fn size(&self) -> usize { + self.size + } + + fn layout(&self) -> LAYOUT { + self.layout + } + /// Returns the number of cols of the [VecZnx]. fn cols(&self) -> usize { self.cols @@ -94,7 +110,7 @@ impl Infos for VecZnxBig { pub trait VecZnxBigOps { /// Allocates a vector Z[X]/(X^N+1) that stores not normalized values. - fn new_vec_znx_big(&self, cols: usize) -> VecZnxBig; + fn new_vec_znx_big(&self, size: usize, cols: usize) -> VecZnxBig; /// Returns a new [VecZnxBig] with the provided bytes array as backing array. /// @@ -107,7 +123,7 @@ pub trait VecZnxBigOps { /// /// # Panics /// If `bytes.len()` < [Module::bytes_of_vec_znx_big]. - fn new_vec_znx_big_from_bytes(&self, cols: usize, bytes: &mut [u8]) -> VecZnxBig; + fn new_vec_znx_big_from_bytes(&self, size: usize, cols: usize, bytes: &mut [u8]) -> VecZnxBig; /// Returns a new [VecZnxBig] with the provided bytes array as backing array. /// @@ -120,11 +136,11 @@ pub trait VecZnxBigOps { /// /// # Panics /// If `bytes.len()` < [Module::bytes_of_vec_znx_big]. - fn new_vec_znx_big_from_bytes_borrow(&self, cols: usize, tmp_bytes: &mut [u8]) -> VecZnxBig; + fn new_vec_znx_big_from_bytes_borrow(&self, size: usize, cols: usize, tmp_bytes: &mut [u8]) -> VecZnxBig; /// Returns the minimum number of bytes necessary to allocate /// a new [VecZnxBig] through [VecZnxBig::from_bytes]. - fn bytes_of_vec_znx_big(&self, cols: usize) -> usize; + fn bytes_of_vec_znx_big(&self, size: usize, cols: usize) -> usize; /// b <- b - a fn vec_znx_big_sub_small_a_inplace(&self, b: &mut VecZnxBig, a: &VecZnx); @@ -162,28 +178,30 @@ pub trait VecZnxBigOps { } impl VecZnxBigOps for Module { - fn new_vec_znx_big(&self, cols: usize) -> VecZnxBig { - let mut data: Vec = alloc_aligned::(self.bytes_of_vec_znx_big(cols)); + fn new_vec_znx_big(&self, size: usize, cols: usize) -> VecZnxBig { + let mut data: Vec = alloc_aligned::(self.bytes_of_vec_znx_big(size, cols)); let ptr: *mut u8 = data.as_mut_ptr(); VecZnxBig { data: data, ptr: ptr, n: self.n(), + size: size, + layout: LAYOUT::COL, cols: cols, backend: self.backend(), } } - fn new_vec_znx_big_from_bytes(&self, cols: usize, bytes: &mut [u8]) -> VecZnxBig { - VecZnxBig::from_bytes(self, cols, bytes) + fn new_vec_znx_big_from_bytes(&self, size: usize, cols: usize, bytes: &mut [u8]) -> VecZnxBig { + VecZnxBig::from_bytes(self, size, cols, bytes) } - fn new_vec_znx_big_from_bytes_borrow(&self, cols: usize, tmp_bytes: &mut [u8]) -> VecZnxBig { - VecZnxBig::from_bytes_borrow(self, cols, tmp_bytes) + fn new_vec_znx_big_from_bytes_borrow(&self, size: usize, cols: usize, tmp_bytes: &mut [u8]) -> VecZnxBig { + VecZnxBig::from_bytes_borrow(self, size, cols, tmp_bytes) } - fn bytes_of_vec_znx_big(&self, cols: usize) -> usize { - unsafe { vec_znx_big::bytes_of_vec_znx_big(self.ptr, cols as u64) as usize } + fn bytes_of_vec_znx_big(&self, size: usize, cols: usize) -> usize { + unsafe { vec_znx_big::bytes_of_vec_znx_big(self.ptr, cols as u64) as usize * size } } fn vec_znx_big_sub_small_a_inplace(&self, b: &mut VecZnxBig, a: &VecZnx) { diff --git a/base2k/src/vec_znx_dft.rs b/base2k/src/vec_znx_dft.rs index 188d13b..8b31ea6 100644 --- a/base2k/src/vec_znx_dft.rs +++ b/base2k/src/vec_znx_dft.rs @@ -1,13 +1,15 @@ use crate::ffi::vec_znx_big::vec_znx_big_t; use crate::ffi::vec_znx_dft; use crate::ffi::vec_znx_dft::{bytes_of_vec_znx_dft, vec_znx_dft_t}; -use crate::{BACKEND, Infos, Module, VecZnxBig, assert_alignement}; +use crate::{BACKEND, Infos, LAYOUT, Module, VecZnxBig, assert_alignement}; use crate::{DEFAULTALIGN, VecZnx, alloc_aligned}; pub struct VecZnxDft { pub data: Vec, pub ptr: *mut u8, pub n: usize, + pub size: usize, + pub layout: LAYOUT, pub cols: usize, pub backend: BACKEND, } @@ -16,10 +18,10 @@ impl VecZnxDft { /// Returns a new [VecZnxDft] with the provided data as backing array. /// User must ensure that data is properly alligned and that /// the size of data is at least equal to [Module::bytes_of_vec_znx_dft]. - pub fn from_bytes(module: &Module, cols: usize, bytes: &mut [u8]) -> VecZnxDft { + pub fn from_bytes(module: &Module, size: usize, cols: usize, bytes: &mut [u8]) -> VecZnxDft { #[cfg(debug_assertions)] { - assert_eq!(bytes.len(), module.bytes_of_vec_znx_dft(cols)); + assert_eq!(bytes.len(), module.bytes_of_vec_znx_dft(size, cols)); assert_alignement(bytes.as_ptr()) } unsafe { @@ -27,22 +29,26 @@ impl VecZnxDft { data: Vec::from_raw_parts(bytes.as_mut_ptr(), bytes.len(), bytes.len()), ptr: bytes.as_mut_ptr(), n: module.n(), + size: size, + layout: LAYOUT::COL, cols: cols, backend: module.backend, } } } - pub fn from_bytes_borrow(module: &Module, cols: usize, bytes: &mut [u8]) -> VecZnxDft { + pub fn from_bytes_borrow(module: &Module, size: usize, cols: usize, bytes: &mut [u8]) -> VecZnxDft { #[cfg(debug_assertions)] { - assert_eq!(bytes.len(), module.bytes_of_vec_znx_dft(cols)); + assert_eq!(bytes.len(), module.bytes_of_vec_znx_dft(size, cols)); assert_alignement(bytes.as_ptr()); } VecZnxDft { data: Vec::new(), ptr: bytes.as_mut_ptr(), n: module.n(), + size: size, + layout: LAYOUT::COL, cols: cols, backend: module.backend, } @@ -56,6 +62,8 @@ impl VecZnxDft { data: Vec::new(), ptr: self.ptr, n: self.n, + layout: LAYOUT::COL, + size: self.size, cols: self.cols, backend: self.backend, } @@ -105,6 +113,14 @@ impl Infos for VecZnxDft { self.n } + fn size(&self) -> usize { + self.size + } + + fn layout(&self) -> LAYOUT { + self.layout + } + /// Returns the number of cols of the [VecZnx]. fn cols(&self) -> usize { self.cols @@ -118,7 +134,7 @@ impl Infos for VecZnxDft { pub trait VecZnxDftOps { /// Allocates a vector Z[X]/(X^N+1) that stores normalized in the DFT space. - fn new_vec_znx_dft(&self, cols: usize) -> VecZnxDft; + fn new_vec_znx_dft(&self, size: usize, cols: usize) -> VecZnxDft; /// Returns a new [VecZnxDft] with the provided bytes array as backing array. /// @@ -131,7 +147,7 @@ pub trait VecZnxDftOps { /// /// # Panics /// If `bytes.len()` < [Module::bytes_of_vec_znx_dft]. - fn new_vec_znx_dft_from_bytes(&self, cols: usize, bytes: &mut [u8]) -> VecZnxDft; + fn new_vec_znx_dft_from_bytes(&self, size: usize, cols: usize, bytes: &mut [u8]) -> VecZnxDft; /// Returns a new [VecZnxDft] with the provided bytes array as backing array. /// @@ -144,7 +160,7 @@ pub trait VecZnxDftOps { /// /// # Panics /// If `bytes.len()` < [Module::bytes_of_vec_znx_dft]. - fn new_vec_znx_dft_from_bytes_borrow(&self, cols: usize, bytes: &mut [u8]) -> VecZnxDft; + fn new_vec_znx_dft_from_bytes_borrow(&self, size: usize, cols: usize, bytes: &mut [u8]) -> VecZnxDft; /// Returns a new [VecZnxDft] with the provided bytes array as backing array. /// @@ -155,7 +171,7 @@ pub trait VecZnxDftOps { /// /// # Panics /// If `bytes.len()` < [Module::bytes_of_vec_znx_dft]. - fn bytes_of_vec_znx_dft(&self, cols: usize) -> usize; + fn bytes_of_vec_znx_dft(&self, size: usize, cols: usize) -> usize; /// Returns the minimum number of bytes necessary to allocate /// a new [VecZnxDft] through [VecZnxDft::from_bytes]. @@ -176,28 +192,30 @@ pub trait VecZnxDftOps { } impl VecZnxDftOps for Module { - fn new_vec_znx_dft(&self, cols: usize) -> VecZnxDft { - let mut data: Vec = alloc_aligned::(self.bytes_of_vec_znx_dft(cols)); + fn new_vec_znx_dft(&self, size: usize, cols: usize) -> VecZnxDft { + let mut data: Vec = alloc_aligned::(self.bytes_of_vec_znx_dft(size, cols)); let ptr: *mut u8 = data.as_mut_ptr(); VecZnxDft { data: data, ptr: ptr, n: self.n(), + size: size, + layout: LAYOUT::COL, cols: cols, backend: self.backend(), } } - fn new_vec_znx_dft_from_bytes(&self, cols: usize, tmp_bytes: &mut [u8]) -> VecZnxDft { - VecZnxDft::from_bytes(self, cols, tmp_bytes) + fn new_vec_znx_dft_from_bytes(&self, size: usize, cols: usize, tmp_bytes: &mut [u8]) -> VecZnxDft { + VecZnxDft::from_bytes(self, size, cols, tmp_bytes) } - fn new_vec_znx_dft_from_bytes_borrow(&self, cols: usize, tmp_bytes: &mut [u8]) -> VecZnxDft { - VecZnxDft::from_bytes_borrow(self, cols, tmp_bytes) + fn new_vec_znx_dft_from_bytes_borrow(&self, size: usize, cols: usize, tmp_bytes: &mut [u8]) -> VecZnxDft { + VecZnxDft::from_bytes_borrow(self, size, cols, tmp_bytes) } - fn bytes_of_vec_znx_dft(&self, cols: usize) -> usize { - unsafe { bytes_of_vec_znx_dft(self.ptr, cols as u64) as usize } + fn bytes_of_vec_znx_dft(&self, size: usize, cols: usize) -> usize { + unsafe { bytes_of_vec_znx_dft(self.ptr, cols as u64) as usize * size } } fn vec_znx_idft_tmp_a(&self, b: &mut VecZnxBig, a: &mut VecZnxDft) { @@ -318,8 +336,8 @@ mod tests { let cols: usize = 2; let log_base2k: usize = 17; let mut a: VecZnx = module.new_vec_znx(1, cols); - let mut a_dft: VecZnxDft = module.new_vec_znx_dft(cols); - let mut b_dft: VecZnxDft = module.new_vec_znx_dft(cols); + let mut a_dft: VecZnxDft = module.new_vec_znx_dft(1, cols); + let mut b_dft: VecZnxDft = module.new_vec_znx_dft(1, cols); let mut source: Source = Source::new(new_seed()); module.fill_uniform(log_base2k, &mut a, cols, &mut source); diff --git a/base2k/src/vmp.rs b/base2k/src/vmp.rs index 90ca9c8..7d6c26f 100644 --- a/base2k/src/vmp.rs +++ b/base2k/src/vmp.rs @@ -1,7 +1,7 @@ use crate::ffi::vec_znx_big::vec_znx_big_t; use crate::ffi::vec_znx_dft::vec_znx_dft_t; use crate::ffi::vmp::{self, vmp_pmat_t}; -use crate::{BACKEND, Infos, Module, VecZnx, VecZnxBig, VecZnxDft, alloc_aligned, assert_alignement}; +use crate::{BACKEND, Infos, LAYOUT, Module, VecZnx, VecZnxBig, VecZnxDft, alloc_aligned, assert_alignement}; /// Vector Matrix Product Prepared Matrix: a vector of [VecZnx], /// stored as a 3D matrix in the DFT domain in a single contiguous array. @@ -23,8 +23,11 @@ pub struct VmpPMat { cols: usize, /// The ring degree of each [VecZnxDft]. n: usize, - - #[warn(dead_code)] + /// The number of stacked [VmpPMat], must be a square. + size: usize, + /// The memory layout of the stacked [VmpPMat]. + layout: LAYOUT, + /// The backend fft or ntt. backend: BACKEND, } @@ -38,6 +41,14 @@ impl Infos for VmpPMat { (usize::BITS - (self.n() - 1).leading_zeros()) as _ } + fn size(&self) -> usize { + self.size + } + + fn layout(&self) -> LAYOUT { + self.layout + } + /// Returns the number of rows (i.e. of [VecZnxDft]) of the [VmpPMat] fn rows(&self) -> usize { self.rows @@ -120,12 +131,16 @@ impl VmpPMat { &self.raw::()[blk * nrows * ncols * 8 + (col / 2) * (2 * nrows) * 8 + row * 2 * 8 + (col % 2) * 8..] } } + + fn backend(&self) -> BACKEND { + self.backend + } } /// This trait implements methods for vector matrix product, /// that is, multiplying a [VecZnx] with a [VmpPMat]. pub trait VmpPMatOps { - fn bytes_of_vmp_pmat(&self, rows: usize, cols: usize) -> usize; + fn bytes_of_vmp_pmat(&self, size: usize, rows: usize, cols: usize) -> usize; /// Allocates a new [VmpPMat] with the given number of rows and columns. /// @@ -133,7 +148,7 @@ pub trait VmpPMatOps { /// /// * `rows`: number of rows (number of [VecZnxDft]). /// * `cols`: number of cols (number of cols of each [VecZnxDft]). - fn new_vmp_pmat(&self, rows: usize, cols: usize) -> VmpPMat; + fn new_vmp_pmat(&self, size: usize, rows: usize, cols: usize) -> VmpPMat; /// Returns the number of bytes needed as scratch space for [VmpPMatOps::vmp_prepare_contiguous]. /// @@ -360,17 +375,19 @@ pub trait VmpPMatOps { } impl VmpPMatOps for Module { - fn bytes_of_vmp_pmat(&self, rows: usize, cols: usize) -> usize { - unsafe { vmp::bytes_of_vmp_pmat(self.ptr, rows as u64, cols as u64) as usize } + fn bytes_of_vmp_pmat(&self, size: usize, rows: usize, cols: usize) -> usize { + unsafe { vmp::bytes_of_vmp_pmat(self.ptr, rows as u64, cols as u64) as usize * size } } - fn new_vmp_pmat(&self, rows: usize, cols: usize) -> VmpPMat { - let mut data: Vec = alloc_aligned::(self.bytes_of_vmp_pmat(rows, cols)); + fn new_vmp_pmat(&self, size: usize, rows: usize, cols: usize) -> VmpPMat { + let mut data: Vec = alloc_aligned::(self.bytes_of_vmp_pmat(size, rows, cols)); let ptr: *mut u8 = data.as_mut_ptr(); VmpPMat { data: data, ptr: ptr, n: self.n(), + size: size, + layout: LAYOUT::COL, cols: cols, rows: rows, backend: self.backend(), @@ -643,12 +660,12 @@ mod tests { let vpmat_cols: usize = 5; let log_base2k: usize = 8; let mut a: VecZnx = module.new_vec_znx(1, vpmat_cols); - let mut a_dft: VecZnxDft = module.new_vec_znx_dft(vpmat_cols); - let mut a_big: VecZnxBig = module.new_vec_znx_big(vpmat_cols); - let mut b_big: VecZnxBig = module.new_vec_znx_big(vpmat_cols); - let mut b_dft: VecZnxDft = module.new_vec_znx_dft(vpmat_cols); - let mut vmpmat_0: VmpPMat = module.new_vmp_pmat(vpmat_rows, vpmat_cols); - let mut vmpmat_1: VmpPMat = module.new_vmp_pmat(vpmat_rows, vpmat_cols); + let mut a_dft: VecZnxDft = module.new_vec_znx_dft(1, vpmat_cols); + let mut a_big: VecZnxBig = module.new_vec_znx_big(1, vpmat_cols); + let mut b_big: VecZnxBig = module.new_vec_znx_big(1, vpmat_cols); + let mut b_dft: VecZnxDft = module.new_vec_znx_dft(1, vpmat_cols); + let mut vmpmat_0: VmpPMat = module.new_vmp_pmat(1, vpmat_rows, vpmat_cols); + let mut vmpmat_1: VmpPMat = module.new_vmp_pmat(1, vpmat_rows, vpmat_cols); let mut tmp_bytes: Vec = alloc_aligned(module.vmp_prepare_tmp_bytes(vpmat_rows, vpmat_cols)); diff --git a/rlwe/benches/gadget_product.rs b/rlwe/benches/gadget_product.rs index 5af41f1..fdd2240 100644 --- a/rlwe/benches/gadget_product.rs +++ b/rlwe/benches/gadget_product.rs @@ -104,8 +104,8 @@ fn bench_gadget_product_inplace(c: &mut Criterion) { &mut tmp_bytes, ); - let mut res_dft_0: VecZnxDft = params.module().new_vec_znx_dft(gadget_ct.cols()); - let mut res_dft_1: VecZnxDft = params.module().new_vec_znx_dft(gadget_ct.cols()); + let mut res_dft_0: VecZnxDft = params.module().new_vec_znx_dft(1, gadget_ct.cols()); + let mut res_dft_1: VecZnxDft = params.module().new_vec_znx_dft(1, gadget_ct.cols()); let mut a: VecZnx = params.module().new_vec_znx(0, params.cols_q()); params diff --git a/rlwe/src/automorphism.rs b/rlwe/src/automorphism.rs index 6390c11..5e5b48a 100644 --- a/rlwe/src/automorphism.rs +++ b/rlwe/src/automorphism.rs @@ -152,7 +152,7 @@ pub fn automorphism( pub fn automorphism_inplace_tmp_bytes(module: &Module, c_cols: usize, a_cols: usize, b_rows: usize, b_cols: usize) -> usize { return module.vmp_apply_dft_to_dft_tmp_bytes(c_cols, a_cols, b_rows, b_cols) - + 2 * module.bytes_of_vec_znx_dft(std::cmp::min(c_cols, a_cols)); + + 2 * module.bytes_of_vec_znx_dft(1, std::cmp::min(c_cols, a_cols)); } pub fn automorphism_inplace( @@ -184,11 +184,11 @@ pub fn automorphism_big( assert_alignement(tmp_bytes.as_ptr()); } - let (tmp_bytes_b1_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(cols)); - let (tmp_bytes_res_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(cols)); + let (tmp_bytes_b1_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(1, cols)); + let (tmp_bytes_res_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(1, cols)); - let mut a1_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(cols, tmp_bytes_b1_dft); - let mut res_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(cols, tmp_bytes_res_dft); + let mut a1_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(1, cols, tmp_bytes_b1_dft); + let mut res_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(1, cols, tmp_bytes_res_dft); // a1_dft = DFT(a[1]) module.vec_znx_dft(&mut a1_dft, a.at(1)); diff --git a/rlwe/src/ciphertext.rs b/rlwe/src/ciphertext.rs index 67a7f77..9d1fe1a 100644 --- a/rlwe/src/ciphertext.rs +++ b/rlwe/src/ciphertext.rs @@ -1,6 +1,6 @@ use crate::elem::{Elem, ElemCommon}; use crate::parameters::Parameters; -use base2k::{Infos, Module, VecZnx, VmpPMat}; +use base2k::{Infos, LAYOUT, Module, VecZnx, VmpPMat}; pub struct Ciphertext(pub Elem); @@ -38,6 +38,10 @@ where self.elem().size() } + fn layout(&self) -> LAYOUT { + self.elem().layout() + } + fn rows(&self) -> usize { self.elem().rows() } diff --git a/rlwe/src/decryptor.rs b/rlwe/src/decryptor.rs index 8f0ff76..6eeea27 100644 --- a/rlwe/src/decryptor.rs +++ b/rlwe/src/decryptor.rs @@ -20,8 +20,8 @@ impl Decryptor { } } -pub fn decrypt_rlwe_tmp_byte(module: &Module, limbs: usize) -> usize { - module.bytes_of_vec_znx_dft(limbs) + module.vec_znx_big_normalize_tmp_bytes() +pub fn decrypt_rlwe_tmp_byte(module: &Module, cols: usize) -> usize { + module.bytes_of_vec_znx_dft(1, cols) + module.vec_znx_big_normalize_tmp_bytes() } impl Parameters { @@ -47,9 +47,9 @@ pub fn decrypt_rlwe(module: &Module, res: &mut Elem, a: &Elem, s decrypt_rlwe_tmp_byte(module, cols) ); - let (tmp_bytes_vec_znx_dft, tmp_bytes_normalize) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(cols)); + let (tmp_bytes_vec_znx_dft, tmp_bytes_normalize) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(1, cols)); - let mut res_dft: VecZnxDft = VecZnxDft::from_bytes_borrow(module, cols, tmp_bytes_vec_znx_dft); + let mut res_dft: VecZnxDft = VecZnxDft::from_bytes_borrow(module, 1, cols, tmp_bytes_vec_znx_dft); let mut res_big: base2k::VecZnxBig = res_dft.as_vec_znx_big(); // res_dft <- DFT(ct[1]) * DFT(sk) diff --git a/rlwe/src/elem.rs b/rlwe/src/elem.rs index 96d11f1..e7e61c4 100644 --- a/rlwe/src/elem.rs +++ b/rlwe/src/elem.rs @@ -1,4 +1,4 @@ -use base2k::{Infos, Module, VecZnx, VecZnxOps, VmpPMat, VmpPMatOps}; +use base2k::{Infos, LAYOUT, Module, VecZnx, VecZnxOps, VmpPMat, VmpPMatOps}; pub struct Elem { pub value: Vec, @@ -71,6 +71,7 @@ pub trait ElemCommon { fn elem(&self) -> &Elem; fn elem_mut(&mut self) -> &mut Elem; fn size(&self) -> usize; + fn layout(&self) -> LAYOUT; fn rows(&self) -> usize; fn cols(&self) -> usize; fn log_base2k(&self) -> usize; @@ -101,6 +102,10 @@ impl ElemCommon for Elem { self.value.len() } + fn layout(&self) -> LAYOUT { + self.value[0].layout() + } + fn rows(&self) -> usize { self.value[0].rows() } @@ -152,7 +157,7 @@ impl Elem { assert!(rows > 0); assert!(cols > 0); let mut value: Vec = Vec::new(); - (0..size).for_each(|_| value.push(module.new_vmp_pmat(rows, cols))); + (0..size).for_each(|_| value.push(module.new_vmp_pmat(1, rows, cols))); Self { value: value, log_q: 0, diff --git a/rlwe/src/encryptor.rs b/rlwe/src/encryptor.rs index b919826..bdb383c 100644 --- a/rlwe/src/encryptor.rs +++ b/rlwe/src/encryptor.rs @@ -108,7 +108,7 @@ impl EncryptorSk { } pub fn encrypt_rlwe_sk_tmp_bytes(module: &Module, log_base2k: usize, log_q: usize) -> usize { - module.bytes_of_vec_znx_dft((log_q + log_base2k - 1) / log_base2k) + module.vec_znx_big_normalize_tmp_bytes() + module.bytes_of_vec_znx_dft(1, (log_q + log_base2k - 1) / log_base2k) + module.vec_znx_big_normalize_tmp_bytes() } pub fn encrypt_rlwe_sk( module: &Module, @@ -151,10 +151,10 @@ fn encrypt_rlwe_sk_core( // c1 <- Z_{2^prec}[X]/(X^{N}+1) module.fill_uniform(log_base2k, c1, cols, source_xa); - let (tmp_bytes_vec_znx_dft, tmp_bytes_normalize) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(cols)); + let (tmp_bytes_vec_znx_dft, tmp_bytes_normalize) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(1, cols)); // Scratch space for DFT values - let mut buf_dft: VecZnxDft = VecZnxDft::from_bytes_borrow(module, cols, tmp_bytes_vec_znx_dft); + let mut buf_dft: VecZnxDft = VecZnxDft::from_bytes_borrow(module, 1, cols, tmp_bytes_vec_znx_dft); // Applies buf_dft <- DFT(s) * DFT(c1) module.svp_apply_dft(&mut buf_dft, sk, c1); diff --git a/rlwe/src/gadget_product.rs b/rlwe/src/gadget_product.rs index 87df6f1..bbf9642 100644 --- a/rlwe/src/gadget_product.rs +++ b/rlwe/src/gadget_product.rs @@ -46,7 +46,7 @@ pub fn gadget_product_core( pub fn gadget_product_big_tmp_bytes(module: &Module, c_cols: usize, a_cols: usize, b_rows: usize, b_cols: usize) -> usize { return module.vmp_apply_dft_to_dft_tmp_bytes(c_cols, a_cols, b_rows, b_cols) - + 2 * module.bytes_of_vec_znx_dft(min(c_cols, a_cols)); + + 2 * module.bytes_of_vec_znx_dft(1, min(c_cols, a_cols)); } /// Evaluates the gadget product: c.at(i) = IDFT() @@ -66,11 +66,11 @@ pub fn gadget_product_big( ) { let cols: usize = min(c.cols(), a.cols()); - let (tmp_bytes_b1_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(cols)); - let (tmp_bytes_res_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(cols)); + let (tmp_bytes_b1_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(1, cols)); + let (tmp_bytes_res_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(1, cols)); - let mut a1_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(cols, tmp_bytes_b1_dft); - let mut res_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(cols, tmp_bytes_res_dft); + let mut a1_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(1, cols, tmp_bytes_b1_dft); + let mut res_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(1, cols, tmp_bytes_res_dft); // a1_dft = DFT(a[1]) module.vec_znx_dft(&mut a1_dft, a.at(1)); @@ -99,11 +99,11 @@ pub fn gadget_product( ) { let cols: usize = min(c.cols(), a.cols()); - let (tmp_bytes_b1_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(cols)); - let (tmp_bytes_res_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(cols)); + let (tmp_bytes_b1_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(1, cols)); + let (tmp_bytes_res_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(1, cols)); - let mut a1_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(cols, tmp_bytes_b1_dft); - let mut res_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(cols, tmp_bytes_res_dft); + let mut a1_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(1, cols, tmp_bytes_b1_dft); + let mut res_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(1, cols, tmp_bytes_res_dft); let mut res_big: VecZnxBig = res_dft.as_vec_znx_big(); // a1_dft = DFT(a[1]) @@ -215,7 +215,7 @@ mod test { let mut elem_res: Elem = Elem::::new(params.module(), log_base2k, params.log_qp(), 2); // Ideal output = a * s - let mut a_dft: VecZnxDft = params.module().new_vec_znx_dft(a.cols()); + let mut a_dft: VecZnxDft = params.module().new_vec_znx_dft(1, a.cols()); let mut a_big: VecZnxBig = a_dft.as_vec_znx_big(); let mut a_times_s: VecZnx = params.module().new_vec_znx(1, a.cols()); @@ -236,8 +236,8 @@ mod test { a_trunc.copy_from(&a); (1..gadget_ct.cols() + 1).for_each(|b_cols| { - let mut res_dft_0: VecZnxDft = params.module().new_vec_znx_dft(b_cols); - let mut res_dft_1: VecZnxDft = params.module().new_vec_znx_dft(b_cols); + let mut res_dft_0: VecZnxDft = params.module().new_vec_znx_dft(1, b_cols); + let mut res_dft_1: VecZnxDft = params.module().new_vec_znx_dft(1, b_cols); let mut res_big_0: VecZnxBig = res_dft_0.as_vec_znx_big(); let mut res_big_1: VecZnxBig = res_dft_1.as_vec_znx_big(); diff --git a/rlwe/src/key_switching.rs b/rlwe/src/key_switching.rs index 46b557a..4e0001a 100644 --- a/rlwe/src/key_switching.rs +++ b/rlwe/src/key_switching.rs @@ -8,8 +8,8 @@ pub fn key_switch_tmp_bytes(module: &Module, log_base2k: usize, res_logq: usize, let in_cols: usize = (in_logq + log_base2k - 1) / log_base2k; let res_cols: usize = (res_logq + log_base2k - 1) / log_base2k; return module.vmp_apply_dft_to_dft_tmp_bytes(res_cols, in_cols, in_cols, gct_cols) - + module.bytes_of_vec_znx_dft(std::cmp::min(res_cols, in_cols)) - + module.bytes_of_vec_znx_dft(gct_cols); + + module.bytes_of_vec_znx_dft(1, std::cmp::min(res_cols, in_cols)) + + module.bytes_of_vec_znx_dft(1, gct_cols); } pub fn key_switch_rlwe( @@ -54,11 +54,11 @@ fn key_switch_rlwe_core( assert_alignement(tmp_bytes.as_ptr()); } - let (tmp_bytes_a1_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(cols)); - let (tmp_bytes_res_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(b_cols)); + let (tmp_bytes_a1_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(1, cols)); + let (tmp_bytes_res_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(1, b_cols)); - let mut a1_dft = module.new_vec_znx_dft_from_bytes_borrow(cols, tmp_bytes_a1_dft); - let mut res_dft = module.new_vec_znx_dft_from_bytes_borrow(b_cols, tmp_bytes_res_dft); + let mut a1_dft = module.new_vec_znx_dft_from_bytes_borrow(1, cols, tmp_bytes_a1_dft); + let mut res_dft = module.new_vec_znx_dft_from_bytes_borrow(1, b_cols, tmp_bytes_res_dft); let mut res_big = res_dft.as_vec_znx_big(); module.vec_znx_dft(&mut a1_dft, a.at(1)); diff --git a/rlwe/src/plaintext.rs b/rlwe/src/plaintext.rs index d7725c3..86f7e32 100644 --- a/rlwe/src/plaintext.rs +++ b/rlwe/src/plaintext.rs @@ -1,7 +1,7 @@ use crate::ciphertext::Ciphertext; use crate::elem::{Elem, ElemCommon, ElemVecZnx}; use crate::parameters::Parameters; -use base2k::{Module, VecZnx}; +use base2k::{LAYOUT, Module, VecZnx}; pub struct Plaintext(pub Elem); @@ -79,6 +79,10 @@ impl ElemCommon for Plaintext { self.elem().size() } + fn layout(&self) -> LAYOUT { + self.elem().layout() + } + fn rows(&self) -> usize { self.0.rows() } diff --git a/rlwe/src/rgsw_product.rs b/rlwe/src/rgsw_product.rs index 71a3cee..dc42602 100644 --- a/rlwe/src/rgsw_product.rs +++ b/rlwe/src/rgsw_product.rs @@ -18,8 +18,8 @@ pub fn rgsw_product_tmp_bytes(module: &Module, log_base2k: usize, res_logq: usiz let in_cols: usize = (in_logq + log_base2k - 1) / log_base2k; let res_cols: usize = (res_logq + log_base2k - 1) / log_base2k; return module.vmp_apply_dft_to_dft_tmp_bytes(res_cols, in_cols, in_cols, gct_cols) - + module.bytes_of_vec_znx_dft(std::cmp::min(res_cols, in_cols)) - + 2 * module.bytes_of_vec_znx_dft(gct_cols); + + module.bytes_of_vec_znx_dft(1, std::cmp::min(res_cols, in_cols)) + + 2 * module.bytes_of_vec_znx_dft(1, gct_cols); } pub fn rgsw_product( @@ -40,13 +40,13 @@ pub fn rgsw_product( assert_alignement(tmp_bytes.as_ptr()); } - let (tmp_bytes_ai_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(a.cols())); - let (tmp_bytes_c0_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(b_cols)); - let (tmp_bytes_c1_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(b_cols)); + let (tmp_bytes_ai_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(1, a.cols())); + let (tmp_bytes_c0_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(1, b_cols)); + let (tmp_bytes_c1_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(1, b_cols)); - let mut ai_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(a.cols(), tmp_bytes_ai_dft); - let mut c0_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(b_cols, tmp_bytes_c0_dft); - let mut c1_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(b_cols, tmp_bytes_c1_dft); + let mut ai_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(1, a.cols(), tmp_bytes_ai_dft); + let mut c0_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(1, b_cols, tmp_bytes_c0_dft); + let mut c1_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(1, b_cols, tmp_bytes_c1_dft); let mut c0_big: VecZnxBig = c0_dft.as_vec_znx_big(); let mut c1_big: VecZnxBig = c1_dft.as_vec_znx_big(); @@ -82,13 +82,13 @@ pub fn rgsw_product_inplace( assert_alignement(tmp_bytes.as_ptr()); } - let (tmp_bytes_ai_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(a.cols())); - let (tmp_bytes_c0_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(b_cols)); - let (tmp_bytes_c1_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(b_cols)); + let (tmp_bytes_ai_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(1, a.cols())); + let (tmp_bytes_c0_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(1, b_cols)); + let (tmp_bytes_c1_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(1, b_cols)); - let mut ai_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(a.cols(), tmp_bytes_ai_dft); - let mut c0_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(b_cols, tmp_bytes_c0_dft); - let mut c1_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(b_cols, tmp_bytes_c1_dft); + let mut ai_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(1, a.cols(), tmp_bytes_ai_dft); + let mut c0_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(1, b_cols, tmp_bytes_c0_dft); + let mut c1_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(1, b_cols, tmp_bytes_c1_dft); let mut c0_big: VecZnxBig = c0_dft.as_vec_znx_big(); let mut c1_big: VecZnxBig = c1_dft.as_vec_znx_big(); diff --git a/rlwe/src/trace.rs b/rlwe/src/trace.rs index 8fc0dc8..9e7feb8 100644 --- a/rlwe/src/trace.rs +++ b/rlwe/src/trace.rs @@ -22,7 +22,7 @@ impl Parameters { pub fn trace_tmp_bytes(module: &Module, c_cols: usize, a_cols: usize, b_rows: usize, b_cols: usize) -> usize { return module.vmp_apply_dft_to_dft_tmp_bytes(c_cols, a_cols, b_rows, b_cols) - + 2 * module.bytes_of_vec_znx_dft(std::cmp::min(c_cols, a_cols)); + + 2 * module.bytes_of_vec_znx_dft(1, std::cmp::min(c_cols, a_cols)); } pub fn trace_inplace( @@ -59,11 +59,11 @@ pub fn trace_inplace( let cols: usize = std::cmp::min(b_cols, a.cols()); - let (tmp_bytes_b1_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(cols)); - let (tmp_bytes_res_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(b_cols)); + let (tmp_bytes_b1_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(1, cols)); + let (tmp_bytes_res_dft, tmp_bytes) = tmp_bytes.split_at_mut(module.bytes_of_vec_znx_dft(1, b_cols)); - let mut a1_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(cols, tmp_bytes_b1_dft); - let mut res_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(b_cols, tmp_bytes_res_dft); + let mut a1_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(1, cols, tmp_bytes_b1_dft); + let mut res_dft: VecZnxDft = module.new_vec_znx_dft_from_bytes_borrow(1, b_cols, tmp_bytes_res_dft); let mut res_big: VecZnxBig = res_dft.as_vec_znx_big(); let log_base2k: usize = a.log_base2k(); diff --git a/sampling/src/source.rs b/sampling/src/source.rs index 9f51df6..c356163 100644 --- a/sampling/src/source.rs +++ b/sampling/src/source.rs @@ -45,7 +45,7 @@ impl Source { min + ((self.next_u64() << 11 >> 11) as f64) / MAXF64 * (max - min) } - pub fn next_i64(&mut self) -> i64{ + pub fn next_i64(&mut self) -> i64 { self.next_u64() as i64 } }