Struct SearchOptions 

pub struct SearchOptions {
    pub top_k: usize,
    pub mode: SearchMode,
    pub alpha: Option<f32>,
    pub filter_languages: Vec<String>,
    pub filter_paths: Vec<String>,
    pub use_query_cache: bool,
    pub explain: bool,
}

Fields

top_k: usize

mode: SearchMode

alpha: Option<f32>

filter_languages: Vec<String>

filter_paths: Vec<String>

use_query_cache: bool

explain: bool

Implementations

impl SearchOptions

pub fn new(top_k: usize) -> Self

Examples found in repository

examples/bench.rs (line 20)

fn main() -> anyhow::Result<()> {
    let path = std::env::args().nth(1).unwrap_or_else(|| ".".to_owned());
    let query = std::env::args()
        .nth(2)
        .unwrap_or_else(|| "hybrid search ranking".to_owned());
    let runs = std::env::args()
        .nth(3)
        .and_then(|s| s.parse::<usize>().ok())
        .unwrap_or(100);

    let start = Instant::now();
    let index = SifsIndex::from_path(&path)?;
    let index_ms = start.elapsed().as_secs_f64() * 1000.0;

    let mut uncached_times = Vec::with_capacity(runs);
    let mut cached_times = Vec::with_capacity(runs);
    let uncached = SearchOptions::new(10)
        .with_mode(SearchMode::Hybrid)
        .with_cache(false);
    let cached = SearchOptions::new(10)
        .with_mode(SearchMode::Hybrid)
        .with_cache(true);
    std::hint::black_box(index.search_with(&query, &uncached)?);
    for _ in 0..runs {
        let start = Instant::now();
        let results = index.search_with(&query, &uncached)?;
        std::hint::black_box(results);
        uncached_times.push(start.elapsed().as_secs_f64() * 1000.0);
    }
    std::hint::black_box(index.search_with(&query, &cached)?);
    for _ in 0..runs {
        let start = Instant::now();
        let results = index.search_with(&query, &cached)?;
        std::hint::black_box(results);
        cached_times.push(start.elapsed().as_secs_f64() * 1000.0);
    }
    uncached_times.sort_by(|a, b| a.partial_cmp(b).unwrap());
    cached_times.sort_by(|a, b| a.partial_cmp(b).unwrap());
    let uncached_p50 = uncached_times[uncached_times.len() / 2];
    let uncached_p90 =
        uncached_times[(uncached_times.len() * 9 / 10).min(uncached_times.len() - 1)];
    let cached_p50 = cached_times[cached_times.len() / 2];
    let cached_p90 = cached_times[(cached_times.len() * 9 / 10).min(cached_times.len() - 1)];
    let stats = index.stats();
    println!(
        "cold_index_ms={index_ms:.3} warm_uncached_query_ms={uncached_p50:.3} warm_uncached_query_p90_ms={uncached_p90:.3} warm_cached_repeat_query_ms={cached_p50:.3} warm_cached_repeat_query_p90_ms={cached_p90:.3} peak_rss_mb={:.1} files={} chunks={}",
        peak_rss_mb(),
        stats.indexed_files,
        index.chunks.len()
    );
    Ok(())
}

pub fn with_mode(self, mode: SearchMode) -> Self

Examples found in repository

examples/bench.rs (line 21)

fn main() -> anyhow::Result<()> {
    let path = std::env::args().nth(1).unwrap_or_else(|| ".".to_owned());
    let query = std::env::args()
        .nth(2)
        .unwrap_or_else(|| "hybrid search ranking".to_owned());
    let runs = std::env::args()
        .nth(3)
        .and_then(|s| s.parse::<usize>().ok())
        .unwrap_or(100);

    let start = Instant::now();
    let index = SifsIndex::from_path(&path)?;
    let index_ms = start.elapsed().as_secs_f64() * 1000.0;

    let mut uncached_times = Vec::with_capacity(runs);
    let mut cached_times = Vec::with_capacity(runs);
    let uncached = SearchOptions::new(10)
        .with_mode(SearchMode::Hybrid)
        .with_cache(false);
    let cached = SearchOptions::new(10)
        .with_mode(SearchMode::Hybrid)
        .with_cache(true);
    std::hint::black_box(index.search_with(&query, &uncached)?);
    for _ in 0..runs {
        let start = Instant::now();
        let results = index.search_with(&query, &uncached)?;
        std::hint::black_box(results);
        uncached_times.push(start.elapsed().as_secs_f64() * 1000.0);
    }
    std::hint::black_box(index.search_with(&query, &cached)?);
    for _ in 0..runs {
        let start = Instant::now();
        let results = index.search_with(&query, &cached)?;
        std::hint::black_box(results);
        cached_times.push(start.elapsed().as_secs_f64() * 1000.0);
    }
    uncached_times.sort_by(|a, b| a.partial_cmp(b).unwrap());
    cached_times.sort_by(|a, b| a.partial_cmp(b).unwrap());
    let uncached_p50 = uncached_times[uncached_times.len() / 2];
    let uncached_p90 =
        uncached_times[(uncached_times.len() * 9 / 10).min(uncached_times.len() - 1)];
    let cached_p50 = cached_times[cached_times.len() / 2];
    let cached_p90 = cached_times[(cached_times.len() * 9 / 10).min(cached_times.len() - 1)];
    let stats = index.stats();
    println!(
        "cold_index_ms={index_ms:.3} warm_uncached_query_ms={uncached_p50:.3} warm_uncached_query_p90_ms={uncached_p90:.3} warm_cached_repeat_query_ms={cached_p50:.3} warm_cached_repeat_query_p90_ms={cached_p90:.3} peak_rss_mb={:.1} files={} chunks={}",
        peak_rss_mb(),
        stats.indexed_files,
        index.chunks.len()
    );
    Ok(())
}

