Skip to content

Filtered search inside greedy search, with a two-heap search buffer - #456

Draft
yuejiaointel wants to merge 33 commits into
mainfrom
feature/filtered-search-two-heap-buffer
Draft

yuejiaointel wants to merge 33 commits into
mainfrom
feature/filtered-search-two-heap-buffer

Conversation

@yuejiaointel

@yuejiaointel yuejiaointel commented Oct 26, 2026 •

Copy link
Copy Markdown
Contributor

What this changes

  • Filtered search runs inside the greedy search, as in hnswlib: a neighbor enters the results only if it passes the filter and could improve the results.
  • Filtered top-k search on the dynamic Vamana index uses two heaps inside the existing MutableBuffer: a min-heap of nodes to visit and a max-heap of the best passing nodes (the results). A hash set marks ids already seen, so repeats are skipped. In this mode the buffer capacity is the search window.
  • The filter is the optional filter argument of the existing MutableVamanaIndex::search(); the buffer calls it through the index's id translator.
  • Filtered vs regular search is chosen at compile time: MutableBuffer<Idx, Cmp, bool Filtered = false>. Regular search (Filtered == false) has no heap code path and compiles as before.
  • Unfiltered search, the static index, greedy_search and the batch iterator are unchanged.

Files

  • include/svs/index/vamana/dynamic_search_buffer.h: the two heaps and the Filtered template parameter.
  • include/svs/index/vamana/dynamic_index.h: search() takes the optional filter and runs its per-thread body with the filtered or the regular buffer.
  • include/svs/index/vamana/extensions.h: the top-up step uses the filter and short result rows are padded with the worst score.
  • include/svs/orchestrators/dynamic_vamana.h: filtered_search entry point (appended last in the interface).
  • bindings/c/src/filtered_search.hpp: the C API filtered search on a dynamic index calls it.

LVQ / LeanVec

LVQ and LeanVec have their own search code. They need a separate change to pass the filter to their top-up step and to pad short LeanVec rows, so do not rely on this path for them until that lands.

Tests

Existing tests.

Results

Not benchmarked yet for this version.

🤖 Generated with Claude Code

Reuse the MutableBuffer valid/invalid mechanism: a FilteredValidBuilder marks an
entry invalid if it is deleted or the predicate rejects its external id. New
MutableVamanaIndex::search overload taking a predicate, padding rows with
id -1 / +inf and returning per-query found counts. Supplement path checks the
predicate before computing the distance. Orchestrator virtual appended last.
Replace the separate filtered search overload with two optional trailing
arguments on MutableVamanaIndex::search (an id predicate and a per-query
result count). Without a predicate the existing code path runs unchanged.
check_and_supplement_search_buffer gets an optional predicate that is
checked before the distance is computed. The filter predicate type is now
a type-erased std::function, so FilteredValidBuilder is no longer a
template. The orchestrator keeps one appended virtual that forwards to the
index search.
The optional filter on MutableVamanaIndex::search now only chooses which
builder the existing greedy search closure uses; both cases call the same
per_thread_batch_search. FilteredValidBuilder derives from ValidBuilder.
The buffer top-up in single_search applies the filter when the search
closure carries one. The per-query result count out-parameter is removed
(callers count non-padding ids).

per_thread_batch_search now pads result rows with fewer than k entries
(id size_t(-1), distance +inf) instead of reading past the end of the
search buffer, and the post-search id translation skips the padding.
Give ValidBuilder an optional predicate and pass it down through
internal_search_builder, greedy_search_closure and search() as optional
arguments, instead of a separate builder and search path. Filtered-only
checks: the supplement fallback skips failing ids, copy-out pads short rows
with id -1 and the worst score, translation skips padded ids.
The orchestrator reports filtered search as unsupported for indexes whose
search has no filter argument (the concurrent index), instead of failing to
compile. In the filtered test, drop the unfiltered-padding section (padding is
filtered-only) and add an inner-product case checking padding uses -inf.
Experiment: with a filter, MutableBuffer keeps a min-heap of entries to
visit and a max-heap of the best valid entries during the search,
instead of one sorted list. greedy_search is unchanged; cleanup() sorts
the results once at the end.
ValidBuilder can be given the search buffer. With a filter, it first
asks the buffer whether the entry would be dropped anyway (can_skip)
and, if so, returns it as invalid without looking up the external id or
calling the filter. Results are unchanged.
The filter skip in ValidBuilder asks can_skip; in heap mode the worst
kept entry is not back().
The existing [filtered] dynamic index test drives heap mode end to end.
ValidBuilder can be given the search buffer. With a filter, it first
asks the buffer whether the entry would be dropped anyway (can_skip)
and, if so, returns it as invalid without looking up the external id or
calling the filter. Results are unchanged.
The filter skip in ValidBuilder asks can_skip; in heap mode the worst
kept entry is not back().
In heap mode, MutableBuffer now calls the filter itself: a neighbor goes
to the results heap only if it could improve the results and passes the
filter. ValidBuilder is back to the main behaviour (deleted check only).

This branch has not been deployed

No deployments
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant