Struct BatchParser 

pub struct BatchParser { /* private fields */ }

Efficient batch parser with an internal token cache and optional volatility classifier.

The cache is keyed by the original formula string; repeated formulas across a batch (very common in spreadsheets) will avoid re-tokenization and whitespace filtering.

Implementations

impl BatchParser

pub fn builder() -> BatchParserBuilder

Examples found in repository

examples/parser_guard_bench.rs (line 168)

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 parse(&mut self, formula: &str) -> Result<ASTNode, ParserError>

Parse a formula using the internal cache and configured classifier.

Examples found in repository

examples/parser_guard_bench.rs (line 189)

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
        );
    }
}