pascal 0.1.8

A modern Pascal compiler with build/intepreter/package manager built with Rust
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

//! Simple performance benchmarking for Pascal programs.

use crate::ast::Program;
use std::path::Path;
use std::time::Instant;

#[derive(Debug, Clone)]
pub struct BenchResult {
    pub iterations: u32,
    pub total_ms: u128,
    pub avg_us: u128,
}

impl BenchResult {
    pub fn format_report(&self) -> String {
        format!(
            "Iterations: {}\nTotal: {} ms\nAverage: {} µs/iter\n",
            self.iterations, self.total_ms, self.avg_us
        )
    }
}

/// Run a program repeatedly and measure interpreter time.
pub fn benchmark_program(program: &Program, iterations: u32, verbose: bool) -> BenchResult {
    let start = Instant::now();
    for i in 0..iterations {
        let mut interp = crate::interpreter::Interpreter::new(verbose && i == 0);
        let _ = interp.run_program(program);
    }
    let elapsed = start.elapsed();
    let total_ms = elapsed.as_millis();
    let avg_us = if iterations > 0 {
        elapsed.as_micros() / iterations as u128
    } else {
        0
    };
    BenchResult {
        iterations,
        total_ms,
        avg_us,
    }
}

/// Load and benchmark a Pascal source file.
pub fn benchmark_file(path: &Path, iterations: u32, verbose: bool) -> anyhow::Result<BenchResult> {
    let source = std::fs::read_to_string(path)?;
    let mut parser = crate::parser::Parser::new(&source);
    let program = parser.parse_program()?;
    Ok(benchmark_program(&program, iterations, verbose))
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::ast::{Block, Program, Stmt};

    #[test]
    fn test_benchmark_simple() {
        let program = Program {
            name: "B".to_string(),
            uses: vec![],
            block: Block::with_statements(vec![Stmt::Empty]),
        };
        let result = benchmark_program(&program, 10, false);
        assert_eq!(result.iterations, 10);
    }
}