brief-core 0.4.0

Compiler library for the Brief markup language: lexer, parser, AST, HTML/LLM emitters, formatter, and Markdown-to-Brief converter.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

//! Stage-level benchmark for the Brief pipeline.
//!
//! Usage: cargo run --release -p brief-core --example bench -- <file.brf> [iters]
//!
//! Times each compiler stage (lex, parse, resolve, validate, emit-html,
//! emit-llm, fmt) separately over `iters` iterations and prints the best
//! (minimum) per-iteration time plus throughput in MiB/s of source input.

#[global_allocator]
static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;

use std::hint::black_box;
use std::time::Instant;

use brief::emit::{html, llm};
use brief::shortcode::Registry;
use brief::span::SourceMap;
use brief::validate::ValidateOpts;
use brief::{fmt, lexer, parser, resolve, validate};

fn main() {
    let mut args = std::env::args().skip(1);
    let path = args.next().expect("usage: bench <file.brf> [iters]");
    let iters: usize = args.next().map(|s| s.parse().unwrap()).unwrap_or(10);

    let raw = std::fs::read_to_string(&path).expect("read input");
    let bytes = raw.len();
    let src = SourceMap::new(path.clone(), raw.clone());
    let registry = Registry::default();
    let vopts = ValidateOpts::default();
    let lopts = llm::Opts::default();

    let mib = bytes as f64 / (1024.0 * 1024.0);
    println!(
        "input: {} ({} bytes, {:.2} MiB), {} iters",
        path, bytes, mib, iters
    );

    let report = |name: &str, best: f64| {
        println!(
            "{:<10} {:>10.3} ms   {:>8.1} MiB/s",
            name,
            best * 1e3,
            mib / best
        );
    };

    // lex
    let mut best = f64::MAX;
    for _ in 0..iters {
        let t = Instant::now();
        let tokens = lexer::lex(black_box(&src)).expect("lex ok");
        best = best.min(t.elapsed().as_secs_f64());
        black_box(tokens);
    }
    report("lex", best);

    // parse (includes a fresh lex per iter, subtracted via separate timing)
    let tokens = lexer::lex(&src).expect("lex ok");
    let mut best = f64::MAX;
    for _ in 0..iters {
        let toks = tokens.clone();
        let t = Instant::now();
        let (doc, diags) = parser::parse(black_box(toks), &src);
        best = best.min(t.elapsed().as_secs_f64());
        black_box((doc, diags));
    }
    report("parse", best);

    // resolve + validate
    let (doc0, _) = parser::parse(tokens.clone(), &src);
    let mut best = f64::MAX;
    for _ in 0..iters {
        let mut doc = doc0.clone();
        let t = Instant::now();
        let d1 = resolve::resolve(black_box(&mut doc), &registry);
        let d2 = validate::validate(&doc, &vopts, &src);
        best = best.min(t.elapsed().as_secs_f64());
        black_box((d1, d2));
    }
    report("res+val", best);

    // fully resolved doc for emitters
    let mut doc = doc0.clone();
    let _ = resolve::resolve(&mut doc, &registry);

    let mut best = f64::MAX;
    for _ in 0..iters {
        let t = Instant::now();
        let out = html::render(black_box(&doc), &registry);
        best = best.min(t.elapsed().as_secs_f64());
        black_box(out);
    }
    report("emit-html", best);

    let mut best = f64::MAX;
    for _ in 0..iters {
        let t = Instant::now();
        let out = llm::render(black_box(&doc), &registry, &lopts);
        best = best.min(t.elapsed().as_secs_f64());
        black_box(out);
    }
    report("emit-llm", best);

    let fopts = fmt::Opts::default();
    let mut best = f64::MAX;
    for _ in 0..iters {
        let t = Instant::now();
        let out = fmt::format(black_box(&raw), &fopts);
        best = best.min(t.elapsed().as_secs_f64());
        black_box(out);
    }
    report("fmt", best);
}