usearch 2.5.0 → 2.6.0

package/.github/workflows/release.yml

@@ -591,8 +591,10 @@ jobs:
       GITHUB_PACKAGES_SOURCE: https://nuget.pkg.github.com/${{ github.repository_owner }}/index.json
     steps:
       - uses: actions/checkout@v3
+        with:
+          ref: 'main'  
       - run: git submodule update --init --recursive
-        
+          
       - name: Download usearch libs artifact
         uses: actions/download-artifact@v3
         with:
@@ -606,8 +608,7 @@ jobs:
 
       - name: Pack project
         run: |
-          VERSION_CONTENT=$(< VERSION)
-          dotnet pack "${{ env.SOLUTION }}" -c Release -p:Version="$VERSION_CONTENT" --output ${{ env.NUGET_PACKAGES }}
+          dotnet pack "${{ env.SOLUTION }}" -c Release --output ${{ env.NUGET_PACKAGES }}
         working-directory: ${{ github.workspace }}
 
       - name: Publish to NuGet

package/.vscode/settings.json

@@ -145,6 +145,7 @@
         "SLOC",
         "sorensen",
         "tanimoto",
+        "tqdm",
         "uninitialize",
         "unumusearch",
         "usearch",

package/CITATION.cff

@@ -5,7 +5,7 @@ authors:
   given-names: "Ash"
   orcid: "https://orcid.org/0000-0002-4882-1815"
 title: "USearch by Unum Cloud"
-version: 2.5.0
+version: 2.6.0
 doi: 10.5281/zenodo.7949416
 date-released: 2022-06-12
 url: "https://github.com/unum-cloud/usearch"

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "usearch"
-version = "2.5.0"
+version = "2.6.0"
 authors = ["Ash Vardanian <1983160+ashvardanian@users.noreply.github.com>"]
 description = "Smaller & Faster Single-File Vector Search Engine from Unum"
 edition = "2021"

package/README.md

@@ -392,7 +392,7 @@ doi = {10.5281/zenodo.7949416},
 author = {Vardanian, Ash},
 title = {{USearch by Unum Cloud}},
 url = {https://github.com/unum-cloud/usearch},
-version = {2.5.0},
+version = {2.6.0},
 year = {2022},
 month = jun,
 }

package/conanfile.py

@@ -7,7 +7,7 @@ required_conan_version = ">=1.53.0"
 class USearchConan(ConanFile):
 
     name = "usearch"
-    version = '2.5.0'
+    version = '2.6.0'
     license = "Apache-2.0"
     description = "Smaller & Faster Single-File Vector Search Engine from Unum"
     homepage = "https://github.com/unum-cloud/usearch"

package/cpp/CMakeLists.txt

@@ -20,6 +20,8 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fmax-errors=1")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fdiagnostics-color=always")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftime-report")
 
     if(${USEARCH_USE_OPENMP})
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fopenmp")
@@ -32,6 +34,8 @@ elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=address -fsanitize=leak -fsanitize=alignment -fsanitize=undefined")
     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wfatal-errors")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fcolor-diagnostics")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftime-trace")
 
     if(${USEARCH_USE_OPENMP})
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fopenmp")

package/csharp/nuget/nuget-package.props

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project>
   <PropertyGroup>
-    <Version Condition="'$(Version)' == ''">2.5.0</Version>
+    <Version Condition="'$(Version)' == ''">2.6.0</Version>
 
     <Authors>Unum</Authors>
     <Company>Unum</Company>

package/include/usearch/index.hpp

@@ -10,7 +10,7 @@
 #define UNUM_USEARCH_HPP
 
 #define USEARCH_VERSION_MAJOR 2
-#define USEARCH_VERSION_MINOR 5
+#define USEARCH_VERSION_MINOR 6
 #define USEARCH_VERSION_PATCH 0
 
 // Inferring C++ version

package/include/usearch/index_dense.hpp

@@ -1,15 +1,18 @@
 #pragma once
 #include <stdlib.h> // `aligned_alloc`
 
