faiss 0.3.0 → 0.3.2

data/vendor/faiss/faiss/impl/io.cpp

@@ -20,11 +20,11 @@ namespace faiss {
  * IO functions
  ***********************************************************************/
 
-int IOReader::fileno() {
+int IOReader::filedescriptor() {
     FAISS_THROW_MSG("IOReader does not support memory mapping");
 }
 
-int IOWriter::fileno() {
+int IOWriter::filedescriptor() {
     FAISS_THROW_MSG("IOWriter does not support memory mapping");
 }
 
@@ -85,8 +85,12 @@ size_t FileIOReader::operator()(void* ptr, size_t size, size_t nitems) {
     return fread(ptr, size, nitems, f);
 }
 
-int FileIOReader::fileno() {
+int FileIOReader::filedescriptor() {
+#ifdef _AIX
+    return fileno(f);
+#else
     return ::fileno(f);
+#endif
 }
 
 FileIOWriter::FileIOWriter(FILE* wf) : f(wf) {}
@@ -116,8 +120,12 @@ size_t FileIOWriter::operator()(const void* ptr, size_t size, size_t nitems) {
     return fwrite(ptr, size, nitems, f);
 }
 
-int FileIOWriter::fileno() {
+int FileIOWriter::filedescriptor() {
+#ifdef _AIX
+    return fileno(f);
+#else
     return ::fileno(f);
+#endif
 }
 
 /***********************************************************************
@@ -196,13 +204,13 @@ size_t BufferedIOWriter::operator()(
     while (size > 0) {
         assert(b0 == bsz);
         // now we need to flush to add more bytes
-        size_t ofs = 0;
+        size_t ofs_2 = 0;
         do {
-            assert(ofs < 10000000);
-            size_t written = (*writer)(buffer.data() + ofs, 1, bsz - ofs);
+            assert(ofs_2 < 10000000);
+            size_t written = (*writer)(buffer.data() + ofs_2, 1, bsz - ofs_2);
             FAISS_THROW_IF_NOT(written > 0);
-            ofs += written;
-        } while (ofs != bsz);
+            ofs_2 += written;
+        } while (ofs_2 != bsz);
 
         // copy src to buffer
         size_t nb1 = std::min(bsz, size);
@@ -217,12 +225,12 @@ size_t BufferedIOWriter::operator()(
 }
 
 BufferedIOWriter::~BufferedIOWriter() {
-    size_t ofs = 0;
-    while (ofs != b0) {
-        // printf("Destructor write %zd \n", b0 - ofs);
-        size_t written = (*writer)(buffer.data() + ofs, 1, b0 - ofs);
+    size_t ofs_2 = 0;
+    while (ofs_2 != b0) {
+        // printf("Destructor write %zd \n", b0 - ofs_2);
+        size_t written = (*writer)(buffer.data() + ofs_2, 1, b0 - ofs_2);
         FAISS_THROW_IF_NOT(written > 0);
-        ofs += written;
+        ofs_2 += written;
     }
 }
 
@@ -259,7 +267,7 @@ std::string fourcc_inv_printable(uint32_t x) {
             str += c;
         } else {
             char buf[10];
-            sprintf(buf, "\\x%02x", c);
+            snprintf(buf, sizeof(buf), "\\x%02x", c);
             str += buf;
         }
     }

data/vendor/faiss/faiss/impl/io.h

@@ -32,7 +32,7 @@ struct IOReader {
     virtual size_t operator()(void* ptr, size_t size, size_t nitems) = 0;
 
     // return a file number that can be memory-mapped
-    virtual int fileno();
+    virtual int filedescriptor();
 
     virtual ~IOReader() {}
 };
@@ -45,7 +45,7 @@ struct IOWriter {
     virtual size_t operator()(const void* ptr, size_t size, size_t nitems) = 0;
 
     // return a file number that can be memory-mapped
-    virtual int fileno();
+    virtual int filedescriptor();
 
     virtual ~IOWriter() noexcept(false) {}
 };
@@ -73,7 +73,7 @@ struct FileIOReader : IOReader {
 
     size_t operator()(void* ptr, size_t size, size_t nitems) override;
 
-    int fileno() override;
+    int filedescriptor() override;
 };
 
 struct FileIOWriter : IOWriter {
@@ -88,7 +88,7 @@ struct FileIOWriter : IOWriter {
 
     size_t operator()(const void* ptr, size_t size, size_t nitems) override;
 
-    int fileno() override;
+    int filedescriptor() override;
 };
 
 /*******************************************************

data/vendor/faiss/faiss/impl/io_macros.h

@@ -29,6 +29,12 @@
 
 #define READ1(x) READANDCHECK(&(x), 1)
 
+#define READ1_DUMMY(x_type) \
+    {                       \
+        x_type x = {};      \
+        READ1(x);           \
+    }
+
 // will fail if we write 256G of data at once...
 #define READVECTOR(vec)                                              \
     {                                                                \

data/vendor/faiss/faiss/impl/lattice_Zn.cpp

@@ -455,7 +455,7 @@ void ZnSphereCodec::decode(uint64_t code, float* c) const {
     int nnz = 0;
     for (int i = 0; i < dim; i++) {
         if (c[i] != 0) {
-            if (signs & (1UL << nnz)) {
+            if (signs & (uint64_t(1) << nnz)) {
                 c[i] = -c[i];
             }
             nnz++;

data/vendor/faiss/faiss/impl/platform_macros.h

@@ -40,11 +40,13 @@
 
 #include <intrin.h>
 
+#ifndef __clang__
 inline int __builtin_ctzll(uint64_t x) {
     unsigned long ret;
     _BitScanForward64(&ret, x);
     return (int)ret;
 }
+#endif
 
 // cudatoolkit provides __builtin_ctz for NVCC >= 11.0
 #if !defined(__CUDACC__) || __CUDACC_VER_MAJOR__ < 11
@@ -55,13 +57,20 @@ inline int __builtin_ctz(unsigned long x) {
 }
 #endif
 
+#ifndef __clang__
 inline int __builtin_clzll(uint64_t x) {
     return (int)__lzcnt64(x);
 }
+#endif
 
 #define __builtin_popcount __popcnt
 #define __builtin_popcountl __popcnt64
 
+#ifndef __clang__
+#define __m128i_u __m128i
+#define __m256i_u __m256i
+#endif
+
 // MSVC does not define __SSEx__, and _M_IX86_FP is only defined on 32-bit
 // processors cf.
 // https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros
@@ -82,6 +91,8 @@ inline int __builtin_clzll(uint64_t x) {
 #define __F16C__ 1
 #endif
 
+#define FAISS_ALWAYS_INLINE __forceinline
+
 #else
 /*******************************************************
  * Linux and OSX
@@ -92,9 +103,15 @@ inline int __builtin_clzll(uint64_t x) {
 
 // aligned should be *in front* of the declaration, for compatibility with
 // windows
+#ifdef SWIG
+#define ALIGNED(x)
+#else
 #define ALIGNED(x) __attribute__((aligned(x)))
+#endif
 
-#endif // _MSC_VER
+#define FAISS_ALWAYS_INLINE __attribute__((always_inline)) inline
+
+#endif
 
 #if defined(__GNUC__) || defined(__clang__)
 #define FAISS_DEPRECATED(msg) __attribute__((deprecated(msg)))
@@ -110,6 +127,13 @@ inline int __builtin_clzll(uint64_t x) {
     __pragma(float_control(precise, off, push))
 #define FAISS_PRAGMA_IMPRECISE_FUNCTION_END __pragma(float_control(pop))
 #elif defined(__clang__)
+#if defined(__PPC__)
+#define FAISS_PRAGMA_IMPRECISE_LOOP \
+    _Pragma("clang loop vectorize_width(4) interleave_count(8)")
+#define FAISS_PRAGMA_IMPRECISE_FUNCTION_BEGIN \
+    _Pragma("float_control(precise, off, push)")
+#define FAISS_PRAGMA_IMPRECISE_FUNCTION_END _Pragma("float_control(pop)")
+#else
 #define FAISS_PRAGMA_IMPRECISE_LOOP \
     _Pragma("clang loop vectorize(enable) interleave(enable)")
 
@@ -127,6 +151,7 @@ inline int __builtin_clzll(uint64_t x) {
 #define FAISS_PRAGMA_IMPRECISE_FUNCTION_BEGIN
 #define FAISS_PRAGMA_IMPRECISE_FUNCTION_END
 #endif
+#endif
 #elif defined(__GNUC__)
 // Unfortunately, GCC does not provide a pragma for detecting it.
 // So, we have to stick to GNUC, which is defined by MANY compilers.
@@ -148,3 +173,17 @@ inline int __builtin_clzll(uint64_t x) {
 #endif
 
 // clang-format on
+
+/*******************************************************
+ * BIGENDIAN specific macros
+ *******************************************************/
+#if !defined(_MSC_VER) && \
+        (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__))
+#define FAISS_BIG_ENDIAN
+#endif
+
+#define Swap2Bytes(val) ((((val) >> 8) & 0x00FF) | (((val) << 8) & 0xFF00))
+
+#define Swap4Bytes(val)                                           \
+    ((((val) >> 24) & 0x000000FF) | (((val) >> 8) & 0x0000FF00) | \
+     (((val) << 8) & 0x00FF0000) | (((val) << 24) & 0xFF000000))

data/vendor/faiss/faiss/impl/pq4_fast_scan.cpp

@@ -6,6 +6,7 @@
  */
 
 #include <faiss/impl/FaissAssert.h>
+#include <faiss/impl/platform_macros.h>
 #include <faiss/impl/pq4_fast_scan.h>
 #include <faiss/impl/simd_result_handlers.h>
 
@@ -54,9 +55,17 @@ void pq4_pack_codes(
     FAISS_THROW_IF_NOT(nb % bbs == 0);
     FAISS_THROW_IF_NOT(nsq % 2 == 0);
 
+    if (nb == 0) {
+        return;
+    }
     memset(blocks, 0, nb * nsq / 2);
+#ifdef FAISS_BIG_ENDIAN
+    const uint8_t perm0[16] = {
+            8, 0, 9, 1, 10, 2, 11, 3, 12, 4, 13, 5, 14, 6, 15, 7};
+#else
     const uint8_t perm0[16] = {
             0, 8, 1, 9, 2, 10, 3, 11, 4, 12, 5, 13, 6, 14, 7, 15};
+#endif
 
     uint8_t* codes2 = blocks;
     for (size_t i0 = 0; i0 < nb; i0 += bbs) {
@@ -90,8 +99,13 @@ void pq4_pack_codes_range(
         size_t bbs,
         size_t nsq,
         uint8_t* blocks) {
+#ifdef FAISS_BIG_ENDIAN
+    const uint8_t perm0[16] = {
+            8, 0, 9, 1, 10, 2, 11, 3, 12, 4, 13, 5, 14, 6, 15, 7};
+#else
     const uint8_t perm0[16] = {
             0, 8, 1, 9, 2, 10, 3, 11, 4, 12, 5, 13, 6, 14, 7, 15};
+#endif
 
     // range of affected blocks
     size_t block0 = i0 / bbs;

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

@@ -24,6 +24,9 @@
 
 namespace faiss {
 
+struct NormTableScaler;
+struct SIMDResultHandler;
+
 /** Pack codes for consumption by the SIMD kernels.
  *  The unused bytes are set to 0.
  *
@@ -117,7 +120,6 @@ void pq4_pack_LUT(int nq, int nsq, const uint8_t* src, uint8_t* dest);
  * @param LUT     packed look-up table
  * @param scaler  scaler to scale the encoded norm
  */
-template <class ResultHandler, class Scaler>
 void pq4_accumulate_loop(
         int nq,
         size_t nb,
@@ -125,8 +127,8 @@ void pq4_accumulate_loop(
         int nsq,
         const uint8_t* codes,
         const uint8_t* LUT,
-        ResultHandler& res,
-        const Scaler& scaler);
+        SIMDResultHandler& res,
+        const NormTableScaler* scaler);
 
 /* qbs versions, supported only for bbs=32.
  *
@@ -178,14 +180,13 @@ int pq4_pack_LUT_qbs_q_map(
  * @param res     call-back for the resutls
  * @param scaler  scaler to scale the encoded norm
  */
-template <class ResultHandler, class Scaler>
 void pq4_accumulate_loop_qbs(
         int qbs,
         size_t nb,
         int nsq,
         const uint8_t* codes,
         const uint8_t* LUT,
-        ResultHandler& res,
-        const Scaler& scaler);
+        SIMDResultHandler& res,
+        const NormTableScaler* scaler = nullptr);
 
 } // namespace faiss

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

@@ -125,7 +125,7 @@ void accumulate_fixed_blocks(
         ResultHandler& res,
         const Scaler& scaler) {
     constexpr int bbs = 32 * BB;
-    for (int64_t j0 = 0; j0 < nb; j0 += bbs) {
+    for (size_t j0 = 0; j0 < nb; j0 += bbs) {
         FixedStorageHandler<NQ, 2 * BB> res2;
         kernel_accumulate_block<NQ, BB>(nsq, codes, LUT, res2, scaler);
         res.set_block_origin(0, j0);
@@ -134,10 +134,8 @@ void accumulate_fixed_blocks(
     }
 }
 
-} // anonymous namespace
-
 template <class ResultHandler, class Scaler>
-void pq4_accumulate_loop(
+void pq4_accumulate_loop_fixed_scaler(
         int nq,
         size_t nb,
         int bbs,
@@ -172,39 +170,55 @@ void pq4_accumulate_loop(
 #undef DISPATCH
 }
 
-// explicit template instantiations
-
-#define INSTANTIATE_ACCUMULATE(TH, C, with_id_map, S)         \
-    template void pq4_accumulate_loop<TH<C, with_id_map>, S>( \
-            int,                                              \
-            size_t,                                           \
-            int,                                              \
-            int,                                              \
-            const uint8_t*,                                   \
-            const uint8_t*,                                   \
-            TH<C, with_id_map>&,                              \
-            const S&);
-
-using DS = DummyScaler;
-using NS = NormTableScaler;
-
-#define INSTANTIATE_3(C, with_id_map)                               \
-    INSTANTIATE_ACCUMULATE(SingleResultHandler, C, with_id_map, DS) \
-    INSTANTIATE_ACCUMULATE(HeapHandler, C, with_id_map, DS)         \
-    INSTANTIATE_ACCUMULATE(ReservoirHandler, C, with_id_map, DS)    \
-                                                                    \
-    INSTANTIATE_ACCUMULATE(SingleResultHandler, C, with_id_map, NS) \
-    INSTANTIATE_ACCUMULATE(HeapHandler, C, with_id_map, NS)         \
-    INSTANTIATE_ACCUMULATE(ReservoirHandler, C, with_id_map, NS)
-
-using Csi = CMax<uint16_t, int>;
-INSTANTIATE_3(Csi, false);
-using CsiMin = CMin<uint16_t, int>;
-INSTANTIATE_3(CsiMin, false);
-
-using Csl = CMax<uint16_t, int64_t>;
-INSTANTIATE_3(Csl, true);
-using CslMin = CMin<uint16_t, int64_t>;
-INSTANTIATE_3(CslMin, true);
+template <class ResultHandler>
+void pq4_accumulate_loop_fixed_handler(
+        int nq,
+        size_t nb,
+        int bbs,
+        int nsq,
+        const uint8_t* codes,
+        const uint8_t* LUT,
+        ResultHandler& res,
+        const NormTableScaler* scaler) {
+    if (scaler) {
+        pq4_accumulate_loop_fixed_scaler(
+                nq, nb, bbs, nsq, codes, LUT, res, *scaler);
+    } else {
+        DummyScaler dscaler;
+        pq4_accumulate_loop_fixed_scaler(
+                nq, nb, bbs, nsq, codes, LUT, res, dscaler);
+    }
+}
+
+struct Run_pq4_accumulate_loop {
+    template <class ResultHandler>
+    void f(ResultHandler& res,
+           int nq,
+           size_t nb,
+           int bbs,
+           int nsq,
+           const uint8_t* codes,
+           const uint8_t* LUT,
+           const NormTableScaler* scaler) {
+        pq4_accumulate_loop_fixed_handler(
+                nq, nb, bbs, nsq, codes, LUT, res, scaler);
+    }
+};
+
+} // anonymous namespace
+
+void pq4_accumulate_loop(
+        int nq,
+        size_t nb,
+        int bbs,
+        int nsq,
+        const uint8_t* codes,
+        const uint8_t* LUT,
+        SIMDResultHandler& res,
+        const NormTableScaler* scaler) {
+    Run_pq4_accumulate_loop consumer;
+    dispatch_SIMDResultHandler(
+            res, consumer, nq, nb, bbs, nsq, codes, LUT, scaler);
+}
 
 } // namespace faiss