Extract PQ4 kernels to includable headers in impl/pq_4bit/ (#4868)

Summary:

Move kernel templates from .cpp anonymous namespaces into includable headers,
parameterized on SIMDLevel SL. No behavior change — existing .cpp files include
the headers and instantiate with defaults.

New headers:
- kernels_simd256.h: multi-BB kernel (from search_1.cpp) + single-BB QBS
  256-bit kernel (from search_qbs.cpp non-AVX512 path)
- kernels_simd512.h: AVX512 nq1/nqx kernels + dispatcher (from search_qbs.cpp)
- decompose_qbs.h: unified kernel_accumulate_block<NQ, SL> that replaces
  #ifndef __AVX512F__ with if constexpr on SL, plus QBS decomposition logic

Template param order: <int NQ, SIMDLevel SL, class ResultHandler, class Scaler>
to enable ergonomic SL propagation via kernel_accumulate_block<Q1, SL>(...).

~900 lines moved (code motion), ~100 lines changed. Pure refactor.

Reviewed By: mdouze, mnorris11

Differential Revision: D95392155

Author: algoriddle

faiss/CMakeLists.txt

@@ -263,6 +263,9 @@ set(FAISS_HEADERS
   impl/lattice_Zn.h
   impl/platform_macros.h
   impl/pq4_fast_scan.h
+  impl/pq_4bit/decompose_qbs.h
+  impl/pq_4bit/kernels_simd256.h
+  impl/pq_4bit/kernels_simd512.h
   impl/residual_quantizer_encode_steps.h
   impl/simd_dispatch.h
   impl/simd_result_handlers.h

faiss/impl/pq4_fast_scan_search_1.cpp

@@ -9,6 +9,7 @@
 
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/impl/LookupTableScaler.h>
+#include <faiss/impl/pq_4bit/kernels_simd256.h>
 #include <faiss/impl/simd_result_handlers.h>
 
 namespace faiss {
@@ -21,101 +22,6 @@ using namespace simd_result_handlers;
 
 namespace {
 
-/*
- * The computation kernel
- * It accumulates results for NQ queries and BB * 32 database elements
- * writes results in a ResultHandler
- */
-
-template <int NQ, int BB, class ResultHandler, class Scaler>
-void kernel_accumulate_block(
-        int nsq,
-        const uint8_t* codes,
-        const uint8_t* LUT,
-        ResultHandler& res,
-        const Scaler& scaler) {
-    // distance accumulators
-    simd16uint16 accu[NQ][BB][4];
-
-    for (int q = 0; q < NQ; q++) {
-        for (int b = 0; b < BB; b++) {
-            accu[q][b][0].clear();
-            accu[q][b][1].clear();
-            accu[q][b][2].clear();
-            accu[q][b][3].clear();
-        }
-    }
-
-    for (int sq = 0; sq < nsq - scaler.nscale; sq += 2) {
-        simd32uint8 lut_cache[NQ];
-        for (int q = 0; q < NQ; q++) {
-            lut_cache[q] = simd32uint8(LUT);
-            LUT += 32;
-        }
-
-        for (int b = 0; b < BB; b++) {
-            simd32uint8 c = simd32uint8(codes);
-            codes += 32;
-            simd32uint8 mask(15);
-            simd32uint8 chi = simd32uint8(simd16uint16(c) >> 4) & mask;
-            simd32uint8 clo = c & mask;
-
-            for (int q = 0; q < NQ; q++) {
-                simd32uint8 lut = lut_cache[q];
-                simd32uint8 res0 = lut.lookup_2_lanes(clo);
-                simd32uint8 res1 = lut.lookup_2_lanes(chi);
-
-                accu[q][b][0] += simd16uint16(res0);
-                accu[q][b][1] += simd16uint16(res0) >> 8;
-
-                accu[q][b][2] += simd16uint16(res1);
-                accu[q][b][3] += simd16uint16(res1) >> 8;
-            }
-        }
-    }
-
-    for (int sq = 0; sq < scaler.nscale; sq += 2) {
-        simd32uint8 lut_cache[NQ];
-        for (int q = 0; q < NQ; q++) {
-            lut_cache[q] = simd32uint8(LUT);
-            LUT += 32;
-        }
-
-        for (int b = 0; b < BB; b++) {
-            simd32uint8 c = simd32uint8(codes);
-            codes += 32;
-            simd32uint8 mask(15);
-            simd32uint8 chi = simd32uint8(simd16uint16(c) >> 4) & mask;
-            simd32uint8 clo = c & mask;
-
-            for (int q = 0; q < NQ; q++) {
-                simd32uint8 lut = lut_cache[q];
-
-                simd32uint8 res0 = scaler.lookup(lut, clo);
-                accu[q][b][0] += scaler.scale_lo(res0); // handle vectors 0..7
-                accu[q][b][1] += scaler.scale_hi(res0); // handle vectors 8..15
-
-                simd32uint8 res1 = scaler.lookup(lut, chi);
-                accu[q][b][2] += scaler.scale_lo(res1); // handle vectors 16..23
-                accu[q][b][3] +=
-                        scaler.scale_hi(res1); //  handle vectors 24..31
-            }
-        }
-    }
-
-    for (int q = 0; q < NQ; q++) {
-        for (int b = 0; b < BB; b++) {
-            accu[q][b][0] -= accu[q][b][1] << 8;
-            simd16uint16 dis0 = combine2x2(accu[q][b][0], accu[q][b][1]);
-
-            accu[q][b][2] -= accu[q][b][3] << 8;
-            simd16uint16 dis1 = combine2x2(accu[q][b][2], accu[q][b][3]);
-
-            res.handle(q, b, dis0, dis1);
-        }
-    }
-}
-
 template <int NQ, int BB, class ResultHandler, class Scaler>
 void accumulate_fixed_blocks(
         size_t nb,