Fix recall computation for beta-filtered search in benchmark

diskann-benchmark/src/index/benchmarks.rs

@@ -13,6 +13,7 @@ use diskann::{
 };
 use diskann_benchmark_core::{
     self as benchmark_core,
+    recall::GroundTruthMode,
     streaming::{executors::bigann, Executor},
 };
 use diskann_benchmark_runner::{
@@ -470,7 +471,12 @@ impl search::Plugin<FullPrecisionProvider<f32>, SearchPhase, Strategy<common::Fu
             inmem::DeterminantDiversity::new(params),
         )?;
 
-        let steps = search::knn::SearchSteps::new(phase.reps, &phase.num_threads, &phase.runs);
+        let steps = search::knn::SearchSteps::new(
+            phase.reps,
+            &phase.num_threads,
+            &phase.runs,
+            GroundTruthMode::Fixed,
+        );
         let results = search::knn::run(&knn, &groundtruth, steps)?;
 
         Ok(AggregatedSearchResults::Topk(results))
@@ -519,7 +525,12 @@ where
             benchmark_core::search::graph::Strategy::broadcast(strategy.inner()),
         )?;
 
-        let steps = search::knn::SearchSteps::new(topk.reps, &topk.num_threads, &topk.runs);
+        let steps = search::knn::SearchSteps::new(
+            topk.reps,
+            &topk.num_threads,
+            &topk.runs,
+            GroundTruthMode::Fixed,
+        );
 
         let results = search::knn::run(&knn, &groundtruth, steps)?;
         Ok(AggregatedSearchResults::Topk(results))
@@ -634,6 +645,7 @@ where
             beta_filter.reps,
             &beta_filter.num_threads,
             &beta_filter.runs,
+            GroundTruthMode::Flexible,
         );
 
         let result = search::knn::run(&knn, &groundtruth, steps)?;
@@ -679,8 +691,12 @@ where
         let groundtruth =
             datafiles::load_range_groundtruth(datafiles::BinFile(&multihop.groundtruth))?;
 
-        let steps =
-            search::knn::SearchSteps::new(multihop.reps, &multihop.num_threads, &multihop.runs);
+        let steps = search::knn::SearchSteps::new(
+            multihop.reps,
+            &multihop.num_threads,
+            &multihop.runs,
+            GroundTruthMode::Flexible,
+        );
 
         let bit_maps = generate_bitmaps(&multihop.query_predicates, &multihop.data_labels)?;
 
@@ -737,7 +753,12 @@ where
         let groundtruth =
             datafiles::load_range_groundtruth(datafiles::BinFile(&inline.groundtruth))?;
 
-        let steps = search::knn::SearchSteps::new(inline.reps, &inline.num_threads, &inline.runs);
+        let steps = search::knn::SearchSteps::new(
+            inline.reps,
+            &inline.num_threads,
+            &inline.runs,
+            GroundTruthMode::Flexible,
+        );
 
         let bit_maps = generate_bitmaps(&inline.query_predicates, &inline.data_labels)?;
 

diskann-benchmark/src/index/bftree/full_precision_streaming.rs

@@ -8,7 +8,11 @@ use diskann::{
     graph::{DiskANNIndex, InplaceDeleteMethod, SampleableForStart},
     utils::{VectorRepr, ONE},
 };
-use diskann_benchmark_core::{self as benchmark_core, recall::Rows, streaming::executors::bigann};
+use diskann_benchmark_core::{
+    self as benchmark_core,
+    recall::{GroundTruthMode, Rows},
+    streaming::executors::bigann,
+};
 use diskann_benchmark_runner::{
     benchmark::{FailureScore, MatchScore},
     output::Output,
@@ -103,6 +107,7 @@ where
             self.search.reps,
             &self.search.num_threads,
             &self.search.runs,
+            GroundTruthMode::Fixed,
         );
         let results = knn::run(&knn, groundtruth, steps)?;
         Ok(StreamStats::Search(results))

diskann-benchmark/src/index/bftree/spherical_streaming.rs

