// Copyright (C) 2019-2023 Aleo Systems Inc. // This file is part of the Leo library. // The Leo library is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or // (at your option) any later version. // The Leo library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with the Leo library. If not, see . //! This file contains tools for benchmarking the Leo compiler and its stages. use leo_compiler::{Compiler, CompilerOptions}; use leo_errors::emitter::{Emitter, Handler}; use leo_span::{source_map::FileName, symbol::SESSION_GLOBALS}; use leo_test_framework::get_benches; use criterion::{black_box, criterion_group, criterion_main, Criterion}; use std::{ path::PathBuf, time::{Duration, Instant}, }; /// An enum to represent the stage of the Compiler we are benchmarking. enum BenchMode { /// Benchmarks parsing. Parse, /// Benchmarks symbol table generation. Symbol, /// Benchmarks type checking. Type, /// Benchmarks loop unrolling. Unroll, /// Benchmarks static single assignment. Ssa, /// Benchmarks flattening. Flatten, /// Benchmarks function inlining. Inline, /// Benchmarks dead code elimination. Dce, /// Benchmarks code generation. Codegen, /// Benchmarks all the above stages. Full, } /// A dummy buffer emitter since we only test on valid programs. struct BufEmitter; impl Emitter for BufEmitter { fn emit_err(&mut self, _: leo_errors::LeoError) {} fn last_emitted_err_code(&self) -> Option { None } fn emit_warning(&mut self, _: leo_errors::LeoWarning) {} } impl BufEmitter { fn new_handler() -> Handler { Handler::new(Box::new(Self)) } } /// The name of the test, and the test content. #[derive(Clone)] struct Sample { name: String, input: String, } /// A helper function to help create a Leo Compiler struct. fn new_compiler(handler: &Handler) -> Compiler<'_> { Compiler::new( String::from("test"), String::from("aleo"), handler, PathBuf::from(String::new()), PathBuf::from(String::new()), Some(CompilerOptions { spans_enabled: false, dce_enabled: true, initial_ast: false, initial_input_ast: false, unrolled_ast: false, ssa_ast: false, flattened_ast: false, inlined_ast: false, dce_ast: false, }), ) } impl Sample { /// Loads all the benchmark samples. /// Leverages the test-framework to grab all tests /// that are passing compiler tests or marked as benchmark tests. fn load_samples() -> Vec { get_benches() .into_iter() .map(|(name, input)| Self { name, input }) .collect() } fn data(&self) -> (&str, FileName) { black_box((&self.input, FileName::Custom(String::new()))) } fn bench(&self, c: &mut Criterion, mode: BenchMode) { match mode { BenchMode::Parse => self.bench_parse(c), BenchMode::Symbol => self.bench_symbol_table(c), BenchMode::Type => self.bench_type_checker(c), BenchMode::Unroll => self.bench_loop_unroller(c), BenchMode::Ssa => self.bench_ssa(c), BenchMode::Flatten => self.bench_flattener(c), BenchMode::Inline => self.bench_inline(c), BenchMode::Dce => self.bench_dce(c), BenchMode::Codegen => self.bench_codegen(c), BenchMode::Full => self.bench_full(c), } } /// Benchmarks `logic(compiler)` where `compiler` is provided. fn bencher(&self, c: &mut Criterion, mode: &str, mut logic: impl FnMut(Compiler) -> Duration) { c.bench_function(&format!("{mode} {}", self.name), |b| { // Iter custom is used so we can use custom timings around the compiler stages. // This way we can only time the necessary stage. b.iter_custom(|iters| { (0..iters) .map(|_| SESSION_GLOBALS.set(&<_>::default(), || logic(new_compiler(&BufEmitter::new_handler())))) .sum() }); }); } /// Benchmarks `logic(compiler)` where `compiler` is provided. /// Parsing has already been done. fn bencher_after_parse(&self, c: &mut Criterion, mode: &str, mut logic: impl FnMut(Compiler) -> Duration) { self.bencher(c, mode, |mut compiler| { let (input, name) = self.data(); compiler .parse_program_from_string(input, name) .expect("Failed to parse program"); logic(compiler) }); } fn bench_parse(&self, c: &mut Criterion) { self.bencher(c, "parse", |mut compiler| { let (input, name) = self.data(); let start = Instant::now(); let out = compiler.parse_program_from_string(input, name); let time = start.elapsed(); out.expect("Failed to parse program"); time }) } fn bench_symbol_table(&self, c: &mut Criterion) { self.bencher_after_parse(c, "symbol table pass", |compiler| { let start = Instant::now(); let out = compiler.symbol_table_pass(); let time = start.elapsed(); out.expect("failed to generate symbol table"); time }); } fn bench_type_checker(&self, c: &mut Criterion) { self.bencher_after_parse(c, "type checker pass", |compiler| { let symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); let start = Instant::now(); let out = compiler.type_checker_pass(symbol_table); let time = start.elapsed(); out.expect("failed to run type check pass"); time }); } fn bench_loop_unroller(&self, c: &mut Criterion) { self.bencher_after_parse(c, "loop unrolling pass", |mut compiler| { let symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); let (symbol_table, _struct_graph, _call_graph) = compiler .type_checker_pass(symbol_table) .expect("failed to run type check pass"); let start = Instant::now(); let out = compiler.loop_unrolling_pass(symbol_table); let time = start.elapsed(); out.expect("failed to run loop unrolling pass"); time }); } fn bench_ssa(&self, c: &mut Criterion) { self.bencher_after_parse(c, "full", |mut compiler| { let symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); let (symbol_table, _struct_graph, _call_graph) = compiler .type_checker_pass(symbol_table) .expect("failed to run type check pass"); let symbol_table = compiler .loop_unrolling_pass(symbol_table) .expect("failed to run loop unrolling pass"); let start = Instant::now(); let out = compiler.static_single_assignment_pass(&symbol_table); let time = start.elapsed(); out.expect("failed to run ssa pass"); time }) } fn bench_flattener(&self, c: &mut Criterion) { self.bencher_after_parse(c, "flattener pass", |mut compiler| { let symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); let (symbol_table, _struct_graph, _call_graph) = compiler .type_checker_pass(symbol_table) .expect("failed to run type check pass"); let symbol_table = compiler .loop_unrolling_pass(symbol_table) .expect("failed to run loop unrolling pass"); let assigner = compiler .static_single_assignment_pass(&symbol_table) .expect("failed to run ssa pass"); let start = Instant::now(); let out = compiler.flattening_pass(&symbol_table, assigner); let time = start.elapsed(); out.expect("failed to run flattener pass"); time }); } fn bench_inline(&self, c: &mut Criterion) { self.bencher_after_parse(c, "inliner pass", |mut compiler| { let symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); let (symbol_table, _struct_graph, call_graph) = compiler .type_checker_pass(symbol_table) .expect("failed to run type check pass"); let symbol_table = compiler .loop_unrolling_pass(symbol_table) .expect("failed to run loop unrolling pass"); let assigner = compiler .static_single_assignment_pass(&symbol_table) .expect("failed to run ssa pass"); let assigner = compiler .flattening_pass(&symbol_table, assigner) .expect("failed to run flattener pass"); let start = Instant::now(); let out = compiler.function_inlining_pass(&call_graph, assigner); let time = start.elapsed(); out.expect("failed to run inliner pass"); time }); } fn bench_dce(&self, c: &mut Criterion) { self.bencher_after_parse(c, "inliner pass", |mut compiler| { let symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); let (symbol_table, _struct_graph, call_graph) = compiler .type_checker_pass(symbol_table) .expect("failed to run type check pass"); let symbol_table = compiler .loop_unrolling_pass(symbol_table) .expect("failed to run loop unrolling pass"); let assigner = compiler .static_single_assignment_pass(&symbol_table) .expect("failed to run ssa pass"); let assigner = compiler .flattening_pass(&symbol_table, assigner) .expect("failed to run flattener pass"); let _ = compiler .function_inlining_pass(&call_graph, assigner) .expect("failed to run inliner pass"); let start = Instant::now(); let out = compiler.dead_code_elimination_pass(); let time = start.elapsed(); out.expect("failed to run dce pass"); time }); } fn bench_codegen(&self, c: &mut Criterion) { self.bencher_after_parse(c, "inliner pass", |mut compiler| { let symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); let (symbol_table, struct_graph, call_graph) = compiler .type_checker_pass(symbol_table) .expect("failed to run type check pass"); let symbol_table = compiler .loop_unrolling_pass(symbol_table) .expect("failed to run loop unrolling pass"); let assigner = compiler .static_single_assignment_pass(&symbol_table) .expect("failed to run ssa pass"); let assigner = compiler .flattening_pass(&symbol_table, assigner) .expect("failed to run flattener pass"); let _ = compiler .function_inlining_pass(&call_graph, assigner) .expect("failed to run inliner pass"); compiler.dead_code_elimination_pass().expect("failed to run dce pass"); let start = Instant::now(); let out = compiler.code_generation_pass(&symbol_table, &struct_graph, &call_graph); let time = start.elapsed(); out.expect("failed to run codegen pass"); time }); } fn bench_full(&self, c: &mut Criterion) { self.bencher(c, "full", |mut compiler| { let (input, name) = self.data(); let start = Instant::now(); compiler .parse_program_from_string(input, name) .expect("Failed to parse program"); let symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); let (symbol_table, struct_graph, call_graph) = compiler .type_checker_pass(symbol_table) .expect("failed to run type check pass"); let symbol_table = compiler .loop_unrolling_pass(symbol_table) .expect("failed to run loop unrolling pass"); let assigner = compiler .static_single_assignment_pass(&symbol_table) .expect("failed to run ssa pass"); let assigner = compiler .flattening_pass(&symbol_table, assigner) .expect("failed to run flattening pass"); compiler .function_inlining_pass(&call_graph, assigner) .expect("failed to run function inlining pass"); compiler.dead_code_elimination_pass().expect("failed to run dce pass"); compiler .code_generation_pass(&symbol_table, &struct_graph, &call_graph) .expect("failed to run codegen pass"); start.elapsed() }) } } macro_rules! bench { ($name:ident, $mode:expr) => { fn $name(c: &mut Criterion) { Sample::load_samples().into_iter().for_each(|s| s.bench(c, $mode)) } }; } bench!(bench_parse, BenchMode::Parse); bench!(bench_symbol, BenchMode::Symbol); bench!(bench_type, BenchMode::Type); bench!(bench_unroll, BenchMode::Unroll); bench!(bench_ssa, BenchMode::Ssa); bench!(bench_flatten, BenchMode::Flatten); bench!(bench_inline, BenchMode::Inline); bench!(bench_dce, BenchMode::Dce); bench!(bench_codegen, BenchMode::Codegen); bench!(bench_full, BenchMode::Full); criterion_group!( name = benches; config = Criterion::default().sample_size(200).measurement_time(Duration::from_secs(10)).nresamples(200_000); targets = bench_parse, bench_symbol, bench_type, bench_unroll, bench_ssa, bench_flatten, bench_inline, bench_dce, bench_codegen, bench_full ); criterion_main!(benches);