usearch 2.21.4 → 2.25.1

package/cpp/test.cpp

@@ -12,14 +12,45 @@
  *      - 128-bit `uuid_t` keys and `enum slot64_t : std::uint64_t` make most sense for
  *        for database users, implementing portable, concurrent systems.
  */
+#include <cassert> // `assert`
+#include <cmath>   // `std::abs`
+#include <csignal> // `std::signal`, `SIGSEGV`, ...
+#include <cstdio>  // `std::fprintf`
+#include <cstdlib> // `std::_Exit`
+
 #include <algorithm>     // `std::shuffle`
-#include <cassert>       // `assert`
-#include <cmath>         // `std::abs`
 #include <random>        // `std::default_random_engine`
 #include <stdexcept>     // `std::terminate`
 #include <unordered_map> // `std::unordered_map`
 #include <vector>        // `std::vector`
 
+// Back-trace support. Prefer the C++23 `<stacktrace>` library when the
+// toolchain + stdlib expose it (`__cpp_lib_stacktrace`); otherwise fall back
+// to the OS-native facility so that unit-test crashes in CI log something
+// useful beyond a bare exit code.
+#if defined(__has_include)
+#if __has_include(<stacktrace>)
+#include <stacktrace>
+#endif
+#endif
+#if defined(__cpp_lib_stacktrace) && __cpp_lib_stacktrace >= 202011L
+#define USEARCH_HAS_STD_STACKTRACE 1
+#else
+#define USEARCH_HAS_STD_STACKTRACE 0
+#if defined(_WIN32)
+// `windows.h` must precede `dbghelp.h` — the latter uses `PSTR` and friends
+// that are only defined after `windows.h`. The blank line keeps clang-format
+// from re-sorting the two headers into a single alphabetized block.
+#include <windows.h>
+
+#include <dbghelp.h>
+#pragma comment(lib, "Dbghelp.lib")
+#else
+#include <execinfo.h>
+#include <unistd.h>
+#endif
+#endif
+
 #define SZ_USE_X86_AVX512 0            // Sanitizers hate AVX512
 #include <stringzilla/stringzilla.hpp> // Levenshtein distance implementation
 
