Backport 0.5.2

.github/workflows/aws_tfhe_gpu_tests.yml

@@ -106,3 +106,7 @@ jobs:
       - name: Run user docs tests
         run: |
           make test_user_doc_gpu
+
+      - name: Test C API
+        run: |
+          make test_c_api_gpu

.github/workflows/cargo_build.yml

@@ -18,7 +18,7 @@ jobs:
 
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
+        os: [ubuntu-latest, macos-latest-large, windows-latest]
       fail-fast: false
 
     steps:

Makefile

@@ -179,6 +179,12 @@ clippy_core: install_rs_check_toolchain
 	RUSTFLAGS="$(RUSTFLAGS)" cargo "$(CARGO_RS_CHECK_TOOLCHAIN)" clippy \
 		--features=$(TARGET_ARCH_FEATURE),experimental \
 		-p $(TFHE_SPEC) -- --no-deps -D warnings
+	RUSTFLAGS="$(RUSTFLAGS)" cargo "$(CARGO_RS_CHECK_TOOLCHAIN)" clippy \
+		--features=$(TARGET_ARCH_FEATURE),nightly-avx512 \
+		-p $(TFHE_SPEC) -- --no-deps -D warnings
+	RUSTFLAGS="$(RUSTFLAGS)" cargo "$(CARGO_RS_CHECK_TOOLCHAIN)" clippy \
+		--features=$(TARGET_ARCH_FEATURE),experimental,nightly-avx512 \
+		-p $(TFHE_SPEC) -- --no-deps -D warnings
 
 .PHONY: clippy_boolean # Run clippy lints enabling the boolean features
 clippy_boolean: install_rs_check_toolchain
@@ -297,6 +303,13 @@ build_c_api: install_rs_check_toolchain
 		-p $(TFHE_SPEC)
 	@"$(MAKE)" symlink_c_libs_without_fingerprint
 
+.PHONY: build_c_api_gpu # Build the C API for boolean, shortint and integer
+build_c_api_gpu: install_rs_check_toolchain
+	RUSTFLAGS="$(RUSTFLAGS)" cargo $(CARGO_RS_CHECK_TOOLCHAIN) build --profile $(CARGO_PROFILE) \
+		--features=$(TARGET_ARCH_FEATURE),boolean-c-api,shortint-c-api,high-level-c-api,gpu \
+		-p $(TFHE_SPEC)
+	@"$(MAKE)" symlink_c_libs_without_fingerprint
+
 .PHONY: build_c_api_experimental_deterministic_fft # Build the C API for boolean, shortint and integer with experimental deterministic FFT
 build_c_api_experimental_deterministic_fft: install_rs_check_toolchain
 	RUSTFLAGS="$(RUSTFLAGS)" cargo $(CARGO_RS_CHECK_TOOLCHAIN) build --profile $(CARGO_PROFILE) \
@@ -400,6 +413,10 @@ test_c_api_c: build_c_api
 .PHONY: test_c_api # Run all the tests for the C API
 test_c_api: test_c_api_rs test_c_api_c
 
+.PHONY: test_c_api_gpu # Run the C tests for the C API
+test_c_api_gpu: build_c_api_gpu
+	./scripts/c_api_tests.sh --gpu
+
 .PHONY: test_shortint_ci # Run the tests for shortint ci
 test_shortint_ci: install_rs_build_toolchain install_cargo_nextest
 	BIG_TESTS_INSTANCE="$(BIG_TESTS_INSTANCE)" \

scripts/c_api_tests.sh

@@ -7,11 +7,12 @@ function usage() {
     echo
     echo "--help                    Print this message"
     echo "--build-only              Pass to only build the tests without running them"
+    echo "--gpu                     Enable GPU support"
     echo
 }
 
 BUILD_ONLY=0
-
+WITH_FEATURE_GPU="OFF"
 while [ -n "$1" ]
 do
    case "$1" in
@@ -24,6 +25,9 @@ do
             BUILD_ONLY=1
             ;;
 
+        "--gpu" )
+            WITH_FEATURE_GPU="ON"
+            ;;
         *)
             echo "Unknown param : $1"
             exit 1
