Add benchmark test cases for the new binder (#1455)

This PR adds a benchmark case to measure the performance of the new
binder. I'd like to have a good baseline before making any big changes
in the implementation (eg. using red-green trees for the CST and IR
nodes). It would also be nice to have this merged before #1443 in order
to measure how the simplification of the IR used by the binder affects
performance.

Author: ggiraldez

crates/solidity/outputs/cargo/crate/src/backend/binder/mod.rs

@@ -231,7 +231,6 @@ impl Binder {
         }
     }
 
-    #[cfg(feature = "__private_testing_utils")]
     pub(crate) fn get_linearised_bases(&self, node_id: NodeId) -> Option<&Vec<NodeId>> {
         self.linearisations.get(&node_id)
     }

crates/solidity/testing/perf/cargo/Cargo.toml

@@ -13,7 +13,7 @@ paste = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
-slang_solidity = { workspace = true }
+slang_solidity = { workspace = true, features = ["__private_backend_api"] }
 solar = { workspace = true }
 solidity_testing_utils = { workspace = true }
 streaming-iterator = { workspace = true }

crates/solidity/testing/perf/cargo/benches/slang/main.rs

@@ -8,6 +8,7 @@ use iai_callgrind::{
     LibraryBenchmarkConfig, Tool, ValgrindTool,
 };
 use paste::paste;
+use slang_solidity::backend::BinderOutput;
 use slang_solidity::compilation::CompilationUnit;
 use solidity_testing_perf_cargo::dataset::SolidityProject;
 use solidity_testing_perf_cargo::tests;
