nidx-binding 6.9.2.post622__tar.gz → 6.9.3.post624__tar.gz

{nidx_binding-6.9.2.post622 → nidx_binding-6.9.3.post624}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nidx_binding
-Version: 6.9.2.post622
+Version: 6.9.3.post624
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{nidx_binding-6.9.2.post622 → nidx_binding-6.9.3.post624}/nidx_protos/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "pdm.backend"
 
 [project]
 name = "nidx_protos"
-version = "6.9.2.post622"
+version = "6.9.3.post624"
 license = "AGPL-3.0-or-later"
 description = "Protobuf definitions for nucliadb/nidx"
 authors = [{ name = "Nuclia", email = "nucliadb@nuclia.com" }]

nidx_binding-6.9.3.post624/nidx_vector/src/hnsw/build.rs

@@ -0,0 +1,172 @@
+// Copyright (C) 2021 Bosutech XXI S.L.
+//
+// nucliadb is offered under the AGPL v3.0 and as commercial software.
+// For commercial licensing, contact us at info@nuclia.com.
+//
+// AGPL:
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+
+use std::collections::BinaryHeap;
+
+use rand::{Rng, SeedableRng, distributions::Uniform, rngs::SmallRng};
+
+use crate::{
+    VectorAddr,
+    hnsw::{
+        Cnx, DataRetriever, HnswSearcher, RAMHnsw, SearchVector, params,
+        ram_hnsw::{Edge, RAMLayer},
+    },
+};
+
+pub struct HnswBuilder<'a, DR> {
+    distribution: Uniform<f64>,
+    layer_rng: SmallRng,
+    retriever: &'a DR,
+    searcher: HnswSearcher<'a, DR>,
+}
+
+impl<'a, DR: DataRetriever> HnswBuilder<'a, DR> {
+    pub fn new(retriever: &DR) -> HnswBuilder<'_, DR> {
+        HnswBuilder {
+            retriever,
+            distribution: Uniform::new(0.0, 1.0),
+            layer_rng: SmallRng::seed_from_u64(2),
+            searcher: HnswSearcher::new(retriever, false),
+        }
+    }
+
+    /// Initialize the graph holding the specified number of vectors
+    /// Each vector is assigned to a random amount of layers but no
+    /// edges are built yet. If the node is preinitialized, you can skip
+    /// an initial amount of nodes so they aren't recreated
+    pub fn initialize_graph(&mut self, hnsw: &mut RAMHnsw, skip_nodes: u32, total_nodes: u32) {
+        for node_id in skip_nodes..total_nodes {
+            let top_layer = self.get_random_layer();
+            hnsw.add_node(VectorAddr(node_id), top_layer);
+        }
+        hnsw.update_entry_point();
+    }
+
+    fn select_neighbours_heuristic(
+        &self,
+        k_neighbours: usize,
+        candidates: &[(VectorAddr, Edge)],
+    ) -> Vec<(VectorAddr, Edge)> {
+        let mut results = Vec::new();
+        let mut discarded = BinaryHeap::new();
+
+        // First, select the best candidates to link, trying to connect from all directions
+        // i.e: avoid linking to all nodes in a single cluster
+        for (x, sim) in candidates.iter().copied() {
+            if results.len() == k_neighbours {
+                break;
+            }
+            // Keep if x is more similar to the new node than it is similar to other results
+            // i.e: similarity(x, new) > similarity(x, y) for all y in result
+            let check = results
+                .iter()
+                .map(|&(y, _)| self.retriever.similarity(x, &SearchVector::Stored(y)))
+                .all(|inter_sim| sim > inter_sim);
+            if check {
+                results.push((x, sim));
+            } else {
+                discarded.push(Cnx(x, sim));
+            }
+        }
+
+        // keepPrunedConnections: keep some other connections to fill M
+        if results.len() < k_neighbours {
+            while results.len() < k_neighbours {
+                let Some(Cnx(n, d)) = discarded.pop() else { break };
+                results.push((n, d));
+            }
+            // Sort the list since the newly added connections might be out of order
+            results.sort_unstable_by(|y, x| x.1.total_cmp(&y.1));
+        }
+
+        results
+    }
+
+    fn get_random_layer(&mut self) -> usize {
+        let sample: f64 = self.layer_rng.sample(self.distribution);
+        let picked_level = -sample.ln() * params::level_factor();
+        picked_level.round() as usize
+    }
+
+    /// Insert a node into a layer, calculating all edges
+    fn layer_insert(&self, x: VectorAddr, layer: &RAMLayer, search_neighbours: Vec<(VectorAddr, Edge)>, mmax: usize) {
+        let neighbours = self.select_neighbours_heuristic(params::M, &search_neighbours);
+
+        // Set edges from this node to neighbours
+        *layer.out.get(&x).unwrap().write().unwrap() = neighbours.clone();
+
+        // Set edges from neighbours to this node
+        for (y, dist) in neighbours.iter().copied() {
+            let other_node = layer.out.get(&y).unwrap();
+            let mut other_edges = other_node.write().unwrap();
+            other_edges.push((x, dist));
+            if other_edges.len() > mmax {
+                *other_edges = self.select_neighbours_heuristic(params::prune_m(mmax), &other_edges);
+            }
+        }
+    }
+
+    /// Insert a node into all corresponding layers.
+    /// The node must be created first by calling initialize_graph()
+    pub fn insert(&self, node: VectorAddr, hnsw: &RAMHnsw) {
+        debug_assert!(!hnsw.layers.is_empty());
+        debug_assert!(node.0 < hnsw.layers[0].out.len() as u32);
+
+        let mut search_ep = vec![hnsw.entry_point.node];
+        let vector = SearchVector::Stored(node);
+
+        // The neighbours of the node at each layer, for insertion
+        let mut layer_neighbours = Vec::with_capacity(hnsw.no_layers());
+        let mut node_in_layer = false;
+
+        // First, find the neighbours for each layer the node appears in.
+        for l in (0..hnsw.no_layers()).rev() {
+            if !node_in_layer && (l == 0 || hnsw.layers[l].contains(&node)) {
+                node_in_layer = true;
+            }
+
+            // On upper layers, find 1 neighbour (as entrypoint to next layer)
+            // On layers where the inserted node appears, find efC neighbours for creating links
+            let k_neighbours = if node_in_layer { params::EF_CONSTRUCTION } else { 1 };
+
+            let search_results: Vec<_> = self
+                .searcher
+                .layer_search(&vector, &hnsw.layers[l], k_neighbours, &search_ep)
+                .map(|x| (x.0, x.1.score))
+                .collect();
+
+            search_ep = search_results.iter().map(|x| x.0).collect();
+            if node_in_layer {
+                // If finding neighbours, store them for insertion later
+                layer_neighbours.push(search_results);
+            }
+        }
+
+        // Insert all neighbours from the bottom layer up. This is done so that it's not possible to
+        // find a node on a top layer before the edges are set on the lower layers because this can cause
+        // problems during parallel insertion.
+        // If edges are inserted from top to bottom, another worker might find the node in layer N and
+        // follow it down to layer N-1 where edges are not yet set. Then, it cannot find neighbours in this
+        // layer and the search gets stuck (no links to follow) resulting in a node with low connectivity.
+        for (layer, neighbours) in layer_neighbours.into_iter().rev().enumerate() {
+            self.layer_insert(node, &hnsw.layers[layer], neighbours, params::m_max_for_layer(layer));
+        }
+    }
+}