@@ -40,7 +44,7 @@ mkdir -p "${TFHE_BUILD_DIR}"
 
 cd "${TFHE_BUILD_DIR}"
 
-cmake .. -DCMAKE_BUILD_TYPE=RELEASE -DCARGO_PROFILE="${CARGO_PROFILE}"
+cmake .. -DCMAKE_BUILD_TYPE=RELEASE -DCARGO_PROFILE="${CARGO_PROFILE}" -DWITH_FEATURE_GPU="${WITH_FEATURE_GPU}"
 
 make -j
 
@@ -55,5 +59,8 @@ if [[ $(uname) == "Darwin" ]]; then
     nproc_bin="sysctl -n hw.logicalcpu"
 fi
 
-# Let's go parallel
-ARGS="-j$(${nproc_bin})" make test
+if [ "${WITH_FEATURE_GPU}" == "ON" ]; then
+    ctest --output-on-failure --test-dir "." --parallel "$(${nproc_bin})" --tests-regex ".*cuda.*"
+else
+    ctest --output-on-failure --test-dir "." --parallel "$(${nproc_bin})" --exclude-regex ".*cuda.*"
+fi

tasks/src/format_latex_doc.rs

@@ -196,7 +196,7 @@ fn find_contiguous_doc_test<'a>(
 
 fn find_contiguous_part_in_doc_test_or_comment(
     part_is_code_block: bool,
-    full_doc_comment_content: &Vec<CommentContent>,
+    full_doc_comment_content: &[CommentContent],
     part_start_idx: usize,
 ) -> (usize, usize) {
     let mut next_line_idx = part_start_idx + 1;
@@ -348,7 +348,7 @@ fn process_doc_lines_until_impossible<'a>(
 }
 
 fn process_non_doc_lines_until_impossible(
-    lines: &Vec<&str>,
+    lines: &[&str],
     rewritten_content: &mut String,
     mut line_idx: usize,
 ) -> usize {

tfhe/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tfhe"
-version = "0.5.1"
+version = "0.5.2"
 edition = "2021"
 readme = "../README.md"
 keywords = ["fully", "homomorphic", "encryption", "fhe", "cryptography"]
@@ -60,9 +60,9 @@ lazy_static = { version = "1.4.0", optional = true }
 serde = { version = "1.0", features = ["derive"] }
 rayon = { version = "1.5.0" }
 bincode = "1.3.3"
-concrete-fft = { version = "0.3.0", features = ["serde", "fft128"] }
-pulp = "0.13"
-tfhe-cuda-backend = { version = "0.1.3", path = "../backends/tfhe-cuda-backend", optional = true }
+concrete-fft = { version = "0.4.0", features = ["serde", "fft128"] }
+pulp = "0.18.8"
+tfhe-cuda-backend = { version = "0.1.2", path = "../backends/tfhe-cuda-backend", optional = true }
 aligned-vec = { version = "0.5", features = ["serde"] }
 dyn-stack = { version = "0.9" }
 paste = "1.0.7"
@@ -79,7 +79,7 @@ js-sys = { version = "0.3", optional = true }
 console_error_panic_hook = { version = "0.1.7", optional = true }
 serde-wasm-bindgen = { version = "0.6.0", optional = true }
 getrandom = { version = "0.2.8", optional = true }
-bytemuck = "1.13.1"
+bytemuck = "1.14.3"
 
 [features]
 boolean = []

tfhe/benches/integer/bench.rs

@@ -3,14 +3,15 @@
 #[path = "../utilities.rs"]
 mod utilities;
 
-use crate::utilities::{write_to_json, OperatorType};
+use crate::utilities::{write_to_json, EnvConfig, OperatorType};
 use std::env;
 
 use criterion::{criterion_group, Criterion};
 use itertools::iproduct;
 use rand::prelude::*;
 use rand::Rng;
 use std::vec::IntoIter;
+use tfhe::core_crypto::algorithms::misc::divide_ceil;
 use tfhe::integer::keycache::KEY_CACHE;
 use tfhe::integer::{IntegerKeyKind, RadixCiphertext, RadixClientKey, ServerKey};
 use tfhe::keycache::NamedParam;
@@ -28,9 +29,6 @@ use tfhe::shortint::parameters::{
 /// It must be as big as the largest bit size tested
 type ScalarType = U256;
 
-const FAST_BENCH_BIT_SIZES: [usize; 1] = [32];
-const BENCH_BIT_SIZES: [usize; 7] = [8, 16, 32, 40, 64, 128, 256];
-
 fn gen_random_u256(rng: &mut ThreadRng) -> U256 {
     let clearlow = rng.gen::<u128>();
     let clearhigh = rng.gen::<u128>();
@@ -48,37 +46,15 @@ struct ParamsAndNumBlocksIter {
 
 impl Default for ParamsAndNumBlocksIter {
     fn default() -> Self {
-        let is_multi_bit = match env::var("__TFHE_RS_BENCH_TYPE") {
-            Ok(val) => val.to_lowercase() == "multi_bit",
-            Err(_) => false,
-        };
-
-        let is_fast_bench = match env::var("__TFHE_RS_FAST_BENCH") {
-            Ok(val) => val.to_lowercase() == "true",
-            Err(_) => false,
-        };
-
-        let bit_sizes = if is_fast_bench {
-            FAST_BENCH_BIT_SIZES.to_vec()
-        } else {
-            BENCH_BIT_SIZES.to_vec()
-        };
+        let env_config = EnvConfig::new();
 
-        if is_multi_bit {
+        if env_config.is_multi_bit {
             #[cfg(feature = "gpu")]
             let params = vec![PARAM_MULTI_BIT_MESSAGE_2_CARRY_2_GROUP_3_KS_PBS.into()];
             #[cfg(not(feature = "gpu"))]
             let params = vec![PARAM_MULTI_BIT_MESSAGE_2_CARRY_2_GROUP_2_KS_PBS.into()];
 
-            let bit_sizes = if is_fast_bench {
-                vec![32]
-            } else if cfg!(feature = "gpu") {
-                BENCH_BIT_SIZES.to_vec()
-            } else {
-                vec![8, 16, 32, 40, 64]
-            };
-
-            let params_and_bit_sizes = iproduct!(params, bit_sizes);
+            let params_and_bit_sizes = iproduct!(params, env_config.bit_sizes());
             Self {
                 params_and_bit_sizes,
             }
@@ -91,7 +67,7 @@ impl Default for ParamsAndNumBlocksIter {
                 // PARAM_MESSAGE_4_CARRY_4_KS_PBS.into(),
             ];
 
-            let params_and_bit_sizes = iproduct!(params, bit_sizes);
+            let params_and_bit_sizes = iproduct!(params, env_config.bit_sizes());
             Self {
                 params_and_bit_sizes,
             }
@@ -585,7 +561,7 @@ fn ciphertexts_sum_parallelized(c: &mut Criterion) {
             bench_group.bench_function(&bench_id, |b| {
                 let (cks, sks) = KEY_CACHE.get_from_params(param, IntegerKeyKind::Radix);
 
-                let nb_ctxt = bit_size.div_ceil(param.message_modulus().0.ilog2() as usize);
+                let nb_ctxt = divide_ceil(bit_size, param.message_modulus().0.ilog2() as usize);
                 let cks = RadixClientKey::from((cks, nb_ctxt));
 
                 let encrypt_values = || {
@@ -1095,12 +1071,6 @@ define_server_key_bench_unary_default_fn!(method_name: abs_parallelized, display
 
 define_server_key_bench_unary_default_fn!(method_name: unchecked_abs_parallelized, display_name: abs);
 
-define_server_key_bench_unary_fn!(method_name: full_propagate, display_name: carry_propagation);
-define_server_key_bench_unary_fn!(
-    method_name: full_propagate_parallelized,
-    display_name: carry_propagation
-);
-
 define_server_key_bench_default_fn!(method_name: unchecked_max, display_name: max);
 define_server_key_bench_default_fn!(method_name: unchecked_min, display_name: min);
 define_server_key_bench_default_fn!(method_name: unchecked_eq, display_name: equal);
@@ -2146,6 +2116,92 @@ criterion_group!(
     unchecked_scalar_ge_parallelized,
 );
 
+//================================================================================
+//     Miscellaneous Benches
+//================================================================================
+
+fn bench_server_key_cast_function<F>(
+    c: &mut Criterion,
+    bench_name: &str,
+    display_name: &str,
+    cast_op: F,
+) where
+    F: Fn(&ServerKey, RadixCiphertext, usize),
+{
+    let mut bench_group = c.benchmark_group(bench_name);
+    bench_group
+        .sample_size(15)
+        .measurement_time(std::time::Duration::from_secs(30));
+    let mut rng = rand::thread_rng();
+
+    let env_config = EnvConfig::new();
+
+    for (param, num_blocks, bit_size) in ParamsAndNumBlocksIter::default() {
+        let all_num_blocks = env_config
+            .bit_sizes()
+            .iter()
+            .copied()
+            .map(|bit| divide_ceil(bit, param.message_modulus().0.ilog2() as usize))
+            .collect::<Vec<_>>();
+        let param_name = param.name();
+
+        for target_num_blocks in all_num_blocks.iter().copied() {
+            let target_bit_size = target_num_blocks * param.message_modulus().0.ilog2() as usize;
+            let bench_id = format!("{bench_name}::{param_name}::{bit_size}_to_{target_bit_size}");
+            bench_group.bench_function(&bench_id, |b| {
+                let (cks, sks) = KEY_CACHE.get_from_params(param, IntegerKeyKind::Radix);
+
+                let encrypt_one_value = || cks.encrypt_radix(gen_random_u256(&mut rng), num_blocks);
+
+                b.iter_batched(
+                    encrypt_one_value,
+                    |ct| {
+                        cast_op(&sks, ct, target_num_blocks);
+                    },
+                    criterion::BatchSize::SmallInput,
+                )
+            });
+
+            write_to_json::<u64, _>(
+                &bench_id,
+                param,
+                param.name(),
+                display_name,
+                &OperatorType::Atomic,
+                bit_size as u32,
+                vec![param.message_modulus().0.ilog2(); num_blocks],
+            );
+        }
+    }
+
+    bench_group.finish()
+}
+
+macro_rules! define_server_key_bench_cast_fn (
+  (method_name: $server_key_method:ident, display_name:$name:ident) => {
+      fn $server_key_method(c: &mut Criterion) {
+        bench_server_key_cast_function(
+              c,
+              concat!("integer::", stringify!($server_key_method)),
+              stringify!($name),
+              |server_key, lhs, rhs| {
+                server_key.$server_key_method(lhs, rhs);
+          })
+      }
+  }
+);
+
+define_server_key_bench_cast_fn!(method_name: cast_to_unsigned, display_name: cast_to_unsigned);
+define_server_key_bench_cast_fn!(method_name: cast_to_signed, display_name: cast_to_signed);
+
+criterion_group!(cast_ops, cast_to_unsigned, cast_to_signed);
+
+define_server_key_bench_unary_fn!(method_name: full_propagate, display_name: carry_propagation);
+define_server_key_bench_unary_fn!(
+    method_name: full_propagate_parallelized,
+    display_name: carry_propagation
+);
+
 criterion_group!(misc, full_propagate, full_propagate_parallelized);
 
 #[cfg(feature = "gpu")]
@@ -2169,7 +2225,8 @@ fn go_through_cpu_bench_groups(val: &str) {
             default_parallelized_ops();
             default_parallelized_ops_comp();
             default_scalar_parallelized_ops();
-            default_scalar_parallelized_ops_comp()
+            default_scalar_parallelized_ops_comp();
+            cast_ops()
         }
         "smart" => {
             smart_ops();
@@ -2203,7 +2260,8 @@ fn main() {
             default_parallelized_ops();
             default_parallelized_ops_comp();
             default_scalar_parallelized_ops();
-            default_scalar_parallelized_ops_comp()
+            default_scalar_parallelized_ops_comp();
+            cast_ops()
         }
     };