-#include <functional>   // `std::function`
-#include <numeric>      // `std::iota`
-#include <shared_mutex> // `std::shared_mutex`
-#include <thread>       // `std::thread`
-#include <vector>       // `std::vector`
+#include <functional> // `std::function`
+#include <numeric>    // `std::iota`
+#include <thread>     // `std::thread`
+#include <vector>     // `std::vector`
 
 #include <usearch/index.hpp>
 #include <usearch/index_plugins.hpp>
 
+#if defined(USEARCH_DEFINED_CPP17)
+#include <shared_mutex> // `std::shared_mutex`
+#endif
+
 namespace unum {
 namespace usearch {
 
@@ -383,7 +386,11 @@ class index_dense_gt {
     /// @brief Mutex, controlling concurrent access to `available_threads_`.
     mutable std::mutex available_threads_mutex_;
 
+#if defined(USEARCH_DEFINED_CPP17)
+    using shared_mutex_t = std::shared_mutex;
+#else
     using shared_mutex_t = unfair_shared_mutex_t;
+#endif
     using shared_lock_t = shared_lock_gt<shared_mutex_t>;
     using unique_lock_t = std::unique_lock<shared_mutex_t>;
 

package/include/usearch/index_plugins.hpp

@@ -42,14 +42,10 @@
 
 #if USEARCH_USE_SIMSIMD
 #if defined(USEARCH_DEFINED_LINUX)
-#define SIMSIMD_TARGET_X86_AVX2 1
-#define SIMSIMD_TARGET_X86_AVX512 1
-#define SIMSIMD_TARGET_ARM_NEON 1
-#define SIMSIMD_TARGET_ARM_SVE 1
 #include <simsimd/simsimd.h>
 #elif defined(USEARCH_DEFINED_APPLE)
-#define SIMSIMD_TARGET_X86_AVX2 1
-#define SIMSIMD_TARGET_ARM_NEON 1
+#define SIMSIMD_TARGET_X86_AVX512 0
+#define SIMSIMD_TARGET_ARM_SVE 0
 #include <simsimd/simsimd.h>
 #endif
 #endif
@@ -1606,7 +1602,7 @@ class flat_hash_multi_set_gt {
         auto slot_pointer = bucket_pointer + sizeof(bucket_header_t) + sizeof(element_t) * in_bucket_index;
         return {
             *reinterpret_cast<bucket_header_t*>(bucket_pointer),
-            std::uint64_t(1ull) << in_bucket_index,
+            static_cast<std::uint64_t>(1ull) << in_bucket_index,
             *reinterpret_cast<element_t*>(slot_pointer),
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "usearch",
-    "version": "2.5.0",
+    "version": "2.6.0",
     "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ash Vardanian",
     "license": "Apache 2.0",

package/python/lib.cpp

@@ -526,55 +526,76 @@ static void search_typed_brute_force(                                //
     byte_t const* dataset_data = reinterpret_cast<byte_t const*>(dataset_info.ptr);
     byte_t const* queries_data = reinterpret_cast<byte_t const*>(queries_info.ptr);
     for (std::size_t query_idx = 0; query_idx != queries_count; ++query_idx)
-        counts_py1d(query_idx) = 0;
+        counts_py1d(query_idx) = wanted;
 
     if (!threads)
         threads = std::thread::hardware_concurrency();
 
     std::size_t tasks_count = static_cast<std::size_t>(dataset_count * queries_count);
-    bitset_t query_mutexes(static_cast<std::size_t>(queries_count));
-    if (!query_mutexes)
-        throw std::bad_alloc();
+    executor_default_t executor{threads};
 
     // Progress status
     progress_t progress_{progress};
     std::atomic<std::size_t> processed{0};
 
-    executor_default_t{threads}.dynamic(tasks_count, [&](std::size_t thread_idx, std::size_t task_idx) {
-        //
-        std::size_t dataset_idx = task_idx / queries_count;
-        std::size_t query_idx = task_idx % queries_count;
-
+    struct dense_key_and_distance_t {
+        u32_t offset;
+        f32_t distance;
+    };
+    auto less = [](dense_key_and_distance_t const& a, dense_key_and_distance_t const& b) {
+        return a.distance < b.distance;
+    };
+
+    // Allocate temporary memory to store the distance matrix
+    // Previous version didn't need temporary memory, but the performance was much lower.
+    // In the new design we keep two buffers - original and transposed, as in-place transpositions
+    // of non-rectangular matrixes is expensive.
+    std::vector<dense_key_and_distance_t> keys_and_distances(tasks_count * 2);
+    dense_key_and_distance_t* keys_and_distances_per_dataset = keys_and_distances.data();
+    dense_key_and_distance_t* keys_and_distances_per_query = keys_and_distances_per_dataset + tasks_count;
+    executor.dynamic(dataset_count, [&](std::size_t thread_idx, std::size_t dataset_idx) {
         byte_t const* dataset = dataset_data + dataset_idx * dataset_info.strides[0];
+        for (std::size_t query_idx = 0; query_idx != queries_count; ++query_idx) {
         byte_t const* query = queries_data + query_idx * queries_info.strides[0];
         distance_t distance = metric(dataset, query);
-
-        {
-            auto lock = query_mutexes.lock(query_idx);
-            dense_key_t* keys = &keys_py2d(query_idx, 0);
-            distance_t* distances = &distances_py2d(query_idx, 0);
-            std::size_t& matches = reinterpret_cast<std::size_t&>(counts_py1d(query_idx));
-            if (matches == wanted)
-                if (distances[wanted - 1] <= distance)
-                    return true;
-
-            std::size_t offset = std::lower_bound(distances, distances + matches, distance) - distances;
-
-            std::size_t count_worse = matches - offset - (wanted == matches);
-            std::memmove(keys + offset + 1, keys + offset, count_worse * sizeof(dense_key_t));
-            std::memmove(distances + offset + 1, distances + offset, count_worse * sizeof(distance_t));
-            keys[offset] = static_cast<dense_key_t>(dataset_idx);
-            distances[offset] = distance;
-            matches += matches != wanted;
+            std::size_t task_idx = dataset_idx * queries_count + query_idx;
+            keys_and_distances_per_dataset[task_idx].offset = static_cast<u32_t>(dataset_idx);
+            keys_and_distances_per_dataset[task_idx].distance = static_cast<f32_t>(distance);
         }
 
         // We don't want to check for signals from multiple threads
-        ++processed;
+        processed += queries_count;
         if (thread_idx == 0)
             if (PyErr_CheckSignals() != 0 || !progress_(processed.load(), tasks_count))
                 return false;
         return true;
     });
+    if (processed.load() != tasks_count)
+        return;
+
+    // Transpose in a single thread to avoid contention writing into the same memory buffers
+    for (std::size_t query_idx = 0; query_idx != queries_count; ++query_idx) {
+        for (std::size_t dataset_idx = 0; dataset_idx != dataset_count; ++dataset_idx) {
+            std::size_t from_idx = queries_count * dataset_idx + query_idx;
+            std::size_t to_idx = dataset_count * query_idx + dataset_idx;
+            keys_and_distances_per_query[to_idx] = keys_and_distances_per_dataset[from_idx];
+        }
+    }
+
+    // Partial-sort every query result
+    executor.fixed(queries_count, [&](std::size_t, std::size_t query_idx) {
+        dense_key_t* keys = &keys_py2d(query_idx, 0);
+        distance_t* distances = &distances_py2d(query_idx, 0);
+        auto start = keys_and_distances_per_query + dataset_count * query_idx;
+        if (wanted > 1) {
+            std::partial_sort(start, start + wanted, start + dataset_count, less);
+        for (std::size_t i = 0; i != wanted; ++i)
+            keys[i] = static_cast<dense_key_t>(start[i].offset), distances[i] = start[i].distance;
+        } else {
+            auto max_it = std::max_element(start, start + dataset_count, less);
+            keys[0] = static_cast<dense_key_t>(max_it->offset), distances[0] = max_it->distance;
+        }
+    });
 
     // At the end report the latest numbers, because the reporter thread may be finished earlier
     progress_(processed.load(), tasks_count);
@@ -602,6 +623,8 @@ static py::tuple search_many_brute_force(    //
     Py_ssize_t queries_dimensions = queries_info.shape[1];
     if (dataset_dimensions != queries_dimensions)
         throw std::invalid_argument("The number of vector dimensions doesn't match!");
+    if (wanted > dataset_count)
+        throw std::invalid_argument("You can't request more matches than in the dataset!");
 
     scalar_kind_t dataset_kind = numpy_string_to_kind(dataset_info.format);
     scalar_kind_t queries_kind = numpy_string_to_kind(queries_info.format);

package/python/scripts/bench_exact.py

@@ -0,0 +1,44 @@
+from time import time
+
+from usearch.index import search, MetricKind, ScalarKind
+from usearch.compiled import hardware_acceleration
+from faiss import IndexFlatL2, knn
+import numpy as np
+import fire
+
+
+def run(
+    n: int = 10**5,
+    q: int = 10,
+    k: int = 100,
+    ndim: int = 256,
+    half: bool = False,
+):
+    usearch_dtype = ScalarKind.F16 if half else ScalarKind.F32
+    acceleration = hardware_acceleration(
+        dtype=usearch_dtype,
+        ndim=ndim,
+        metric_kind=MetricKind.L2sq,
+    )
+    print("Hardware acceleration in USearch: ", acceleration)
+
+    x = np.random.random((n, ndim))
+    x = x.astype(np.float16) if half else x.astype(np.float32)
+
+    start = time()
+    _ = search(
+        x,
+        x[:q],
+        k,
+        MetricKind.L2sq,
+        exact=True,
+    ).keys
+    print("USearch: ", time() - start)
+
+    start = time()
+    _ = knn(x, x[:q], k)[1]
+    print("FAISS:   ", time() - start)
+
+
+if __name__ == "__main__":
+    fire.Fire(run)

package/python/scripts/test_tooling.py

@@ -11,7 +11,7 @@ from usearch.index import Match, Matches, BatchMatches, Index, Indexes
 
 
 dimensions = [3, 97, 256]
-batch_sizes = [1, 77]
+batch_sizes = [1, 77, 100]
 
 
 @pytest.mark.parametrize("rows", batch_sizes)
@@ -56,15 +56,16 @@ def test_exact_search(rows: int, cols: int):
     :param int cols: The number of columns in the matrix.
     """
     original = np.random.rand(rows, cols)
-    matches: BatchMatches = search(original, original, 10, exact=True)
+    keys = np.arange(rows)
+    matches: BatchMatches = search(original, original, min(10, rows), exact=True)
     top_matches = (
         [int(m.keys[0]) for m in matches] if rows > 1 else int(matches.keys[0])
     )
-    assert np.all(top_matches == np.arange(rows))
+    assert np.all(top_matches == keys)
 
-    matches: Matches = search(original, original[0], 10, exact=True)
+    matches: Matches = search(original, original[-1], min(10, rows), exact=True)
     top_match = int(matches.keys[0])
-    assert top_match == 0
+    assert top_match == keys[-1]
 
 
 def test_matches_creation_and_methods():

package/python/usearch/index.py

@@ -180,7 +180,7 @@ def _search_in_compiled(
         vectors = vectors.reshape(1, len(vectors))
     count_vectors = vectors.shape[0]
 
-    def distil_batch(
+    def distill_batch(
         batch_matches: BatchMatches,
     ) -> Union[BatchMatches, Matches]:
         return batch_matches[0] if count_vectors == 1 else batch_matches
@@ -188,22 +188,22 @@ def _search_in_compiled(
     # Create progress bar if needed
     if log:
         name = log if isinstance(log, str) else "Search"
-        pbar = tqdm(
+        progress_bar = tqdm(
             desc=name,
             total=count_vectors,
             unit="vector",
         )
 
         def update_progress_bar(processed: int, total: int) -> bool:
-            pbar.update(processed - pbar.n)
+            progress_bar.update(processed - progress_bar.n)
             return progress if progress else True
 
         tuple_ = compiled_callable(vectors, progress=update_progress_bar, **kwargs)
-        pbar.close()
+        progress_bar.close()
     else:
         tuple_ = compiled_callable(vectors, **kwargs)
 
-    return distil_batch(BatchMatches(*tuple_))
+    return distill_batch(BatchMatches(*tuple_))
 
 
 def _add_to_compiled(
@@ -871,6 +871,10 @@ class Index:
     def serialized_length(self) -> int:
         return self._compiled.serialized_length
 
+    @property
+    def metric_kind(self) -> Union[MetricKind, CompiledMetric]:
+        return self._metric_jit if self._metric_jit.kind else self._metric_kind
+
     @property
     def metric(self) -> Union[MetricKind, CompiledMetric]:
         return self._metric_jit if self._metric_jit else self._metric_kind
@@ -1190,6 +1194,7 @@ class Index:
             "size": self.size,
             "jit": self.jit,
             "hardware_acceleration": self.hardware_acceleration,
+            "metric_kind": self.metric_kind,
             "dtype": self.dtype,
             "path": self.path,
             "compiled_with_openmp": USES_OPENMP,
@@ -1204,7 +1209,7 @@ class Index:
         return f.format(
             self.dtype,
             self.ndim,
-            self.metric,
+            self.metric_kind,
             self.connectivity,
             self.expansion_add,
             self.expansion_search,
@@ -1225,7 +1230,7 @@ class Index:
                 "- config",
                 f"-- data type: {self.dtype}",
                 f"-- dimensions: {self.ndim}",
-                f"-- metric: {self.metric}",
+                f"-- metric: {self.metric_kind}",
                 f"-- connectivity: {self.connectivity}",
                 f"-- expansion on addition:{self.expansion_add} candidates",
                 f"-- expansion on search: {self.expansion_search} candidates",
@@ -1233,7 +1238,7 @@ class Index:
                 f"-- uses OpenMP: {USES_OPENMP}",
                 f"-- uses SimSIMD: {USES_SIMSIMD}",
                 f"-- supports half-precision: {USES_NATIVE_F16}",
-                f"-- uses hardware acceletion: {self.hardware_acceleration}",
+                f"-- uses hardware acceleration: {self.hardware_acceleration}",
                 "- state",
                 f"-- size: {self.size:,} vectors",
                 f"-- memory usage: {self.memory_usage:,} bytes",

package/setup.py

@@ -12,8 +12,11 @@ macros_args = []
 if sys.platform == "linux":
     compile_args.append("-std=c++17")
     compile_args.append("-O3")  # Maximize performance
-    compile_args.append("-g")  # Simplify debugging
     compile_args.append("-Wno-unknown-pragmas")
+    compile_args.append("-fdiagnostics-color=always")
+
+    # Simplify debugging, but the normal `-g` may make builds much longer!
+    compile_args.append("-g1")
 
     macros_args.append(("USEARCH_USE_NATIVE_F16", "0"))
     macros_args.append(("USEARCH_USE_SIMSIMD", "1"))
@@ -27,9 +30,12 @@ if sys.platform == "darwin":
     compile_args.append("-mmacosx-version-min=10.15")
     compile_args.append("-std=c++17")
     compile_args.append("-O3")  # Maximize performance
-    compile_args.append("-g")  # Simplify debugging
+    compile_args.append("-fcolor-diagnostics")
     compile_args.append("-Wno-unknown-pragmas")
 
+    # Simplify debugging, but the normal `-g` may make builds much longer!
+    compile_args.append("-g1")
+
     # Linking OpenMP requires additional preparation in CIBuildWheel
     # macros_args.append(("USEARCH_USE_OPENMP", "1"))
     # compile_args.append("-Xpreprocessor -fopenmp")

package/wasmer.toml

@@ -1,6 +1,6 @@
 [package]
 name="unum/usearch"
-version="2.5.0"
+version="2.6.0"
 description="Smaller & Faster Single-File Vector Search Engine from Unum"
 license="Apache-2.0"
 readme="README.md"