Add benchmark framework to sway-lsp

sway-lsp/Cargo.toml

@@ -40,7 +40,12 @@ urlencoding = "2.1.2"
 
 [dev-dependencies]
 assert-json-diff = "2.0"
+criterion = "0.5"
 dirs = "4.0"
 futures = { version = "0.3", default-features = false, features = ["std", "async-await"] }
 sway-lsp-test-utils = { path = "tests/utils" }
 tower = { version = "0.4.12", default-features = false, features = ["util"] }
+
+[[bench]]
+name = "bench_main"
+harness = false

sway-lsp/benches/bench_main.rs

@@ -0,0 +1,7 @@
+mod lsp_benchmarks;
+use criterion::criterion_main;
+
+criterion_main! {
+    lsp_benchmarks::token_map::benches,
+    lsp_benchmarks::requests::benches,
+}

sway-lsp/benches/lsp_benchmarks/mod.rs

@@ -0,0 +1,29 @@
+pub mod requests;
+pub mod token_map;
+
+use lsp_types::Url;
+use std::{path::PathBuf, sync::Arc};
+use sway_lsp::core::session::{self, Session};
+
+pub fn compile_test_project() -> (Url, Arc<Session>) {
+    let session = Session::new();
+    // Load the test project
+    let uri = Url::from_file_path(benchmark_dir().join("src/main.sw")).unwrap();
+    session.handle_open_file(&uri);
+    // Compile the project and write the parse result to the session
+    let parse_result = session::parse_project(&uri).unwrap();
+    session.write_parse_result(parse_result);
+    (uri, Arc::new(session))
+}
+
+pub fn sway_workspace_dir() -> PathBuf {
+    std::env::current_dir()
+        .unwrap()
+        .parent()
+        .unwrap()
+        .to_path_buf()
+}
+
+pub fn benchmark_dir() -> PathBuf {
+    sway_workspace_dir().join("sway-lsp/tests/fixtures/benchmark")
+}

sway-lsp/benches/lsp_benchmarks/requests.rs

@@ -0,0 +1,44 @@
+use criterion::{black_box, criterion_group, Criterion};
+use lsp_types::Position;
+use sway_lsp::{capabilities, utils::keyword_docs::KeywordDocs};
+
+fn benchmarks(c: &mut Criterion) {
+    let (uri, session) = black_box(super::compile_test_project());
+    let keyword_docs = KeywordDocs::new();
+    let position = Position::new(1716, 24);
+
+    c.bench_function("hover", |b| {
+        b.iter(|| {
+            capabilities::hover::hover_data(session.clone(), &keyword_docs, uri.clone(), position)
+        })
+    });
+
+    c.bench_function("highlight", |b| {
+        b.iter(|| capabilities::highlight::get_highlights(session.clone(), uri.clone(), position))
+    });
+
+    c.bench_function("goto_definition", |b| {
+        b.iter(|| session.token_definition_response(uri.clone(), position))
+    });
+
+    c.bench_function("prepare_rename", |b| {
+        b.iter(|| capabilities::rename::prepare_rename(session.clone(), uri.clone(), position))
+    });
+
+    c.bench_function("rename", |b| {
+        b.iter(|| {
+            capabilities::rename::rename(
+                session.clone(),
+                "new_token_name".to_string(),
+                uri.clone(),
+                position,
+            )
+        })
+    });
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default().measurement_time(std::time::Duration::from_secs(10));
+    targets = benchmarks
+}

sway-lsp/benches/lsp_benchmarks/token_map.rs

@@ -0,0 +1,50 @@
+use criterion::{black_box, criterion_group, Criterion};
+use lsp_types::Position;
+
+fn benchmarks(c: &mut Criterion) {
+    let (uri, session) = black_box(super::compile_test_project());
+    let engines = session.engines.read();
+    let position = Position::new(1716, 24);
+
+    c.bench_function("tokens_for_file", |b| {
+        b.iter(|| session.token_map().tokens_for_file(engines.se(), &uri))
+    });
+
+    c.bench_function("idents_at_position", |b| {
+        b.iter(|| {
+            session
+                .token_map()
+                .idents_at_position(position, session.token_map().iter())
+        })
+    });
+
+    c.bench_function("tokens_at_position", |b| {
+        b.iter(|| {
+            session
+                .token_map()
+                .tokens_at_position(engines.se(), &uri, position, None)
+        })
+    });
+
+    c.bench_function("token_at_position", |b| {
+        b.iter(|| {
+            session
+                .token_map()
+                .token_at_position(engines.se(), &uri, position)
+        })
+    });
+
+    c.bench_function("parent_decl_at_position", |b| {
+        b.iter(|| {
+            session
+                .token_map()
+                .parent_decl_at_position(engines.se(), &uri, position)
+        })
+    });
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default().measurement_time(std::time::Duration::from_secs(10));
+    targets = benchmarks
+}

sway-lsp/src/core/mod.rs

@@ -2,5 +2,5 @@ pub mod document;
 pub mod session;
 pub(crate) mod sync;
 pub(crate) mod token;
-pub(crate) mod token_map;
+pub mod token_map;
 pub mod token_map_ext;

sway-lsp/src/core/session.rs

@@ -86,6 +86,12 @@ pub struct Session {
     pub diagnostics: Arc<RwLock<Diagnostics>>,
 }
 
+impl Default for Session {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Session {
     pub fn new() -> Self {
         Session {
@@ -138,7 +144,7 @@ impl Session {
 
     /// Write the result of parsing to the session.
     /// This function should only be called after successfully parsing.
-    pub(crate) fn write_parse_result(&self, res: ParseResult) {
+    pub fn write_parse_result(&self, res: ParseResult) {
         self.token_map.clear();
         self.runnables.clear();
 

sway-lsp/src/core/token_map.rs

@@ -11,7 +11,7 @@ pub use crate::core::token_map_ext::TokenMapExt;
 /// It stores all of the tokens that have been parsed and typechecked by the sway compiler.
 ///
 /// The TokenMap is a wrapper around a [DashMap], which is a concurrent HashMap.
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct TokenMap(DashMap<(Ident, Span), Token>);
 
 impl TokenMap {

sway-lsp/src/lib.rs

@@ -1,8 +1,8 @@
 #![recursion_limit = "256"]
 
-mod capabilities;
+pub mod capabilities;
 pub mod config;
-mod core;
+pub mod core;
 pub mod error;
 pub mod server_state;
 mod handlers {

sway-lsp/src/utils/mod.rs

@@ -1,6 +1,6 @@
 pub(crate) mod attributes;
 pub mod debug;
 pub(crate) mod document;
-pub(crate) mod keyword_docs;
+pub mod keyword_docs;
 pub mod markdown;
 pub(crate) mod markup;