diff --git a/utils/tfhe-backward-compat-data/Cargo.toml b/utils/tfhe-backward-compat-data/Cargo.toml index 95f9a7d19..d2d76618b 100644 --- a/utils/tfhe-backward-compat-data/Cargo.toml +++ b/utils/tfhe-backward-compat-data/Cargo.toml @@ -55,6 +55,13 @@ tfhe_1_3 = { git = "https://github.com/zama-ai/tfhe-rs.git", features = [ "zk-pok", "experimental-force_fft_algo_dif4", ], package = "tfhe", tag = "tfhe-rs-1.3.0", optional = true } +tfhe_1_4 = { path = "../../tfhe", features = [ + "boolean", + "integer", + "shortint", + "zk-pok", + "experimental-force_fft_algo_dif4", +], package = "tfhe", optional = true } # TFHE-rs 0.8 and 0.10 use the same version of versionable @@ -63,6 +70,7 @@ tfhe_0_11-versionable = { version = "0.4.0", optional = true, package = "tfhe-ve tfhe_1_0-versionable = { version = "0.5.0", optional = true, package = "tfhe-versionable" } tfhe_1_1-versionable = { git = "https://github.com/zama-ai/tfhe-rs.git", tag = "tfhe-rs-1.1.0", optional = true, package = "tfhe-versionable" } tfhe_1_3-versionable = { git = "https://github.com/zama-ai/tfhe-rs.git", tag = "tfhe-rs-1.3.0", optional = true, package = "tfhe-versionable" } +tfhe_1_4-versionable = { path = "../../utils/tfhe-versionable", optional = true, package = "tfhe-versionable" } # other deps @@ -87,10 +95,12 @@ generate = [ "dep:tfhe_1_0", "dep:tfhe_1_1", "dep:tfhe_1_3", + "dep:tfhe_1_4", "dep:tfhe-versionable", "dep:tfhe_0_11-versionable", "dep:tfhe_1_0-versionable", "dep:tfhe_1_1-versionable", "dep:tfhe_1_3-versionable", + "dep:tfhe_1_4-versionable", ] load = ["dep:semver"] diff --git a/utils/tfhe-backward-compat-data/data/1_4/high_level_api/client_key_with_noise_squashing.bcode b/utils/tfhe-backward-compat-data/data/1_4/high_level_api/client_key_with_noise_squashing.bcode new file mode 100644 index 000000000..4cfdb110d --- /dev/null +++ b/utils/tfhe-backward-compat-data/data/1_4/high_level_api/client_key_with_noise_squashing.bcode @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4fde99e29edfc15e5f7c9693940706cc6ff3f1ecdc56a759265ff58c46a06265 +size 16718 diff --git a/utils/tfhe-backward-compat-data/data/1_4/high_level_api/client_key_with_noise_squashing.cbor b/utils/tfhe-backward-compat-data/data/1_4/high_level_api/client_key_with_noise_squashing.cbor new file mode 100644 index 000000000..b2a55a117 --- /dev/null +++ b/utils/tfhe-backward-compat-data/data/1_4/high_level_api/client_key_with_noise_squashing.cbor @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0c6cb8493b0e32785a3c0aa809434e59c0aa6bd7395a4b8acd47f9dbbe97dd0d +size 2845 diff --git a/utils/tfhe-backward-compat-data/data/1_4/high_level_api/server_key_with_noise_squashing.bcode b/utils/tfhe-backward-compat-data/data/1_4/high_level_api/server_key_with_noise_squashing.bcode new file mode 100644 index 000000000..ffc00feac --- /dev/null +++ b/utils/tfhe-backward-compat-data/data/1_4/high_level_api/server_key_with_noise_squashing.bcode @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3c2f4f5defbb7e80e1eb0c879c997727da7dedc83bc606f4442ab7720855ad25 +size 1458994 diff --git a/utils/tfhe-backward-compat-data/data/1_4/high_level_api/server_key_with_noise_squashing.cbor b/utils/tfhe-backward-compat-data/data/1_4/high_level_api/server_key_with_noise_squashing.cbor new file mode 100644 index 000000000..352e7b21f --- /dev/null +++ b/utils/tfhe-backward-compat-data/data/1_4/high_level_api/server_key_with_noise_squashing.cbor @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:090343d3114d5de87990cd496f07ce32a23e6906d86968f2c077d5e8bb414770 +size 1706898 diff --git a/utils/tfhe-backward-compat-data/data/1_4/high_level_api/squashed_noise_unsigned_ciphertext.bcode b/utils/tfhe-backward-compat-data/data/1_4/high_level_api/squashed_noise_unsigned_ciphertext.bcode new file mode 100644 index 000000000..394b9283d --- /dev/null +++ b/utils/tfhe-backward-compat-data/data/1_4/high_level_api/squashed_noise_unsigned_ciphertext.bcode @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a275ecba88781266620ed5a6c447f214bb6c271f458a4c0d3d6a4652604b21f7 +size 525104 diff --git a/utils/tfhe-backward-compat-data/data/1_4/high_level_api/squashed_noise_unsigned_ciphertext.cbor b/utils/tfhe-backward-compat-data/data/1_4/high_level_api/squashed_noise_unsigned_ciphertext.cbor new file mode 100644 index 000000000..c64b357bc --- /dev/null +++ b/utils/tfhe-backward-compat-data/data/1_4/high_level_api/squashed_noise_unsigned_ciphertext.cbor @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3700ccf4058c5f453a3e44d446d20fb7c3f849fa689ddb1023b3b035bd16bd63 +size 590873 diff --git a/utils/tfhe-backward-compat-data/data/high_level_api.ron b/utils/tfhe-backward-compat-data/data/high_level_api.ron index 0131445d1..15c286a93 100644 --- a/utils/tfhe-backward-compat-data/data/high_level_api.ron +++ b/utils/tfhe-backward-compat-data/data/high_level_api.ron @@ -638,4 +638,51 @@ ], )), ), + ( + tfhe_version_min: "1.4", + tfhe_module: "high_level_api", + metadata: HlClientKey(( + test_filename: "client_key_with_noise_squashing", + parameters: TestMultiBitParameterSet(( + lwe_dimension: 4, + glwe_dimension: 1, + polynomial_size: 2048, + lwe_noise_distribution: TUniform( + bound_log2: 45, + ), + glwe_noise_distribution: TUniform( + bound_log2: 17, + ), + pbs_base_log: 22, + pbs_level: 1, + ks_base_log: 3, + ks_level: 5, + message_modulus: 4, + ciphertext_modulus: 18446744073709551616, + carry_modulus: 4, + max_noise_level: 5, + log2_p_fail: -134.345, + encryption_key_choice: "big", + grouping_factor: 4, + )), + )), + ), + ( + tfhe_version_min: "1.4", + tfhe_module: "high_level_api", + metadata: HlServerKey(( + test_filename: "server_key_with_noise_squashing", + client_key_filename: "client_key_with_noise_squashing", + compressed: false, + )), + ), + ( + tfhe_version_min: "1.4", + tfhe_module: "high_level_api", + metadata: HlSquashedNoiseUnsignedCiphertext(( + test_filename: "squashed_noise_unsigned_ciphertext", + key_filename: "client_key_with_noise_squashing", + clear_value: 42, + )), + ), ] \ No newline at end of file diff --git a/utils/tfhe-backward-compat-data/src/data_1_4.rs b/utils/tfhe-backward-compat-data/src/data_1_4.rs new file mode 100644 index 000000000..cfec3ee8b --- /dev/null +++ b/utils/tfhe-backward-compat-data/src/data_1_4.rs @@ -0,0 +1,304 @@ +use crate::generate::{ + store_versioned_test_tfhe_1_4, TfhersVersion, + INSECURE_SMALL_TEST_NOISE_SQUASHING_PARAMS_MULTI_BIT, INSECURE_SMALL_TEST_PARAMS_MULTI_BIT, +}; +use crate::{ + HlClientKeyTest, HlServerKeyTest, HlSquashedNoiseUnsignedCiphertextTest, + TestClassicParameterSet, TestDistribution, TestMetadata, TestModulusSwitchNoiseReductionParams, + TestModulusSwitchType, TestMultiBitParameterSet, TestNoiseSquashingParamsMultiBit, + TestParameterSet, HL_MODULE_NAME, +}; +use std::borrow::Cow; +use std::fs::create_dir_all; + +use tfhe_1_4::boolean::engine::BooleanEngine; +use tfhe_1_4::core_crypto::commons::generators::DeterministicSeeder; + +use tfhe_1_4::core_crypto::prelude::DefaultRandomGenerator; +use tfhe_1_4::prelude::*; +use tfhe_1_4::shortint::engine::ShortintEngine; +use tfhe_1_4::shortint::parameters::noise_squashing::NoiseSquashingMultiBitParameters; +use tfhe_1_4::shortint::parameters::{ + CarryModulus, CiphertextModulus, CoreCiphertextModulus, DecompositionBaseLog, + DecompositionLevelCount, DynamicDistribution, EncryptionKeyChoice, GlweDimension, + LweBskGroupingFactor, LweCiphertextCount, LweDimension, MaxNoiseLevel, MessageModulus, + ModulusSwitchNoiseReductionParams, ModulusSwitchType, NoiseEstimationMeasureBound, + NoiseSquashingParameters, PolynomialSize, RSigmaFactor, StandardDev, Variance, +}; +use tfhe_1_4::shortint::{AtomicPatternParameters, ClassicPBSParameters, MultiBitPBSParameters}; +use tfhe_1_4::{set_server_key, ClientKey, FheUint32, Seed, ServerKey}; + +macro_rules! store_versioned_test { + ($msg:expr, $dir:expr, $test_filename:expr $(,)? ) => { + store_versioned_test_tfhe_1_4($msg, $dir, $test_filename) + }; +} + +impl From for DynamicDistribution { + fn from(value: TestDistribution) -> Self { + match value { + TestDistribution::Gaussian { stddev } => { + DynamicDistribution::new_gaussian_from_std_dev(StandardDev(stddev)) + } + TestDistribution::TUniform { bound_log2 } => { + DynamicDistribution::new_t_uniform(bound_log2) + } + } + } +} + +impl From for DynamicDistribution { + fn from(value: TestDistribution) -> Self { + match value { + TestDistribution::Gaussian { stddev } => { + DynamicDistribution::new_gaussian_from_std_dev(StandardDev(stddev)) + } + TestDistribution::TUniform { bound_log2 } => { + DynamicDistribution::new_t_uniform(bound_log2) + } + } + } +} + +impl From for ModulusSwitchNoiseReductionParams { + fn from(value: TestModulusSwitchNoiseReductionParams) -> Self { + let TestModulusSwitchNoiseReductionParams { + modulus_switch_zeros_count, + ms_bound, + ms_r_sigma_factor, + ms_input_variance, + } = value; + + ModulusSwitchNoiseReductionParams { + modulus_switch_zeros_count: LweCiphertextCount(modulus_switch_zeros_count), + ms_bound: NoiseEstimationMeasureBound(ms_bound), + ms_r_sigma_factor: RSigmaFactor(ms_r_sigma_factor), + ms_input_variance: Variance(ms_input_variance), + } + } +} + +impl From for ModulusSwitchType { + fn from(value: TestModulusSwitchType) -> Self { + match value { + TestModulusSwitchType::Standard => ModulusSwitchType::Standard, + TestModulusSwitchType::DriftTechniqueNoiseReduction( + test_modulus_switch_noise_reduction_params, + ) => ModulusSwitchType::DriftTechniqueNoiseReduction( + test_modulus_switch_noise_reduction_params.into(), + ), + TestModulusSwitchType::CenteredMeanNoiseReduction => { + ModulusSwitchType::CenteredMeanNoiseReduction + } + } + } +} + +impl From for ClassicPBSParameters { + fn from(value: TestClassicParameterSet) -> Self { + ClassicPBSParameters { + lwe_dimension: LweDimension(value.lwe_dimension), + glwe_dimension: GlweDimension(value.glwe_dimension), + polynomial_size: PolynomialSize(value.polynomial_size), + lwe_noise_distribution: value.lwe_noise_distribution.into(), + glwe_noise_distribution: value.glwe_noise_distribution.into(), + pbs_base_log: DecompositionBaseLog(value.pbs_base_log), + pbs_level: DecompositionLevelCount(value.pbs_level), + ks_base_log: DecompositionBaseLog(value.ks_base_log), + ks_level: DecompositionLevelCount(value.ks_level), + message_modulus: MessageModulus(value.message_modulus as u64), + carry_modulus: CarryModulus(value.carry_modulus as u64), + max_noise_level: MaxNoiseLevel::new(value.max_noise_level as u64), + log2_p_fail: value.log2_p_fail, + ciphertext_modulus: CiphertextModulus::try_new(value.ciphertext_modulus).unwrap(), + encryption_key_choice: { + match &*value.encryption_key_choice { + "big" => EncryptionKeyChoice::Big, + "small" => EncryptionKeyChoice::Small, + _ => panic!("Invalid encryption key choice"), + } + }, + modulus_switch_noise_reduction_params: value + .modulus_switch_noise_reduction_params + .into(), + } + } +} + +impl From for MultiBitPBSParameters { + fn from(value: TestMultiBitParameterSet) -> Self { + let TestMultiBitParameterSet { + lwe_dimension, + glwe_dimension, + polynomial_size, + lwe_noise_distribution, + glwe_noise_distribution, + pbs_base_log, + pbs_level, + ks_base_log, + ks_level, + message_modulus, + ciphertext_modulus, + carry_modulus, + max_noise_level, + log2_p_fail, + encryption_key_choice, + grouping_factor, + } = value; + + MultiBitPBSParameters { + lwe_dimension: LweDimension(lwe_dimension), + glwe_dimension: GlweDimension(glwe_dimension), + polynomial_size: PolynomialSize(polynomial_size), + lwe_noise_distribution: lwe_noise_distribution.into(), + glwe_noise_distribution: glwe_noise_distribution.into(), + pbs_base_log: DecompositionBaseLog(pbs_base_log), + pbs_level: DecompositionLevelCount(pbs_level), + ks_base_log: DecompositionBaseLog(ks_base_log), + ks_level: DecompositionLevelCount(ks_level), + message_modulus: MessageModulus(message_modulus as u64), + carry_modulus: CarryModulus(carry_modulus as u64), + max_noise_level: MaxNoiseLevel::new(max_noise_level as u64), + log2_p_fail, + ciphertext_modulus: CiphertextModulus::try_new(ciphertext_modulus).unwrap(), + encryption_key_choice: { + match &*encryption_key_choice { + "big" => EncryptionKeyChoice::Big, + "small" => EncryptionKeyChoice::Small, + _ => panic!("Invalid encryption key choice"), + } + }, + grouping_factor: LweBskGroupingFactor(grouping_factor), + deterministic_execution: false, + } + } +} + +impl From for AtomicPatternParameters { + fn from(value: TestParameterSet) -> Self { + match value { + TestParameterSet::TestClassicParameterSet(test_classic_parameter_set) => { + let classic = ClassicPBSParameters::from(test_classic_parameter_set); + + classic.into() + } + TestParameterSet::TestMultiBitParameterSet(test_parameter_set_multi_bit) => { + let classic = MultiBitPBSParameters::from(test_parameter_set_multi_bit); + + classic.into() + } + } + } +} + +impl From for NoiseSquashingParameters { + fn from(value: TestNoiseSquashingParamsMultiBit) -> Self { + let TestNoiseSquashingParamsMultiBit { + glwe_dimension, + polynomial_size, + glwe_noise_distribution, + decomp_base_log, + decomp_level_count, + grouping_factor, + message_modulus, + carry_modulus, + ciphertext_modulus, + } = value; + + Self::MultiBit(NoiseSquashingMultiBitParameters { + glwe_dimension: GlweDimension(glwe_dimension), + polynomial_size: PolynomialSize(polynomial_size), + glwe_noise_distribution: glwe_noise_distribution.into(), + decomp_base_log: DecompositionBaseLog(decomp_base_log), + decomp_level_count: DecompositionLevelCount(decomp_level_count), + grouping_factor: LweBskGroupingFactor(grouping_factor), + message_modulus: MessageModulus(message_modulus as u64), + carry_modulus: CarryModulus(carry_modulus as u64), + ciphertext_modulus: CoreCiphertextModulus::try_new(ciphertext_modulus).unwrap(), + deterministic_execution: false, + }) + } +} + +const TEST_FILENAME: Cow<'static, str> = Cow::Borrowed("client_key_with_noise_squashing"); + +const HL_CLIENTKEY_WITH_NOISE_SQUASHING_TEST: HlClientKeyTest = HlClientKeyTest { + test_filename: TEST_FILENAME, + parameters: INSECURE_SMALL_TEST_PARAMS_MULTI_BIT, +}; + +const HL_SERVERKEY_TEST: HlServerKeyTest = HlServerKeyTest { + test_filename: Cow::Borrowed("server_key_with_noise_squashing"), + client_key_filename: TEST_FILENAME, + compressed: false, +}; + +const HL_SQUASHED_NOISE_UNSIGNED_CIPHERTEXT_TEST: HlSquashedNoiseUnsignedCiphertextTest = + HlSquashedNoiseUnsignedCiphertextTest { + test_filename: Cow::Borrowed("squashed_noise_unsigned_ciphertext"), + key_filename: TEST_FILENAME, + clear_value: 42, + }; + +pub struct V1_4; + +impl TfhersVersion for V1_4 { + const VERSION_NUMBER: &'static str = "1.4"; + + fn seed_prng(seed: u128) { + let mut seeder = DeterministicSeeder::::new(Seed(seed)); + let shortint_engine = ShortintEngine::new_from_seeder(&mut seeder); + ShortintEngine::with_thread_local_mut(|local_engine| { + let _ = std::mem::replace(local_engine, shortint_engine); + }); + + let boolean_engine = BooleanEngine::new_from_seeder(&mut seeder); + BooleanEngine::replace_thread_local(boolean_engine); + } + + fn gen_shortint_data() -> Vec { + Vec::new() + } + + fn gen_hl_data() -> Vec { + let dir = Self::data_dir().join(HL_MODULE_NAME); + create_dir_all(&dir).unwrap(); + + let config = tfhe_1_4::ConfigBuilder::with_custom_parameters( + HL_CLIENTKEY_WITH_NOISE_SQUASHING_TEST.parameters, + ) + .enable_noise_squashing(INSECURE_SMALL_TEST_NOISE_SQUASHING_PARAMS_MULTI_BIT.into()) + .build(); + let hl_client_key = ClientKey::generate(config); + let hl_server_key = ServerKey::new(&hl_client_key); + set_server_key(hl_server_key.clone()); + + let input = FheUint32::encrypt( + HL_SQUASHED_NOISE_UNSIGNED_CIPHERTEXT_TEST.clear_value as u32, + &hl_client_key, + ); + + let ns = input.squash_noise().unwrap(); + + store_versioned_test!( + &hl_client_key, + &dir, + &HL_CLIENTKEY_WITH_NOISE_SQUASHING_TEST.test_filename + ); + store_versioned_test!(&hl_server_key, &dir, &HL_SERVERKEY_TEST.test_filename,); + + store_versioned_test!( + &ns, + &dir, + &HL_SQUASHED_NOISE_UNSIGNED_CIPHERTEXT_TEST.test_filename, + ); + + vec![ + TestMetadata::HlClientKey(HL_CLIENTKEY_WITH_NOISE_SQUASHING_TEST), + TestMetadata::HlServerKey(HL_SERVERKEY_TEST), + TestMetadata::HlSquashedNoiseUnsignedCiphertext( + HL_SQUASHED_NOISE_UNSIGNED_CIPHERTEXT_TEST, + ), + ] + } +} diff --git a/utils/tfhe-backward-compat-data/src/generate.rs b/utils/tfhe-backward-compat-data/src/generate.rs index ac8cafffa..a6bcb0827 100644 --- a/utils/tfhe-backward-compat-data/src/generate.rs +++ b/utils/tfhe-backward-compat-data/src/generate.rs @@ -8,12 +8,14 @@ use tfhe_0_11_versionable::Versionize as VersionizeTfhe_0_11; use tfhe_1_0_versionable::Versionize as VersionizeTfhe_1_0; use tfhe_1_1_versionable::Versionize as VersionizeTfhe_1_1; use tfhe_1_3_versionable::Versionize as VersionizeTfhe_1_3; +use tfhe_1_4_versionable::Versionize as VersionizeTfhe_1_4; use tfhe_versionable::{Versionize as VersionizeTfhe_0_10, Versionize as VersionizeTfhe_0_8}; use crate::{ data_dir, dir_for_version, TestClassicParameterSet, TestCompressionParameterSet, TestDistribution, TestMetadata, TestModulusSwitchNoiseReductionParams, TestModulusSwitchType, - TestNoiseSquashingCompressionParameters, TestNoiseSquashingParams, TestParameterSet, + TestMultiBitParameterSet, TestNoiseSquashingCompressionParameters, TestNoiseSquashingParams, + TestNoiseSquashingParamsMultiBit, TestParameterSet, }; pub const PRNG_SEED: u128 = 0xdeadbeef; @@ -137,6 +139,27 @@ pub const INSECURE_SMALL_TEST_PARAMS_MS_MEAN_COMPENSATION: TestParameterSet = modulus_switch_noise_reduction_params: TestModulusSwitchType::CenteredMeanNoiseReduction, }); +/// Those parameters are insecure and are used to generate small legacy public keys +pub const INSECURE_SMALL_TEST_PARAMS_MULTI_BIT: TestParameterSet = + TestParameterSet::from_multi(TestMultiBitParameterSet { + lwe_dimension: 4, + glwe_dimension: 1, + polynomial_size: 2048, + lwe_noise_distribution: TestDistribution::TUniform { bound_log2: 45 }, + glwe_noise_distribution: TestDistribution::TUniform { bound_log2: 17 }, + pbs_base_log: 22, + pbs_level: 1, + ks_base_log: 3, + ks_level: 5, + message_modulus: 4, + carry_modulus: 4, + max_noise_level: 5, + log2_p_fail: -134.345, + ciphertext_modulus: 1 << 64, + encryption_key_choice: Cow::Borrowed("big"), + grouping_factor: 4, + }); + /// Those parameters are insecure and are used to generate small legacy public keys /// Got with the above parameters for noise squashing pub const INSECURE_SMALL_TEST_NOISE_SQUASHING_PARAMS_MS_NOISE_REDUCTION: TestNoiseSquashingParams = @@ -171,6 +194,20 @@ pub const TEST_PRAMS_NOISE_SQUASHING_COMPRESSION: TestNoiseSquashingCompressionP ciphertext_modulus: 0, // native modulus for u128 }; +pub const INSECURE_SMALL_TEST_NOISE_SQUASHING_PARAMS_MULTI_BIT: TestNoiseSquashingParamsMultiBit = + TestNoiseSquashingParamsMultiBit { + glwe_dimension: 2, + polynomial_size: 2048, + glwe_noise_distribution: TestDistribution::TUniform { bound_log2: 30 }, + decomp_base_log: 23, + decomp_level_count: 3, + grouping_factor: 4, + message_modulus: 4, + carry_modulus: 4, + // 0 interpreted as native modulus for u128 + ciphertext_modulus: 0, + }; + // Compression parameters for 2_2 TUniform pub const VALID_TEST_PARAMS_TUNIFORM_COMPRESSION: TestCompressionParameterSet = TestCompressionParameterSet { @@ -260,6 +297,7 @@ define_store_versioned_test_fn!(store_versioned_test_tfhe_0_11, VersionizeTfhe_0 define_store_versioned_test_fn!(store_versioned_test_tfhe_1_0, VersionizeTfhe_1_0); define_store_versioned_test_fn!(store_versioned_test_tfhe_1_1, VersionizeTfhe_1_1); define_store_versioned_test_fn!(store_versioned_test_tfhe_1_3, VersionizeTfhe_1_3); +define_store_versioned_test_fn!(store_versioned_test_tfhe_1_4, VersionizeTfhe_1_4); /// Stores the auxiliary data in `dir`, encoded in cbor, using the right tfhe-versionable version macro_rules! define_store_versioned_auxiliary_fn { @@ -281,6 +319,7 @@ define_store_versioned_auxiliary_fn!(store_versioned_auxiliary_tfhe_0_8, Version define_store_versioned_auxiliary_fn!(store_versioned_auxiliary_tfhe_0_10, VersionizeTfhe_0_10); define_store_versioned_auxiliary_fn!(store_versioned_auxiliary_tfhe_0_11, VersionizeTfhe_0_11); define_store_versioned_auxiliary_fn!(store_versioned_auxiliary_tfhe_1_3, VersionizeTfhe_1_3); +define_store_versioned_auxiliary_fn!(store_versioned_auxiliary_tfhe_1_4, VersionizeTfhe_1_4); pub fn store_metadata>(value: &Meta, path: P) { let serialized = ron::ser::to_string_pretty(value, ron::ser::PrettyConfig::default()).unwrap(); diff --git a/utils/tfhe-backward-compat-data/src/lib.rs b/utils/tfhe-backward-compat-data/src/lib.rs index 443f68075..7e41321a6 100644 --- a/utils/tfhe-backward-compat-data/src/lib.rs +++ b/utils/tfhe-backward-compat-data/src/lib.rs @@ -23,6 +23,8 @@ pub mod data_1_1; #[cfg(feature = "generate")] pub mod data_1_3; #[cfg(feature = "generate")] +pub mod data_1_4; +#[cfg(feature = "generate")] pub mod generate; #[cfg(feature = "load")] pub mod load; diff --git a/utils/tfhe-backward-compat-data/src/main.rs b/utils/tfhe-backward-compat-data/src/main.rs index c322fd786..027504604 100644 --- a/utils/tfhe-backward-compat-data/src/main.rs +++ b/utils/tfhe-backward-compat-data/src/main.rs @@ -6,6 +6,7 @@ use tfhe_backward_compat_data::data_0_8::V0_8; use tfhe_backward_compat_data::data_1_0::V1_0; use tfhe_backward_compat_data::data_1_1::V1_1; use tfhe_backward_compat_data::data_1_3::V1_3; +use tfhe_backward_compat_data::data_1_4::V1_4; use tfhe_backward_compat_data::generate::{store_metadata, TfhersVersion, PRNG_SEED}; use tfhe_backward_compat_data::{data_dir, Testcase, HL_MODULE_NAME, SHORTINT_MODULE_NAME}; @@ -45,6 +46,7 @@ fn main() { let handler_v1_0 = thread::spawn(gen_all_data::); let handler_v1_1 = thread::spawn(gen_all_data::); let handler_v1_3 = thread::spawn(gen_all_data::); + let handler_v1_4 = thread::spawn(gen_all_data::); let mut testcases = vec![]; @@ -54,6 +56,7 @@ fn main() { testcases.extend_from_slice(&handler_v1_0.join().unwrap()); testcases.extend_from_slice(&handler_v1_1.join().unwrap()); testcases.extend_from_slice(&handler_v1_3.join().unwrap()); + testcases.extend_from_slice(&handler_v1_4.join().unwrap()); let shortint_testcases: Vec = testcases .iter()