chore(gpu): fix parameter name mismatches between declarations and definitions

Author: pdroalves

backends/tfhe-cuda-backend/cuda/include/pbs/programmable_bootstrap.h

@@ -88,9 +88,9 @@ void cuda_programmable_bootstrap_128_async(
     uint32_t level_count, uint32_t num_samples);
 
 void cleanup_cuda_programmable_bootstrap_64(void *stream, uint32_t gpu_index,
-                                            int8_t **pbs_buffer);
+                                            int8_t **buffer);
 
 void cleanup_cuda_programmable_bootstrap_128(void *stream, uint32_t gpu_index,
-                                             int8_t **pbs_buffer);
+                                             int8_t **buffer);
 }
 #endif // CUDA_BOOTSTRAP_H

backends/tfhe-cuda-backend/cuda/include/pbs/programmable_bootstrap_multibit.h

@@ -21,8 +21,8 @@ void cuda_convert_lwe_multi_bit_programmable_bootstrap_key_128_async(
     uint32_t polynomial_size, uint32_t grouping_factor);
 
 uint64_t scratch_cuda_multi_bit_programmable_bootstrap_64_async(
-    void *stream, uint32_t gpu_index, int8_t **pbs_buffer,
-    uint32_t glwe_dimension, uint32_t polynomial_size, uint32_t level_count,
+    void *stream, uint32_t gpu_index, int8_t **buffer, uint32_t glwe_dimension,
+    uint32_t polynomial_size, uint32_t level_count,
     uint32_t input_lwe_ciphertext_count, bool allocate_gpu_memory);
 
 void cuda_multi_bit_programmable_bootstrap_64_async(
@@ -37,17 +37,17 @@ void cuda_multi_bit_programmable_bootstrap_64_async(
 
 void cleanup_cuda_multi_bit_programmable_bootstrap_64(void *stream,
                                                       uint32_t gpu_index,
-                                                      int8_t **pbs_buffer);
+                                                      int8_t **buffer);
 
 // Noise-tests-namespaced wrappers for scratch/cleanup, so that callers
 // working with the noise-tests PBS variant use a consistent naming scheme.
 uint64_t scratch_cuda_multi_bit_programmable_bootstrap_noise_tests_64_async(
-    void *stream, uint32_t gpu_index, int8_t **pbs_buffer,
-    uint32_t glwe_dimension, uint32_t polynomial_size, uint32_t level_count,
+    void *stream, uint32_t gpu_index, int8_t **buffer, uint32_t glwe_dimension,
+    uint32_t polynomial_size, uint32_t level_count,
     uint32_t input_lwe_ciphertext_count, bool allocate_gpu_memory);
 
 void cleanup_cuda_multi_bit_programmable_bootstrap_noise_tests_64(
-    void *stream, uint32_t gpu_index, int8_t **pbs_buffer);
+    void *stream, uint32_t gpu_index, int8_t **buffer);
 
 // Noise tests variant: 64-bit torus, polynomial_size=2048 only. Uses the
 // NOISE_TESTS keybundle mode for noise analysis purposes.

backends/tfhe-cuda-backend/cuda/src/crypto/keyswitch.cu