@@ -11,7 +11,10 @@ use std::{borrow::Cow, io::Write, num::NonZeroUsize, sync::Arc};
 use diskann::graph::{DiskANNIndex, InplaceDeleteMethod};
 use diskann::utils::ONE;
 use diskann_benchmark_core as benchmark_core;
-use diskann_benchmark_core::{recall::Rows, streaming::executors::bigann};
+use diskann_benchmark_core::{
+    recall::{GroundTruthMode, Rows},
+    streaming::executors::bigann,
+};
 use diskann_benchmark_runner::{
     benchmark::{FailureScore, MatchScore},
     output::Output,
@@ -107,6 +110,7 @@ impl ManagedStream<f32> for BfTreeSQStream {
             self.search.reps,
             &self.search.num_threads,
             &self.search.runs,
+            GroundTruthMode::Fixed,
         );
         let results = knn::run(&knn, groundtruth, steps)?;
         Ok(StreamStats::Search(results))

diskann-benchmark/src/index/inmem/spherical.rs

@@ -67,6 +67,7 @@ pub(crate) fn register_benchmarks(registry: &mut Registry) -> anyhow::Result<()>
 mod imp {
     use diskann::graph::{DiskANNIndex, StartPointStrategy};
     use diskann_benchmark_core as benchmark_core;
+    use diskann_benchmark_core::recall::GroundTruthMode;
     use diskann_benchmark_runner::{
         benchmark::{FailureScore, MatchScore},
         utils::{datatype::AsDataType, MicroSeconds},
@@ -390,7 +391,12 @@ mod imp {
             let groundtruth =
                 datafiles::load_groundtruth(datafiles::BinFile(&topk.groundtruth), Some(max_k))?;
 
-            let steps = search::knn::SearchSteps::new(topk.reps, &topk.num_threads, &topk.runs);
+            let steps = search::knn::SearchSteps::new(
+                topk.reps,
+                &topk.num_threads,
+                &topk.runs,
+                GroundTruthMode::Fixed,
+            );
 
             let knn = benchmark_core::search::graph::KNN::new(
                 index.clone(),
@@ -477,6 +483,7 @@ mod imp {
                 betafilter.reps,
                 &betafilter.num_threads,
                 &betafilter.runs,
+                GroundTruthMode::Flexible,
             );
 
             let bit_maps = generate_bitmaps(&betafilter.query_predicates, &betafilter.data_labels)?;
@@ -527,8 +534,12 @@ mod imp {
             let groundtruth =
                 datafiles::load_range_groundtruth(datafiles::BinFile(&multihop.groundtruth))?;
 
-            let steps =
-                search::knn::SearchSteps::new(multihop.reps, &multihop.num_threads, &multihop.runs);
+            let steps = search::knn::SearchSteps::new(
+                multihop.reps,
+                &multihop.num_threads,
+                &multihop.runs,
+                GroundTruthMode::Flexible,
+            );
 
             let bit_maps = generate_bitmaps(&multihop.query_predicates, &multihop.data_labels)?;
 
@@ -577,8 +588,12 @@ mod imp {
             let groundtruth =
                 datafiles::load_range_groundtruth(datafiles::BinFile(&inline.groundtruth))?;
 
-            let steps =
-                search::knn::SearchSteps::new(inline.reps, &inline.num_threads, &inline.runs);
+            let steps = search::knn::SearchSteps::new(
+                inline.reps,
+                &inline.num_threads,
+                &inline.runs,
+                GroundTruthMode::Flexible,
+            );
 
             let bit_maps = generate_bitmaps(&inline.query_predicates, &inline.data_labels)?;
 

diskann-benchmark/src/index/search/knn.rs

@@ -15,18 +15,21 @@ pub(crate) struct SearchSteps<'a> {
     pub reps: NonZeroUsize,
     pub num_tasks: &'a [NonZeroUsize],
     pub runs: &'a [GraphSearch],
+    pub groundtruth_mode: GroundTruthMode,
 }
 
 impl<'a> SearchSteps<'a> {
     pub(crate) fn new(
         reps: NonZeroUsize,
         num_tasks: &'a [NonZeroUsize],
         runs: &'a [GraphSearch],
+        groundtruth_mode: GroundTruthMode,
     ) -> Self {
         Self {
             reps,
             num_tasks,
             runs,
+            groundtruth_mode,
         }
     }
 }
@@ -57,7 +60,13 @@ pub(crate) fn run<I>(
                 })
                 .collect();
 
-            all.extend(runner.search_all(parameters, groundtruth, run.recall_k, run.search_n)?);
+            all.extend(runner.search_all(
+                parameters,
+                groundtruth,
+                run.recall_k,
+                run.search_n,
+                steps.groundtruth_mode,
+            )?);
         }
     }
 
@@ -72,6 +81,7 @@ pub(crate) trait Knn<I> {
         groundtruth: &dyn benchmark_core::recall::Rows<I>,
         recall_k: usize,
         recall_n: usize,
+        groundtruth_mode: GroundTruthMode,
     ) -> anyhow::Result<Vec<SearchResults>>;
 }
 
@@ -94,6 +104,7 @@ where
         groundtruth: &dyn benchmark_core::recall::Rows<DP::InternalId>,
         recall_k: usize,
         recall_n: usize,
+        groundtruth_mode: GroundTruthMode,
     ) -> anyhow::Result<Vec<SearchResults>> {
         let results = core_search::search_all(
             self.clone(),
@@ -102,7 +113,7 @@ where
                 groundtruth,
                 recall_k,
                 recall_n,
-                GroundTruthMode::Fixed,
+                groundtruth_mode,
             ),
         )?;
 
@@ -125,6 +136,7 @@ where
         groundtruth: &dyn benchmark_core::recall::Rows<DP::InternalId>,
         recall_k: usize,
         recall_n: usize,
+        groundtruth_mode: GroundTruthMode,
     ) -> anyhow::Result<Vec<SearchResults>> {
         let results = core_search::search_all(
             self.clone(),
@@ -133,7 +145,7 @@ where
                 groundtruth,
                 recall_k,
                 recall_n,
-                GroundTruthMode::Flexible,
+                groundtruth_mode,
             ),
         )?;
 
