feat: upgrade V8 to 136

Author: devsnek

Cargo.lock

@@ -29,7 +29,7 @@ deno_ast = { version = "=0.45.1", features = ["transpiling"] }
 deno_core_icudata = "0.74.0"
 deno_error = { version = "0.5.6", features = ["serde_json", "serde", "url", "tokio"] }
 deno_unsync = "0.4.2"
-v8 = { version = "135.1.0", default-features = false }
+v8 = { version = "136.0.0", default-features = false }
 
 anyhow = "1"
 bencher = "0.1"

Cargo.toml

@@ -150,7 +150,6 @@ pub(crate) struct InnerIsolateState {
   main_realm: ManuallyDrop<JsRealm>,
   pub(crate) state: ManuallyDropRc<JsRuntimeState>,
   v8_isolate: ManuallyDrop<v8::OwnedIsolate>,
-  v8_cpp_heap: ManuallyDrop<v8::UniqueRef<v8::cppgc::Heap>>,
 }
 
 impl InnerIsolateState {
@@ -187,23 +186,13 @@ impl InnerIsolateState {
     debug_assert_eq!(Rc::strong_count(&self.state), 1);
   }
 
-  pub fn cleanup_cpp_heap(&mut self) {
-    self.v8_isolate.detach_cpp_heap();
-    self.v8_cpp_heap.terminate();
-    unsafe {
-      ManuallyDrop::drop(&mut self.v8_cpp_heap);
-    }
-  }
-
   pub fn prepare_for_snapshot(mut self) -> v8::OwnedIsolate {
     self.cleanup();
 
     // SAFETY: We're copying out of self and then immediately forgetting self
     unsafe {
       ManuallyDrop::drop(&mut self.state.0);
 
-      self.cleanup_cpp_heap();
-
       let isolate = ManuallyDrop::take(&mut self.v8_isolate);
 
       std::mem::forget(self);
@@ -220,8 +209,6 @@ impl Drop for InnerIsolateState {
     unsafe {
       ManuallyDrop::drop(&mut self.state.0);
 
-      self.cleanup_cpp_heap();
-
       if self.will_snapshot {
         // Create the snapshot and just drop it.
         #[allow(clippy::print_stderr)]
@@ -953,8 +940,6 @@ impl JsRuntime {
       maybe_startup_snapshot,
       external_refs_static,
     );
-    let mut cpp_heap = setup::create_cpp_heap();
-    isolate.attach_cpp_heap(&mut cpp_heap);
 
     if state_rc.import_assertions_support.has_warning() {
       isolate.add_message_listener_with_error_level(
@@ -1166,7 +1151,6 @@ impl JsRuntime {
         main_realm: ManuallyDrop::new(main_realm),
         state: ManuallyDropRc(ManuallyDrop::new(state_rc)),
         v8_isolate: ManuallyDrop::new(isolate),
-        v8_cpp_heap: ManuallyDrop::new(cpp_heap),
       },
       allocations: isolate_allocations,
       files_loaded_from_fs_during_snapshot: vec![],

core/runtime/jsruntime.rs

@@ -80,8 +80,6 @@ fn v8_init(
   });
   v8::V8::initialize_platform(v8_platform.clone());
   v8::V8::initialize();
-
-  v8::cppgc::initialize_process(v8_platform);
 }
 
 pub fn init_v8(
@@ -114,13 +112,6 @@ pub fn init_v8(
   });
 }
 
-pub fn create_cpp_heap() -> v8::UniqueRef<v8::cppgc::Heap> {
-  v8::cppgc::Heap::create(
-    v8::V8::get_current_platform(),
-    v8::cppgc::HeapCreateParams::default(),
-  )
-}
-
 pub fn create_isolate(
   will_snapshot: bool,
   maybe_create_params: Option<v8::CreateParams>,

core/runtime/setup.rs

@@ -310,6 +310,7 @@ fn duplicate_op_names() {
     }
   }
 
+  #[allow(clippy::unnecessary_wraps)]
   #[op2]
   #[string]
   pub fn op_test() -> Result<String, JsErrorBox> {
@@ -332,6 +333,7 @@ fn ops_in_js_have_proper_names() {
     Ok(String::from("Test"))
   }
 
+  #[allow(clippy::unnecessary_wraps)]
   #[op2(async)]
   #[string]
   async fn op_test_async() -> Result<String, JsErrorBox> {

core/runtime/tests/ops.rs

@@ -49,35 +49,35 @@ fn main() -> Result<(), Error> {
 
   init_v8_flags(&v8_flags);
 
-  let (metrics_summary, mut js_runtime) = if matches.get_flag("strace-ops")
-    || matches.get_flag("strace-ops-summary")
-  {
-    let (summary, op_metrics_factory_fn) = create_metrics(
-      matches.get_flag("strace-ops"),
-      matches.get_flag("strace-ops-summary"),
-    );
-    (
-      Some(summary),
-      deno_core_testing::create_runtime_from_snapshot_with_options(
-        SNAPSHOT,
-        inspector_server.is_some(),
-        vec![],
-        RuntimeOptions {
-          op_metrics_factory_fn: Some(op_metrics_factory_fn),
-          ..Default::default()
-        },
-      ),
-    )
-  } else {
-    (
-      None,
-      create_runtime_from_snapshot(
+  let (metrics_summary, mut js_runtime, _worker_host_side) =
+    if matches.get_flag("strace-ops") || matches.get_flag("strace-ops-summary")
+    {
+      let (summary, op_metrics_factory_fn) = create_metrics(
+        matches.get_flag("strace-ops"),
+        matches.get_flag("strace-ops-summary"),
+      );
+
+      let (runtime, worker_host_side) =
+        deno_core_testing::create_runtime_from_snapshot_with_options(
+          SNAPSHOT,
+          inspector_server.is_some(),
+          None,
+          vec![],
+          RuntimeOptions {
+            op_metrics_factory_fn: Some(op_metrics_factory_fn),
+            ..Default::default()
+          },
+        );
+      (Some(summary), runtime, worker_host_side)
+    } else {
+      let (runtime, worker_host_side) = create_runtime_from_snapshot(
         SNAPSHOT,
         inspector_server.is_some(),
+        None,
         vec![],
-      ),
-    )
-  };
+      );
+      (None, runtime, worker_host_side)
+    };
 
   let runtime = tokio::runtime::Builder::new_current_thread()
     .enable_all()
@@ -96,7 +96,7 @@ fn main() -> Result<(), Error> {
     );
   }
 
-  let future = async move {
+  let future = async {
     let mod_id = js_runtime.load_main_es_module(&main_module).await?;
     let result = js_runtime.mod_evaluate(mod_id);
     js_runtime.run_event_loop(Default::default()).await?;

dcore/src/main.rs

@@ -22,7 +22,6 @@ use std::future::Future;
 use std::rc::Rc;
 use std::sync::Arc;
 use std::sync::Mutex;
-use std::sync::OnceLock;
 use std::sync::mpsc::RecvTimeoutError;
 use std::sync::mpsc::channel;
 use std::time::Duration;
@@ -93,40 +92,32 @@ impl TestData {
   }
 }
 
-pub fn create_runtime(
-  parent: Option<WorkerCloseWatcher>,
-  additional_extensions: Vec<Extension>,
-) -> (JsRuntime, WorkerHostSide) {
-  let (worker, worker_host_side) = worker_create(parent);
-
-  static SNAPSHOT: OnceLock<Box<[u8]>> = OnceLock::new();
-
-  let snapshot = SNAPSHOT.get_or_init(snapshot::create_snapshot);
-
-  let runtime =
-    create_runtime_from_snapshot(snapshot, false, additional_extensions);
-  runtime.op_state().borrow_mut().put(worker);
-  (runtime, worker_host_side)
-}
-
 pub fn create_runtime_from_snapshot(
   snapshot: &'static [u8],
   inspector: bool,
+  parent: Option<WorkerCloseWatcher>,
   additional_extensions: Vec<Extension>,
-) -> JsRuntime {
+) -> (JsRuntime, WorkerHostSide) {
   create_runtime_from_snapshot_with_options(
     snapshot,
     inspector,
+    parent,
     additional_extensions,
     RuntimeOptions::default(),
   )
 }
+
+pub struct Snapshot(&'static [u8]);
+
 pub fn create_runtime_from_snapshot_with_options(
   snapshot: &'static [u8],
   inspector: bool,
+  parent: Option<WorkerCloseWatcher>,
   additional_extensions: Vec<Extension>,
   options: RuntimeOptions,
-) -> JsRuntime {
+) -> (JsRuntime, WorkerHostSide) {
+  let (worker, worker_host_side) = worker_create(parent);
+
   let mut extensions = vec![extensions::checkin_runtime::init_ops::<()>()];
   extensions.extend(additional_extensions);
   let module_loader =
@@ -147,8 +138,10 @@ pub fn create_runtime_from_snapshot_with_options(
 
   let stats = runtime.runtime_activity_stats_factory();
   runtime.op_state().borrow_mut().put(stats);
-  runtime.op_state().borrow_mut().put(Output::default());
-  runtime
+  runtime.op_state().borrow_mut().put(worker);
+  runtime.op_state().borrow_mut().put(Snapshot(snapshot));
+
+  (runtime, worker_host_side)
 }
 
 fn run_async(f: impl Future<Output = Result<(), anyhow::Error>>) {

testing/checkin/runner/mod.rs

@@ -1,7 +1,8 @@
 // Copyright 2018-2025 the Deno authors. MIT license.
 
 use super::Output;
-use super::create_runtime;
+use super::Snapshot;
+use super::create_runtime_from_snapshot;
 use super::run_async;
 use anyhow::anyhow;
 use deno_core::GarbageCollected;
@@ -25,6 +26,7 @@ use tokio::sync::mpsc::unbounded_channel;
 use tokio::sync::watch;
 
 /// Our cppgc object.
+#[derive(Debug)]
 pub struct WorkerControl {
   worker_channel: WorkerChannel,
   close_watcher: WorkerCloseWatcher,
@@ -34,16 +36,18 @@ pub struct WorkerControl {
 
 impl GarbageCollected for WorkerControl {}
 
+#[derive(Debug)]
 pub struct WorkerChannel {
   tx: UnboundedSender<String>,
   rx: Mutex<UnboundedReceiver<String>>,
 }
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct WorkerCloseWatcher {
   watcher: Arc<Mutex<watch::Receiver<bool>>>,
 }
 
+#[derive(Debug)]
 pub struct Worker {
   _close_send: watch::Sender<bool>,
   pub(crate) close_watcher: WorkerCloseWatcher,
@@ -92,16 +96,22 @@ pub fn worker_create(
 pub fn op_worker_spawn(
   #[state] this_worker: &Worker,
   #[state] output: &Output,
+  #[state] snapshot: &Snapshot,
   #[string] base_url: String,
   #[string] main_script: String,
 ) -> Result<WorkerControl, std::sync::mpsc::RecvError> {
   let output = output.clone();
+  let snapshot = snapshot.0;
   let close_watcher = this_worker.close_watcher.clone();
   let (init_send, init_recv) = channel();
   let (shutdown_tx, shutdown_rx) = unbounded_channel();
   std::thread::spawn(move || {
-    let (mut runtime, worker_host_side) =
-      create_runtime(Some(close_watcher), vec![]);
+    let (mut runtime, worker_host_side) = create_runtime_from_snapshot(
+      snapshot,
+      false,
+      Some(close_watcher),
+      vec![],
+    );
     runtime.op_state().borrow_mut().put(output.clone());
     init_send
       .send(WorkerControl {
@@ -147,11 +157,21 @@ async fn run_worker_task(
     let state = state.borrow();
     let output: &Output = state.borrow();
     for line in e.to_string().split('\n') {
+      println!("[ERR] {line}");
+      output.line(format!("[ERR] {line}"));
+    }
+    return Ok(());
+  } else if let Err(e) = f.await {
+    let state = runtime.op_state().clone();
+    let state = state.borrow();
+    let output: &Output = state.borrow();
+    for line in e.to_string().split('\n') {
+      println!("[ERR] {line}");
       output.line(format!("[ERR] {line}"));
     }
     return Ok(());
   }
-  _ = f.await;
+
   Ok(())
 }