usearch 0.2.4 → 0.8.0

package/include/usearch/usearch.hpp

@@ -9,51 +9,84 @@
 #ifndef UNUM_USEARCH_H
 #define UNUM_USEARCH_H
 
+// Inferring C++ version
+#if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L)
+#define USEARCH_IS_CPP17
+#endif
+
+// Inferring target OS
 #if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
-#define _USE_MATH_DEFINES
+#define USEARCH_IS_WINDOWS
+#elif defined(__APPLE__) && defined(__MACH__)
+#define USEARCH_IS_APPLE
+#elif defined(__linux__)
+#define USEARCH_IS_LINUX
+#endif
 
-#include <Windows.h>
+// Inferring the compiler
+#if defined(__clang__)
+#define USEARCH_IS_CLANG
+#elif defined(__GNUC__)
+#define USEARCH_IS_GCC
+#endif
 
-#define usearch_pack_m
-#define usearch_align_m __declspec(align(64))
-#define WINDOWS
+// Inferring hardware architecture: x86 vs Arm
+#if defined(__x86_64__)
+#define USEARCH_IS_X86
+#elif defined(__aarch64__)
+#define USEARCH_IS_ARM
+#endif
 
+// OS-specific includes
+#if defined(USEARCH_IS_WINDOWS)
+#define _USE_MATH_DEFINES
+#include <Windows.h>
+#include <sys/stat.h> // `fstat` for file size
 #else
 #include <fcntl.h>    // `fallocate`
 #include <stdlib.h>   // `posix_memalign`
 #include <sys/mman.h> // `mmap`
+#include <sys/stat.h> // `fstat` for file size
 #include <unistd.h>   // `open`, `close`
-
-#define usearch_pack_m __attribute__((packed))
-#define usearch_align_m __attribute__((aligned(64)))
 #endif
 
-#include <sys/stat.h> // `fstat` for file size
-
+// STL includes
 #include <algorithm> // `std::sort_heap`
 #include <atomic>    // `std::atomic`
 #include <bitset>    // `std::bitset`
 #include <climits>   // `CHAR_BIT`
 #include <cmath>     // `std::sqrt`
 #include <cstring>   // `std::memset`
+#include <iterator>  // `std::reverse_iterator`
 #include <mutex>     // `std::unique_lock` - replacement candidate
 #include <random>    // `std::default_random_engine` - replacement candidate
 #include <stdexcept> // `std::runtime_exception`
-#include <utility>   // `std::exchange`
+#include <utility>   // `std::exchange`, `std::pair`
 #include <vector>    // `std::vector`
 
-#if defined(__GNUC__)
+// Prefetching
+#if defined(USEARCH_IS_GCC)
 // https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html
 // Zero means we are only going to read from that memory.
 // Three means high temporal locality and suggests to keep
 // the data in all layers of cache.
 #define prefetch_m(ptr) __builtin_prefetch((void*)(ptr), 0, 3)
-#elif defined(__x86_64__)
+#elif defined(USEARCH_IS_X86)
 #define prefetch_m(ptr) _mm_prefetch((void*)(ptr), _MM_HINT_T0)
 #else
 #define prefetch_m(ptr)
 #endif
 
+// Alignment
+#if defined(USEARCH_IS_WINDOWS)
+#define usearch_pack_m
+#define usearch_align_m __declspec(align(64))
+#else
+#define usearch_pack_m __attribute__((packed))
+#define usearch_align_m __attribute__((aligned(64)))
+#endif
+
+// Debugging
 #if defined(NDEBUG)
 #define assert_m(must_be_true, message)
 #else
