Add spqlios-intl: interleaved-format FFT backend

Add a new FFT backend at thirdparties/spqlios-intl/ that uses interleaved
complex layout [re0,im0,re1,im1,...] instead of SPQLIOS's split layout.

Enable with -DUSE_SPQLIOS_INTL=ON. This sets USE_INTERLEAVED_FORMAT and
links the new library.

Components:
  - fft_processor_spqlios_intl.h: class with same interface as SPQLIOS
  - fft_processor_spqlios_intl.cpp: C++ FFT/IFFT with AVX2 intrinsics
    - Complex multiply via unpacklo/unpackhi + vfmaddsub (3 ops)
    - Cooley-Tukey DIT (forward) / Gentleman-Sande DIF (inverse)
    - Interleaved trig tables
  - AVX2 MulInFD/FMAInFD for interleaved format in mulfft.hpp

Status: functionally correct (passes polymul, externalproduct tests).
Performance is currently ~2x slower than optimized split SPQLIOS because
the FFT butterfly lacks stage fusion. The interleaved MulInFD/FMAInFD
use vfmaddsub for complex multiply (3 loads + 1 store per 2 complex
values vs 6 loads + 2 stores for split format).

Next step: port the fused butterfly passes (Option C/D) to the
interleaved FFT to match or beat split SPQLIOS performance.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Ubuntu

CMakeLists.txt

@@ -83,6 +83,7 @@ option(USE_MKL "Use Intel MKL" OFF)
 option(USE_FFTW3 "Use FFTW3" OFF)
 option(USE_SPQLIOX_AARCH64 "Use spqliox_aarch64" OFF)
 option(USE_SPQLIOS_ARITHMETIC "Use spqlios-arithmetic backend" OFF)
+option(USE_SPQLIOS_INTL "Use interleaved-format SPQLIOS" OFF)
 option(USE_HEXL "Use Intel HEXL" OFF)
 
 option(ENABLE_TEST "Build tests" OFF)
@@ -191,6 +192,13 @@ elseif(USE_CONCRETE_FFT)
   add_compile_definitions(USE_CONCRETE_FFT)
   add_compile_definitions(USE_INTERLEAVED_FORMAT)
   add_subdirectory(thirdparties/concrete-fft)
