faiss 0.1.7 → 0.2.3

data/vendor/faiss/faiss/impl/FaissAssert.h

@@ -12,85 +12,100 @@
 
 #include <faiss/impl/FaissException.h>
 #include <faiss/impl/platform_macros.h>
-#include <cstdlib>
 #include <cstdio>
+#include <cstdlib>
 #include <string>
 
 ///
 /// Assertions
 ///
 
-#define FAISS_ASSERT(X)                                                 \
-  do {                                                                  \
-    if (! (X)) {                                                        \
-      fprintf(stderr, "Faiss assertion '%s' failed in %s "              \
-               "at %s:%d\n",                                            \
-               #X, __PRETTY_FUNCTION__, __FILE__, __LINE__);            \
-      abort();                                                          \
-    }                                                                   \
-  } while (false)
+#define FAISS_ASSERT(X)                                  \
+    do {                                                 \
+        if (!(X)) {                                      \
+            fprintf(stderr,                              \
+                    "Faiss assertion '%s' failed in %s " \
+                    "at %s:%d\n",                        \
+                    #X,                                  \
+                    __PRETTY_FUNCTION__,                 \
+                    __FILE__,                            \
+                    __LINE__);                           \
+            abort();                                     \
+        }                                                \
+    } while (false)
 
-#define FAISS_ASSERT_MSG(X, MSG)                                        \
-  do {                                                                  \
-    if (! (X)) {                                                        \
-      fprintf(stderr, "Faiss assertion '%s' failed in %s "              \
-               "at %s:%d; details: " MSG "\n",                          \
-               #X, __PRETTY_FUNCTION__, __FILE__, __LINE__);            \
-      abort();                                                          \
-    }                                                                   \
-  } while (false)
+#define FAISS_ASSERT_MSG(X, MSG)                         \
+    do {                                                 \
+        if (!(X)) {                                      \
+            fprintf(stderr,                              \
+                    "Faiss assertion '%s' failed in %s " \
+                    "at %s:%d; details: " MSG "\n",      \
+                    #X,                                  \
+                    __PRETTY_FUNCTION__,                 \
+                    __FILE__,                            \
+                    __LINE__);                           \
+            abort();                                     \
+        }                                                \
+    } while (false)
 
-#define FAISS_ASSERT_FMT(X, FMT, ...)                                   \
-  do {                                                                  \
-    if (! (X)) {                                                        \
-      fprintf(stderr, "Faiss assertion '%s' failed in %s "              \
-               "at %s:%d; details: " FMT "\n",                          \
-               #X, __PRETTY_FUNCTION__, __FILE__, __LINE__, __VA_ARGS__); \
-      abort();                                                          \
-    }                                                                   \
-  } while (false)
+#define FAISS_ASSERT_FMT(X, FMT, ...)                    \
+    do {                                                 \
+        if (!(X)) {                                      \
+            fprintf(stderr,                              \
+                    "Faiss assertion '%s' failed in %s " \
+                    "at %s:%d; details: " FMT "\n",      \
+                    #X,                                  \
+                    __PRETTY_FUNCTION__,                 \
+                    __FILE__,                            \
+                    __LINE__,                            \
+                    __VA_ARGS__);                        \
+            abort();                                     \
+        }                                                \
+    } while (false)
 
 ///
 /// Exceptions for returning user errors
 ///
 
-#define FAISS_THROW_MSG(MSG)                                            \
-  do {                                                                  \
-    throw faiss::FaissException(MSG, __PRETTY_FUNCTION__, __FILE__, __LINE__); \
-  } while (false)
+#define FAISS_THROW_MSG(MSG)                                   \
+    do {                                                       \
+        throw faiss::FaissException(                           \
+                MSG, __PRETTY_FUNCTION__, __FILE__, __LINE__); \
+    } while (false)
 
-#define FAISS_THROW_FMT(FMT, ...)                                       \
-  do {                                                                  \
-    std::string __s;                                                    \
-    int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__);                \
-    __s.resize(__size + 1);                                             \
-    snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__);                    \
-    throw faiss::FaissException(__s, __PRETTY_FUNCTION__, __FILE__, __LINE__); \
-  } while (false)
+#define FAISS_THROW_FMT(FMT, ...)                              \
+    do {                                                       \
+        std::string __s;                                       \
+        int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__);   \
+        __s.resize(__size + 1);                                \
+        snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__);       \
+        throw faiss::FaissException(                           \
+                __s, __PRETTY_FUNCTION__, __FILE__, __LINE__); \
+    } while (false)
 
 ///
 /// Exceptions thrown upon a conditional failure
 ///
 
