Struct BatchParserBuilder 

pub struct BatchParserBuilder { /* private fields */ }

Implementations

impl BatchParserBuilder

pub fn limits(self, limits: ParserLimits) -> Self

pub fn cache_capacity(self, entries: usize, bytes: usize) -> Self

Set FIFO cache payload bounds. Zero entries disables retention.

Examples found in repository

examples/parser_guard_bench.rs (line 170)

fn main() {
    println!("workload,iterations,sources,elapsed_ns,ns_per_parse,digest");
    for c in corpus() {
        let digest = semantic_digest(&c.formulas);
        let builder = BatchParser::builder();
        let builder = if let Ok(entries) = std::env::var("BENCH_CACHE_ENTRIES") {
            builder.cache_capacity(entries.parse().unwrap(), usize::MAX)
        } else {
            builder
        };
        let mut batch = builder.build();
        // Warm allocator, code and the full working set. Pre-existing token
        // cache warmup is retained intentionally to reveal eviction thrashing.
        let unique = c.name == "batch_unique_stream";
        let warm_count = if unique {
            4096
        } else {
            c.formulas.len().max(4096)
        };
        for i in 0..warm_count {
            let other = unique.then(|| format!("=X{i}+Y{i}*$C$1"));
            let f = other
                .as_deref()
                .unwrap_or(&c.formulas[i % c.formulas.len()]);
            consume(if c.batch {
                batch.parse(f).unwrap()
            } else {
                parse(f).unwrap()
            });
        }
        let start = Instant::now();
        for i in 0..c.iterations {
            let f = black_box(&c.formulas[i % c.formulas.len()]);
            consume(if c.batch {
                batch.parse(f).unwrap()
            } else {
                parse(f).unwrap()
            });
        }
        let elapsed = start.elapsed().as_nanos();
        println!(
            "{},{},{},{},{:.3},{:016x}",
            c.name,
            c.iterations,
            c.formulas.len(),
            elapsed,
            elapsed as f64 / c.iterations as f64,
            digest
        );
    }
}

pub fn include_whitespace(self, include: bool) -> Self

pub fn with_volatility_classifier<F>(self, f: F) -> Self

where F: Fn(&str) -> bool + Send + Sync + 'static,

pub fn dialect(self, dialect: FormulaDialect) -> Self

pub fn build(self) -> BatchParser

Examples found in repository

examples/parser_guard_bench.rs (line 174)

fn main() {
    println!("workload,iterations,sources,elapsed_ns,ns_per_parse,digest");
    for c in corpus() {
        let digest = semantic_digest(&c.formulas);
        let builder = BatchParser::builder();
        let builder = if let Ok(entries) = std::env::var("BENCH_CACHE_ENTRIES") {
            builder.cache_capacity(entries.parse().unwrap(), usize::MAX)
        } else {
            builder
        };
        let mut batch = builder.build();
        // Warm allocator, code and the full working set. Pre-existing token
        // cache warmup is retained intentionally to reveal eviction thrashing.
        let unique = c.name == "batch_unique_stream";
        let warm_count = if unique {
            4096
        } else {
            c.formulas.len().max(4096)
        };
        for i in 0..warm_count {
            let other = unique.then(|| format!("=X{i}+Y{i}*$C$1"));
            let f = other
                .as_deref()
                .unwrap_or(&c.formulas[i % c.formulas.len()]);
            consume(if c.batch {
                batch.parse(f).unwrap()
            } else {
                parse(f).unwrap()
            });
        }
        let start = Instant::now();
        for i in 0..c.iterations {
            let f = black_box(&c.formulas[i % c.formulas.len()]);
            consume(if c.batch {
                batch.parse(f).unwrap()
            } else {
                parse(f).unwrap()
            });
        }
        let elapsed = start.elapsed().as_nanos();
        println!(
            "{},{},{},{},{:.3},{:016x}",
            c.name,
            c.iterations,
            c.formulas.len(),
            elapsed,
            elapsed as f64 / c.iterations as f64,
            digest
        );
    }
}

Trait Implementations

impl Default for BatchParserBuilder

fn default() -> Self

Returns the “default value” for a type.