+elseif(USE_SPQLIOS_INTL)
+  set(TFHEpp_DEFINITIONS
+      "${TFHEpp_DEFINITIONS};USE_SPQLIOS_INTL;USE_INTERLEAVED_FORMAT"
+      PARENT_SCOPE)
+  add_compile_definitions(USE_SPQLIOS_INTL)
+  add_compile_definitions(USE_INTERLEAVED_FORMAT)
+  add_subdirectory(thirdparties/spqlios-intl)
 elseif(USE_SPQLIOS_ARITHMETIC)
   set(TFHEpp_DEFINITIONS
       "${TFHEpp_DEFINITIONS};USE_SPQLIOS_ARITHMETIC"

benchmark/bench_fft.cpp

@@ -9,6 +9,11 @@
 #include <immintrin.h>
 #include "google-benchmark/include/benchmark/benchmark.h"
 
+// Alias for the active FFT processor type
+#ifdef USE_SPQLIOS_INTL
+using FFT_Processor_Spqlios = FFT_Processor_Spqlios_Intl;
+#endif
+
 // Forward-declare the SPQLIOS conversion functions from x86.h
 namespace SPQLIOS {
 inline __m256i mm256_cvtpd_epi64(const __m256d x) {

include/mulfft.hpp

@@ -17,6 +17,8 @@
 #include <fft_processor_concrete.hpp>
 #elif USE_SPQLIOS_ARITHMETIC
 #include <fft_processor_spqlios_arithmetic.h>
+#elif USE_SPQLIOS_INTL
+#include <fft_processor_spqlios_intl.h>
 #else
 #include <fft_processor_spqlios.h>
 #endif
@@ -217,7 +219,18 @@ inline void TwistIFFTUInt(PolynomialInFD<P> &res, const Polynomial<P> &a)
 template <uint32_t N>
 inline void MulInFD(std::array<double, N> &res, const std::array<double, N> &b)
 {
-#ifdef USE_INTERLEAVED_FORMAT
+#if defined(USE_INTERLEAVED_FORMAT) && defined(__AVX2__)
+    // AVX2 interleaved complex multiply: 2 complex per YMM
+    for (uint32_t i = 0; i < N; i += 4) {
+        __m256d a = _mm256_load_pd(res.data() + i);
+        __m256d w = _mm256_load_pd(b.data() + i);
+        __m256d w_swap = _mm256_permute_pd(w, 0b0101);
+        __m256d a_re = _mm256_unpacklo_pd(a, a);
+        __m256d a_im = _mm256_unpackhi_pd(a, a);
+        _mm256_store_pd(res.data() + i,
+            _mm256_fmaddsub_pd(a_re, w, _mm256_mul_pd(a_im, w_swap)));
+    }
+#elif defined(USE_INTERLEAVED_FORMAT)
     for (int i = 0; i < N / 2; i++) {
         const std::complex tmp = std::complex(res[2 * i], res[2 * i + 1]) *
                                  std::complex(b[2 * i], b[2 * i + 1]);
@@ -279,7 +292,17 @@ template <uint32_t N>
 inline void MulInFD(std::array<double, N> &res, const std::array<double, N> &a,
                     const std::array<double, N> &b)
 {
-#ifdef USE_INTERLEAVED_FORMAT
+#if defined(USE_INTERLEAVED_FORMAT) && defined(__AVX2__)
+    for (uint32_t i = 0; i < N; i += 4) {
+        __m256d va = _mm256_load_pd(a.data() + i);
+        __m256d w = _mm256_load_pd(b.data() + i);
+        __m256d w_swap = _mm256_permute_pd(w, 0b0101);
+        __m256d a_re = _mm256_unpacklo_pd(va, va);
+        __m256d a_im = _mm256_unpackhi_pd(va, va);
+        _mm256_store_pd(res.data() + i,
+            _mm256_fmaddsub_pd(a_re, w, _mm256_mul_pd(a_im, w_swap)));
+    }
+#elif defined(USE_INTERLEAVED_FORMAT)
     for (int i = 0; i < N / 2; i++) {
         const std::complex tmp = std::complex(a[2 * i], a[2 * i + 1]) *
                                  std::complex(b[2 * i], b[2 * i + 1]);
@@ -347,7 +370,19 @@ template <uint32_t N>
 inline void FMAInFD(std::array<double, N> &res, const std::array<double, N> &a,
                     const std::array<double, N> &b)
 {
-#ifdef USE_INTERLEAVED_FORMAT
+#if defined(USE_INTERLEAVED_FORMAT) && defined(__AVX2__)
+    // AVX2 interleaved complex FMA: res += a * b
+    for (uint32_t i = 0; i < N; i += 4) {
+        __m256d va = _mm256_load_pd(a.data() + i);
+        __m256d w = _mm256_load_pd(b.data() + i);
+        __m256d r = _mm256_load_pd(res.data() + i);
+        __m256d w_swap = _mm256_permute_pd(w, 0b0101);
+        __m256d a_re = _mm256_unpacklo_pd(va, va);
+        __m256d a_im = _mm256_unpackhi_pd(va, va);
+        __m256d prod = _mm256_fmaddsub_pd(a_re, w, _mm256_mul_pd(a_im, w_swap));
+        _mm256_store_pd(res.data() + i, _mm256_add_pd(r, prod));
+    }
+#elif defined(USE_INTERLEAVED_FORMAT)
     for (int i = 0; i < N / 2; i++) {
         std::complex tmp = std::complex(a[2 * i], a[2 * i + 1]) *
                            std::complex(b[2 * i], b[2 * i + 1]);

src/CMakeLists.txt

@@ -58,6 +58,10 @@ elseif(USE_SPQLIOS_ARITHMETIC)
   target_link_libraries(tfhe++ INTERFACE libspqlios)
   target_include_directories(
     tfhe++ PUBLIC ${PROJECT_SOURCE_DIR}/thirdparties/spqlios-arithmetic)
+elseif(USE_SPQLIOS_INTL)
+  target_link_libraries(tfhe++ INTERFACE spqlios-intl)
+  target_include_directories(
+    tfhe++ PUBLIC ${PROJECT_SOURCE_DIR}/thirdparties/spqlios-intl)
 else()
   if(USE_MKL)
     target_link_libraries(tfhe++ INTERFACE mklproc)

thirdparties/spqlios-intl/CMakeLists.txt

@@ -0,0 +1,6 @@
+add_library(spqlios-intl STATIC
+    fft_processor_spqlios_intl.cpp
+)
+target_include_directories(spqlios-intl PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
+target_include_directories(spqlios-intl PRIVATE ${CMAKE_SOURCE_DIR}/include)
+target_compile_options(spqlios-intl PRIVATE -mavx2 -mfma)