order distance

Author: shisoft

src/apps/hnsw/partition/search.rs

@@ -601,6 +601,11 @@ impl HnswOnlinePartition {
         Ok(())
     }
 
+    
+    /// Performs a breadth-first search to find the top K closest vertices to the query
+    /// 
+    /// Returns a vector of tuples (vertex_id, cell_id, distance) containing the k vertices
+    /// nearest to the query vector, sorted by distance in ascending order.
     async fn bfs_top_k<M: HnswMetric>(
         &self,
         starting_vertices: &[Id],
@@ -614,15 +619,20 @@ impl HnswOnlinePartition {
         job_id: JobId,
     ) -> Result<Vec<(Id, Id, Distance)>, HNSWIndexError> {
         // Priority queue to maintain vertices ordered by distance
-        let mut top_k = BinaryHeap::<ReverseOrd<(OrderedFloat, Id, Id)>>::with_capacity(k + 1);
+        let mut top_k = BinaryHeap::<(OrderedFloat, Id, Id)>::with_capacity(k + 1);
 
         // Queue for BFS traversal
         let mut queue = VecDeque::new();
-        queue.extend(starting_vertices.iter().cloned());
-
+        
         // Track visited vertices to avoid cycles
         let mut visited = HashSet::<Id>::default();
-        visited.extend(starting_vertices.iter().cloned());
+        
+        // Push starting vertices and mark them as visited at enqueue time
+        for &vertex in starting_vertices {
+            if visited.insert(vertex) {  // Returns true if the value was not present
+                queue.push_back(vertex);
+            }
+        }
 
         while let Some(current_vertex) = queue.pop_front() {
             // Get distance for the current vertex
@@ -637,40 +647,34 @@ impl HnswOnlinePartition {
                 job_id,
             ) {
                 // Use max heap with negative distance for top-k minimum
-                top_k.push(ReverseOrd((
+                // top_k.push(ReverseOrd((
+                //     OrderedFloat(distance),
+                //     current_vertex,
+                //     cell_id,
+                // )));
+                top_k.push((
                     OrderedFloat(distance),
                     current_vertex,
                     cell_id,
-                )));
+                ));
 
                 // If we have more than k elements, remove the largest one
                 if top_k.len() > k {
                     top_k.pop();
                 }
 
-                visited.insert(current_vertex);
                 // Get all neighbors of the current vertex
                 match self.engine.node_local_neighbour_id_and_edge(
                     &current_vertex,
                     level_schema,
                     EdgeDirection::Undirected,
                 ) {
                     Ok(neighbors) => {
-                        append_job_log(
-                            logger,
-                            job_id,
-                            JobLogLevel::Info,
-                            format!(
-                                "Found {} neighbors for vertex {:?} with level schema {}",
-                                neighbors.len(),
-                                current_vertex,
-                                level_schema
-                            ),
-                        );
                         for (neighbor_id, _) in neighbors {
                             let is_local = self.conshash.get_server_id(neighbor_id.higher)
                                 == Some(self.server_id);
-                            if is_local && !visited.contains(&neighbor_id) {
+                            // Only enqueue if local and not yet visited
+                            if is_local && visited.insert(neighbor_id) {
                                 queue.push_back(neighbor_id);
                             }
                         }
@@ -704,11 +708,11 @@ impl HnswOnlinePartition {
 
         // Convert the max heap with negative distances back to sorted results
         let mut result: Vec<_> = top_k.into_iter().collect();
-        result.sort_by(|a, b| b.0.cmp(&a.0));
+        result.sort_by(|a, b| a.0.cmp(&b.0));
 
         Ok(result
             .into_iter()
-            .map(|ReverseOrd((dist, vid, cid))| (vid, cid, dist.0))
+            .map(|(dist, vid, cid)| (vid, cid, dist.0))
             .collect())
     }
 
@@ -917,11 +921,12 @@ impl HnswOnlinePartition {
                 job_id,
                 JobLogLevel::Info,
                 format!(
-                    "Found {} nearest neighbors at level {} for vertex {:?}, with entry points {:?}",
+                    "Found {} nearest neighbors at level {} for vertex {:?}, with entry points {:?}. List of vertices: {}",
                     nearest_neighbors.len(),
                     level,
                     vertex_id,
-                    entry_points
+                    entry_points,
+                    nearest_neighbors.iter().map(|(id, _, d)| format!("{:?}: {}", id, d)).collect::<Vec<_>>().join(", ")
                 ),
             );
             // Apply the neighbor selection heuristic to choose diverse neighbors

src/graph/id_list.rs

@@ -968,10 +968,11 @@ impl<'a> Iterator for LocalIdListSegmentIdIterator<'a> {
         if !self.next.is_unit_id() {
             let cell = self.chunks.read_selected(&self.next, &*NEXT_KEY_ID_VEC);
             if let Ok(fields) = cell {
+                let current_id = self.next;
                 if let SharedValue::Id(ref id) = fields.data[0usize] {
                     self.next = **id;
                     self.level += 1;
-                    return Some(self.next);
+                    return Some(current_id);
                 } else {
                     error!("Expecting Id but got: {:?}", fields.data[0usize]);
                 }
@@ -1060,6 +1061,9 @@ impl<'a> LocalIdList<'a> {
                     return Ok(Err(IdListError::ContainerCellNotReady));
                 }
             }
+            SharedValue::Null | SharedValue::NA => {
+                return Ok(Err(IdListError::ContainerCellNotReady));
+            }
             _ => {
                 error!(
                     "Cannot find type list id for container id {:?}",
@@ -1137,6 +1141,7 @@ impl<'a> LocalIdList<'a> {
 
     /// Returns an iterator over all IDs in the list
     pub fn iter(&mut self) -> Result<Result<LocalIdListIterator, IdListError>, ReadError> {
+        // Get the root list id
         let list_root_id = match self.get_root_list_id()? {
             Ok(id) => id,
             Err(e) => return Ok(Err(e)),