perf(compile): code cache (#26528)

Adds a lazily created code cache to `deno compile` by default.

The code cache is created on first run to a single file in the temp
directory and is only written once. After it's been written, the code
cache becomes read only on subsequent runs. Only the modules loaded
during startup are cached (dynamic imports are not code cached).

The code cache can be disabled by compiling with `--no-code-cache`.

1 files changed, 82 insertions, 7 deletions

diff --git a/cli/standalone/mod.rs b/cli/standalone/mod.rs
index e3449c152..b9f0b1d5b 100644
--- a/cli/standalone/mod.rs
+++ b/cli/standalone/mod.rs
@@ -7,6 +7,7 @@
 
 use binary::StandaloneData;
 use binary::StandaloneModules;
+use code_cache::DenoCompileCodeCache;
 use deno_ast::MediaType;
 use deno_cache_dir::npm::NpmCacheDir;
 use deno_config::workspace::MappedResolution;
@@ -17,6 +18,7 @@ use deno_core::anyhow::Context;
 use deno_core::error::generic_error;
 use deno_core::error::type_error;
 use deno_core::error::AnyError;
+use deno_core::futures::future::LocalBoxFuture;
 use deno_core::futures::FutureExt;
 use deno_core::v8_set_flags;
 use deno_core::FastString;
@@ -27,6 +29,7 @@ use deno_core::ModuleSpecifier;
 use deno_core::ModuleType;
 use deno_core::RequestedModuleType;
 use deno_core::ResolutionKind;
+use deno_core::SourceCodeCacheInfo;
 use deno_npm::npm_rc::ResolvedNpmRc;
 use deno_package_json::PackageJsonDepValue;
 use deno_resolver::npm::NpmReqResolverOptions;
@@ -64,6 +67,7 @@ use crate::args::StorageKeyResolver;
 use crate::cache::Caches;
 use crate::cache::DenoCacheEnvFsAdapter;
 use crate::cache::DenoDirProvider;
+use crate::cache::FastInsecureHasher;
 use crate::cache::NodeAnalysisCache;
 use crate::cache::RealDenoCacheEnv;
 use crate::http_util::HttpClientProvider;
@@ -86,12 +90,14 @@ use crate::resolver::NpmModuleLoader;
 use crate::util::progress_bar::ProgressBar;
 use crate::util::progress_bar::ProgressBarStyle;
 use crate::util::v8::construct_v8_flags;
+use crate::worker::CliCodeCache;
 use crate::worker::CliMainWorkerFactory;
 use crate::worker::CliMainWorkerOptions;
 use crate::worker::CreateModuleLoaderResult;
 use crate::worker::ModuleLoaderFactory;
 
 pub mod binary;
+mod code_cache;
 mod file_system;
 mod serialization;
 mod virtual_fs;
@@ -113,6 +119,35 @@ struct SharedModuleLoaderState {
   npm_req_resolver: Arc<CliNpmReqResolver>,
   npm_resolver: Arc<dyn CliNpmResolver>,
   workspace_resolver: WorkspaceResolver,
+  code_cache: Option<Arc<dyn CliCodeCache>>,
+}
+
+impl SharedModuleLoaderState {
+  fn get_code_cache(
+    &self,
+    specifier: &ModuleSpecifier,
+    source: &[u8],
+  ) -> Option<SourceCodeCacheInfo> {
+    let Some(code_cache) = &self.code_cache else {
+      return None;
+    };
+    if !code_cache.enabled() {
+      return None;
+    }
+    // deno version is already included in the root cache key
+    let hash = FastInsecureHasher::new_without_deno_version()
+      .write_hashable(source)
+      .finish();
+    let data = code_cache.get_sync(
+      specifier,
+      deno_runtime::code_cache::CodeCacheType::EsModule,
+      hash,
+    );
+    Some(SourceCodeCacheInfo {
+      hash,
+      data: data.map(Cow::Owned),
+    })
+  }
 }
 
 #[derive(Clone)]
@@ -329,14 +364,19 @@ impl ModuleLoader for EmbeddedModuleLoader {
     }
 
     if self.shared.node_resolver.in_npm_package(original_specifier) {
-      let npm_module_loader = self.shared.npm_module_loader.clone();
+      let shared = self.shared.clone();
       let original_specifier = original_specifier.clone();
       let maybe_referrer = maybe_referrer.cloned();
       return deno_core::ModuleLoadResponse::Async(
         async move {
-          let code_source = npm_module_loader
+          let code_source = shared
+            .npm_module_loader
             .load(&original_specifier, maybe_referrer.as_ref())
             .await?;
+          let code_cache_entry = shared.get_code_cache(
+            &code_source.found_url,
+            code_source.code.as_bytes(),
+          );
           Ok(deno_core::ModuleSource::new_with_redirect(
             match code_source.media_type {
               MediaType::Json => ModuleType::Json,
@@ -345,7 +385,7 @@ impl ModuleLoader for EmbeddedModuleLoader {
             code_source.code,
             &original_specifier,
             &code_source.found_url,
-            None,
+            code_cache_entry,
           ))
         }
         .boxed_local(),
@@ -398,25 +438,30 @@ impl ModuleLoader for EmbeddedModuleLoader {
                   ModuleSourceCode::String(FastString::from_static(source))
                 }
               };
+              let code_cache_entry = shared
+                .get_code_cache(&module_specifier, module_source.as_bytes());
               Ok(deno_core::ModuleSource::new_with_redirect(
                 module_type,
                 module_source,
                 &original_specifier,
                 &module_specifier,
-                None,
+                code_cache_entry,
               ))
             }
             .boxed_local(),
           )
         } else {
           let module_source = module_source.into_for_v8();
+          let code_cache_entry = self
+            .shared
+            .get_code_cache(module_specifier, module_source.as_bytes());
           deno_core::ModuleLoadResponse::Sync(Ok(
             deno_core::ModuleSource::new_with_redirect(
               module_type,
               module_source,
               original_specifier,
               module_specifier,
-              None,
+              code_cache_entry,
             ),
           ))
         }
@@ -429,6 +474,23 @@ impl ModuleLoader for EmbeddedModuleLoader {
       ))),
     }
   }