@@ -25,7 +25,7 @@ void cuda_keyswitch_gemm_64_64_async(
     void const *lwe_output_indexes, void const *lwe_array_in,
     void const *lwe_input_indexes, void const *ksk, uint32_t lwe_dimension_in,
     uint32_t lwe_dimension_out, uint32_t base_log, uint32_t level_count,
-    uint32_t num_samples, bool uses_trivial_indices) {
+    uint32_t num_samples, bool uses_trivial_indexes) {
 
   host_gemm_keyswitch_lwe_ciphertext_vector<uint64_t, uint64_t>(
       static_cast<cudaStream_t>(stream), gpu_index,
@@ -34,7 +34,7 @@ void cuda_keyswitch_gemm_64_64_async(
       static_cast<const uint64_t *>(lwe_array_in),
       static_cast<const uint64_t *>(lwe_input_indexes),
       static_cast<const uint64_t *>(ksk), lwe_dimension_in, lwe_dimension_out,
-      base_log, level_count, num_samples, uses_trivial_indices);
+      base_log, level_count, num_samples, uses_trivial_indexes);
 }
 
 /* Perform keyswitch on a batch of 64 bits input LWE ciphertexts
@@ -46,7 +46,7 @@ void cuda_keyswitch_gemm_64_32_async(
     void const *lwe_output_indexes, void const *lwe_array_in,
     void const *lwe_input_indexes, void const *ksk, uint32_t lwe_dimension_in,
     uint32_t lwe_dimension_out, uint32_t base_log, uint32_t level_count,
-    uint32_t num_samples, bool uses_trivial_indices) {
+    uint32_t num_samples, bool uses_trivial_indexes) {
 
   host_gemm_keyswitch_lwe_ciphertext_vector<uint64_t, uint32_t>(
       static_cast<cudaStream_t>(stream), gpu_index,
@@ -55,7 +55,7 @@ void cuda_keyswitch_gemm_64_32_async(
       static_cast<const uint64_t *>(lwe_array_in),
       static_cast<const uint64_t *>(lwe_input_indexes),
       static_cast<const uint32_t *>(ksk), lwe_dimension_in, lwe_dimension_out,
-      base_log, level_count, num_samples, uses_trivial_indices);
+      base_log, level_count, num_samples, uses_trivial_indexes);
 }
 
 void cuda_keyswitch_lwe_ciphertext_vector_64_64_async(

backends/tfhe-cuda-backend/cuda/src/integer/comparison.cu

@@ -3,7 +3,7 @@
 uint64_t scratch_cuda_integer_comparison_64_async(
     CudaStreamsFFI streams, int8_t **mem_ptr,
     CudaLweBootstrapKeyParamsFFI bsk_params,
-    CudaLweKeyswitchKeyParamsFFI ksk_params, uint32_t num_radix_blocks,
+    CudaLweKeyswitchKeyParamsFFI ksk_params, uint32_t lwe_ciphertext_count,
     uint32_t message_modulus, uint32_t carry_modulus, COMPARISON_TYPE op_type,
     bool is_signed, bool allocate_gpu_memory,
     PBS_MS_REDUCTION_T noise_reduction_type) {
@@ -17,7 +17,8 @@ uint64_t scratch_cuda_integer_comparison_64_async(
   case NE:
     size_tracker += scratch_cuda_comparison_check<uint64_t>(
         CudaStreams(streams), (int_comparison_buffer<uint64_t> **)mem_ptr,
-        num_radix_blocks, params, op_type, false, false, allocate_gpu_memory);
+        lwe_ciphertext_count, params, op_type, false, false,
+        allocate_gpu_memory);
     break;
   case GT:
   case GE:
@@ -27,7 +28,7 @@ uint64_t scratch_cuda_integer_comparison_64_async(
   case MIN:
     size_tracker += scratch_cuda_comparison_check<uint64_t>(
         CudaStreams(streams), (int_comparison_buffer<uint64_t> **)mem_ptr,
-        num_radix_blocks, params, op_type, is_signed, true,
+        lwe_ciphertext_count, params, op_type, is_signed, true,
         allocate_gpu_memory);
     break;
   }
@@ -38,7 +39,7 @@ uint64_t scratch_cuda_integer_comparison_64_async(
 uint64_t scratch_cuda_integer_scalar_comparison_64_async(
     CudaStreamsFFI streams, int8_t **mem_ptr,
     CudaLweBootstrapKeyParamsFFI bsk_params,
-    CudaLweKeyswitchKeyParamsFFI ksk_params, uint32_t num_radix_blocks,
+    CudaLweKeyswitchKeyParamsFFI ksk_params, uint32_t lwe_ciphertext_count,
     uint32_t message_modulus, uint32_t carry_modulus, COMPARISON_TYPE op_type,
     bool is_signed, bool allocate_gpu_memory,
     PBS_MS_REDUCTION_T noise_reduction_type) {
@@ -52,7 +53,8 @@ uint64_t scratch_cuda_integer_scalar_comparison_64_async(
   case NE:
     size_tracker += scratch_cuda_comparison_check<uint64_t>(
         CudaStreams(streams), (int_comparison_buffer<uint64_t> **)mem_ptr,
-        num_radix_blocks, params, op_type, false, false, allocate_gpu_memory);
+        lwe_ciphertext_count, params, op_type, false, false,
+        allocate_gpu_memory);
     break;
   case GT:
   case GE:
@@ -62,7 +64,7 @@ uint64_t scratch_cuda_integer_scalar_comparison_64_async(
   case MIN:
     size_tracker += scratch_cuda_comparison_check<uint64_t>(
         CudaStreams(streams), (int_comparison_buffer<uint64_t> **)mem_ptr,
-        num_radix_blocks, params, op_type, is_signed, false,
+        lwe_ciphertext_count, params, op_type, is_signed, false,
         allocate_gpu_memory);
     break;
   }

backends/tfhe-cuda-backend/cuda/src/integer/integer.cu

@@ -174,16 +174,17 @@ void cleanup_cuda_integer_overflowing_sub_64_inplace(CudaStreamsFFI streams,
 uint64_t scratch_cuda_apply_univariate_lut_64_async(
     CudaStreamsFFI streams, int8_t **mem_ptr, void const *input_lut,
     CudaLweBootstrapKeyParamsFFI bsk_params,
-    CudaLweKeyswitchKeyParamsFFI ksk_params, uint32_t num_radix_blocks,
-    uint32_t message_modulus, uint32_t carry_modulus, uint64_t lut_degree,
-    bool allocate_gpu_memory, PBS_MS_REDUCTION_T noise_reduction_type) {
+    CudaLweKeyswitchKeyParamsFFI ksk_params,
+    uint32_t input_lwe_ciphertext_count, uint32_t message_modulus,
+    uint32_t carry_modulus, uint64_t lut_degree, bool allocate_gpu_memory,
+    PBS_MS_REDUCTION_T noise_reduction_type) {
   int_radix_params params(bsk_params, ksk_params, message_modulus,
                           carry_modulus, noise_reduction_type);
 
   return scratch_cuda_apply_univariate_lut<uint64_t>(
       CudaStreams(streams), (int_radix_lut<uint64_t> **)mem_ptr,
-      static_cast<const uint64_t *>(input_lut), num_radix_blocks, params,
-      lut_degree, allocate_gpu_memory);
+      static_cast<const uint64_t *>(input_lut), input_lwe_ciphertext_count,
+      params, lut_degree, allocate_gpu_memory);
 }
 
 uint64_t scratch_cuda_apply_many_univariate_lut_64_async(
@@ -238,16 +239,16 @@ void cleanup_cuda_apply_many_univariate_lut_64(CudaStreamsFFI streams,
 void cuda_apply_many_univariate_lut_64_async(
     CudaStreamsFFI streams, CudaRadixCiphertextFFI *output_radix_lwe,
     CudaRadixCiphertextFFI const *input_radix_lwe, int8_t *mem_ptr,
-    void *const *ksks, void *const *bsks, uint32_t num_many_lut,
+    void *const *ksks, void *const *bsks, uint32_t num_luts,
     uint32_t lut_stride) {
   PANIC_IF_FALSE(output_radix_lwe != input_radix_lwe,
                  "Output and input pointers must be different for out-of-place "
                  "operations");
 
   host_apply_many_univariate_lut<uint64_t>(
       CudaStreams(streams), output_radix_lwe, input_radix_lwe,
-      (int_radix_lut<uint64_t> *)mem_ptr, (uint64_t **)(ksks), bsks,
-      num_many_lut, lut_stride);
+      (int_radix_lut<uint64_t> *)mem_ptr, (uint64_t **)(ksks), bsks, num_luts,
+      lut_stride);
 }
 
 void cuda_integer_reverse_blocks_64_inplace_async(
@@ -291,7 +292,7 @@ uint64_t scratch_cuda_apply_noise_squashing_async(
     CudaStreamsFFI streams, int8_t **mem_ptr,
     CudaLweBootstrapKeyParamsFFI bsk_params, uint32_t input_glwe_dimension,
     uint32_t input_polynomial_size, CudaLweKeyswitchKeyParamsFFI ksk_params,
-    uint32_t num_radix_blocks, uint32_t original_num_blocks,
+    uint32_t num_radix_blocks, uint32_t num_original_blocks,
     uint32_t message_modulus, uint32_t carry_modulus, bool allocate_gpu_memory,
     PBS_MS_REDUCTION_T noise_reduction_type) {
   int_radix_params params(bsk_params, ksk_params, message_modulus,
@@ -300,7 +301,7 @@ uint64_t scratch_cuda_apply_noise_squashing_async(
   return scratch_cuda_apply_noise_squashing_mem(
       streams, params, (int_noise_squashing_lut<uint64_t> **)mem_ptr,
       input_glwe_dimension, input_polynomial_size, num_radix_blocks,
-      original_num_blocks, allocate_gpu_memory);
+      num_original_blocks, allocate_gpu_memory);
 }
 
 void cuda_apply_noise_squashing_async(

backends/tfhe-cuda-backend/cuda/src/integer/scalar_mul.cu

@@ -17,13 +17,13 @@ uint64_t scratch_cuda_integer_scalar_mul_64_async(
 void cuda_integer_scalar_mul_64_async(
     CudaStreamsFFI streams, CudaRadixCiphertextFFI *lwe_array,
     uint64_t const *decomposed_scalar, uint64_t const *has_at_least_one_set,
-    int8_t *mem, void *const *bsks, void *const *ksks,
+    int8_t *mem_ptr, void *const *bsks, void *const *ksks,
     uint32_t /*polynomial_size*/, uint32_t message_modulus,
     uint32_t num_scalars) {
 
   host_integer_scalar_mul_radix<uint64_t>(
       CudaStreams(streams), lwe_array, decomposed_scalar, has_at_least_one_set,
-      reinterpret_cast<int_scalar_mul_buffer<uint64_t> *>(mem), bsks,
+      reinterpret_cast<int_scalar_mul_buffer<uint64_t> *>(mem_ptr), bsks,
       (uint64_t **)(ksks), message_modulus, num_scalars);
 }
 