-#define FAISS_THROW_IF_NOT(X)                           \
-  do {                                                  \
-    if (!(X)) {                                         \
-      FAISS_THROW_FMT("Error: '%s' failed", #X);        \
-    }                                                   \
-  } while (false)
+#define FAISS_THROW_IF_NOT(X)                          \
+    do {                                               \
+        if (!(X)) {                                    \
+            FAISS_THROW_FMT("Error: '%s' failed", #X); \
+        }                                              \
+    } while (false)
 
-#define FAISS_THROW_IF_NOT_MSG(X, MSG)                  \
-  do {                                                  \
-    if (!(X)) {                                         \
-      FAISS_THROW_FMT("Error: '%s' failed: " MSG, #X);  \
-    }                                                   \
-  } while (false)
+#define FAISS_THROW_IF_NOT_MSG(X, MSG)                       \
+    do {                                                     \
+        if (!(X)) {                                          \
+            FAISS_THROW_FMT("Error: '%s' failed: " MSG, #X); \
+        }                                                    \
+    } while (false)
 
-#define FAISS_THROW_IF_NOT_FMT(X, FMT, ...)                             \
-  do {                                                                  \
-    if (!(X)) {                                                         \
-      FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__);     \
-    }                                                                   \
-  } while (false)
+#define FAISS_THROW_IF_NOT_FMT(X, FMT, ...)                               \
+    do {                                                                  \
+        if (!(X)) {                                                       \
+            FAISS_THROW_FMT("Error: '%s' failed: " FMT, #X, __VA_ARGS__); \
+        }                                                                 \
+    } while (false)
 
 #endif

data/vendor/faiss/faiss/impl/FaissException.cpp

@@ -10,71 +10,81 @@
 #include <faiss/impl/FaissException.h>
 #include <sstream>
 
-#ifdef  __GNUG__
+#ifdef __GNUG__
 #include <cxxabi.h>
 #endif
 
 namespace faiss {
 
-FaissException::FaissException(const std::string& m)
-    : msg(m) {
-}
-
-FaissException::FaissException(const std::string& m,
-                               const char* funcName,
-                               const char* file,
-                               int line) {
-  int size = snprintf(nullptr, 0, "Error in %s at %s:%d: %s",
-                      funcName, file, line, m.c_str());
-  msg.resize(size + 1);
-  snprintf(&msg[0], msg.size(), "Error in %s at %s:%d: %s",
-           funcName, file, line, m.c_str());
+FaissException::FaissException(const std::string& m) : msg(m) {}
+
+FaissException::FaissException(
+        const std::string& m,
+        const char* funcName,
+        const char* file,
+        int line) {
+    int size = snprintf(
+            nullptr,
+            0,
+            "Error in %s at %s:%d: %s",
+            funcName,
+            file,
+            line,
+            m.c_str());
+    msg.resize(size + 1);
+    snprintf(
+            &msg[0],
+            msg.size(),
+            "Error in %s at %s:%d: %s",
+            funcName,
+            file,
+            line,
+            m.c_str());
 }
 
-const char*
-FaissException::what() const noexcept {
-  return msg.c_str();
+const char* FaissException::what() const noexcept {
+    return msg.c_str();
 }
 
 void handleExceptions(
-  std::vector<std::pair<int, std::exception_ptr>>& exceptions) {
-  if (exceptions.size() == 1) {
-    // throw the single received exception directly
-    std::rethrow_exception(exceptions.front().second);
-
-  } else if (exceptions.size() > 1) {
-    // multiple exceptions; aggregate them and return a single exception
-    std::stringstream ss;
-
-    for (auto& p : exceptions) {
-      try {
-        std::rethrow_exception(p.second);
-      } catch (std::exception& ex) {
-        if (ex.what()) {
-          // exception message available
-          ss << "Exception thrown from index " << p.first << ": "
-             << ex.what() << "\n";
-        } else {
-          // No message available
-          ss << "Unknown exception thrown from index " << p.first << "\n";
+        std::vector<std::pair<int, std::exception_ptr>>& exceptions) {
+    if (exceptions.size() == 1) {
+        // throw the single received exception directly
+        std::rethrow_exception(exceptions.front().second);
+
+    } else if (exceptions.size() > 1) {
+        // multiple exceptions; aggregate them and return a single exception
+        std::stringstream ss;
+
+        for (auto& p : exceptions) {
+            try {
+                std::rethrow_exception(p.second);
+            } catch (std::exception& ex) {
+                if (ex.what()) {
+                    // exception message available
+                    ss << "Exception thrown from index " << p.first << ": "
+                       << ex.what() << "\n";
+                } else {
+                    // No message available
+                    ss << "Unknown exception thrown from index " << p.first
+                       << "\n";
+                }
+            } catch (...) {
+                ss << "Unknown exception thrown from index " << p.first << "\n";
+            }
         }
-      } catch (...) {
-        ss << "Unknown exception thrown from index " << p.first << "\n";
-      }
-    }
 
-    throw FaissException(ss.str());
-  }
+        throw FaissException(ss.str());
+    }
 }
 
-
 // From
 // https://stackoverflow.com/questions/281818/unmangling-the-result-of-stdtype-infoname
 
 std::string demangle_cpp_symbol(const char* name) {
 #ifdef __GNUG__
     int status = -1;
-    const char * res = abi::__cxa_demangle(name, nullptr, nullptr, &status);
+    const char* res = abi::__cxa_demangle(name, nullptr, nullptr, &status);
     std::string sres;
     if (status == 0) {
         sres = res;
@@ -87,6 +97,4 @@ std::string demangle_cpp_symbol(const char* name) {
 #endif
 }
 
-
-
-} // namespace
+} // namespace faiss

data/vendor/faiss/faiss/impl/FaissException.h

@@ -12,56 +12,69 @@
 
 #include <exception>
 #include <string>
-#include <vector>
 #include <utility>
+#include <vector>
 
 namespace faiss {
 
 /// Base class for Faiss exceptions
 class FaissException : public std::exception {
- public:
-  explicit FaissException(const std::string& msg);
+   public:
+    explicit FaissException(const std::string& msg);
 
-  FaissException(const std::string& msg,
-                 const char* funcName,
-                 const char* file,
-                 int line);
+    FaissException(
+            const std::string& msg,
+            const char* funcName,
+            const char* file,
+            int line);
 
-  /// from std::exception
-  const char* what() const noexcept override;
+    /// from std::exception
+    const char* what() const noexcept override;
 
-  std::string msg;
+    std::string msg;
 };
 
 /// Handle multiple exceptions from worker threads, throwing an appropriate
 /// exception that aggregates the information
 /// The pair int is the thread that generated the exception
-void
-handleExceptions(std::vector<std::pair<int, std::exception_ptr>>& exceptions);
+void handleExceptions(
+        std::vector<std::pair<int, std::exception_ptr>>& exceptions);
 
 /** bare-bones unique_ptr
  * this one deletes with delete [] */
-template<class T>
+template <class T>
 struct ScopeDeleter {
-    const T * ptr;
-    explicit ScopeDeleter (const T* ptr = nullptr): ptr (ptr) {}
-    void release () {ptr = nullptr; }
-    void set (const T * ptr_in) { ptr = ptr_in; }
-    void swap (ScopeDeleter<T> &other) {std::swap (ptr, other.ptr); }
-    ~ScopeDeleter () {
-        delete [] ptr;
+    const T* ptr;
+    explicit ScopeDeleter(const T* ptr = nullptr) : ptr(ptr) {}
+    void release() {
+        ptr = nullptr;
+    }
+    void set(const T* ptr_in) {
+        ptr = ptr_in;
+    }
+    void swap(ScopeDeleter<T>& other) {
+        std::swap(ptr, other.ptr);
+    }
+    ~ScopeDeleter() {
+        delete[] ptr;
     }
 };
 
 /** same but deletes with the simple delete (least common case) */
-template<class T>
+template <class T>
 struct ScopeDeleter1 {
-    const T * ptr;
-    explicit ScopeDeleter1 (const T* ptr = nullptr): ptr (ptr) {}
-    void release () {ptr = nullptr; }
-    void set (const T * ptr_in) { ptr = ptr_in; }
-    void swap (ScopeDeleter1<T> &other) {std::swap (ptr, other.ptr); }
-    ~ScopeDeleter1 () {
+    const T* ptr;
+    explicit ScopeDeleter1(const T* ptr = nullptr) : ptr(ptr) {}
+    void release() {
+        ptr = nullptr;
+    }
+    void set(const T* ptr_in) {
+        ptr = ptr_in;
+    }
+    void swap(ScopeDeleter1<T>& other) {
+        std::swap(ptr, other.ptr);
+    }
+    ~ScopeDeleter1() {
         delete ptr;
     }
 };
@@ -69,7 +82,6 @@ struct ScopeDeleter1 {
 /// make typeids more readable
 std::string demangle_cpp_symbol(const char* name);
 
-
-}
+} // namespace faiss
 
 #endif