rs_tfhe 0.1.1

A high-performance Rust implementation of TFHE (Torus Fully Homomorphic Encryption) with advanced programmable bootstrapping capabilities
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

/// x86_64 SIMD-optimized FFT processor using SPQLIOS C++ library
///
/// This implementation uses hand-written AVX/FMA assembly code
/// for maximum performance on Intel/AMD processors.
///
/// **Optimizations:**
/// - Hand-coded AVX2 assembly for FFT operations
/// - FMA (Fused Multiply-Add) instructions
/// - Specialized register allocation
/// - Cache-optimized butterfly operations
///
/// **Performance:** ~30ms per gate (3.5x faster than ARM64 NEON)
///
/// Only available on x86_64 architecture. Other platforms automatically
/// use the portable RustFFTProcessor instead.
use crate::fft::FFTProcessor;
use std::os::raw::c_double;
use std::os::raw::c_int;
use std::os::raw::c_uint;

pub enum SpqliosImpl {}

extern "C" {
  fn Spqlios_new(N: c_int) -> *mut SpqliosImpl;
  fn Spqlios_destructor(spqlios: *mut SpqliosImpl);
  fn Spqlios_ifft_lv1(spqlios: *mut SpqliosImpl, res: *mut c_double, src: *const c_uint);
  fn Spqlios_fft_lv1(spqlios: *mut SpqliosImpl, res: *mut c_uint, src: *const c_double);
  fn Spqlios_poly_mul_1024(
    spqlios: *mut SpqliosImpl,
    res: *mut c_uint,
    src_a: *const c_uint,
    src_b: *const c_uint,
  );
}

pub struct SpqliosFFT {
  raw: *mut SpqliosImpl,
  n: usize,
}

impl FFTProcessor for SpqliosFFT {
  fn new(n: usize) -> Self {
    unsafe {
      SpqliosFFT {
        raw: Spqlios_new(n as i32),
        n,
      }
    }
  }

  fn ifft<const N: usize>(&mut self, input: &[u32; N]) -> [f64; N] {
    let mut res: [f64; N] = [0.0f64; N];
    unsafe {
      Spqlios_ifft_lv1(self.raw, res.as_mut_ptr(), input.as_ptr());
    }
    res.try_into().unwrap()
  }

  fn fft<const N: usize>(&mut self, input: &[f64; N]) -> [u32; N] {
    let mut res: [u32; N] = [0u32; N];
    unsafe {
      Spqlios_fft_lv1(self.raw, res.as_mut_ptr(), input.as_ptr());
    }
    res.try_into().unwrap()
  }

  fn poly_mul<const N: usize>(&mut self, a: &[u32; N], b: &[u32; N]) -> [u32; N] {
    let mut res: [u32; N] = [0u32; N];
    let res_mut_ptr = res.as_mut_ptr() as *mut _;
    unsafe {
      Spqlios_poly_mul_1024(self.raw, res_mut_ptr, a.as_ptr(), b.as_ptr());
    }
    res.try_into().unwrap()
  }

  fn batch_ifft<const N: usize>(&mut self, inputs: &[[u32; N]]) -> Vec<[f64; N]> {
    inputs.iter().map(|input| self.ifft::<N>(input)).collect()
  }

  fn batch_fft<const N: usize>(&mut self, inputs: &[[f64; N]]) -> Vec<[u32; N]> {
    inputs.iter().map(|input| self.fft::<N>(input)).collect()
  }
}
impl Drop for SpqliosFFT {
  fn drop(&mut self) {
    unsafe {
      Spqlios_destructor(self.raw);
    }
  }
}