pub fn with_alpha(self, alpha: f32) -> Self

pub fn with_languages(self, languages: impl IntoIterator<Item = String>) -> Self

pub fn with_paths(self, paths: impl IntoIterator<Item = String>) -> Self

pub fn with_cache(self, use_query_cache: bool) -> Self

Examples found in repository

examples/bench.rs (line 22)

fn main() -> anyhow::Result<()> {
    let path = std::env::args().nth(1).unwrap_or_else(|| ".".to_owned());
    let query = std::env::args()
        .nth(2)
        .unwrap_or_else(|| "hybrid search ranking".to_owned());
    let runs = std::env::args()
        .nth(3)
        .and_then(|s| s.parse::<usize>().ok())
        .unwrap_or(100);

    let start = Instant::now();
    let index = SifsIndex::from_path(&path)?;
    let index_ms = start.elapsed().as_secs_f64() * 1000.0;

    let mut uncached_times = Vec::with_capacity(runs);
    let mut cached_times = Vec::with_capacity(runs);
    let uncached = SearchOptions::new(10)
        .with_mode(SearchMode::Hybrid)
        .with_cache(false);
    let cached = SearchOptions::new(10)
        .with_mode(SearchMode::Hybrid)
        .with_cache(true);
    std::hint::black_box(index.search_with(&query, &uncached)?);
    for _ in 0..runs {
        let start = Instant::now();
        let results = index.search_with(&query, &uncached)?;
        std::hint::black_box(results);
        uncached_times.push(start.elapsed().as_secs_f64() * 1000.0);
    }
    std::hint::black_box(index.search_with(&query, &cached)?);
    for _ in 0..runs {
        let start = Instant::now();
        let results = index.search_with(&query, &cached)?;
        std::hint::black_box(results);
        cached_times.push(start.elapsed().as_secs_f64() * 1000.0);
    }
    uncached_times.sort_by(|a, b| a.partial_cmp(b).unwrap());
    cached_times.sort_by(|a, b| a.partial_cmp(b).unwrap());
    let uncached_p50 = uncached_times[uncached_times.len() / 2];
    let uncached_p90 =
        uncached_times[(uncached_times.len() * 9 / 10).min(uncached_times.len() - 1)];
    let cached_p50 = cached_times[cached_times.len() / 2];
    let cached_p90 = cached_times[(cached_times.len() * 9 / 10).min(cached_times.len() - 1)];
    let stats = index.stats();
    println!(
        "cold_index_ms={index_ms:.3} warm_uncached_query_ms={uncached_p50:.3} warm_uncached_query_p90_ms={uncached_p90:.3} warm_cached_repeat_query_ms={cached_p50:.3} warm_cached_repeat_query_p90_ms={cached_p90:.3} peak_rss_mb={:.1} files={} chunks={}",
        peak_rss_mb(),
        stats.indexed_files,
        index.chunks.len()
    );
    Ok(())
}

pub fn with_explain(self, explain: bool) -> Self

Trait Implementations

impl Clone for SearchOptions

fn clone(&self) -> SearchOptions

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SearchOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SearchOptions

fn default() -> Self

Returns the “default value” for a type.

impl From<SearchOptions> for SearchOptionsWire

fn from(value: SearchOptions) -> Self

Converts to this type from the input type.

impl From<SearchOptionsWire> for SearchOptions

fn from(value: SearchOptionsWire) -> Self

Converts to this type from the input type.

impl PartialEq for SearchOptions

fn eq(&self, other: &SearchOptions) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for SearchOptions