Cache Build Plans in language server

sway-lsp/benches/lsp_benchmarks/compile.rs

@@ -1,35 +1,44 @@
 use criterion::{black_box, criterion_group, Criterion};
-use lsp_types::Url;
 use std::sync::Arc;
 use sway_core::{Engines, ExperimentalFlags};
 use sway_lsp::core::session;
+use tokio::runtime::Runtime;
 
 const NUM_DID_CHANGE_ITERATIONS: usize = 10;
 
 fn benchmarks(c: &mut Criterion) {
-    let experimental = ExperimentalFlags {
-        new_encoding: false,
-    };
+    let (uri, session, _) = Runtime::new()
+        .unwrap()
+        .block_on(async { black_box(super::compile_test_project().await) });
+
+    let build_plan = session
+        .build_plan_cache
+        .get_or_update(&session.sync.manifest_path(), || session::build_plan(&uri))
+        .unwrap();
 
-    // Load the test project
-    let uri = Url::from_file_path(super::benchmark_dir().join("src/main.sw")).unwrap();
     let mut lsp_mode = Some(sway_core::LspConfig {
         optimized_build: false,
         file_versions: Default::default(),
     });
+
+    let experimental = ExperimentalFlags {
+        new_encoding: false,
+    };
+
     c.bench_function("compile", |b| {
         b.iter(|| {
             let engines = Engines::default();
             let _ = black_box(
-                session::compile(&uri, &engines, None, lsp_mode.clone(), experimental).unwrap(),
+                session::compile(&build_plan, &engines, None, lsp_mode.clone(), experimental)
+                    .unwrap(),
             );
         })
     });
 
     c.bench_function("traverse", |b| {
         let engines = Engines::default();
         let results = black_box(
-            session::compile(&uri, &engines, None, lsp_mode.clone(), experimental).unwrap(),
+            session::compile(&build_plan, &engines, None, lsp_mode.clone(), experimental).unwrap(),
         );
         let session = Arc::new(session::Session::new());
         b.iter(|| {
@@ -44,7 +53,8 @@ fn benchmarks(c: &mut Criterion) {
         b.iter(|| {
             for _ in 0..NUM_DID_CHANGE_ITERATIONS {
                 let _ = black_box(
-                    session::compile(&uri, &engines, None, lsp_mode.clone(), experimental).unwrap(),
+                    session::compile(&build_plan, &engines, None, lsp_mode.clone(), experimental)
+                        .unwrap(),
                 );
             }
         })

sway-lsp/src/core/session.rs

@@ -29,6 +29,7 @@ use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
 use std::{
     path::PathBuf,
     sync::{atomic::AtomicBool, Arc},
+    time::SystemTime,
 };
 use sway_core::{
     decl_engine::DeclEngine,
@@ -61,6 +62,7 @@ pub struct CompiledProgram {
 pub struct Session {
     token_map: TokenMap,
     pub runnables: RunnableMap,
+    pub build_plan_cache: BuildPlanCache,
     pub compiled_program: RwLock<CompiledProgram>,
     pub engines: RwLock<Engines>,
     pub sync: SyncWorkspace,
@@ -80,6 +82,7 @@ impl Session {
         Session {
             token_map: TokenMap::new(),
             runnables: DashMap::new(),
+            build_plan_cache: BuildPlanCache::default(),
             metrics: DashMap::new(),
             compiled_program: RwLock::new(CompiledProgram::default()),
             engines: <_>::default(),
@@ -228,7 +231,7 @@ impl Session {
 }
 
 /// Create a [BuildPlan] from the given [Url] appropriate for the language server.
-pub(crate) fn build_plan(uri: &Url) -> Result<BuildPlan, LanguageServerError> {
+pub fn build_plan(uri: &Url) -> Result<BuildPlan, LanguageServerError> {
     let _p = tracing::trace_span!("build_plan").entered();
     let manifest_dir = PathBuf::from(uri.path());
     let manifest =
@@ -254,17 +257,16 @@ pub(crate) fn build_plan(uri: &Url) -> Result<BuildPlan, LanguageServerError> {
 }
 
 pub fn compile(
-    uri: &Url,
+    build_plan: &BuildPlan,
     engines: &Engines,
     retrigger_compilation: Option<Arc<AtomicBool>>,
     lsp_mode: Option<LspConfig>,
     experimental: sway_core::ExperimentalFlags,
 ) -> Result<Vec<(Option<Programs>, Handler)>, LanguageServerError> {
     let _p = tracing::trace_span!("compile").entered();
-    let build_plan = build_plan(uri)?;
     let tests_enabled = true;
     pkg::check(
-        &build_plan,
+        build_plan,
         BuildTarget::default(),
         true,
         lsp_mode,
@@ -382,8 +384,11 @@ pub fn parse_project(
     experimental: sway_core::ExperimentalFlags,
 ) -> Result<(), LanguageServerError> {
     let _p = tracing::trace_span!("parse_project").entered();
+    let build_plan = session
+        .build_plan_cache
+        .get_or_update(&session.sync.manifest_path(), || build_plan(uri))?;
     let results = compile(
-        uri,
+        &build_plan,
         engines,
         retrigger_compilation,
         lsp_mode.clone(),
@@ -508,6 +513,56 @@ pub(crate) fn program_id_from_path(
     Ok(program_id)
 }
 
+/// A cache for storing and retrieving BuildPlan objects.
+#[derive(Debug, Clone)]
+pub struct BuildPlanCache {
+    /// The cached BuildPlan and its last update time
+    cache: Arc<RwLock<Option<(BuildPlan, SystemTime)>>>,
+}
+
+impl Default for BuildPlanCache {
+    fn default() -> Self {
+        Self {
+            cache: Arc::new(RwLock::new(None)),
+        }
+    }
+}
+
+impl BuildPlanCache {
+    /// Retrieves a BuildPlan from the cache or updates it if necessary.
+    pub fn get_or_update<F>(
+        &self,
+        manifest_path: &Option<PathBuf>,
+        update_fn: F,
+    ) -> Result<BuildPlan, LanguageServerError>
+    where
+        F: FnOnce() -> Result<BuildPlan, LanguageServerError>,
+    {
+        let should_update = {
+            let cache = self.cache.read();
+            manifest_path
+                .as_ref()
+                .and_then(|path| path.metadata().ok()?.modified().ok())
+                .map_or(cache.is_none(), |time| {
+                    cache.as_ref().map_or(true, |&(_, last)| time > last)
+                })
+        };
+
+        if should_update {
+            let new_plan = update_fn()?;
+            let mut cache = self.cache.write();
+            *cache = Some((new_plan.clone(), SystemTime::now()));
+            Ok(new_plan)
+        } else {
+            let cache = self.cache.read();
+            cache
+                .as_ref()
+                .map(|(plan, _)| plan.clone())
+                .ok_or(LanguageServerError::BuildPlanCacheIsEmpty)
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

sway-lsp/src/core/sync.rs

@@ -175,7 +175,7 @@ impl SyncWorkspace {
             .ok()
     }
 
-    pub(crate) fn manifest_path(&self) -> Option<PathBuf> {
+    pub fn manifest_path(&self) -> Option<PathBuf> {
         self.manifest_dir()
             .map(|dir| dir.join(sway_utils::constants::MANIFEST_FILE_NAME))
             .ok()

sway-lsp/src/error.rs

@@ -14,6 +14,8 @@ pub enum LanguageServerError {
     // Top level errors
     #[error("Failed to create build plan. {0}")]
     BuildPlanFailed(anyhow::Error),
+    #[error("Build Plan Cache is empty")]
+    BuildPlanCacheIsEmpty,
     #[error("Failed to compile. {0}")]
     FailedToCompile(anyhow::Error),
     #[error("Failed to parse document")]