diff --git a/Cargo.toml b/Cargo.toml index 86fb592215..ee429bc551 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -14,6 +14,7 @@ members = [ "tfhe-fft", "tfhe-ntt", "tfhe-zk-pok", + "utils/benchmark_spec", "utils/param_dedup", "utils/tfhe-backward-compat-checker", "utils/tfhe-backward-compat-data", diff --git a/tfhe-benchmark/Cargo.toml b/tfhe-benchmark/Cargo.toml index de8a388be2..895e04ae89 100644 --- a/tfhe-benchmark/Cargo.toml +++ b/tfhe-benchmark/Cargo.toml @@ -32,14 +32,15 @@ tfhe-csprng = { path = "../tfhe-csprng" } cpu-time = "1.0" num_cpus = "1.17" gag = "1.0.0" +benchmark_spec = { version = "0.1.0", path = "../utils/benchmark_spec" } [features] default = ["avx512"] boolean = ["tfhe/boolean"] shortint = ["tfhe/shortint"] integer = ["shortint", "tfhe/integer"] -gpu = ["tfhe/gpu"] -hpu = ["tfhe/hpu"] +gpu = ["tfhe/gpu", "benchmark_spec/gpu"] +hpu = ["tfhe/hpu", "benchmark_spec/hpu"] hpu-v80 = ["tfhe/hpu-v80"] internal-keycache = ["tfhe/internal-keycache"] avx512 = ["tfhe/avx512"] diff --git a/tfhe-benchmark/benches/boolean/bench.rs b/tfhe-benchmark/benches/boolean/bench.rs index d68fd473ad..0662e4a1be 100644 --- a/tfhe-benchmark/benches/boolean/bench.rs +++ b/tfhe-benchmark/benches/boolean/bench.rs @@ -1,4 +1,4 @@ -use benchmark::utilities::{write_to_json, CryptoParametersRecord, OperatorType}; +use benchmark::utilities::{write_to_json_unchecked, CryptoParametersRecord, OperatorType}; use criterion::{black_box, criterion_group, criterion_main, Criterion}; use tfhe::boolean::client_key::ClientKey; use tfhe::boolean::parameters::{ @@ -27,7 +27,7 @@ pub fn write_to_json_boolean>>( params_alias: impl Into, display_name: impl Into, ) { - write_to_json( + write_to_json_unchecked( bench_id, params, params_alias, diff --git a/tfhe-benchmark/benches/core_crypto/ks_bench.rs b/tfhe-benchmark/benches/core_crypto/ks_bench.rs index da1b801134..a8b62a666e 100644 --- a/tfhe-benchmark/benches/core_crypto/ks_bench.rs +++ b/tfhe-benchmark/benches/core_crypto/ks_bench.rs @@ -4,9 +4,9 @@ use benchmark::params::{ benchmark_compression_parameters, benchmark_parameters, multi_bit_benchmark_parameters, }; use benchmark::utilities::{ - get_bench_type, get_param_type, write_to_json, BenchmarkType, CryptoParametersRecord, - OperatorType, ParamType, + get_param_type, write_to_json_unchecked, CryptoParametersRecord, OperatorType, ParamType, }; +use benchmark_spec::{get_bench_type, BenchmarkType}; use criterion::{black_box, Criterion, Throughput}; use itertools::Itertools; use rayon::prelude::*; @@ -146,7 +146,7 @@ fn keyswitch + Serialize>( }; let bit_size = (params.message_modulus.unwrap_or(2) as u32).ilog2(); - write_to_json( + write_to_json_unchecked( &bench_id, *params, name, @@ -330,7 +330,7 @@ fn packing_keyswitch( }; let bit_size = (params.message_modulus.unwrap_or(2) as u32).ilog2(); - write_to_json( + write_to_json_unchecked( &bench_id, *params, name, @@ -346,10 +346,11 @@ fn packing_keyswitch( mod cuda { use benchmark::params::{benchmark_parameters, multi_bit_benchmark_parameters}; use benchmark::utilities::{ - cuda_local_keys_core, cuda_local_streams_core, get_bench_type, throughput_num_threads, - write_to_json, BenchmarkType, CpuKeys, CpuKeysBuilder, CryptoParametersRecord, CudaIndexes, + cuda_local_keys_core, cuda_local_streams_core, throughput_num_threads, + write_to_json_unchecked, CpuKeys, CpuKeysBuilder, CryptoParametersRecord, CudaIndexes, CudaLocalKeys, OperatorType, }; + use benchmark_spec::{get_bench_type, BenchmarkType}; use criterion::{black_box, Criterion, Throughput}; use itertools::Itertools; use rayon::prelude::*; @@ -496,7 +497,7 @@ mod cuda { } let bit_size = (params.message_modulus.unwrap_or(2) as u32).ilog2(); - write_to_json( + write_to_json_unchecked( &bench_id, *params, name, @@ -630,7 +631,7 @@ mod cuda { }); let bit_size = (params.message_modulus.unwrap_or(2) as u32).ilog2(); - write_to_json( + write_to_json_unchecked( &bench_id, *params, name, @@ -873,7 +874,7 @@ mod cuda { }; let bit_size = (params.message_modulus.unwrap_or(2) as u32).ilog2(); - write_to_json( + write_to_json_unchecked( &bench_id, *params, name, diff --git a/tfhe-benchmark/benches/core_crypto/ks_pbs_bench.rs b/tfhe-benchmark/benches/core_crypto/ks_pbs_bench.rs index d5151aa818..d76f6458fa 100644 --- a/tfhe-benchmark/benches/core_crypto/ks_pbs_bench.rs +++ b/tfhe-benchmark/benches/core_crypto/ks_pbs_bench.rs @@ -3,9 +3,9 @@ use benchmark::params::{ }; use benchmark::utilities::{ - get_bench_type, get_param_type, write_to_json, BenchmarkType, CryptoParametersRecord, - OperatorType, ParamType, + get_param_type, write_to_json_unchecked, CryptoParametersRecord, OperatorType, ParamType, }; +use benchmark_spec::{get_bench_type, BenchmarkType}; use criterion::{black_box, Criterion, Throughput}; use rayon::prelude::*; use serde::Serialize; @@ -269,7 +269,7 @@ fn ks_pbs + Serialize>( } let bit_size = (params.message_modulus.unwrap_or(2) as u32).ilog2(); - write_to_json( + write_to_json_unchecked( &bench_id, *params, name, @@ -505,7 +505,7 @@ fn multi_bit_ks_pbs< }; let bit_size = params.message_modulus.unwrap().ilog2(); - write_to_json( + write_to_json_unchecked( &bench_id, *params, name, @@ -521,10 +521,11 @@ fn multi_bit_ks_pbs< mod cuda { use super::{benchmark_parameters, multi_bit_benchmark_parameters_with_grouping}; use benchmark::utilities::{ - cuda_local_keys_core, cuda_local_streams_core, get_bench_type, throughput_num_threads, - write_to_json, BenchmarkType, CpuKeys, CpuKeysBuilder, CryptoParametersRecord, CudaIndexes, + cuda_local_keys_core, cuda_local_streams_core, throughput_num_threads, + write_to_json_unchecked, CpuKeys, CpuKeysBuilder, CryptoParametersRecord, CudaIndexes, CudaLocalKeys, OperatorType, GPU_MAX_SUPPORTED_POLYNOMIAL_SIZE, }; + use benchmark_spec::{get_bench_type, BenchmarkType}; use criterion::{black_box, Criterion, Throughput}; use rayon::prelude::*; use serde::Serialize; @@ -833,7 +834,7 @@ mod cuda { }; let bit_size = (params.message_modulus.unwrap_or(2) as u32).ilog2(); - write_to_json( + write_to_json_unchecked( &bench_id, *params, name, @@ -1143,7 +1144,7 @@ mod cuda { }; let bit_size = params.message_modulus.unwrap().ilog2(); - write_to_json( + write_to_json_unchecked( &bench_id, *params, name, diff --git a/tfhe-benchmark/benches/core_crypto/pbs128_bench.rs b/tfhe-benchmark/benches/core_crypto/pbs128_bench.rs index c692a11a7b..e5dc78beee 100644 --- a/tfhe-benchmark/benches/core_crypto/pbs128_bench.rs +++ b/tfhe-benchmark/benches/core_crypto/pbs128_bench.rs @@ -2,7 +2,7 @@ use benchmark::params_aliases::{ BENCH_NOISE_SQUASHING_PARAM_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128, BENCH_PARAM_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128, }; -use benchmark::utilities::{write_to_json, CryptoParametersRecord, OperatorType}; +use benchmark::utilities::{write_to_json_unchecked, CryptoParametersRecord, OperatorType}; use criterion::{black_box, Criterion}; use dyn_stack::PodStack; use tfhe::core_crypto::fft_impl::fft128::crypto::bootstrap::bootstrap_scratch; @@ -149,7 +149,7 @@ fn pbs_128(c: &mut Criterion) { }; let bit_size = (message_modulus as u32).ilog2(); - write_to_json( + write_to_json_unchecked( &id, params_record, noise_params.name(), @@ -163,10 +163,11 @@ fn pbs_128(c: &mut Criterion) { #[cfg(feature = "gpu")] mod cuda { use benchmark::utilities::{ - cuda_local_keys_core, cuda_local_streams_core, get_bench_type, throughput_num_threads, - write_to_json, BenchmarkType, CpuKeys, CpuKeysBuilder, CryptoParametersRecord, CudaIndexes, + cuda_local_keys_core, cuda_local_streams_core, throughput_num_threads, + write_to_json_unchecked, CpuKeys, CpuKeysBuilder, CryptoParametersRecord, CudaIndexes, CudaLocalKeys, OperatorType, }; + use benchmark_spec::{get_bench_type, BenchmarkType}; use criterion::{black_box, Criterion, Throughput}; use rayon::prelude::*; use tfhe::core_crypto::gpu::glwe_ciphertext_list::CudaGlweCiphertextList; @@ -430,7 +431,7 @@ mod cuda { }; let bit_size = (message_modulus as u32).ilog2(); - write_to_json( + write_to_json_unchecked( &bench_id, params_record, params_name, @@ -695,7 +696,7 @@ mod cuda { }; let bit_size = (message_modulus as u32).ilog2(); - write_to_json( + write_to_json_unchecked( &bench_id, params_record, params_name, diff --git a/tfhe-benchmark/benches/core_crypto/pbs_bench.rs b/tfhe-benchmark/benches/core_crypto/pbs_bench.rs index 4f5e67939c..76f91de0c7 100644 --- a/tfhe-benchmark/benches/core_crypto/pbs_bench.rs +++ b/tfhe-benchmark/benches/core_crypto/pbs_bench.rs @@ -3,9 +3,9 @@ use benchmark::params::{ multi_bit_benchmark_parameters_with_grouping, multi_bit_num_threads, }; use benchmark::utilities::{ - get_bench_type, get_param_type, write_to_json, BenchmarkType, CryptoParametersRecord, - OperatorType, ParamType, + get_param_type, write_to_json_unchecked, CryptoParametersRecord, OperatorType, ParamType, }; +use benchmark_spec::{get_bench_type, BenchmarkType}; use criterion::{black_box, Criterion, Throughput}; use rayon::prelude::*; use serde::Serialize; @@ -220,7 +220,7 @@ fn mem_optimized_pbs + Serialize>( }; let bit_size = (params.message_modulus.unwrap_or(2) as u32).ilog2(); - write_to_json( + write_to_json_unchecked( &bench_id, *params, name, @@ -460,7 +460,7 @@ fn mem_optimized_batched_pbs + Serialize }; let bit_size = (params.message_modulus.unwrap_or(2) as u32).ilog2(); - write_to_json( + write_to_json_unchecked( &bench_id, *params, name, @@ -656,7 +656,7 @@ fn multi_bit_pbs< }; let bit_size = params.message_modulus.unwrap().ilog2(); - write_to_json( + write_to_json_unchecked( &bench_id, *params, name, @@ -920,7 +920,7 @@ fn mem_optimized_pbs_ntt(c: &mut Criterion) { }; let bit_size = (params.message_modulus.unwrap_or(2) as u32).ilog2(); - write_to_json( + write_to_json_unchecked( &bench_id, *params, name, @@ -936,10 +936,11 @@ fn mem_optimized_pbs_ntt(c: &mut Criterion) { mod cuda { use benchmark::params::{benchmark_parameters, multi_bit_benchmark_parameters}; use benchmark::utilities::{ - cuda_local_keys_core, cuda_local_streams_core, get_bench_type, throughput_num_threads, - write_to_json, BenchmarkType, CpuKeys, CpuKeysBuilder, CryptoParametersRecord, CudaIndexes, + cuda_local_keys_core, cuda_local_streams_core, throughput_num_threads, + write_to_json_unchecked, CpuKeys, CpuKeysBuilder, CryptoParametersRecord, CudaIndexes, CudaLocalKeys, OperatorType, GPU_MAX_SUPPORTED_POLYNOMIAL_SIZE, }; + use benchmark_spec::{get_bench_type, BenchmarkType}; use criterion::{black_box, Criterion, Throughput}; use rayon::prelude::*; use serde::Serialize; @@ -1188,7 +1189,7 @@ mod cuda { }; let bit_size = (params.message_modulus.unwrap_or(2) as u32).ilog2(); - write_to_json( + write_to_json_unchecked( &bench_id, *params, name, @@ -1446,7 +1447,7 @@ mod cuda { }; let bit_size = params.message_modulus.unwrap().ilog2(); - write_to_json( + write_to_json_unchecked( &bench_id, *params, name, diff --git a/tfhe-benchmark/benches/high_level_api/bench_common.rs b/tfhe-benchmark/benches/high_level_api/bench_common.rs index a89e2ffd18..361315bf8d 100644 --- a/tfhe-benchmark/benches/high_level_api/bench_common.rs +++ b/tfhe-benchmark/benches/high_level_api/bench_common.rs @@ -1,8 +1,7 @@ use benchmark::high_level_api::bench_wait::*; use benchmark::high_level_api::benchmark_op::*; -use benchmark::utilities::{ - get_bench_type, will_this_bench_run, write_to_json, BenchmarkType, OperandType, OperatorType, -}; +use benchmark::utilities::{will_this_bench_run, write_to_json, OperatorType}; +use benchmark_spec::{get_bench_type, AtomicOp, BenchmarkSpec, BenchmarkType, OperandType}; use criterion::{black_box, Criterion, Throughput}; use rand::prelude::*; use rayon::prelude::*; @@ -10,60 +9,42 @@ use tfhe::keycache::NamedParam; use tfhe::prelude::*; use tfhe::ClientKey; -pub struct BenchConfig<'a> { - pub type_name: &'a str, - pub display_name: &'a str, - pub operand_type: OperandType, - pub func_name: &'a str, - pub bit_size: usize, -} - +#[allow(clippy::too_many_arguments)] #[inline(never)] pub fn bench_fhe_type_op( c: &mut Criterion, client_key: &ClientKey, - config: BenchConfig, + hlapi_op: AtomicOp, + operand_type: OperandType, + type_name: &str, + bit_size: usize, op: Op, ) where Op: BenchmarkOp + Sync, FheType: FheWait + Send + Sync, { - let group_name = config.type_name; - let mut bench_group = c.benchmark_group(group_name); - let mut bench_prefix = "hlapi".to_string(); - if cfg!(feature = "gpu") { - bench_prefix = format!("{}::cuda", bench_prefix); - } else if cfg!(feature = "hpu") { - bench_prefix = format!("{}::hpu", bench_prefix); - } - - bench_prefix = format!("{}::ops", bench_prefix); + let mut bench_group = c.benchmark_group(type_name); let mut rng = thread_rng(); let param = client_key.computation_parameters(); let param_name = param.name(); - let bit_size = config.bit_size as u32; + let bit_size = bit_size as u32; let inputs = op.setup_inputs(client_key, &mut rng); - let bench_id; - match get_bench_type() { + let bench_type = get_bench_type(); + let benchmark_spec = BenchmarkSpec::new_hlapi( + hlapi_op, + ¶m_name, + &operand_type, + Some(type_name), + bench_type, + ); + let bench_id = benchmark_spec.to_string(); + + match bench_type { BenchmarkType::Latency => { - bench_id = match config.operand_type { - OperandType::PlainText => { - format!( - "{bench_prefix}::{}::{param_name}::scalar::{}", - config.func_name, config.type_name - ) - } - OperandType::CipherText => { - format!( - "{bench_prefix}::{}::{param_name}::{}", - config.func_name, config.type_name - ) - } - }; bench_group.bench_function(&bench_id, |b| { b.iter(|| { let res = op.execute(&inputs); @@ -73,21 +54,6 @@ pub fn bench_fhe_type_op( }); } BenchmarkType::Throughput => { - bench_id = match config.operand_type { - OperandType::PlainText => { - format!( - "{bench_prefix}::{}::throughput::{param_name}::scalar::{}", - config.func_name, config.type_name - ) - } - OperandType::CipherText => { - format!( - "{bench_prefix}::{}::throughput::{param_name}::{}", - config.func_name, config.type_name - ) - } - }; - let setup = |batch_size: usize| { (0..batch_size) .into_par_iter() @@ -95,7 +61,7 @@ pub fn bench_fhe_type_op( .collect::>() }; - let elements = if will_this_bench_run(group_name, &bench_id) { + let elements = if will_this_bench_run(type_name, &bench_id) { #[cfg(any(feature = "gpu", feature = "hpu"))] { use benchmark::utilities::throughput_num_threads; @@ -149,10 +115,9 @@ pub fn bench_fhe_type_op( } write_to_json::( - &bench_id, + &benchmark_spec, param, - ¶m_name, - config.display_name, + hlapi_op.to_string(), &OperatorType::Atomic, bit_size, vec![], @@ -165,7 +130,7 @@ macro_rules! bench_type_binary_op { right_type_name: $fhe_right_type:ident, left_type: $left_type:ty, right_type: $right_type:ty, - display_name: $display_name:literal, + hlapi_op: $hlapi_op:expr, operation: $op:ident ) => { ::paste::paste! { @@ -174,13 +139,10 @@ macro_rules! bench_type_binary_op { bench_fhe_type_op( c, cks, - BenchConfig { - type_name: stringify!($fhe_type), - bit_size: $fhe_type::num_bits(), - display_name: $display_name, - operand_type: OperandType::CipherText, - func_name: stringify!($op), - }, + $hlapi_op, + OperandType::CipherText, + stringify!($fhe_type), + $fhe_type::num_bits(), BinaryOp { func: |lhs: &$fhe_type, rhs: &$fhe_right_type| lhs.$op(rhs), _encrypt_lhs: PhantomData::<$left_type>, @@ -198,7 +160,7 @@ macro_rules! bench_type_binary_scalar_op { type_name: $fhe_type:ident, integer_type: $integer_type:ty, scalar_type: $scalar_ty:ty, - display_name: $display_name:literal, + hlapi_op: $hlapi_op:expr, operation: $op:ident, rng: $rng_fn:expr ) => { @@ -208,13 +170,10 @@ macro_rules! bench_type_binary_scalar_op { bench_fhe_type_op( c, cks, - BenchConfig { - type_name: stringify!($fhe_type), - bit_size: $fhe_type::num_bits(), - display_name: $display_name, - operand_type: OperandType::PlainText, - func_name: stringify!($op), - }, + $hlapi_op, + OperandType::PlainText, + stringify!($fhe_type), + $fhe_type::num_bits(), ScalarBinaryOp { func: |lhs: &$fhe_type, rhs: &$scalar_ty| lhs.$op(*rhs), rng_function: $rng_fn, @@ -230,7 +189,7 @@ macro_rules! bench_type_unary_op { ( type_name: $fhe_type:ident, integer_type: $integer_type:ty, - display_name: $display_name:literal, + hlapi_op: $hlapi_op:expr, operation: $op:ident ) => { ::paste::paste! { @@ -239,13 +198,10 @@ macro_rules! bench_type_unary_op { bench_fhe_type_op( c, cks, - BenchConfig { - type_name: stringify!($fhe_type), - bit_size: $fhe_type::num_bits(), - display_name: $display_name, - operand_type: OperandType::CipherText, - func_name: stringify!($op), - }, + $hlapi_op, + OperandType::CipherText, + stringify!($fhe_type), + $fhe_type::num_bits(), UnaryOp { func: |lhs: &$fhe_type| lhs.$op(), _encrypt: PhantomData::<$integer_type> @@ -260,7 +216,7 @@ macro_rules! bench_type_ternary_op { ( type_name: $fhe_type:ident, integer_type: $integer_type:ty, - display_name: $display_name:literal, + hlapi_op: $hlapi_op:expr, operation: $op:ident ) => { ::paste::paste! { @@ -269,13 +225,10 @@ macro_rules! bench_type_ternary_op { bench_fhe_type_op( c, cks, - BenchConfig { - type_name: stringify!($fhe_type), - bit_size: $fhe_type::num_bits(), - display_name: $display_name, - operand_type: OperandType::CipherText, - func_name: stringify!($op), - }, + $hlapi_op, + OperandType::CipherText, + stringify!($fhe_type), + $fhe_type::num_bits(), TernaryOp { func: |cond: &FheBool, lhs: &$fhe_type, rhs: &$fhe_type| cond.$op(lhs, rhs), _encrypt: PhantomData::<$integer_type> @@ -290,7 +243,7 @@ macro_rules! bench_type_array_op { ( type_name: $fhe_type:ident, integer_type: $integer_type:ty, - display_name: $display_name:literal, + hlapi_op: $hlapi_op:expr, operation: $op:ident ) => { ::paste::paste! { @@ -299,13 +252,10 @@ macro_rules! bench_type_array_op { bench_fhe_type_op( c, cks, - BenchConfig { - type_name: stringify!($fhe_type), - bit_size: $fhe_type::num_bits(), - display_name: $display_name, - operand_type: OperandType::CipherText, - func_name: stringify!($op), - }, + $hlapi_op, + OperandType::CipherText, + stringify!($fhe_type), + $fhe_type::num_bits(), ArrayOp { func: |iter: std::slice::Iter<'_, $fhe_type>| iter.$op(), array_size: 64, @@ -325,7 +275,7 @@ macro_rules! generate_typed_benches { bench_type_array_op!( type_name: $fhe_type, integer_type: $integer_type, - display_name: "sum", + hlapi_op: AtomicOp::Sum, operation: sum ); bench_type_binary_op!( @@ -333,16 +283,15 @@ macro_rules! generate_typed_benches { right_type_name: $fhe_type, left_type: $integer_type, right_type: $integer_type, - display_name: "add", - operation: - add + hlapi_op: AtomicOp::Add, + operation: add ); bench_type_binary_op!( type_name: $fhe_type, right_type_name: $fhe_type, left_type: $integer_type, right_type: $integer_type, - display_name: "bitand", + hlapi_op: AtomicOp::Bitand, operation: bitand ); bench_type_binary_op!( @@ -350,7 +299,7 @@ macro_rules! generate_typed_benches { right_type_name: $fhe_type, left_type: $integer_type, right_type: $integer_type, - display_name: "bitor", + hlapi_op: AtomicOp::Bitor, operation: bitor ); bench_type_binary_op!( @@ -358,7 +307,7 @@ macro_rules! generate_typed_benches { right_type_name: $fhe_type, left_type: $integer_type, right_type: $integer_type, - display_name: "bitxor", + hlapi_op: AtomicOp::Bitxor, operation: bitxor ); bench_type_binary_op!( @@ -366,7 +315,7 @@ macro_rules! generate_typed_benches { right_type_name: $fhe_type, left_type: $integer_type, right_type: $integer_type, - display_name: "div", + hlapi_op: AtomicOp::Div, operation: div ); bench_type_binary_op!( @@ -374,7 +323,7 @@ macro_rules! generate_typed_benches { right_type_name: $fhe_type, left_type: $integer_type, right_type: $integer_type, - display_name: "div_rem", + hlapi_op: AtomicOp::DivRem, operation: div_rem ); bench_type_binary_op!( @@ -382,7 +331,7 @@ macro_rules! generate_typed_benches { right_type_name: $fhe_type, left_type: $integer_type, right_type: $integer_type, - display_name: "eq", + hlapi_op: AtomicOp::Eq, operation: eq ); bench_type_binary_op!( @@ -390,7 +339,7 @@ macro_rules! generate_typed_benches { right_type_name: $fhe_type, left_type: $integer_type, right_type: $integer_type, - display_name: "ge", + hlapi_op: AtomicOp::Ge, operation: ge ); bench_type_binary_op!( @@ -398,7 +347,7 @@ macro_rules! generate_typed_benches { right_type_name: $fhe_type, left_type: $integer_type, right_type: $integer_type, - display_name: "gt", + hlapi_op: AtomicOp::Gt, operation: gt ); bench_type_binary_op!( @@ -406,7 +355,7 @@ macro_rules! generate_typed_benches { right_type_name: $fhe_type, left_type: $integer_type, right_type: $integer_type, - display_name: "le", + hlapi_op: AtomicOp::Le, operation: le ); bench_type_binary_op!( @@ -414,7 +363,7 @@ macro_rules! generate_typed_benches { right_type_name: FheUint8, left_type: $integer_type, right_type: u8, - display_name: "left_rotate", + hlapi_op: AtomicOp::LeftRotate, operation: rotate_left ); bench_type_binary_op!( @@ -422,7 +371,7 @@ macro_rules! generate_typed_benches { right_type_name: FheUint8, left_type: $integer_type, right_type: u8, - display_name: "left_shift", + hlapi_op: AtomicOp::LeftShift, operation: shl ); bench_type_binary_op!( @@ -430,7 +379,7 @@ macro_rules! generate_typed_benches { right_type_name: $fhe_type, left_type: $integer_type, right_type: $integer_type, - display_name: "lt", + hlapi_op: AtomicOp::Lt, operation: lt ); bench_type_binary_op!( @@ -438,7 +387,7 @@ macro_rules! generate_typed_benches { right_type_name: $fhe_type, left_type: $integer_type, right_type: $integer_type, - display_name: "max", + hlapi_op: AtomicOp::Max, operation: max ); bench_type_binary_op!( @@ -446,7 +395,7 @@ macro_rules! generate_typed_benches { right_type_name: $fhe_type, left_type: $integer_type, right_type: $integer_type, - display_name: "min", + hlapi_op: AtomicOp::Min, operation: min ); bench_type_binary_op!( @@ -454,7 +403,7 @@ macro_rules! generate_typed_benches { right_type_name: $fhe_type, left_type: $integer_type, right_type: $integer_type, - display_name: "mul", + hlapi_op: AtomicOp::Mul, operation: mul ); bench_type_binary_op!( @@ -462,7 +411,7 @@ macro_rules! generate_typed_benches { right_type_name: $fhe_type, left_type: $integer_type, right_type: $integer_type, - display_name: "ne", + hlapi_op: AtomicOp::Ne, operation: ne ); bench_type_binary_op!( @@ -470,7 +419,7 @@ macro_rules! generate_typed_benches { right_type_name: $fhe_type, left_type: $integer_type, right_type: $integer_type, - display_name: "overflowing_add", + hlapi_op: AtomicOp::OverflowingAdd, operation: overflowing_add ); bench_type_binary_op!( @@ -478,7 +427,7 @@ macro_rules! generate_typed_benches { right_type_name: $fhe_type, left_type: $integer_type, right_type: $integer_type, - display_name: "overflowing_mul", + hlapi_op: AtomicOp::OverflowingMul, operation: overflowing_mul ); bench_type_binary_op!( @@ -486,7 +435,7 @@ macro_rules! generate_typed_benches { right_type_name: $fhe_type, left_type: $integer_type, right_type: $integer_type, - display_name: "overflowing_sub", + hlapi_op: AtomicOp::OverflowingSub, operation: overflowing_sub ); bench_type_binary_op!( @@ -494,7 +443,7 @@ macro_rules! generate_typed_benches { right_type_name: $fhe_type, left_type: $integer_type, right_type: $integer_type, - display_name: "rem", + hlapi_op: AtomicOp::Rem, operation: rem ); bench_type_binary_op!( @@ -502,7 +451,7 @@ macro_rules! generate_typed_benches { right_type_name: FheUint8, left_type: $integer_type, right_type: u8, - display_name: "right_rotate", + hlapi_op: AtomicOp::RightRotate, operation: rotate_right ); bench_type_binary_op!( @@ -510,7 +459,7 @@ macro_rules! generate_typed_benches { right_type_name: FheUint8, left_type: $integer_type, right_type: u8, - display_name: "right_shift", + hlapi_op: AtomicOp::RightShift, operation: shr ); bench_type_binary_op!( @@ -518,103 +467,103 @@ macro_rules! generate_typed_benches { right_type_name: $fhe_type, left_type: $integer_type, right_type: $integer_type, - display_name: "sub", + hlapi_op: AtomicOp::Sub, operation: sub ); bench_type_ternary_op!( type_name: $fhe_type, integer_type: $integer_type, - display_name: "flip", + hlapi_op: AtomicOp::Flip, operation: flip ); bench_type_ternary_op!( type_name: $fhe_type, integer_type: $integer_type, - display_name: "if_then_else", + hlapi_op: AtomicOp::IfThenElse, operation: if_then_else ); bench_type_unary_op!( type_name: $fhe_type, integer_type: $integer_type, - display_name: "checked_ilog2", + hlapi_op: AtomicOp::CheckedIlog2, operation: checked_ilog2 ); bench_type_unary_op!( type_name: $fhe_type, integer_type: $integer_type, - display_name: "count_ones", + hlapi_op: AtomicOp::CountOnes, operation: count_ones ); bench_type_unary_op!( type_name: $fhe_type, integer_type: $integer_type, - display_name: "count_zeros", + hlapi_op: AtomicOp::CountZeros, operation: count_zeros ); bench_type_unary_op!( type_name: $fhe_type, integer_type: $integer_type, - display_name: "ilog2", + hlapi_op: AtomicOp::Ilog2, operation: ilog2 ); bench_type_unary_op!( type_name: $fhe_type, integer_type: $integer_type, - display_name: "is_even", + hlapi_op: AtomicOp::IsEven, operation: is_even ); bench_type_unary_op!( type_name: $fhe_type, integer_type: $integer_type, - display_name: "is_odd", + hlapi_op: AtomicOp::IsOdd, operation: is_odd ); bench_type_unary_op!( type_name: $fhe_type, integer_type: $integer_type, - display_name: "leading_ones", + hlapi_op: AtomicOp::LeadingOnes, operation: leading_ones ); bench_type_unary_op!( type_name: $fhe_type, integer_type: $integer_type, - display_name: "leading_zeros", + hlapi_op: AtomicOp::LeadingZeros, operation: leading_zeros ); bench_type_unary_op!( type_name: $fhe_type, integer_type: $integer_type, - display_name: "neg", + hlapi_op: AtomicOp::Neg, operation: neg ); bench_type_unary_op!( type_name: $fhe_type, integer_type: $integer_type, - display_name: "not", + hlapi_op: AtomicOp::Not, operation: not ); bench_type_unary_op!( type_name: $fhe_type, integer_type: $integer_type, - display_name: "overflowing_neg", + hlapi_op: AtomicOp::OverflowingNeg, operation: overflowing_neg ); bench_type_unary_op!( type_name: $fhe_type, integer_type: $integer_type, - display_name: "reverse_bits", + hlapi_op: AtomicOp::ReverseBits, operation: reverse_bits ); bench_type_unary_op!( type_name: $fhe_type, integer_type: $integer_type, - display_name: "trailing_ones", + hlapi_op: AtomicOp::TrailingOnes, operation: trailing_ones ); bench_type_unary_op!( type_name: $fhe_type, integer_type: $integer_type, - display_name: "trailing_zeros", + hlapi_op: AtomicOp::TrailingZeros, operation: trailing_zeros ); }; @@ -631,7 +580,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $scalar_ty, - display_name: "add", + hlapi_op: AtomicOp::Add, operation: add, rng: || rand::random::<$scalar_ty>() ); @@ -639,7 +588,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $scalar_ty, - display_name: "bitand", + hlapi_op: AtomicOp::Bitand, operation: bitand, rng: || rand::random::<$scalar_ty>() ); @@ -647,7 +596,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $scalar_ty, - display_name: "bitor", + hlapi_op: AtomicOp::Bitor, operation: bitor, rng: || rand::random::<$scalar_ty>() ); @@ -655,7 +604,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $scalar_ty, - display_name: "bitxor", + hlapi_op: AtomicOp::Bitxor, operation: bitxor, rng: || rand::random::<$scalar_ty>() ); @@ -663,7 +612,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $scalar_ty, - display_name: "div", + hlapi_op: AtomicOp::Div, operation: div, rng: || random_non_zero::<$scalar_ty>() ); @@ -671,7 +620,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $scalar_ty, - display_name: "eq", + hlapi_op: AtomicOp::Eq, operation: eq, rng: || rand::random::<$scalar_ty>() ); @@ -679,7 +628,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $scalar_ty, - display_name: "ge", + hlapi_op: AtomicOp::Ge, operation: ge, rng: || rand::random::<$scalar_ty>() ); @@ -687,7 +636,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $scalar_ty, - display_name: "gt", + hlapi_op: AtomicOp::Gt, operation: gt, rng: || rand::random::<$scalar_ty>() ); @@ -695,7 +644,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $scalar_ty, - display_name: "le", + hlapi_op: AtomicOp::Le, operation: le, rng: || rand::random::<$scalar_ty>() ); @@ -703,7 +652,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $scalar_ty, - display_name: "lt", + hlapi_op: AtomicOp::Lt, operation: lt, rng: || rand::random::<$scalar_ty>() ); @@ -711,7 +660,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $scalar_ty, - display_name: "max", + hlapi_op: AtomicOp::Max, operation: max, rng: || rand::random::<$scalar_ty>() ); @@ -719,7 +668,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $scalar_ty, - display_name: "min", + hlapi_op: AtomicOp::Min, operation: min, rng: || rand::random::<$scalar_ty>() ); @@ -727,7 +676,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $scalar_ty, - display_name: "mul", + hlapi_op: AtomicOp::Mul, operation: mul, rng: || random_not_power_of_two::<$scalar_ty>() ); @@ -735,7 +684,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $scalar_ty, - display_name: "ne", + hlapi_op: AtomicOp::Ne, operation: ne, rng: || rand::random::<$scalar_ty>() ); @@ -743,7 +692,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $scalar_ty, - display_name: "overflowing_add", + hlapi_op: AtomicOp::OverflowingAdd, operation: overflowing_add, rng: || rand::random::<$scalar_ty>() ); @@ -751,7 +700,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $scalar_ty, - display_name: "overflowing_sub", + hlapi_op: AtomicOp::OverflowingSub, operation: overflowing_sub, rng: || rand::random::<$scalar_ty>() ); @@ -759,7 +708,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $scalar_ty, - display_name: "rem", + hlapi_op: AtomicOp::Rem, operation: rem, rng: || random_non_zero::<$scalar_ty>() ); @@ -767,7 +716,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $specific_ty, - display_name: "rotate_left", + hlapi_op: AtomicOp::LeftRotate, operation: rotate_left, rng: || rand::random::<$specific_ty>() ); @@ -775,7 +724,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $specific_ty, - display_name: "rotate_right", + hlapi_op: AtomicOp::RightRotate, operation: rotate_right, rng: || rand::random::<$specific_ty>() ); @@ -783,7 +732,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $specific_ty, - display_name: "shift_left", + hlapi_op: AtomicOp::LeftShift, operation: shl, rng: || <$specific_ty>::ONE ); @@ -791,7 +740,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $specific_ty, - display_name: "shift_right", + hlapi_op: AtomicOp::RightShift, operation: shr, rng: || <$specific_ty>::ONE ); @@ -799,7 +748,7 @@ macro_rules! generate_typed_scalar_benches { type_name: $fhe_type, integer_type: $integer_type, scalar_type: $scalar_ty, - display_name: "sub", + hlapi_op: AtomicOp::Sub, operation: sub, rng: || rand::random::<$scalar_ty>() ); diff --git a/tfhe-benchmark/benches/high_level_api/bench_signed.rs b/tfhe-benchmark/benches/high_level_api/bench_signed.rs index f8fd310cd9..eaf7a862d7 100644 --- a/tfhe-benchmark/benches/high_level_api/bench_signed.rs +++ b/tfhe-benchmark/benches/high_level_api/bench_signed.rs @@ -1,7 +1,8 @@ -use crate::bench_common::{bench_fhe_type_op, BenchConfig}; +use crate::bench_common::bench_fhe_type_op; use benchmark::high_level_api::benchmark_op::*; use benchmark::high_level_api::random_generator::{random_non_zero, random_not_power_of_two}; -use benchmark::utilities::{BitSizesSet, EnvConfig, OperandType}; +use benchmark::utilities::{BitSizesSet, EnvConfig}; +use benchmark_spec::{AtomicOp, OperandType}; use criterion::Criterion; use oprf::oprf_any_range2; use std::env; diff --git a/tfhe-benchmark/benches/high_level_api/bench_unsigned.rs b/tfhe-benchmark/benches/high_level_api/bench_unsigned.rs index 3ce4f2a86e..3797aa8526 100644 --- a/tfhe-benchmark/benches/high_level_api/bench_unsigned.rs +++ b/tfhe-benchmark/benches/high_level_api/bench_unsigned.rs @@ -1,8 +1,9 @@ -use crate::bench_common::{bench_fhe_type_op, BenchConfig}; +use crate::bench_common::bench_fhe_type_op; use crate::oprf::oprf_any_range2; use benchmark::high_level_api::benchmark_op::*; use benchmark::high_level_api::random_generator::{random_non_zero, random_not_power_of_two}; -use benchmark::utilities::{BitSizesSet, EnvConfig, OperandType}; +use benchmark::utilities::{BitSizesSet, EnvConfig}; +use benchmark_spec::{AtomicOp, OperandType}; use criterion::Criterion; use std::env; use std::marker::PhantomData; diff --git a/tfhe-benchmark/benches/high_level_api/dex.rs b/tfhe-benchmark/benches/high_level_api/dex.rs index 0592e403eb..bfd1fa14a2 100644 --- a/tfhe-benchmark/benches/high_level_api/dex.rs +++ b/tfhe-benchmark/benches/high_level_api/dex.rs @@ -7,7 +7,8 @@ use benchmark::params_aliases::{ }; #[cfg(feature = "gpu")] use benchmark::utilities::{configure_gpu, get_param_type, ParamType}; -use benchmark::utilities::{get_bench_type, write_to_json, BenchmarkType, OperatorType}; +use benchmark::utilities::{write_to_json_unchecked, OperatorType}; +use benchmark_spec::{get_bench_type, BenchmarkType}; use criterion::measurement::WallTime; use criterion::{BenchmarkGroup, Criterion, Throughput}; use rand::prelude::*; @@ -276,7 +277,7 @@ mod pbs_stats { write_result(&mut file, &test_name, count as usize); - write_to_json::( + write_to_json_unchecked::( &test_name, params, params_name, @@ -331,7 +332,7 @@ mod pbs_stats { write_result(&mut file, &test_name, count as usize); - write_to_json::( + write_to_json_unchecked::( &test_name, params, params_name, @@ -394,7 +395,7 @@ mod pbs_stats { write_result(&mut file, &test_name, count as usize); - write_to_json::( + write_to_json_unchecked::( &test_name, params, params_name, @@ -454,7 +455,7 @@ mod pbs_stats { write_result(&mut file, &test_name, count as usize); - write_to_json::( + write_to_json_unchecked::( &test_name, params, params_name, @@ -524,7 +525,7 @@ fn bench_swap_request_latency( }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, params, params_name, @@ -640,7 +641,7 @@ fn bench_swap_request_throughput( }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, params, ¶ms_name, @@ -852,7 +853,7 @@ fn cuda_bench_swap_request_throughput( }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, params, ¶ms_name, @@ -928,7 +929,7 @@ fn bench_swap_claim_latency( }); }); - write_to_json::( + write_to_json_unchecked::( &bench_id, params, ¶ms_name, @@ -1062,7 +1063,7 @@ fn bench_swap_claim_throughput( }); }); - write_to_json::( + write_to_json_unchecked::( &bench_id, params, ¶ms_name, @@ -1269,7 +1270,7 @@ fn cuda_bench_swap_claim_throughput( }); }); - write_to_json::( + write_to_json_unchecked::( &bench_id, params, ¶ms_name, diff --git a/tfhe-benchmark/benches/high_level_api/erc20.rs b/tfhe-benchmark/benches/high_level_api/erc20.rs index 0a44c70427..7ddab9e474 100644 --- a/tfhe-benchmark/benches/high_level_api/erc20.rs +++ b/tfhe-benchmark/benches/high_level_api/erc20.rs @@ -1,6 +1,7 @@ #[cfg(feature = "gpu")] use benchmark::utilities::{configure_gpu, get_param_type, ParamType}; -use benchmark::utilities::{get_bench_type, write_to_json, BenchmarkType, OperatorType}; +use benchmark::utilities::{write_to_json_unchecked, OperatorType}; +use benchmark_spec::{get_bench_type, BenchmarkType}; use criterion::measurement::WallTime; use criterion::{BenchmarkGroup, Criterion, Throughput}; use rand::prelude::*; @@ -340,7 +341,7 @@ mod pbs_stats { write_result(&mut file, &test_name, count as usize); - write_to_json::( + write_to_json_unchecked::( &test_name, params, params_name, @@ -387,7 +388,7 @@ fn bench_transfer_latency( }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, params, params_name, @@ -448,7 +449,7 @@ fn bench_transfer_latency_simd( }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, params, params_name, @@ -502,7 +503,7 @@ fn bench_transfer_throughput( }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, params, ¶ms_name, @@ -592,7 +593,7 @@ fn cuda_bench_transfer_throughput( }); }); - write_to_json::( + write_to_json_unchecked::( &bench_id, params, ¶ms_name, @@ -656,7 +657,7 @@ fn hpu_bench_transfer_throughput( }); }); - write_to_json::( + write_to_json_unchecked::( &bench_id, params, ¶ms_name, @@ -741,7 +742,7 @@ fn hpu_bench_transfer_throughput_simd( }); }); - write_to_json::( + write_to_json_unchecked::( &bench_id, params, ¶ms_name, diff --git a/tfhe-benchmark/benches/high_level_api/kv_store.rs b/tfhe-benchmark/benches/high_level_api/kv_store.rs index b37f55274c..9d560cceea 100644 --- a/tfhe-benchmark/benches/high_level_api/kv_store.rs +++ b/tfhe-benchmark/benches/high_level_api/kv_store.rs @@ -1,9 +1,8 @@ #[cfg(not(any(feature = "gpu", feature = "hpu")))] use benchmark::find_optimal_batch::find_optimal_batch; use benchmark::high_level_api::type_display::*; -use benchmark::utilities::{ - get_bench_type, write_to_json, BenchmarkType, BitSizesSet, EnvConfig, OperatorType, -}; +use benchmark::utilities::{write_to_json_unchecked, BitSizesSet, EnvConfig, OperatorType}; +use benchmark_spec::{get_bench_type, BenchmarkType}; use criterion::{Criterion, Throughput}; use rand::prelude::*; use rayon::prelude::*; @@ -171,7 +170,7 @@ where (bench_id_update, "update"), (bench_id_map, "map"), ] { - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), diff --git a/tfhe-benchmark/benches/high_level_api/noise_squash.rs b/tfhe-benchmark/benches/high_level_api/noise_squash.rs index c13af26820..eb9436da6a 100644 --- a/tfhe-benchmark/benches/high_level_api/noise_squash.rs +++ b/tfhe-benchmark/benches/high_level_api/noise_squash.rs @@ -15,9 +15,9 @@ use benchmark::params_aliases::{ #[cfg(feature = "gpu")] use benchmark::utilities::configure_gpu; use benchmark::utilities::{ - get_bench_type, will_this_bench_run, write_to_json, BenchmarkType, BitSizesSet, EnvConfig, - OperatorType, + will_this_bench_run, write_to_json_unchecked, BitSizesSet, EnvConfig, OperatorType, }; +use benchmark_spec::{get_bench_type, BenchmarkType}; use criterion::{Criterion, Throughput}; use rand::prelude::*; use rand::thread_rng; @@ -200,7 +200,7 @@ fn bench_sns_only_fhe_type( } let params = client_key.computation_parameters(); - write_to_json::( + write_to_json_unchecked::( &bench_id, params, params.name(), @@ -409,7 +409,7 @@ fn bench_decomp_sns_comp_fhe_type( } let params = client_key.computation_parameters(); - write_to_json::( + write_to_json_unchecked::( &bench_id, params, params.name(), diff --git a/tfhe-benchmark/benches/integer/aes.rs b/tfhe-benchmark/benches/integer/aes.rs index 73537dc2d5..7819837c06 100644 --- a/tfhe-benchmark/benches/integer/aes.rs +++ b/tfhe-benchmark/benches/integer/aes.rs @@ -3,7 +3,7 @@ use criterion::Criterion; #[cfg(feature = "gpu")] pub mod cuda { use benchmark::params_aliases::BENCH_PARAM_GPU_MULTI_BIT_GROUP_4_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128; - use benchmark::utilities::{write_to_json, OperatorType}; + use benchmark::utilities::{write_to_json_unchecked, OperatorType}; use criterion::{black_box, criterion_group, Criterion}; use tfhe::core_crypto::gpu::{check_valid_cuda_malloc, CudaStreams}; use tfhe::integer::gpu::ciphertext::CudaUnsignedRadixCiphertext; @@ -62,7 +62,7 @@ pub mod cuda { }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, atomic_param, param.name(), @@ -81,7 +81,7 @@ pub mod cuda { }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, atomic_param, param.name(), @@ -136,7 +136,7 @@ pub mod cuda { }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, atomic_param, param.name(), diff --git a/tfhe-benchmark/benches/integer/aes256.rs b/tfhe-benchmark/benches/integer/aes256.rs index 0e48d8d03c..738ceb12b6 100644 --- a/tfhe-benchmark/benches/integer/aes256.rs +++ b/tfhe-benchmark/benches/integer/aes256.rs @@ -3,7 +3,7 @@ use criterion::Criterion; #[cfg(feature = "gpu")] pub mod cuda { use benchmark::params_aliases::BENCH_PARAM_GPU_MULTI_BIT_GROUP_4_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128; - use benchmark::utilities::{write_to_json, OperatorType}; + use benchmark::utilities::{write_to_json_unchecked, OperatorType}; use criterion::{black_box, criterion_group, Criterion}; use tfhe::core_crypto::gpu::{check_valid_cuda_malloc, CudaStreams}; use tfhe::integer::gpu::ciphertext::CudaUnsignedRadixCiphertext; @@ -66,7 +66,7 @@ pub mod cuda { }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, atomic_param, param.name(), @@ -85,7 +85,7 @@ pub mod cuda { }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, atomic_param, param.name(), @@ -140,7 +140,7 @@ pub mod cuda { }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, atomic_param, param.name(), diff --git a/tfhe-benchmark/benches/integer/bench.rs b/tfhe-benchmark/benches/integer/bench.rs index fbb4f78794..fbba762590 100644 --- a/tfhe-benchmark/benches/integer/bench.rs +++ b/tfhe-benchmark/benches/integer/bench.rs @@ -12,7 +12,8 @@ mod rerand; use benchmark::params::ParamsAndNumBlocksIter; #[cfg(any(feature = "gpu", feature = "hpu"))] use benchmark::utilities::throughput_num_threads; -use benchmark::utilities::{get_bench_type, write_to_json, BenchmarkType, EnvConfig, OperatorType}; +use benchmark::utilities::{write_to_json_unchecked, EnvConfig, OperatorType}; +use benchmark_spec::{get_bench_type, BenchmarkType}; use criterion::{criterion_group, Criterion, Throughput}; use rand::prelude::*; use rayon::prelude::*; @@ -94,7 +95,7 @@ fn bench_server_key_binary_function_dirty_inputs( ) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -207,7 +208,7 @@ fn bench_server_key_binary_function_clean_inputs( } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -274,7 +275,7 @@ fn bench_server_key_unary_function_dirty_inputs( ) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -377,7 +378,7 @@ fn bench_server_key_unary_function_clean_inputs( } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -449,7 +450,7 @@ fn bench_server_key_binary_scalar_function_dirty_inputs( ) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -569,7 +570,7 @@ fn bench_server_key_binary_scalar_function_clean_inputs( } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -710,7 +711,7 @@ fn if_then_else_parallelized(c: &mut Criterion) { } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -820,7 +821,7 @@ fn flip_parallelized(c: &mut Criterion) { } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -944,7 +945,7 @@ fn ciphertexts_sum_parallelized(c: &mut Criterion) { } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -1655,7 +1656,7 @@ mod cuda { } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -1799,7 +1800,7 @@ mod cuda { } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -1938,7 +1939,7 @@ mod cuda { } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -2090,7 +2091,7 @@ mod cuda { } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -2959,7 +2960,7 @@ mod cuda { ) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -3170,7 +3171,7 @@ mod hpu { } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -3750,7 +3751,7 @@ fn bench_server_key_cast_function( ) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), diff --git a/tfhe-benchmark/benches/integer/glwe_packing_compression.rs b/tfhe-benchmark/benches/integer/glwe_packing_compression.rs index a50c0ccaef..ff37d91dab 100644 --- a/tfhe-benchmark/benches/integer/glwe_packing_compression.rs +++ b/tfhe-benchmark/benches/integer/glwe_packing_compression.rs @@ -1,7 +1,6 @@ use benchmark::params_aliases::*; -use benchmark::utilities::{ - get_bench_type, write_to_json, BenchmarkType, BitSizesSet, EnvConfig, OperatorType, -}; +use benchmark::utilities::{write_to_json_unchecked, BitSizesSet, EnvConfig, OperatorType}; +use benchmark_spec::{get_bench_type, BenchmarkType}; use criterion::{black_box, criterion_group, Criterion, Throughput}; use rayon::prelude::*; use tfhe::integer::ciphertext::CompressedCiphertextListBuilder; @@ -178,7 +177,7 @@ fn cpu_glwe_packing(c: &mut Criterion) { } } - write_to_json::( + write_to_json_unchecked::( &bench_id_pack, (comp_param, param.into()), comp_param.name(), @@ -188,7 +187,7 @@ fn cpu_glwe_packing(c: &mut Criterion) { vec![param.message_modulus.0.ilog2(); num_blocks], ); - write_to_json::( + write_to_json_unchecked::( &bench_id_unpack, (comp_param, param.into()), comp_param.name(), @@ -334,7 +333,7 @@ mod cuda { } } - write_to_json::( + write_to_json_unchecked::( &bench_id_pack, (comp_param, param), comp_param.name(), @@ -497,7 +496,7 @@ mod cuda { } } - write_to_json::( + write_to_json_unchecked::( &bench_id_unpack, (comp_param, param), comp_param.name(), diff --git a/tfhe-benchmark/benches/integer/glwe_packing_compression_128b.rs b/tfhe-benchmark/benches/integer/glwe_packing_compression_128b.rs index 24164b90db..04aa3f25d2 100644 --- a/tfhe-benchmark/benches/integer/glwe_packing_compression_128b.rs +++ b/tfhe-benchmark/benches/integer/glwe_packing_compression_128b.rs @@ -2,9 +2,8 @@ mod cuda { use benchmark::params_aliases::*; use benchmark::utilities::cuda_integer_utils::cuda_local_streams; - use benchmark::utilities::{ - cuda_local_keys, get_bench_type, write_to_json, BenchmarkType, OperatorType, - }; + use benchmark::utilities::{cuda_local_keys, write_to_json_unchecked, OperatorType}; + use benchmark_spec::{get_bench_type, BenchmarkType}; use criterion::{black_box, criterion_group, Criterion, Throughput}; use rayon::prelude::*; use tfhe::core_crypto::gpu::{get_number_of_gpus, CudaStreams}; @@ -169,7 +168,7 @@ mod cuda { } } - write_to_json::( + write_to_json_unchecked::( &bench_id_pack, (noise_squashing_compression_parameters, param.into()), noise_squashing_compression_parameters.name(), @@ -324,7 +323,7 @@ mod cuda { } } - write_to_json::( + write_to_json_unchecked::( &bench_id_unpack, (noise_squashing_compression_parameters, param.into()), noise_squashing_compression_parameters.name(), diff --git a/tfhe-benchmark/benches/integer/kreyvium.rs b/tfhe-benchmark/benches/integer/kreyvium.rs index 17342f6991..4467a377e3 100644 --- a/tfhe-benchmark/benches/integer/kreyvium.rs +++ b/tfhe-benchmark/benches/integer/kreyvium.rs @@ -3,7 +3,7 @@ use criterion::Criterion; #[cfg(feature = "gpu")] pub mod cuda { use benchmark::params_aliases::BENCH_PARAM_GPU_MULTI_BIT_GROUP_4_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128; - use benchmark::utilities::{write_to_json, OperatorType}; + use benchmark::utilities::{write_to_json_unchecked, OperatorType}; use criterion::{black_box, criterion_group, Criterion}; use tfhe::core_crypto::gpu::CudaStreams; use tfhe::integer::gpu::ciphertext::CudaUnsignedRadixCiphertext; @@ -61,7 +61,7 @@ pub mod cuda { }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, atomic_param, param.name(), diff --git a/tfhe-benchmark/benches/integer/oprf.rs b/tfhe-benchmark/benches/integer/oprf.rs index 036d226216..8bd9a16049 100644 --- a/tfhe-benchmark/benches/integer/oprf.rs +++ b/tfhe-benchmark/benches/integer/oprf.rs @@ -1,7 +1,8 @@ use benchmark::params::ParamsAndNumBlocksIter; #[cfg(any(feature = "gpu", feature = "hpu"))] use benchmark::utilities::throughput_num_threads; -use benchmark::utilities::{get_bench_type, write_to_json, BenchmarkType, OperatorType}; +use benchmark::utilities::{write_to_json_unchecked, OperatorType}; +use benchmark_spec::{get_bench_type, BenchmarkType}; use criterion::{black_box, Criterion, Throughput}; use rayon::prelude::*; #[cfg(any(feature = "gpu", feature = "hpu"))] @@ -125,7 +126,7 @@ pub fn unsigned_oprf(c: &mut Criterion) { (bench_id_oprf, "oprf"), (bench_id_oprf_bounded, "oprf_bounded"), ] { - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -263,7 +264,7 @@ pub mod cuda { (bench_id_oprf, "oprf"), (bench_id_oprf_bounded, "oprf_bounded"), ] { - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), diff --git a/tfhe-benchmark/benches/integer/rerand.rs b/tfhe-benchmark/benches/integer/rerand.rs index 252b734505..9f6899b94a 100644 --- a/tfhe-benchmark/benches/integer/rerand.rs +++ b/tfhe-benchmark/benches/integer/rerand.rs @@ -4,7 +4,8 @@ use benchmark::params_aliases::{ BENCH_PARAM_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128, BENCH_PARAM_PKE_TO_BIG_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128_ZKV1, }; -use benchmark::utilities::{get_bench_type, write_to_json, BenchmarkType, OperatorType}; +use benchmark::utilities::{write_to_json_unchecked, OperatorType}; +use benchmark_spec::{get_bench_type, BenchmarkType}; use criterion::{black_box, criterion_group, BatchSize, Criterion, Throughput}; #[cfg(feature = "gpu")] use cuda::gpu_re_randomize_group; @@ -200,7 +201,7 @@ fn execute_cpu_re_randomize(c: &mut Criterion, bit_size: usize, rerand_mode: Ben } } - write_to_json::( + write_to_json_unchecked::( &bench_id, (comp_param, param.into()), comp_param.name(), @@ -233,9 +234,8 @@ mod cuda { BENCH_PARAM_PKE_TO_BIG_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128_ZKV1, }; use benchmark::utilities::cuda_integer_utils::cuda_local_streams; - use benchmark::utilities::{ - get_bench_type, throughput_num_threads, write_to_json, BenchmarkType, OperatorType, - }; + use benchmark::utilities::{throughput_num_threads, write_to_json_unchecked, OperatorType}; + use benchmark_spec::{get_bench_type, BenchmarkType}; use criterion::{black_box, criterion_group, BatchSize, Criterion, Throughput}; use rayon::prelude::*; use tfhe::core_crypto::gpu::{get_number_of_gpus, CudaStreams}; @@ -439,7 +439,7 @@ mod cuda { } } - write_to_json::( + write_to_json_unchecked::( &bench_id, (comp_param, param.into()), comp_param.name(), diff --git a/tfhe-benchmark/benches/integer/signed_bench.rs b/tfhe-benchmark/benches/integer/signed_bench.rs index 3bfeb4e52e..f3ba7fb30a 100644 --- a/tfhe-benchmark/benches/integer/signed_bench.rs +++ b/tfhe-benchmark/benches/integer/signed_bench.rs @@ -1,7 +1,8 @@ use benchmark::params::ParamsAndNumBlocksIter; use benchmark::utilities::{ - get_bench_type, throughput_num_threads, write_to_json, BenchmarkType, EnvConfig, OperatorType, + throughput_num_threads, write_to_json_unchecked, EnvConfig, OperatorType, }; +use benchmark_spec::{get_bench_type, BenchmarkType}; use criterion::{criterion_group, Criterion, Throughput}; use rand::prelude::*; use rayon::prelude::*; @@ -116,7 +117,7 @@ fn bench_server_key_signed_binary_function_clean_inputs( } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -217,7 +218,7 @@ fn bench_server_key_signed_shift_function_clean_inputs( } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -303,7 +304,7 @@ fn bench_server_key_unary_function_clean_inputs( } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -400,7 +401,7 @@ fn signed_if_then_else_parallelized(c: &mut Criterion) { } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -942,7 +943,7 @@ fn bench_server_key_binary_scalar_function_clean_inputs( } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -1120,7 +1121,7 @@ fn signed_flip_parallelized(c: &mut Criterion) { } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -1475,7 +1476,7 @@ fn bench_server_key_signed_cast_function( ) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -1664,7 +1665,7 @@ mod cuda { } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -1802,7 +1803,7 @@ mod cuda { } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -1964,7 +1965,7 @@ mod cuda { } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -2141,7 +2142,7 @@ mod cuda { } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -2311,7 +2312,7 @@ mod cuda { } } - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), @@ -3084,7 +3085,7 @@ mod cuda { ) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, param, param.name(), diff --git a/tfhe-benchmark/benches/integer/trivium.rs b/tfhe-benchmark/benches/integer/trivium.rs index 73c0c736d1..b521930bf5 100644 --- a/tfhe-benchmark/benches/integer/trivium.rs +++ b/tfhe-benchmark/benches/integer/trivium.rs @@ -3,7 +3,7 @@ use criterion::Criterion; #[cfg(feature = "gpu")] pub mod cuda { use benchmark::params_aliases::BENCH_PARAM_GPU_MULTI_BIT_GROUP_4_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128; - use benchmark::utilities::{write_to_json, OperatorType}; + use benchmark::utilities::{write_to_json_unchecked, OperatorType}; use criterion::{black_box, criterion_group, Criterion}; use tfhe::core_crypto::gpu::CudaStreams; use tfhe::integer::gpu::ciphertext::CudaUnsignedRadixCiphertext; @@ -61,7 +61,7 @@ pub mod cuda { }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, atomic_param, param.name(), diff --git a/tfhe-benchmark/benches/integer/vector_find.rs b/tfhe-benchmark/benches/integer/vector_find.rs index 25d2b3043c..81cc85e31a 100644 --- a/tfhe-benchmark/benches/integer/vector_find.rs +++ b/tfhe-benchmark/benches/integer/vector_find.rs @@ -1,5 +1,5 @@ use benchmark::params_aliases::BENCH_PARAM_GPU_MULTI_BIT_GROUP_4_MESSAGE_2_CARRY_2_KS_PBS_TUNIFORM_2M128; -use benchmark::utilities::{write_to_json, OperatorType}; +use benchmark::utilities::{write_to_json_unchecked, OperatorType}; use criterion::{black_box, Criterion}; use tfhe::integer::keycache::KEY_CACHE; use tfhe::integer::{IntegerKeyKind, RadixClientKey}; @@ -39,7 +39,7 @@ pub fn match_value(c: &mut Criterion) { }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, atomic_param, param.name(), @@ -92,7 +92,7 @@ pub mod cuda { }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, atomic_param, param.name(), diff --git a/tfhe-benchmark/benches/integer/zk_pke.rs b/tfhe-benchmark/benches/integer/zk_pke.rs index a93d6c7c11..71fcfbba11 100644 --- a/tfhe-benchmark/benches/integer/zk_pke.rs +++ b/tfhe-benchmark/benches/integer/zk_pke.rs @@ -1,7 +1,6 @@ use benchmark::params_aliases::*; -use benchmark::utilities::{ - get_bench_type, throughput_num_threads, write_to_json, BenchmarkType, OperatorType, -}; +use benchmark::utilities::{throughput_num_threads, write_to_json_unchecked, OperatorType}; +use benchmark_spec::{get_bench_type, BenchmarkType}; use criterion::{criterion_group, Criterion, Throughput}; use rand::prelude::*; use rayon::prelude::*; @@ -192,7 +191,7 @@ fn cpu_pke_zk_proof(c: &mut Criterion) { let shortint_params: PBSParameters = param_fhe.into(); - write_to_json::( + write_to_json_unchecked::( &bench_id, shortint_params, param_name, @@ -273,7 +272,7 @@ fn cpu_pke_zk_verify(c: &mut Criterion, results_file: &Path) { format!("zk::crs_sizes::{param_name}::{bits}_bits_packed_ZK{zk_vers:?}"); write_result(&mut file, &test_name, crs_data.len()); - write_to_json::( + write_to_json_unchecked::( &test_name, shortint_params, param_name, @@ -327,7 +326,7 @@ fn cpu_pke_zk_verify(c: &mut Criterion, results_file: &Path) { &test_name, proven_ciphertext_list_serialized.len(), ); - write_to_json::( + write_to_json_unchecked::( &test_name, shortint_params, param_name, @@ -344,7 +343,7 @@ fn cpu_pke_zk_verify(c: &mut Criterion, results_file: &Path) { format!("zk::proof_sizes::{param_name}::{bits}_bits_packed_{crs_size}_bits_crs_{zk_load}_ZK{zk_vers:?}"); write_result(&mut file, &test_name, proof_size); - write_to_json::( + write_to_json_unchecked::( &test_name, shortint_params, param_name, @@ -447,7 +446,7 @@ fn cpu_pke_zk_verify(c: &mut Criterion, results_file: &Path) { } } - write_to_json::( + write_to_json_unchecked::( &bench_id_verify, shortint_params, param_name, @@ -457,7 +456,7 @@ fn cpu_pke_zk_verify(c: &mut Criterion, results_file: &Path) { vec![shortint_params.message_modulus().0.ilog2(); num_block], ); - write_to_json::( + write_to_json_unchecked::( &bench_id_verify_and_expand, shortint_params, param_name, @@ -562,7 +561,7 @@ mod cuda { format!("zk::crs_sizes::{param_name}::{bits}_bits_packed_ZK{zk_vers:?}"); write_result(&mut file, &test_name, crs_data.len()); - write_to_json::( + write_to_json_unchecked::( &test_name, param_fhe, param_name, @@ -636,7 +635,7 @@ mod cuda { &test_name, proven_ciphertext_list_serialized.len(), ); - write_to_json::( + write_to_json_unchecked::( &test_name, param_fhe, param_name, @@ -653,7 +652,7 @@ mod cuda { format!("zk::proof_sizes::{param_name}::{bits}_bits_packed_{crs_size}_bits_crs_{zk_load}_ZK{zk_vers:?}"); write_result(&mut file, &test_name, proof_size); - write_to_json::( + write_to_json_unchecked::( &test_name, param_fhe, param_name, @@ -799,7 +798,7 @@ mod cuda { (bench_id_expand_without_verify, "pke_zk_verify_only_expand"), (bench_id_verify_and_expand, "pke_zk_verify_and_expand"), ] { - write_to_json::( + write_to_json_unchecked::( &bench_id, param_fhe, param_name, diff --git a/tfhe-benchmark/benches/shortint/bench.rs b/tfhe-benchmark/benches/shortint/bench.rs index 68a38fa435..29a1da68a2 100644 --- a/tfhe-benchmark/benches/shortint/bench.rs +++ b/tfhe-benchmark/benches/shortint/bench.rs @@ -2,7 +2,7 @@ use benchmark::params::{ raw_benchmark_parameters, SHORTINT_BENCH_PARAMS_GAUSSIAN, SHORTINT_BENCH_PARAMS_TUNIFORM, SHORTINT_MULTI_BIT_BENCH_PARAMS, }; -use benchmark::utilities::{write_to_json, OperatorType}; +use benchmark::utilities::{write_to_json_unchecked, OperatorType}; use criterion::{criterion_group, Criterion}; use rand::Rng; use std::env; @@ -40,7 +40,7 @@ fn bench_server_key_unary_function( }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, *param, param.name(), @@ -85,7 +85,7 @@ fn bench_server_key_binary_function( }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, *param, param.name(), @@ -129,7 +129,7 @@ fn bench_server_key_binary_scalar_function( }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, *param, param.name(), @@ -177,7 +177,7 @@ fn bench_server_key_binary_scalar_division_function( }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, *param, param.name(), @@ -213,7 +213,7 @@ fn carry_extract_bench(c: &mut Criterion) { }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, *param, param.name(), @@ -252,7 +252,7 @@ fn programmable_bootstrapping_bench(c: &mut Criterion) { }) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, *param, param.name(), @@ -301,7 +301,7 @@ fn server_key_from_compressed_key(c: &mut Criterion) { ) }); - write_to_json::( + write_to_json_unchecked::( &bench_id, *param, param.name(), diff --git a/tfhe-benchmark/benches/shortint/casting.rs b/tfhe-benchmark/benches/shortint/casting.rs index f0162ac3ed..745ff50671 100644 --- a/tfhe-benchmark/benches/shortint/casting.rs +++ b/tfhe-benchmark/benches/shortint/casting.rs @@ -1,5 +1,5 @@ use benchmark::params_aliases::*; -use benchmark::utilities::{write_to_json, OperatorType}; +use benchmark::utilities::{write_to_json_unchecked, OperatorType}; use criterion::Criterion; use rayon::prelude::*; use tfhe::keycache::NamedParam; @@ -45,7 +45,7 @@ pub fn pack_cast_64(c: &mut Criterion) { }); }); - write_to_json::( + write_to_json_unchecked::( &bench_id, ks_param, ks_param_name, @@ -86,7 +86,7 @@ pub fn pack_cast(c: &mut Criterion) { }); }); - write_to_json::( + write_to_json_unchecked::( &bench_id, ks_param, ks_param_name, @@ -124,7 +124,7 @@ pub fn cast(c: &mut Criterion) { }); }); - write_to_json::( + write_to_json_unchecked::( &bench_id, ks_param, ks_param_name, diff --git a/tfhe-benchmark/src/bin/boolean_key_sizes.rs b/tfhe-benchmark/src/bin/boolean_key_sizes.rs index d2772bb986..b21988dced 100644 --- a/tfhe-benchmark/src/bin/boolean_key_sizes.rs +++ b/tfhe-benchmark/src/bin/boolean_key_sizes.rs @@ -1,4 +1,4 @@ -use benchmark::utilities::{write_to_json, OperatorType}; +use benchmark::utilities::{write_to_json_unchecked, OperatorType}; use std::fs::{File, OpenOptions}; use std::io::Write; use std::path::Path; @@ -39,7 +39,7 @@ fn client_server_key_sizes(results_file: &Path) { let test_name = format!("boolean_key_sizes_{params_name}_ksk"); write_result(&mut file, &test_name, ksk_size); - write_to_json::( + write_to_json_unchecked::( &test_name, *params, *params_name, @@ -59,7 +59,7 @@ fn client_server_key_sizes(results_file: &Path) { let test_name = format!("boolean_key_sizes_{params_name}_bsk"); write_result(&mut file, &test_name, bsk_size); - write_to_json::( + write_to_json_unchecked::( &test_name, *params, *params_name, diff --git a/tfhe-benchmark/src/bin/hlapi_ct_sizes.rs b/tfhe-benchmark/src/bin/hlapi_ct_sizes.rs index e22a45a329..7b6dfdac0a 100644 --- a/tfhe-benchmark/src/bin/hlapi_ct_sizes.rs +++ b/tfhe-benchmark/src/bin/hlapi_ct_sizes.rs @@ -1,6 +1,6 @@ use benchmark::params::{get_classical_tuniform_groups, get_multi_bit_tuniform_groups}; use benchmark::params_aliases::*; -use benchmark::utilities::{write_to_json, OperatorType}; +use benchmark::utilities::{write_to_json_unchecked, OperatorType}; use rand::Rng; use std::fs::{File, OpenOptions}; use std::io::Write; @@ -88,7 +88,7 @@ pub fn ct_sizes(results_file: &Path) { let mut write_and_record_result = |res: usize, test_name: &str, display_name: &str| { write_result(&mut file, test_name, res); - write_to_json::( + write_to_json_unchecked::( test_name, params_record, param_fhe.name(), @@ -206,7 +206,7 @@ pub fn cpk_and_cctl_sizes(results_file: &Path) { println!("PK size: {cpk_size} bytes"); write_result(&mut file, &test_name, cpk_size); - write_to_json::( + write_to_json_unchecked::( &test_name, params, params.name(), @@ -228,7 +228,7 @@ pub fn cpk_and_cctl_sizes(results_file: &Path) { println!("Compact CT list for {NB_CTXT} CTs: {cctl_size} bytes"); write_result(&mut file, &test_name, cctl_size); - write_to_json::( + write_to_json_unchecked::( &test_name, params, params.name(), @@ -274,7 +274,7 @@ pub fn cpk_and_cctl_sizes(results_file: &Path) { println!("Compact CT list for {NB_CTXT} CTs: {cctl_size} bytes"); write_result(&mut file, &test_name, cctl_size); - write_to_json::( + write_to_json_unchecked::( &test_name, params, params.name(), diff --git a/tfhe-benchmark/src/bin/shortint_key_sizes.rs b/tfhe-benchmark/src/bin/shortint_key_sizes.rs index 6b1f95da1a..a2e987283c 100644 --- a/tfhe-benchmark/src/bin/shortint_key_sizes.rs +++ b/tfhe-benchmark/src/bin/shortint_key_sizes.rs @@ -1,6 +1,6 @@ use benchmark::params::get_classical_tuniform_groups; use benchmark::params_aliases::*; -use benchmark::utilities::{write_to_json, CryptoParametersRecord, OperatorType}; +use benchmark::utilities::{write_to_json_unchecked, CryptoParametersRecord, OperatorType}; use std::fs::{File, OpenOptions}; use std::io::Write; use std::path::Path; @@ -84,7 +84,7 @@ fn client_server_key_sizes(results_file: &Path) { let test_name = format!("shortint_key_sizes_{}_ksk", params.name()); write_result(&mut file, &test_name, ksk_size); - write_to_json::( + write_to_json_unchecked::( &test_name, params, params.name(), @@ -104,7 +104,7 @@ fn client_server_key_sizes(results_file: &Path) { let test_name = format!("shortint_key_sizes_{}_bsk", params.name()); write_result(&mut file, &test_name, bsk_size); - write_to_json::( + write_to_json_unchecked::( &test_name, params, params.name(), @@ -125,7 +125,7 @@ fn client_server_key_sizes(results_file: &Path) { let test_name = format!("shortint_key_sizes_{}_bsk_compressed", params.name()); write_result(&mut file, &test_name, bsk_compressed_size); - write_to_json::( + write_to_json_unchecked::( &test_name, params, params.name(), @@ -158,7 +158,7 @@ fn measure_serialized_size( + write_to_json_unchecked::( &test_name, param.clone(), param_name, diff --git a/tfhe-benchmark/src/bin/wasm_benchmarks_parser.rs b/tfhe-benchmark/src/bin/wasm_benchmarks_parser.rs index fdfcef6c3f..5ed5814792 100644 --- a/tfhe-benchmark/src/bin/wasm_benchmarks_parser.rs +++ b/tfhe-benchmark/src/bin/wasm_benchmarks_parser.rs @@ -1,4 +1,4 @@ -use benchmark::utilities::{write_to_json, OperatorType}; +use benchmark::utilities::{write_to_json_unchecked, OperatorType}; use clap::Parser; use std::collections::HashMap; use std::fs; @@ -66,7 +66,7 @@ pub fn parse_wasm_benchmarks(results_file: &Path, raw_results_file: &Path) { write_result(&mut file, &prefixed_full_name, value_in_ns); } - write_to_json::( + write_to_json_unchecked::( &prefixed_full_name, params, params.name(), diff --git a/tfhe-benchmark/src/utilities.rs b/tfhe-benchmark/src/utilities.rs index 9ddeedadfc..a21268ba0f 100644 --- a/tfhe-benchmark/src/utilities.rs +++ b/tfhe-benchmark/src/utilities.rs @@ -1,3 +1,4 @@ +use benchmark_spec::{BenchmarkSpec, OperandType}; use criterion::Criterion; use serde::Serialize; use std::path::PathBuf; @@ -259,12 +260,6 @@ enum KeySetType { // Multi, } -#[derive(Serialize)] -pub enum OperandType { - CipherText, - PlainText, -} - #[derive(Clone, Serialize)] pub enum OperatorType { Atomic, @@ -292,10 +287,34 @@ struct BenchmarkParametersRecord { operator_type: OperatorType, } -/// Writes benchmarks parameters to disk in JSON format. +/// Writes benchmarks parameters to disk in JSON format, enforcing the bench name spec. pub fn write_to_json< Scalar: UnsignedInteger + Serialize, T: Into>, +>( + benchmark_spec: &BenchmarkSpec, + params: T, + display_name: impl Into, + operator_type: &OperatorType, + bit_size: u32, + decomposition_basis: Vec, +) { + write_to_json_unchecked( + &benchmark_spec.to_string(), + params, + benchmark_spec.param_name, + display_name, + operator_type, + bit_size, + decomposition_basis, + ) +} + +/// Writes benchmarks parameters to disk in JSON format. +/// Prefer `write_to_json` which enforces the bench name spec via `BenchmarkSpec`. +pub fn write_to_json_unchecked< + Scalar: UnsignedInteger + Serialize, + T: Into>, >( bench_id: &str, params: T, @@ -416,28 +435,6 @@ impl EnvConfig { } } -pub static BENCH_TYPE: OnceLock = OnceLock::new(); - -pub enum BenchmarkType { - Latency, - Throughput, -} - -impl BenchmarkType { - pub fn from_env() -> Result { - let raw_value = env::var("__TFHE_RS_BENCH_TYPE").unwrap_or("latency".to_string()); - match raw_value.to_lowercase().as_str() { - "latency" => Ok(BenchmarkType::Latency), - "throughput" => Ok(BenchmarkType::Throughput), - _ => Err(format!("benchmark type '{raw_value}' is not supported")), - } - } -} - -pub fn get_bench_type() -> &'static BenchmarkType { - BENCH_TYPE.get_or_init(|| BenchmarkType::from_env().unwrap()) -} - pub static PARAM_TYPE: OnceLock = OnceLock::new(); pub enum ParamType { diff --git a/utils/benchmark_spec/Cargo.toml b/utils/benchmark_spec/Cargo.toml new file mode 100644 index 0000000000..4962739190 --- /dev/null +++ b/utils/benchmark_spec/Cargo.toml @@ -0,0 +1,14 @@ +[package] +name = "benchmark_spec" +version = "0.1.0" +edition = "2024" +rust-version.workspace = true +publish = false + +[features] +gpu = [] +hpu = [] + +[dependencies] +strum = { version = "0.28", features = ["derive"] } +serde = { workspace = true, default-features = false, features = ["derive"] } diff --git a/utils/benchmark_spec/src/backend.rs b/utils/benchmark_spec/src/backend.rs new file mode 100644 index 0000000000..2b382f2275 --- /dev/null +++ b/utils/benchmark_spec/src/backend.rs @@ -0,0 +1,21 @@ +use strum::Display; + +#[derive(Clone, Copy, Display)] +#[strum(serialize_all = "snake_case")] +pub enum Backend { + Cpu, + Cuda, + Hpu, +} + +impl Backend { + pub fn from_cfg() -> Self { + if cfg!(feature = "gpu") { + Backend::Cuda + } else if cfg!(feature = "hpu") { + Backend::Hpu + } else { + Backend::Cpu + } + } +} diff --git a/utils/benchmark_spec/src/bench_crate.rs b/utils/benchmark_spec/src/bench_crate.rs new file mode 100644 index 0000000000..8c24962d76 --- /dev/null +++ b/utils/benchmark_spec/src/bench_crate.rs @@ -0,0 +1,24 @@ +use std::fmt; +use strum::Display; + +use crate::tfhe::TfheLayer; +use crate::traits::SpecFmt; + +#[derive(Display)] +#[strum(serialize_all = "snake_case")] +pub enum BenchCrate { + Tfhe(TfheLayer), +} + +impl BenchCrate { + fn layer(&self) -> &dyn SpecFmt { + match self { + BenchCrate::Tfhe(layer) => layer, + } + } + + pub(crate) fn fmt_crate(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{self}")?; + self.layer().fmt_spec(f) + } +} diff --git a/utils/benchmark_spec/src/lib.rs b/utils/benchmark_spec/src/lib.rs new file mode 100644 index 0000000000..a112677ee3 --- /dev/null +++ b/utils/benchmark_spec/src/lib.rs @@ -0,0 +1,206 @@ +mod backend; +mod bench_crate; +pub mod tfhe; +mod traits; + +pub use backend::Backend; +pub use bench_crate::BenchCrate; +use serde::Serialize; +use std::{env, fmt}; +pub use tfhe::hlapi::HlapiBench; +pub use tfhe::{AtomicOp, TfheLayer}; + +#[derive(Serialize)] +pub enum OperandType { + CipherText, + PlainText, +} + +impl OperandType { + pub fn is_scalar(&self) -> bool { + matches!(self, OperandType::PlainText) + } +} + +#[derive(Serialize)] +pub enum BenchmarkType { + Latency, + Throughput, +} + +impl BenchmarkType { + pub fn from_env() -> Result { + let raw_value = env::var("__TFHE_RS_BENCH_TYPE").unwrap_or("latency".to_string()); + match raw_value.to_lowercase().as_str() { + "latency" => Ok(BenchmarkType::Latency), + "throughput" => Ok(BenchmarkType::Throughput), + _ => Err(format!("benchmark type '{raw_value}' is not supported")), + } + } +} + +pub fn get_bench_type() -> &'static BenchmarkType { + use std::sync::OnceLock; + static BENCH_TYPE: OnceLock = OnceLock::new(); + BENCH_TYPE.get_or_init(|| BenchmarkType::from_env().unwrap()) +} + +/// Enforces the naming convention for benchmark IDs. +/// +/// ```text +/// {crate}::{layer}::{bench}::{op}(::{backend})?(::{throughput})?::{param}(::scalar)?(::{type})? +/// ``` +/// +/// `param_name` and `type_name` are kept as `&str` because their values +/// are generated dynamically: `type_name` comes from `stringify!()` in +/// bench macros, and `param_name` comes from `NamedParam::name()` at runtime. +pub struct BenchmarkSpec<'a> { + pub bench_crate: BenchCrate, + pub backend: Backend, + pub param_name: &'a str, + pub operand_type: &'a OperandType, + pub type_name: Option<&'a str>, + pub bench_type: &'a BenchmarkType, +} + +impl<'a> BenchmarkSpec<'a> { + pub fn new( + bench_crate: BenchCrate, + backend: Backend, + param_name: &'a str, + operand_type: &'a OperandType, + type_name: Option<&'a str>, + bench_type: &'a BenchmarkType, + ) -> Self { + Self { + bench_crate, + backend, + param_name, + operand_type, + type_name, + bench_type, + } + } + + pub fn new_hlapi( + hlapi_op: AtomicOp, + param_name: &'a str, + operand_type: &'a OperandType, + type_name: Option<&'a str>, + bench_type: &'a BenchmarkType, + ) -> Self { + Self { + bench_crate: BenchCrate::Tfhe(TfheLayer::Hlapi(HlapiBench::Ops(hlapi_op))), + backend: Backend::from_cfg(), + param_name, + operand_type, + type_name, + bench_type, + } + } +} + +impl fmt::Display for BenchmarkSpec<'_> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + self.bench_crate.fmt_crate(f)?; + if !matches!(self.backend, Backend::Cpu) { + write!(f, "::{}", self.backend)?; + } + if matches!(self.bench_type, BenchmarkType::Throughput) { + write!(f, "::throughput")?; + } + write!(f, "::{}", self.param_name)?; + if self.operand_type.is_scalar() { + write!(f, "::scalar")?; + } + if let Some(type_name) = self.type_name { + write!(f, "::{type_name}")?; + } + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn hlapi_cpu_latency() { + let spec = BenchmarkSpec::new( + BenchCrate::Tfhe(TfheLayer::Hlapi(HlapiBench::Ops(AtomicOp::Add))), + Backend::Cpu, + "PARAM_MESSAGE_2_CARRY_2", + &OperandType::CipherText, + Some("FheUint64"), + &BenchmarkType::Latency, + ); + assert_eq!( + spec.to_string(), + "tfhe::hlapi::ops::add::PARAM_MESSAGE_2_CARRY_2::FheUint64" + ); + } + + #[test] + fn hlapi_cuda_latency() { + let spec = BenchmarkSpec::new( + BenchCrate::Tfhe(TfheLayer::Hlapi(HlapiBench::Ops(AtomicOp::Mul))), + Backend::Cuda, + "PARAM_MESSAGE_2_CARRY_2", + &OperandType::CipherText, + Some("FheUint128"), + &BenchmarkType::Latency, + ); + assert_eq!( + spec.to_string(), + "tfhe::hlapi::ops::mul::cuda::PARAM_MESSAGE_2_CARRY_2::FheUint128" + ); + } + + #[test] + fn hlapi_hpu_throughput() { + let spec = BenchmarkSpec::new( + BenchCrate::Tfhe(TfheLayer::Hlapi(HlapiBench::Ops(AtomicOp::Add))), + Backend::Hpu, + "PARAM_MESSAGE_2_CARRY_2", + &OperandType::CipherText, + Some("FheUint64"), + &BenchmarkType::Throughput, + ); + assert_eq!( + spec.to_string(), + "tfhe::hlapi::ops::add::hpu::throughput::PARAM_MESSAGE_2_CARRY_2::FheUint64" + ); + } + + #[test] + fn hlapi_scalar() { + let spec = BenchmarkSpec::new( + BenchCrate::Tfhe(TfheLayer::Hlapi(HlapiBench::Ops(AtomicOp::LeftShift))), + Backend::Cpu, + "PARAM_MESSAGE_2_CARRY_2", + &OperandType::PlainText, + Some("FheUint64"), + &BenchmarkType::Latency, + ); + assert_eq!( + spec.to_string(), + "tfhe::hlapi::ops::left_shift::PARAM_MESSAGE_2_CARRY_2::scalar::FheUint64" + ); + } + + #[test] + fn hlapi_no_type_name() { + let spec = BenchmarkSpec::new( + BenchCrate::Tfhe(TfheLayer::Hlapi(HlapiBench::Ops(AtomicOp::Neg))), + Backend::Cpu, + "PARAM_MESSAGE_2_CARRY_2", + &OperandType::CipherText, + None, + &BenchmarkType::Latency, + ); + assert_eq!( + spec.to_string(), + "tfhe::hlapi::ops::neg::PARAM_MESSAGE_2_CARRY_2" + ); + } +} diff --git a/utils/benchmark_spec/src/tfhe/atomic_op.rs b/utils/benchmark_spec/src/tfhe/atomic_op.rs new file mode 100644 index 0000000000..c72ee34a25 --- /dev/null +++ b/utils/benchmark_spec/src/tfhe/atomic_op.rs @@ -0,0 +1,48 @@ +use strum::Display; + +/// Atomic operations shared across layers (hlapi, integer...). +#[derive(Clone, Copy, Display)] +#[strum(serialize_all = "snake_case")] +pub enum AtomicOp { + Add, + Bitand, + Bitor, + Bitxor, + CheckedIlog2, + CountOnes, + CountZeros, + Div, + DivRem, + Eq, + Flip, + Ge, + Gt, + IfThenElse, + Ilog2, + IsEven, + IsOdd, + Le, + LeadingOnes, + LeadingZeros, + LeftRotate, + LeftShift, + Lt, + Max, + Min, + Mul, + Ne, + Neg, + Not, + OverflowingAdd, + OverflowingMul, + OverflowingNeg, + OverflowingSub, + Rem, + ReverseBits, + RightRotate, + RightShift, + Sub, + Sum, + TrailingOnes, + TrailingZeros, +} diff --git a/utils/benchmark_spec/src/tfhe/hlapi/mod.rs b/utils/benchmark_spec/src/tfhe/hlapi/mod.rs new file mode 100644 index 0000000000..f07d6475a6 --- /dev/null +++ b/utils/benchmark_spec/src/tfhe/hlapi/mod.rs @@ -0,0 +1,34 @@ +use std::fmt; +use strum::Display; + +use crate::traits::SpecFmt; + +pub use super::atomic_op::AtomicOp; + +/// Benchmark categories within the HLAPI layer. +/// +/// Each variant represents a category of benchmarks (ops, erc20, dex, etc.) +/// and carries its own op enum. Adding a new category requires: +/// 1. Add the variant here (strum handles the name) +/// 2. Add a match arm in `op()` to return the inner op +/// +/// `SpecFmt` is already implemented generically — no change needed there. +#[derive(Display)] +#[strum(serialize_all = "snake_case")] +pub enum HlapiBench { + Ops(AtomicOp), +} + +impl HlapiBench { + fn op(&self) -> &dyn fmt::Display { + match self { + HlapiBench::Ops(op) => op, + } + } +} + +impl SpecFmt for HlapiBench { + fn fmt_spec(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "::{}::{}", self, self.op()) + } +} diff --git a/utils/benchmark_spec/src/tfhe/mod.rs b/utils/benchmark_spec/src/tfhe/mod.rs new file mode 100644 index 0000000000..6ab761a8bf --- /dev/null +++ b/utils/benchmark_spec/src/tfhe/mod.rs @@ -0,0 +1,38 @@ +pub mod atomic_op; +pub mod hlapi; + +use std::fmt; +use strum::Display; + +use crate::traits::SpecFmt; + +pub use atomic_op::AtomicOp; +pub use hlapi::HlapiBench; + +/// Layers of the `tfhe` crate. +/// +/// Adding a new layer requires: +/// 1. Add the variant here (strum handles the name) +/// 2. Add a match arm in `bench()` — the inner type must implement `SpecFmt` +/// +/// `SpecFmt` is already implemented generically — no change needed there. +#[derive(Display)] +#[strum(serialize_all = "snake_case")] +pub enum TfheLayer { + Hlapi(HlapiBench), +} + +impl TfheLayer { + fn bench(&self) -> &dyn SpecFmt { + match self { + TfheLayer::Hlapi(bench) => bench, + } + } +} + +impl SpecFmt for TfheLayer { + fn fmt_spec(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "::{self}")?; + self.bench().fmt_spec(f) + } +} diff --git a/utils/benchmark_spec/src/traits.rs b/utils/benchmark_spec/src/traits.rs new file mode 100644 index 0000000000..18c00cc396 --- /dev/null +++ b/utils/benchmark_spec/src/traits.rs @@ -0,0 +1,7 @@ +use std::fmt; + +/// Any level in the benchmark spec hierarchy must implement this. +/// Used by layers (hlapi, integer...) and bench categories (ops, erc20...). +pub(crate) trait SpecFmt: fmt::Display { + fn fmt_spec(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result; +}