usearch 2.21.4 → 2.25.1

package/c/test.c

@@ -1,10 +1,91 @@
+/**
+ *  @file       test.c
+ *  @author     Ash Vardanian
+ *  @brief      Unit tests for the pure-C ABI of USearch (`usearch.h`).
+ *  @date       June 25, 2023
+ *
+ *  Exercises the lifecycle of `usearch_index_t` through the public C surface:
+ *  index creation with every supported metric and scalar kind, `add` / `get` /
+ *  `find` / `remove`, on-disk `save` / `load` / `view`, and error propagation
+ *  via `usearch_error_t`. The harness is intentionally dependency-free so it
+ *  can run in the same matrix as the C++ tests and on cross-compilation
+ *  targets where only the C runtime is available.
+ *
+ *  On startup we install a signal handler (see `install_crash_handlers`) that
+ *  prints a native back-trace before re-raising, so CI logs pinpoint the
+ *  faulting frame instead of stopping at a bare exit code.
+ */
 #include <errno.h>
-#include <stdio.h> // `remove`
+#include <signal.h> // `signal`, `raise`, `SIGSEGV`
+#include <stdio.h>  // `remove`
 #include <stdlib.h>
+#include <string.h> // `memset`
 #include <sys/stat.h>
 
+/* Back-trace support for the C test harness. The `signal` API is standard C;
+ * the back-trace itself is taken via an OS-specific facility since C has no
+ * standard stack-introspection API. On Windows, `dbghelp.h` references types
+ * (e.g. `PSTR`) that are only defined after `windows.h`, so the two headers
+ * are separated by a blank line to keep clang-format from re-sorting them
+ * into a single alphabetized block. */
+#if defined(_WIN32)
+#include <windows.h>
+
+#include <dbghelp.h>
+#pragma comment(lib, "Dbghelp.lib")
+#elif defined(__unix__) || defined(__APPLE__)
+#include <execinfo.h>
+#include <unistd.h>
+#endif
+
 #include "usearch.h"
 
