nidx-binding 6.8.1.post513__tar.gz → 6.8.1.post515__tar.gz

{nidx_binding-6.8.1.post513 → nidx_binding-6.8.1.post515}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nidx_binding
-Version: 6.8.1.post513
+Version: 6.8.1.post515
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{nidx_binding-6.8.1.post513 → nidx_binding-6.8.1.post515}/nidx_protos/pyproject.toml

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

{nidx_binding-6.8.1.post513 → nidx_binding-6.8.1.post515}/nidx_vector/src/data_store/v1/store.rs

@@ -67,7 +67,7 @@ impl<T: AsRef<[u8]>> IntoBuffer for T {
 // O(1)
 // Returns how many elements are in x, alive or deleted.
 pub fn stored_elements(x: &[u8]) -> usize {
-    usize_from_slice_le(&x[..HEADER_LEN])
+    usize_from_slice_le(&x[..USIZE_LEN])
 }
 
 // O(1)
@@ -230,7 +230,7 @@ mod tests {
 
         let buf_map = unsafe { memmap2::Mmap::map(&buf).unwrap() };
         let no_values = stored_elements(&buf_map);
-        assert_eq!(no_values, expected.len());
+        assert_eq!(no_values as usize, expected.len());
         for (id, expected_value) in expected.iter().enumerate() {
             let actual_value = get_value(&buf_map, id);
             assert_eq!(actual_value.key(), expected_value.key);
@@ -275,7 +275,7 @@ mod tests {
             .map(|s| s.key().parse().unwrap())
             .collect();
 
-        assert_eq!(number_of_elements, values.len());
+        assert_eq!(number_of_elements as usize, values.len());
         assert_eq!(values.len(), expected.len());
         assert!(values.iter().all(|i| expected.contains(i)));
     }
@@ -317,7 +317,7 @@ mod tests {
             .map(|s| s.key().parse().unwrap())
             .collect();
 
-        assert_eq!(number_of_elements, values.len());
+        assert_eq!(number_of_elements as usize, values.len());
         assert_eq!(values.len(), expected.len());
         assert!(values.iter().all(|i| expected.contains(i)));
     }
@@ -358,7 +358,7 @@ mod tests {
             .map(|s| s.key().parse().unwrap())
             .collect();
 
-        assert_eq!(number_of_elements, values.len());
+        assert_eq!(number_of_elements as usize, values.len());
         assert_eq!(values.len(), expected.len());
         assert!(values.iter().all(|i| expected.contains(i)));
     }
@@ -399,7 +399,7 @@ mod tests {
             .map(|s| s.key().parse().unwrap())
             .collect();
 
-        assert_eq!(number_of_elements, values.len());
+        assert_eq!(number_of_elements as usize, values.len());
         assert_eq!(values.len(), expected.len());
         assert!(values.iter().all(|i| expected.contains(i)));
     }
@@ -440,7 +440,7 @@ mod tests {
             .map(|s| s.key().parse().unwrap())
             .collect();
 
-        assert_eq!(number_of_elements, values.len());
+        assert_eq!(number_of_elements as usize, values.len());
         assert_eq!(values.len(), expected.len());
         assert!(values.iter().all(|i| expected.contains(i)));
     }
@@ -482,7 +482,7 @@ mod tests {
             .map(|s| s.key().parse().unwrap())
             .collect();
 
-        assert_eq!(number_of_elements, values.len());
+        assert_eq!(number_of_elements as usize, values.len());
         assert_eq!(values.len(), expected.len());
         assert!(values.iter().all(|i| expected.contains(i)));
     }

{nidx_binding-6.8.1.post513 → nidx_binding-6.8.1.post515}/nidx_vector/src/data_store/v1.rs

@@ -46,11 +46,11 @@ impl DataStore for DataStoreV1 {
         self.nodes.len()
     }
 
-    fn stored_paragraph_count(&self) -> usize {
-        store::stored_elements(&self.nodes)
+    fn stored_paragraph_count(&self) -> u32 {
+        store::stored_elements(&self.nodes) as u32
     }
 
-    fn stored_vector_count(&self) -> usize {
+    fn stored_vector_count(&self) -> u32 {
         self.stored_paragraph_count()
     }
 

{nidx_binding-6.8.1.post513 → nidx_binding-6.8.1.post515}/nidx_vector/src/data_store/v2/paragraph_store.rs

@@ -106,8 +106,8 @@ impl ParagraphStore {
         self.data.len() + self.pos.len()
     }
 
-    pub fn stored_elements(&self) -> usize {
-        self.pos.len() / U32_LEN
+    pub fn stored_elements(&self) -> u32 {
+        (self.pos.len() / U32_LEN) as u32
     }
 }
 

{nidx_binding-6.8.1.post513 → nidx_binding-6.8.1.post515}/nidx_vector/src/data_store/v2/vector_store.rs

@@ -85,8 +85,8 @@ impl VectorStore {
         self.data.len()
     }
 
-    pub fn stored_elements(&self) -> usize {
-        self.data.len() / (self.record_len_bytes)
+    pub fn stored_elements(&self) -> u32 {
+        (self.data.len() / (self.record_len_bytes)) as u32
     }
 
     fn record_start(&self, VectorAddr(addr): VectorAddr) -> usize {

{nidx_binding-6.8.1.post513 → nidx_binding-6.8.1.post515}/nidx_vector/src/data_store/v2.rs

@@ -91,11 +91,11 @@ impl DataStore for DataStoreV2 {
         self.vectors.size_bytes() + self.paragraphs.size_bytes()
     }
 
-    fn stored_paragraph_count(&self) -> usize {
+    fn stored_paragraph_count(&self) -> u32 {
         self.paragraphs.stored_elements()
     }
 
-    fn stored_vector_count(&self) -> usize {
+    fn stored_vector_count(&self) -> u32 {
         self.vectors.stored_elements()
     }
 

{nidx_binding-6.8.1.post513 → nidx_binding-6.8.1.post515}/nidx_vector/src/data_store.rs

@@ -90,8 +90,8 @@ impl ParagraphRef<'_> {
 
 pub trait DataStore: Sync + Send {
     fn size_bytes(&self) -> usize;
-    fn stored_paragraph_count(&self) -> usize;
-    fn stored_vector_count(&self) -> usize;
+    fn stored_paragraph_count(&self) -> u32;
+    fn stored_vector_count(&self) -> u32;
     fn get_paragraph(&self, id: ParagraphAddr) -> ParagraphRef;
     fn get_vector(&self, id: VectorAddr) -> VectorRef;
     fn will_need(&self, id: VectorAddr);
@@ -99,5 +99,5 @@ pub trait DataStore: Sync + Send {
 }
 
 pub fn iter_paragraphs(data_store: &impl DataStore) -> impl Iterator<Item = ParagraphAddr> {
-    (0..data_store.stored_paragraph_count() as u32).map(ParagraphAddr)
+    (0..data_store.stored_paragraph_count()).map(ParagraphAddr)
 }

{nidx_binding-6.8.1.post513 → nidx_binding-6.8.1.post515}/nidx_vector/src/hnsw/disk_hnsw.rs

@@ -46,9 +46,9 @@
 use std::collections::HashMap;
 use std::io;
 
-use super::Address;
 use super::ops_hnsw::{Hnsw, Layer};
 use super::ram_hnsw::{Edge, EntryPoint, RAMHnsw, RAMLayer};
+use crate::VectorAddr;
 use crate::data_types::usize_utils::*;
 
 const EDGE_LEN: usize = 4;
@@ -68,16 +68,16 @@ pub struct DiskLayer<'a> {
 
 impl<'a> Layer for &'a DiskLayer<'a> {
     type EdgeIt = EdgeIter<'a>;
-    fn get_out_edges(&self, Address(node): Address) -> Self::EdgeIt {
-        let node = DiskHnsw::get_node(self.hnsw, node);
+    fn get_out_edges(&self, address: VectorAddr) -> Self::EdgeIt {
+        let node = DiskHnsw::get_node(self.hnsw, address);
         DiskHnsw::get_out_edges(node, self.layer)
     }
 }
 
 impl<'a> Layer for DiskLayer<'a> {
     type EdgeIt = EdgeIter<'a>;
-    fn get_out_edges(&self, Address(node): Address) -> Self::EdgeIt {
-        let node = DiskHnsw::get_node(self.hnsw, node);
+    fn get_out_edges(&self, address: VectorAddr) -> Self::EdgeIt {
+        let node = DiskHnsw::get_node(self.hnsw, address);
         DiskHnsw::get_out_edges(node, self.layer)
     }
 }
@@ -97,30 +97,30 @@ pub struct EdgeIter<'a> {
     buf: &'a [u8],
 }
 impl Iterator for EdgeIter<'_> {
-    type Item = (Address, Edge);
+    type Item = (VectorAddr, Edge);
     fn next(&mut self) -> Option<Self::Item> {
         if self.buf.len() == self.crnt {
             None
         } else {
             let buf = self.buf;
             let mut crnt = self.crnt;
-            let node = usize_from_slice_le(&buf[crnt..(crnt + NODE_LEN)]);
+            let node_addr = usize_from_slice_le(&buf[crnt..(crnt + NODE_LEN)]);
             crnt += USIZE_LEN;
             let edge = f32_from_le_bytes(&buf[crnt..(crnt + EDGE_LEN)]);
             crnt += EDGE_LEN;
             self.crnt = crnt;
-            Some((Address(node), edge))
+            Some((VectorAddr(node_addr as u32), edge))
         }
     }
 }
 
 pub struct DiskHnsw;
 impl DiskHnsw {
-    fn serialize_node<W>(mut buf: W, offset: usize, node: usize, hnsw: &RAMHnsw) -> io::Result<usize>
+    fn serialize_node<W>(mut buf: W, offset: usize, node_addr: u32, hnsw: &RAMHnsw) -> io::Result<usize>
     where
         W: io::Write,
     {
-        let node = Address(node);
+        let node = VectorAddr(node_addr);
         let mut length = offset;
         let mut indexing = HashMap::new();
         for layer in 0..hnsw.no_layers() {
@@ -129,7 +129,7 @@ impl DiskHnsw {
             buf.write_all(&no_edges.to_le_bytes())?;
             length += USIZE_LEN;
             for (cnx, edge) in hnsw.get_layer(layer).get_out_edges(node) {
-                buf.write_all(&cnx.0.to_le_bytes())?;
+                buf.write_all(&(cnx.0 as usize).to_le_bytes())?;
                 buf.write_all(&edge.to_le_bytes())?;
                 length += CNX_LEN;
             }
@@ -157,7 +157,7 @@ impl DiskHnsw {
             buf: &node[cnx_start..cnx_end],
         }
     }
-    pub fn serialize_into<W: io::Write>(mut buf: W, no_nodes: usize, hnsw: RAMHnsw) -> io::Result<()> {
+    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![];
@@ -171,7 +171,7 @@ impl DiskHnsw {
             }
             let EntryPoint { node, layer } = entry_point;
             buf.write_all(&layer.to_le_bytes())?;
-            buf.write_all(&node.0.to_le_bytes())?;
+            buf.write_all(&(node.0 as usize).to_le_bytes())?;
             let _length = length + 2 * USIZE_LEN;
             buf.flush()?;
         }
@@ -182,10 +182,10 @@ impl DiskHnsw {
         if !hnsw.is_empty() {
             let node_start = hnsw.len() - USIZE_LEN;
             let layer_start = node_start - USIZE_LEN;
-            let node = usize_from_slice_le(&hnsw[node_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: Address(node),
+                node: VectorAddr(node_addr as u32),
                 layer,
             })
         } else {
@@ -194,12 +194,12 @@ impl DiskHnsw {
     }
     // hnsw must be serialized using MHnsw, may have trailing bytes at the start.
     // The returned node will have trailing bytes at the start.
-    pub fn get_node(hnsw: &[u8], node: usize) -> &[u8] {
+    pub fn get_node(hnsw: &[u8], address: VectorAddr) -> &[u8] {
         let indexing_end = hnsw.len() - (2 * USIZE_LEN);
         // node + 1 since the layers are stored in reverse order.
         // [n3, n2, n1, n0, end] Since we have the position of end, the node i is
         // i + 1 positions to its left.
-        let pos = indexing_end - ((node + 1) * USIZE_LEN);
+        let pos = indexing_end - ((address.0 as usize + 1) * USIZE_LEN);
         let node_end = usize_from_slice_le(&hnsw[pos..(pos + USIZE_LEN)]);
         &hnsw[..node_end]
     }
@@ -213,9 +213,9 @@ impl DiskHnsw {
         let end = hnsw.len();
         ram.entry_point = Self::get_entry_point(hnsw);
 
-        let mut node_index = 0;
+        let mut node_index: u32 = 0;
         loop {
-            let indexing_pos = end - (node_index + 3) * USIZE_LEN;
+            let indexing_pos = end - (node_index as usize + 3) * USIZE_LEN;
             let node_end = usize_from_slice_le(&hnsw[indexing_pos..indexing_pos + USIZE_LEN]);
             let mut layer_index = 0;
             loop {
@@ -231,7 +231,7 @@ impl DiskHnsw {
                 let cnx_end = cnx_start + number_edges * CNX_LEN;
 
                 if number_edges > 0 {
-                    let ram_edges = ram.layers[layer_index].out.entry(Address(node_index)).or_default();
+                    let ram_edges = ram.layers[layer_index].out.entry(VectorAddr(node_index)).or_default();
                     let edges = EdgeIter {
                         crnt: 0,
                         buf: &hnsw[cnx_start..cnx_end],
@@ -261,11 +261,11 @@ impl DiskHnsw {
 mod tests {
     use super::*;
     use crate::hnsw::ram_hnsw::RAMLayer;
-    fn layer_check<L: Layer>(buf: L, no_nodes: usize, cnx: &[Vec<(Address, Edge)>]) {
+    fn layer_check<L: Layer>(buf: L, no_nodes: u32, cnx: &[Vec<(VectorAddr, Edge)>]) {
         let no_cnx = vec![];
         for i in 0..no_nodes {
-            let expected = cnx.get(i).unwrap_or(&no_cnx);
-            let got: Vec<_> = buf.get_out_edges(Address(i)).collect();
+            let expected = cnx.get(i as usize).unwrap_or(&no_cnx);
+            let got: Vec<_> = buf.get_out_edges(VectorAddr(i)).collect();
             assert_eq!(expected, &got);
         }
     }
@@ -282,23 +282,35 @@ mod tests {
     fn hnsw_test() {
         let no_nodes = 3;
         let cnx0 = vec![
-            vec![(Address(1), 1.0)],
-            vec![(Address(2), 2.0)],
-            vec![(Address(3), 3.0)],
+            vec![(VectorAddr(1), 1.0)],
+            vec![(VectorAddr(2), 2.0)],
+            vec![(VectorAddr(3), 3.0)],
         ];
         let layer0 = RAMLayer {
-            out: cnx0.iter().enumerate().map(|(i, c)| (Address(i), c.clone())).collect(),
+            out: cnx0
+                .iter()
+                .enumerate()
+                .map(|(i, c)| (VectorAddr(i as u32), c.clone()))
+                .collect(),
         };
-        let cnx1 = vec![vec![(Address(1), 4.0)], vec![(Address(2), 5.0)]];
+        let cnx1 = vec![vec![(VectorAddr(1), 4.0)], vec![(VectorAddr(2), 5.0)]];
         let layer1 = RAMLayer {
-            out: cnx1.iter().enumerate().map(|(i, c)| (Address(i), c.clone())).collect(),
+            out: cnx1
+                .iter()
+                .enumerate()
+                .map(|(i, c)| (VectorAddr(i as u32), c.clone()))
+                .collect(),
         };
-        let cnx2 = vec![vec![(Address(1), 6.0)]];
+        let cnx2 = vec![vec![(VectorAddr(1), 6.0)]];
         let layer2 = RAMLayer {
-            out: cnx2.iter().enumerate().map(|(i, c)| (Address(i), c.clone())).collect(),
+            out: cnx2
+                .iter()
+                .enumerate()
+                .map(|(i, c)| (VectorAddr(i as u32), c.clone()))
+                .collect(),
         };
         let entry_point = EntryPoint {
-            node: Address(0),
+            node: VectorAddr(0),
             layer: 2,
         };
         let mut hnsw = RAMHnsw::new();
@@ -320,23 +332,35 @@ mod tests {
     fn hnsw_deserialize_test() {
         let no_nodes = 3;
         let cnx0 = [
-            vec![(Address(1), 1.0)],
-            vec![(Address(2), 2.0)],
-            vec![(Address(3), 3.0)],
+            vec![(VectorAddr(1), 1.0)],
+            vec![(VectorAddr(2), 2.0)],
+            vec![(VectorAddr(3), 3.0)],
         ];
         let layer0 = RAMLayer {
-            out: cnx0.iter().enumerate().map(|(i, c)| (Address(i), c.clone())).collect(),
+            out: cnx0
+                .iter()
+                .enumerate()
+                .map(|(i, c)| (VectorAddr(i as u32), c.clone()))
+                .collect(),
         };
-        let cnx1 = [vec![(Address(1), 4.0)], vec![(Address(2), 5.0)]];
+        let cnx1 = [vec![(VectorAddr(1), 4.0)], vec![(VectorAddr(2), 5.0)]];
         let layer1 = RAMLayer {
-            out: cnx1.iter().enumerate().map(|(i, c)| (Address(i), c.clone())).collect(),
+            out: cnx1
+                .iter()
+                .enumerate()
+                .map(|(i, c)| (VectorAddr(i as u32), c.clone()))
+                .collect(),
         };
-        let cnx2 = [vec![(Address(1), 6.0)]];
+        let cnx2 = [vec![(VectorAddr(1), 6.0)]];
         let layer2 = RAMLayer {
-            out: cnx2.iter().enumerate().map(|(i, c)| (Address(i), c.clone())).collect(),
+            out: cnx2
+                .iter()
+                .enumerate()
+                .map(|(i, c)| (VectorAddr(i as u32), c.clone()))
+                .collect(),
         };
         let entry_point = EntryPoint {
-            node: Address(0),
+            node: VectorAddr(0),
             layer: 2,
         };
         let mut hnsw = RAMHnsw::new();

{nidx_binding-6.8.1.post513 → nidx_binding-6.8.1.post515}/nidx_vector/src/hnsw/ops_hnsw.rs

@@ -27,26 +27,26 @@ use rustc_hash::FxHashSet;
 use std::cmp::{Ordering, Reverse};
 use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
 
-use crate::ParagraphAddr;
 use crate::inverted_index::FilterBitSet;
+use crate::{ParagraphAddr, VectorAddr};
 
 use super::params;
 use super::*;
 
 /// Implementors of this trait can guide the hnsw search
 pub trait DataRetriever: std::marker::Sync {
-    fn similarity(&self, x: Address, y: Address) -> f32;
-    fn paragraph(&self, x: Address) -> ParagraphAddr;
-    fn get_vector(&self, x: Address) -> &[u8];
+    fn similarity(&self, x: VectorAddr, y: VectorAddr) -> f32;
+    fn paragraph(&self, x: VectorAddr) -> ParagraphAddr;
+    fn get_vector(&self, x: VectorAddr) -> &[u8];
     /// Embeddings with smaller similarity should not be considered.
     fn min_score(&self) -> f32;
-    fn will_need(&self, x: Address);
+    fn will_need(&self, x: VectorAddr);
 }
 
 /// Implementors of this trait are layers of an HNSW where a nearest neighbour search can be ran.
 pub trait Layer {
-    type EdgeIt: Iterator<Item = (Address, Edge)>;
-    fn get_out_edges(&self, node: Address) -> Self::EdgeIt;
+    type EdgeIt: Iterator<Item = (VectorAddr, Edge)>;
+    fn get_out_edges(&self, node: VectorAddr) -> Self::EdgeIt;
 }
 
 /// Implementors of this trait are an HNSW where search can be ran.
@@ -56,11 +56,11 @@ pub trait Hnsw {
     fn get_layer(&self, i: usize) -> Self::L;
 }
 
-///  Tuples ([`Address`], [`f32`]) can not be stored in a [`BinaryHeap`] because [`f32`] does not
+///  Tuples ([`VectorAddr`], [`f32`]) can not be stored in a [`BinaryHeap`] because [`f32`] does not
 /// implement [`Ord`]. [`Cnx`] is an application of the new-type pattern that lets us bypass the
 /// orphan rules and store such tuples in a [`BinaryHeap`].
 #[derive(Clone, Copy)]
-pub struct Cnx(pub Address, pub f32);
+pub struct Cnx(pub VectorAddr, pub f32);
 impl Eq for Cnx {}
 impl Ord for Cnx {
     fn cmp(&self, other: &Self) -> Ordering {
@@ -79,7 +79,7 @@ impl PartialOrd for Cnx {
 }
 
 /// A list of neighbours containing a pointer to the embedding and their similarity.
-pub type Neighbours = Vec<(Address, f32)>;
+pub type Neighbours = Vec<(VectorAddr, f32)>;
 
 /// Guides an algorithm to the valid nodes.
 struct NodeFilter<'a, DR> {
@@ -94,7 +94,7 @@ impl<DR: DataRetriever> NodeFilter<'_, DR> {
         self.filter.contains(n)
     }
 
-    pub fn is_valid(&self, n: Address, score: f32) -> bool {
+    pub fn is_valid(&self, n: VectorAddr, score: f32) -> bool {
         !score.is_nan()
         // Reject the candidate if we already have a result for the same paragraph
         && !self.paragraphs.contains(&self.retriever.paragraph(n))
@@ -104,7 +104,7 @@ impl<DR: DataRetriever> NodeFilter<'_, DR> {
 
     /// Adds a result so that further candidates with the same vector
     /// or paragraph will get rejected.
-    pub fn add_result(&mut self, n: Address) {
+    pub fn add_result(&mut self, n: VectorAddr) {
         self.paragraphs.insert(self.retriever.paragraph(n));
         self.vec_counter.add(self.retriever.get_vector(n));
     }
@@ -121,9 +121,9 @@ impl<'a, DR: DataRetriever> HnswOps<'a, DR> {
     fn select_neighbours_heuristic(
         &self,
         k_neighbours: usize,
-        candidates: Vec<(Address, Edge)>,
+        candidates: Vec<(VectorAddr, Edge)>,
         layer: &RAMLayer,
-    ) -> Vec<(Address, Edge)> {
+    ) -> Vec<(VectorAddr, Edge)> {
         let mut results = Vec::new();
         let mut discarded = BinaryHeap::new();
 
@@ -163,7 +163,7 @@ impl<'a, DR: DataRetriever> HnswOps<'a, DR> {
 
         results
     }
-    fn similarity(&self, x: Address, y: Address) -> f32 {
+    fn similarity(&self, x: VectorAddr, y: VectorAddr) -> f32 {
         self.retriever.similarity(x, y)
     }
     fn get_random_layer(&mut self) -> usize {
@@ -173,19 +173,19 @@ impl<'a, DR: DataRetriever> HnswOps<'a, DR> {
     }
     fn closest_up_nodes<L: Layer>(
         &'a self,
-        entry_points: Vec<Address>,
-        query: Address,
+        entry_points: Vec<VectorAddr>,
+        query: VectorAddr,
         layer: L,
         number_of_results: usize,
         mut filter: NodeFilter<'a, DR>,
-    ) -> Vec<(Address, f32)> {
+    ) -> Vec<(VectorAddr, f32)> {
         // We just need to perform BFS, the replacement is the closest node to the actual
         // best solution. This algorithm takes a lazy approach to computing the similarity of
         // candidates.
 
         const MAX_VECTORS_TO_PRELOAD: u32 = 20_000;
         let mut results = Vec::new();
-        let inner_entry_points_iter = entry_points.iter().map(|Address(inner)| *inner);
+        let inner_entry_points_iter = entry_points.iter().map(|VectorAddr(inner)| *inner as usize);
         let mut visited_nodes: BitSet = BitSet::from_iter(inner_entry_points_iter);
         let mut candidates = VecDeque::from(entry_points);
 
@@ -215,8 +215,8 @@ impl<'a, DR: DataRetriever> HnswOps<'a, DR> {
             let mut sorted_out: Vec<_> = layer.get_out_edges(candidate).collect();
             sorted_out.sort_by(|a, b| b.1.total_cmp(&a.1));
             sorted_out.into_iter().for_each(|(new_candidate, _)| {
-                if !visited_nodes.contains(new_candidate.0) {
-                    visited_nodes.insert(new_candidate.0);
+                if !visited_nodes.contains(new_candidate.0 as usize) {
+                    visited_nodes.insert(new_candidate.0 as usize);
                     candidates.push_back(new_candidate);
 
                     if self.preload_nodes && preloaded < MAX_VECTORS_TO_PRELOAD {
@@ -231,10 +231,10 @@ impl<'a, DR: DataRetriever> HnswOps<'a, DR> {
     }
     fn layer_search<L: Layer>(
         &self,
-        x: Address,
+        x: VectorAddr,
         layer: L,
         k_neighbours: usize,
-        entry_points: &[Address],
+        entry_points: &[VectorAddr],
     ) -> Neighbours {
         let mut visited = FxHashSet::default();
         let mut candidates = BinaryHeap::new();
@@ -280,7 +280,13 @@ impl<'a, DR: DataRetriever> HnswOps<'a, DR> {
             .collect()
     }
 
-    fn layer_insert(&self, x: Address, layer: &mut RAMLayer, entry_points: &[Address], mmax: usize) -> Vec<Address> {
+    fn layer_insert(
+        &self,
+        x: VectorAddr,
+        layer: &mut RAMLayer,
+        entry_points: &[VectorAddr],
+        mmax: usize,
+    ) -> Vec<VectorAddr> {
         use params::*;
         let neighbours = self.layer_search::<&RAMLayer>(x, layer, ef_construction(), entry_points);
         let neighbours = self.select_neighbours_heuristic(m(), neighbours, layer);
@@ -304,7 +310,7 @@ impl<'a, DR: DataRetriever> HnswOps<'a, DR> {
         }
         result
     }
-    pub fn insert(&mut self, x: Address, hnsw: &mut RAMHnsw) {
+    pub fn insert(&mut self, x: VectorAddr, hnsw: &mut RAMHnsw) {
         match hnsw.entry_point {
             None => {
                 let top_level = self.get_random_layer();
@@ -331,7 +337,7 @@ impl<'a, DR: DataRetriever> HnswOps<'a, DR> {
 
     pub fn search<H: Hnsw>(
         &self,
-        query: Address,
+        query: VectorAddr,
         hnsw: H,
         k_neighbours: usize,
         with_filter: &FilterBitSet,

{nidx_binding-6.8.1.post513 → nidx_binding-6.8.1.post515}/nidx_vector/src/hnsw/ram_hnsw.rs

@@ -21,13 +21,15 @@
 use ops_hnsw::{Hnsw, Layer};
 use rustc_hash::FxHashMap;
 
+use crate::VectorAddr;
+
 use super::*;
 
-const NO_EDGES: [(Address, Edge); 0] = [];
+const NO_EDGES: [(VectorAddr, Edge); 0] = [];
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
 pub struct EntryPoint {
-    pub node: Address,
+    pub node: VectorAddr,
     pub layer: usize,
 }
 
@@ -35,11 +37,11 @@ pub type Edge = f32;
 
 #[derive(Default, Clone)]
 pub struct RAMLayer {
-    pub out: FxHashMap<Address, Vec<(Address, Edge)>>,
+    pub out: FxHashMap<VectorAddr, Vec<(VectorAddr, Edge)>>,
 }
 
 impl RAMLayer {
-    fn out_edges(&self, node: Address) -> std::iter::Copied<std::slice::Iter<'_, (Address, Edge)>> {
+    fn out_edges(&self, node: VectorAddr) -> std::iter::Copied<std::slice::Iter<'_, (VectorAddr, Edge)>> {
         self.out
             .get(&node)
             .map_or_else(|| NO_EDGES.iter().copied(), |out| out.iter().copied())
@@ -47,21 +49,21 @@ impl RAMLayer {
     pub fn new() -> RAMLayer {
         RAMLayer::default()
     }
-    pub fn add_node(&mut self, node: Address) {
+    pub fn add_node(&mut self, node: VectorAddr) {
         self.out.entry(node).or_default();
     }
-    pub fn add_edge(&mut self, from: Address, edge: Edge, to: Address) {
+    pub fn add_edge(&mut self, from: VectorAddr, edge: Edge, to: VectorAddr) {
         if let Some(edges) = self.out.get_mut(&from) {
             edges.push((to, edge))
         }
     }
-    pub fn take_out_edges(&mut self, x: Address) -> Vec<(Address, Edge)> {
+    pub fn take_out_edges(&mut self, x: VectorAddr) -> Vec<(VectorAddr, Edge)> {
         self.out.get_mut(&x).map(std::mem::take).unwrap_or_default()
     }
-    pub fn no_out_edges(&self, node: Address) -> usize {
+    pub fn no_out_edges(&self, node: VectorAddr) -> usize {
         self.out.get(&node).map_or(0, |v| v.len())
     }
-    pub fn first(&self) -> Option<Address> {
+    pub fn first(&self) -> Option<VectorAddr> {
         self.out.keys().next().cloned()
     }
     pub fn is_empty(&self) -> bool {
@@ -78,7 +80,7 @@ impl RAMHnsw {
     pub fn new() -> RAMHnsw {
         Self::default()
     }
-    pub fn increase_layers_with(&mut self, x: Address, level: usize) -> &mut Self {
+    pub fn increase_layers_with(&mut self, x: VectorAddr, level: usize) -> &mut Self {
         while self.layers.len() <= level {
             let mut new_layer = RAMLayer::new();
             new_layer.add_node(x);
@@ -109,8 +111,8 @@ impl RAMHnsw {
 }
 
 impl<'a> Layer for &'a RAMLayer {
-    type EdgeIt = std::iter::Copied<std::slice::Iter<'a, (Address, Edge)>>;
-    fn get_out_edges(&self, node: Address) -> Self::EdgeIt {
+    type EdgeIt = std::iter::Copied<std::slice::Iter<'a, (VectorAddr, Edge)>>;
+    fn get_out_edges(&self, node: VectorAddr) -> Self::EdgeIt {
         self.out_edges(node)
     }
 }