faiss 0.2.0 → 0.2.4

data/vendor/faiss/faiss/impl/pq4_fast_scan.h

@@ -20,10 +20,8 @@
  * parallel compile times. Templates are instanciated explicitly.
  */
 
-
 namespace faiss {
 
-
 /** Pack codes for consumption by the SIMD kernels.
  *  The unused bytes are set to 0.
  *
@@ -36,11 +34,13 @@ namespace faiss {
  * @param blocks  output array, size nb * nsq / 2.
  */
 void pq4_pack_codes(
-        const uint8_t *codes,
-        size_t ntotal, size_t M,
-        size_t nb, size_t bbs, size_t M2,
-        uint8_t * blocks
-);
+        const uint8_t* codes,
+        size_t ntotal,
+        size_t M,
+        size_t nb,
+        size_t bbs,
+        size_t M2,
+        uint8_t* blocks);
 
 /** Same as pack_codes but write in a given range of the output,
  * leaving the rest untouched. Assumes allocated entries are 0 on input.
@@ -51,12 +51,13 @@ void pq4_pack_codes(
  * @param blocks  output array, size at least ceil(i1 / bbs) * bbs * nsq / 2
  */
 void pq4_pack_codes_range(
-        const uint8_t *codes,
+        const uint8_t* codes,
         size_t M,
-        size_t i0, size_t i1,
-        size_t bbs, size_t M2,
-        uint8_t * blocks
-);
+        size_t i0,
+        size_t i1,
+        size_t bbs,
+        size_t M2,
+        uint8_t* blocks);
 
 /** get a single element from a packed codes table
  *
@@ -64,9 +65,11 @@ void pq4_pack_codes_range(
  * @param sq       subquantizer (< nsq)
  */
 uint8_t pq4_get_packed_element(
-        const uint8_t *data, size_t bbs, size_t nsq,
-        size_t i, size_t sq
-);
+        const uint8_t* data,
+        size_t bbs,
+        size_t nsq,
+        size_t i,
+        size_t sq);
 
 /** Pack Look-up table for consumption by the kernel.
  *
@@ -75,13 +78,7 @@ uint8_t pq4_get_packed_element(
  * @param src     input array, size (nq, 16)
  * @param dest    output array, size (nq, 16)
  */
-void pq4_pack_LUT(
-        int nq, int nsq,
-        const uint8_t *src,
-        uint8_t *dest
-);
-
-
+void pq4_pack_LUT(int nq, int nsq, const uint8_t* src, uint8_t* dest);
 
 /** Loop over database elements and accumulate results into result handler
  *
@@ -92,16 +89,15 @@ void pq4_pack_LUT(
  * @param codes   packed codes array
  * @param LUT     packed look-up table
  */
-template<class ResultHandler>
+template <class ResultHandler>
 void pq4_accumulate_loop(
         int nq,
-        size_t nb, int bbs,
+        size_t nb,
+        int bbs,
         int nsq,
-        const uint8_t *codes,
-        const uint8_t *LUT,
-        ResultHandler & res);
-
-
+        const uint8_t* codes,
+        const uint8_t* LUT,
+        ResultHandler& res);
 
 /* qbs versions, supported only for bbs=32.
  *
@@ -115,8 +111,7 @@ void pq4_accumulate_loop(
  * nq = 3 + 2 + 2 + 1 = 6 queries. For a given total block size, the optimal
  * decomposition into sub-blocks (measured empirically) is given by
  * preferred_qbs().
-*/
-
+ */
 
 /* compute the number of queries from a base-16 decomposition */
 int pq4_qbs_to_nq(int qbs);
@@ -133,18 +128,16 @@ int pq4_preferred_qbs(int nq);
  * @param dest    output array, size (nq, 16)
  * @return nq
  */
-int pq4_pack_LUT_qbs(
-        int fqbs, int nsq,
-        const uint8_t *src,
-        uint8_t *dest
-);
+int pq4_pack_LUT_qbs(int fqbs, int nsq, const uint8_t* src, uint8_t* dest);
 
-/** Same as pq4_pack_LUT_qbs, except the source vectors are remapped with q_map */
+/** Same as pq4_pack_LUT_qbs, except the source vectors are remapped with q_map
+ */
 int pq4_pack_LUT_qbs_q_map(
-        int qbs, int nsq,
-        const uint8_t *src,
-        const int * q_map,
-        uint8_t *dest);
+        int qbs,
+        int nsq,
+        const uint8_t* src,
+        const int* q_map,
+        uint8_t* dest);
 
 /** Run accumulation loop.
  *
@@ -155,15 +148,13 @@ int pq4_pack_LUT_qbs_q_map(
  * @param LUT     look-up table (packed)
  * @param res     call-back for the resutls
  */
-template<class ResultHandler>
+template <class ResultHandler>
 void pq4_accumulate_loop_qbs(
         int qbs,
         size_t nb,
         int nsq,
-        const uint8_t *codes,
-        const uint8_t *LUT,
-        ResultHandler & res);
-
-
+        const uint8_t* codes,
+        const uint8_t* LUT,
+        ResultHandler& res);
 
-} // namespace faiss
+} // namespace faiss

data/vendor/faiss/faiss/impl/pq4_fast_scan_search_1.cpp

@@ -5,16 +5,13 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-
 #include <faiss/impl/pq4_fast_scan.h>
 
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/impl/simd_result_handlers.h>
 
