exeora-cli 0.8.2

Native Exeora CLI and local tool executor
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

//! The Rust half of `bun run bench:tools`.
//!
//! Takes a fixture the comparison script generated, runs one suite over it and
//! prints the timings as JSON. It builds nothing itself: the script hands both
//! engines their own copy of the same corpus, which is the only way the two
//! numbers under a case mean the same thing. `--verify` swaps the timings for a
//! fingerprint of every answer, which is how the script proves the two engines
//! did the same work before dividing one by the other.

mod core_suite;
mod hard_cases;
mod hard_suite;
mod harness;
mod verify;

use exeora_cli::tools::ToolEngine;
use harness::{BenchmarkResult, Config, Suite};
use std::{env, path::PathBuf};

struct Arguments {
    root: PathBuf,
    suite: Suite,
    quick: bool,
    verify: bool,
}

fn main() {
    let arguments = parse_arguments();
    let config = Config::new(arguments.suite, arguments.quick);
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .expect("Tokio runtime");
    let engine = ToolEngine::new().expect("tool engine");
    let root = arguments.root.as_path();

    if arguments.verify {
        let fingerprints = verify::run(&runtime, &engine, root);
        println!(
            "{}",
            serde_json::to_string(&fingerprints).expect("serialize fingerprints")
        );
        return;
    }

    let cases = match arguments.suite {
        Suite::Core => core_suite::run(&runtime, &engine, root, config),
        Suite::Hard => hard_suite::run(&runtime, &engine, root, config),
    };

    println!(
        "{}",
        serde_json::to_string(&BenchmarkResult {
            engine: "rust",
            cases,
        })
        .expect("serialize benchmark result")
    );
}

fn parse_arguments() -> Arguments {
    let mut root = None;
    let mut suite = Suite::Core;
    let mut quick = false;
    let mut verify = false;
    let mut arguments = env::args().skip(1);

    while let Some(argument) = arguments.next() {
        match argument.as_str() {
            "--fixture" => root = arguments.next().map(PathBuf::from),
            "--suite" => {
                suite = match arguments.next().as_deref() {
                    Some("core") | None => Suite::Core,
                    Some("hard") => Suite::Hard,
                    Some(other) => panic!("unknown suite: {other}"),
                }
            }
            "--quick" => quick = true,
            "--verify" => verify = true,
            _ => panic!("unknown argument: {argument}"),
        }
    }

    Arguments {
        root: root.expect("--fixture PATH is required"),
        suite,
        quick,
        verify,
    }
}