backends/tfhe-cuda-backend/cuda/src/linearalgebra/multiplication.cu

@@ -34,10 +34,10 @@ void cuda_wrapping_polynomial_mul_one_to_many_64_async(
 }
 
 void cuda_glwe_wrapping_polynomial_mul_one_to_many_64_async(
-    void *stream, uint32_t gpu_index, void *result, void const *glwe_lhs,
+    void *stream, uint32_t gpu_index, void *result, void const *poly_lhs,
     int8_t *circulant, void const *poly_rhs, uint32_t polynomial_size,
     uint32_t glwe_dimension, uint32_t n_rhs) {
-  PANIC_IF_FALSE(result != glwe_lhs,
+  PANIC_IF_FALSE(result != poly_lhs,
                  "Output and left input pointers must be different for "
                  "out-of-place operations");
   PANIC_IF_FALSE(result != poly_rhs,
@@ -46,7 +46,7 @@ void cuda_glwe_wrapping_polynomial_mul_one_to_many_64_async(
 
   host_glwe_wrapping_polynomial_mul_one_to_many<uint64_t, ulonglong4>(
       static_cast<cudaStream_t>(stream), gpu_index,
-      static_cast<uint64_t *>(result), static_cast<uint64_t const *>(glwe_lhs),
+      static_cast<uint64_t *>(result), static_cast<uint64_t const *>(poly_lhs),
       circulant, static_cast<uint64_t const *>(poly_rhs), polynomial_size,
       glwe_dimension, n_rhs);
 }