diff --git a/.github/workflows/disk-benchmarks.yml b/.github/workflows/disk-benchmarks.yml index 29c0a7af86..b7960cf9ea 100644 --- a/.github/workflows/disk-benchmarks.yml +++ b/.github/workflows/disk-benchmarks.yml @@ -116,7 +116,7 @@ jobs: working-directory: baseline run: | cargo run -p diskann-benchmark --features disk-index --release -- \ - run --input-file ../diskann_rust/${{ env.PERF_INPUTS }}/${{ matrix.config }} \ + run --input-file ${{ env.PERF_INPUTS }}/${{ matrix.config }} \ --output-file target/tmp/${{ matrix.dataset }}_baseline.json - name: Run current branch benchmark @@ -144,4 +144,4 @@ jobs: path: | diskann_rust/target/tmp/${{ matrix.dataset }}_target.json baseline/target/tmp/${{ matrix.dataset }}_baseline.json - retention-days: 30 \ No newline at end of file + retention-days: 30 diff --git a/diskann-benchmark/example/disk-index-determinant-diversity.json b/diskann-benchmark/example/disk-index-determinant-diversity.json index e32e7c07eb..06cbc5fc0b 100644 --- a/diskann-benchmark/example/disk-index-determinant-diversity.json +++ b/diskann-benchmark/example/disk-index-determinant-diversity.json @@ -27,14 +27,15 @@ "beam_width": 4, "recall_at": 10, "num_threads": 1, - "is_flat_search": false, - "distance": "squared_l2", - "vector_filters_file": null, - "post_processor": { - "type": "determinant-diversity", - "power": 2.0, - "eta": 1.0 - } + "search_mode": { + "mode": "graph", + "post_processor": { + "type": "determinant-diversity", + "power": 2.0, + "eta": 1.0 + } + }, + "distance": "squared_l2" } } } diff --git a/diskann-benchmark/example/disk-index-filter.json b/diskann-benchmark/example/disk-index-filter.json index a3f35ca91a..ee55aeffa2 100644 --- a/diskann-benchmark/example/disk-index-filter.json +++ b/diskann-benchmark/example/disk-index-filter.json @@ -27,9 +27,11 @@ "beam_width": 4, "recall_at": 10, "num_threads": 1, - "is_flat_search": false, - "distance": "squared_l2", - "vector_filters_file": "disk_index_10pts_idx_uint32_range_res_r_100000.bin" + "search_mode": { + "mode": "graph", + "vector_filters_file": "disk_index_10pts_idx_uint32_range_res_r_100000.bin" + }, + "distance": "squared_l2" } } }, @@ -57,9 +59,11 @@ "beam_width": 4, "recall_at": 10, "num_threads": 1, - "is_flat_search": true, - "distance": "squared_l2", - "vector_filters_file": "disk_index_10pts_idx_uint32_range_res_r_100000.bin" + "search_mode": { + "mode": "flat", + "vector_filters_file": "disk_index_10pts_idx_uint32_range_res_r_100000.bin" + }, + "distance": "squared_l2" } } } diff --git a/diskann-benchmark/example/disk-index.json b/diskann-benchmark/example/disk-index.json index 46db8e118a..0b8534951a 100644 --- a/diskann-benchmark/example/disk-index.json +++ b/diskann-benchmark/example/disk-index.json @@ -27,9 +27,8 @@ "beam_width": 4, "recall_at": 10, "num_threads": 1, - "is_flat_search": false, - "distance": "squared_l2", - "vector_filters_file": null + "search_mode": { "mode": "graph" }, + "distance": "squared_l2" } } }, @@ -48,9 +47,8 @@ "beam_width": 4, "recall_at": 10, "num_threads": 1, - "is_flat_search": true, - "distance": "squared_l2", - "vector_filters_file": null + "search_mode": { "mode": "flat" }, + "distance": "squared_l2" } } } diff --git a/diskann-benchmark/perf_test_inputs/openai-100K-disk-index.json b/diskann-benchmark/perf_test_inputs/openai-100K-disk-index.json index 6b3e3b42d5..2e535d4f4c 100644 --- a/diskann-benchmark/perf_test_inputs/openai-100K-disk-index.json +++ b/diskann-benchmark/perf_test_inputs/openai-100K-disk-index.json @@ -29,9 +29,8 @@ "beam_width": 4, "recall_at": 100, "num_threads": 4, - "is_flat_search": false, - "distance": "squared_l2", - "vector_filters_file": null + "search_mode": { "mode": "graph" }, + "distance": "squared_l2" } } } diff --git a/diskann-benchmark/perf_test_inputs/wikipedia-100K-disk-index.json b/diskann-benchmark/perf_test_inputs/wikipedia-100K-disk-index.json index 59c439017d..3593ad8d62 100644 --- a/diskann-benchmark/perf_test_inputs/wikipedia-100K-disk-index.json +++ b/diskann-benchmark/perf_test_inputs/wikipedia-100K-disk-index.json @@ -29,9 +29,8 @@ "beam_width": 4, "recall_at": 100, "num_threads": 4, - "is_flat_search": false, - "distance": "inner_product", - "vector_filters_file": null + "search_mode": { "mode": "graph" }, + "distance": "inner_product" } } } diff --git a/diskann-benchmark/src/disk_index/search.rs b/diskann-benchmark/src/disk_index/search.rs index 8cd0f5e606..29e1428348 100644 --- a/diskann-benchmark/src/disk_index/search.rs +++ b/diskann-benchmark/src/disk_index/search.rs @@ -9,6 +9,7 @@ use std::{collections::HashSet, fmt, sync::atomic::AtomicBool, time::Instant}; use opentelemetry::{global, trace::Span, trace::Tracer}; use opentelemetry_sdk::trace::SdkTracerProvider; +use diskann::graph; use diskann::utils::VectorRepr; use diskann_benchmark_runner::{files::InputFile, utils::MicroSeconds}; use diskann_disk::{ @@ -36,7 +37,8 @@ use serde::{Deserialize, Serialize}; use crate::{ disk_index::json_spancollector::JsonSpanCollector, - inputs::disk::{DiskIndexLoad, DiskSearchPhase}, + inputs::disk::{DiskIndexLoad, DiskSearchMode, DiskSearchPhase}, + inputs::post_processor::TopkPostProcessor, utils::{datafiles, SimilarityMeasure}, }; @@ -158,6 +160,58 @@ impl DiskSearchResult { } } +/// Construct the disk [`SearchMode`] from the JSON-driven [`DiskSearchMode`] +/// config plus the per-query filter and post-processor supplied at search time. +fn build_search_mode<'a>( + mode: &'a DiskSearchMode, + vector_filter: Option<&'a HashSet>, +) -> SearchMode<'a> { + match mode { + DiskSearchMode::Flat { .. } => match vector_filter { + None => SearchMode::flat(), + Some(vector_filter) => { + SearchMode::flat_filtered(move |vid: &u32| vector_filter.contains(vid)) + } + }, + DiskSearchMode::Graph { + adaptive_l, + post_processor, + .. + } => { + let adaptive_l = adaptive_l.as_ref().map(|adaptive_l| { + graph::search::AdaptiveL::new( + adaptive_l.sample_count.into(), + adaptive_l.scale_factor, + ) + .expect("validated adaptive L must construct") + }); + + match (post_processor, adaptive_l, vector_filter) { + (Some(TopkPostProcessor::DeterminantDiversity(params)), _, None) => { + SearchMode::diverse_graph(*params) + } + (Some(TopkPostProcessor::DeterminantDiversity(params)), _, Some(vector_filter)) => { + SearchMode::diverse_graph_filtered( + move |vid: &u32| vector_filter.contains(vid), + *params, + ) + } + (None, Some(adaptive_l), None) => { + SearchMode::inline_filter(|_| true, Some(adaptive_l)) + } + (None, Some(adaptive_l), Some(vector_filter)) => SearchMode::inline_filter( + move |vid: &u32| vector_filter.contains(vid), + Some(adaptive_l), + ), + (None, None, None) => SearchMode::graph(), + (None, None, Some(vector_filter)) => { + SearchMode::graph_filtered(move |vid: &u32| vector_filter.contains(vid)) + } + } + } + } +} + pub(super) fn search_disk_index( index_load: &DiskIndexLoad, search_params: &DiskSearchPhase, @@ -185,21 +239,27 @@ where let num_queries = queries.nrows(); // Load the vector filters - let vector_filters = match &search_params.vector_filters_file { + let vector_filters = match search_params.search_mode.vector_filters_file() { Some(vector_filters_file) => { let vector_filters_file = vector_filters_file.to_string_lossy().to_string(); - search_index_utils::load_vector_filters(storage_provider, &vector_filters_file)? + Some(search_index_utils::load_vector_filters( + storage_provider, + &vector_filters_file, + )?) } - None => vec![HashSet::::new(); num_queries], + None => None, }; - if vector_filters.len() != num_queries { + if vector_filters + .as_ref() + .is_some_and(|filters| filters.len() != num_queries) + { anyhow::bail!("Mismatch in query and vector filter sizes"); } // Prepare ground truth context let gt_context = prepare_ground_truth_context( - search_params.vector_filters_file.is_some(), + search_params.search_mode.vector_filters_file().is_some(), &search_params.groundtruth, search_params.recall_at, storage_provider, @@ -259,7 +319,7 @@ where let zipped = queries .par_row_iter() - .zip(vector_filters.par_iter()) + .enumerate() .zip(result_ids.par_chunks_mut(search_params.recall_at as usize)) .zip(result_dists.par_chunks_mut(search_params.recall_at as usize)) .zip(statistics_vec.par_iter_mut()) @@ -267,16 +327,12 @@ where zipped.for_each_in_pool( pool.as_ref(), - |(((((q, vf), id_chunk), dist_chunk), stats), rc)| { - // Construct the SearchMode from the JSON-driven - // `adaptive_l` is now encapsulated in `DiskSearchMode`, so the - // benchmark only supplies the per-query filter and post-processor. - let has_filter = search_params.vector_filters_file.is_some(); - let mode: SearchMode<'_> = search_params.search_mode.search_mode( - has_filter, - vf, - search_params.post_processor.as_ref(), - ); + |(((((query_index, q), id_chunk), dist_chunk), stats), rc)| { + let vector_filter = vector_filters + .as_ref() + .and_then(|filters| filters.get(query_index)); + let mode: SearchMode<'_> = + build_search_mode(&search_params.search_mode, vector_filter); match searcher.search( q, @@ -349,9 +405,9 @@ where num_threads: search_params.num_threads, beam_width: search_params.beam_width, recall_at: search_params.recall_at, - is_flat_search: search_params.search_mode.is_flat_search, + is_flat_search: matches!(search_params.search_mode, DiskSearchMode::Flat { .. }), distance: search_params.distance, - uses_vector_filters: search_params.vector_filters_file.is_some(), + uses_vector_filters: search_params.search_mode.vector_filters_file().is_some(), num_nodes_to_cache: search_params.num_nodes_to_cache, search_results_per_l, span_metrics, diff --git a/diskann-benchmark/src/inputs/disk.rs b/diskann-benchmark/src/inputs/disk.rs index 7ed521a874..739d02e281 100644 --- a/diskann-benchmark/src/inputs/disk.rs +++ b/diskann-benchmark/src/inputs/disk.rs @@ -6,27 +6,18 @@ use std::{fmt, num::NonZeroUsize, path::Path}; use anyhow::Context; -#[cfg(feature = "disk-index")] -use std::collections::HashSet; -#[cfg(feature = "disk-index")] -use diskann::graph; use diskann_benchmark_runner::{files::InputFile, utils::datatype::DataType, Checker}; #[cfg(feature = "disk-index")] -use diskann_disk::search::search_mode::SearchMode; -#[cfg(feature = "disk-index")] use diskann_disk::QuantizationType; use diskann_providers::storage::{get_compressed_pq_file, get_disk_index_file, get_pq_pivot_file}; use serde::{Deserialize, Serialize}; use crate::{ - inputs::{as_input, post_processor::TopkPostProcessor, Example}, + inputs::{as_input, graph_index::AdaptiveL, post_processor::TopkPostProcessor, Example}, utils::SimilarityMeasure, }; -#[cfg(feature = "disk-index")] -use crate::inputs::graph_index::AdaptiveL; - ////////////// // Registry // ////////////// @@ -72,82 +63,156 @@ pub(crate) struct DiskIndexBuild { pub(crate) save_path: String, } -#[cfg(feature = "disk-index")] -#[derive(Debug, Serialize, Deserialize, Default)] -pub(crate) struct DiskSearchMode { - pub(crate) is_flat_search: bool, - #[serde(default)] - pub(crate) adaptive_l: Option, +/// Disk search mode. The `flat` / `graph` split is encoded as an enum so that +/// combinations invalid for flat scan (adaptive L, post-processor) are +/// unrepresentable rather than rejected at validation time. Mirrors the spirit +/// of `diskann_disk::search::search_mode::SearchMode` at the config level. +#[derive(Debug, Serialize, Deserialize)] +#[serde(tag = "mode", rename_all = "kebab-case")] +pub(crate) enum DiskSearchMode { + /// Brute-force flat scan, optionally restricted by a per-query vector filter. + Flat { + #[serde(default)] + vector_filters_file: Option, + }, + /// Greedy graph search, optionally with inline adaptive-L, a per-query + /// vector filter, and/or a top-k post-processor. + Graph { + #[serde(default)] + adaptive_l: Option, + #[serde(default)] + vector_filters_file: Option, + #[serde(default)] + post_processor: Option, + }, +} + +impl Default for DiskSearchMode { + fn default() -> Self { + Self::Graph { + adaptive_l: None, + vector_filters_file: None, + post_processor: None, + } + } } -#[cfg(feature = "disk-index")] impl DiskSearchMode { - pub(crate) fn search_mode<'a>( - &'a self, - has_vector_filters: bool, - vector_filter: &'a HashSet, - post_processor: Option<&TopkPostProcessor>, - ) -> SearchMode<'a> { - let adaptive_l = self.adaptive_l.as_ref().map(|adaptive_l| { - graph::search::AdaptiveL::new(adaptive_l.sample_count.into(), adaptive_l.scale_factor) - .expect("validated adaptive L must construct") - }); - - match ( - self.is_flat_search, - has_vector_filters, - post_processor, - adaptive_l, - ) { - (true, false, _, _) => SearchMode::flat(), - (true, true, _, _) => { - SearchMode::flat_filtered(move |vid: &u32| vector_filter.contains(vid)) - } - (false, false, Some(TopkPostProcessor::DeterminantDiversity(params)), _) => { - SearchMode::diverse_graph(*params) - } - (false, true, Some(TopkPostProcessor::DeterminantDiversity(params)), _) => { - SearchMode::diverse_graph_filtered( - move |vid: &u32| vector_filter.contains(vid), - *params, - ) - } - (false, false, None, Some(adaptive_l)) => { - SearchMode::inline_filter(|_| true, Some(adaptive_l)) - } - (false, true, None, Some(adaptive_l)) => SearchMode::inline_filter( - move |vid: &u32| vector_filter.contains(vid), - Some(adaptive_l), - ), - (false, false, None, None) => SearchMode::graph(), - (false, true, None, None) => { - SearchMode::graph_filtered(move |vid: &u32| vector_filter.contains(vid)) + pub(crate) fn vector_filters_file(&self) -> Option<&InputFile> { + match self { + Self::Flat { + vector_filters_file, } + | Self::Graph { + vector_filters_file, + .. + } => vector_filters_file.as_ref(), + } + } + + pub(crate) fn post_processor(&self) -> Option<&TopkPostProcessor> { + match self { + Self::Flat { .. } => None, + Self::Graph { post_processor, .. } => post_processor.as_ref(), } } pub(crate) fn validate(&mut self, checker: &mut Checker) -> Result<(), anyhow::Error> { - if let Some(adaptive_l) = self.adaptive_l.as_mut() { - adaptive_l.validate(checker)?; + match self { + Self::Flat { + vector_filters_file, + } => { + if let Some(vf) = vector_filters_file.as_mut() { + vf.resolve(checker).context("invalid vector_filters_file")?; + } + } + Self::Graph { + adaptive_l, + vector_filters_file, + post_processor, + } => { + if let Some(adaptive_l) = adaptive_l.as_mut() { + adaptive_l.validate(checker)?; + } + if let Some(vf) = vector_filters_file.as_mut() { + vf.resolve(checker).context("invalid vector_filters_file")?; + } + if let Some(pp) = post_processor.as_mut() { + pp.validate(checker) + .context("invalid disk search post processor")?; + } + } } Ok(()) } } -#[cfg(feature = "disk-index")] impl fmt::Display for DiskSearchMode { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let base = if self.is_flat_search { "flat" } else { "graph" }; - if self.adaptive_l.is_some() { - write!(f, "{} + adaptive-l", base) - } else { - write!(f, "{}", base) + match self { + Self::Flat { .. } => write!(f, "flat"), + Self::Graph { adaptive_l, .. } if adaptive_l.is_some() => { + write!(f, "graph + adaptive-l") + } + Self::Graph { .. } => write!(f, "graph"), } } } +#[cfg(test)] +mod tests { + use super::*; + + // The flat/graph split is an enum, so combinations invalid for flat scan + // (adaptive L, post-processor) are unrepresentable by construction — there + // is no runtime compatibility check left to test. These round-trip tests + // just pin the JSON shape. + #[test] + fn flat_disk_search_deserializes_without_graph_only_fields() { + let mode: DiskSearchMode = + serde_json::from_str(r#"{ "mode": "flat" }"#).expect("flat mode must deserialize"); + assert!(matches!(mode, DiskSearchMode::Flat { .. })); + assert!(mode.post_processor().is_none()); + } + + #[test] + fn graph_disk_search_deserializes_with_adaptive_l() { + let mode: DiskSearchMode = serde_json::from_str( + r#"{ "mode": "graph", "adaptive_l": { "sample_count": 1, "scale_factor": 2.0 } }"#, + ) + .expect("graph mode with adaptive_l must deserialize"); + assert!(matches!( + mode, + DiskSearchMode::Graph { + adaptive_l: Some(_), + .. + } + )); + } + + #[test] + fn disk_search_phase_rejects_legacy_phase_level_search_mode_fields() { + let error = serde_json::from_str::( + r#"{ + "queries": "queries.fbin", + "groundtruth": "groundtruth.bin", + "num_threads": 1, + "beam_width": 1, + "search_list": [1], + "recall_at": 1, + "distance": "squared_l2", + "is_flat_search": true + }"#, + ) + .expect_err("legacy phase-level search settings must be rejected"); + + assert!(error.to_string().contains("is_flat_search")); + } +} + /// Search phase configuration #[derive(Debug, Deserialize, Serialize)] +#[serde(deny_unknown_fields)] pub(crate) struct DiskSearchPhase { pub(crate) queries: InputFile, pub(crate) groundtruth: InputFile, @@ -155,21 +220,11 @@ pub(crate) struct DiskSearchPhase { pub(crate) beam_width: usize, pub(crate) search_list: Vec, pub(crate) recall_at: u32, - #[cfg(feature = "disk-index")] #[serde(default)] pub(crate) search_mode: DiskSearchMode, - // Backward compatibility for older benchmark inputs that used - // `is_flat_search` directly at the search-phase level. - #[cfg(feature = "disk-index")] - #[serde(default, skip_serializing)] - pub(crate) is_flat_search: Option, - #[cfg(not(feature = "disk-index"))] - pub(crate) is_flat_search: bool, pub(crate) distance: SimilarityMeasure, - pub(crate) vector_filters_file: Option, pub(crate) num_nodes_to_cache: Option, pub(crate) search_io_limit: Option, - pub(crate) post_processor: Option, } ///////// @@ -270,16 +325,7 @@ impl DiskSearchPhase { self.groundtruth .resolve(checker) .context("invalid groundtruth file")?; - if let Some(vf) = self.vector_filters_file.as_mut() { - vf.resolve(checker).context("invalid vector_filters_file")?; - } - #[cfg(feature = "disk-index")] - if let Some(is_flat_search) = self.is_flat_search { - self.search_mode.is_flat_search = is_flat_search; - } - - #[cfg(feature = "disk-index")] self.search_mode .validate(checker) .context("invalid disk search mode")?; @@ -315,11 +361,6 @@ impl DiskSearchPhase { } } - if let Some(pp) = self.post_processor.as_mut() { - pp.validate(checker) - .context("invalid disk search post processor")?; - } - Ok(()) } } @@ -353,20 +394,14 @@ impl Example for DiskIndexOperation { beam_width: 16, recall_at: 10, num_threads: 8, - #[cfg(feature = "disk-index")] - search_mode: DiskSearchMode { - is_flat_search: false, + search_mode: DiskSearchMode::Graph { adaptive_l: None, + vector_filters_file: None, + post_processor: None, }, - #[cfg(feature = "disk-index")] - is_flat_search: None, - #[cfg(not(feature = "disk-index"))] - is_flat_search: false, distance: SimilarityMeasure::SquaredL2, - vector_filters_file: None, num_nodes_to_cache: None, search_io_limit: None, - post_processor: None, }; Self { @@ -478,12 +513,9 @@ impl DiskSearchPhase { write_field!(f, "Beam Width", self.beam_width)?; write_field!(f, "Recall@", self.recall_at)?; write_field!(f, "Threads", self.num_threads)?; - #[cfg(feature = "disk-index")] write_field!(f, "Search Mode", self.search_mode)?; - #[cfg(not(feature = "disk-index"))] - write_field!(f, "Flat Search", self.is_flat_search)?; write_field!(f, "Distance", self.distance)?; - match &self.vector_filters_file { + match self.search_mode.vector_filters_file() { Some(vf) => write_field!(f, "Vector Filters File", vf.display())?, None => write_field!(f, "Vector Filters File", "none")?, } @@ -495,7 +527,7 @@ impl DiskSearchPhase { Some(lim) => write_field!(f, "Search IO Limit", format!("{lim}"))?, None => write_field!(f, "Search IO Limit", "none (defaults to `usize::MAX`)")?, } - match &self.post_processor { + match self.search_mode.post_processor() { Some(pp) => write_field!(f, "Post Processor", pp)?, None => write_field!(f, "Post Processor", "none")?, } diff --git a/diskann-benchmark/src/main.rs b/diskann-benchmark/src/main.rs index cf9a0ea522..e577eb2181 100644 --- a/diskann-benchmark/src/main.rs +++ b/diskann-benchmark/src/main.rs @@ -709,6 +709,18 @@ mod tests { prefix_search_directories(&mut raw, &root_directory()); let tempdir = tempfile::tempdir().unwrap(); + + // Redirect each build job's `save_path` into the tempdir so the disk index + // artifacts are not written relative to the process cwd (the repo tree). + let jobs = raw["jobs"] + .as_array_mut() + .expect("\"jobs\" should be an array"); + for (i, job) in jobs.iter_mut().enumerate() { + let save_path = tempdir.path().join(format!("disk_index_filter_job_{i}")); + job["content"]["source"]["save_path"] = + serde_json::Value::String(save_path.to_str().unwrap().to_string()); + } + let input_path = tempdir.path().join("disk-index-filter.json"); save_to_file(&input_path, &raw); let output_path = tempdir.path().join("output.json");