@@ -156,6 +168,7 @@ where
         groundtruth: &dyn benchmark_core::recall::Rows<DP::InternalId>,
         recall_k: usize,
         recall_n: usize,
+        groundtruth_mode: GroundTruthMode,
     ) -> anyhow::Result<Vec<SearchResults>> {
         let results = core_search::search_all(
             self.clone(),
@@ -164,7 +177,7 @@ where
                 groundtruth,
                 recall_k,
                 recall_n,
-                GroundTruthMode::Flexible,
+                groundtruth_mode,
             ),
         )?;
 

diskann-benchmark/src/index/streaming/full_precision.rs

@@ -11,7 +11,7 @@ use diskann::{
     utils::{VectorRepr, ONE},
     ANNError, ANNErrorKind, ANNResult,
 };
-use diskann_benchmark_core::recall::Rows;
+use diskann_benchmark_core::recall::{GroundTruthMode, Rows};
 use diskann_providers::model::graph::provider::async_::{
     common,
     inmem::{self, DefaultProvider},
@@ -103,6 +103,7 @@ where
             self.search.reps,
             &self.search.num_threads,
             &self.search.runs,
+            GroundTruthMode::Fixed,
         );
         let results = knn::run(&knn, groundtruth, steps)?;
         Ok(StreamStats::Search(results))

diskann-benchmark/src/utils/recall.rs

@@ -49,6 +49,8 @@ pub(crate) fn compute_multiple_recalls<T>(
 where
     T: benchmark_core::recall::RecallCompatible,
 {
+    use diskann_benchmark_core::recall::GroundTruthMode;
+
     let mut result = Vec::new();
     for k in recall_k {
         for n in recall_n {
@@ -62,7 +64,7 @@ where
                 results,
                 *k,
                 *n,
-                benchmark_core::recall::GroundTruthMode::Fixed,
+                GroundTruthMode::Fixed,
             )?;
             result.push((&recall).into());
         }