@@ -32,54 +33,68 @@ macro_rules! slang_define_full_tests {
          */
 
         paste! {
-          #[library_benchmark(setup = tests::parser::setup)]
-          #[bench::test(stringify!($prj))]
-          pub fn [< $prj _parser >](project: &SolidityProject) -> Rc<CompilationUnit> {
-              black_box(tests::parser::run(project))
-          }
-
-          #[library_benchmark(setup = tests::cursor::setup)]
-          #[bench::test(stringify!($prj))]
-          pub fn [<$prj _cursor >](unit: Rc<CompilationUnit>) -> Rc<CompilationUnit> {
-              black_box(tests::cursor::run(unit))
-          }
-
-          #[library_benchmark(setup = tests::query::setup)]
-          #[bench::test(stringify!($prj))]
-          pub fn [<$prj _query >](unit: Rc<CompilationUnit>) -> Rc<CompilationUnit> {
-              black_box(tests::query::run(unit))
-          }
-
-          #[library_benchmark(setup = tests::bindings_build::setup)]
-          #[bench::test(stringify!($prj))]
-          pub fn [<$prj _bindings_build >](unit: Rc<CompilationUnit>) -> BuiltBindingGraph {
-              black_box(tests::bindings_build::run(unit))
-          }
-
-          #[library_benchmark(setup = tests::bindings_resolve::setup)]
-          #[bench::test(stringify!($prj))]
-          pub fn [<$prj _bindings_resolve >](unit: BuiltBindingGraph) -> BuiltBindingGraph {
-              black_box(tests::bindings_resolve::run(unit))
-          }
-
-          // We add a cleanup phase to measure the destruction of the AST and the binding structures
-          #[library_benchmark(setup = tests::bindings_resolve::setup)]
-          #[bench::test(stringify!($prj))]
-          pub fn [< $prj _cleanup >](unit: BuiltBindingGraph) {
-              black_box(unit);
-          }
-
-          library_benchmark_group!(
-              name = [< $prj _full>];
-
-              // __SLANG_INFRA_BENCHMARKS_LIST__ (keep in sync)
-              benchmarks =
-                [< $prj _parser>],
-                [< $prj _cursor>],
-                [< $prj _query>],
-                [< $prj _bindings_build>],
-                [< $prj _bindings_resolve>],
-                [< $prj _cleanup>],
+            #[library_benchmark(setup = tests::parser::setup)]
+            #[bench::test(stringify!($prj))]
+            pub fn [< $prj _parser >](project: &SolidityProject) -> Rc<CompilationUnit> {
+                black_box(tests::parser::run(project))
+            }
+
+            #[library_benchmark(setup = tests::cursor::setup)]
+            #[bench::test(stringify!($prj))]
+            pub fn [< $prj _cursor >](unit: Rc<CompilationUnit>) -> Rc<CompilationUnit> {
+                black_box(tests::cursor::run(unit))
+            }
+
+            #[library_benchmark(setup = tests::query::setup)]
+            #[bench::test(stringify!($prj))]
+            pub fn [< $prj _query >](unit: Rc<CompilationUnit>) -> Rc<CompilationUnit> {
+                black_box(tests::query::run(unit))
+            }
+
+            #[library_benchmark(setup = tests::bindings_build::setup)]
+            #[bench::test(stringify!($prj))]
+            pub fn [< $prj _bindings_build >](unit: Rc<CompilationUnit>) -> BuiltBindingGraph {
+                black_box(tests::bindings_build::run(unit))
+            }
+
+            #[library_benchmark(setup = tests::bindings_resolve::setup)]
+            #[bench::test(stringify!($prj))]
+            pub fn [< $prj _bindings_resolve >](unit: BuiltBindingGraph) -> BuiltBindingGraph {
+                black_box(tests::bindings_resolve::run(unit))
+            }
+
+            // We add a cleanup phase to measure the destruction of the AST and the binding structures
+            #[library_benchmark(setup = tests::bindings_resolve::setup)]
+            #[bench::test(stringify!($prj))]
+            pub fn [< $prj _cleanup >](unit: BuiltBindingGraph) {
+                black_box(unit);
+            }
+
+            #[library_benchmark(setup = tests::binder_v2_run::setup)]
+            #[bench::test(stringify!($prj))]
+            fn [< $prj _binder_v2_run >](unit: CompilationUnit) -> BinderOutput {
+                black_box(tests::binder_v2_run::run(unit))
+            }
+
+            #[library_benchmark(setup = tests::binder_v2_cleanup::setup)]
+            #[bench::test(stringify!($prj))]
+            fn [< $prj _binder_v2_cleanup >](output: BinderOutput) {
+                black_box(output);
+            }
+
+            library_benchmark_group!(
+                name = [< $prj _full >];
+
+                // __SLANG_INFRA_BENCHMARKS_LIST__ (keep in sync)
+                benchmarks =
+                    [< $prj _parser >],
+                    [< $prj _cursor >],
+                    [< $prj _query >],
+                    [< $prj _bindings_build >],
+                    [< $prj _bindings_resolve >],
+                    [< $prj _cleanup >],
+                    [< $prj _binder_v2_run >],
+                    [< $prj _binder_v2_cleanup >],
             );
         }
     };

crates/solidity/testing/perf/cargo/src/lib.rs

@@ -46,6 +46,7 @@ mod unit_tests {
         define_payload_test_and_assert_count_eq!(query, super::CONTRACT_COUNT);
         define_payload_test!(bindings_build);
         define_payload_test_and_assert_count_eq!(bindings_resolve, super::IDENTIFIER_COUNT);
+        define_payload_test_and_assert_count_eq!(binder_v2_run, super::IDENTIFIER_COUNT);
     }
 
     mod solar {

crates/solidity/testing/perf/cargo/src/tests/binder_v2_cleanup.rs

@@ -0,0 +1,9 @@
+use slang_solidity::backend::{build_binder_output, BinderOutput};
+
+pub fn setup(project: &str) -> BinderOutput {
+    build_binder_output(
+        super::setup::setup(project)
+            .build_compilation_unit()
+            .unwrap(),
+    )
+}

crates/solidity/testing/perf/cargo/src/tests/binder_v2_run.rs

@@ -0,0 +1,54 @@
+use slang_solidity::backend::binder::Resolution;
+use slang_solidity::backend::{build_binder_output, BinderOutput};
+use slang_solidity::compilation::CompilationUnit;
+use slang_solidity::cst::{NodeKind, TerminalKindExtensions};
+
+pub fn setup(project: &str) -> CompilationUnit {
+    let project = super::setup::setup(project);
+    project.build_compilation_unit().unwrap()
+}
+
+pub fn run(unit: CompilationUnit) -> BinderOutput {
+    inner_run(unit).0
+}
+
+pub fn test(unit: CompilationUnit) -> usize {
+    inner_run(unit).1
+}
+
+fn inner_run(unit: CompilationUnit) -> (BinderOutput, usize) {
+    let data = build_binder_output(unit);
+
+    let mut ids = 0;
+
+    for file in data.compilation_unit.files() {
+        let mut cursor = file.create_tree_cursor();
+
+        while cursor.go_to_next_terminal() {
+            if !matches!(cursor.node().kind(), NodeKind::Terminal(kind) if kind.is_identifier()) {
+                continue;
+            }
+
+            ids += 1;
+            let node_id = cursor.node().id();
+            if data
+                .binder
+                .find_definition_by_identifier_node_id(node_id)
+                .is_none()
+                && data
+                    .binder
+                    .find_reference_by_identifier_node_id(node_id)
+                    .is_none_or(|reference| reference.resolution == Resolution::Unresolved)
+            {
+                panic!(
+                    "Unbound identifier: '{value}' in '{file_path}:{line}:{column}'.",
+                    value = cursor.node().unparse(),
+                    file_path = file.id(),
+                    line = cursor.text_range().start.line + 1,
+                    column = cursor.text_range().start.column + 1,
+                );
+            }
+        }
+    }
+    (data, ids)
+}

crates/solidity/testing/perf/cargo/src/tests/mod.rs

@@ -1,3 +1,5 @@
+pub mod binder_v2_cleanup;
+pub mod binder_v2_run;
 pub mod bindings_build;
 pub mod bindings_resolve;
 pub mod cursor;