perf: snapshot runtime ops (denoland#21127)

Closes denoland#21135

~1ms startup time improvement

---------

Signed-off-by: Divy Srivastava <[email protected]>
Co-authored-by: David Sherret <[email protected]>

cli/args/flags.rs

@@ -307,6 +307,12 @@ pub enum DenoSubcommand {
  Vendor(VendorFlags),
 }
 
+impl DenoSubcommand {
+ pub fn is_run(&self) -> bool {
+ matches!(self, Self::Run(_))
+ }
+}
+
 impl Default for DenoSubcommand {
  fn default() -> DenoSubcommand {
  DenoSubcommand::Repl(ReplFlags {

cli/build.rs

@@ -392,6 +392,20 @@ fn create_cli_snapshot(snapshot_path: PathBuf) -> CreateSnapshotOutput {
  deno_fs::deno_fs::init_ops::<PermissionsContainer>(fs.clone()),
  deno_node::deno_node::init_ops::<PermissionsContainer>(None, fs),
  deno_runtime::runtime::init_ops(),
+ deno_runtime::ops::runtime::deno_runtime::init_ops(
+ "deno:runtime".parse().unwrap(),
+ ),
+ deno_runtime::ops::worker_host::deno_worker_host::init_ops(
+ Arc::new(|_| unreachable!("not used in snapshot.")),
+ None,
+ ),
+ deno_runtime::ops::fs_events::deno_fs_events::init_ops(),
+ deno_runtime::ops::os::deno_os::init_ops(Default::default()),
+ deno_runtime::ops::permissions::deno_permissions::init_ops(),
+ deno_runtime::ops::process::deno_process::init_ops(),
+ deno_runtime::ops::signal::deno_signal::init_ops(),
+ deno_runtime::ops::tty::deno_tty::init_ops(),
+ deno_runtime::ops::http::deno_http_runtime::init_ops(),
  cli::init_ops_and_esm(), // NOTE: This needs to be init_ops_and_esm!
  ];
 

cli/factory.rs

@@ -668,6 +668,10 @@ impl CliFactory {
  ) -> Result<CliMainWorkerOptions, AnyError> {
  Ok(CliMainWorkerOptions {
  argv: self.options.argv().clone(),
+ // This optimization is only available for "run" subcommand
+ // because we need to register new ops for testing and jupyter
+ // integration.
+ skip_op_registration: self.options.sub_command().is_run(),
  log_level: self.options.log_level().unwrap_or(log::Level::Info).into(),
  coverage_dir: self.options.coverage_dir(),
  enable_op_summary_metrics: self.options.enable_op_summary_metrics(),

cli/npm/byonm.rs

@@ -82,6 +82,16 @@ impl ByonmCliNpmResolver {
 }
 
 impl NpmResolver for ByonmCliNpmResolver {
+ fn get_npm_process_state(&self) -> String {
+ serde_json::to_string(&NpmProcessState {
+ kind: NpmProcessStateKind::Byonm,
+ local_node_modules_path: Some(
+ self.root_node_modules_dir.to_string_lossy().to_string(),
+ ),
+ })
+ .unwrap()
+ }
+
  fn resolve_package_folder_from_package(
  &self,
  name: &str,
@@ -248,16 +258,6 @@ impl CliNpmResolver for ByonmCliNpmResolver {
  )
  }
 
- fn get_npm_process_state(&self) -> String {
- serde_json::to_string(&NpmProcessState {
- kind: NpmProcessStateKind::Byonm,
- local_node_modules_path: Some(
- self.root_node_modules_dir.to_string_lossy().to_string(),
- ),
- })
- .unwrap()
- }
-
  fn check_state_hash(&self) -> Option<u64> {
  // it is very difficult to determine the check state hash for byonm
  // so we just return None to signify check caching is not supported

cli/npm/managed/mod.rs

@@ -492,6 +492,23 @@ impl ManagedCliNpmResolver {
 }
 
 impl NpmResolver for ManagedCliNpmResolver {
+ /// Gets the state of npm for the process.
+ fn get_npm_process_state(&self) -> String {
+ serde_json::to_string(&NpmProcessState {
+ kind: NpmProcessStateKind::Snapshot(
+ self
+ .resolution
+ .serialized_valid_snapshot()
+ .into_serialized(),
+ ),
+ local_node_modules_path: self
+ .fs_resolver
+ .node_modules_path()
+ .map(|p| p.to_string_lossy().to_string()),
+ })
+ .unwrap()
+ }
+
  fn resolve_package_folder_from_package(
  &self,
  name: &str,
@@ -571,23 +588,6 @@ impl CliNpmResolver for ManagedCliNpmResolver {
  self.resolve_pkg_folder_from_pkg_id(&pkg_id)
  }
 
- /// Gets the state of npm for the process.
- fn get_npm_process_state(&self) -> String {
- serde_json::to_string(&NpmProcessState {
- kind: NpmProcessStateKind::Snapshot(
- self
- .resolution
- .serialized_valid_snapshot()
- .into_serialized(),
- ),
- local_node_modules_path: self
- .fs_resolver
- .node_modules_path()
- .map(|p| p.to_string_lossy().to_string()),
- })
- .unwrap()
- }
-
  fn check_state_hash(&self) -> Option<u64> {
  // We could go further and check all the individual
  // npm packages, but that's probably overkill.

cli/npm/mod.rs

@@ -83,9 +83,6 @@ pub trait CliNpmResolver: NpmResolver {
  referrer: &ModuleSpecifier,
  ) -> Result<PathBuf, AnyError>;
 
- /// Gets the state of npm for the process.
- fn get_npm_process_state(&self) -> String;
-
  /// Returns a hash returning the state of the npm resolver
  /// or `None` if the state currently can't be determined.
  fn check_state_hash(&self) -> Option<u64>;

cli/ops/mod.rs

@@ -1,43 +1,30 @@
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
 
-use std::sync::Arc;
-
-use crate::npm::CliNpmResolver;
-use deno_core::error::AnyError;
-use deno_core::op2;
 use deno_core::Extension;
-use deno_core::OpState;
 
 pub mod bench;
 pub mod jupyter;
 pub mod testing;
 
-pub fn cli_exts(npm_resolver: Arc<dyn CliNpmResolver>) -> Vec<Extension> {
+pub fn cli_exts() -> Vec<Extension> {
  vec![
  #[cfg(not(feature = "__runtime_js_sources"))]
- cli::init_ops(npm_resolver),
+ cli::init_ops(),
  #[cfg(feature = "__runtime_js_sources")]
- cli::init_ops_and_esm(npm_resolver),
+ cli::init_ops_and_esm(),
  ]
 }
 
 // ESM parts duplicated in `../build.rs`. Keep in sync!
 deno_core::extension!(cli,
  deps = [runtime],
- ops = [op_npm_process_state],
  esm_entry_point = "ext:cli/99_main.js",
  esm = [
  dir "js",
  "40_testing.js",
  "40_jupyter.js",
  "99_main.js"
  ],
- options = {
- npm_resolver: Arc<dyn CliNpmResolver>,
- },
- state = |state, options| {
- state.put(options.npm_resolver);
- },
  customizer = |ext: &mut deno_core::Extension| {
  ext.esm_files.to_mut().push(deno_core::ExtensionFileSource {
  specifier: "ext:cli/runtime/js/99_main.js",
@@ -47,10 +34,3 @@ deno_core::extension!(cli,
  });
  },
 );
-
-#[op2]
-#[string]
-fn op_npm_process_state(state: &mut OpState) -> Result<String, AnyError> {
- let npm_resolver = state.borrow_mut::<Arc<dyn CliNpmResolver>>();
- Ok(npm_resolver.get_npm_process_state())
-}

cli/standalone/mod.rs

@@ -462,6 +462,7 @@ pub async fn run(
  strace_ops: None,
  is_inspecting: false,
  is_npm_main: main_module.scheme() == "npm",
+ skip_op_registration: true,
  location: metadata.location,
  maybe_binary_npm_command_name: NpmPackageReqReference::from_specifier(
  main_module,

cli/worker.rs

@@ -101,6 +101,7 @@ pub struct CliMainWorkerOptions {
  pub seed: Option<u64>,
  pub unsafely_ignore_certificate_errors: Option<Vec<String>>,
  pub unstable: bool,
+ pub skip_op_registration: bool,
  pub maybe_root_package_json_deps: Option<PackageJsonDeps>,
 }
 
@@ -528,7 +529,7 @@ impl CliMainWorkerFactory {
  .join(checksum::gen(&[key.as_bytes()]))
  });
 
- let mut extensions = ops::cli_exts(shared.npm_resolver.clone());
+ let mut extensions = ops::cli_exts();
  extensions.append(&mut custom_extensions);
 
  // TODO(bartlomieju): this is cruft, update FeatureChecker to spit out
@@ -596,6 +597,7 @@ impl CliMainWorkerFactory {
  ),
  stdio,
  feature_checker,
+ skip_op_registration: shared.options.skip_op_registration,
  };
 
  let worker = MainWorker::bootstrap_from_options(
@@ -706,7 +708,7 @@ fn create_web_worker_callback(
  let create_web_worker_cb =
  create_web_worker_callback(shared.clone(), stdio.clone());
 
- let extensions = ops::cli_exts(shared.npm_resolver.clone());
+ let extensions = ops::cli_exts();
 
  let maybe_storage_key = shared
  .storage_key_resolver

ext/node/lib.rs

@@ -14,6 +14,7 @@ use deno_core::v8;
 use deno_core::v8::ExternalReference;
 use deno_core::JsRuntime;
 use deno_core::ModuleSpecifier;
+use deno_core::OpState;
 use deno_fs::sync::MaybeSend;
 use deno_fs::sync::MaybeSync;
 use once_cell::sync::Lazy;
@@ -75,6 +76,16 @@ impl NodePermissions for AllowAllNodePermissions {
 pub type NpmResolverRc = deno_fs::sync::MaybeArc<dyn NpmResolver>;
 
 pub trait NpmResolver: std::fmt::Debug + MaybeSend + MaybeSync {
+ /// Gets a string containing the serialized npm state of the process.
+ ///
+ /// This will be set on the `DENO_DONT_USE_INTERNAL_NODE_COMPAT_STATE` environment
+ /// variable when doing a `child_process.fork`. The implementor can then check this environment
+ /// variable on startup to repopulate the internal npm state.
+ fn get_npm_process_state(&self) -> String {
+ // This method is only used in the CLI.
+ String::new()
+ }
+
  /// Resolves an npm package folder path from an npm package referrer.
  fn resolve_package_folder_from_package(
  &self,
@@ -139,6 +150,13 @@ fn op_node_is_promise_rejected(value: v8::Local<v8::Value>) -> bool {
  promise.state() == v8::PromiseState::Rejected
 }
 
+#[op2]
+#[string]
+fn op_npm_process_state(state: &mut OpState) -> Result<String, AnyError> {
+ let npm_resolver = state.borrow_mut::<NpmResolverRc>();
+ Ok(npm_resolver.get_npm_process_state())
+}
+
 deno_core::extension!(deno_node,
  deps = [ deno_io, deno_fs ],
  parameters = [P: NodePermissions],
@@ -254,6 +272,7 @@ deno_core::extension!(deno_node,
  op_node_build_os,
  op_is_any_arraybuffer,
  op_node_is_promise_rejected,
+ op_npm_process_state,
  ops::require::op_require_init_paths,
  ops::require::op_require_node_module_paths<P>,
  ops::require::op_require_proxy_path,

runtime/web_worker.rs

@@ -464,7 +464,6 @@ impl WebWorker {
  options.fs,
  ),
  // Runtime ops that are always initialized for WebWorkers
- ops::web_worker::deno_web_worker::init_ops_and_esm(),
  ops::runtime::deno_runtime::init_ops_and_esm(main_module.clone()),
  ops::worker_host::deno_worker_host::init_ops_and_esm(
  options.create_web_worker_cb.clone(),
@@ -482,6 +481,7 @@ impl WebWorker {
  enable_testing_features,
  ),
  runtime::init_ops_and_esm(),
+ ops::web_worker::deno_web_worker::init_ops_and_esm(),
  ];
 
  for extension in &mut extensions {

runtime/worker.rs

@@ -94,6 +94,9 @@ pub struct WorkerOptions {
  /// V8 snapshot that should be loaded on startup.
  pub startup_snapshot: Option<Snapshot>,
 
+ /// Should op registration be skipped?
+ pub skip_op_registration: bool,
+
  /// Optional isolate creation parameters, such as heap limits.
  pub create_params: Option<v8::CreateParams>,
 
@@ -160,6 +163,7 @@ impl Default for WorkerOptions {
  }),
  fs: Arc::new(deno_fs::RealFs),
  module_loader: Rc::new(FsModuleLoader),
+ skip_op_registration: false,
  seed: None,
  unsafely_ignore_certificate_errors: Default::default(),
  should_break_on_first_statement: Default::default(),
@@ -419,6 +423,7 @@ impl MainWorker {
  .or_else(crate::js::deno_isolate_init),
  create_params: options.create_params,
  source_map_getter: options.source_map_getter,
+ skip_op_registration: options.skip_op_registration,
  get_error_class_fn: options.get_error_class_fn,
  shared_array_buffer_store: options.shared_array_buffer_store.clone(),
  compiled_wasm_module_store: options.compiled_wasm_module_store.clone(),