+static void usearch_write_backtrace(int signal_number) {
+    fprintf(stderr, "\n[usearch] Fatal signal %d. Back-trace:\n", signal_number);
+#if defined(_WIN32)
+    enum { backtrace_depth_limit = 64 };
+    void* backtrace_frames[backtrace_depth_limit];
+    USHORT backtrace_depth = CaptureStackBackTrace(0, backtrace_depth_limit, backtrace_frames, NULL);
+    HANDLE current_process = GetCurrentProcess();
+    SymInitialize(current_process, NULL, TRUE);
+
+    unsigned char symbol_info_buffer[sizeof(SYMBOL_INFO) + 256 * sizeof(char)];
+    SYMBOL_INFO* symbol_info = (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, (DWORD64)backtrace_frames[frame_index], 0, symbol_info))
+            fprintf(stderr, "  #%2u %s + 0x%llx\n", (unsigned)frame_index, symbol_info->Name,
+                    (unsigned long long)((DWORD64)backtrace_frames[frame_index] - symbol_info->Address));
+        else
+            fprintf(stderr, "  #%2u %p\n", (unsigned)frame_index, backtrace_frames[frame_index]);
+    }
+#elif defined(__unix__) || defined(__APPLE__)
+    enum { backtrace_depth_limit = 64 };
+    void* backtrace_frames[backtrace_depth_limit];
+    int backtrace_depth = backtrace(backtrace_frames, backtrace_depth_limit);
+    backtrace_symbols_fd(backtrace_frames, backtrace_depth, STDERR_FILENO);
+#else
+    (void)signal_number;
+    fprintf(stderr, "  <back-trace unavailable on this platform>\n");
+#endif
+    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. */
+    signal(signal_number, SIG_DFL);
+    raise(signal_number);
+}
+
+static void install_crash_handlers(void) {
+    int const fatal_signals[] = {SIGSEGV, SIGABRT, SIGILL, SIGFPE};
+    for (unsigned signal_index = 0; signal_index < sizeof(fatal_signals) / sizeof(fatal_signals[0]); ++signal_index)
+        signal(fatal_signals[signal_index], &usearch_crash_handler);
+}
+
 void expect(bool must_be_true, char const* message) {
     if (must_be_true)
         return;
@@ -367,7 +448,48 @@ void test_view(size_t const collection_size, size_t const dimensions) {
     printf("Test: View - PASSED\n");
 }
 
+void test_mini_float_quantizations(size_t const collection_size, size_t const dimensions) {
+    printf("Test: Mini-float quantizations... %zu vectors, %zu dimensions\n", collection_size, dimensions);
+    usearch_scalar_kind_t kinds[] = {
+        usearch_scalar_e5m2_k,
+        usearch_scalar_e4m3_k,
+        usearch_scalar_e3m2_k,
+        usearch_scalar_e2m3_k,
+    };
+    float* data = create_vectors(collection_size, dimensions);
+    usearch_key_t* keys = (usearch_key_t*)malloc(collection_size * sizeof(usearch_key_t));
+    float* distances = (float*)malloc(collection_size * sizeof(float));
+    expect(keys && distances, "Failed to allocate memory");
+
+    for (size_t k = 0; k < sizeof(kinds) / sizeof(kinds[0]); ++k) {
+        usearch_error_t error = NULL;
+        usearch_init_options_t opts = create_options(dimensions);
+        opts.quantization = kinds[k];
+        usearch_index_t index = usearch_init(&opts, &error);
+        expect(!error, error);
+        usearch_reserve(index, collection_size, &error);
+        expect(!error, error);
+        for (size_t i = 0; i < collection_size; ++i) {
+            usearch_add(index, (usearch_key_t)i, data + i * dimensions, usearch_scalar_f32_k, &error);
+            expect(!error, error);
+        }
+        expect_eq(usearch_size(index, &error), collection_size, error);
+        for (size_t i = 0; i < collection_size; ++i) {
+            size_t found =
+                usearch_search(index, data + i * dimensions, usearch_scalar_f32_k, 1, keys, distances, &error);
+            expect(!error, error);
+            expect(found >= 1, "Vector not found");
+        }
+        usearch_free(index, &error);
+    }
+    free(data);
+    free(keys);
+    free(distances);
+    printf("Test: Mini-float quantizations - PASSED\n");
+}
+
 int main(int argc, char const* argv[]) {
+    install_crash_handlers();
     printf("Running tests...\n");
     printf("USearch version: %s\n", usearch_version());
 
@@ -382,6 +504,7 @@ int main(int argc, char const* argv[]) {
             test_remove_vector(collection_sizes[index], dimensions[jdx]);
             test_save_load(collection_sizes[index], dimensions[jdx]);
             test_view(collection_sizes[index], dimensions[jdx]);
+            test_mini_float_quantizations(collection_sizes[index], dimensions[jdx]);
         }
     }
 

package/c/usearch.h

@@ -53,12 +53,17 @@ USEARCH_EXPORT typedef enum usearch_metric_kind_t {
 
 USEARCH_EXPORT typedef enum usearch_scalar_kind_t {
     usearch_scalar_unknown_k = 0,
-    usearch_scalar_f32_k = 1,
     usearch_scalar_f64_k = 2,
+    usearch_scalar_f32_k = 1,
+    usearch_scalar_bf16_k = 6,
     usearch_scalar_f16_k = 3,
+    usearch_scalar_e5m2_k = 7,
+    usearch_scalar_e4m3_k = 8,
+    usearch_scalar_e3m2_k = 11,
+    usearch_scalar_e2m3_k = 10,
     usearch_scalar_i8_k = 4,
+    usearch_scalar_u8_k = 9,
     usearch_scalar_b1_k = 5,
-    usearch_scalar_bf16_k = 6,
 } usearch_scalar_kind_t;
 
 USEARCH_EXPORT typedef struct usearch_init_options_t {
@@ -109,12 +114,26 @@ USEARCH_EXPORT typedef struct usearch_init_options_t {
     bool multi;
 } usearch_init_options_t;
 
+USEARCH_EXPORT typedef int (*usearch_filtered_search_callback_t)(usearch_key_t, void*);
+
 /**
  *  @brief Retrieves the version of the library.
  *  @return The version of the library.
  */
 USEARCH_EXPORT char const* usearch_version(void);
 
+/**
+ *  @brief Retrieves a list of hardware capabilities in this precompiled binary.
+ *  @return A comma-separated string with names of CPU features.
+ */
+USEARCH_EXPORT char const* usearch_hardware_acceleration_compiled(void);
+
+/**
+ *  @brief Retrieves a list of hardware capabilities supported by the current machine.
+ *  @return A comma-separated string with names of CPU features.
+ */
+USEARCH_EXPORT char const* usearch_hardware_acceleration_available(void);
+
 /**
  *  @brief Initializes a new instance of the index.
  *  @param options Pointer to the `usearch_init_options_t` structure containing initialization options.
@@ -391,7 +410,7 @@ USEARCH_EXPORT size_t usearch_search(                                         //
 USEARCH_EXPORT size_t usearch_filtered_search(                                //
     usearch_index_t index,                                                    //
     void const* query_vector, usearch_scalar_kind_t query_kind, size_t count, //
-    int (*filter)(usearch_key_t key, void* filter_state), void* filter_state, //
+    usearch_filtered_search_callback_t filter, void* filter_state,            //
     usearch_key_t* keys, usearch_distance_t* distances, usearch_error_t* error);
 
 /**
@@ -480,6 +499,8 @@ USEARCH_EXPORT void usearch_exact_search(                            //
  */
 USEARCH_EXPORT void usearch_clear(usearch_index_t index, usearch_error_t* error);
 
+extern int goFilteredSearchCallback(usearch_key_t, void*);
+
 #ifdef __cplusplus
 }
 #endif

package/cpp/CMakeLists.txt

@@ -7,6 +7,10 @@ if (USEARCH_BUILD_TEST_CPP)
 
     target_include_directories(test_cpp PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../stringzilla/include)
 
+    # Export the dynamic symbol table so `backtrace_symbols` / `std::stacktrace`
+    # can resolve function names when the in-test crash handler fires.
+    set_target_properties(test_cpp PROPERTIES ENABLE_EXPORTS ON)
+
     if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
         target_compile_options(test_cpp PRIVATE -Wno-vla -Wno-unused-function -Wno-cast-function-type)
     endif ()

package/cpp/README.md

@@ -6,7 +6,7 @@ To use in a C++ project, copy the `include/usearch/*` headers into your project.
 Alternatively, fetch it with CMake:
 
 ```cmake
-FetchContent_Declare(usearch GIT_REPOSITORY https://github.com/unum-cloud/usearch.git)
+FetchContent_Declare(usearch GIT_REPOSITORY https://github.com/unum-cloud/USearch.git)
 FetchContent_MakeAvailable(usearch)
 ```
 
@@ -43,9 +43,9 @@ int main(int argc, char **argv) {
 
 Here we:
 
-- define a metric of kind [`metric_kind_t::l2sq_k`](https://unum-cloud.github.io/usearch/cpp/reference.html#_CPPv413metric_kind_t),
-- to be applied to [`scalar_kind_t::f32_k`](https://unum-cloud.github.io/usearch/cpp/reference.html#_CPPv413scalar_kind_t) floating-point vectors,
-- instantiate an [`index_dense_t`](https://unum-cloud.github.io/usearch/cpp/reference.html#_CPPv4I00EN4unum7usearch14index_dense_gtE) index.
+- define a metric of kind [`metric_kind_t::l2sq_k`](https://unum-cloud.github.io/USearch/cpp/reference.html#_CPPv413metric_kind_t),
+- to be applied to [`scalar_kind_t::f32_k`](https://unum-cloud.github.io/USearch/cpp/reference.html#_CPPv413scalar_kind_t) floating-point vectors,
+- instantiate an [`index_dense_t`](https://unum-cloud.github.io/USearch/cpp/reference.html#_CPPv4I00EN4unum7usearch14index_dense_gtE) index.
 
 The `add` is thread-safe for concurrent index construction.
 It also has an overload for different vector types, casting them under the hood.
@@ -174,7 +174,7 @@ In its high-level interface, USearch supports a variety of metrics, including th
 - `metric_haversine_gt<scalar_t>` for "Haversine" or "Great Circle" distance between coordinates used in GIS applications.
 - `metric_divergence_gt<scalar_t>` for the "Jensen Shannon" similarity between probability distributions.
 
-In reality, for most common types, one of the [SimSIMD](https://github.com/ashvardanian/SimSIMD) backends will be triggered, providing hardware-acceleration for most common CPUs.
+In reality, for most common types, one of the [NumKong](https://github.com/ashvardanian/numkong) backends will be triggered, providing hardware-acceleration for most common CPUs.
 
 If you need a different metric, you can implement it yourself and wrap it into a `metric_punned_t`, which is our alternative to the `std::function`.
 Unlike the `std::function`, it is a trivial type, which is important for performance.

package/cpp/bench.cpp

@@ -26,16 +26,18 @@
 
 #include <sys/stat.h> // `stat`
 
-#include <algorithm>
 #include <csignal>
 #include <cstdio>
-#include <iostream>  // `std::cerr`
-#include <numeric>   // `std::iota`
-#include <stdexcept> // `std::invalid_argument`
-#include <string>    // `std::to_string`
-#include <thread>    // `std::thread::hardware_concurrency()`
-#include <variant>   // `std::monostate`
-#include <vector>
+
+#include <algorithm>     // ?
+#include <iostream>      // `std::cerr`
+#include <numeric>       // `std::iota`
+#include <stdexcept>     // `std::invalid_argument`
+#include <string>        // `std::to_string`
+#include <thread>        // `std::thread::hardware_concurrency()`
+#include <unordered_map> // `std::unordered_map`
+#include <variant>       // `std::monostate`
+#include <vector>        // `std::vector`
 
 #include <clipp.h> // Command Line Interface
 #if USEARCH_USE_OPENMP
@@ -112,9 +114,10 @@ struct alignas(32) persisted_matrix_gt {
         if (fstat(file_descriptor, &stat_vectors) == -1)
             throw std::invalid_argument("Couldn't obtain file stats");
         raw_length = stat_vectors.st_size;
-        raw_handle = (std::uint8_t*)mmap(NULL, raw_length, PROT_READ, MAP_PRIVATE, file_descriptor, 0);
-        if (raw_handle == nullptr)
+        auto* result = mmap(NULL, raw_length, PROT_READ, MAP_PRIVATE, file_descriptor, 0);
+        if (result == MAP_FAILED)
             throw std::invalid_argument("Couldn't memory-map the file");
+        raw_handle = (std::uint8_t*)result;
         std::memcpy(&rows, raw_handle, sizeof(rows));
         std::memcpy(&cols, raw_handle + sizeof(rows), sizeof(cols));
         scalars = (scalar_t*)(raw_handle + sizeof(rows) + sizeof(cols));
@@ -201,14 +204,20 @@ struct persisted_dataset_gt {
             for (std::size_t i = 0; i < ids_matrix.rows; ++i)
                 vector_ids_[i] = static_cast<default_key_t>(*ids_matrix.row(i));
         }
+
+        // When custom IDs are loaded and self-search is active, populate
+        // neighborhoods_iota_ with the actual IDs so recall comparison works.
+        if (has_vector_ids() && !queries_.scalars && !neighborhoods_.scalars) {
+            for (std::size_t i = 0; i < neighborhoods_iota_.size(); ++i)
+                neighborhoods_iota_[i] = static_cast<compressed_slot_t>(vector_ids_[i]);
+        }
     }
 
     bool search_itself() const noexcept { return vectors_count() && !queries_.rows; }
     bool has_vector_ids() const noexcept { return !vector_ids_.empty(); }
 
     default_key_t vector_id(std::size_t i) const noexcept {
-        return has_vector_ids() ? vector_ids_[i + vectors_to_skip_]
-                                : static_cast<default_key_t>(i + vectors_to_skip_);
+        return has_vector_ids() ? vector_ids_[i + vectors_to_skip_] : static_cast<default_key_t>(i + vectors_to_skip_);
     }
 
     std::size_t dimensions() const noexcept { return vectors_.cols; }
@@ -224,9 +233,7 @@ struct persisted_dataset_gt {
     std::size_t vectors_count() const noexcept {
         return vectors_to_take_ ? vectors_to_take_ : (vectors_.rows - vectors_to_skip_);
     }
-    matrix_slice_gt<scalar_t const> vectors_view() const noexcept {
-        return {vector(vectors_to_skip_), vectors_count(), dimensions()};
-    }
+    matrix_slice_gt<scalar_t const> vectors_view() const noexcept { return {vector(0), vectors_count(), dimensions()}; }
 };
 
 template <typename scalar_at, typename vector_id_at> //
@@ -288,7 +295,7 @@ struct running_stats_printer_t {
         std::size_t count = progress.load();
         timestamp_t time = std::chrono::high_resolution_clock::now();
         std::size_t duration = std::chrono::duration_cast<std::chrono::nanoseconds>(time - start_time).count();
-        float vectors_per_second = count * 1e9 / duration;
+        float vectors_per_second = static_cast<float>(count * 1e9 / duration);
         std::printf("\r\33[2K100 %% completed, %.0f vectors/s\n", vectors_per_second);
     }
 
@@ -314,7 +321,7 @@ struct running_stats_printer_t {
         timestamp_t time_new = std::chrono::high_resolution_clock::now();
         std::size_t duration =
             std::chrono::duration_cast<std::chrono::nanoseconds>(time_new - last_printed_time).count();
-        float vectors_per_second = count_new * 1e9 / duration;
+        float vectors_per_second = static_cast<float>(count_new * 1e9 / duration);
 
         std::printf("\r%3.3f%% [%.*s%*s] %.0f vectors/s, finished %zu/%zu", percentage * 100.f, left_pad, bars_k,
                     right_pad, "", vectors_per_second, progress, total);
@@ -377,9 +384,8 @@ void search_many( //
 }
 
 template <typename dataset_at, typename index_at> //
-static void single_shot(dataset_at& dataset, index_at& index, bool construct = true) {
+static void single_shot(dataset_at& dataset, index_at& index, bool construct = true, bool bench_join = false) {
     using distance_t = typename index_at::distance_t;
-    constexpr default_key_t missing_key = std::numeric_limits<default_key_t>::max();
 
     std::printf("\n");
     std::printf("------------\n");
@@ -391,6 +397,9 @@ static void single_shot(dataset_at& dataset, index_at& index, bool construct = t
         index_many(index, dataset.vectors_count(), ids.data(), dataset.vector(0), dataset.dimensions());
     }
 
+    std::size_t mem = index.memory_usage();
+    std::printf("Memory usage: %.2f GB\n", mem / (1024.0 * 1024.0 * 1024.0));
+
     // Perform search, evaluate speed
     std::vector<default_key_t> found_neighbors(dataset.queries_count() * dataset.neighborhood_size());
     std::vector<distance_t> found_distances(dataset.queries_count() * dataset.neighborhood_size());
@@ -409,40 +418,38 @@ static void single_shot(dataset_at& dataset, index_at& index, bool construct = t
     std::printf("Recall@1 %.2f %%\n", recall_at_1 * 100.f / dataset.queries_count());
     std::printf("Recall %.2f %%\n", recall_full * 100.f / dataset.queries_count());
 
-    // Perform joins
-    std::vector<default_key_t> man_to_woman(dataset.vectors_count());
-    std::vector<default_key_t> woman_to_man(dataset.vectors_count());
-    std::size_t join_attempts = 0;
-    {
+    if (!bench_join) {
+        // Perform joins using maps to support non-contiguous IDs
+        std::unordered_map<default_key_t, default_key_t> man_to_woman;
+        std::unordered_map<default_key_t, default_key_t> woman_to_man;
+        std::size_t join_attempts = 0;
+
         index_at& men = index;
         index_at women = index.copy();
-        std::fill(man_to_woman.begin(), man_to_woman.end(), missing_key);
-        std::fill(woman_to_man.begin(), woman_to_man.end(), missing_key);
-        {
-            executor_default_t executor(index.limits().threads());
-            running_stats_printer_t printer{1, "Join"};
-            join_result_t result = join(                          //
-                men, women, index_join_config_t{executor.size()}, //
-                man_to_woman.data(), woman_to_man.data(),         //
-                executor, [&](std::size_t progress, std::size_t total) {
-                    if (progress % 1000 == 0)
-                        printer.print(progress, total);
-                    return true;
-                });
-            // Refresh once again to show 100% completion
-            printer.print();
-            join_attempts = result.visited_members;
-        }
-    }
-    // Evaluate join quality
-    std::size_t recall_join = 0, unmatched_count = 0;
-    for (std::size_t i = 0; i != index.size(); ++i) {
-        recall_join += man_to_woman[i] == static_cast<default_key_t>(i);
-        unmatched_count += man_to_woman[i] == missing_key;
+
+        executor_default_t executor(index.limits().threads());
+        running_stats_printer_t printer{1, "Join"};
+        join_result_t result = join(                          //
+            men, women, index_join_config_t{executor.size()}, //
+            man_to_woman, woman_to_man,                       //
+            executor, [&](std::size_t progress, std::size_t total) {
+                if (progress % 1000 == 0)
+                    printer.print(progress, total);
+                return true;
+            });
+        // Refresh once again to show 100% completion
+        printer.print();
+        join_attempts = result.visited_members;
+
+        // Evaluate join quality
+        std::size_t recall_join = 0;
+        for (auto const& [man, woman] : man_to_woman)
+            recall_join += (man == woman);
+        std::size_t unmatched_count = dataset.vectors_count() - man_to_woman.size();
+        std::printf("Recall Joins %.2f %%\n", recall_join * 100.f / index.size());
+        std::printf("Unmatched %.2f %% (%zu items)\n", unmatched_count * 100.f / index.size(), unmatched_count);
+        std::printf("Proposals %.2f / man (%zu total)\n", join_attempts * 1.f / index.size(), join_attempts);
     }
-    std::printf("Recall Joins %.2f %%\n", recall_join * 100.f / index.size());
-    std::printf("Unmatched %.2f %% (%zu items)\n", unmatched_count * 100.f / index.size(), unmatched_count);
-    std::printf("Proposals %.2f / man (%zu total)\n", join_attempts * 1.f / index.size(), join_attempts);
 
     std::printf("------------\n");
     std::printf("\n");
@@ -473,7 +480,7 @@ void handler(int sig) {
             name = "<unknown>";
         }
         DWORD bytes_written;
-        WriteFile(STDERR_FILENO, name, std::strlen(name), &bytes_written, NULL);
+        WriteFile(STDERR_FILENO, name, static_cast<DWORD>(std::strlen(name)), &bytes_written, NULL);
         WriteFile(STDERR_FILENO, "\n", 1, &bytes_written, NULL);
     }
     free(symbol);
@@ -508,49 +515,24 @@ struct args_t {
     bool help = false;
 
     bool big = false;
+    bool join = false;
+    bool view = false;
 
-    bool quantize_bf16 = false;
-    bool quantize_f16 = false;
-    bool quantize_i8 = false;
-    bool quantize_b1 = false;
-
-    bool metric_ip = false;
-    bool metric_l2 = false;
-    bool metric_cos = false;
-    bool metric_haversine = false;
-    bool metric_divergence = false;
-    bool metric_hamming = false;
-    bool metric_tanimoto = false;
-    bool metric_sorensen = false;
+    std::string dtype_str = "f32";
+    std::string metric_str = "ip";
 
     metric_kind_t metric() const noexcept {
-        if (metric_l2)
-            return metric_kind_t::l2sq_k;
-        if (metric_cos)
-            return metric_kind_t::cos_k;
-        if (metric_haversine)
-            return metric_kind_t::haversine_k;
-        if (metric_divergence)
-            return metric_kind_t::divergence_k;
-        if (metric_hamming)
-            return metric_kind_t::hamming_k;
-        if (metric_tanimoto)
-            return metric_kind_t::tanimoto_k;
-        if (metric_sorensen)
-            return metric_kind_t::sorensen_k;
-        return metric_kind_t::ip_k;
+        auto parsed = metric_from_name(metric_str.c_str(), metric_str.size());
+        if (!parsed)
+            return metric_kind_t::ip_k;
+        return parsed.result;
     }
 
     scalar_kind_t quantization() const noexcept {
-        if (quantize_bf16)
-            return scalar_kind_t::bf16_k;
-        if (quantize_f16)
-            return scalar_kind_t::f16_k;
-        if (quantize_i8)
-            return scalar_kind_t::i8_k;
-        if (quantize_b1)
-            return scalar_kind_t::b1x8_k;
-        return scalar_kind_t::f32_k;
+        auto parsed = scalar_kind_from_name(dtype_str.c_str(), dtype_str.size());
+        if (!parsed)
+            return scalar_kind_t::f32_k;
+        return parsed.result;
     }
 };
 
@@ -569,14 +551,16 @@ void run_punned(dataset_at& dataset, args_t const& args, index_dense_config_t co
     std::printf("-- Hardware acceleration: %s\n", index.metric().isa_name());
     std::printf("Will benchmark in-memory\n");
 
-    single_shot(dataset, index, true);
+    single_shot(dataset, index, true, args.join);
     index.save(args.path_output.c_str());
 
+    if (!args.view)
+        return;
     std::printf("Will benchmark an on-disk view\n");
 
     index_at index_view = index.fork();
     index_view.view(args.path_output.c_str());
-    single_shot(dataset, index_view, false);
+    single_shot(dataset, index_view, false, args.join);
 }
 
 template <typename index_at, typename dataset_at> //
@@ -586,14 +570,16 @@ void run_typed(dataset_at& dataset, args_t const& args, index_config_t config, i
     index.reserve(limits);
     std::printf("Will benchmark in-memory\n");
 
-    single_shot(dataset, index, true);
+    single_shot(dataset, index, true, args.join);
     index.save(args.path_output.c_str());
 
+    if (!args.view)
+        return;
     std::printf("Will benchmark an on-disk view\n");
 
     index_at index_view = index.fork();
     index_view.view(args.path_output.c_str());
-    single_shot(dataset, index_view, false);
+    single_shot(dataset, index_view, false, args.join);
 }
 
 template <typename dataset_scalar_at> void bench_with_args(args_t const& args) {
@@ -636,9 +622,9 @@ int main(int argc, char** argv) {
     auto args = args_t{};
     auto cli = ( //
         (option("--vectors") & value("path", args.path_vectors))
-            .doc(".[fhbd]bin, .i8bin, .f32bin file path to construct the index"),
+            .doc(".[fhbd]bin, .i8bin, .u8bin, .f32bin file path to construct the index"),
         (option("--queries") & value("path", args.path_queries))
-            .doc(".[fhbd]bin, .i8bin, .f32bin file path to query the index"),
+            .doc(".[fhbd]bin, .i8bin, .u8bin, .f32bin file path to query the index"),
         (option("--neighbors") & value("path", args.path_neighbors)).doc(".ibin, .i32bin file path with ground truth"),
         (option("--ids") & value("path", args.path_ids)).doc(".i32bin file path with vector IDs (optional)"),
         (option("-o", "--output") & value("path", args.path_output)).doc(".usearch output file path"),
@@ -649,20 +635,13 @@ int main(int argc, char** argv) {
         (option("--expansion-search") & value("integer", args.expansion_search)).doc("Affects search depth"),
         (option("--rows-skip") & value("integer", args.vectors_to_skip)).doc("Number of vectors to skip"),
         (option("--rows-take") & value("integer", args.vectors_to_take)).doc("Number of vectors to take"),
-        ( //
-            option("-bf16", "--bf16quant").set(args.quantize_bf16).doc("Enable `bf16_t` quantization") |
-            option("-f16", "--f16quant").set(args.quantize_f16).doc("Enable `f16_t` quantization") |
-            option("-i8", "--i8quant").set(args.quantize_i8).doc("Enable `i8_t` quantization") |
-            option("-b1", "--b1quant").set(args.quantize_b1).doc("Enable `b1x8_t` quantization")),
-        ( //
-            option("--ip").set(args.metric_ip).doc("Choose Inner Product metric") |
-            option("--l2sq").set(args.metric_l2).doc("Choose L2 Euclidean metric") |
-            option("--cos").set(args.metric_cos).doc("Choose Angular metric") |
-            option("--hamming").set(args.metric_hamming).doc("Choose Hamming metric") |
-            option("--tanimoto").set(args.metric_tanimoto).doc("Choose Tanimoto metric") |
-            option("--sorensen").set(args.metric_sorensen).doc("Choose Sorensen metric") |
-            option("--haversine").set(args.metric_haversine).doc("Choose Haversine metric")),
-        option("-h", "--help").set(args.help).doc("Print this help information on this tool and exit"));
+        (option("--dtype") & value("type", args.dtype_str))
+            .doc("Quantization type: f64, f32, bf16, f16, e5m2, e4m3, e3m2, e2m3, i8, u8, b1"),
+        (option("--metric") & value("name", args.metric_str))
+            .doc("Distance metric: ip, l2sq, cos, hamming, tanimoto, sorensen, haversine"),
+        option("-h", "--help").set(args.help).doc("Print this help information on this tool and exit"),
+        option("--join").set(args.join).doc("Also benchmark joins"),
+        option("--view").set(args.view).doc("Also benchmark on-disk view"));
 
     if (!parse(argc, argv, cli)) {
         std::cerr << make_man_page(cli, argv[0]);
@@ -678,10 +657,12 @@ int main(int argc, char** argv) {
     // to better estimate statistics between tasks batches, without having to recreate
     // the threads.
     omp_set_dynamic(true);
-    omp_set_num_threads(args.threads);
+    omp_set_num_threads(static_cast<int>(args.threads));
     std::printf("- OpenMP threads: %d\n", omp_get_max_threads());
 #endif
 
+    std::printf("- Hardware acceleration compiled: %s\n", hardware_acceleration_compiled());
+    std::printf("- Hardware acceleration available: %s\n", hardware_acceleration_available());
     std::printf("- Dataset: \n");
     std::printf("-- Base vectors path: %s\n", args.path_vectors.c_str());
     std::printf("-- Query vectors path: %s\n", args.path_queries.c_str());
@@ -693,18 +674,18 @@ int main(int argc, char** argv) {
         return stack.find(needle, stack.size() - needle.size()) != std::string_view::npos;
     };
 
-    if (ends_with(args.path_vectors, ".fbin"))
-        bench_with_args<f32_t>(args);
-    else if (ends_with(args.path_vectors, ".dbin"))
+    if (ends_with(args.path_vectors, ".dbin"))
         bench_with_args<f64_t>(args);
+    else if (ends_with(args.path_vectors, ".fbin") || ends_with(args.path_vectors, ".f32bin"))
+        bench_with_args<f32_t>(args);
     else if (ends_with(args.path_vectors, ".hbin"))
         bench_with_args<f16_t>(args);
-    else if (ends_with(args.path_vectors, ".bbin"))
-        bench_with_args<b1x8_t>(args);
     else if (ends_with(args.path_vectors, ".i8bin"))
         bench_with_args<i8_t>(args);
-    else if (ends_with(args.path_vectors, ".f32bin"))
-        bench_with_args<f32_t>(args);
+    else if (ends_with(args.path_vectors, ".u8bin"))
+        bench_with_args<u8_t>(args);
+    else if (ends_with(args.path_vectors, ".bbin"))
+        bench_with_args<b1x8_t>(args);
     else
         throw std::runtime_error("Unknown input file path");