faiss 0.2.0 → 0.2.1

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
-

data/vendor/faiss/faiss/impl/pq4_fast_scan_search_qbs.cpp

@@ -8,13 +8,11 @@
 #include <faiss/impl/pq4_fast_scan.h>
 
 #include <faiss/impl/FaissAssert.h>
-#include <faiss/utils/simdlib.h>
 #include <faiss/impl/simd_result_handlers.h>
-
+#include <faiss/utils/simdlib.h>
 
 namespace faiss {
 
-
 using namespace simd_result_handlers;
 
 /************************************************************
@@ -29,27 +27,25 @@ namespace {
  * writes results in a ResultHandler
  */
 
-template<int NQ, class ResultHandler>
+template <int NQ, 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) {
     // dummy alloc to keep the windows compiler happy
     constexpr int NQA = NQ > 0 ? NQ : 1;
     // distance accumulators
     simd16uint16 accu[NQA][4];
 
-    for(int q = 0; q < NQ; q++) {
-        for(int b = 0; b < 4; b++) {
+    for (int q = 0; q < NQ; q++) {
+        for (int b = 0; b < 4; b++) {
             accu[q][b].clear();
         }
     }
 
     // _mm_prefetch(codes + 768, 0);
-    for(int sq = 0; sq < nsq; sq += 2) {
-
+    for (int sq = 0; sq < nsq; sq += 2) {
         // prefetch
         simd32uint8 c(codes);
         codes += 32;
@@ -59,7 +55,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++) {
             // load LUTs for 2 quantizers
             simd32uint8 lut(LUT);
             LUT += 32;
@@ -75,26 +71,23 @@ void kernel_accumulate_block(
         }
     }
 
-    for(int q = 0; q < NQ; q++) {
+    for (int q = 0; q < NQ; q++) {
         accu[q][0] -= accu[q][1] << 8;
         simd16uint16 dis0 = combine2x2(accu[q][0], accu[q][1]);
         accu[q][2] -= accu[q][3] << 8;
         simd16uint16 dis1 = combine2x2(accu[q][2], accu[q][3]);
         res.handle(q, 0, dis0, dis1);
     }
-
 }
 
 // handle at most 4 blocks of queries
-template<int QBS, class ResultHandler>
+template <int QBS, class ResultHandler>
 void accumulate_q_4step(
         size_t ntotal2,
         int nsq,
-        const uint8_t *codes,
-        const uint8_t *LUT0,
-        ResultHandler & res)
-{
-
+        const uint8_t* codes,
+        const uint8_t* LUT0,
+        ResultHandler& res) {
     constexpr int Q1 = QBS & 15;
     constexpr int Q2 = (QBS >> 4) & 15;
     constexpr int Q3 = (QBS >> 8) & 15;
@@ -103,7 +96,7 @@ void accumulate_q_4step(
 
     for (int64_t j0 = 0; j0 < ntotal2; j0 += 32) {
         FixedStorageHandler<SQ, 2> res2;
-        const uint8_t *LUT = LUT0;
+        const uint8_t* LUT = LUT0;
         kernel_accumulate_block<Q1>(nsq, codes, LUT, res2);
         LUT += Q1 * nsq * 16;
         if (Q2 > 0) {
@@ -126,134 +119,118 @@ void accumulate_q_4step(
     }
 }
 
-
-
-
-template<int NQ, class ResultHandler>
+template <int NQ, class ResultHandler>
 void kernel_accumulate_block_loop(
         size_t ntotal2,
         int nsq,
-        const uint8_t *codes,
-        const uint8_t *LUT,
-        ResultHandler & res)
-{
-
+        const uint8_t* codes,
+        const uint8_t* LUT,
+        ResultHandler& res) {
     for (int64_t j0 = 0; j0 < ntotal2; j0 += 32) {
         res.set_block_origin(0, j0);
-        kernel_accumulate_block<NQ, ResultHandler>
-            (nsq, codes + j0 * nsq / 2, LUT, res);
+        kernel_accumulate_block<NQ, ResultHandler>(
+                nsq, codes + j0 * nsq / 2, LUT, res);
     }
-
 }
 
 // non-template version of accumulate kernel -- dispatches dynamically
-template<class ResultHandler>
+template <class ResultHandler>
 void accumulate(
         int nq,
         size_t ntotal2,
         int nsq,
-        const uint8_t *codes,
-        const uint8_t *LUT,
-        ResultHandler & res)
-{
-
+        const uint8_t* codes,
+        const uint8_t* LUT,
+        ResultHandler& res) {
     assert(nsq % 2 == 0);
     assert(is_aligned_pointer(codes));
     assert(is_aligned_pointer(LUT));
 
-#define DISPATCH(NQ)                                       \
-    case NQ:                                                    \
-        kernel_accumulate_block_loop<NQ, ResultHandler>    \
-                (ntotal2, nsq, codes, LUT, res);                \
-    return
+#define DISPATCH(NQ)                                     \
+    case NQ:                                             \
+        kernel_accumulate_block_loop<NQ, ResultHandler>( \
+                ntotal2, nsq, codes, LUT, res);          \
+        return
 
-    switch(nq) {
+    switch (nq) {
         DISPATCH(1);
         DISPATCH(2);
         DISPATCH(3);
         DISPATCH(4);
     }
-    FAISS_THROW_FMT("accumulate nq=%d not instanciated",
-                    nq);
+    FAISS_THROW_FMT("accumulate nq=%d not instanciated", nq);
 
 #undef DISPATCH
 }
 
+} // namespace
 
-} // anonumous namespace
-
-
-
-template<class ResultHandler>
+template <class ResultHandler>
 void pq4_accumulate_loop_qbs(
         int qbs,
         size_t ntotal2,
         int nsq,
-        const uint8_t *codes,
-        const uint8_t *LUT0,
-        ResultHandler & res)
-{
-
+        const uint8_t* codes,
+        const uint8_t* LUT0,
+        ResultHandler& res) {
     assert(nsq % 2 == 0);
     assert(is_aligned_pointer(codes));
     assert(is_aligned_pointer(LUT0));
 
     // try out optimized versions
-    switch(qbs) {
-#define DISPATCH(QBS) \
-        case QBS: accumulate_q_4step<QBS>  \
-            (ntotal2, nsq, codes, LUT0, res);  \
+    switch (qbs) {
+#define DISPATCH(QBS)                                            \
+    case QBS:                                                    \
+        accumulate_q_4step<QBS>(ntotal2, nsq, codes, LUT0, res); \
         return;
-            DISPATCH(0x3333);  // 12
-            DISPATCH(0x2333);  // 11
-            DISPATCH(0x2233);  // 10
-            DISPATCH(0x333);   // 9
-            DISPATCH(0x2223);  // 9
-            DISPATCH(0x233);   // 8
-            DISPATCH(0x1223);  // 8
-            DISPATCH(0x223);   // 7
-            DISPATCH(0x34);    // 7
-            DISPATCH(0x133);   // 7
-            DISPATCH(0x6);     // 6
-            DISPATCH(0x33);    // 6
-            DISPATCH(0x123);   // 6
-            DISPATCH(0x222);   // 6
-            DISPATCH(0x23);    // 5
-            DISPATCH(0x5);     // 5
-            DISPATCH(0x13);    // 4
-            DISPATCH(0x22);    // 4
-            DISPATCH(0x4);     // 4
-            DISPATCH(0x3);     // 3
-            DISPATCH(0x21);    // 3
-            DISPATCH(0x2);     // 2
-            DISPATCH(0x1);     // 1
+        DISPATCH(0x3333); // 12
+        DISPATCH(0x2333); // 11
+        DISPATCH(0x2233); // 10
+        DISPATCH(0x333);  // 9
+        DISPATCH(0x2223); // 9
+        DISPATCH(0x233);  // 8
+        DISPATCH(0x1223); // 8
+        DISPATCH(0x223);  // 7
+        DISPATCH(0x34);   // 7
+        DISPATCH(0x133);  // 7
+        DISPATCH(0x6);    // 6
+        DISPATCH(0x33);   // 6
+        DISPATCH(0x123);  // 6
+        DISPATCH(0x222);  // 6
+        DISPATCH(0x23);   // 5
+        DISPATCH(0x5);    // 5
+        DISPATCH(0x13);   // 4
+        DISPATCH(0x22);   // 4
+        DISPATCH(0x4);    // 4
+        DISPATCH(0x3);    // 3
+        DISPATCH(0x21);   // 3
+        DISPATCH(0x2);    // 2
+        DISPATCH(0x1);    // 1
 #undef DISPATCH
     }
 
     // default implementation where qbs is not known at compile time
 
     for (int64_t j0 = 0; j0 < ntotal2; j0 += 32) {
-        const uint8_t *LUT = LUT0;
+        const uint8_t* LUT = LUT0;
         int qi = qbs;
         int i0 = 0;
-        while(qi) {
+        while (qi) {
             int nq = qi & 15;
             qi >>= 4;
             res.set_block_origin(i0, j0);
-#define DISPATCH(NQ)                                     \
-    case NQ:                                             \
-        kernel_accumulate_block<NQ, ResultHandler> \
-           (nsq, codes, LUT, res);                       \
+#define DISPATCH(NQ)                                                      \
+    case NQ:                                                              \
+        kernel_accumulate_block<NQ, ResultHandler>(nsq, codes, LUT, res); \
         break
-            switch(nq) {
+            switch (nq) {
                 DISPATCH(1);
                 DISPATCH(2);
                 DISPATCH(3);
                 DISPATCH(4);
 #undef DISPATCH
-            default:
-                FAISS_THROW_FMT("accumulate nq=%d not instanciated",
-                                nq);
+                default:
+                    FAISS_THROW_FMT("accumulate nq=%d not instanciated", nq);
             }
             i0 += nq;
             LUT += nq * nsq * 16;
@@ -262,14 +239,11 @@ void pq4_accumulate_loop_qbs(
     }
 }
 
-
-
 // explicit template instantiations
 
-
-#define INSTANTIATE_ACCUMULATE_Q(RH) \
-template void pq4_accumulate_loop_qbs<RH> \
-    (int, size_t, int, const uint8_t *, const uint8_t *, RH &);
+#define INSTANTIATE_ACCUMULATE_Q(RH)           \
+    template void pq4_accumulate_loop_qbs<RH>( \
+            int, size_t, int, const uint8_t*, const uint8_t*, RH&);
 
 using Csi = CMax<uint16_t, int>;
 INSTANTIATE_ACCUMULATE_Q(SingleResultHandler<Csi>)
@@ -295,7 +269,6 @@ INSTANTIATE_ACCUMULATE_Q(HHCsl2)
 INSTANTIATE_ACCUMULATE_Q(RHCsl2)
 INSTANTIATE_ACCUMULATE_Q(SHCsl2)
 
-
 /***************************************************************
  * Packing functions
  ***************************************************************/
@@ -303,7 +276,7 @@ INSTANTIATE_ACCUMULATE_Q(SHCsl2)
 int pq4_qbs_to_nq(int qbs) {
     int i0 = 0;
     int qi = qbs;
-    while(qi) {
+    while (qi) {
         int nq = qi & 15;
         qi >>= 4;
         i0 += nq;
@@ -311,29 +284,22 @@ int pq4_qbs_to_nq(int qbs) {
     return i0;
 }
 
-
-
 void accumulate_to_mem(
         int nq,
         size_t ntotal2,
         int nsq,
-        const uint8_t *codes,
-        const uint8_t *LUT,
-        uint16_t* accu)
-{
+        const uint8_t* codes,
+        const uint8_t* LUT,
+        uint16_t* accu) {
     FAISS_THROW_IF_NOT(ntotal2 % 32 == 0);
     StoreResultHandler handler(accu, ntotal2);
     accumulate(nq, ntotal2, nsq, codes, LUT, handler);
 }
 
-
 int pq4_preferred_qbs(int n) {
     // from timmings in P141901742, P141902828
     static int map[12] = {
-        0, 1, 2, 3, 0x13,
-        0x23, 0x33, 0x223, 0x233, 0x333,
-        0x2233, 0x2333
-    };
+            0, 1, 2, 3, 0x13, 0x23, 0x33, 0x223, 0x233, 0x333, 0x2233, 0x2333};
     if (n <= 11) {
         return map[n];
     } else if (n <= 24) {
@@ -348,7 +314,4 @@ int pq4_preferred_qbs(int n) {
     }
 }
 
-
-
 } // namespace faiss
-