Concurrent graph modifications

bindings/python/include/svs/python/manager.h

@@ -44,7 +44,10 @@ pybind11::tuple py_search(
         matrix_view(result_idx), matrix_view(result_dists)
     );
 
-    svs::index::search_batch_into(self, q_result, query_data.cview());
+    {
+        pybind11::gil_scoped_release release;
+        svs::index::search_batch_into(self, q_result, query_data.cview());
+    }
     return pybind11::make_tuple(result_idx, result_dists);
 }
 
@@ -86,7 +89,7 @@ void add_threading_interface(pybind11::class_<Manager>& manager) {
         "num_threads",
         &Manager::get_num_threads,
         [](Manager& self, int num_threads) {
-            self.set_threadpool(svs::threads::DefaultThreadPool(num_threads));
+            self.set_threadpool(svs::threads::SwitchNativeThreadPool(num_threads));
         },
         "Read/Write (int): Get and set the number of threads used to process queries."
     );

bindings/python/src/dynamic_vamana.cpp

@@ -174,7 +174,12 @@ void add_points(
             "Expected IDs to be the same length as the number of rows in points!"
         );
     }
-    index.add_points(data_view(py_data), std::span(ids.data(), ids.size()), reuse_empty);
+    auto data = data_view(py_data);
+    auto id_span = std::span(ids.data(), ids.size());
+    {
+        py::gil_scoped_release release;
+        index.add_points(data, id_span, reuse_empty);
+    }
 }
 
 const char* ADD_POINTS_DOCSTRING = R"(
@@ -381,8 +386,18 @@ void wrap(py::module& m) {
 
     add_dynamic_vamana_properties(vamana);
 
-    vamana.def("consolidate", &svs::DynamicVamana::consolidate, CONSOLIDATE_DOCSTRING);
-    vamana.def("compact", &svs::DynamicVamana::compact, COMPACT_DOCSTRING);
+    vamana.def(
+        "consolidate",
+        &svs::DynamicVamana::consolidate,
+        py::call_guard<py::gil_scoped_release>(),
+        CONSOLIDATE_DOCSTRING
+    );
+    vamana.def(
+        "compact",
+        &svs::DynamicVamana::compact,
+        py::call_guard<py::gil_scoped_release>(),
+        COMPACT_DOCSTRING
+    );
 
     // Reloading
     vamana.def(
@@ -435,7 +450,11 @@ void wrap(py::module& m) {
     vamana.def(
         "delete",
         [](svs::DynamicVamana& index, const py_contiguous_array_t<size_t>& ids) {
-            index.delete_points(as_span(ids));
+            auto id_span = as_span(ids);
+            {
+                py::gil_scoped_release release;
+                index.delete_points(id_span);
+            }
         },
         py::arg("ids"),
         DELETE_DOCSTRING

bindings/python/src/python_bindings.cpp

@@ -156,7 +156,7 @@ class ScopedModuleNameOverride {
 
 } // namespace
 
-PYBIND11_MODULE(_svs, m) {
+PYBIND11_MODULE(_svs, m, py::mod_gil_not_used()) {
     // Internally, the top level `__init__.py` imports everything from the C++ module named
     // `_svs`.
     //

include/svs/concepts/graph.h

@@ -50,6 +50,15 @@
 
 namespace svs::graphs {
 
+/// Outcome of `MemoryGraph::add_edge(src, dst)`. Distinguishes three cases so callers
+/// can route dropped edges (e.g. to a backedge buffer) without a TOCTOU race between a
+/// pre-check and the insert.
+enum class AddEdgeResult : uint8_t {
+    Added,         // Edge was inserted.
+    AlreadyExists, // Edge was already present (or self-loop). Not inserted.
+    Full,          // Node's adjacency list is at max_degree. Edge NOT inserted.
+};
+
 // clang-format off
 
 ///
@@ -135,12 +144,13 @@ template <ImmutableMemoryGraph G> using index_type_t = typename G::index_type;
 /// @code{.cpp}
 /// template <typename T>
 /// concept MemoryGraph = requires(T& g, const T& const_g) {
-///     // Add an edge to the graph.
-///     // Must return the out degree of `src` after adding the edge `src -> dst`.
-///     // If adding the edge would result in the graph exceeding its maximum degree,
-///     // implementations are free to not add this edge.
+///     // Add an edge to the graph atomically. Returns an AddEdgeResult indicating:
+///     //   Added          - edge was inserted
+///     //   AlreadyExists  - edge was already present (or self-loop); no insert
+///     //   Full           - node is at max_degree; edge NOT inserted (caller should
+///     //                    route to an overflow buffer if needed)
 ///     requires requires(index_type_t<T> src, index_type_t<T> dst) {
-///         { g.add_edge(src, dst) } -> std::convertible_to<size_t>;
+///         { g.add_edge(src, dst) } -> std::convertible_to<AddEdgeResult>;
 ///     };
 ///
 ///     // Completely clear the adjacency list for vertex ``i``.
@@ -164,7 +174,7 @@ template <typename T>
 concept MemoryGraph = requires(T& g, const T& const_g) {
     // Adding an edge.
     requires requires(index_type_t<T> src, index_type_t<T> dst) {
-        { g.add_edge(src, dst) } -> std::convertible_to<size_t>;
+        { g.add_edge(src, dst) } -> std::convertible_to<AddEdgeResult>;
     };
 
     // Clear adjacency list.

include/svs/core/data/simple.h

@@ -30,6 +30,7 @@
 #include "svs/lib/misc.h"
 #include "svs/lib/prefetch.h"
 #include "svs/lib/saveload.h"
+#include "svs/lib/segmented_vector.h"
 #include "svs/lib/threads.h"
 #include "svs/lib/uuid.h"
 
@@ -729,7 +730,6 @@ class SimpleData<T, Extent, Blocked<Alloc>> {
         , allocator_{alloc} {
         size_t elements_per_block = blocksize_.value();
         size_t num_blocks = lib::div_round_up(n_elements, elements_per_block);
-        blocks_.reserve(num_blocks);
         for (size_t i = 0; i < num_blocks; ++i) {
             add_block();
         }
@@ -782,10 +782,10 @@ class SimpleData<T, Extent, Blocked<Alloc>> {
     /// Add a new data block to the end of the current collection of blocks.
     ///
     void add_block() {
-        blocks_.emplace_back(
+        blocks_.push_back(array_type(
             make_dims(blocksize().value(), lib::forward_extent<Extent>(dimensions())),
             allocator_.get_allocator()
-        );
+        ));
     }
 
     ///
@@ -967,7 +967,12 @@ class SimpleData<T, Extent, Blocked<Alloc>> {
   private:
     // The blocksize in terms of number of vectors.
     lib::PowerOfTwo blocksize_;
-    std::vector<array_type> blocks_;
+    // Grow-stable directory of fixed-size blocks: appending a block never relocates the
+    // existing block wrappers (or the heap buffers they point to), so a concurrent
+    // lock-free reader subscripting blocks_[block_id] is safe against a writer growing the
+    // dataset. Element addressing (block_id, data_id) is unchanged; only the outer block
+    // directory is grow-stable (2-level lock-free array). See svs/lib/segmented_vector.h.
+    lib::SegmentedVector<array_type> blocks_;
     size_t dimensions_;
     size_t size_;
     Blocked<Alloc> allocator_;