Add API to load pre-built index in wrapped_async

diskann-providers/Cargo.toml

@@ -40,6 +40,7 @@ bf-tree = { workspace = true, optional = true }
 anyhow.workspace = true
 prost = "0.14.1"
 futures-util.workspace = true
+futures-executor = "0.3"
 polonius-the-crab = { version = "0.5.0", optional = true }
 serde_json = { workspace = true, optional = true }
 vfs = { workspace = true, optional = true }

diskann-providers/src/index/wrapped_async.rs

@@ -3,10 +3,11 @@
  * Licensed under the MIT license.
  */
 
+use futures_executor::block_on;
 use std::{num::NonZeroUsize, sync::Arc};
 
 use diskann::{
-    ANNResult,
+    ANNError, ANNResult,
     graph::{
         self, ConsolidateKind, InplaceDeleteMethod, SearchParams,
         glue::{
@@ -20,6 +21,14 @@ use diskann::{
     utils::{ONE, async_tools::VectorIdBoxSlice},
 };
 
+use crate::{
+    model::IndexConfiguration,
+    storage::{
+        AsyncIndexMetadata, AsyncQuantLoadContext, LoadWith, StorageReadProvider,
+        file_storage_provider::FileStorageProvider,
+    },
+};
+
 pub struct DiskANNIndex<DP: DataProvider> {
     /// The underlying async DiskANNIndex.
     pub inner: Arc<graph::DiskANNIndex<DP>>,
@@ -317,3 +326,50 @@ where
         self.handle.block_on(self.inner.get_degree_stats(accessor))
     }
 }
+
+pub trait SyncLoadWith<DP>: Sized {
+    fn load_with(path: &str, index_config: IndexConfiguration) -> ANNResult<Self>;
+}
+
+// Load static memory index from pre-built files synchronously
+impl<DP> SyncLoadWith<DP> for DiskANNIndex<DP>
+where
+    DP: DataProvider<InternalId = u32> + LoadWith<AsyncQuantLoadContext, Error = ANNError>,
+{
+    fn load_with(path: &str, index_config: IndexConfiguration) -> ANNResult<DiskANNIndex<DP>> {
+        let storage = FileStorageProvider;
+        let data_provider = create_data_provider(&storage, path, &index_config);
+
+        match data_provider {
+            Ok(dp) => {
+                let index =
+                    DiskANNIndex::<DP>::new_with_current_thread_runtime(index_config.config, dp);
+                Ok(index)
+            }
+            Err(e) => Err(e),
+        }
+    }
+}
+
+pub fn create_data_provider<'a, P, DP>(
+    provider: &P,
+    path: &'a str,
+    index_config: &'a IndexConfiguration,
+) -> ANNResult<DP>
+where
+    P: StorageReadProvider,
+    DP: DataProvider + LoadWith<AsyncQuantLoadContext, Error = ANNError>,
+{
+    let pq_context = AsyncQuantLoadContext {
+        metadata: AsyncIndexMetadata::new(path),
+        num_frozen_points: index_config.num_frozen_pts,
+        metric: index_config.dist_metric,
+        prefetch_lookahead: index_config.prefetch_lookahead.map(|x| x.get()),
+        is_disk_index: false, // only support in-memory index loading here
+        prefetch_cache_line_level: index_config.prefetch_cache_line_level,
+    };
+
+    let data_provider = DP::load_with(provider, &pq_context);
+
+    block_on(data_provider)
+}