1use crate::ffi;
4
5unsafe extern "C" {
6 pub fn cuda_convert_lwe_ciphertext_vector_to_gpu_64(
7 stream: *mut ffi::c_void,
8 gpu_index: u32,
9 dest: *mut ffi::c_void,
10 src: *const ffi::c_void,
11 number_of_cts: u32,
12 lwe_dimension: u32,
13 );
14}
15unsafe extern "C" {
16 pub fn cuda_convert_lwe_ciphertext_vector_to_cpu_64(
17 stream: *mut ffi::c_void,
18 gpu_index: u32,
19 dest: *mut ffi::c_void,
20 src: *const ffi::c_void,
21 number_of_cts: u32,
22 lwe_dimension: u32,
23 );
24}
25unsafe extern "C" {
26 pub fn cuda_glwe_sample_extract_64(
27 stream: *mut ffi::c_void,
28 gpu_index: u32,
29 lwe_array_out: *mut ffi::c_void,
30 glwe_array_in: *const ffi::c_void,
31 nth_array: *const u32,
32 num_nths: u32,
33 lwe_per_glwe: u32,
34 glwe_dimension: u32,
35 polynomial_size: u32,
36 );
37}
38unsafe extern "C" {
39 pub fn cuda_modulus_switch_inplace_64(
40 stream: *mut ffi::c_void,
41 gpu_index: u32,
42 lwe_array_out: *mut ffi::c_void,
43 size: u32,
44 log_modulus: u32,
45 );
46}
47unsafe extern "C" {
48 pub fn cuda_modulus_switch_64(
49 stream: *mut ffi::c_void,
50 gpu_index: u32,
51 lwe_out: *mut ffi::c_void,
52 lwe_in: *const ffi::c_void,
53 size: u32,
54 log_modulus: u32,
55 );
56}
57unsafe extern "C" {
58 pub fn cuda_centered_modulus_switch_64(
59 stream: *mut ffi::c_void,
60 gpu_index: u32,
61 lwe_out: *mut ffi::c_void,
62 lwe_in: *const ffi::c_void,
63 lwe_dimension: u32,
64 log_modulus: u32,
65 );
66}
67unsafe extern "C" {
68 pub fn cuda_improve_noise_modulus_switch_64(
69 stream: *mut ffi::c_void,
70 gpu_index: u32,
71 lwe_array_out: *mut ffi::c_void,
72 lwe_array_in: *const ffi::c_void,
73 lwe_array_indexes: *const ffi::c_void,
74 encrypted_zeros: *const ffi::c_void,
75 lwe_size: u32,
76 num_lwes: u32,
77 num_zeros: u32,
78 input_variance: f64,
79 r_sigma: f64,
80 bound: f64,
81 log_modulus: u32,
82 );
83}
84unsafe extern "C" {
85 pub fn cuda_glwe_sample_extract_128(
86 stream: *mut ffi::c_void,
87 gpu_index: u32,
88 lwe_array_out: *mut ffi::c_void,
89 glwe_array_in: *const ffi::c_void,
90 nth_array: *const u32,
91 num_nths: u32,
92 lwe_per_glwe: u32,
93 glwe_dimension: u32,
94 polynomial_size: u32,
95 );
96}
97pub const PBS_TYPE_MULTI_BIT: PBS_TYPE = 0;
98pub const PBS_TYPE_CLASSICAL: PBS_TYPE = 1;
99pub type PBS_TYPE = ffi::c_uint;
100pub const PBS_MS_REDUCTION_T_NO_REDUCTION: PBS_MS_REDUCTION_T = 0;
101pub const PBS_MS_REDUCTION_T_DRIFT: PBS_MS_REDUCTION_T = 1;
102pub const PBS_MS_REDUCTION_T_CENTERED: PBS_MS_REDUCTION_T = 2;
103pub type PBS_MS_REDUCTION_T = ffi::c_uint;
104#[repr(C)]
105#[derive(Debug, Copy, Clone)]
106pub struct CudaModulusSwitchNoiseReductionKeyFFI {
107 pub ptr: *const *mut ffi::c_void,
108 pub num_zeros: u32,
109 pub ms_bound: f64,
110 pub ms_r_sigma: f64,
111 pub ms_input_variance: f64,
112}
113#[allow(clippy::unnecessary_operation, clippy::identity_op)]
114const _: () = {
115 ["Size of CudaModulusSwitchNoiseReductionKeyFFI"]
116 [::std::mem::size_of::<CudaModulusSwitchNoiseReductionKeyFFI>() - 40usize];
117 ["Alignment of CudaModulusSwitchNoiseReductionKeyFFI"]
118 [::std::mem::align_of::<CudaModulusSwitchNoiseReductionKeyFFI>() - 8usize];
119 ["Offset of field: CudaModulusSwitchNoiseReductionKeyFFI::ptr"]
120 [::std::mem::offset_of!(CudaModulusSwitchNoiseReductionKeyFFI, ptr) - 0usize];
121 ["Offset of field: CudaModulusSwitchNoiseReductionKeyFFI::num_zeros"]
122 [::std::mem::offset_of!(CudaModulusSwitchNoiseReductionKeyFFI, num_zeros) - 8usize];
123 ["Offset of field: CudaModulusSwitchNoiseReductionKeyFFI::ms_bound"]
124 [::std::mem::offset_of!(CudaModulusSwitchNoiseReductionKeyFFI, ms_bound) - 16usize];
125 ["Offset of field: CudaModulusSwitchNoiseReductionKeyFFI::ms_r_sigma"]
126 [::std::mem::offset_of!(CudaModulusSwitchNoiseReductionKeyFFI, ms_r_sigma) - 24usize];
127 ["Offset of field: CudaModulusSwitchNoiseReductionKeyFFI::ms_input_variance"][::std::mem::offset_of!(
128 CudaModulusSwitchNoiseReductionKeyFFI,
129 ms_input_variance
130 ) - 32usize];
131};
132pub const SHIFT_OR_ROTATE_TYPE_LEFT_SHIFT: SHIFT_OR_ROTATE_TYPE = 0;
133pub const SHIFT_OR_ROTATE_TYPE_RIGHT_SHIFT: SHIFT_OR_ROTATE_TYPE = 1;
134pub const SHIFT_OR_ROTATE_TYPE_LEFT_ROTATE: SHIFT_OR_ROTATE_TYPE = 2;
135pub const SHIFT_OR_ROTATE_TYPE_RIGHT_ROTATE: SHIFT_OR_ROTATE_TYPE = 3;
136pub type SHIFT_OR_ROTATE_TYPE = ffi::c_uint;
137pub const BITOP_TYPE_BITAND: BITOP_TYPE = 0;
138pub const BITOP_TYPE_BITOR: BITOP_TYPE = 1;
139pub const BITOP_TYPE_BITXOR: BITOP_TYPE = 2;
140pub const BITOP_TYPE_SCALAR_BITAND: BITOP_TYPE = 3;
141pub const BITOP_TYPE_SCALAR_BITOR: BITOP_TYPE = 4;
142pub const BITOP_TYPE_SCALAR_BITXOR: BITOP_TYPE = 5;
143pub type BITOP_TYPE = ffi::c_uint;
144pub const COMPARISON_TYPE_EQ: COMPARISON_TYPE = 0;
145pub const COMPARISON_TYPE_NE: COMPARISON_TYPE = 1;
146pub const COMPARISON_TYPE_GT: COMPARISON_TYPE = 2;
147pub const COMPARISON_TYPE_GE: COMPARISON_TYPE = 3;
148pub const COMPARISON_TYPE_LT: COMPARISON_TYPE = 4;
149pub const COMPARISON_TYPE_LE: COMPARISON_TYPE = 5;
150pub const COMPARISON_TYPE_MAX: COMPARISON_TYPE = 6;
151pub const COMPARISON_TYPE_MIN: COMPARISON_TYPE = 7;
152pub type COMPARISON_TYPE = ffi::c_uint;
153pub const Direction_Trailing: Direction = 0;
154pub const Direction_Leading: Direction = 1;
155pub type Direction = ffi::c_uint;
156pub const BitValue_Zero: BitValue = 0;
157pub const BitValue_One: BitValue = 1;
158pub type BitValue = ffi::c_uint;
159#[repr(C)]
160#[derive(Debug, Copy, Clone)]
161pub struct CudaStreamsFFI {
162 pub streams: *const *mut ffi::c_void,
163 pub gpu_indexes: *const u32,
164 pub gpu_count: u32,
165}
166#[allow(clippy::unnecessary_operation, clippy::identity_op)]
167const _: () = {
168 ["Size of CudaStreamsFFI"][::std::mem::size_of::<CudaStreamsFFI>() - 24usize];
169 ["Alignment of CudaStreamsFFI"][::std::mem::align_of::<CudaStreamsFFI>() - 8usize];
170 ["Offset of field: CudaStreamsFFI::streams"]
171 [::std::mem::offset_of!(CudaStreamsFFI, streams) - 0usize];
172 ["Offset of field: CudaStreamsFFI::gpu_indexes"]
173 [::std::mem::offset_of!(CudaStreamsFFI, gpu_indexes) - 8usize];
174 ["Offset of field: CudaStreamsFFI::gpu_count"]
175 [::std::mem::offset_of!(CudaStreamsFFI, gpu_count) - 16usize];
176};
177#[repr(C)]
178#[derive(Debug, Copy, Clone)]
179pub struct CudaRadixCiphertextFFI {
180 pub ptr: *mut ffi::c_void,
181 pub degrees: *mut u64,
182 pub noise_levels: *mut u64,
183 pub num_radix_blocks: u32,
184 pub max_num_radix_blocks: u32,
185 pub lwe_dimension: u32,
186}
187#[allow(clippy::unnecessary_operation, clippy::identity_op)]
188const _: () = {
189 ["Size of CudaRadixCiphertextFFI"][::std::mem::size_of::<CudaRadixCiphertextFFI>() - 40usize];
190 ["Alignment of CudaRadixCiphertextFFI"]
191 [::std::mem::align_of::<CudaRadixCiphertextFFI>() - 8usize];
192 ["Offset of field: CudaRadixCiphertextFFI::ptr"]
193 [::std::mem::offset_of!(CudaRadixCiphertextFFI, ptr) - 0usize];
194 ["Offset of field: CudaRadixCiphertextFFI::degrees"]
195 [::std::mem::offset_of!(CudaRadixCiphertextFFI, degrees) - 8usize];
196 ["Offset of field: CudaRadixCiphertextFFI::noise_levels"]
197 [::std::mem::offset_of!(CudaRadixCiphertextFFI, noise_levels) - 16usize];
198 ["Offset of field: CudaRadixCiphertextFFI::num_radix_blocks"]
199 [::std::mem::offset_of!(CudaRadixCiphertextFFI, num_radix_blocks) - 24usize];
200 ["Offset of field: CudaRadixCiphertextFFI::max_num_radix_blocks"]
201 [::std::mem::offset_of!(CudaRadixCiphertextFFI, max_num_radix_blocks) - 28usize];
202 ["Offset of field: CudaRadixCiphertextFFI::lwe_dimension"]
203 [::std::mem::offset_of!(CudaRadixCiphertextFFI, lwe_dimension) - 32usize];
204};
205#[repr(C)]
206#[derive(Debug, Copy, Clone)]
207pub struct CudaScalarDivisorFFI {
208 pub chosen_multiplier_has_at_least_one_set: *const u64,
209 pub decomposed_chosen_multiplier: *const u64,
210 pub num_scalars: u32,
211 pub active_bits: u32,
212 pub shift_pre: u64,
213 pub shift_post: u32,
214 pub ilog2_chosen_multiplier: u32,
215 pub chosen_multiplier_num_bits: u32,
216 pub is_chosen_multiplier_zero: bool,
217 pub is_abs_chosen_multiplier_one: bool,
218 pub is_chosen_multiplier_negative: bool,
219 pub is_chosen_multiplier_pow2: bool,
220 pub chosen_multiplier_has_more_bits_than_numerator: bool,
221 pub is_chosen_multiplier_geq_two_pow_numerator: bool,
222 pub ilog2_divisor: u32,
223 pub is_divisor_zero: bool,
224 pub is_abs_divisor_one: bool,
225 pub is_divisor_negative: bool,
226 pub is_divisor_pow2: bool,
227 pub divisor_has_more_bits_than_numerator: bool,
228}
229#[allow(clippy::unnecessary_operation, clippy::identity_op)]
230const _: () = {
231 ["Size of CudaScalarDivisorFFI"][::std::mem::size_of::<CudaScalarDivisorFFI>() - 64usize];
232 ["Alignment of CudaScalarDivisorFFI"][::std::mem::align_of::<CudaScalarDivisorFFI>() - 8usize];
233 ["Offset of field: CudaScalarDivisorFFI::chosen_multiplier_has_at_least_one_set"][::std::mem::offset_of!(
234 CudaScalarDivisorFFI,
235 chosen_multiplier_has_at_least_one_set
236 ) - 0usize];
237 ["Offset of field: CudaScalarDivisorFFI::decomposed_chosen_multiplier"]
238 [::std::mem::offset_of!(CudaScalarDivisorFFI, decomposed_chosen_multiplier) - 8usize];
239 ["Offset of field: CudaScalarDivisorFFI::num_scalars"]
240 [::std::mem::offset_of!(CudaScalarDivisorFFI, num_scalars) - 16usize];
241 ["Offset of field: CudaScalarDivisorFFI::active_bits"]
242 [::std::mem::offset_of!(CudaScalarDivisorFFI, active_bits) - 20usize];
243 ["Offset of field: CudaScalarDivisorFFI::shift_pre"]
244 [::std::mem::offset_of!(CudaScalarDivisorFFI, shift_pre) - 24usize];
245 ["Offset of field: CudaScalarDivisorFFI::shift_post"]
246 [::std::mem::offset_of!(CudaScalarDivisorFFI, shift_post) - 32usize];
247 ["Offset of field: CudaScalarDivisorFFI::ilog2_chosen_multiplier"]
248 [::std::mem::offset_of!(CudaScalarDivisorFFI, ilog2_chosen_multiplier) - 36usize];
249 ["Offset of field: CudaScalarDivisorFFI::chosen_multiplier_num_bits"]
250 [::std::mem::offset_of!(CudaScalarDivisorFFI, chosen_multiplier_num_bits) - 40usize];
251 ["Offset of field: CudaScalarDivisorFFI::is_chosen_multiplier_zero"]
252 [::std::mem::offset_of!(CudaScalarDivisorFFI, is_chosen_multiplier_zero) - 44usize];
253 ["Offset of field: CudaScalarDivisorFFI::is_abs_chosen_multiplier_one"]
254 [::std::mem::offset_of!(CudaScalarDivisorFFI, is_abs_chosen_multiplier_one) - 45usize];
255 ["Offset of field: CudaScalarDivisorFFI::is_chosen_multiplier_negative"]
256 [::std::mem::offset_of!(CudaScalarDivisorFFI, is_chosen_multiplier_negative) - 46usize];
257 ["Offset of field: CudaScalarDivisorFFI::is_chosen_multiplier_pow2"]
258 [::std::mem::offset_of!(CudaScalarDivisorFFI, is_chosen_multiplier_pow2) - 47usize];
259 ["Offset of field: CudaScalarDivisorFFI::chosen_multiplier_has_more_bits_than_numerator"][::std::mem::offset_of!(
260 CudaScalarDivisorFFI,
261 chosen_multiplier_has_more_bits_than_numerator
262 )
263 - 48usize];
264 ["Offset of field: CudaScalarDivisorFFI::is_chosen_multiplier_geq_two_pow_numerator"][::std::mem::offset_of!(
265 CudaScalarDivisorFFI,
266 is_chosen_multiplier_geq_two_pow_numerator
267 )
268 - 49usize];
269 ["Offset of field: CudaScalarDivisorFFI::ilog2_divisor"]
270 [::std::mem::offset_of!(CudaScalarDivisorFFI, ilog2_divisor) - 52usize];
271 ["Offset of field: CudaScalarDivisorFFI::is_divisor_zero"]
272 [::std::mem::offset_of!(CudaScalarDivisorFFI, is_divisor_zero) - 56usize];
273 ["Offset of field: CudaScalarDivisorFFI::is_abs_divisor_one"]
274 [::std::mem::offset_of!(CudaScalarDivisorFFI, is_abs_divisor_one) - 57usize];
275 ["Offset of field: CudaScalarDivisorFFI::is_divisor_negative"]
276 [::std::mem::offset_of!(CudaScalarDivisorFFI, is_divisor_negative) - 58usize];
277 ["Offset of field: CudaScalarDivisorFFI::is_divisor_pow2"]
278 [::std::mem::offset_of!(CudaScalarDivisorFFI, is_divisor_pow2) - 59usize];
279 ["Offset of field: CudaScalarDivisorFFI::divisor_has_more_bits_than_numerator"][::std::mem::offset_of!(
280 CudaScalarDivisorFFI,
281 divisor_has_more_bits_than_numerator
282 ) - 60usize];
283};
284unsafe extern "C" {
285 pub fn scratch_cuda_apply_univariate_lut_kb_64(
286 streams: CudaStreamsFFI,
287 mem_ptr: *mut *mut i8,
288 input_lut: *const ffi::c_void,
289 lwe_dimension: u32,
290 glwe_dimension: u32,
291 polynomial_size: u32,
292 ks_level: u32,
293 ks_base_log: u32,
294 pbs_level: u32,
295 pbs_base_log: u32,
296 grouping_factor: u32,
297 input_lwe_ciphertext_count: u32,
298 message_modulus: u32,
299 carry_modulus: u32,
300 pbs_type: PBS_TYPE,
301 lut_degree: u64,
302 allocate_gpu_memory: bool,
303 noise_reduction_type: PBS_MS_REDUCTION_T,
304 ) -> u64;
305}
306unsafe extern "C" {
307 pub fn scratch_cuda_apply_many_univariate_lut_kb_64(
308 streams: CudaStreamsFFI,
309 mem_ptr: *mut *mut i8,
310 input_lut: *const ffi::c_void,
311 lwe_dimension: u32,
312 glwe_dimension: u32,
313 polynomial_size: u32,
314 ks_level: u32,
315 ks_base_log: u32,
316 pbs_level: u32,
317 pbs_base_log: u32,
318 grouping_factor: u32,
319 num_radix_blocks: u32,
320 message_modulus: u32,
321 carry_modulus: u32,
322 pbs_type: PBS_TYPE,
323 num_many_lut: u32,
324 lut_degree: u64,
325 allocate_gpu_memory: bool,
326 noise_reduction_type: PBS_MS_REDUCTION_T,
327 ) -> u64;
328}
329unsafe extern "C" {
330 pub fn cuda_apply_univariate_lut_kb_64(
331 streams: CudaStreamsFFI,
332 output_radix_lwe: *mut CudaRadixCiphertextFFI,
333 input_radix_lwe: *const CudaRadixCiphertextFFI,
334 mem_ptr: *mut i8,
335 ksks: *const *mut ffi::c_void,
336 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
337 bsks: *const *mut ffi::c_void,
338 );
339}
340unsafe extern "C" {
341 pub fn cleanup_cuda_apply_univariate_lut_kb_64(
342 streams: CudaStreamsFFI,
343 mem_ptr_void: *mut *mut i8,
344 );
345}
346unsafe extern "C" {
347 pub fn scratch_cuda_apply_bivariate_lut_kb_64(
348 streams: CudaStreamsFFI,
349 mem_ptr: *mut *mut i8,
350 input_lut: *const ffi::c_void,
351 lwe_dimension: u32,
352 glwe_dimension: u32,
353 polynomial_size: u32,
354 ks_level: u32,
355 ks_base_log: u32,
356 pbs_level: u32,
357 pbs_base_log: u32,
358 grouping_factor: u32,
359 input_lwe_ciphertext_count: u32,
360 message_modulus: u32,
361 carry_modulus: u32,
362 pbs_type: PBS_TYPE,
363 lut_degree: u64,
364 allocate_gpu_memory: bool,
365 noise_reduction_type: PBS_MS_REDUCTION_T,
366 ) -> u64;
367}
368unsafe extern "C" {
369 pub fn cuda_apply_bivariate_lut_kb_64(
370 streams: CudaStreamsFFI,
371 output_radix_lwe: *mut CudaRadixCiphertextFFI,
372 input_radix_lwe_1: *const CudaRadixCiphertextFFI,
373 input_radix_lwe_2: *const CudaRadixCiphertextFFI,
374 mem_ptr: *mut i8,
375 ksks: *const *mut ffi::c_void,
376 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
377 bsks: *const *mut ffi::c_void,
378 num_radix_blocks: u32,
379 shift: u32,
380 );
381}
382unsafe extern "C" {
383 pub fn cleanup_cuda_apply_bivariate_lut_kb_64(
384 streams: CudaStreamsFFI,
385 mem_ptr_void: *mut *mut i8,
386 );
387}
388unsafe extern "C" {
389 pub fn cuda_apply_many_univariate_lut_kb_64(
390 streams: CudaStreamsFFI,
391 output_radix_lwe: *mut CudaRadixCiphertextFFI,
392 input_radix_lwe: *const CudaRadixCiphertextFFI,
393 mem_ptr: *mut i8,
394 ksks: *const *mut ffi::c_void,
395 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
396 bsks: *const *mut ffi::c_void,
397 num_luts: u32,
398 lut_stride: u32,
399 );
400}
401unsafe extern "C" {
402 pub fn scratch_cuda_full_propagation_64(
403 streams: CudaStreamsFFI,
404 mem_ptr: *mut *mut i8,
405 lwe_dimension: u32,
406 glwe_dimension: u32,
407 polynomial_size: u32,
408 ks_level: u32,
409 ks_base_log: u32,
410 pbs_level: u32,
411 pbs_base_log: u32,
412 grouping_factor: u32,
413 message_modulus: u32,
414 carry_modulus: u32,
415 pbs_type: PBS_TYPE,
416 allocate_gpu_memory: bool,
417 noise_reduction_type: PBS_MS_REDUCTION_T,
418 ) -> u64;
419}
420unsafe extern "C" {
421 pub fn cuda_full_propagation_64_inplace(
422 streams: CudaStreamsFFI,
423 input_blocks: *mut CudaRadixCiphertextFFI,
424 mem_ptr: *mut i8,
425 ksks: *const *mut ffi::c_void,
426 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
427 bsks: *const *mut ffi::c_void,
428 num_blocks: u32,
429 );
430}
431unsafe extern "C" {
432 pub fn cleanup_cuda_full_propagation(streams: CudaStreamsFFI, mem_ptr_void: *mut *mut i8);
433}
434unsafe extern "C" {
435 pub fn scratch_cuda_integer_mult_radix_ciphertext_kb_64(
436 streams: CudaStreamsFFI,
437 mem_ptr: *mut *mut i8,
438 is_boolean_left: bool,
439 is_boolean_right: bool,
440 message_modulus: u32,
441 carry_modulus: u32,
442 glwe_dimension: u32,
443 lwe_dimension: u32,
444 polynomial_size: u32,
445 pbs_base_log: u32,
446 pbs_level: u32,
447 ks_base_log: u32,
448 ks_level: u32,
449 grouping_factor: u32,
450 num_blocks: u32,
451 pbs_type: PBS_TYPE,
452 allocate_gpu_memory: bool,
453 noise_reduction_type: PBS_MS_REDUCTION_T,
454 ) -> u64;
455}
456unsafe extern "C" {
457 pub fn cuda_integer_mult_radix_ciphertext_kb_64(
458 streams: CudaStreamsFFI,
459 radix_lwe_out: *mut CudaRadixCiphertextFFI,
460 radix_lwe_left: *const CudaRadixCiphertextFFI,
461 is_bool_left: bool,
462 radix_lwe_right: *const CudaRadixCiphertextFFI,
463 is_bool_right: bool,
464 bsks: *const *mut ffi::c_void,
465 ksks: *const *mut ffi::c_void,
466 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
467 mem_ptr: *mut i8,
468 polynomial_size: u32,
469 num_blocks: u32,
470 );
471}
472unsafe extern "C" {
473 pub fn cleanup_cuda_integer_mult(streams: CudaStreamsFFI, mem_ptr_void: *mut *mut i8);
474}
475unsafe extern "C" {
476 pub fn cuda_negate_integer_radix_ciphertext_64(
477 streams: CudaStreamsFFI,
478 lwe_array_out: *mut CudaRadixCiphertextFFI,
479 lwe_array_in: *const CudaRadixCiphertextFFI,
480 message_modulus: u32,
481 carry_modulus: u32,
482 num_radix_blocks: u32,
483 );
484}
485unsafe extern "C" {
486 pub fn cuda_scalar_addition_integer_radix_ciphertext_64_inplace(
487 streams: CudaStreamsFFI,
488 lwe_array: *mut CudaRadixCiphertextFFI,
489 scalar_input: *const ffi::c_void,
490 h_scalar_input: *const ffi::c_void,
491 num_scalars: u32,
492 message_modulus: u32,
493 carry_modulus: u32,
494 );
495}
496unsafe extern "C" {
497 pub fn scratch_cuda_integer_radix_logical_scalar_shift_kb_64(
498 streams: CudaStreamsFFI,
499 mem_ptr: *mut *mut i8,
500 glwe_dimension: u32,
501 polynomial_size: u32,
502 big_lwe_dimension: u32,
503 small_lwe_dimension: u32,
504 ks_level: u32,
505 ks_base_log: u32,
506 pbs_level: u32,
507 pbs_base_log: u32,
508 grouping_factor: u32,
509 num_blocks: u32,
510 message_modulus: u32,
511 carry_modulus: u32,
512 pbs_type: PBS_TYPE,
513 shift_type: SHIFT_OR_ROTATE_TYPE,
514 allocate_gpu_memory: bool,
515 noise_reduction_type: PBS_MS_REDUCTION_T,
516 ) -> u64;
517}
518unsafe extern "C" {
519 pub fn cuda_integer_radix_logical_scalar_shift_kb_64_inplace(
520 streams: CudaStreamsFFI,
521 lwe_array: *mut CudaRadixCiphertextFFI,
522 shift: u32,
523 mem_ptr: *mut i8,
524 bsks: *const *mut ffi::c_void,
525 ksks: *const *mut ffi::c_void,
526 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
527 );
528}
529unsafe extern "C" {
530 pub fn scratch_cuda_integer_radix_arithmetic_scalar_shift_kb_64(
531 streams: CudaStreamsFFI,
532 mem_ptr: *mut *mut i8,
533 glwe_dimension: u32,
534 polynomial_size: u32,
535 big_lwe_dimension: u32,
536 small_lwe_dimension: u32,
537 ks_level: u32,
538 ks_base_log: u32,
539 pbs_level: u32,
540 pbs_base_log: u32,
541 grouping_factor: u32,
542 num_blocks: u32,
543 message_modulus: u32,
544 carry_modulus: u32,
545 pbs_type: PBS_TYPE,
546 shift_type: SHIFT_OR_ROTATE_TYPE,
547 allocate_gpu_memory: bool,
548 noise_reduction_type: PBS_MS_REDUCTION_T,
549 ) -> u64;
550}
551unsafe extern "C" {
552 pub fn cuda_integer_radix_arithmetic_scalar_shift_kb_64_inplace(
553 streams: CudaStreamsFFI,
554 lwe_array: *mut CudaRadixCiphertextFFI,
555 shift: u32,
556 mem_ptr: *mut i8,
557 bsks: *const *mut ffi::c_void,
558 ksks: *const *mut ffi::c_void,
559 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
560 );
561}
562unsafe extern "C" {
563 pub fn cleanup_cuda_integer_radix_logical_scalar_shift(
564 streams: CudaStreamsFFI,
565 mem_ptr_void: *mut *mut i8,
566 );
567}
568unsafe extern "C" {
569 pub fn cleanup_cuda_integer_radix_arithmetic_scalar_shift(
570 streams: CudaStreamsFFI,
571 mem_ptr_void: *mut *mut i8,
572 );
573}
574unsafe extern "C" {
575 pub fn scratch_cuda_integer_radix_shift_and_rotate_kb_64(
576 streams: CudaStreamsFFI,
577 mem_ptr: *mut *mut i8,
578 glwe_dimension: u32,
579 polynomial_size: u32,
580 big_lwe_dimension: u32,
581 small_lwe_dimension: u32,
582 ks_level: u32,
583 ks_base_log: u32,
584 pbs_level: u32,
585 pbs_base_log: u32,
586 grouping_factor: u32,
587 num_blocks: u32,
588 message_modulus: u32,
589 carry_modulus: u32,
590 pbs_type: PBS_TYPE,
591 shift_type: SHIFT_OR_ROTATE_TYPE,
592 is_signed: bool,
593 allocate_gpu_memory: bool,
594 noise_reduction_type: PBS_MS_REDUCTION_T,
595 ) -> u64;
596}
597unsafe extern "C" {
598 pub fn cuda_integer_radix_shift_and_rotate_kb_64_inplace(
599 streams: CudaStreamsFFI,
600 lwe_array: *mut CudaRadixCiphertextFFI,
601 lwe_shift: *const CudaRadixCiphertextFFI,
602 mem_ptr: *mut i8,
603 bsks: *const *mut ffi::c_void,
604 ksks: *const *mut ffi::c_void,
605 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
606 );
607}
608unsafe extern "C" {
609 pub fn cleanup_cuda_integer_radix_shift_and_rotate(
610 streams: CudaStreamsFFI,
611 mem_ptr_void: *mut *mut i8,
612 );
613}
614unsafe extern "C" {
615 pub fn scratch_cuda_integer_radix_comparison_kb_64(
616 streams: CudaStreamsFFI,
617 mem_ptr: *mut *mut i8,
618 glwe_dimension: u32,
619 polynomial_size: u32,
620 big_lwe_dimension: u32,
621 small_lwe_dimension: u32,
622 ks_level: u32,
623 ks_base_log: u32,
624 pbs_level: u32,
625 pbs_base_log: u32,
626 grouping_factor: u32,
627 lwe_ciphertext_count: u32,
628 message_modulus: u32,
629 carry_modulus: u32,
630 pbs_type: PBS_TYPE,
631 op_type: COMPARISON_TYPE,
632 is_signed: bool,
633 allocate_gpu_memory: bool,
634 noise_reduction_type: PBS_MS_REDUCTION_T,
635 ) -> u64;
636}
637unsafe extern "C" {
638 pub fn cuda_comparison_integer_radix_ciphertext_kb_64(
639 streams: CudaStreamsFFI,
640 lwe_array_out: *mut CudaRadixCiphertextFFI,
641 lwe_array_1: *const CudaRadixCiphertextFFI,
642 lwe_array_2: *const CudaRadixCiphertextFFI,
643 mem_ptr: *mut i8,
644 bsks: *const *mut ffi::c_void,
645 ksks: *const *mut ffi::c_void,
646 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
647 );
648}
649unsafe extern "C" {
650 pub fn cuda_scalar_comparison_integer_radix_ciphertext_kb_64(
651 streams: CudaStreamsFFI,
652 lwe_array_out: *mut CudaRadixCiphertextFFI,
653 lwe_array_in: *const CudaRadixCiphertextFFI,
654 scalar_blocks: *const ffi::c_void,
655 h_scalar_blocks: *const ffi::c_void,
656 mem_ptr: *mut i8,
657 bsks: *const *mut ffi::c_void,
658 ksks: *const *mut ffi::c_void,
659 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
660 num_scalar_blocks: u32,
661 );
662}
663unsafe extern "C" {
664 pub fn cleanup_cuda_integer_comparison(streams: CudaStreamsFFI, mem_ptr_void: *mut *mut i8);
665}
666unsafe extern "C" {
667 pub fn scratch_cuda_integer_radix_bitop_kb_64(
668 streams: CudaStreamsFFI,
669 mem_ptr: *mut *mut i8,
670 glwe_dimension: u32,
671 polynomial_size: u32,
672 big_lwe_dimension: u32,
673 small_lwe_dimension: u32,
674 ks_level: u32,
675 ks_base_log: u32,
676 pbs_level: u32,
677 pbs_base_log: u32,
678 grouping_factor: u32,
679 lwe_ciphertext_count: u32,
680 message_modulus: u32,
681 carry_modulus: u32,
682 pbs_type: PBS_TYPE,
683 op_type: BITOP_TYPE,
684 allocate_gpu_memory: bool,
685 noise_reduction_type: PBS_MS_REDUCTION_T,
686 ) -> u64;
687}
688unsafe extern "C" {
689 pub fn cuda_bitop_integer_radix_ciphertext_kb_64(
690 streams: CudaStreamsFFI,
691 lwe_array_out: *mut CudaRadixCiphertextFFI,
692 lwe_array_1: *const CudaRadixCiphertextFFI,
693 lwe_array_2: *const CudaRadixCiphertextFFI,
694 mem_ptr: *mut i8,
695 bsks: *const *mut ffi::c_void,
696 ksks: *const *mut ffi::c_void,
697 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
698 );
699}
700unsafe extern "C" {
701 pub fn cuda_scalar_bitop_integer_radix_ciphertext_kb_64(
702 streams: CudaStreamsFFI,
703 lwe_array_out: *mut CudaRadixCiphertextFFI,
704 lwe_array_input: *const CudaRadixCiphertextFFI,
705 clear_blocks: *const ffi::c_void,
706 h_clear_blocks: *const ffi::c_void,
707 num_clear_blocks: u32,
708 mem_ptr: *mut i8,
709 bsks: *const *mut ffi::c_void,
710 ksks: *const *mut ffi::c_void,
711 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
712 );
713}
714unsafe extern "C" {
715 pub fn cleanup_cuda_integer_bitop(streams: CudaStreamsFFI, mem_ptr_void: *mut *mut i8);
716}
717unsafe extern "C" {
718 pub fn scratch_cuda_integer_radix_cmux_kb_64(
719 streams: CudaStreamsFFI,
720 mem_ptr: *mut *mut i8,
721 glwe_dimension: u32,
722 polynomial_size: u32,
723 big_lwe_dimension: u32,
724 small_lwe_dimension: u32,
725 ks_level: u32,
726 ks_base_log: u32,
727 pbs_level: u32,
728 pbs_base_log: u32,
729 grouping_factor: u32,
730 lwe_ciphertext_count: u32,
731 message_modulus: u32,
732 carry_modulus: u32,
733 pbs_type: PBS_TYPE,
734 allocate_gpu_memory: bool,
735 noise_reduction_type: PBS_MS_REDUCTION_T,
736 ) -> u64;
737}
738unsafe extern "C" {
739 pub fn cuda_cmux_integer_radix_ciphertext_kb_64(
740 streams: CudaStreamsFFI,
741 lwe_array_out: *mut CudaRadixCiphertextFFI,
742 lwe_condition: *const CudaRadixCiphertextFFI,
743 lwe_array_true: *const CudaRadixCiphertextFFI,
744 lwe_array_false: *const CudaRadixCiphertextFFI,
745 mem_ptr: *mut i8,
746 bsks: *const *mut ffi::c_void,
747 ksks: *const *mut ffi::c_void,
748 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
749 );
750}
751unsafe extern "C" {
752 pub fn cleanup_cuda_integer_radix_cmux(streams: CudaStreamsFFI, mem_ptr_void: *mut *mut i8);
753}
754unsafe extern "C" {
755 pub fn scratch_cuda_integer_radix_scalar_rotate_kb_64(
756 streams: CudaStreamsFFI,
757 mem_ptr: *mut *mut i8,
758 glwe_dimension: u32,
759 polynomial_size: u32,
760 big_lwe_dimension: u32,
761 small_lwe_dimension: u32,
762 ks_level: u32,
763 ks_base_log: u32,
764 pbs_level: u32,
765 pbs_base_log: u32,
766 grouping_factor: u32,
767 num_blocks: u32,
768 message_modulus: u32,
769 carry_modulus: u32,
770 pbs_type: PBS_TYPE,
771 shift_type: SHIFT_OR_ROTATE_TYPE,
772 allocate_gpu_memory: bool,
773 noise_reduction_type: PBS_MS_REDUCTION_T,
774 ) -> u64;
775}
776unsafe extern "C" {
777 pub fn cuda_integer_radix_scalar_rotate_kb_64_inplace(
778 streams: CudaStreamsFFI,
779 lwe_array: *mut CudaRadixCiphertextFFI,
780 n: u32,
781 mem_ptr: *mut i8,
782 bsks: *const *mut ffi::c_void,
783 ksks: *const *mut ffi::c_void,
784 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
785 );
786}
787unsafe extern "C" {
788 pub fn cleanup_cuda_integer_radix_scalar_rotate(
789 streams: CudaStreamsFFI,
790 mem_ptr_void: *mut *mut i8,
791 );
792}
793unsafe extern "C" {
794 pub fn scratch_cuda_propagate_single_carry_kb_64_inplace(
795 streams: CudaStreamsFFI,
796 mem_ptr: *mut *mut i8,
797 glwe_dimension: u32,
798 polynomial_size: u32,
799 big_lwe_dimension: u32,
800 small_lwe_dimension: u32,
801 ks_level: u32,
802 ks_base_log: u32,
803 pbs_level: u32,
804 pbs_base_log: u32,
805 grouping_factor: u32,
806 num_blocks: u32,
807 message_modulus: u32,
808 carry_modulus: u32,
809 pbs_type: PBS_TYPE,
810 requested_flag: u32,
811 allocate_gpu_memory: bool,
812 noise_reduction_type: PBS_MS_REDUCTION_T,
813 ) -> u64;
814}
815unsafe extern "C" {
816 pub fn scratch_cuda_add_and_propagate_single_carry_kb_64_inplace(
817 streams: CudaStreamsFFI,
818 mem_ptr: *mut *mut i8,
819 glwe_dimension: u32,
820 polynomial_size: u32,
821 big_lwe_dimension: u32,
822 small_lwe_dimension: u32,
823 ks_level: u32,
824 ks_base_log: u32,
825 pbs_level: u32,
826 pbs_base_log: u32,
827 grouping_factor: u32,
828 num_blocks: u32,
829 message_modulus: u32,
830 carry_modulus: u32,
831 pbs_type: PBS_TYPE,
832 requested_flag: u32,
833 allocate_gpu_memory: bool,
834 noise_reduction_type: PBS_MS_REDUCTION_T,
835 ) -> u64;
836}
837unsafe extern "C" {
838 pub fn cuda_propagate_single_carry_kb_64_inplace(
839 streams: CudaStreamsFFI,
840 lwe_array: *mut CudaRadixCiphertextFFI,
841 carry_out: *mut CudaRadixCiphertextFFI,
842 carry_in: *const CudaRadixCiphertextFFI,
843 mem_ptr: *mut i8,
844 bsks: *const *mut ffi::c_void,
845 ksks: *const *mut ffi::c_void,
846 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
847 requested_flag: u32,
848 uses_carry: u32,
849 );
850}
851unsafe extern "C" {
852 pub fn cuda_add_and_propagate_single_carry_kb_64_inplace(
853 streams: CudaStreamsFFI,
854 lhs_array: *mut CudaRadixCiphertextFFI,
855 rhs_array: *const CudaRadixCiphertextFFI,
856 carry_out: *mut CudaRadixCiphertextFFI,
857 carry_in: *const CudaRadixCiphertextFFI,
858 mem_ptr: *mut i8,
859 bsks: *const *mut ffi::c_void,
860 ksks: *const *mut ffi::c_void,
861 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
862 requested_flag: u32,
863 uses_carry: u32,
864 );
865}
866unsafe extern "C" {
867 pub fn cleanup_cuda_propagate_single_carry(streams: CudaStreamsFFI, mem_ptr_void: *mut *mut i8);
868}
869unsafe extern "C" {
870 pub fn cleanup_cuda_add_and_propagate_single_carry(
871 streams: CudaStreamsFFI,
872 mem_ptr_void: *mut *mut i8,
873 );
874}
875unsafe extern "C" {
876 pub fn scratch_cuda_integer_overflowing_sub_kb_64_inplace(
877 streams: CudaStreamsFFI,
878 mem_ptr: *mut *mut i8,
879 glwe_dimension: u32,
880 polynomial_size: u32,
881 big_lwe_dimension: u32,
882 small_lwe_dimension: u32,
883 ks_level: u32,
884 ks_base_log: u32,
885 pbs_level: u32,
886 pbs_base_log: u32,
887 grouping_factor: u32,
888 num_blocks: u32,
889 message_modulus: u32,
890 carry_modulus: u32,
891 pbs_type: PBS_TYPE,
892 compute_overflow: u32,
893 allocate_gpu_memory: bool,
894 noise_reduction_type: PBS_MS_REDUCTION_T,
895 ) -> u64;
896}
897unsafe extern "C" {
898 pub fn cuda_integer_overflowing_sub_kb_64_inplace(
899 streams: CudaStreamsFFI,
900 lhs_array: *mut CudaRadixCiphertextFFI,
901 rhs_array: *const CudaRadixCiphertextFFI,
902 overflow_block: *mut CudaRadixCiphertextFFI,
903 input_borrow: *const CudaRadixCiphertextFFI,
904 mem_ptr: *mut i8,
905 bsks: *const *mut ffi::c_void,
906 ksks: *const *mut ffi::c_void,
907 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
908 compute_overflow: u32,
909 uses_input_borrow: u32,
910 );
911}
912unsafe extern "C" {
913 pub fn cleanup_cuda_integer_overflowing_sub(
914 streams: CudaStreamsFFI,
915 mem_ptr_void: *mut *mut i8,
916 );
917}
918unsafe extern "C" {
919 pub fn scratch_cuda_integer_radix_partial_sum_ciphertexts_vec_kb_64(
920 streams: CudaStreamsFFI,
921 mem_ptr: *mut *mut i8,
922 glwe_dimension: u32,
923 polynomial_size: u32,
924 lwe_dimension: u32,
925 ks_level: u32,
926 ks_base_log: u32,
927 pbs_level: u32,
928 pbs_base_log: u32,
929 grouping_factor: u32,
930 num_blocks_in_radix: u32,
931 max_num_radix_in_vec: u32,
932 message_modulus: u32,
933 carry_modulus: u32,
934 pbs_type: PBS_TYPE,
935 reduce_degrees_for_single_carry_propagation: bool,
936 allocate_gpu_memory: bool,
937 noise_reduction_type: PBS_MS_REDUCTION_T,
938 ) -> u64;
939}
940unsafe extern "C" {
941 pub fn cuda_integer_radix_partial_sum_ciphertexts_vec_kb_64(
942 streams: CudaStreamsFFI,
943 radix_lwe_out: *mut CudaRadixCiphertextFFI,
944 radix_lwe_vec: *mut CudaRadixCiphertextFFI,
945 mem_ptr: *mut i8,
946 bsks: *const *mut ffi::c_void,
947 ksks: *const *mut ffi::c_void,
948 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
949 );
950}
951unsafe extern "C" {
952 pub fn cleanup_cuda_integer_radix_partial_sum_ciphertexts_vec(
953 streams: CudaStreamsFFI,
954 mem_ptr_void: *mut *mut i8,
955 );
956}
957unsafe extern "C" {
958 pub fn scratch_cuda_integer_scalar_mul_kb_64(
959 streams: CudaStreamsFFI,
960 mem_ptr: *mut *mut i8,
961 glwe_dimension: u32,
962 polynomial_size: u32,
963 lwe_dimension: u32,
964 ks_level: u32,
965 ks_base_log: u32,
966 pbs_level: u32,
967 pbs_base_log: u32,
968 grouping_factor: u32,
969 num_blocks: u32,
970 message_modulus: u32,
971 carry_modulus: u32,
972 pbs_type: PBS_TYPE,
973 num_scalar_bits: u32,
974 allocate_gpu_memory: bool,
975 noise_reduction_type: PBS_MS_REDUCTION_T,
976 ) -> u64;
977}
978unsafe extern "C" {
979 pub fn cuda_scalar_multiplication_integer_radix_ciphertext_64_inplace(
980 streams: CudaStreamsFFI,
981 lwe_array: *mut CudaRadixCiphertextFFI,
982 decomposed_scalar: *const u64,
983 has_at_least_one_set: *const u64,
984 mem_ptr: *mut i8,
985 bsks: *const *mut ffi::c_void,
986 ksks: *const *mut ffi::c_void,
987 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
988 polynomial_size: u32,
989 message_modulus: u32,
990 num_scalars: u32,
991 );
992}
993unsafe extern "C" {
994 pub fn cleanup_cuda_integer_radix_scalar_mul(
995 streams: CudaStreamsFFI,
996 mem_ptr_void: *mut *mut i8,
997 );
998}
999unsafe extern "C" {
1000 pub fn scratch_cuda_integer_div_rem_radix_ciphertext_kb_64(
1001 streams: CudaStreamsFFI,
1002 is_signed: bool,
1003 mem_ptr: *mut *mut i8,
1004 glwe_dimension: u32,
1005 polynomial_size: u32,
1006 big_lwe_dimension: u32,
1007 small_lwe_dimension: u32,
1008 ks_level: u32,
1009 ks_base_log: u32,
1010 pbs_level: u32,
1011 pbs_base_log: u32,
1012 grouping_factor: u32,
1013 num_blocks: u32,
1014 message_modulus: u32,
1015 carry_modulus: u32,
1016 pbs_type: PBS_TYPE,
1017 allocate_gpu_memory: bool,
1018 noise_reduction_type: PBS_MS_REDUCTION_T,
1019 ) -> u64;
1020}
1021unsafe extern "C" {
1022 pub fn cuda_integer_div_rem_radix_ciphertext_kb_64(
1023 streams: CudaStreamsFFI,
1024 quotient: *mut CudaRadixCiphertextFFI,
1025 remainder: *mut CudaRadixCiphertextFFI,
1026 numerator: *const CudaRadixCiphertextFFI,
1027 divisor: *const CudaRadixCiphertextFFI,
1028 is_signed: bool,
1029 mem_ptr: *mut i8,
1030 bsks: *const *mut ffi::c_void,
1031 ksks: *const *mut ffi::c_void,
1032 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
1033 );
1034}
1035unsafe extern "C" {
1036 pub fn cleanup_cuda_integer_div_rem(streams: CudaStreamsFFI, mem_ptr_void: *mut *mut i8);
1037}
1038unsafe extern "C" {
1039 pub fn scratch_cuda_integer_compute_prefix_sum_hillis_steele_64(
1040 streams: CudaStreamsFFI,
1041 mem_ptr: *mut *mut i8,
1042 input_lut: *const ffi::c_void,
1043 lwe_dimension: u32,
1044 glwe_dimension: u32,
1045 polynomial_size: u32,
1046 ks_level: u32,
1047 ks_base_log: u32,
1048 pbs_level: u32,
1049 pbs_base_log: u32,
1050 grouping_factor: u32,
1051 num_radix_blocks: u32,
1052 message_modulus: u32,
1053 carry_modulus: u32,
1054 pbs_type: PBS_TYPE,
1055 lut_degree: u64,
1056 allocate_gpu_memory: bool,
1057 noise_reduction_type: PBS_MS_REDUCTION_T,
1058 ) -> u64;
1059}
1060unsafe extern "C" {
1061 pub fn cuda_integer_compute_prefix_sum_hillis_steele_64(
1062 streams: CudaStreamsFFI,
1063 output_radix_lwe: *mut CudaRadixCiphertextFFI,
1064 generates_or_propagates: *mut CudaRadixCiphertextFFI,
1065 mem_ptr: *mut i8,
1066 ksks: *const *mut ffi::c_void,
1067 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
1068 bsks: *const *mut ffi::c_void,
1069 num_blocks: u32,
1070 );
1071}
1072unsafe extern "C" {
1073 pub fn cleanup_cuda_integer_compute_prefix_sum_hillis_steele_64(
1074 streams: CudaStreamsFFI,
1075 mem_ptr_void: *mut *mut i8,
1076 );
1077}
1078unsafe extern "C" {
1079 pub fn cuda_integer_reverse_blocks_64_inplace(
1080 streams: CudaStreamsFFI,
1081 lwe_array: *mut CudaRadixCiphertextFFI,
1082 );
1083}
1084unsafe extern "C" {
1085 pub fn scratch_cuda_integer_abs_inplace_radix_ciphertext_kb_64(
1086 streams: CudaStreamsFFI,
1087 mem_ptr: *mut *mut i8,
1088 is_signed: bool,
1089 glwe_dimension: u32,
1090 polynomial_size: u32,
1091 big_lwe_dimension: u32,
1092 small_lwe_dimension: u32,
1093 ks_level: u32,
1094 ks_base_log: u32,
1095 pbs_level: u32,
1096 pbs_base_log: u32,
1097 grouping_factor: u32,
1098 num_blocks: u32,
1099 message_modulus: u32,
1100 carry_modulus: u32,
1101 pbs_type: PBS_TYPE,
1102 allocate_gpu_memory: bool,
1103 noise_reduction_type: PBS_MS_REDUCTION_T,
1104 ) -> u64;
1105}
1106unsafe extern "C" {
1107 pub fn cuda_integer_abs_inplace_radix_ciphertext_kb_64(
1108 streams: CudaStreamsFFI,
1109 ct: *mut CudaRadixCiphertextFFI,
1110 mem_ptr: *mut i8,
1111 is_signed: bool,
1112 bsks: *const *mut ffi::c_void,
1113 ksks: *const *mut ffi::c_void,
1114 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
1115 );
1116}
1117unsafe extern "C" {
1118 pub fn cleanup_cuda_integer_abs_inplace(streams: CudaStreamsFFI, mem_ptr_void: *mut *mut i8);
1119}
1120unsafe extern "C" {
1121 pub fn scratch_cuda_integer_are_all_comparisons_block_true_kb_64(
1122 streams: CudaStreamsFFI,
1123 mem_ptr: *mut *mut i8,
1124 glwe_dimension: u32,
1125 polynomial_size: u32,
1126 big_lwe_dimension: u32,
1127 small_lwe_dimension: u32,
1128 ks_level: u32,
1129 ks_base_log: u32,
1130 pbs_level: u32,
1131 pbs_base_log: u32,
1132 grouping_factor: u32,
1133 num_radix_blocks: u32,
1134 message_modulus: u32,
1135 carry_modulus: u32,
1136 pbs_type: PBS_TYPE,
1137 allocate_gpu_memory: bool,
1138 noise_reduction_type: PBS_MS_REDUCTION_T,
1139 ) -> u64;
1140}
1141unsafe extern "C" {
1142 pub fn cuda_integer_are_all_comparisons_block_true_kb_64(
1143 streams: CudaStreamsFFI,
1144 lwe_array_out: *mut CudaRadixCiphertextFFI,
1145 lwe_array_in: *const CudaRadixCiphertextFFI,
1146 mem_ptr: *mut i8,
1147 bsks: *const *mut ffi::c_void,
1148 ksks: *const *mut ffi::c_void,
1149 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
1150 num_radix_blocks: u32,
1151 );
1152}
1153unsafe extern "C" {
1154 pub fn cleanup_cuda_integer_are_all_comparisons_block_true(
1155 streams: CudaStreamsFFI,
1156 mem_ptr_void: *mut *mut i8,
1157 );
1158}
1159unsafe extern "C" {
1160 pub fn scratch_cuda_integer_is_at_least_one_comparisons_block_true_kb_64(
1161 streams: CudaStreamsFFI,
1162 mem_ptr: *mut *mut i8,
1163 glwe_dimension: u32,
1164 polynomial_size: u32,
1165 big_lwe_dimension: u32,
1166 small_lwe_dimension: u32,
1167 ks_level: u32,
1168 ks_base_log: u32,
1169 pbs_level: u32,
1170 pbs_base_log: u32,
1171 grouping_factor: u32,
1172 num_radix_blocks: u32,
1173 message_modulus: u32,
1174 carry_modulus: u32,
1175 pbs_type: PBS_TYPE,
1176 allocate_gpu_memory: bool,
1177 noise_reduction_type: PBS_MS_REDUCTION_T,
1178 ) -> u64;
1179}
1180unsafe extern "C" {
1181 pub fn cuda_integer_is_at_least_one_comparisons_block_true_kb_64(
1182 streams: CudaStreamsFFI,
1183 lwe_array_out: *mut CudaRadixCiphertextFFI,
1184 lwe_array_in: *const CudaRadixCiphertextFFI,
1185 mem_ptr: *mut i8,
1186 bsks: *const *mut ffi::c_void,
1187 ksks: *const *mut ffi::c_void,
1188 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
1189 num_radix_blocks: u32,
1190 );
1191}
1192unsafe extern "C" {
1193 pub fn cleanup_cuda_integer_is_at_least_one_comparisons_block_true(
1194 streams: CudaStreamsFFI,
1195 mem_ptr_void: *mut *mut i8,
1196 );
1197}
1198unsafe extern "C" {
1199 pub fn extend_radix_with_trivial_zero_blocks_msb_64(
1200 output: *mut CudaRadixCiphertextFFI,
1201 input: *const CudaRadixCiphertextFFI,
1202 streams: CudaStreamsFFI,
1203 );
1204}
1205unsafe extern "C" {
1206 pub fn trim_radix_blocks_lsb_64(
1207 output: *mut CudaRadixCiphertextFFI,
1208 input: *const CudaRadixCiphertextFFI,
1209 streams: CudaStreamsFFI,
1210 );
1211}
1212unsafe extern "C" {
1213 pub fn scratch_cuda_apply_noise_squashing_kb(
1214 streams: CudaStreamsFFI,
1215 mem_ptr: *mut *mut i8,
1216 lwe_dimension: u32,
1217 glwe_dimension: u32,
1218 polynomial_size: u32,
1219 input_glwe_dimension: u32,
1220 input_polynomial_size: u32,
1221 ks_level: u32,
1222 ks_base_log: u32,
1223 pbs_level: u32,
1224 pbs_base_log: u32,
1225 grouping_factor: u32,
1226 num_radix_blocks: u32,
1227 num_original_blocks: u32,
1228 message_modulus: u32,
1229 carry_modulus: u32,
1230 pbs_type: PBS_TYPE,
1231 allocate_gpu_memory: bool,
1232 noise_reduction_type: PBS_MS_REDUCTION_T,
1233 ) -> u64;
1234}
1235unsafe extern "C" {
1236 pub fn cuda_apply_noise_squashing_kb(
1237 streams: CudaStreamsFFI,
1238 output_radix_lwe: *mut CudaRadixCiphertextFFI,
1239 input_radix_lwe: *const CudaRadixCiphertextFFI,
1240 mem_ptr: *mut i8,
1241 ksks: *const *mut ffi::c_void,
1242 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
1243 bsks: *const *mut ffi::c_void,
1244 );
1245}
1246unsafe extern "C" {
1247 pub fn cleanup_cuda_apply_noise_squashing_kb(
1248 streams: CudaStreamsFFI,
1249 mem_ptr_void: *mut *mut i8,
1250 );
1251}
1252unsafe extern "C" {
1253 pub fn scratch_cuda_sub_and_propagate_single_carry_kb_64_inplace(
1254 streams: CudaStreamsFFI,
1255 mem_ptr: *mut *mut i8,
1256 glwe_dimension: u32,
1257 polynomial_size: u32,
1258 big_lwe_dimension: u32,
1259 small_lwe_dimension: u32,
1260 ks_level: u32,
1261 ks_base_log: u32,
1262 pbs_level: u32,
1263 pbs_base_log: u32,
1264 grouping_factor: u32,
1265 num_blocks: u32,
1266 message_modulus: u32,
1267 carry_modulus: u32,
1268 pbs_type: PBS_TYPE,
1269 requested_flag: u32,
1270 allocate_gpu_memory: bool,
1271 noise_reduction_type: PBS_MS_REDUCTION_T,
1272 ) -> u64;
1273}
1274unsafe extern "C" {
1275 pub fn cuda_sub_and_propagate_single_carry_kb_64_inplace(
1276 streams: CudaStreamsFFI,
1277 lhs_array: *mut CudaRadixCiphertextFFI,
1278 rhs_array: *const CudaRadixCiphertextFFI,
1279 carry_out: *mut CudaRadixCiphertextFFI,
1280 carry_in: *const CudaRadixCiphertextFFI,
1281 mem_ptr: *mut i8,
1282 bsks: *const *mut ffi::c_void,
1283 ksks: *const *mut ffi::c_void,
1284 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
1285 requested_flag: u32,
1286 uses_carry: u32,
1287 );
1288}
1289unsafe extern "C" {
1290 pub fn cleanup_cuda_sub_and_propagate_single_carry(
1291 streams: CudaStreamsFFI,
1292 mem_ptr_void: *mut *mut i8,
1293 );
1294}
1295unsafe extern "C" {
1296 pub fn scratch_cuda_integer_unsigned_scalar_div_radix_kb_64(
1297 streams: CudaStreamsFFI,
1298 mem_ptr: *mut *mut i8,
1299 glwe_dimension: u32,
1300 polynomial_size: u32,
1301 lwe_dimension: u32,
1302 ks_level: u32,
1303 ks_base_log: u32,
1304 pbs_level: u32,
1305 pbs_base_log: u32,
1306 grouping_factor: u32,
1307 num_blocks: u32,
1308 message_modulus: u32,
1309 carry_modulus: u32,
1310 pbs_type: PBS_TYPE,
1311 scalar_divisor_ffi: *const CudaScalarDivisorFFI,
1312 allocate_gpu_memory: bool,
1313 noise_reduction_type: PBS_MS_REDUCTION_T,
1314 ) -> u64;
1315}
1316unsafe extern "C" {
1317 pub fn cuda_integer_unsigned_scalar_div_radix_kb_64(
1318 streams: CudaStreamsFFI,
1319 numerator_ct: *mut CudaRadixCiphertextFFI,
1320 mem_ptr: *mut i8,
1321 bsks: *const *mut ffi::c_void,
1322 ksks: *const *mut ffi::c_void,
1323 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
1324 scalar_divisor_ffi: *const CudaScalarDivisorFFI,
1325 );
1326}
1327unsafe extern "C" {
1328 pub fn cleanup_cuda_integer_unsigned_scalar_div_radix_kb_64(
1329 streams: CudaStreamsFFI,
1330 mem_ptr_void: *mut *mut i8,
1331 );
1332}
1333unsafe extern "C" {
1334 pub fn scratch_cuda_extend_radix_with_sign_msb_64(
1335 streams: CudaStreamsFFI,
1336 mem_ptr: *mut *mut i8,
1337 glwe_dimension: u32,
1338 polynomial_size: u32,
1339 lwe_dimension: u32,
1340 ks_level: u32,
1341 ks_base_log: u32,
1342 pbs_level: u32,
1343 pbs_base_log: u32,
1344 grouping_factor: u32,
1345 num_blocks: u32,
1346 num_additional_blocks: u32,
1347 message_modulus: u32,
1348 carry_modulus: u32,
1349 pbs_type: PBS_TYPE,
1350 allocate_gpu_memory: bool,
1351 noise_reduction_type: PBS_MS_REDUCTION_T,
1352 ) -> u64;
1353}
1354unsafe extern "C" {
1355 pub fn cuda_extend_radix_with_sign_msb_64(
1356 streams: CudaStreamsFFI,
1357 output: *mut CudaRadixCiphertextFFI,
1358 input: *const CudaRadixCiphertextFFI,
1359 mem_ptr: *mut i8,
1360 num_additional_blocks: u32,
1361 bsks: *const *mut ffi::c_void,
1362 ksks: *const *mut ffi::c_void,
1363 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
1364 );
1365}
1366unsafe extern "C" {
1367 pub fn cleanup_cuda_extend_radix_with_sign_msb_64(
1368 streams: CudaStreamsFFI,
1369 mem_ptr_void: *mut *mut i8,
1370 );
1371}
1372unsafe extern "C" {
1373 pub fn scratch_cuda_integer_signed_scalar_div_radix_kb_64(
1374 streams: CudaStreamsFFI,
1375 mem_ptr: *mut *mut i8,
1376 glwe_dimension: u32,
1377 polynomial_size: u32,
1378 lwe_dimension: u32,
1379 ks_level: u32,
1380 ks_base_log: u32,
1381 pbs_level: u32,
1382 pbs_base_log: u32,
1383 grouping_factor: u32,
1384 num_blocks: u32,
1385 message_modulus: u32,
1386 carry_modulus: u32,
1387 pbs_type: PBS_TYPE,
1388 scalar_divisor_ffi: *const CudaScalarDivisorFFI,
1389 allocate_gpu_memory: bool,
1390 noise_reduction_type: PBS_MS_REDUCTION_T,
1391 ) -> u64;
1392}
1393unsafe extern "C" {
1394 pub fn cuda_integer_signed_scalar_div_radix_kb_64(
1395 streams: CudaStreamsFFI,
1396 numerator_ct: *mut CudaRadixCiphertextFFI,
1397 mem_ptr: *mut i8,
1398 bsks: *const *mut ffi::c_void,
1399 ksks: *const *mut ffi::c_void,
1400 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
1401 scalar_divisor_ffi: *const CudaScalarDivisorFFI,
1402 numerator_bits: u32,
1403 );
1404}
1405unsafe extern "C" {
1406 pub fn cleanup_cuda_integer_signed_scalar_div_radix_kb_64(
1407 streams: CudaStreamsFFI,
1408 mem_ptr_void: *mut *mut i8,
1409 );
1410}
1411unsafe extern "C" {
1412 pub fn scratch_integer_unsigned_scalar_div_rem_radix_kb_64(
1413 streams: CudaStreamsFFI,
1414 mem_ptr: *mut *mut i8,
1415 glwe_dimension: u32,
1416 polynomial_size: u32,
1417 lwe_dimension: u32,
1418 ks_level: u32,
1419 ks_base_log: u32,
1420 pbs_level: u32,
1421 pbs_base_log: u32,
1422 grouping_factor: u32,
1423 num_blocks: u32,
1424 message_modulus: u32,
1425 carry_modulus: u32,
1426 pbs_type: PBS_TYPE,
1427 scalar_divisor_ffi: *const CudaScalarDivisorFFI,
1428 active_bits_divisor: u32,
1429 allocate_gpu_memory: bool,
1430 noise_reduction_type: PBS_MS_REDUCTION_T,
1431 ) -> u64;
1432}
1433unsafe extern "C" {
1434 pub fn cuda_integer_unsigned_scalar_div_rem_radix_kb_64(
1435 streams: CudaStreamsFFI,
1436 quotient_ct: *mut CudaRadixCiphertextFFI,
1437 remainder_ct: *mut CudaRadixCiphertextFFI,
1438 mem_ptr: *mut i8,
1439 bsks: *const *mut ffi::c_void,
1440 ksks: *const *mut ffi::c_void,
1441 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
1442 scalar_divisor_ffi: *const CudaScalarDivisorFFI,
1443 divisor_has_at_least_one_set: *const u64,
1444 decomposed_divisor: *const u64,
1445 num_scalars_divisor: u32,
1446 clear_blocks: *const ffi::c_void,
1447 h_clear_blocks: *const ffi::c_void,
1448 num_clear_blocks: u32,
1449 );
1450}
1451unsafe extern "C" {
1452 pub fn cleanup_cuda_integer_unsigned_scalar_div_rem_radix_kb_64(
1453 streams: CudaStreamsFFI,
1454 mem_ptr_void: *mut *mut i8,
1455 );
1456}
1457unsafe extern "C" {
1458 pub fn scratch_integer_signed_scalar_div_rem_radix_kb_64(
1459 streams: CudaStreamsFFI,
1460 mem_ptr: *mut *mut i8,
1461 glwe_dimension: u32,
1462 polynomial_size: u32,
1463 lwe_dimension: u32,
1464 ks_level: u32,
1465 ks_base_log: u32,
1466 pbs_level: u32,
1467 pbs_base_log: u32,
1468 grouping_factor: u32,
1469 num_blocks: u32,
1470 message_modulus: u32,
1471 carry_modulus: u32,
1472 pbs_type: PBS_TYPE,
1473 scalar_divisor_ffi: *const CudaScalarDivisorFFI,
1474 active_bits_divisor: u32,
1475 allocate_gpu_memory: bool,
1476 noise_reduction_type: PBS_MS_REDUCTION_T,
1477 ) -> u64;
1478}
1479unsafe extern "C" {
1480 pub fn cuda_integer_signed_scalar_div_rem_radix_kb_64(
1481 streams: CudaStreamsFFI,
1482 quotient_ct: *mut CudaRadixCiphertextFFI,
1483 remainder_ct: *mut CudaRadixCiphertextFFI,
1484 mem_ptr: *mut i8,
1485 bsks: *const *mut ffi::c_void,
1486 ksks: *const *mut ffi::c_void,
1487 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
1488 scalar_divisor_ffi: *const CudaScalarDivisorFFI,
1489 divisor_has_at_least_one_set: *const u64,
1490 decomposed_divisor: *const u64,
1491 num_scalars_divisor: u32,
1492 numerator_bits: u32,
1493 );
1494}
1495unsafe extern "C" {
1496 pub fn cleanup_cuda_integer_signed_scalar_div_rem_radix_kb_64(
1497 streams: CudaStreamsFFI,
1498 mem_ptr_void: *mut *mut i8,
1499 );
1500}
1501unsafe extern "C" {
1502 pub fn scratch_integer_count_of_consecutive_bits_kb_64(
1503 streams: CudaStreamsFFI,
1504 mem_ptr: *mut *mut i8,
1505 glwe_dimension: u32,
1506 polynomial_size: u32,
1507 lwe_dimension: u32,
1508 ks_level: u32,
1509 ks_base_log: u32,
1510 pbs_level: u32,
1511 pbs_base_log: u32,
1512 grouping_factor: u32,
1513 num_blocks: u32,
1514 counter_num_blocks: u32,
1515 message_modulus: u32,
1516 carry_modulus: u32,
1517 pbs_type: PBS_TYPE,
1518 direction: Direction,
1519 bit_value: BitValue,
1520 allocate_gpu_memory: bool,
1521 noise_reduction_type: PBS_MS_REDUCTION_T,
1522 ) -> u64;
1523}
1524unsafe extern "C" {
1525 pub fn cuda_integer_count_of_consecutive_bits_kb_64(
1526 streams: CudaStreamsFFI,
1527 output_ct: *mut CudaRadixCiphertextFFI,
1528 input_ct: *const CudaRadixCiphertextFFI,
1529 mem_ptr: *mut i8,
1530 bsks: *const *mut ffi::c_void,
1531 ksks: *const *mut ffi::c_void,
1532 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
1533 );
1534}
1535unsafe extern "C" {
1536 pub fn cleanup_cuda_integer_count_of_consecutive_bits_kb_64(
1537 streams: CudaStreamsFFI,
1538 mem_ptr_void: *mut *mut i8,
1539 );
1540}
1541unsafe extern "C" {
1542 pub fn scratch_cuda_integer_grouped_oprf_64(
1543 streams: CudaStreamsFFI,
1544 mem_ptr: *mut *mut i8,
1545 glwe_dimension: u32,
1546 polynomial_size: u32,
1547 lwe_dimension: u32,
1548 ks_level: u32,
1549 ks_base_log: u32,
1550 pbs_level: u32,
1551 pbs_base_log: u32,
1552 grouping_factor: u32,
1553 num_blocks_to_process: u32,
1554 num_blocks: u32,
1555 message_modulus: u32,
1556 carry_modulus: u32,
1557 pbs_type: PBS_TYPE,
1558 allocate_gpu_memory: bool,
1559 message_bits_per_block: u32,
1560 total_random_bits: u32,
1561 noise_reduction_type: PBS_MS_REDUCTION_T,
1562 ) -> u64;
1563}
1564unsafe extern "C" {
1565 pub fn cuda_integer_grouped_oprf_async_64(
1566 streams: CudaStreamsFFI,
1567 radix_lwe_out: *mut CudaRadixCiphertextFFI,
1568 seeded_lwe_input: *const ffi::c_void,
1569 num_blocks_to_process: u32,
1570 mem: *mut i8,
1571 bsks: *const *mut ffi::c_void,
1572 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
1573 );
1574}
1575unsafe extern "C" {
1576 pub fn cleanup_cuda_integer_grouped_oprf_64(
1577 streams: CudaStreamsFFI,
1578 mem_ptr_void: *mut *mut i8,
1579 );
1580}
1581unsafe extern "C" {
1582 pub fn scratch_integer_ilog2_kb_64(
1583 streams: CudaStreamsFFI,
1584 mem_ptr: *mut *mut i8,
1585 glwe_dimension: u32,
1586 polynomial_size: u32,
1587 lwe_dimension: u32,
1588 ks_level: u32,
1589 ks_base_log: u32,
1590 pbs_level: u32,
1591 pbs_base_log: u32,
1592 grouping_factor: u32,
1593 message_modulus: u32,
1594 carry_modulus: u32,
1595 pbs_type: PBS_TYPE,
1596 input_num_blocks: u32,
1597 counter_num_blocks: u32,
1598 num_bits_in_ciphertext: u32,
1599 allocate_gpu_memory: bool,
1600 noise_reduction_type: PBS_MS_REDUCTION_T,
1601 ) -> u64;
1602}
1603unsafe extern "C" {
1604 pub fn cuda_integer_ilog2_kb_64(
1605 streams: CudaStreamsFFI,
1606 output_ct: *mut CudaRadixCiphertextFFI,
1607 input_ct: *const CudaRadixCiphertextFFI,
1608 trivial_ct_neg_n: *const CudaRadixCiphertextFFI,
1609 trivial_ct_2: *const CudaRadixCiphertextFFI,
1610 trivial_ct_m_minus_1_block: *const CudaRadixCiphertextFFI,
1611 mem_ptr: *mut i8,
1612 bsks: *const *mut ffi::c_void,
1613 ksks: *const *mut ffi::c_void,
1614 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
1615 );
1616}
1617unsafe extern "C" {
1618 pub fn cleanup_cuda_integer_ilog2_kb_64(streams: CudaStreamsFFI, mem_ptr_void: *mut *mut i8);
1619}
1620#[repr(C)]
1621#[derive(Debug, Copy, Clone)]
1622pub struct CudaLweCiphertextListFFI {
1623 pub ptr: *mut ffi::c_void,
1624 pub num_radix_blocks: u32,
1625 pub lwe_dimension: u32,
1626}
1627#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1628const _: () = {
1629 ["Size of CudaLweCiphertextListFFI"]
1630 [::std::mem::size_of::<CudaLweCiphertextListFFI>() - 16usize];
1631 ["Alignment of CudaLweCiphertextListFFI"]
1632 [::std::mem::align_of::<CudaLweCiphertextListFFI>() - 8usize];
1633 ["Offset of field: CudaLweCiphertextListFFI::ptr"]
1634 [::std::mem::offset_of!(CudaLweCiphertextListFFI, ptr) - 0usize];
1635 ["Offset of field: CudaLweCiphertextListFFI::num_radix_blocks"]
1636 [::std::mem::offset_of!(CudaLweCiphertextListFFI, num_radix_blocks) - 8usize];
1637 ["Offset of field: CudaLweCiphertextListFFI::lwe_dimension"]
1638 [::std::mem::offset_of!(CudaLweCiphertextListFFI, lwe_dimension) - 12usize];
1639};
1640#[repr(C)]
1641#[derive(Debug, Copy, Clone)]
1642pub struct CudaPackedGlweCiphertextListFFI {
1643 pub ptr: *mut ffi::c_void,
1644 pub storage_log_modulus: u32,
1645 pub lwe_per_glwe: u32,
1646 pub total_lwe_bodies_count: u32,
1647 pub glwe_dimension: u32,
1648 pub polynomial_size: u32,
1649}
1650#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1651const _: () = {
1652 ["Size of CudaPackedGlweCiphertextListFFI"]
1653 [::std::mem::size_of::<CudaPackedGlweCiphertextListFFI>() - 32usize];
1654 ["Alignment of CudaPackedGlweCiphertextListFFI"]
1655 [::std::mem::align_of::<CudaPackedGlweCiphertextListFFI>() - 8usize];
1656 ["Offset of field: CudaPackedGlweCiphertextListFFI::ptr"]
1657 [::std::mem::offset_of!(CudaPackedGlweCiphertextListFFI, ptr) - 0usize];
1658 ["Offset of field: CudaPackedGlweCiphertextListFFI::storage_log_modulus"]
1659 [::std::mem::offset_of!(CudaPackedGlweCiphertextListFFI, storage_log_modulus) - 8usize];
1660 ["Offset of field: CudaPackedGlweCiphertextListFFI::lwe_per_glwe"]
1661 [::std::mem::offset_of!(CudaPackedGlweCiphertextListFFI, lwe_per_glwe) - 12usize];
1662 ["Offset of field: CudaPackedGlweCiphertextListFFI::total_lwe_bodies_count"]
1663 [::std::mem::offset_of!(CudaPackedGlweCiphertextListFFI, total_lwe_bodies_count) - 16usize];
1664 ["Offset of field: CudaPackedGlweCiphertextListFFI::glwe_dimension"]
1665 [::std::mem::offset_of!(CudaPackedGlweCiphertextListFFI, glwe_dimension) - 20usize];
1666 ["Offset of field: CudaPackedGlweCiphertextListFFI::polynomial_size"]
1667 [::std::mem::offset_of!(CudaPackedGlweCiphertextListFFI, polynomial_size) - 24usize];
1668};
1669unsafe extern "C" {
1670 pub fn scratch_cuda_integer_compress_radix_ciphertext_64(
1671 streams: CudaStreamsFFI,
1672 mem_ptr: *mut *mut i8,
1673 compression_glwe_dimension: u32,
1674 compression_polynomial_size: u32,
1675 lwe_dimension: u32,
1676 ks_level: u32,
1677 ks_base_log: u32,
1678 num_radix_blocks: u32,
1679 message_modulus: u32,
1680 carry_modulus: u32,
1681 pbs_type: PBS_TYPE,
1682 lwe_per_glwe: u32,
1683 allocate_gpu_memory: bool,
1684 ) -> u64;
1685}
1686unsafe extern "C" {
1687 pub fn scratch_cuda_integer_decompress_radix_ciphertext_64(
1688 streams: CudaStreamsFFI,
1689 mem_ptr: *mut *mut i8,
1690 encryption_glwe_dimension: u32,
1691 encryption_polynomial_size: u32,
1692 compression_glwe_dimension: u32,
1693 compression_polynomial_size: u32,
1694 lwe_dimension: u32,
1695 pbs_level: u32,
1696 pbs_base_log: u32,
1697 num_blocks_to_decompress: u32,
1698 message_modulus: u32,
1699 carry_modulus: u32,
1700 pbs_type: PBS_TYPE,
1701 allocate_gpu_memory: bool,
1702 noise_reduction_type: PBS_MS_REDUCTION_T,
1703 ) -> u64;
1704}
1705unsafe extern "C" {
1706 pub fn cuda_integer_compress_radix_ciphertext_64(
1707 streams: CudaStreamsFFI,
1708 glwe_array_out: *mut CudaPackedGlweCiphertextListFFI,
1709 lwe_array_in: *const CudaLweCiphertextListFFI,
1710 fp_ksk: *const *mut ffi::c_void,
1711 mem_ptr: *mut i8,
1712 );
1713}
1714unsafe extern "C" {
1715 pub fn cuda_integer_decompress_radix_ciphertext_64(
1716 streams: CudaStreamsFFI,
1717 lwe_array_out: *mut CudaLweCiphertextListFFI,
1718 glwe_in: *const CudaPackedGlweCiphertextListFFI,
1719 indexes_array: *const u32,
1720 bsks: *const *mut ffi::c_void,
1721 mem_ptr: *mut i8,
1722 );
1723}
1724unsafe extern "C" {
1725 pub fn cleanup_cuda_integer_compress_radix_ciphertext_64(
1726 streams: CudaStreamsFFI,
1727 mem_ptr_void: *mut *mut i8,
1728 );
1729}
1730unsafe extern "C" {
1731 pub fn cleanup_cuda_integer_decompress_radix_ciphertext_64(
1732 streams: CudaStreamsFFI,
1733 mem_ptr_void: *mut *mut i8,
1734 );
1735}
1736unsafe extern "C" {
1737 pub fn scratch_cuda_integer_compress_radix_ciphertext_128(
1738 streams: CudaStreamsFFI,
1739 mem_ptr: *mut *mut i8,
1740 compression_glwe_dimension: u32,
1741 compression_polynomial_size: u32,
1742 lwe_dimension: u32,
1743 ks_level: u32,
1744 ks_base_log: u32,
1745 num_radix_blocks: u32,
1746 message_modulus: u32,
1747 carry_modulus: u32,
1748 pbs_type: PBS_TYPE,
1749 lwe_per_glwe: u32,
1750 allocate_gpu_memory: bool,
1751 ) -> u64;
1752}
1753unsafe extern "C" {
1754 pub fn scratch_cuda_integer_decompress_radix_ciphertext_128(
1755 streams: CudaStreamsFFI,
1756 mem_ptr: *mut *mut i8,
1757 compression_glwe_dimension: u32,
1758 compression_polynomial_size: u32,
1759 lwe_dimension: u32,
1760 num_radix_blocks: u32,
1761 message_modulus: u32,
1762 carry_modulus: u32,
1763 allocate_gpu_memory: bool,
1764 ) -> u64;
1765}
1766unsafe extern "C" {
1767 pub fn cuda_integer_compress_radix_ciphertext_128(
1768 streams: CudaStreamsFFI,
1769 glwe_array_out: *mut CudaPackedGlweCiphertextListFFI,
1770 lwe_array_in: *const CudaLweCiphertextListFFI,
1771 fp_ksk: *const *mut ffi::c_void,
1772 mem_ptr: *mut i8,
1773 );
1774}
1775unsafe extern "C" {
1776 pub fn cuda_integer_decompress_radix_ciphertext_128(
1777 streams: CudaStreamsFFI,
1778 lwe_array_out: *mut CudaLweCiphertextListFFI,
1779 glwe_in: *const CudaPackedGlweCiphertextListFFI,
1780 indexes_array: *const u32,
1781 mem_ptr: *mut i8,
1782 );
1783}
1784unsafe extern "C" {
1785 pub fn cleanup_cuda_integer_compress_radix_ciphertext_128(
1786 streams: CudaStreamsFFI,
1787 mem_ptr_void: *mut *mut i8,
1788 );
1789}
1790unsafe extern "C" {
1791 pub fn cleanup_cuda_integer_decompress_radix_ciphertext_128(
1792 streams: CudaStreamsFFI,
1793 mem_ptr_void: *mut *mut i8,
1794 );
1795}
1796pub const KS_TYPE_BIG_TO_SMALL: KS_TYPE = 0;
1797pub const KS_TYPE_SMALL_TO_BIG: KS_TYPE = 1;
1798pub type KS_TYPE = ffi::c_uint;
1799unsafe extern "C" {
1800 pub fn scratch_cuda_expand_without_verification_64(
1801 streams: CudaStreamsFFI,
1802 mem_ptr: *mut *mut i8,
1803 glwe_dimension: u32,
1804 polynomial_size: u32,
1805 big_lwe_dimension: u32,
1806 small_lwe_dimension: u32,
1807 computing_ks_level: u32,
1808 computing_ks_base_log: u32,
1809 casting_input_dimension: u32,
1810 casting_output_dimension: u32,
1811 casting_ks_level: u32,
1812 casting_ks_base_log: u32,
1813 pbs_level: u32,
1814 pbs_base_log: u32,
1815 grouping_factor: u32,
1816 num_lwes_per_compact_list: *const u32,
1817 is_boolean_array: *const bool,
1818 num_compact_lists: u32,
1819 message_modulus: u32,
1820 carry_modulus: u32,
1821 pbs_type: PBS_TYPE,
1822 casting_key_type: KS_TYPE,
1823 allocate_gpu_memory: bool,
1824 noise_reduction_type: PBS_MS_REDUCTION_T,
1825 ) -> u64;
1826}
1827unsafe extern "C" {
1828 pub fn cuda_expand_without_verification_64(
1829 streams: CudaStreamsFFI,
1830 lwe_array_out: *mut ffi::c_void,
1831 lwe_flattened_compact_array_in: *const ffi::c_void,
1832 mem_ptr: *mut i8,
1833 bsks: *const *mut ffi::c_void,
1834 computing_ksks: *const *mut ffi::c_void,
1835 casting_keys: *const *mut ffi::c_void,
1836 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
1837 );
1838}
1839unsafe extern "C" {
1840 pub fn cleanup_expand_without_verification_64(
1841 streams: CudaStreamsFFI,
1842 mem_ptr_void: *mut *mut i8,
1843 );
1844}
1845unsafe extern "C" {
1846 pub fn cuda_keyswitch_lwe_ciphertext_vector_32(
1847 stream: *mut ffi::c_void,
1848 gpu_index: u32,
1849 lwe_array_out: *mut ffi::c_void,
1850 lwe_output_indexes: *const ffi::c_void,
1851 lwe_array_in: *const ffi::c_void,
1852 lwe_input_indexes: *const ffi::c_void,
1853 ksk: *const ffi::c_void,
1854 lwe_dimension_in: u32,
1855 lwe_dimension_out: u32,
1856 base_log: u32,
1857 level_count: u32,
1858 num_samples: u32,
1859 );
1860}
1861unsafe extern "C" {
1862 pub fn cuda_keyswitch_lwe_ciphertext_vector_64(
1863 stream: *mut ffi::c_void,
1864 gpu_index: u32,
1865 lwe_array_out: *mut ffi::c_void,
1866 lwe_output_indexes: *const ffi::c_void,
1867 lwe_array_in: *const ffi::c_void,
1868 lwe_input_indexes: *const ffi::c_void,
1869 ksk: *const ffi::c_void,
1870 lwe_dimension_in: u32,
1871 lwe_dimension_out: u32,
1872 base_log: u32,
1873 level_count: u32,
1874 num_samples: u32,
1875 );
1876}
1877unsafe extern "C" {
1878 pub fn scratch_packing_keyswitch_lwe_list_to_glwe_64(
1879 stream: *mut ffi::c_void,
1880 gpu_index: u32,
1881 fp_ks_buffer: *mut *mut i8,
1882 lwe_dimension: u32,
1883 glwe_dimension: u32,
1884 polynomial_size: u32,
1885 num_lwes: u32,
1886 allocate_gpu_memory: bool,
1887 ) -> u64;
1888}
1889unsafe extern "C" {
1890 pub fn cuda_packing_keyswitch_lwe_list_to_glwe_64(
1891 stream: *mut ffi::c_void,
1892 gpu_index: u32,
1893 glwe_array_out: *mut ffi::c_void,
1894 lwe_array_in: *const ffi::c_void,
1895 fp_ksk_array: *const ffi::c_void,
1896 fp_ks_buffer: *mut i8,
1897 input_lwe_dimension: u32,
1898 output_glwe_dimension: u32,
1899 output_polynomial_size: u32,
1900 base_log: u32,
1901 level_count: u32,
1902 num_lwes: u32,
1903 );
1904}
1905unsafe extern "C" {
1906 pub fn scratch_packing_keyswitch_lwe_list_to_glwe_128(
1907 stream: *mut ffi::c_void,
1908 gpu_index: u32,
1909 fp_ks_buffer: *mut *mut i8,
1910 lwe_dimension: u32,
1911 glwe_dimension: u32,
1912 polynomial_size: u32,
1913 num_lwes: u32,
1914 allocate_gpu_memory: bool,
1915 );
1916}
1917unsafe extern "C" {
1918 pub fn cuda_packing_keyswitch_lwe_list_to_glwe_128(
1919 stream: *mut ffi::c_void,
1920 gpu_index: u32,
1921 glwe_array_out: *mut ffi::c_void,
1922 lwe_array_in: *const ffi::c_void,
1923 fp_ksk_array: *const ffi::c_void,
1924 fp_ks_buffer: *mut i8,
1925 input_lwe_dimension: u32,
1926 output_glwe_dimension: u32,
1927 output_polynomial_size: u32,
1928 base_log: u32,
1929 level_count: u32,
1930 num_lwes: u32,
1931 );
1932}
1933unsafe extern "C" {
1934 pub fn cleanup_packing_keyswitch_lwe_list_to_glwe(
1935 stream: *mut ffi::c_void,
1936 gpu_index: u32,
1937 fp_ks_buffer: *mut *mut i8,
1938 gpu_memory_allocated: bool,
1939 );
1940}
1941unsafe extern "C" {
1942 pub fn cuda_negate_lwe_ciphertext_vector_32(
1943 stream: *mut ffi::c_void,
1944 gpu_index: u32,
1945 lwe_array_out: *mut ffi::c_void,
1946 lwe_array_in: *const ffi::c_void,
1947 input_lwe_dimension: u32,
1948 input_lwe_ciphertext_count: u32,
1949 );
1950}
1951unsafe extern "C" {
1952 pub fn cuda_negate_lwe_ciphertext_vector_64(
1953 stream: *mut ffi::c_void,
1954 gpu_index: u32,
1955 lwe_array_out: *mut ffi::c_void,
1956 lwe_array_in: *const ffi::c_void,
1957 input_lwe_dimension: u32,
1958 input_lwe_ciphertext_count: u32,
1959 );
1960}
1961unsafe extern "C" {
1962 pub fn cuda_add_lwe_ciphertext_vector_32(
1963 stream: *mut ffi::c_void,
1964 gpu_index: u32,
1965 output: *mut CudaRadixCiphertextFFI,
1966 input_1: *const CudaRadixCiphertextFFI,
1967 input_2: *const CudaRadixCiphertextFFI,
1968 );
1969}
1970unsafe extern "C" {
1971 pub fn cuda_add_lwe_ciphertext_vector_64(
1972 stream: *mut ffi::c_void,
1973 gpu_index: u32,
1974 output: *mut CudaRadixCiphertextFFI,
1975 input_1: *const CudaRadixCiphertextFFI,
1976 input_2: *const CudaRadixCiphertextFFI,
1977 );
1978}
1979unsafe extern "C" {
1980 pub fn cuda_add_lwe_ciphertext_vector_plaintext_vector_32(
1981 stream: *mut ffi::c_void,
1982 gpu_index: u32,
1983 lwe_array_out: *mut ffi::c_void,
1984 lwe_array_in: *const ffi::c_void,
1985 plaintext_array_in: *const ffi::c_void,
1986 input_lwe_dimension: u32,
1987 input_lwe_ciphertext_count: u32,
1988 );
1989}
1990unsafe extern "C" {
1991 pub fn cuda_add_lwe_ciphertext_vector_plaintext_vector_64(
1992 stream: *mut ffi::c_void,
1993 gpu_index: u32,
1994 lwe_array_out: *mut ffi::c_void,
1995 lwe_array_in: *const ffi::c_void,
1996 plaintext_array_in: *const ffi::c_void,
1997 input_lwe_dimension: u32,
1998 input_lwe_ciphertext_count: u32,
1999 );
2000}
2001unsafe extern "C" {
2002 pub fn cuda_mult_lwe_ciphertext_vector_cleartext_vector_32(
2003 stream: *mut ffi::c_void,
2004 gpu_index: u32,
2005 lwe_array_out: *mut ffi::c_void,
2006 lwe_array_in: *const ffi::c_void,
2007 cleartext_array_in: *const ffi::c_void,
2008 input_lwe_dimension: u32,
2009 input_lwe_ciphertext_count: u32,
2010 );
2011}
2012unsafe extern "C" {
2013 pub fn cuda_mult_lwe_ciphertext_vector_cleartext_vector_64(
2014 stream: *mut ffi::c_void,
2015 gpu_index: u32,
2016 lwe_array_out: *mut ffi::c_void,
2017 lwe_array_in: *const ffi::c_void,
2018 cleartext_array_in: *const ffi::c_void,
2019 input_lwe_dimension: u32,
2020 input_lwe_ciphertext_count: u32,
2021 );
2022}
2023unsafe extern "C" {
2024 pub fn scratch_wrapping_polynomial_mul_one_to_many_64(
2025 stream: *mut ffi::c_void,
2026 gpu_index: u32,
2027 polynomial_size: u32,
2028 circulant_buf: *mut *mut i8,
2029 );
2030}
2031unsafe extern "C" {
2032 pub fn cleanup_wrapping_polynomial_mul_one_to_many_64(
2033 stream: *mut ffi::c_void,
2034 gpu_index: u32,
2035 circulant_buf: *mut i8,
2036 );
2037}
2038unsafe extern "C" {
2039 pub fn cuda_wrapping_polynomial_mul_one_to_many_64(
2040 stream: *mut ffi::c_void,
2041 gpu_index: u32,
2042 result: *mut ffi::c_void,
2043 poly_lhs: *const ffi::c_void,
2044 circulant: *mut i8,
2045 poly_rhs: *const ffi::c_void,
2046 polynomial_size: u32,
2047 n_rhs: u32,
2048 );
2049}
2050unsafe extern "C" {
2051 pub fn cuda_glwe_wrapping_polynomial_mul_one_to_many_64(
2052 stream: *mut ffi::c_void,
2053 gpu_index: u32,
2054 result: *mut ffi::c_void,
2055 poly_lhs: *const ffi::c_void,
2056 circulant: *mut i8,
2057 poly_rhs: *const ffi::c_void,
2058 polynomial_size: u32,
2059 glwe_dimension: u32,
2060 n_rhs: u32,
2061 );
2062}
2063unsafe extern "C" {
2064 pub fn cuda_add_lwe_ciphertext_vector_plaintext_64(
2065 stream: *mut ffi::c_void,
2066 gpu_index: u32,
2067 lwe_array_out: *mut ffi::c_void,
2068 lwe_array_in: *const ffi::c_void,
2069 plaintext_in: u64,
2070 input_lwe_dimension: u32,
2071 input_lwe_ciphertext_count: u32,
2072 );
2073}
2074unsafe extern "C" {
2075 pub fn cuda_fourier_transform_forward_as_torus_f128_async(
2076 stream: *mut ffi::c_void,
2077 gpu_index: u32,
2078 re0: *mut ffi::c_void,
2079 re1: *mut ffi::c_void,
2080 im0: *mut ffi::c_void,
2081 im1: *mut ffi::c_void,
2082 standard: *const ffi::c_void,
2083 N: u32,
2084 number_of_samples: u32,
2085 );
2086}
2087unsafe extern "C" {
2088 pub fn cuda_fourier_transform_forward_as_integer_f128_async(
2089 stream: *mut ffi::c_void,
2090 gpu_index: u32,
2091 re0: *mut ffi::c_void,
2092 re1: *mut ffi::c_void,
2093 im0: *mut ffi::c_void,
2094 im1: *mut ffi::c_void,
2095 standard: *const ffi::c_void,
2096 N: u32,
2097 number_of_samples: u32,
2098 );
2099}
2100unsafe extern "C" {
2101 pub fn cuda_fourier_transform_backward_as_torus_f128_async(
2102 stream: *mut ffi::c_void,
2103 gpu_index: u32,
2104 standard: *mut ffi::c_void,
2105 re0: *const ffi::c_void,
2106 re1: *const ffi::c_void,
2107 im0: *const ffi::c_void,
2108 im1: *const ffi::c_void,
2109 N: u32,
2110 number_of_samples: u32,
2111 );
2112}
2113unsafe extern "C" {
2114 pub fn cuda_fourier_polynomial_mul(
2115 stream: *mut ffi::c_void,
2116 gpu_index: u32,
2117 input1: *const ffi::c_void,
2118 input2: *const ffi::c_void,
2119 output: *mut ffi::c_void,
2120 polynomial_size: u32,
2121 total_polynomials: u32,
2122 );
2123}
2124unsafe extern "C" {
2125 pub fn cuda_convert_lwe_programmable_bootstrap_key_32(
2126 stream: *mut ffi::c_void,
2127 gpu_index: u32,
2128 dest: *mut ffi::c_void,
2129 src: *const ffi::c_void,
2130 input_lwe_dim: u32,
2131 glwe_dim: u32,
2132 level_count: u32,
2133 polynomial_size: u32,
2134 );
2135}
2136unsafe extern "C" {
2137 pub fn cuda_convert_lwe_programmable_bootstrap_key_64(
2138 stream: *mut ffi::c_void,
2139 gpu_index: u32,
2140 dest: *mut ffi::c_void,
2141 src: *const ffi::c_void,
2142 input_lwe_dim: u32,
2143 glwe_dim: u32,
2144 level_count: u32,
2145 polynomial_size: u32,
2146 );
2147}
2148unsafe extern "C" {
2149 pub fn cuda_convert_lwe_programmable_bootstrap_key_128(
2150 stream: *mut ffi::c_void,
2151 gpu_index: u32,
2152 dest: *mut ffi::c_void,
2153 src: *const ffi::c_void,
2154 input_lwe_dim: u32,
2155 glwe_dim: u32,
2156 level_count: u32,
2157 polynomial_size: u32,
2158 );
2159}
2160unsafe extern "C" {
2161 pub fn scratch_cuda_programmable_bootstrap_amortized_32(
2162 stream: *mut ffi::c_void,
2163 gpu_index: u32,
2164 pbs_buffer: *mut *mut i8,
2165 glwe_dimension: u32,
2166 polynomial_size: u32,
2167 input_lwe_ciphertext_count: u32,
2168 allocate_gpu_memory: bool,
2169 ) -> u64;
2170}
2171unsafe extern "C" {
2172 pub fn scratch_cuda_programmable_bootstrap_amortized_64(
2173 stream: *mut ffi::c_void,
2174 gpu_index: u32,
2175 pbs_buffer: *mut *mut i8,
2176 glwe_dimension: u32,
2177 polynomial_size: u32,
2178 input_lwe_ciphertext_count: u32,
2179 allocate_gpu_memory: bool,
2180 ) -> u64;
2181}
2182unsafe extern "C" {
2183 pub fn cuda_programmable_bootstrap_amortized_lwe_ciphertext_vector_32(
2184 stream: *mut ffi::c_void,
2185 gpu_index: u32,
2186 lwe_array_out: *mut ffi::c_void,
2187 lwe_output_indexes: *const ffi::c_void,
2188 lut_vector: *const ffi::c_void,
2189 lut_vector_indexes: *const ffi::c_void,
2190 lwe_array_in: *const ffi::c_void,
2191 lwe_input_indexes: *const ffi::c_void,
2192 bootstrapping_key: *const ffi::c_void,
2193 pbs_buffer: *mut i8,
2194 lwe_dimension: u32,
2195 glwe_dimension: u32,
2196 polynomial_size: u32,
2197 base_log: u32,
2198 level_count: u32,
2199 num_samples: u32,
2200 );
2201}
2202unsafe extern "C" {
2203 pub fn cuda_programmable_bootstrap_amortized_lwe_ciphertext_vector_64(
2204 stream: *mut ffi::c_void,
2205 gpu_index: u32,
2206 lwe_array_out: *mut ffi::c_void,
2207 lwe_output_indexes: *const ffi::c_void,
2208 lut_vector: *const ffi::c_void,
2209 lut_vector_indexes: *const ffi::c_void,
2210 lwe_array_in: *const ffi::c_void,
2211 lwe_input_indexes: *const ffi::c_void,
2212 bootstrapping_key: *const ffi::c_void,
2213 pbs_buffer: *mut i8,
2214 lwe_dimension: u32,
2215 glwe_dimension: u32,
2216 polynomial_size: u32,
2217 base_log: u32,
2218 level_count: u32,
2219 num_samples: u32,
2220 );
2221}
2222unsafe extern "C" {
2223 pub fn cleanup_cuda_programmable_bootstrap_amortized(
2224 stream: *mut ffi::c_void,
2225 gpu_index: u32,
2226 pbs_buffer: *mut *mut i8,
2227 );
2228}
2229unsafe extern "C" {
2230 pub fn scratch_cuda_programmable_bootstrap_32(
2231 stream: *mut ffi::c_void,
2232 gpu_index: u32,
2233 buffer: *mut *mut i8,
2234 lwe_dimension: u32,
2235 glwe_dimension: u32,
2236 polynomial_size: u32,
2237 level_count: u32,
2238 input_lwe_ciphertext_count: u32,
2239 allocate_gpu_memory: bool,
2240 noise_reduction_type: PBS_MS_REDUCTION_T,
2241 ) -> u64;
2242}
2243unsafe extern "C" {
2244 pub fn scratch_cuda_programmable_bootstrap_64(
2245 stream: *mut ffi::c_void,
2246 gpu_index: u32,
2247 buffer: *mut *mut i8,
2248 lwe_dimension: u32,
2249 glwe_dimension: u32,
2250 polynomial_size: u32,
2251 level_count: u32,
2252 input_lwe_ciphertext_count: u32,
2253 allocate_gpu_memory: bool,
2254 noise_reduction_type: PBS_MS_REDUCTION_T,
2255 ) -> u64;
2256}
2257unsafe extern "C" {
2258 pub fn scratch_cuda_programmable_bootstrap_128(
2259 stream: *mut ffi::c_void,
2260 gpu_index: u32,
2261 buffer: *mut *mut i8,
2262 lwe_dimension: u32,
2263 glwe_dimension: u32,
2264 polynomial_size: u32,
2265 level_count: u32,
2266 input_lwe_ciphertext_count: u32,
2267 allocate_gpu_memory: bool,
2268 noise_reduction_type: PBS_MS_REDUCTION_T,
2269 ) -> u64;
2270}
2271unsafe extern "C" {
2272 pub fn cuda_programmable_bootstrap_lwe_ciphertext_vector_32(
2273 stream: *mut ffi::c_void,
2274 gpu_index: u32,
2275 lwe_array_out: *mut ffi::c_void,
2276 lwe_output_indexes: *const ffi::c_void,
2277 lut_vector: *const ffi::c_void,
2278 lut_vector_indexes: *const ffi::c_void,
2279 lwe_array_in: *const ffi::c_void,
2280 lwe_input_indexes: *const ffi::c_void,
2281 bootstrapping_key: *const ffi::c_void,
2282 buffer: *mut i8,
2283 lwe_dimension: u32,
2284 glwe_dimension: u32,
2285 polynomial_size: u32,
2286 base_log: u32,
2287 level_count: u32,
2288 num_samples: u32,
2289 num_many_lut: u32,
2290 lut_stride: u32,
2291 );
2292}
2293unsafe extern "C" {
2294 pub fn cuda_programmable_bootstrap_lwe_ciphertext_vector_64(
2295 stream: *mut ffi::c_void,
2296 gpu_index: u32,
2297 lwe_array_out: *mut ffi::c_void,
2298 lwe_output_indexes: *const ffi::c_void,
2299 lut_vector: *const ffi::c_void,
2300 lut_vector_indexes: *const ffi::c_void,
2301 lwe_array_in: *const ffi::c_void,
2302 lwe_input_indexes: *const ffi::c_void,
2303 bootstrapping_key: *const ffi::c_void,
2304 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
2305 ms_noise_reduction_ptr: *mut ffi::c_void,
2306 buffer: *mut i8,
2307 lwe_dimension: u32,
2308 glwe_dimension: u32,
2309 polynomial_size: u32,
2310 base_log: u32,
2311 level_count: u32,
2312 num_samples: u32,
2313 num_many_lut: u32,
2314 lut_stride: u32,
2315 );
2316}
2317unsafe extern "C" {
2318 pub fn cuda_programmable_bootstrap_lwe_ciphertext_vector_128(
2319 stream: *mut ffi::c_void,
2320 gpu_index: u32,
2321 lwe_array_out: *mut ffi::c_void,
2322 lut_vector: *const ffi::c_void,
2323 lwe_array_in: *const ffi::c_void,
2324 bootstrapping_key: *const ffi::c_void,
2325 ms_noise_reduction_key: *const CudaModulusSwitchNoiseReductionKeyFFI,
2326 ms_noise_reduction_ptr: *const ffi::c_void,
2327 buffer: *mut i8,
2328 lwe_dimension: u32,
2329 glwe_dimension: u32,
2330 polynomial_size: u32,
2331 base_log: u32,
2332 level_count: u32,
2333 num_samples: u32,
2334 );
2335}
2336unsafe extern "C" {
2337 pub fn cleanup_cuda_programmable_bootstrap(
2338 stream: *mut ffi::c_void,
2339 gpu_index: u32,
2340 pbs_buffer: *mut *mut i8,
2341 );
2342}
2343unsafe extern "C" {
2344 pub fn cleanup_cuda_programmable_bootstrap_128(
2345 stream: *mut ffi::c_void,
2346 gpu_index: u32,
2347 pbs_buffer: *mut *mut i8,
2348 );
2349}
2350unsafe extern "C" {
2351 pub fn has_support_to_cuda_programmable_bootstrap_cg_multi_bit(
2352 glwe_dimension: u32,
2353 polynomial_size: u32,
2354 level_count: u32,
2355 num_samples: u32,
2356 max_shared_memory: u32,
2357 ) -> bool;
2358}
2359unsafe extern "C" {
2360 pub fn cuda_convert_lwe_multi_bit_programmable_bootstrap_key_64(
2361 stream: *mut ffi::c_void,
2362 gpu_index: u32,
2363 dest: *mut ffi::c_void,
2364 src: *const ffi::c_void,
2365 input_lwe_dim: u32,
2366 glwe_dim: u32,
2367 level_count: u32,
2368 polynomial_size: u32,
2369 grouping_factor: u32,
2370 );
2371}
2372unsafe extern "C" {
2373 pub fn cuda_convert_lwe_multi_bit_programmable_bootstrap_key_128(
2374 stream: *mut ffi::c_void,
2375 gpu_index: u32,
2376 dest: *mut ffi::c_void,
2377 src: *const ffi::c_void,
2378 input_lwe_dim: u32,
2379 glwe_dim: u32,
2380 level_count: u32,
2381 polynomial_size: u32,
2382 grouping_factor: u32,
2383 );
2384}
2385unsafe extern "C" {
2386 pub fn scratch_cuda_multi_bit_programmable_bootstrap_64(
2387 stream: *mut ffi::c_void,
2388 gpu_index: u32,
2389 pbs_buffer: *mut *mut i8,
2390 glwe_dimension: u32,
2391 polynomial_size: u32,
2392 level_count: u32,
2393 input_lwe_ciphertext_count: u32,
2394 allocate_gpu_memory: bool,
2395 ) -> u64;
2396}
2397unsafe extern "C" {
2398 pub fn cuda_multi_bit_programmable_bootstrap_lwe_ciphertext_vector_64(
2399 stream: *mut ffi::c_void,
2400 gpu_index: u32,
2401 lwe_array_out: *mut ffi::c_void,
2402 lwe_output_indexes: *const ffi::c_void,
2403 lut_vector: *const ffi::c_void,
2404 lut_vector_indexes: *const ffi::c_void,
2405 lwe_array_in: *const ffi::c_void,
2406 lwe_input_indexes: *const ffi::c_void,
2407 bootstrapping_key: *const ffi::c_void,
2408 buffer: *mut i8,
2409 lwe_dimension: u32,
2410 glwe_dimension: u32,
2411 polynomial_size: u32,
2412 grouping_factor: u32,
2413 base_log: u32,
2414 level_count: u32,
2415 num_samples: u32,
2416 num_many_lut: u32,
2417 lut_stride: u32,
2418 );
2419}
2420unsafe extern "C" {
2421 pub fn cleanup_cuda_multi_bit_programmable_bootstrap(
2422 stream: *mut ffi::c_void,
2423 gpu_index: u32,
2424 pbs_buffer: *mut *mut i8,
2425 );
2426}
2427unsafe extern "C" {
2428 pub fn scratch_cuda_multi_bit_programmable_bootstrap_128_vector_64(
2429 stream: *mut ffi::c_void,
2430 gpu_index: u32,
2431 buffer: *mut *mut i8,
2432 glwe_dimension: u32,
2433 polynomial_size: u32,
2434 level_count: u32,
2435 input_lwe_ciphertext_count: u32,
2436 allocate_gpu_memory: bool,
2437 ) -> u64;
2438}
2439unsafe extern "C" {
2440 pub fn cuda_multi_bit_programmable_bootstrap_lwe_ciphertext_vector_128(
2441 stream: *mut ffi::c_void,
2442 gpu_index: u32,
2443 lwe_array_out: *mut ffi::c_void,
2444 lwe_output_indexes: *const ffi::c_void,
2445 lut_vector: *const ffi::c_void,
2446 lwe_array_in: *const ffi::c_void,
2447 lwe_input_indexes: *const ffi::c_void,
2448 bootstrapping_key: *const ffi::c_void,
2449 mem_ptr: *mut i8,
2450 lwe_dimension: u32,
2451 glwe_dimension: u32,
2452 polynomial_size: u32,
2453 grouping_factor: u32,
2454 base_log: u32,
2455 level_count: u32,
2456 num_samples: u32,
2457 num_many_lut: u32,
2458 lut_stride: u32,
2459 );
2460}
2461unsafe extern "C" {
2462 pub fn cleanup_cuda_multi_bit_programmable_bootstrap_128(
2463 stream: *mut ffi::c_void,
2464 gpu_index: u32,
2465 buffer: *mut *mut i8,
2466 );
2467}