address PR review: refactor and optimize adaptive batch size

- Rename compute_filtered_batch_size to predict_further_processing
  and move to svs_runtime_utils.h for reuse
- Use float arithmetic instead of double for hit rate calculation
- Compute batch size at loop start to avoid unnecessary computation
- Use iterator.size() instead of per-element increment for total_checked
- Initial batch size = max(k, search_window_size)
- Apply adaptive batch size to vamana_index_impl.h filtered search

Author: yuejiaointel

bindings/cpp/src/dynamic_vamana_index_impl.h

@@ -38,20 +38,6 @@
 namespace svs {
 namespace runtime {
 
-// Compute the next batch size based on observed filter hit rate.
-// On the first round (found == 0), returns initial_batch_size unchanged.
-// On subsequent rounds, estimates how many candidates are needed to find the
-// remaining results given the observed hit rate.
-inline size_t compute_filtered_batch_size(
-    size_t found, size_t needed, size_t total_checked, size_t initial_batch_size
-) {
-    if (found == 0 || found >= needed) {
-        return initial_batch_size;
-    }
-    double hit_rate = static_cast<double>(found) / total_checked;
-    return static_cast<size_t>((needed - found) / hit_rate);
-}
-
 // Dynamic Vamana index implementation
 class DynamicVamanaIndexImpl {
     using allocator_type = svs::data::Blocked<svs::lib::Allocator<float>>;
@@ -140,11 +126,13 @@ class DynamicVamanaIndexImpl {
                 auto iterator = impl_->batch_iterator(query);
                 size_t found = 0;
                 size_t total_checked = 0;
-                auto batch_size = sp.buffer_config_.get_search_window_size();
+                auto batch_size = std::max(k, sp.buffer_config_.get_search_window_size());
                 do {
+                    batch_size =
+                        predict_further_processing(total_checked, found, k, batch_size);
                     iterator.next(batch_size);
+                    total_checked += iterator.size();
                     for (auto& neighbor : iterator.results()) {
-                        total_checked++;
                         if (filter->is_member(neighbor.id())) {
                             result.set(neighbor, i, found);
                             found++;
@@ -153,8 +141,6 @@ class DynamicVamanaIndexImpl {
                             }
                         }
                     }
-                    batch_size =
-                        compute_filtered_batch_size(found, k, total_checked, batch_size);
                 } while (found < k && !iterator.done());
 
                 // Pad results if not enough neighbors found

bindings/cpp/src/svs_runtime_utils.h

@@ -431,6 +431,20 @@ auto dispatch_storage_kind(StorageKind kind, F&& f, Args&&... args) {
 }
 } // namespace storage
 
+// Predict how many more items need to be processed to reach the goal,
+// based on the observed hit rate so far.
+// If no hits yet, returns `hint` unchanged.
+// The caller should cap the result to a max batch size if needed.
+inline size_t predict_further_processing(
+    size_t processed, size_t hits, size_t goal, size_t hint
+) {
+    if (hits == 0 || hits >= goal) {
+        return hint;
+    }
+    float batch_size = static_cast<float>(goal - hits) * processed / hits;
+    return std::max(static_cast<size_t>(batch_size), size_t{1});
+}
+
 inline svs::threads::ThreadPoolHandle default_threadpool() {
     return svs::threads::ThreadPoolHandle(svs::threads::OMPThreadPool(omp_get_max_threads())
     );

bindings/cpp/src/vamana_index_impl.h

@@ -131,8 +131,13 @@ class VamanaIndexImpl {
                 auto query = queries.get_datum(i);
                 auto iterator = get_impl()->batch_iterator(query);
                 size_t found = 0;
+                size_t total_checked = 0;
+                auto batch_size = std::max(k, sp.buffer_config_.get_search_window_size());
                 do {
-                    iterator.next(k);
+                    batch_size =
+                        predict_further_processing(total_checked, found, k, batch_size);
+                    iterator.next(batch_size);
+                    total_checked += iterator.size();
                     for (auto& neighbor : iterator.results()) {
                         if (filter->is_member(neighbor.id())) {
                             result.set(neighbor, i, found);