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