faiss 0.5.3 → 0.6.1

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

@@ -12,6 +12,7 @@
 
 #include <faiss/impl/FaissException.h>
 #include <faiss/impl/platform_macros.h>
+#include <cinttypes>
 #include <cstdio>
 #include <cstdlib>
 #include <string>
@@ -69,7 +70,7 @@
 
 #define FAISS_THROW_MSG(MSG)                                   \
     do {                                                       \
-        throw faiss::FaissException(                           \
+        throw ::faiss::FaissException(                         \
                 MSG, __PRETTY_FUNCTION__, __FILE__, __LINE__); \
     } while (false)
 
@@ -77,8 +78,11 @@
     do {                                                       \
         std::string __s;                                       \
         int __size = snprintf(nullptr, 0, FMT, __VA_ARGS__);   \
-        __s.resize(__size + 1);                                \
-        snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__);       \
+        if (__size > 0) {                                      \
+            __s.resize(static_cast<size_t>(__size) + 1);       \
+            snprintf(&__s[0], __s.size(), FMT, __VA_ARGS__);   \
+            __s.resize(static_cast<size_t>(__size));           \
+        }                                                      \
         throw faiss::FaissException(                           \
                 __s, __PRETTY_FUNCTION__, __FILE__, __LINE__); \
     } while (false)
@@ -110,4 +114,61 @@
         }                                                                 \
     } while (false)
 
+///
+/// Safe arithmetic
+///
+
+#include <limits>
+
+namespace faiss {
+
+/// Multiplication that throws on overflow instead of wrapping
+inline size_t mul_no_overflow(size_t a, size_t b, const char* context) {
+    if (a != 0 && b > (std::numeric_limits<size_t>::max)() / a) {
+        FAISS_THROW_FMT("integer overflow in %s: %zu * %zu", context, a, b);
+    }
+    return a * b;
+}
+
+/// Addition that throws on overflow instead of wrapping
+inline size_t add_no_overflow(size_t a, size_t b, const char* context) {
+    if (a > (std::numeric_limits<size_t>::max)() - b) {
+        FAISS_THROW_FMT("integer overflow in %s: %zu + %zu", context, a, b);
+    }
+    return a + b;
+}
+
+} // namespace faiss
+
+///
+/// Bounds checking
+///
+
+/// Check that val is in half-open range [lo, hi). Throws with the
+/// stringified expression, its value, and the bounds on failure.
+#define FAISS_CHECK_RANGE(val, lo, hi)                                         \
+    FAISS_THROW_IF_NOT_FMT(                                                    \
+            (int64_t)(val) >= (int64_t)(lo) && (int64_t)(val) < (int64_t)(hi), \
+            "%s (= %" PRId64 ") out of range [%" PRId64 ", %" PRId64 ")",      \
+            #val,                                                              \
+            (int64_t)(val),                                                    \
+            (int64_t)(lo),                                                     \
+            (int64_t)(hi))
+
+/// Debug-only variant of FAISS_CHECK_RANGE. Aborts in debug builds
+/// (when NDEBUG is not defined); compiled out in release builds to
+/// avoid overhead in hot paths.
+#ifndef NDEBUG
+#define FAISS_CHECK_RANGE_DEBUG(val, lo, hi)                                   \
+    FAISS_ASSERT_FMT(                                                          \
+            (int64_t)(val) >= (int64_t)(lo) && (int64_t)(val) < (int64_t)(hi), \
+            "%s (= %" PRId64 ") out of range [%" PRId64 ", %" PRId64 ")",      \
+            #val,                                                              \
+            (int64_t)(val),                                                    \
+            (int64_t)(lo),                                                     \
+            (int64_t)(hi))
+#else
+#define FAISS_CHECK_RANGE_DEBUG(val, lo, hi) ((void)0)
+#endif
+
 #endif

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

@@ -46,9 +46,8 @@ void handleExceptions(
 struct TransformedVectors {
     const float* x;
     bool own_x;
-    TransformedVectors(const float* x_orig, const float* x) : x(x) {
-        own_x = x_orig != x;
-    }
+    TransformedVectors(const float* x_orig, const float* x_in)
+            : x(x_in), own_x(x_orig != x_in) {}
 
     ~TransformedVectors() {
         if (own_x) {
@@ -60,6 +59,54 @@ struct TransformedVectors {
 /// make typeids more readable
 std::string demangle_cpp_symbol(const char* name);
 
+/// Capture the current exception into `ex` if no prior exception has been
+/// recorded.  Call from a catch block inside an OpenMP parallel region.
+/// Uses `#pragma omp critical` to serialize access to `ex`.
+///
+/// The optional `cleanup` callable runs inside the critical section
+/// alongside the exception capture, so that side-effects visible to
+/// other threads (e.g. setting an interrupt flag) are serialized with
+/// the exception_ptr write.
+///
+/// Usage:
+///   std::exception_ptr ex;
+///   bool interrupt = false;
+///   #pragma omp parallel
+///   {
+///       try { ... } catch (...) {
+///           omp_capture_exception(ex, [&] { interrupt = true; });
+///       }
+///   }
+///   omp_rethrow_if_exception(ex);
+inline void omp_capture_exception(std::exception_ptr& ex) {
+#pragma omp critical(faiss_omp_exception)
+    {
+        if (!ex) {
+            ex = std::current_exception();
+        }
+    }
+}
+
+/// Overload with cleanup that runs inside the critical section.
+template <typename Cleanup>
+inline void omp_capture_exception(std::exception_ptr& ex, Cleanup&& cleanup) {
+#pragma omp critical(faiss_omp_exception)
+    {
+        cleanup();
+        if (!ex) {
+            ex = std::current_exception();
+        }
+    }
+}
+
+/// Rethrow the captured exception, if any.  Call on the main thread
+/// after the parallel region completes.
+inline void omp_rethrow_if_exception(std::exception_ptr& ex) {
+    if (ex) {
+        std::rethrow_exception(ex);
+    }
+}
+
 } // namespace faiss
 
 #endif