no more time threads

Author: fraidev

libs/core/runtime/jsruntime.rs

@@ -436,8 +436,10 @@ pub struct JsRuntimeState {
   pub(crate) function_templates: Rc<RefCell<FunctionTemplateData>>,
   pub(crate) callsite_prototype: RefCell<Option<v8::Global<v8::Object>>>,
   waker: Arc<AtomicWaker>,
-  /// Guards the 100ms safety-net timer so at most one is active at a time.
-  safety_net_active: Arc<std::sync::atomic::AtomicBool>,
+  /// Level-triggered flag set by the custom V8 platform when a foreground
+  /// task is posted. Checked and cleared each poll to ensure pumping even
+  /// if the edge-triggered AtomicWaker notification was lost.
+  has_foreground_task: Arc<std::sync::atomic::AtomicBool>,
   /// Accessed through [`JsRuntimeState::with_inspector`].
   inspector: RefCell<Option<Rc<JsRuntimeInspector>>>,
   has_inspector: Cell<bool>,
@@ -743,6 +745,8 @@ impl JsRuntime {
     // ...now let's set up ` JsRuntimeState`, we'll need to set some fields
     // later, after `JsRuntime` is all set up...
     let waker = op_state.waker.clone();
+    let has_foreground_task =
+      Arc::new(std::sync::atomic::AtomicBool::new(false));
     let op_state = Rc::new(RefCell::new(op_state));
     let (eval_context_get_code_cache_cb, eval_context_set_code_cache_cb) =
       options
@@ -765,7 +769,7 @@ impl JsRuntime {
         eval_context_set_code_cache_cb,
       ),
       waker: waker.clone(),
-      safety_net_active: Arc::new(std::sync::atomic::AtomicBool::new(false)),
+      has_foreground_task: has_foreground_task.clone(),
       // Some fields are initialized later after isolate is created
       inspector: None.into(),
       has_inspector: false.into(),
@@ -847,6 +851,7 @@ impl JsRuntime {
     setup::register_isolate_waker(
       setup::isolate_ptr_to_key(isolate_ptr),
       waker.clone(),
+      has_foreground_task,
     );
 
     // ...isolate is fully set up, we can forward its pointer to the ops to finish
@@ -2108,7 +2113,14 @@ impl JsRuntime {
     if has_inspector {
       self.inspector().poll_sessions_from_event_loop(cx);
     }
-    if poll_options.pump_v8_message_loop {
+    // Clear the foreground-task flag (set by the custom V8 platform callback).
+    // If it was set, we must pump the message loop regardless of other state.
+    let had_foreground_task = self
+      .inner
+      .state
+      .has_foreground_task
+      .swap(false, std::sync::atomic::Ordering::Relaxed);
+    if poll_options.pump_v8_message_loop || had_foreground_task {
       self.pump_v8_message_loop(scope)?;
     }
 
@@ -2265,27 +2277,6 @@ impl JsRuntime {
       scope.perform_microtask_checkpoint();
     }
 
-    // Safety net: if V8 has pending background tasks (e.g. module compilation),
-    // schedule a delayed wake to pump the message loop in case the platform
-    // callback was missed due to a race condition. Uses an OS thread (not
-    // tokio) to avoid depending on the async runtime being cooperative.
-    // The AtomicBool guard ensures at most one safety-net timer is active.
-    if pending_state.has_pending_background_tasks
-      && !self
-        .inner
-        .state
-        .safety_net_active
-        .swap(true, std::sync::atomic::Ordering::Relaxed)
-    {
-      let waker = cx.waker().clone();
-      let flag = self.inner.state.safety_net_active.clone();
-      std::thread::spawn(move || {
-        std::thread::sleep(std::time::Duration::from_millis(100));
-        flag.store(false, std::sync::atomic::Ordering::Relaxed);
-        waker.wake_by_ref();
-      });
-    }
-
     // Re-wake logic for next iteration
     #[allow(clippy::suspicious_else_formatting, clippy::if_same_then_else)]
     {

libs/core/runtime/setup.rs

@@ -32,51 +32,69 @@ pub(crate) fn isolate_ptr_to_key(ptr: v8::UnsafeRawIsolatePtr) -> usize {
   unsafe { std::mem::transmute::<v8::UnsafeRawIsolatePtr, usize>(ptr) }
 }
 
-/// Global registry mapping isolate pointers to their event loop wakers.
-/// When V8 posts a foreground task for an isolate, the callback looks up
-/// the waker here and wakes the event loop. Isolates that received a
-/// notification before their waker was registered are tracked in
-/// `pending_wakes` so `register_isolate_waker` can wake them immediately.
+/// Per-isolate waker state: an `AtomicWaker` for edge-triggered wakeups
+/// and an `AtomicBool` flag for level-triggered detection.
+///
+/// The `AtomicWaker` can lose wakes if `wake()` is called while the stored
+/// waker was already consumed (e.g. by the re-wake logic in the poll loop).
+/// The `AtomicBool` flag ensures the poll loop always sees that a foreground
+/// task was posted, even if the waker-based notification was lost.
+struct IsolateWakerEntry {
+  waker: std::sync::Arc<AtomicWaker>,
+  has_foreground_task: std::sync::Arc<AtomicBool>,
+}
+
+/// Global registry mapping isolate pointers to their waker state.
 struct IsolateWakerRegistry {
-  wakers: HashMap<usize, std::sync::Arc<AtomicWaker>>,
+  entries: HashMap<usize, IsolateWakerEntry>,
   pending_wakes: std::collections::HashSet<usize>,
 }
 
 static ISOLATE_WAKERS: std::sync::LazyLock<Mutex<IsolateWakerRegistry>> =
   std::sync::LazyLock::new(|| {
     Mutex::new(IsolateWakerRegistry {
-      wakers: HashMap::new(),
+      entries: HashMap::new(),
       pending_wakes: std::collections::HashSet::new(),
     })
   });
 
-/// Register a waker for an isolate so foreground task notifications
-/// wake the correct event loop. If a notification arrived before
-/// registration, the waker is triggered immediately.
+/// Register a waker and foreground-task flag for an isolate.
+/// If a notification arrived before registration, the flag is set
+/// and the waker is triggered immediately.
 pub fn register_isolate_waker(
   isolate_ptr: usize,
   waker: std::sync::Arc<AtomicWaker>,
+  has_foreground_task: std::sync::Arc<AtomicBool>,
 ) {
   let mut reg = ISOLATE_WAKERS.lock().unwrap();
   if reg.pending_wakes.remove(&isolate_ptr) {
+    has_foreground_task.store(true, Ordering::Relaxed);
     waker.wake();
   }
-  reg.wakers.insert(isolate_ptr, waker);
+  reg.entries.insert(
+    isolate_ptr,
+    IsolateWakerEntry {
+      waker,
+      has_foreground_task,
+    },
+  );
 }
 
-/// Unregister an isolate's waker (called on isolate drop).
+/// Unregister an isolate's waker state (called on isolate drop).
 pub fn unregister_isolate_waker(isolate_ptr: usize) {
   let mut reg = ISOLATE_WAKERS.lock().unwrap();
-  reg.wakers.remove(&isolate_ptr);
+  reg.entries.remove(&isolate_ptr);
   reg.pending_wakes.remove(&isolate_ptr);
 }
 
-/// Wake the event loop for a given isolate. If the isolate's waker
-/// is not yet registered, marks it as pending so registration wakes it.
+/// Notify that a foreground task was posted for the given isolate.
+/// Sets the level-triggered flag and wakes the event loop.
+/// If the isolate's state is not yet registered, marks it as pending.
 fn wake_isolate(key: usize) {
   let mut reg = ISOLATE_WAKERS.lock().unwrap();
-  if let Some(waker) = reg.wakers.get(&key) {
-    waker.wake();
+  if let Some(entry) = reg.entries.get(&key) {
+    entry.has_foreground_task.store(true, Ordering::Relaxed);
+    entry.waker.wake();
   } else {
     reg.pending_wakes.insert(key);
   }