-
 namespace faiss {
 
-
 using namespace simd_result_handlers;
 
 /***************************************************************
@@ -29,18 +26,17 @@ namespace {
  * writes results in a ResultHandler
  */
 
-template<int NQ, int BB, class ResultHandler>
+template <int NQ, int BB, class ResultHandler>
 void kernel_accumulate_block(
         int nsq,
-        const uint8_t *codes,
-        const uint8_t *LUT,
-        ResultHandler & res)
-{
+        const uint8_t* codes,
+        const uint8_t* LUT,
+        ResultHandler& res) {
     // distance accumulators
     simd16uint16 accu[NQ][BB][4];
 
-    for(int q = 0; q < NQ; q++) {
-        for(int b = 0; b < BB; b++) {
+    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();
@@ -48,9 +44,9 @@ void kernel_accumulate_block(
         }
     }
 
-    for(int sq = 0; sq < nsq; sq += 2) {
+    for (int sq = 0; sq < nsq; sq += 2) {
         simd32uint8 lut_cache[NQ];
-        for(int q = 0; q < NQ; q++) {
+        for (int q = 0; q < NQ; q++) {
             lut_cache[q] = simd32uint8(LUT);
             LUT += 32;
         }
@@ -62,7 +58,7 @@ void kernel_accumulate_block(
             simd32uint8 chi = simd32uint8(simd16uint16(c) >> 4) & mask;
             simd32uint8 clo = c & mask;
 
-            for(int q = 0; q < NQ; q++) {
+            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);
@@ -76,9 +72,8 @@ void kernel_accumulate_block(
         }
     }
 
-    for(int q = 0; q < NQ; q++) {
+    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]);
 
@@ -88,19 +83,15 @@ void kernel_accumulate_block(
             res.handle(q, b, dis0, dis1);
         }
     }
-
-
 }
 
-
-template<int NQ, int BB, class ResultHandler>
+template <int NQ, int BB, class ResultHandler>
 void accumulate_fixed_blocks(
         size_t nb,
         int nsq,
-        const uint8_t *codes,
-        const uint8_t *LUT,
-        ResultHandler & res)
-{
+        const uint8_t* codes,
+        const uint8_t* LUT,
+        ResultHandler& res) {
     constexpr int bbs = 32 * BB;
     for (int64_t j0 = 0; j0 < nb; j0 += bbs) {
         FixedStorageHandler<NQ, 2 * BB> res2;
@@ -111,29 +102,28 @@ void accumulate_fixed_blocks(
     }
 }
 
-
 } // anonymous namespace
 
-template<class ResultHandler>
+template <class ResultHandler>
 void pq4_accumulate_loop(
         int nq,
-        size_t nb, int bbs,
+        size_t nb,
+        int bbs,
         int nsq,
-        const uint8_t *codes,
-        const uint8_t *LUT,
-        ResultHandler & res)
-{
+        const uint8_t* codes,
+        const uint8_t* LUT,
+        ResultHandler& res) {
     FAISS_THROW_IF_NOT(is_aligned_pointer(codes));
     FAISS_THROW_IF_NOT(is_aligned_pointer(LUT));
     FAISS_THROW_IF_NOT(bbs % 32 == 0);
     FAISS_THROW_IF_NOT(nb % bbs == 0);
 
-#define DISPATCH(NQ, BB) \
-   case NQ * 1000 + BB: \
-    accumulate_fixed_blocks<NQ, BB>(nb, nsq, codes, LUT, res);  \
-    break
+#define DISPATCH(NQ, BB)                                           \
+    case NQ * 1000 + BB:                                           \
+        accumulate_fixed_blocks<NQ, BB>(nb, nsq, codes, LUT, res); \
+        break
 
-    switch(nq * 1000 + bbs / 32) {
+    switch (nq * 1000 + bbs / 32) {
         DISPATCH(1, 1);
         DISPATCH(1, 2);
         DISPATCH(1, 3);
@@ -143,26 +133,28 @@ void pq4_accumulate_loop(
         DISPATCH(2, 2);
         DISPATCH(3, 1);
         DISPATCH(4, 1);
-    default:
-        FAISS_THROW_FMT("nq=%d bbs=%d not instantiated", nq, bbs);
+        default:
+            FAISS_THROW_FMT("nq=%d bbs=%d not instantiated", nq, bbs);
     }
 #undef DISPATCH
-
 }
 
 // explicit template instantiations
 
-
-
-
-#define INSTANTIATE_ACCUMULATE(TH, C, with_id_map) \
-template void pq4_accumulate_loop<TH<C, with_id_map>> \
-    (int, size_t, int, int, const uint8_t *, const uint8_t *, TH<C, with_id_map> &);
-
-#define INSTANTIATE_3(C, with_id_map) \
-INSTANTIATE_ACCUMULATE(SingleResultHandler, C, with_id_map) \
-INSTANTIATE_ACCUMULATE(HeapHandler, C, with_id_map) \
-INSTANTIATE_ACCUMULATE(ReservoirHandler, C, with_id_map) \
+#define INSTANTIATE_ACCUMULATE(TH, C, with_id_map)         \
+    template void pq4_accumulate_loop<TH<C, with_id_map>>( \
+            int,                                           \
+            size_t,                                        \
+            int,                                           \
+            int,                                           \
+            const uint8_t*,                                \
+            const uint8_t*,                                \
+            TH<C, with_id_map>&);
+
+#define INSTANTIATE_3(C, with_id_map)                           \
+    INSTANTIATE_ACCUMULATE(SingleResultHandler, C, with_id_map) \
+    INSTANTIATE_ACCUMULATE(HeapHandler, C, with_id_map)         \
+    INSTANTIATE_ACCUMULATE(ReservoirHandler, C, with_id_map)
 
 using Csi = CMax<uint16_t, int>;
 INSTANTIATE_3(Csi, false);
@@ -174,7 +166,4 @@ INSTANTIATE_3(Csl, true);
 using CslMin = CMin<uint16_t, int64_t>;
 INSTANTIATE_3(CslMin, true);
 
-
-
 } // namespace faiss
-