@@ -68,11 +101,16 @@ namespace usearch {
 
 using f64_t = double;
 using f32_t = float;
+using byte_t = char;
 
 template <typename at> at angle_to_radians(at angle) noexcept { return angle * M_PI / 180.f; }
 
 template <typename at> at square(at value) noexcept { return value * value; }
 
+template <std::size_t multiple_ak> inline std::size_t divide_round_up(std::size_t num) noexcept {
+    return (num + multiple_ak - 1) / multiple_ak;
+}
+
 inline std::size_t ceil2(std::size_t v) noexcept {
     v--;
     v |= v >> 1;
@@ -85,6 +123,71 @@ inline std::size_t ceil2(std::size_t v) noexcept {
     return v;
 }
 
+template <typename at> void misaligned_store(void* ptr, at v) noexcept { std::memcpy(ptr, &v, sizeof(v)); }
+
+template <typename at> at misaligned_load(void* ptr) noexcept {
+    at v;
+    std::memcpy(&v, ptr, sizeof(v));
+    return v;
+}
+
+template <typename at> class misaligned_ref_gt {
+    byte_t* ptr_;
+
+  public:
+    misaligned_ref_gt(byte_t* ptr) noexcept : ptr_(ptr) {}
+    operator at() const noexcept { return misaligned_load<at>(ptr_); }
+    misaligned_ref_gt& operator=(at const& v) noexcept {
+        misaligned_store<at>(ptr_, v);
+        return *this;
+    }
+    misaligned_ref_gt& operator=(at v) noexcept {
+        misaligned_store<at>(ptr_, v);
+        return *this;
+    }
+};
+
+template <typename at> class misaligned_ptr_gt {
+    byte_t* ptr_;
+
+  public:
+    using iterator_category = std::random_access_iterator_tag;
+    using value_type = at;
+    using difference_type = std::ptrdiff_t;
+    using pointer = misaligned_ptr_gt<at>;
+    using reference = misaligned_ref_gt<at>;
+
+    reference operator*() const noexcept { return {ptr_}; }
+
+    misaligned_ptr_gt(byte_t* ptr) noexcept : ptr_(ptr) {}
+    misaligned_ptr_gt operator++(int) noexcept { return misaligned_ptr_gt(ptr_ + sizeof(at)); }
+    misaligned_ptr_gt operator--(int) noexcept { return misaligned_ptr_gt(ptr_ - sizeof(at)); }
+    misaligned_ptr_gt operator+(difference_type d) noexcept { return misaligned_ptr_gt(ptr_ + d * sizeof(at)); }
+    misaligned_ptr_gt operator-(difference_type d) noexcept { return misaligned_ptr_gt(ptr_ - d * sizeof(at)); }
+
+    misaligned_ptr_gt& operator++() noexcept {
+        ptr_ += sizeof(at);
+        return *this;
+    }
+    misaligned_ptr_gt& operator--() noexcept {
+        ptr_ -= sizeof(at);
+        return *this;
+    }
+    misaligned_ptr_gt& operator+=(difference_type d) noexcept {
+        ptr_ += d * sizeof(at);
+        return *this;
+    }
+    misaligned_ptr_gt& operator-=(difference_type d) noexcept {
+        ptr_ -= d * sizeof(at);
+        return *this;
+    }
+    bool operator==(misaligned_ptr_gt const& other) noexcept { return ptr_ == other.ptr_; }
+    bool operator!=(misaligned_ptr_gt const& other) noexcept { return ptr_ != other.ptr_; }
+};
+
+/**
+ *  @brief  Inner (Dot) Product distance.
+ */
 template <typename scalar_at, typename result_at = scalar_at> struct ip_gt {
     using scalar_t = scalar_at;
     using result_t = result_at;
@@ -92,12 +195,12 @@ template <typename scalar_at, typename result_at = scalar_at> struct ip_gt {
 
     inline result_t operator()(scalar_t const* a, scalar_t const* b, std::size_t dim, std::size_t = 0) const noexcept {
         result_type ab{};
-#if defined(__GNUC__)
-#pragma GCC ivdep
-#elif defined(__clang__)
-#pragma clang loop vectorize(enable)
-#elif defined(_OPENMP)
+#if defined(USEARCH_USE_OPENMP)
 #pragma omp simd reduction(+ : ab)
+#elif defined(USEARCH_IS_CLANG)
+#pragma clang loop vectorize(enable)
+#elif defined(USEARCH_IS_GCC)
+#pragma GCC ivdep
 #endif
         for (std::size_t i = 0; i != dim; ++i)
             ab += result_t(a[i]) * result_t(b[i]);
@@ -105,6 +208,12 @@ template <typename scalar_at, typename result_at = scalar_at> struct ip_gt {
     }
 };
 
+/**
+ *  @brief  Cosine (Angular) distance.
+ *          Identical to the Inner Product of normalized vectors.
+ *          Unless you are running on an tiny embedded platform, this metric
+ *          is recommended over `::ip_gt` for low-precision scalars.
+ */
 template <typename scalar_at, typename result_at = scalar_at> struct cos_gt {
     using scalar_t = scalar_at;
     using result_t = result_at;
@@ -112,21 +221,25 @@ template <typename scalar_at, typename result_at = scalar_at> struct cos_gt {
 
     inline result_t operator()(scalar_t const* a, scalar_t const* b, std::size_t dim, std::size_t = 0) const noexcept {
         result_t ab{}, a2{}, b2{};
-#if defined(__GNUC__)
-#pragma GCC ivdep
-#elif defined(__clang__)
-#pragma clang loop vectorize(enable)
-#elif defined(_OPENMP)
+#if defined(USEARCH_USE_OPENMP)
 #pragma omp simd reduction(+ : ab, a2, b2)
+#elif defined(USEARCH_IS_CLANG)
+#pragma clang loop vectorize(enable)
+#elif defined(USEARCH_IS_GCC)
+#pragma GCC ivdep
 #endif
         for (std::size_t i = 0; i != dim; ++i)
             ab += result_t(a[i]) * result_t(b[i]), //
                 a2 += square<result_t>(a[i]),      //
                 b2 += square<result_t>(b[i]);
-        return 1 - ab / (std::sqrt(a2) * std::sqrt(b2));
+        return ab ? (1 - ab / (std::sqrt(a2) * std::sqrt(b2))) : 0;
     }
 };
 
+/**
+ *  @brief  Squared Euclidean (L2) distance.
+ *          Square root is avoided at the end, as it won't affect the ordering.
+ */
 template <typename scalar_at, typename result_at = scalar_at> struct l2sq_gt {
     using scalar_t = scalar_at;
     using result_t = result_at;
@@ -134,12 +247,12 @@ template <typename scalar_at, typename result_at = scalar_at> struct l2sq_gt {
 
     inline result_t operator()(scalar_t const* a, scalar_t const* b, std::size_t dim, std::size_t = 0) const noexcept {
         result_t ab_deltas_sq{};
-#if defined(__GNUC__)
-#pragma GCC ivdep
-#elif defined(__clang__)
-#pragma clang loop vectorize(enable)
-#elif defined(_OPENMP)
+#if defined(USEARCH_USE_OPENMP)
 #pragma omp simd reduction(+ : ab_deltas_sq)
+#elif defined(USEARCH_IS_CLANG)
+#pragma clang loop vectorize(enable)
+#elif defined(USEARCH_IS_GCC)
+#pragma GCC ivdep
 #endif
         for (std::size_t i = 0; i != dim; ++i)
             ab_deltas_sq += square(result_t(a[i]) - result_t(b[i]));
@@ -156,17 +269,16 @@ template <typename scalar_at, typename result_at = std::size_t> struct hamming_g
     using result_t = result_at;
     using result_type = result_t;
 
-    inline result_t operator()(scalar_t const* a, scalar_t const* b, std::size_t elements,
-                               std::size_t = 0) const noexcept {
+    inline result_t operator()(scalar_t const* a, scalar_t const* b, std::size_t dim, std::size_t = 0) const noexcept {
         result_t matches{};
-#if defined(__GNUC__)
-#pragma GCC ivdep
-#elif defined(__clang__)
-#pragma clang loop vectorize(enable)
-#elif defined(_OPENMP)
+#if defined(USEARCH_USE_OPENMP)
 #pragma omp simd reduction(+ : matches)
+#elif defined(USEARCH_IS_CLANG)
+#pragma clang loop vectorize(enable)
+#elif defined(USEARCH_IS_GCC)
+#pragma GCC ivdep
 #endif
-        for (std::size_t i = 0; i != elements; ++i)
+        for (std::size_t i = 0; i != dim; ++i)
             matches += a[i] != b[i];
         return matches;
     }
@@ -182,17 +294,17 @@ template <typename scalar_at, typename result_at = std::size_t> struct bit_hammi
     using result_t = result_at;
     using result_type = result_t;
     static_assert(std::is_unsigned<scalar_t>::value, "Hamming distance requires unsigned integral words");
-    static constexpr std::size_t bits_per_word_k = sizeof(scalar_t) * CHAR_BIT;
 
     inline result_t operator()(scalar_t const* a, scalar_t const* b, std::size_t words,
                                std::size_t = 0) const noexcept {
+        constexpr std::size_t bits_per_word_k = sizeof(scalar_t) * CHAR_BIT;
         result_t matches{};
-#if defined(__GNUC__)
-#pragma GCC ivdep
-#elif defined(__clang__)
-#pragma clang loop vectorize(enable)
-#elif defined(_OPENMP)
+#if defined(USEARCH_USE_OPENMP)
 #pragma omp simd reduction(+ : matches)
+#elif defined(USEARCH_IS_CLANG)
+#pragma clang loop vectorize(enable)
+#elif defined(USEARCH_IS_GCC)
+#pragma GCC ivdep
 #endif
         for (std::size_t i = 0; i != words; ++i)
             matches += std::bitset<bits_per_word_k>(a[i] ^ b[i]).count();
@@ -239,12 +351,12 @@ template <typename scalar_at, typename result_at = scalar_at> struct pearson_cor
         scalar_t const* a, scalar_t const* b, std::size_t dim, std::size_t = 0) const noexcept {
         result_t a_sum{}, b_sum{}, ab_sum{};
         result_t a_sq_sum{}, b_sq_sum{};
-#if defined(__GNUC__)
-#pragma GCC ivdep
-#elif defined(__clang__)
-#pragma clang loop vectorize(enable)
-#elif defined(_OPENMP)
+#if defined(USEARCH_USE_OPENMP)
 #pragma omp simd reduction(+ : a_sum, b_sum, ab_sum, a_sq_sum, b_sq_sum)
+#elif defined(USEARCH_IS_CLANG)
+#pragma clang loop vectorize(enable)
+#elif defined(USEARCH_IS_GCC)
+#pragma GCC ivdep
 #endif
         for (std::size_t i = 0; i != dim; ++i) {
             a_sum += a[i];
@@ -287,16 +399,21 @@ template <typename scalar_at, typename result_at = scalar_at> struct haversine_g
     }
 };
 
-template <std::size_t multiple_ak> inline std::size_t divide_round_up(std::size_t num) noexcept {
-    return (num + multiple_ak - 1) / multiple_ak;
-}
-
+/**
+ *  @brief  Light-weight bitset implementation to track visited nodes during graph traversal.
+ *          Extends basic functionality with atomic operations.
+ */
 template <typename allocator_at = std::allocator<char>> class visits_bitset_gt {
     using allocator_t = allocator_at;
     using byte_t = typename allocator_t::value_type;
     static_assert(sizeof(byte_t) == 1, "Allocator must allocate separate addressable bytes");
 
+#if defined(USEARCH_IS_WINDOWS)
+    using slot_t = LONG volatile;
+    static_assert(sizeof(slot_t) == 8);
+#else
     using slot_t = std::uint64_t;
+#endif
 
     std::uint64_t* u64s_{};
     std::size_t slots_{};
@@ -306,6 +423,7 @@ template <typename allocator_at = std::allocator<char>> class visits_bitset_gt {
     visits_bitset_gt(std::size_t capacity) noexcept {
         slots_ = divide_round_up<64>(capacity);
         u64s_ = (slot_t*)allocator_t{}.allocate(slots_ * sizeof(slot_t));
+        clear();
     }
     ~visits_bitset_gt() noexcept { allocator_t{}.deallocate((byte_t*)u64s_, slots_ * sizeof(slot_t)), u64s_ = nullptr; }
     void clear() noexcept { std::memset(u64s_, 0, slots_ * sizeof(slot_t)); }
@@ -324,6 +442,42 @@ template <typename allocator_at = std::allocator<char>> class visits_bitset_gt {
         std::swap(slots_, other.slots_);
         return *this;
     }
+
+#if defined(USEARCH_IS_WINDOWS)
+
+    inline bool atomic_test(std::size_t i) noexcept {
+        slot_t mask{1ul << (i & 63ul)};
+        return InterlockedOr(&u64s_[i / 64], 0) & mask;
+    }
+
+    inline bool atomic_set(std::size_t i) noexcept {
+        slot_t mask{1ul << (i & 63ul)};
+        return InterLockedOr(&u64s_[i / 64], mask) & mask;
+    }
+
+    inline void atomic_reset(std::size_t i) noexcept {
+        slot_t mask{1ul << (i & 63ul)};
+        InterLockedAnd((LONG volatile*)&u64s_[i / 64], ~mask);
+    }
+
+#else
+
+    inline bool atomic_test(std::size_t i) noexcept {
+        slot_t mask{1ul << (i & 63ul)};
+        return __atomic_load_n(&u64s_[i / 64], __ATOMIC_RELAXED) & mask;
+    }
+
+    inline bool atomic_set(std::size_t i) noexcept {
+        slot_t mask{1ul << (i & 63ul)};
+        return __atomic_fetch_or(&u64s_[i / 64], mask, __ATOMIC_ACQUIRE) & mask;
+    }
+
+    inline void atomic_reset(std::size_t i) noexcept {
+        slot_t mask{1ul << (i & 63ul)};
+        __atomic_fetch_and(&u64s_[i / 64], ~mask, __ATOMIC_RELEASE);
+    }
+
+#endif
 };
 
 using visits_bitset_t = visits_bitset_gt<>;
@@ -564,63 +718,13 @@ class sorted_buffer_gt {
     static bool less(element_t const& a, element_t const& b) noexcept { return comparator_t{}(a, b); }
 };
 
-/**
- *
- */
-class mutex_t {
-#if defined(WINDOWS)
-    using slot_t = volatile LONG;
-#else
-    using slot_t = std::int32_t;
-#endif // WINDOWS
-
-    slot_t flag_;
-
-  public:
-    inline mutex_t(slot_t flag = 0) noexcept : flag_(flag) {}
-    inline ~mutex_t() noexcept {}
-
-    inline bool try_lock() noexcept {
-        slot_t raw = 0;
-#if defined(WINDOWS)
-        return InterlockedCompareExchange(&flag_, 1, raw);
-#else
-        return __atomic_compare_exchange_n(&flag_, &raw, 1, true, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED);
-#endif // WINDOWS
-    }
-
-    inline void lock() noexcept {
-        slot_t raw = 0;
-#if defined(WINDOWS)
-        InterlockedCompareExchange(&flag_, 1, raw);
-#else
-    lock_again:
-        raw = 0;
-        if (!__atomic_compare_exchange_n(&flag_, &raw, 1, true, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED))
-            goto lock_again;
-#endif // WINDOWS
-    }
-
-    inline void unlock() noexcept {
-#if defined(WINDOWS)
-        InterlockedExchange(&flag_, 0);
-#else
-        __atomic_store_n(&flag_, 0, __ATOMIC_RELEASE);
+#if defined(USEARCH_IS_WINDOWS)
+#pragma pack(push, 1) // Pack struct members on 1-byte alignment
 #endif
-    }
-};
-
-static_assert(sizeof(mutex_t) == sizeof(std::int32_t), "Mutex is larger than expected");
-
-using lock_t = std::unique_lock<mutex_t>;
 
 /**
  *  @brief Five-byte integer type to address node clouds with over 4B entries.
  */
-#if defined(WINDOWS)
-#pragma pack(push, 1) // Pack struct members on 1-byte alignment
-#endif
-
 class usearch_pack_m uint40_t {
     unsigned char octets[5];
 
@@ -628,7 +732,7 @@ class usearch_pack_m uint40_t {
     inline uint40_t() noexcept { std::memset(octets, 0, 5); }
     inline uint40_t(std::uint32_t n) noexcept { std::memcpy(octets + 1, (char*)&n, 4), octets[0] = 0; }
     inline uint40_t(std::uint64_t n) noexcept { std::memcpy(octets, (char*)&n + 3, 5); }
-#if defined(__clang__)
+#if defined(USEARCH_IS_CLANG)
     inline uint40_t(std::size_t n) noexcept { std::memcpy(octets, (char*)&n + 3, 5); }
 #endif
 
@@ -658,12 +762,16 @@ class usearch_pack_m uint40_t {
         return old;
     }
 };
-#if defined(WINDOWS)
+
+#if defined(USEARCH_IS_WINDOWS)
 #pragma pack(pop) // Reset alignment to default
 #endif
 
 static_assert(sizeof(uint40_t) == 5, "uint40_t must be exactly 5 bytes");
 
+/**
+ *  @brief  Non-owning memory range view, similar to `std::span`, but for C++11.
+ */
 template <typename scalar_at> class span_gt {
     scalar_at* data_;
     std::size_t size_;
@@ -676,48 +784,61 @@ template <typename scalar_at> class span_gt {
     operator scalar_at*() const noexcept { return data(); }
 };
 
+constexpr std::size_t default_connectivity() { return 16; }
+constexpr std::size_t default_expansion_add() { return 128; }
+constexpr std::size_t default_expansion_search() { return 64; }
+
 /**
- *  @brief
- *      Configuration settings for the index construction.
- *      Includes the main `::connectivity` parameter (`M` in the paper)
- *      and two expansion factors - for construction and search.
+ *  @brief  Configuration settings for the index construction.
+ *          Includes the main `::connectivity` parameter (`M` in the paper)
+ *          and two expansion factors - for construction and search.
  */
 struct config_t {
 
     /// @brief Number of neighbors per graph node.
     /// Defaults to 32 in FAISS and 16 in hnswlib.
     /// > It is called `M` in the paper.
-    static constexpr std::size_t connectivity_default_k = 16;
+    std::size_t connectivity = default_connectivity();
 
     /// @brief Hyper-parameter controlling the quality of indexing.
     /// Defaults to 40 in FAISS and 200 in hnswlib.
     /// > It is called `efConstruction` in the paper.
-    static constexpr std::size_t expansion_add_default_k = 128;
+    std::size_t expansion_add = default_expansion_add();
 
     /// @brief Hyper-parameter controlling the quality of search.
     /// Defaults to 16 in FAISS and 10 in hnswlib.
     /// > It is called `ef` in the paper.
-    static constexpr std::size_t expansion_search_default_k = 64;
-
-    std::size_t connectivity = connectivity_default_k;
-    std::size_t expansion_add = expansion_add_default_k;
-    std::size_t expansion_search = expansion_search_default_k;
+    std::size_t expansion_search = default_expansion_search();
 
     ///
     std::size_t max_elements = 0;
-    std::size_t max_threads_add = 0;
-    std::size_t max_threads_search = 0;
+    std::size_t max_threads_add = 1;
+    std::size_t max_threads_search = 1;
+
+    std::size_t max_threads() const noexcept { return (std::max)(max_threads_add, max_threads_search); }
+    std::size_t concurrency() const noexcept { return (std::min)(max_threads_add, max_threads_search); }
+};
+
+struct add_config_t {
+    /// @brief Optional thread identifier for multi-threaded construction.
+    std::size_t thread{};
+    /// @brief Don't copy the ::vector, if it's persisted elsewhere.
+    bool store_vector{true};
+};
+
+struct search_config_t {
+    std::size_t thread{};
+    bool exact{};
 };
 
 /**
- *  @brief
- *      Approximate Nearest Neighbors Search index using the
- *      Hierarchical Navigable Small World graph algorithm.
+ *  @brief  Approximate Nearest Neighbors Search index using the
+ *          Hierarchical Navigable Small World graph algorithm.
  *
  *  @section Features
- *      - Search for vectors of different dimensionality.
- *      - Thread-safe.
- *      - Bring your threads!
+ *      - Thread-safe for concurrent construction.
+ *      - Doesn't allocate new threads, and reuses the ones its called from.
+ *      - Search for vectors of different dimensionality, if ::`metric_at` supports that.
  *
  *  @tparam metric_at
  *      A function vector responsible for computing the distance between two vectors.
@@ -733,6 +854,40 @@ struct config_t {
  *
  *  @tparam allocator_at
  *      Dynamic memory allocator.
+ *
+ *
+ *  @section Implementation Details
+ *
+ *  Like every HNSW implementation, USearch builds levels of "Proximity Graphs".
+ *  Every added vector forms a node in one or more levels of the graph.
+ *  Every node is present in the base level. Every following level contains a smaller
+ *  fraction of nodes. During search, the operation starts with the smaller levels
+ *  and zooms-in on every following iteration of larger graph traversals.
+ *
+ *  Just one memory allocation is performed regardless of the number of levels.
+ *  The adjacency lists across all levels are concatenated into that single buffer.
+ *  That buffer starts with a "head", that stores the metadata, such as the
+ *  tallest "level" of the graph that it belongs to, the external "label", and the
+ *  number of "dimensions" in the vector.
+ *
+ *  @subsection Colocated Nodes
+ *
+ *  Every node contains some graph-related data, as well as the original vector.
+ *  Assuming the vectors can get large, we allow separating the index from the vectors.
+ *  They can either be stored in a single continuous block of memory, or in two separate
+ *  locations. Vector storage can also be detached from `index_gt` and managed by the user.
+ *  To properly serialize and deserialize, use the right `save()`, `load()`,  and `view()`
+ *  overloads.
+ *
+ *  @subsection Missing Functionality
+ *
+ *  To simplify the implementation, the `index_gt` lacks endpoints to remove existing
+ *  vectors. That, however, is solved by `punned_gt`, which also adds automatic casting.
+ *
+ *  @subsection Ugly Implementation Parts
+ *
+ *  Internally, a number of `std::vector`-s is created, often `mutable`.
+ *
  */
 template <typename metric_at = ip_gt<float>,            //
           typename label_at = std::size_t,              //
@@ -747,18 +902,104 @@ class index_gt {
     using id_t = id_at;
     using allocator_t = allocator_at;
 
+    /// C++17 and newer version deprecate the `std::result_of`
     using distance_t =
+#if defined(USEARCH_IS_CPP17)
+        typename std::invoke_result<metric_t, scalar_t const*, scalar_t const*, std::size_t, std::size_t>::type;
+#else
         typename std::result_of<metric_t(scalar_t const*, scalar_t const*, std::size_t, std::size_t)>::type;
+#endif
+
+    using vector_view_t = span_gt<scalar_t const>;
+
+    struct member_ref_t {
+        misaligned_ref_gt<label_t> label;
+        vector_view_t vector;
+    };
+
+    struct member_cref_t {
+        label_t label;
+        vector_view_t vector;
+    };
+
+    template <typename ref_at> class member_iterator_gt {
+        using ref_t = ref_at;
+        index_gt& index_;
+        std::size_t offset_;
+
+        member_iterator_gt() noexcept {}
+        member_iterator_gt(index_gt& index, std::size_t offset) noexcept : index_(index), offset_(offset) {}
+
+      public:
+        using iterator_category = std::random_access_iterator_tag;
+        using value_type = ref_t;
+        using difference_type = std::ptrdiff_t;
+        using pointer = void;
+        using reference = ref_t;
+
+        reference operator*() const noexcept { return index_.node_with_id_(offset_); }
+        member_iterator_gt operator++(int) noexcept { return member_iterator_gt(index_, offset_ + 1); }
+        member_iterator_gt operator--(int) noexcept { return member_iterator_gt(index_, offset_ - 1); }
+        member_iterator_gt operator+(difference_type d) noexcept { return member_iterator_gt(index_, offset_ + d); }
+        member_iterator_gt operator-(difference_type d) noexcept { return member_iterator_gt(index_, offset_ - d); }
+
+        member_iterator_gt& operator++() noexcept {
+            offset_ += 1;
+            return *this;
+        }
+        member_iterator_gt& operator--() noexcept {
+            offset_ -= 1;
+            return *this;
+        }
+        member_iterator_gt& operator+=(difference_type d) noexcept {
+            offset_ += d;
+            return *this;
+        }
+        member_iterator_gt& operator-=(difference_type d) noexcept {
+            offset_ -= d;
+            return *this;
+        }
+        bool operator!=(member_iterator_gt const& other) noexcept {
+            return &index_ != &other.index_ || offset_ != other.offset_;
+        }
+    };
+
+    using member_iterator_t = member_iterator_gt<member_ref_t>;
+    using member_citerator_t = member_iterator_gt<member_cref_t>;
+
+    // STL compatibility:
+    using value_type = std::pair<label_t, distance_t>;
+    using allocator_type = allocator_t;
+    using size_type = std::size_t;
+    using difference_type = std::ptrdiff_t;
+    using reference = member_ref_t;
+    using const_reference = member_cref_t;
+    using pointer = void;
+    using const_pointer = void;
+    using iterator = member_iterator_t;
+    using const_iterator = member_citerator_t;
+    using reverse_iterator = std::reverse_iterator<member_iterator_t>;
+    using reverse_const_iterator = std::reverse_iterator<member_citerator_t>;
 
   private:
-    using neighbors_count_t = id_t;
+    using neighbors_count_t = std::uint32_t;
     using dim_t = std::uint32_t;
     using level_t = std::int32_t;
 
     using allocator_traits_t = std::allocator_traits<allocator_t>;
     using byte_t = typename allocator_t::value_type;
     static_assert(sizeof(byte_t) == 1, "Allocator must allocate separate addressable bytes");
-    static constexpr std::size_t base_level_multiple_k = 2;
+
+    /**
+     *  @brief  How much larger (number of neighbors per node) will the base level be
+     *          comapred to other levels.
+     */
+    static constexpr std::size_t base_level_multiple_() { return 2; }
+
+    /**
+     *  @brief  How many bytes of memory are needed to form the "head" of the node.
+     */
+    static constexpr std::size_t node_head_bytes_() { return sizeof(label_t) + sizeof(dim_t) + sizeof(level_t); }
 
     using visits_bitset_t = visits_bitset_gt<allocator_t>;
 
@@ -767,14 +1008,13 @@ class index_gt {
         std::size_t connectivity_max_base{};
         std::size_t neighbors_bytes{};
         std::size_t neighbors_base_bytes{};
-        std::size_t mutex_bytes{};
     };
     struct candidate_t {
-        distance_t first;
-        id_t second;
+        distance_t distance;
+        id_t id;
     };
     struct compare_by_distance_t {
-        inline bool operator()(candidate_t a, candidate_t b) const noexcept { return a.first < b.first; }
+        inline bool operator()(candidate_t a, candidate_t b) const noexcept { return a.distance < b.distance; }
     };
 
     using candidates_view_t = span_gt<candidate_t const>;
@@ -782,69 +1022,85 @@ class index_gt {
     using top_candidates_t = sorted_buffer_gt<candidate_t, compare_by_distance_t, candidates_allocator_t>;
     using next_candidates_t = max_heap_gt<candidate_t, compare_by_distance_t, candidates_allocator_t>;
 
-    struct neighbors_ref_t {
-        neighbors_count_t& count_;
-        id_t* neighbors_{};
-
-        inline neighbors_ref_t(byte_t* tape) noexcept
-            : count_(*(neighbors_count_t*)tape), neighbors_((neighbors_count_t*)tape + 1) {}
-        inline id_t* begin() noexcept { return neighbors_; }
-        inline id_t* end() noexcept { return neighbors_ + count_; }
-        inline id_t const* begin() const noexcept { return neighbors_; }
-        inline id_t const* end() const noexcept { return neighbors_ + count_; }
-        inline id_t& operator[](std::size_t i) noexcept { return neighbors_[i]; }
-        inline id_t operator[](std::size_t i) const noexcept { return neighbors_[i]; }
-        inline std::size_t size() const noexcept { return count_; }
-        inline void clear() noexcept { count_ = 0u; }
-        inline void push_back(id_t id) noexcept { neighbors_[count_] = id, count_++; }
-    };
-
-#if defined(WINDOWS)
-#pragma pack(push, 1) // Pack struct members on 1-byte alignment
-#endif
-    struct usearch_pack_m node_head_t {
-        label_t label;
-        dim_t dim;
-        level_t level;
-        // Variable length array, that has multiple similarly structured segments.
-        // Each starts with a `neighbors_count_t` and is followed by such number of `id_t`s.
-        byte_t neighbors[1];
-    };
-#if defined(WINDOWS)
-#pragma pack(pop) // Reset alignment to default
-#endif
-
-    static constexpr std::size_t head_bytes_k = sizeof(label_t) + sizeof(dim_t) + sizeof(level_t);
-
-    struct node_t {
+    /**
+     *  @brief  A loosely-structured handle for every node. One such node is created for every vector.
+     *          To minimize memory usage and maximize the number of entries per cache-line, it only
+     *          stores to pointers. To reinterpret those into a structured `node_t` more
+     *          information is needed from the parent `index_gt`.
+     */
+    class node_t {
         byte_t* tape_{};
         scalar_t* vector_{};
 
+      public:
         explicit node_t(byte_t* tape, scalar_t* vector) noexcept : tape_(tape), vector_(vector) {}
+        byte_t* tape() const noexcept { return tape_; }
+        scalar_t* vector() const noexcept { return vector_; }
+        byte_t* neighbors_tape() const noexcept { return tape_ + node_head_bytes_(); }
 
         node_t() = default;
         node_t(node_t const&) = default;
         node_t& operator=(node_t const&) = default;
+
+        label_t label() const noexcept { return misaligned_load<label_t>(tape_); }
+        dim_t dim() const noexcept { return misaligned_load<dim_t>(tape_ + sizeof(label_t)); }
+        level_t level() const noexcept { return misaligned_load<level_t>(tape_ + sizeof(label_t) + sizeof(dim_t)); }
+
+        void label(label_t v) noexcept { return misaligned_store<label_t>(tape_, v); }
+        void dim(dim_t v) noexcept { return misaligned_store<dim_t>(tape_ + sizeof(label_t), v); }
+        void level(level_t v) noexcept { return misaligned_store<level_t>(tape_ + sizeof(label_t) + sizeof(dim_t), v); }
+
+        operator vector_view_t() const noexcept { return {vector(), dim()}; }
+        vector_view_t vector_view() const noexcept { return {vector(), dim()}; }
+        member_ref_t ref() noexcept { return {label(), vector_view()}; }
+        member_cref_t cref() const noexcept { return {label(), vector_view()}; }
     };
 
-    class node_ref_t {
-        mutex_t* mutex_{};
+    /**
+     *  @brief  A slice of the node's tape, containing a the list of neighbors
+     *          for a node in a single graph level. It's pre-allocated to fit
+     *          as many neighbors IDs, as may be needed at the target level,
+     *          and starts with a single integer `neighbors_count_t` counter.
+     */
+    class neighbors_ref_t {
+        byte_t* tape_;
+
+        static constexpr std::size_t shift(std::size_t i = 0) { return sizeof(neighbors_count_t) + sizeof(id_t) * i; }
 
       public:
-        node_head_t& head{};
-        scalar_t* vector{};
-
-        inline node_ref_t(mutex_t& m, node_head_t& h, scalar_t* s) noexcept : mutex_(&m), head(h), vector(s) {}
-        inline lock_t lock() const noexcept { return mutex_ ? lock_t{*mutex_} : lock_t{}; }
-        inline operator node_t() const noexcept { return node_t{mutex_ ? (byte_t*)mutex_ : (byte_t*)&head, vector}; }
+        neighbors_ref_t(byte_t* tape) noexcept : tape_(tape) {}
+        misaligned_ptr_gt<id_t> begin() noexcept { return tape_ + shift(); }
+        misaligned_ptr_gt<id_t> end() noexcept { return begin() + size(); }
+        misaligned_ptr_gt<id_t const> begin() const noexcept { return tape_ + shift(); }
+        misaligned_ptr_gt<id_t const> end() const noexcept { return begin() + size(); }
+        id_t operator[](std::size_t i) const noexcept { return misaligned_load<id_t>(tape_ + shift(i)); }
+        std::size_t size() const noexcept { return misaligned_load<neighbors_count_t>(tape_); }
+        void clear() noexcept { misaligned_store<neighbors_count_t>(tape_, 0); }
+        void push_back(id_t id) noexcept {
+            neighbors_count_t n = misaligned_load<neighbors_count_t>(tape_);
+            misaligned_store<id_t>(tape_ + shift(n), id);
+            misaligned_store<neighbors_count_t>(tape_, n + 1);
+        }
     };
 
+    /**
+     *  @brief  A package of all kinds of temporary data-structures, that the threads
+     *          would reuse to process requests. Similar to having all of those as
+     *          separate `thread_local` global variables.
+     */
     struct usearch_align_m thread_context_t {
-        top_candidates_t top_candidates;
-        next_candidates_t next_candidates;
-        visits_bitset_t visits;
-        std::default_random_engine level_generator;
-        metric_t metric;
+        top_candidates_t top_candidates{};
+        next_candidates_t next_candidates{};
+        visits_bitset_t visits{};
+        std::default_random_engine level_generator{};
+        metric_t metric{};
+        std::size_t iteration_cycles{};
+        std::size_t measurements_count{};
+
+        inline distance_t measure(vector_view_t a, vector_view_t b) noexcept {
+            measurements_count++;
+            return metric(a.data(), b.data(), a.size(), b.size());
+        }
     };
 
     config_t config_{};
@@ -856,12 +1112,15 @@ class index_gt {
     usearch_align_m mutable std::atomic<std::size_t> capacity_{};
     usearch_align_m mutable std::atomic<std::size_t> size_{};
 
-    mutex_t global_mutex_{};
+    /// @brief  Controls access to `max_level_` and `entry_id_`.
+    ///         If any thread is updating those values, no other threads can `add()` or `search()`.
+    std::mutex global_mutex_{};
     level_t max_level_{};
     id_t entry_id_{};
 
     using node_allocator_t = typename allocator_traits_t::template rebind_alloc<node_t>;
     std::vector<node_t, node_allocator_t> nodes_{};
+    mutable visits_bitset_t nodes_mutexes_{};
 
     using thread_context_allocator_t = typename allocator_traits_t::template rebind_alloc<thread_context_t>;
     mutable std::vector<thread_context_t, thread_context_allocator_t> thread_contexts_{};
@@ -870,16 +1129,15 @@ class index_gt {
     std::size_t connectivity() const noexcept { return config_.connectivity; }
     std::size_t capacity() const noexcept { return capacity_; }
     std::size_t size() const noexcept { return size_; }
-    std::size_t max_threads_add() const noexcept { return config_.max_threads_add; }
+    std::size_t max_level() const noexcept { return static_cast<std::size_t>(max_level_); }
+    config_t const& config() const { return config_; }
     bool is_immutable() const noexcept { return viewed_file_descriptor_ != 0; }
-    bool synchronize() const noexcept { return config_.max_threads_add > 1; }
 
     index_gt(config_t config = {}, metric_t metric = {}, allocator_t allocator = {}) noexcept(false)
-        : config_(config), metric_(metric), allocator_(allocator) {
+        : config_(normalize(config)), metric_(metric), allocator_(allocator) {
 
         // Externally defined hyper-parameters:
-        config_.expansion_add = (std::max)(config_.expansion_add, config_.connectivity);
-        pre_ = precompute(config);
+        pre_ = precompute_(config);
 
         // Configure initial empty state:
         size_ = 0u;
@@ -888,12 +1146,15 @@ class index_gt {
         viewed_file_descriptor_ = 0;
 
         // Dynamic memory:
-        thread_contexts_.resize((std::max)(config.max_threads_search, config.max_threads_add));
+        thread_contexts_.resize(config.max_threads());
         for (thread_context_t& context : thread_contexts_)
             context.metric = metric;
         reserve(config.max_elements);
     }
 
+    /**
+     *  @brief  Clones the structure with the same hyper-parameters, but without contents.
+     */
     index_gt fork() noexcept(false) { return {config_, metric_, allocator_}; }
 
     ~index_gt() noexcept { clear(); }
@@ -907,15 +1168,22 @@ class index_gt {
 
 #pragma region Adjusting Configuration
 
+    /**
+     *  @brief  Erases all the vectors from the index.
+     *          Will change `size()` to zero, but will keep the same `capacity()`.
+     */
     void clear() noexcept {
         std::size_t n = size_;
         for (std::size_t i = 0; i != n; ++i)
-            node_free(i);
+            node_free_(i);
         size_ = 0;
         max_level_ = -1;
         entry_id_ = 0u;
     }
 
+    /**
+     *  @brief  Swaps the underlying memory buffers and thread contexts.
+     */
     void swap(index_gt& other) noexcept {
         std::swap(config_, other.config_);
         std::swap(metric_, other.metric_);
@@ -936,123 +1204,259 @@ class index_gt {
         other.size_ = size;
     }
 
+    /**
+     *  @brief  Increases the `capacity()` of the index to allow adding more vectors.
+     */
     void reserve(std::size_t new_capacity) noexcept(false) {
 
         assert_m(new_capacity >= size_, "Can't drop existing values");
         nodes_.resize(new_capacity);
+        nodes_mutexes_ = visits_bitset_t(new_capacity);
         for (thread_context_t& context : thread_contexts_)
             context.visits = visits_bitset_t(new_capacity);
 
         capacity_ = new_capacity;
     }
 
-    static config_t optimize(config_t const& config) noexcept {
-        precomputed_constants_t pre = precompute(config);
-        std::size_t bytes_per_node_base = head_bytes_k + pre.neighbors_base_bytes + pre.mutex_bytes;
+    /**
+     *  @brief  Optimizes configuration options to fit the maximum number
+     *          of neighbors in CPU-cache-aligned buffers.
+     */
+    static config_t optimize(config_t config) noexcept {
+        precomputed_constants_t pre = precompute_(config);
+        std::size_t bytes_per_node_base = node_head_bytes_() + pre.neighbors_base_bytes;
         std::size_t rounded_size = divide_round_up<64>(bytes_per_node_base) * 64;
         std::size_t added_connections = (rounded_size - rounded_size) / sizeof(id_t);
-        config_t result = config;
-        result.connectivity = config.connectivity + added_connections / base_level_multiple_k;
-        return result;
+        config.connectivity = config.connectivity + added_connections / base_level_multiple_();
+        return config;
+    }
+
+    /**
+     *  @brief  Validates/normalizes the configuration options and throws an exception
+     *          if those are incorrect.
+     */
+    static config_t normalize(config_t config) noexcept {
+        config.expansion_add = (std::max<std::size_t>)(config.expansion_add, config.connectivity);
+        config.max_threads_add = (std::max<std::size_t>)(1u, config.max_threads_add);
+        config.max_threads_search = (std::max<std::size_t>)(1u, config.max_threads_search);
+        return config;
     }
 
 #pragma endregion
 
 #pragma region Construction and Search
 
-    id_t add(                                                //
-        label_t new_label, span_gt<scalar_t const> new_span, //
-        std::size_t thread_idx = 0, bool store_vector = true) {
+    struct add_result_t {
+        std::size_t new_size{};
+        std::size_t cycles{};
+        std::size_t measurements{};
+        id_t id{};
+    };
+
+    struct search_result_t {
+        member_cref_t member;
+        distance_t distance;
+    };
+
+    class search_results_t {
+        index_gt const& index_;
+        top_candidates_t& top_;
+
+        friend class index_gt;
+        inline search_results_t(index_gt const& index, top_candidates_t& top) noexcept : index_(index), top_(top) {}
+
+      public:
+        std::size_t count{};
+        std::size_t cycles{};
+        std::size_t measurements{};
+
+        inline search_results_t(search_results_t&&) = default;
+        inline search_results_t& operator=(search_results_t&&) = default;
+
+        inline operator std::size_t() const noexcept { return count; }
+        inline std::size_t size() const noexcept { return count; }
+        inline search_result_t operator[](std::size_t i) const noexcept {
+            candidate_t const* top_ordered = top_.data();
+            return {index_.node_with_id_(top_ordered[i].id).cref(), top_ordered[i].distance};
+        }
+        inline std::size_t dump_to(label_t* labels, distance_t* distances) const noexcept {
+            for (std::size_t i = 0; i != count; ++i) {
+                search_result_t result = operator[](i);
+                labels[i] = result.member.label;
+                distances[i] = result.distance;
+            }
+            return count;
+        }
+    };
+
+    /**
+     *  @brief Inserts a new vector into the index. Thread-safe.
+     *
+     *  @param[in] label External identifier/name/descriptor for the vector.
+     *  @param[in] vector Contiguous range of scalars forming a vector view.
+     *  @param[in] config Configuration options for this specific operation.
+     */
+    add_result_t add(label_t label, vector_view_t vector, add_config_t config = {}) noexcept(false) {
 
         assert_m(!is_immutable(), "Can't add to an immutable index");
-        id_t new_id = static_cast<id_t>(size_.fetch_add(1));
-        scalar_t const* new_vector = new_span.data();
-        std::size_t new_dim = new_span.size();
-
-        // Determining how much memory to allocate depends on the target level.
-        lock_t new_level_lock(global_mutex_);
-        level_t max_level = max_level_;
-        thread_context_t& context = thread_contexts_[thread_idx];
-        level_t new_target_level = choose_random_level(context.level_generator);
-        if (new_target_level <= max_level)
+        add_result_t result;
+        result.new_size = size_.fetch_add(1);
+        id_t new_id = result.id = static_cast<id_t>(result.new_size);
+
+        // Determining how much memory to allocate depends on the target level
+        std::unique_lock<std::mutex> new_level_lock(global_mutex_);
+        level_t max_level = max_level_; // Copy under lock
+        id_t entry_id = entry_id_;      // Copy under lock
+        thread_context_t& context = thread_contexts_[config.thread];
+        level_t target_level = choose_random_level_(context.level_generator);
+        if (target_level <= max_level)
             new_level_lock.unlock();
 
         // Allocate the neighbors
-        node_ref_t new_node = node_malloc(new_label, new_vector, new_dim, new_target_level, store_vector);
-        lock_t new_lock = new_node.lock();
-        nodes_[new_id] = new_node;
+        nodes_[result.new_size] = node_malloc_(label, vector, target_level, config.store_vector);
+        node_lock_t new_lock = node_lock_(new_id);
+        result.new_size++;
 
         // Do nothing for the first element
         if (!new_id) {
-            max_level_ = new_target_level;
-            return new_id;
+            entry_id_ = new_id;
+            max_level_ = target_level;
+            return result;
         }
 
+        // Pull stats
+        result.measurements = context.measurements_count;
+        result.cycles = context.iteration_cycles;
+
         // Go down the level, tracking only the closest match
-        id_t closest_id = search_for_one(entry_id_, new_vector, new_dim, max_level, new_target_level, context);
+        id_t closest_id = search_for_one_(entry_id, vector, max_level, target_level, context);
 
-        // From `new_target_level` down perform proper extensive search.
-        for (level_t level = (std::min)(new_target_level, max_level); level >= 0; level--) {
-            search_to_insert(closest_id, new_vector, new_dim, level, context);
-            closest_id = connect_new_element(new_id, level, context);
+        // From `target_level` down perform proper extensive search
+        for (level_t level = (std::min)(target_level, max_level); level >= 0; level--) {
+            search_to_insert_(closest_id, vector, level, context);
+            closest_id = connect_new_node_(new_id, level, context);
         }
 
-        // Releasing lock for the maximum level
-        if (new_target_level > max_level) {
+        // Normalize stats
+        result.measurements = context.measurements_count - result.measurements;
+        result.cycles = context.iteration_cycles - result.cycles;
+
+        // Updating the entry point if needed
+        if (target_level > max_level) {
             entry_id_ = new_id;
-            max_level_ = new_target_level;
+            max_level_ = target_level;
         }
-        return new_id;
+        return result;
     }
 
-    template <typename label_and_distance_callback_at>
-    void search(                                                //
-        span_gt<scalar_t const> query_span, std::size_t wanted, //
-        label_and_distance_callback_at&& callback, std::size_t thread_idx = 0) const {
+    /**
+     *  @brief Searches for the closest members to the given ::query. Thread-safe.
+     *
+     *  @param[in] query Contiguous range of scalars forming a vector view.
+     *  @param[in] wanted The upper bound for the number of results to return.
+     *  @param[in] config Configuration options for this specific operation.
+     *  @return Smart object referencing temporary memory. Valid until next `search()` or `add()`.
+     */
+    search_results_t search(                     //
+        vector_view_t query, std::size_t wanted, //
+        search_config_t config = {}) const noexcept(false) {
 
+        thread_context_t& context = thread_contexts_[config.thread];
+        top_candidates_t& top = context.top_candidates;
+        search_results_t result{*this, top};
         if (!size_)
-            return;
+            return result;
 
-        scalar_t const* query_vec = query_span.data();
-        std::size_t query_dim = query_span.size();
+        // Go down the level, tracking only the closest match
+        result.measurements = context.measurements_count;
+        result.cycles = context.iteration_cycles;
+
+        if (config.exact) {
+            search_exact_(query, wanted, context);
+        } else {
+            id_t closest_id = search_for_one_(entry_id_, query, max_level_, 0, context);
+            std::size_t expansion = (std::max)(config_.expansion_search, wanted);
+            // For bottom layer we need a more optimized procedure
+            search_to_find_in_base_(closest_id, query, expansion, context);
+        }
+
+        top.sort_ascending();
+        top.shrink(wanted);
+
+        // Normalize stats
+        result.measurements = context.measurements_count - result.measurements;
+        result.cycles = context.iteration_cycles - result.cycles;
+        result.count = top.size();
+        return result;
+    }
+
+    search_results_t search_around(                         //
+        id_t hint, vector_view_t query, std::size_t wanted, //
+        search_config_t config = {}) const noexcept(false) {
+
+        thread_context_t& context = thread_contexts_[config.thread];
+        top_candidates_t& top = context.top_candidates;
+        search_results_t result{*this, top};
+        if (!size_)
+            return result;
 
         // Go down the level, tracking only the closest match
-        thread_context_t& context = thread_contexts_[thread_idx];
-        id_t closest_id = search_for_one(entry_id_, query_vec, query_dim, max_level_, 0, context);
+        result.measurements = context.measurements_count;
+        result.cycles = context.iteration_cycles;
 
-        // For bottom layer we need a more optimized procedure
         std::size_t expansion = (std::max)(config_.expansion_search, wanted);
-        search_to_find_in_base(closest_id, query_vec, query_dim, expansion, context);
-        context.top_candidates.sort_ascending();
-        context.top_candidates.shrink(wanted);
-
-        candidate_t const* top = context.top_candidates.data();
-        for (std::size_t i = 0; i < context.top_candidates.size(); ++i)
-            callback(node(top[i].second).head.label, top[i].first);
-    }
-
-    std::size_t search(                                         //
-        span_gt<scalar_t const> query_span, std::size_t wanted, //
-        label_t* matches, distance_t* distances,                //
-        std::size_t thread_idx = 0) const {
-
-        std::size_t found = 0;
-        auto callback = [&](label_t label, distance_t distance) noexcept {
-            if (matches)
-                matches[found] = label;
-            if (distances)
-                distances[found] = distance;
-            ++found;
-        };
-        search(query_span, wanted, callback, thread_idx);
-        return found;
+        search_to_find_in_base_(hint, query, expansion, context);
+        top.sort_ascending();
+        top.shrink(wanted);
+
+        // Normalize stats
+        result.measurements = context.measurements_count - result.measurements;
+        result.cycles = context.iteration_cycles - result.cycles;
+        result.count = top.size();
+        return result;
+    }
+
+    struct stats_t {
+        std::size_t nodes;
+        std::size_t edges;
+        std::size_t max_edged;
+    };
+
+    stats_t stats() const noexcept {
+        stats_t result{};
+        result.nodes = nodes_.size();
+        for (std::size_t i = 0; i != result.nodes; ++i) {
+            node_t node = node_with_id_(i);
+            std::size_t max_edges = node.level() * config_.connectivity + base_level_multiple_() * config_.connectivity;
+            std::size_t edges = 0;
+            for (level_t level = 0; level != node.level(); ++level)
+                edges += neighbors_(node, level).size();
+
+            result.edges += edges;
+            result.max_edges += max_edges;
+        }
+        return result;
+    }
+
+    stats_t stats(std::size_t level) const noexcept {
+        stats_t result{};
+        result.nodes = nodes_.size();
+        for (std::size_t i = 0; i != result.nodes; ++i) {
+            node_t node = node_with_id_(i);
+            if (node.level() >= level)
+                result.edges += neighbors_(node, level).size();
+        }
+        std::size_t max_edges_per_node = level ? config_.connectivity : base_level_multiple_() * config_.connectivity;
+        result.max_edges = result.nodes * max_edges_per_node;
+        return result;
     }
 
 #pragma endregion
 
 #pragma region Serialization
 
-    struct state_t {
+  private:
+    struct serialized_state_t {
         // Check compatibility
         std::uint64_t bytes_per_label{};
         std::uint64_t bytes_per_id{};
@@ -1064,12 +1468,15 @@ class index_gt {
         std::uint64_t max_level{};
     };
 
+  public:
     /**
-     *  Compatibility: Linux, MacOS, Windows.
+     *  @brief  Saves serialized binary index representation to disk,
+     *          co-locating vectors and neighbors lists.
+     *          Available on Linux, MacOS, Windows.
      */
     void save(char const* file_path) const noexcept(false) {
 
-        state_t state;
+        serialized_state_t state;
         // Check compatibility
         state.bytes_per_label = sizeof(label_t);
         state.bytes_per_id = sizeof(id_t);
@@ -1083,53 +1490,52 @@ class index_gt {
         if (!file)
             throw std::runtime_error(std::strerror(errno));
 
-        // Write the header
-        {
-            std::size_t written = std::fwrite(&state, sizeof(state), 1, file);
+        auto write_chunk = [&](void* begin, std::size_t length) {
+            std::size_t written = std::fwrite(begin, length, 1, file);
             if (!written) {
                 std::fclose(file);
                 throw std::runtime_error(std::strerror(errno));
             }
-        }
+        };
+
+        // Write the header
+        write_chunk(&state, sizeof(state));
 
         // Serialize nodes one by one
         for (std::size_t i = 0; i != state.size; ++i) {
-            node_ref_t node_ref = node(static_cast<id_t>(i));
-            std::size_t bytes_to_dump = node_dump_size(node_ref.head.dim, node_ref.head.level);
-            std::size_t bytes_in_vec = node_ref.head.dim * sizeof(scalar_t);
-            // Dump just neighbors, as vectors may be in a disjoint location
-            std::size_t written = std::fwrite(&node_ref.head, bytes_to_dump - bytes_in_vec, 1, file);
-            if (!written) {
-                std::fclose(file);
-                throw std::runtime_error(std::strerror(errno));
-            }
-            // Dump the vector
-            written = std::fwrite(node_ref.vector, bytes_in_vec, 1, file);
-            if (!written) {
-                std::fclose(file);
-                throw std::runtime_error(std::strerror(errno));
-            }
+            node_t node = node_with_id_(i);
+            std::size_t node_bytes = node_bytes_(node);
+            std::size_t node_vector_bytes = node_vector_bytes_(node);
+            // Dump neighbors and vectors, as vectors may be in a disjoint location
+            write_chunk(node.tape(), node_bytes - node_vector_bytes);
+            write_chunk(node.vector(), node_vector_bytes);
         }
 
         std::fclose(file);
     }
 
     /**
-     *  Compatibility: Linux, MacOS, Windows.
+     *  @brief  Loads the serialized binary index representation from disk,
+     *          copying both vectors and neighbors lists into RAM.
+     *          Available on Linux, MacOS, Windows.
      */
     void load(char const* file_path) noexcept(false) {
-        state_t state;
+        serialized_state_t state;
         std::FILE* file = std::fopen(file_path, "r");
         if (!file)
             throw std::runtime_error(std::strerror(errno));
 
-        // Read the header
-        {
-            std::size_t read = std::fread(&state, sizeof(state), 1, file);
+        auto read_chunk = [&](void* begin, std::size_t length) {
+            std::size_t read = std::fread(begin, length, 1, file);
             if (!read) {
                 std::fclose(file);
                 throw std::runtime_error(std::strerror(errno));
             }
+        };
+
+        // Read the header
+        {
+            read_chunk(&state, sizeof(state));
             if (state.bytes_per_label != sizeof(label_t)) {
                 std::fclose(file);
                 throw std::runtime_error("Incompatible label type!");
@@ -1141,7 +1547,7 @@ class index_gt {
 
             config_.connectivity = state.connectivity;
             config_.max_elements = state.size;
-            pre_ = precompute(config_);
+            pre_ = precompute_(config_);
             reserve(state.size);
             size_ = state.size;
             max_level_ = static_cast<level_t>(state.max_level);
@@ -1150,22 +1556,17 @@ class index_gt {
 
         // Load nodes one by one
         for (std::size_t i = 0; i != state.size; ++i) {
-            node_head_t head;
-            std::size_t read = std::fread(&head, head_bytes_k, 1, file);
-            if (!read) {
-                std::fclose(file);
-                throw std::runtime_error(std::strerror(errno));
-            }
-
-            std::size_t bytes_to_dump = node_dump_size(head.dim, head.level);
-            node_ref_t node_ref = node_malloc(head.label, nullptr, head.dim, head.level, true);
-            read = std::fread((byte_t*)&node_ref.head + head_bytes_k, bytes_to_dump - head_bytes_k, 1, file);
-            if (!read) {
-                std::fclose(file);
-                throw std::runtime_error(std::strerror(errno));
-            }
-
-            nodes_[i] = node_ref;
+            label_t label;
+            dim_t dim;
+            level_t level;
+            read_chunk(&label, sizeof(label));
+            read_chunk(&dim, sizeof(dim));
+            read_chunk(&level, sizeof(level));
+
+            std::size_t node_bytes = node_bytes_(dim, level);
+            node_t node = node_malloc_(label, {nullptr, dim}, level, true);
+            read_chunk(node.tape() + node_head_bytes_(), node_bytes - node_head_bytes_());
+            nodes_[i] = node;
         }
 
         std::fclose(file);
@@ -1173,13 +1574,15 @@ class index_gt {
     }
 
     /**
-     *  Compatibility: Linux, MacOS.
+     *  @brief  Memory-maps the serialized binary index representation from disk,
+     *          @b without copying the vectors and neighbors lists into RAM.
+     *          Available on Linux, MacOS, but @b not on Windows.
      */
     void view(char const* file_path) noexcept(false) {
-#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
+#if defined(USEARCH_IS_WINDOWS)
         throw std::logic_error("Memory-mapping is not yet available for Windows");
 #else
-        state_t state;
+        serialized_state_t state;
         int open_flags = O_RDONLY;
 #if __linux__
         open_flags |= O_NOATIME;
@@ -1216,7 +1619,7 @@ class index_gt {
             config_.connectivity = state.connectivity;
             config_.max_elements = state.size;
             config_.max_threads_add = 0;
-            pre_ = precompute(config_);
+            pre_ = precompute_(config_);
             reserve(state.size);
             size_ = state.size;
             max_level_ = static_cast<level_t>(state.max_level);
@@ -1226,13 +1629,15 @@ class index_gt {
         // Locate every node packed into file
         std::size_t progress = sizeof(state);
         for (std::size_t i = 0; i != state.size; ++i) {
-            node_head_t const& head = *(node_head_t const*)(file + progress);
-            std::size_t bytes_to_dump = node_dump_size(head.dim, head.level);
-            std::size_t bytes_in_vec = head.dim * sizeof(scalar_t);
-            nodes_[i].tape_ = (byte_t*)(file + progress);
-            nodes_[i].vector_ = (scalar_t*)(file + progress + bytes_to_dump - bytes_in_vec);
-            progress += bytes_to_dump;
-            max_level_ = (std::max)(max_level_, head.level);
+            byte_t* tape = (byte_t*)(file + progress);
+            dim_t dim = misaligned_load<dim_t>(tape + sizeof(label_t));
+            level_t level = misaligned_load<level_t>(tape + sizeof(label_t) + sizeof(dim_t));
+
+            std::size_t node_bytes = node_bytes_(dim, level);
+            std::size_t node_vector_bytes = dim * sizeof(scalar_t);
+            nodes_[i] = node_t{tape, (scalar_t*)(tape + node_bytes - node_vector_bytes)};
+            progress += node_bytes;
+            max_level_ = (std::max)(max_level_, level);
         }
 
         viewed_file_descriptor_ = descriptor;
@@ -1242,124 +1647,114 @@ class index_gt {
 #pragma endregion
 
   private:
-    inline static precomputed_constants_t precompute(config_t const& config) noexcept {
+    inline static precomputed_constants_t precompute_(config_t const& config) noexcept {
         precomputed_constants_t pre;
-        pre.connectivity_max_base = config.connectivity * base_level_multiple_k;
+        pre.connectivity_max_base = config.connectivity * base_level_multiple_();
         pre.inverse_log_connectivity = 1.0 / std::log(static_cast<double>(config.connectivity));
         pre.neighbors_bytes = config.connectivity * sizeof(id_t) + sizeof(neighbors_count_t);
         pre.neighbors_base_bytes = pre.connectivity_max_base * sizeof(id_t) + sizeof(neighbors_count_t);
-        pre.mutex_bytes = sizeof(mutex_t) * (config.max_threads_add > 1);
         return pre;
     }
 
-    inline std::size_t node_dump_size(dim_t dim, level_t level) const noexcept {
-        return head_bytes_k + pre_.neighbors_base_bytes + pre_.neighbors_bytes * level + sizeof(scalar_t) * dim;
+    inline std::size_t node_bytes_(node_t node) const noexcept { return node_bytes_(node.dim(), node.level()); }
+    inline std::size_t node_bytes_(dim_t dim, level_t level) const noexcept {
+        return node_head_bytes_() + pre_.neighbors_base_bytes + pre_.neighbors_bytes * level + sizeof(scalar_t) * dim;
     }
 
-    void node_free(std::size_t id) noexcept {
+    inline bool node_stored_(node_t node) const noexcept {
+        std::size_t levels_bytes = pre_.neighbors_base_bytes + pre_.neighbors_bytes * node.level();
+        return (node.tape() + node_head_bytes_() + levels_bytes) == (byte_t*)node.vector();
+    }
+
+    inline std::size_t node_vector_bytes_(dim_t dim) const noexcept { return dim * sizeof(scalar_t); }
+    inline std::size_t node_vector_bytes_(node_t node) const noexcept { return node_vector_bytes_(node.dim()); }
+
+    void node_free_(std::size_t id) noexcept {
 
         if (viewed_file_descriptor_ != 0)
             return;
 
-        // This function is rarely called and can be as expensive as needed for higher space-efficiency.
         node_t& node = nodes_[id];
-        if (!node.tape_)
-            return;
-
-        node_head_t const& head = *(node_head_t const*)(node.tape_ + pre_.mutex_bytes);
-        std::size_t levels_bytes = pre_.neighbors_base_bytes + pre_.neighbors_bytes * head.level;
-        bool store_vector = (byte_t*)(node.tape_ + pre_.mutex_bytes + head_bytes_k + levels_bytes) == //
-                            (byte_t*)(node.vector_);
-        std::size_t node_bytes =          //
-            pre_.mutex_bytes +            // Optional concurrency-control
-            head_bytes_k + levels_bytes + // Obligatory neighborhood index
-            head.dim * store_vector       // Optional vector copy
-            ;
-
-        allocator_t{}.deallocate(node.tape_, node_bytes);
+        std::size_t node_bytes = node_bytes_(node) - node_vector_bytes_(node) * !node_stored_(node);
+        allocator_t{}.deallocate(node.tape(), node_bytes);
         node = node_t{};
     }
 
-    node_ref_t node_malloc(                                     //
-        label_t label, scalar_t const* vector, std::size_t dim, //
-        level_t level, bool store_vector = true) noexcept(false) {
+    node_t node_malloc_(label_t label, vector_view_t vector, level_t level, bool store_vector) noexcept(false) {
 
-        // This function is rarely called and can be as expensive as needed for higher space-efficiency.
-        std::size_t levels_bytes = pre_.neighbors_base_bytes + pre_.neighbors_bytes * level;
-        std::size_t node_bytes =                  //
-            pre_.mutex_bytes +                    // Optional concurrency-control
-            head_bytes_k + levels_bytes +         // Obligatory neighborhood index
-            sizeof(scalar_t) * dim * store_vector // Optional vector copy
-            ;
+        std::size_t dim = vector.size();
+        std::size_t stored_vector_bytes = node_vector_bytes_(dim) * store_vector;
+        std::size_t node_bytes = node_bytes_(dim, level) - node_vector_bytes_(dim) * !store_vector;
 
         byte_t* data = (byte_t*)allocator_t{}.allocate(node_bytes);
         assert_m(data, "Not enough memory for links");
-
-        mutex_t* mutex = synchronize() ? (mutex_t*)data : nullptr;
-        scalar_t* scalars = store_vector //
-                                ? (scalar_t*)(data + pre_.mutex_bytes + head_bytes_k + levels_bytes)
-                                : (scalar_t*)(vector);
-
         std::memset(data, 0, node_bytes);
-        std::memcpy(scalars, vector, sizeof(scalar_t) * dim * (store_vector && vector));
-
-        node_head_t& head = *(node_head_t*)(data + pre_.mutex_bytes);
-        head.label = label;
-        head.dim = static_cast<dim_t>(dim);
-        head.level = level;
+        if (vector.data())
+            std::memcpy(data + node_bytes - stored_vector_bytes, vector.data(), stored_vector_bytes);
 
-        return {*mutex, head, scalars};
+        scalar_t* scalars = store_vector //
+                                ? (scalar_t*)(data + node_bytes - stored_vector_bytes)
+                                : (scalar_t*)(vector.data());
+
+        node_t node{data, scalars};
+        node.label(label);
+        node.dim(static_cast<dim_t>(dim));
+        node.level(level);
+        return node;
     }
 
-    inline node_ref_t node(id_t id) const noexcept { return node(nodes_[id]); }
+    inline node_t node_with_id_(std::size_t idx) const noexcept { return nodes_[idx]; }
+    inline neighbors_ref_t neighbors_base_(node_t node) const noexcept { return {node.neighbors_tape()}; }
 
-    inline node_ref_t node(node_t node) const noexcept {
-        byte_t* data = node.tape_;
-        mutex_t* mutex = synchronize() ? (mutex_t*)data : nullptr;
-        node_head_t& head = *(node_head_t*)(data + pre_.mutex_bytes);
-        scalar_t* scalars = node.vector_;
+    inline neighbors_ref_t neighbors_non_base_(node_t node, level_t level) const noexcept {
+        return {node.neighbors_tape() + pre_.neighbors_base_bytes + (level - 1) * pre_.neighbors_bytes};
+    }
 
-        return {*mutex, head, scalars};
+    inline neighbors_ref_t neighbors_(node_t node, level_t level) const noexcept {
+        return level ? neighbors_non_base_(node, level) : neighbors_base_(node);
     }
 
-    inline neighbors_ref_t neighbors_base(node_ref_t node) const noexcept { return {node.head.neighbors}; }
+    struct node_lock_t {
+        visits_bitset_t& bitset;
+        std::size_t idx;
 
-    inline neighbors_ref_t neighbors_non_base(node_ref_t node, level_t level) const noexcept {
-        return {node.head.neighbors + pre_.neighbors_base_bytes + (level - 1) * pre_.neighbors_bytes};
-    }
+        inline ~node_lock_t() noexcept { bitset.atomic_reset(idx); }
+    };
 
-    inline neighbors_ref_t neighbors(node_ref_t node, level_t level) const noexcept {
-        return level ? neighbors_non_base(node, level) : neighbors_base(node);
+    inline node_lock_t node_lock_(std::size_t idx) const noexcept {
+        while (nodes_mutexes_.atomic_set(idx))
+            ;
+        return {nodes_mutexes_, idx};
     }
 
-    id_t connect_new_element(id_t new_id, level_t level, thread_context_t& context) noexcept(false) {
+    id_t connect_new_node_(id_t new_id, level_t level, thread_context_t& context) noexcept(false) {
 
-        node_ref_t new_node = node(new_id);
+        node_t new_node = node_with_id_(new_id);
         top_candidates_t& top = context.top_candidates;
         std::size_t const connectivity_max = level ? config_.connectivity : pre_.connectivity_max_base;
 
         // Outgoing links from `new_id`:
-        neighbors_ref_t new_neighbors = neighbors(new_node, level);
+        neighbors_ref_t new_neighbors = neighbors_(new_node, level);
         {
             assert_m(!new_neighbors.size(), "The newly inserted element should have blank link list");
-            candidates_view_t top_view = refine(top, config_.connectivity, context);
+            candidates_view_t top_view = refine_(top, config_.connectivity, context);
 
             for (std::size_t idx = 0; idx != top_view.size(); idx++) {
                 assert_m(!new_neighbors[idx], "Possible memory corruption");
-                assert_m(level <= node(top_view[idx].second).head.level, "Linking to missing level");
-                new_neighbors.push_back(top_view[idx].second);
+                assert_m(level <= node_with_id_(top_view[idx].id).level(), "Linking to missing level");
+                new_neighbors.push_back(top_view[idx].id);
             }
         }
 
         // Reverse links from the neighbors:
         for (id_t close_id : new_neighbors) {
-            node_ref_t close_node = node(close_id);
-            lock_t close_lock = close_node.lock();
+            node_t close_node = node_with_id_(close_id);
+            node_lock_t close_lock = node_lock_(close_id);
 
-            neighbors_ref_t close_header = neighbors(close_node, level);
+            neighbors_ref_t close_header = neighbors_(close_node, level);
             assert_m(close_header.size() <= connectivity_max, "Possible corruption");
             assert_m(close_id != new_id, "Self-loops are impossible");
-            assert_m(level <= close_node.head.level, "Linking to missing level");
+            assert_m(level <= close_node.level(), "Linking to missing level");
 
             // If `new_id` is already present in the neighboring connections of `close_id`
             // then no need to modify any connections or run the heuristics.
@@ -1371,66 +1766,56 @@ class index_gt {
             // To fit a new connection we need to drop an existing one.
             top.clear();
             top.reserve(close_header.size() + 1);
-            top.emplace_reserved( //
-                context.metric(   //
-                    new_node.vector, close_node.vector, new_node.head.dim, close_node.head.dim),
-                new_id);
-            for (id_t successor_id : close_header) {
-                node_ref_t successor_node = node(successor_id);
-                top.emplace_reserved( //
-                    context.metric(   //
-                        successor_node.vector, close_node.vector, successor_node.head.dim, close_node.head.dim),
-                    successor_id);
-            }
+            top.emplace_reserved(context.measure(new_node, close_node), new_id);
+            for (id_t successor_id : close_header)
+                top.emplace_reserved(context.measure(node_with_id_(successor_id), close_node), successor_id);
 
             // Export the results:
             close_header.clear();
-            candidates_view_t top_view = refine(top, connectivity_max, context);
+            candidates_view_t top_view = refine_(top, connectivity_max, context);
             for (std::size_t idx = 0; idx != top_view.size(); idx++)
-                close_header.push_back(top_view[idx].second);
+                close_header.push_back(top_view[idx].id);
         }
 
         return new_neighbors[0];
     }
 
-    level_t choose_random_level(std::default_random_engine& level_generator) const noexcept {
+    level_t choose_random_level_(std::default_random_engine& level_generator) const noexcept {
         std::uniform_real_distribution<double> distribution(0.0, 1.0);
         double r = -std::log(distribution(level_generator)) * pre_.inverse_log_connectivity;
         return (level_t)r;
     }
 
-    id_t search_for_one(                                                 //
-        id_t entry_id, scalar_t const* query_vec, std::size_t query_dim, //
-        level_t begin_level, level_t end_level, thread_context_t& context) const noexcept {
+    id_t search_for_one_(                       //
+        id_t closest_id, vector_view_t query,   //
+        level_t begin_level, level_t end_level, //
+        thread_context_t& context) const noexcept {
 
-        id_t closest_id = entry_id;
-        distance_t closest_dist =
-            context.metric(query_vec, node(closest_id).vector, query_dim, node(closest_id).head.dim);
+        distance_t closest_dist = context.measure(query, node_with_id_(closest_id));
         for (level_t level = begin_level; level > end_level; level--) {
             bool changed;
             do {
                 changed = false;
-                node_ref_t closest_node = node(closest_id);
-                lock_t closest_lock = closest_node.lock();
-                neighbors_ref_t closest_header = neighbors_non_base(closest_node, level);
-                for (id_t candidate_id : closest_header) {
-                    node_ref_t candidate_node = node(candidate_id);
-                    distance_t candidate_dist =
-                        context.metric(query_vec, candidate_node.vector, query_dim, candidate_node.head.dim);
+                node_t closest_node = node_with_id_(closest_id);
+                node_lock_t closest_lock = node_lock_(closest_id);
+                neighbors_ref_t closest_neighbors = neighbors_non_base_(closest_node, level);
+                for (id_t candidate_id : closest_neighbors) {
+                    distance_t candidate_dist = context.measure(query, node_with_id_(candidate_id));
                     if (candidate_dist < closest_dist) {
                         closest_dist = candidate_dist;
                         closest_id = candidate_id;
                         changed = true;
                     }
                 }
+                context.iteration_cycles++;
             } while (changed);
         }
         return closest_id;
     }
 
-    void search_to_insert(                                               //
-        id_t start_id, scalar_t const* query_vec, std::size_t query_dim, //
-        level_t level, thread_context_t& context) noexcept(false) {
+    void search_to_insert_(                                //
+        id_t start_id, vector_view_t query, level_t level, //
+        thread_context_t& context) noexcept(false) {
 
         visits_bitset_t& visits = context.visits;
         next_candidates_t& candidates = context.next_candidates; // pop min, push
@@ -1442,7 +1827,7 @@ class index_gt {
         top.clear();
         top.reserve(top_limit + 1);
 
-        distance_t radius = context.metric(query_vec, node(start_id).vector, query_dim, node(start_id).head.dim);
+        distance_t radius = context.measure(query, node_with_id_(start_id));
         candidates.emplace(-radius, start_id);
         top.emplace_reserved(radius, start_id);
         visits.set(start_id);
@@ -1450,38 +1835,39 @@ class index_gt {
         while (!candidates.empty()) {
 
             candidate_t candidacy = candidates.top();
-            if ((-candidacy.first) > radius && top.size() == top_limit)
+            if ((-candidacy.distance) > radius && top.size() == top_limit)
                 break;
 
             candidates.pop();
-            id_t candidate_id = candidacy.second;
-            node_ref_t candidate_node = node(candidate_id);
-            lock_t candidate_lock = candidate_node.lock();
-            neighbors_ref_t candidate_header = neighbors(candidate_node, level);
+            context.iteration_cycles++;
 
-            prefetch_neighbors(candidate_header, visits);
-            for (id_t successor_id : candidate_header) {
+            id_t candidate_id = candidacy.id;
+            node_t candidate_ref = node_with_id_(candidate_id);
+            node_lock_t candidate_lock = node_lock_(candidate_id);
+            neighbors_ref_t candidate_neighbors = neighbors_(candidate_ref, level);
+
+            prefetch_neighbors_(candidate_neighbors, visits);
+            for (id_t successor_id : candidate_neighbors) {
                 if (visits.test(successor_id))
                     continue;
 
                 visits.set(successor_id);
-                node_ref_t successor_node = node(successor_id);
-                distance_t successor_dist =
-                    context.metric(query_vec, successor_node.vector, query_dim, successor_node.head.dim);
+                distance_t successor_dist = context.measure(query, node_with_id_(successor_id));
+
                 if (top.size() < top_limit || successor_dist < radius) {
                     candidates.emplace(-successor_dist, successor_id);
                     top.emplace_reserved(successor_dist, successor_id);
                     if (top.size() > top_limit)
                         top.pop();
-                    radius = top.top().first;
+                    radius = top.top().distance;
                 }
             }
         }
     }
 
-    void search_to_find_in_base(                                         //
-        id_t start_id, scalar_t const* query_vec, std::size_t query_dim, //
-        std::size_t expansion, thread_context_t& context) const noexcept(false) {
+    void search_to_find_in_base_(                                  //
+        id_t start_id, vector_view_t query, std::size_t expansion, //
+        thread_context_t& context) const noexcept(false) {
 
         visits_bitset_t& visits = context.visits;
         next_candidates_t& candidates = context.next_candidates; // pop min, push
@@ -1493,7 +1879,7 @@ class index_gt {
         top.clear();
         top.reserve(top_limit + 1);
 
-        distance_t radius = context.metric(query_vec, node(start_id).vector, query_dim, node(start_id).head.dim);
+        distance_t radius = context.measure(query, node_with_id_(start_id));
         candidates.emplace(-radius, start_id);
         top.emplace_reserved(radius, start_id);
         visits.set(start_id);
@@ -1501,43 +1887,53 @@ class index_gt {
         while (!candidates.empty()) {
 
             candidate_t candidate = candidates.top();
-            if ((-candidate.first) > radius)
+            if ((-candidate.distance) > radius)
                 break;
 
             candidates.pop();
+            context.iteration_cycles++;
 
-            id_t candidate_id = candidate.second;
-            neighbors_ref_t candidate_header = neighbors_base(node(candidate_id));
+            id_t candidate_id = candidate.id;
+            neighbors_ref_t candidate_neighbors = neighbors_base_(node_with_id_(candidate_id));
 
-            prefetch_neighbors(candidate_header, visits);
-            for (id_t successor_id : candidate_header) {
+            prefetch_neighbors_(candidate_neighbors, visits);
+            for (id_t successor_id : candidate_neighbors) {
                 if (visits.test(successor_id))
                     continue;
 
                 visits.set(successor_id);
-                node_ref_t successor_node = node(successor_id);
-                distance_t successor_dist =
-                    context.metric(query_vec, successor_node.vector, query_dim, successor_node.head.dim);
+                distance_t successor_dist = context.measure(query, node_with_id_(successor_id));
 
                 if (top.size() < top_limit || successor_dist < radius) {
                     candidates.emplace(-successor_dist, successor_id);
                     top.emplace_reserved(successor_dist, successor_id);
                     if (top.size() > top_limit)
                         top.pop();
-                    radius = top.top().first;
+                    radius = top.top().distance;
                 }
             }
         }
     }
 
-    void prefetch_neighbors(neighbors_ref_t, visits_bitset_t const&) const noexcept {}
+    void search_exact_(vector_view_t query, std::size_t count, thread_context_t& context) const noexcept(false) {
+        top_candidates_t& top = context.top_candidates;
+        top.clear();
+        top.reserve(count);
+        for (std::size_t i = 0; i != nodes_.size(); ++i)
+            top.emplace_reserved(context.measure(query, node_with_id_(i)), static_cast<id_t>(i));
+    }
+
+    void prefetch_neighbors_(neighbors_ref_t, visits_bitset_t const&) const noexcept {}
 
     /**
      *  @brief  This algorithm from the original paper implements a heuristic,
      *          that massively reduces the number of connections a point has,
      *          to keep only the neighbors, that are from each other.
      */
-    candidates_view_t refine(top_candidates_t& top, std::size_t needed, thread_context_t& context) const noexcept {
+
+    candidates_view_t refine_(                     //
+        top_candidates_t& top, std::size_t needed, //
+        thread_context_t& context) const noexcept {
 
         top.sort_ascending();
         candidate_t* top_data = top.data();
@@ -1549,15 +1945,13 @@ class index_gt {
         std::size_t consumed_count = 1; /// Always equal or greater than `submitted_count`.
         while (submitted_count < needed && consumed_count < top_count) {
             candidate_t candidate = top_data[consumed_count];
-            node_ref_t candidate_node = node(candidate.second);
-            distance_t candidate_dist = candidate.first;
+            node_t candidate_ref = node_with_id_(candidate.id);
+            distance_t candidate_dist = candidate.distance;
             bool good = true;
             for (std::size_t idx = 0; idx < submitted_count; idx++) {
                 candidate_t submitted = top_data[idx];
-                node_ref_t submitted_node = node(submitted.second);
-                distance_t inter_result_dist = context.metric(    //
-                    submitted_node.vector, candidate_node.vector, //
-                    submitted_node.head.dim, candidate_node.head.dim);
+                node_t submitted_node = node_with_id_(submitted.id);
+                distance_t inter_result_dist = context.measure(submitted_node, candidate_ref);
                 if (inter_result_dist < candidate_dist) {
                     good = false;
                     break;