@@ -54,7 +85,7 @@ void __expect_eq(value_at a, value_at b, char const* file, int line, char const*
 enum slot32_t : std::uint32_t {};
 template <> struct unum::usearch::hash_gt<slot32_t> : public unum::usearch::hash_gt<std::uint32_t> {};
 template <> struct unum::usearch::default_free_value_gt<slot32_t> {
-    static slot32_t value() noexcept { return static_cast<slot32_t>(std::numeric_limits<std::uint32_t>::max()); }
+    static slot32_t value() noexcept { return static_cast<slot32_t>((std::numeric_limits<std::uint32_t>::max)()); }
 };
 
 /*
@@ -166,8 +197,8 @@ void test_uint40() {
     }
 
     // Test min and max functions
-    expect_eq(uint40_t::min(), uint40_t(0u));
-    expect_eq(uint40_t::max(), uint40_t(max_uint40_k));
+    expect_eq((uint40_t::min)(), uint40_t(0u));
+    expect_eq((uint40_t::max)(), uint40_t(max_uint40_k));
 
     // Test copy and move semantics
     for (std::uint64_t input_u64 : test_numbers) {
@@ -664,7 +695,7 @@ void test_cosine(std::size_t collection_size, std::size_t dimensions) {
     vector_of_vectors_t vector_of_vectors(collection_size);
     for (auto& vector : vector_of_vectors) {
         vector.resize(dimensions);
-        std::generate(vector.begin(), vector.end(), [=] { return float(std::rand()) / float(INT_MAX); });
+        std::generate(vector.begin(), vector.end(), [=] { return float(std::rand()) / float(RAND_MAX); });
     }
 
     struct metric_t {
@@ -1127,20 +1158,20 @@ void test_filtered_search() {
     {
         auto predicate = [](index_dense_t::key_t key) { return key != 0; };
         auto results = index.filtered_search(vector_of_vectors[0].data(), 10, predicate);
-        expect_eq(10, results.size()); // ! Should not contain 0
+        expect_eq(10u, results.size()); // ! Should not contain 0
         for (std::size_t i = 0; i != results.size(); ++i)
             expect(0 != results[i].member.key);
     }
     {
         auto predicate = [](index_dense_t::key_t) { return false; };
         auto results = index.filtered_search(vector_of_vectors[0].data(), 10, predicate);
-        expect_eq(0, results.size()); // ! Should not contain 0
+        expect_eq(0u, results.size()); // ! Should not contain 0
     }
     {
         auto predicate = [](index_dense_t::key_t key) { return key == 10; };
         auto results = index.filtered_search(vector_of_vectors[0].data(), 10, predicate);
-        expect_eq(1, results.size()); // ! Should not contain 0
-        expect_eq(10, results[0].member.key);
+        expect_eq(1u, results.size()); // ! Should not contain 0
+        expect_eq(index_dense_t::key_t(10), results[0].member.key);
     }
 }
 
@@ -1179,13 +1210,73 @@ void test_isolate() {
     }
 }
 
+static void usearch_write_backtrace(int signal_number) {
+    std::fprintf(stderr, "\n[usearch] Fatal signal %d. Back-trace:\n", signal_number);
+#if USEARCH_HAS_STD_STACKTRACE
+    // C++23 `std::stacktrace` covers every platform the library can reach.
+    auto const current_trace = std::stacktrace::current();
+    std::size_t frame_index = 0;
+    for (auto const& frame : current_trace) {
+        std::fprintf(stderr, "  #%2zu %s\n", frame_index, std::to_string(frame).c_str());
+        ++frame_index;
+    }
+#elif defined(_WIN32)
+    // Fallback for MSVC stdlibs without `<stacktrace>`: DbgHelp API.
+    constexpr USHORT backtrace_depth_limit = 64;
+    void* backtrace_frames[backtrace_depth_limit];
+    USHORT backtrace_depth = CaptureStackBackTrace(0, backtrace_depth_limit, backtrace_frames, nullptr);
+    HANDLE current_process = GetCurrentProcess();
+    SymInitialize(current_process, nullptr, TRUE);
+
+    unsigned char symbol_info_buffer[sizeof(SYMBOL_INFO) + 256 * sizeof(char)];
+    SYMBOL_INFO* symbol_info = reinterpret_cast<SYMBOL_INFO*>(symbol_info_buffer);
+    symbol_info->MaxNameLen = 255;
+    symbol_info->SizeOfStruct = sizeof(SYMBOL_INFO);
+
+    for (USHORT frame_index = 0; frame_index < backtrace_depth; ++frame_index) {
+        if (SymFromAddr(current_process, reinterpret_cast<DWORD64>(backtrace_frames[frame_index]), 0, symbol_info))
+            std::fprintf(stderr, "  #%2u %s + 0x%llx\n", static_cast<unsigned>(frame_index), symbol_info->Name,
+                         static_cast<unsigned long long>(reinterpret_cast<DWORD64>(backtrace_frames[frame_index]) -
+                                                         symbol_info->Address));
+        else
+            std::fprintf(stderr, "  #%2u %p\n", static_cast<unsigned>(frame_index), backtrace_frames[frame_index]);
+    }
+#else
+    // Fallback for POSIX stdlibs without `<stacktrace>`: `<execinfo.h>`.
+    constexpr int backtrace_depth_limit = 64;
+    void* backtrace_frames[backtrace_depth_limit];
+    int const backtrace_depth = backtrace(backtrace_frames, backtrace_depth_limit);
+    backtrace_symbols_fd(backtrace_frames, backtrace_depth, STDERR_FILENO);
+#endif
+    std::fflush(stderr);
+}
+
+static void usearch_crash_handler(int signal_number) {
+    usearch_write_backtrace(signal_number);
+    // Restore the default disposition and re-raise so the shell / CI sees the true exit status.
+    std::signal(signal_number, SIG_DFL);
+    std::raise(signal_number);
+}
+
+static void install_crash_handlers() {
+    int const fatal_signals[] = {SIGSEGV, SIGABRT, SIGILL, SIGFPE};
+    for (int signal_number : fatal_signals)
+        std::signal(signal_number, &usearch_crash_handler);
+}
+
 int main(int, char**) {
-    test_uint40();
-    test_cosine<float, std::int64_t, uint40_t>(10, 10);
+    install_crash_handlers();
+
+    std::printf("Hardware acceleration compiled: %s\n", hardware_acceleration_compiled());
+    std::printf("Hardware acceleration available: %s\n", hardware_acceleration_available());
 
     // Non-default floating-point types may result in many compilation & rounding issues.
-    test_cosine<f16_t, std::int64_t, uint40_t>(10, 10);
+    test_uint40();
+    test_cosine<f32_t, std::int64_t, uint40_t>(10, 10);
     test_cosine<bf16_t, std::int64_t, uint40_t>(10, 10);
+    test_cosine<f16_t, std::int64_t, uint40_t>(10, 10);
+    test_cosine<e5m2_t, std::int64_t, uint40_t>(10, 10);
+    test_cosine<e4m3_t, std::int64_t, uint40_t>(10, 10);
 
     // Test plugins, like K-Means clustering.
     {
@@ -1195,7 +1286,7 @@ int main(int, char**) {
         std::vector<float> vectors(vectors_count * dimensions), centroids(centroids_count * dimensions);
         matrix_slice_gt<float const> vectors_slice(vectors.data(), dimensions, vectors_count);
         matrix_slice_gt<float> centroids_slice(centroids.data(), dimensions, centroids_count);
-        std::generate(vectors.begin(), vectors.end(), [] { return float(std::rand()) / float(INT_MAX); });
+        std::generate(vectors.begin(), vectors.end(), [] { return float(std::rand()) / float(RAND_MAX); });
         std::vector<std::size_t> assignments(vectors_count);
         std::vector<distance_punned_t> distances(vectors_count);
         auto clustering_result = clustering(vectors_slice, centroids_slice, {assignments.data(), assignments.size()},
@@ -1209,9 +1300,11 @@ int main(int, char**) {
     for (std::size_t dataset_count : {10, 100})
         for (std::size_t queries_count : {1, 10})
             for (std::size_t wanted_count : {1, 5}) {
-                test_exact_search<float>(dataset_count, queries_count, wanted_count);
-                test_exact_search<f16_t>(dataset_count, queries_count, wanted_count);
+                test_exact_search<f32_t>(dataset_count, queries_count, wanted_count);
                 test_exact_search<bf16_t>(dataset_count, queries_count, wanted_count);
+                test_exact_search<f16_t>(dataset_count, queries_count, wanted_count);
+                test_exact_search<e5m2_t>(dataset_count, queries_count, wanted_count);
+                test_exact_search<e4m3_t>(dataset_count, queries_count, wanted_count);
             }
 
     // Make sure the initializers and the algorithms can work with inadequately small values.
@@ -1235,12 +1328,16 @@ int main(int, char**) {
     std::printf("Testing common cases\n");
     for (std::size_t collection_size : {10, 500})
         for (std::size_t dimensions : {97, 256}) {
-            std::printf("- Indexing %zu vectors with cos: <float, std::int64_t, slot32_t> \n", collection_size);
-            test_cosine<float, std::int64_t, slot32_t>(collection_size, dimensions);
-            std::printf("- Indexing %zu vectors with cos: <float, std::int64_t, uint40_t> \n", collection_size);
-            test_cosine<float, std::int64_t, uint40_t>(collection_size, dimensions);
+            std::printf("- Indexing %zu vectors with cos: <f32_t, std::int64_t, slot32_t> \n", collection_size);
+            test_cosine<f32_t, std::int64_t, slot32_t>(collection_size, dimensions);
+            std::printf("- Indexing %zu vectors with cos: <f32_t, std::int64_t, uint40_t> \n", collection_size);
+            test_cosine<f32_t, std::int64_t, uint40_t>(collection_size, dimensions);
             std::printf("- Indexing %zu vectors with cos: <bf16, std::int64_t, uint40_t> \n", collection_size);
             test_cosine<bf16_t, std::int64_t, uint40_t>(collection_size, dimensions);
+            std::printf("- Indexing %zu vectors with cos: <e5m2, std::int64_t, uint40_t> \n", collection_size);
+            test_cosine<e5m2_t, std::int64_t, uint40_t>(collection_size, dimensions);
+            std::printf("- Indexing %zu vectors with cos: <e4m3, std::int64_t, uint40_t> \n", collection_size);
+            test_cosine<e4m3_t, std::int64_t, uint40_t>(collection_size, dimensions);
         }
 
     // Test with binary vectors