+
+  fn code_cache_ready(
+    &self,
+    specifier: ModuleSpecifier,
+    source_hash: u64,
+    code_cache_data: &[u8],
+  ) -> LocalBoxFuture<'static, ()> {
+    if let Some(code_cache) = &self.shared.code_cache {
+      code_cache.set_sync(
+        specifier,
+        deno_runtime::code_cache::CodeCacheType::EsModule,
+        source_hash,
+        code_cache_data,
+      );
+    }
+    std::future::ready(()).boxed_local()
+  }
 }
 
 impl NodeRequireLoader for EmbeddedModuleLoader {
@@ -739,6 +801,19 @@ pub async fn run(data: StandaloneData) -> Result<i32, AnyError> {
       metadata.workspace_resolver.pkg_json_resolution,
     )
   };
+  let code_cache = match metadata.code_cache_key {
+    Some(code_cache_key) => Some(Arc::new(DenoCompileCodeCache::new(
+      root_path.with_file_name(format!(
+        "{}.cache",
+        root_path.file_name().unwrap().to_string_lossy()
+      )),
+      code_cache_key,
+    )) as Arc<dyn CliCodeCache>),
+    None => {
+      log::debug!("Code cache disabled.");
+      None
+    }
+  };
   let module_loader_factory = StandaloneModuleLoaderFactory {
     shared: Arc::new(SharedModuleLoaderState {
       cjs_tracker: cjs_tracker.clone(),
@@ -751,6 +826,7 @@ pub async fn run(data: StandaloneData) -> Result<i32, AnyError> {
         fs.clone(),
         node_code_translator,
       )),
+      code_cache: code_cache.clone(),
       npm_resolver: npm_resolver.clone(),
       workspace_resolver,
       npm_req_resolver,
@@ -792,8 +868,7 @@ pub async fn run(data: StandaloneData) -> Result<i32, AnyError> {
   });
   let worker_factory = CliMainWorkerFactory::new(
     Arc::new(BlobStore::default()),
-    // Code cache is not supported for standalone binary yet.
-    None,
+    code_cache,
     feature_checker,
     fs,
     None,