{nidx_binding-6.9.2.post622 → nidx_binding-6.9.3.post624}/nidx_vector/src/hnsw/disk_hnsw.rs

@@ -46,8 +46,8 @@
 use std::collections::HashMap;
 use std::io;
 
-use super::ops_hnsw::{Hnsw, Layer};
 use super::ram_hnsw::{Edge, EntryPoint, RAMHnsw, RAMLayer};
+use super::search::{SearchableHnsw, SearchableLayer};
 use crate::VectorAddr;
 use crate::data_types::usize_utils::*;
 
@@ -66,7 +66,7 @@ pub struct DiskLayer<'a> {
     layer: usize,
 }
 
-impl<'a> Layer for &'a DiskLayer<'a> {
+impl<'a> SearchableLayer for &'a DiskLayer<'a> {
     type EdgeIt = EdgeIter<'a>;
     fn get_out_edges(&self, address: VectorAddr) -> Self::EdgeIt {
         let node = DiskHnsw::get_node(self.hnsw, address);
@@ -74,7 +74,7 @@ impl<'a> Layer for &'a DiskLayer<'a> {
     }
 }
 
-impl<'a> Layer for DiskLayer<'a> {
+impl<'a> SearchableLayer for DiskLayer<'a> {
     type EdgeIt = EdgeIter<'a>;
     fn get_out_edges(&self, address: VectorAddr) -> Self::EdgeIt {
         let node = DiskHnsw::get_node(self.hnsw, address);
@@ -82,9 +82,9 @@ impl<'a> Layer for DiskLayer<'a> {
     }
 }
 
-impl<'a> Hnsw for &'a [u8] {
+impl<'a> SearchableHnsw for &'a [u8] {
     type L = DiskLayer<'a>;
-    fn get_entry_point(&self) -> Option<EntryPoint> {
+    fn get_entry_point(&self) -> EntryPoint {
         DiskHnsw::get_entry_point(self)
     }
     fn get_layer(&self, i: usize) -> Self::L {
@@ -124,14 +124,16 @@ impl DiskHnsw {
         let mut length = offset;
         let mut indexing = HashMap::new();
         for layer in 0..hnsw.no_layers() {
-            let no_edges = hnsw.get_layer(layer).no_out_edges(node);
+            let num_edges = hnsw.get_layer(layer).num_out_edges(&node);
             indexing.insert(layer, length);
-            buf.write_all(&no_edges.to_le_bytes())?;
+            buf.write_all(&num_edges.to_le_bytes())?;
             length += USIZE_LEN;
-            for (cnx, edge) in hnsw.get_layer(layer).get_out_edges(node) {
-                buf.write_all(&(cnx.0 as usize).to_le_bytes())?;
-                buf.write_all(&edge.to_le_bytes())?;
-                length += CNX_LEN;
+            if num_edges > 0 {
+                for (cnx, edge) in hnsw.get_layer(layer).get_out_edges(node) {
+                    buf.write_all(&(cnx.0 as usize).to_le_bytes())?;
+                    buf.write_all(&edge.to_le_bytes())?;
+                    length += CNX_LEN;
+                }
             }
         }
         for layer in (0..hnsw.no_layers()).rev() {
@@ -158,38 +160,40 @@ impl DiskHnsw {
         }
     }
     pub fn serialize_into<W: io::Write>(mut buf: W, no_nodes: u32, hnsw: RAMHnsw) -> io::Result<()> {
-        if let Some(entry_point) = hnsw.entry_point {
-            let mut length = 0;
-            let mut nodes_end = vec![];
-            for node in 0..no_nodes {
-                length = DiskHnsw::serialize_node(&mut buf, length, node, &hnsw)?;
-                nodes_end.push(length)
-            }
-            for ends_at in nodes_end.into_iter().rev() {
-                buf.write_all(&ends_at.to_le_bytes())?;
-                length += USIZE_LEN;
-            }
-            let EntryPoint { node, layer } = entry_point;
-            buf.write_all(&layer.to_le_bytes())?;
-            buf.write_all(&(node.0 as usize).to_le_bytes())?;
-            let _length = length + 2 * USIZE_LEN;
-            buf.flush()?;
+        if no_nodes == 0 {
+            // Empty graph, nothing to serialize
+            return Ok(());
+        }
+
+        let mut length = 0;
+        let mut nodes_end = vec![];
+        for node in 0..no_nodes {
+            length = DiskHnsw::serialize_node(&mut buf, length, node, &hnsw)?;
+            nodes_end.push(length)
+        }
+        for ends_at in nodes_end.into_iter().rev() {
+            buf.write_all(&ends_at.to_le_bytes())?;
+            length += USIZE_LEN;
         }
+        let EntryPoint { node, layer } = hnsw.entry_point;
+        buf.write_all(&layer.to_le_bytes())?;
+        buf.write_all(&(node.0 as usize).to_le_bytes())?;
+        let _length = length + 2 * USIZE_LEN;
+        buf.flush()?;
+
         Ok(())
     }
     // hnsw must be serialized using DiskHnsw, may have trailing bytes at the start.
-    pub fn get_entry_point(hnsw: &[u8]) -> Option<EntryPoint> {
-        if !hnsw.is_empty() {
-            let node_start = hnsw.len() - USIZE_LEN;
-            let layer_start = node_start - USIZE_LEN;
-            let node_addr = usize_from_slice_le(&hnsw[node_start..(node_start + NODE_LEN)]);
-            let layer = usize_from_slice_le(&hnsw[layer_start..(layer_start + USIZE_LEN)]);
-            Some(EntryPoint {
-                node: VectorAddr(node_addr as u32),
-                layer,
-            })
-        } else {
-            None
+    pub fn get_entry_point(hnsw: &[u8]) -> EntryPoint {
+        assert!(!hnsw.is_empty());
+
+        let node_start = hnsw.len() - USIZE_LEN;
+        let layer_start = node_start - USIZE_LEN;
+        let node_addr = usize_from_slice_le(&hnsw[node_start..(node_start + NODE_LEN)]);
+        let layer = usize_from_slice_le(&hnsw[layer_start..(layer_start + USIZE_LEN)]);
+        EntryPoint {
+            node: VectorAddr(node_addr as u32),
+            layer,
         }
     }
     // hnsw must be serialized using MHnsw, may have trailing bytes at the start.
@@ -231,7 +235,12 @@ impl DiskHnsw {
                 let cnx_end = cnx_start + number_edges * CNX_LEN;
 
                 if number_edges > 0 {
-                    let ram_edges = ram.layers[layer_index].out.entry(VectorAddr(node_index)).or_default();
+                    let mut ram_edges = ram.layers[layer_index]
+                        .out
+                        .entry(VectorAddr(node_index))
+                        .or_default()
+                        .write()
+                        .unwrap();
                     let edges = EdgeIter {
                         crnt: 0,
                         buf: &hnsw[cnx_start..cnx_end],
@@ -259,9 +268,11 @@ impl DiskHnsw {
 
 #[cfg(test)]
 mod tests {
+    use std::sync::RwLock;
+
     use super::*;
     use crate::hnsw::ram_hnsw::RAMLayer;
-    fn layer_check<L: Layer>(buf: L, no_nodes: u32, cnx: &[Vec<(VectorAddr, Edge)>]) {
+    fn layer_check<L: SearchableLayer>(buf: L, no_nodes: u32, cnx: &[Vec<(VectorAddr, Edge)>]) {
         let no_cnx = vec![];
         for i in 0..no_nodes {
             let expected = cnx.get(i as usize).unwrap_or(&no_cnx);
@@ -274,8 +285,7 @@ mod tests {
         let hnsw = RAMHnsw::new();
         let mut buf = vec![];
         DiskHnsw::serialize_into(&mut buf, 0, hnsw).unwrap();
-        let ep = DiskHnsw::get_entry_point(&buf);
-        assert_eq!(ep, None);
+        assert!(buf.is_empty());
     }
 
     #[test]
@@ -290,7 +300,7 @@ mod tests {
             out: cnx0
                 .iter()
                 .enumerate()
-                .map(|(i, c)| (VectorAddr(i as u32), c.clone()))
+                .map(|(i, c)| (VectorAddr(i as u32), RwLock::new(c.clone())))
                 .collect(),
         };
         let cnx1 = vec![vec![(VectorAddr(1), 4.0)], vec![(VectorAddr(2), 5.0)]];
@@ -298,7 +308,7 @@ mod tests {
             out: cnx1
                 .iter()
                 .enumerate()
-                .map(|(i, c)| (VectorAddr(i as u32), c.clone()))
+                .map(|(i, c)| (VectorAddr(i as u32), RwLock::new(c.clone())))
                 .collect(),
         };
         let cnx2 = vec![vec![(VectorAddr(1), 6.0)]];
@@ -306,7 +316,7 @@ mod tests {
             out: cnx2
                 .iter()
                 .enumerate()
-                .map(|(i, c)| (VectorAddr(i as u32), c.clone()))
+                .map(|(i, c)| (VectorAddr(i as u32), RwLock::new(c.clone())))
                 .collect(),
         };
         let entry_point = EntryPoint {
@@ -314,11 +324,11 @@ mod tests {
             layer: 2,
         };
         let mut hnsw = RAMHnsw::new();
-        hnsw.entry_point = Some(entry_point);
+        hnsw.entry_point = entry_point;
         hnsw.layers = vec![layer0, layer1, layer2];
         let mut buf = vec![];
         DiskHnsw::serialize_into(&mut buf, no_nodes, hnsw).unwrap();
-        let ep = DiskHnsw::get_entry_point(&buf).unwrap();
+        let ep = DiskHnsw::get_entry_point(&buf);
         assert_eq!(ep, entry_point);
         let layer0 = buf.as_slice().get_layer(0);
         layer_check(layer0, no_nodes, &cnx0);
@@ -340,7 +350,7 @@ mod tests {
             out: cnx0
                 .iter()
                 .enumerate()
-                .map(|(i, c)| (VectorAddr(i as u32), c.clone()))
+                .map(|(i, c)| (VectorAddr(i as u32), RwLock::new(c.clone())))
                 .collect(),
         };
         let cnx1 = [vec![(VectorAddr(1), 4.0)], vec![(VectorAddr(2), 5.0)]];
@@ -348,7 +358,7 @@ mod tests {
             out: cnx1
                 .iter()
                 .enumerate()
-                .map(|(i, c)| (VectorAddr(i as u32), c.clone()))
+                .map(|(i, c)| (VectorAddr(i as u32), RwLock::new(c.clone())))
                 .collect(),
         };
         let cnx2 = [vec![(VectorAddr(1), 6.0)]];
@@ -356,7 +366,7 @@ mod tests {
             out: cnx2
                 .iter()
                 .enumerate()
-                .map(|(i, c)| (VectorAddr(i as u32), c.clone()))
+                .map(|(i, c)| (VectorAddr(i as u32), RwLock::new(c.clone())))
                 .collect(),
         };
         let entry_point = EntryPoint {
@@ -364,7 +374,7 @@ mod tests {
             layer: 2,
         };
         let mut hnsw = RAMHnsw::new();
-        hnsw.entry_point = Some(entry_point);
+        hnsw.entry_point = entry_point;
         hnsw.layers = vec![layer0, layer1, layer2];
         let mut buf = vec![];
         DiskHnsw::serialize_into(&mut buf, no_nodes, hnsw).unwrap();

nidx_binding-6.9.3.post624/nidx_vector/src/hnsw/ram_hnsw.rs

@@ -0,0 +1,178 @@
+// Copyright (C) 2021 Bosutech XXI S.L.
+//
+// nucliadb is offered under the AGPL v3.0 and as commercial software.
+// For commercial licensing, contact us at info@nuclia.com.
+//
+// AGPL:
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+
+use std::sync::{RwLock, RwLockReadGuard};
+
+use rustc_hash::FxHashMap;
+use search::{SearchableHnsw, SearchableLayer};
+
+use crate::VectorAddr;
+
+use super::*;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct EntryPoint {
+    pub node: VectorAddr,
+    pub layer: usize,
+}
+
+pub type Edge = f32;
+
+#[derive(Default)]
+pub struct RAMLayer {
+    pub(super) out: FxHashMap<VectorAddr, RwLock<Vec<(VectorAddr, Edge)>>>,
+}
+
+impl RAMLayer {
+    pub fn new() -> RAMLayer {
+        RAMLayer::default()
+    }
+
+    pub fn add_node(&mut self, node: VectorAddr) {
+        self.out.entry(node).or_default();
+    }
+
+    pub fn contains(&self, node: &VectorAddr) -> bool {
+        self.out.contains_key(node)
+    }
+
+    pub fn num_out_edges(&self, node: &VectorAddr) -> usize {
+        // This is called by the serialization code for all nodes and each layer, so we need to handle non-existing nodes
+        self.out.get(node).map(|n| n.read().unwrap().len()).unwrap_or(0)
+    }
+
+    /// Remove any links that point to a node which is not in this layer
+    /// See RAMHnsw.fix_broken_links for details
+    fn fix_broken_links(&self) {
+        for edges in self.out.values() {
+            let mut edges = edges.write().unwrap();
+            edges.retain(|e| self.out.contains_key(&e.0));
+        }
+    }
+}
+
+pub struct RAMHnsw {
+    pub entry_point: EntryPoint,
+    pub layers: Vec<RAMLayer>,
+}
+impl RAMHnsw {
+    pub fn new() -> RAMHnsw {
+        Self {
+            entry_point: EntryPoint {
+                node: VectorAddr(0),
+                layer: 0,
+            },
+            layers: vec![],
+        }
+    }
+
+    /// Adds a node to the graph at all layers below the selected top layer
+    pub fn add_node(&mut self, node: VectorAddr, top_layer: usize) {
+        for _ in self.layers.len()..=top_layer {
+            self.layers.push(RAMLayer::new());
+        }
+
+        for layer in 0..=top_layer {
+            self.layers[layer].add_node(node)
+        }
+    }
+
+    /// Updates the entrypoint to point to the first node of the top layer
+    pub fn update_entry_point(&mut self) {
+        // Only update if the entrypoint is not already at the top layer
+        if self.layers.len() > self.entry_point.layer + 1 {
+            self.entry_point = EntryPoint {
+                node: *self.layers.last().unwrap().out.keys().next().unwrap(),
+                layer: self.layers.len() - 1,
+            }
+        }
+    }
+
+    pub fn no_layers(&self) -> usize {
+        self.layers.len()
+    }
+
+    /// Remove any links that point to a node which is not in this layer
+    /// A bug in a previous version of this program could cause a node in layer N
+    /// to link to a node in layer N-1. This breaks navigation accross layer N.
+    /// This function will delete any such link from the graph.
+    pub fn fix_broken_links(&self) {
+        for l in &self.layers[1..] {
+            l.fix_broken_links();
+        }
+    }
+}
+
+pub struct EdgesIterator<'a>(RwLockReadGuard<'a, Vec<(VectorAddr, Edge)>>, usize);
+
+impl<'a> Iterator for EdgesIterator<'a> {
+    type Item = (VectorAddr, Edge);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let it = self.0.get(self.1);
+        self.1 += 1;
+        it.copied()
+    }
+}
+
+impl<'a> SearchableLayer for &'a RAMLayer {
+    type EdgeIt = EdgesIterator<'a>;
+    fn get_out_edges(&self, node: VectorAddr) -> Self::EdgeIt {
+        EdgesIterator(self.out[&node].read().unwrap(), 0)
+    }
+}
+
+impl<'a> SearchableHnsw for &'a RAMHnsw {
+    type L = &'a RAMLayer;
+    fn get_entry_point(&self) -> EntryPoint {
+        self.entry_point
+    }
+    fn get_layer(&self, i: usize) -> Self::L {
+        &self.layers[i]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_fix_broken_links() {
+        // Create a minimal broken graph
+        let layer0 = RAMLayer {
+            out: [
+                (VectorAddr(0), RwLock::new(vec![(VectorAddr(1), 0.5)])),
+                (VectorAddr(1), RwLock::new(vec![(VectorAddr(0), 0.5)])),
+            ]
+            .into_iter()
+            .collect(),
+        };
+        let layer1 = RAMLayer {
+            out: [(VectorAddr(0), RwLock::new(vec![(VectorAddr(1), 0.5)]))]
+                .into_iter()
+                .collect(),
+        };
+        let mut graph = RAMHnsw::new();
+        graph.layers.push(layer0);
+        graph.layers.push(layer1);
+        graph.fix_broken_links();
+        assert!(graph.layers[1].out[&VectorAddr(0)].read().unwrap().is_empty());
+    }
+}