mini_racer_rs 1.0.0

data/crates/mini_racer_engine/src/process/watchdog.rs

@@ -0,0 +1,185 @@
+use std::cmp::{Ordering, Reverse};
+use std::collections::BinaryHeap;
+use std::sync::{Arc, Condvar, Mutex, Weak};
+use std::time::{Duration, Instant};
+
+use mini_racer_sync::{DispatchId, Interrupt, lock, wait, wait_timeout};
+
+use crate::EngineError;
+use crate::control::ControlBlock;
+
+struct Entry {
+    at: Instant,
+    seq: u64,
+    block: Weak<ControlBlock>,
+}
+
+impl PartialEq for Entry {
+    fn eq(&self, other: &Self) -> bool {
+        (self.at, self.seq) == (other.at, other.seq)
+    }
+}
+
+impl Eq for Entry {}
+
+impl PartialOrd for Entry {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Entry {
+    fn cmp(&self, other: &Self) -> Ordering {
+        (self.at, self.seq).cmp(&(other.at, other.seq))
+    }
+}
+
+#[derive(Default)]
+struct Timers {
+    heap: BinaryHeap<Reverse<Entry>>,
+    seq: u64,
+}
+
+pub struct Watchdog {
+    timers: Mutex<Timers>,
+    changed: Condvar,
+}
+
+impl Watchdog {
+    fn push(&self, at: Instant, block: Weak<ControlBlock>) {
+        let mut timers = lock(&self.timers);
+        timers.seq = timers.seq.wrapping_add(1);
+        let seq = timers.seq;
+        timers.heap.push(Reverse(Entry { at, seq, block }));
+        drop(timers);
+        self.changed.notify_one();
+    }
+}
+
+// One thread per process serves every context's timeouts. It is kept per
+// fork generation: a forked child has the parent's watchdog state but not its
+// thread, and a runner of the parent may have held its lock at the fork.
+fn current() -> Result<Arc<Watchdog>, EngineError> {
+    let mut slot = lock(super::fork::current().watchdog());
+    if let Some(watchdog) = slot.as_ref() {
+        return Ok(Arc::clone(watchdog));
+    }
+    let watchdog = Arc::new(Watchdog {
+        timers: Mutex::default(),
+        changed: Condvar::new(),
+    });
+    let serving = Arc::clone(&watchdog);
+    std::thread::Builder::new()
+        .name("mini_racer_rs watchdog".to_owned())
+        .spawn(move || run(&serving))
+        .map_err(|e| EngineError::Internal(format!("cannot start the timeout watchdog: {e}")))?;
+    *slot = Some(Arc::clone(&watchdog));
+    drop(slot);
+    Ok(watchdog)
+}
+
+/// Arms `dispatch`'s timeout. Fails rather than let a timed script run
+/// unbounded when the watchdog cannot start.
+// A context's timer slot holds its current deadline; a heap entry only wakes
+// the watchdog to look at the slot, so a context needs a new entry only when
+// its deadline moves earlier.
+pub fn schedule(
+    after: Duration,
+    block: &Arc<ControlBlock>,
+    dispatch: DispatchId,
+) -> Result<(), EngineError> {
+    let watchdog = current()?;
+    let at = Instant::now()
+        .checked_add(after)
+        .ok_or_else(|| EngineError::Internal("timeout out of range".to_owned()))?;
+    let mut timer = lock(&block.timer);
+    timer.due = Some((at, dispatch));
+    let wake = timer.queued.is_none_or(|queued| at < queued);
+    if wake {
+        timer.queued = Some(at);
+    }
+    drop(timer);
+    // A wake entry the watchdog no longer needs is harmless: it rereads the slot.
+    if wake {
+        watchdog.push(at, Arc::downgrade(block));
+    }
+    Ok(())
+}
+
+/// Bounds work `dispatch` does after its timeout fired with the timeout again.
+/// A deadline that has not fired yet already bounds it.
+pub fn rearm_if_fired(
+    after: Duration,
+    block: &Arc<ControlBlock>,
+    dispatch: DispatchId,
+) -> Result<(), EngineError> {
+    let pending = lock(&block.timer)
+        .due
+        .is_some_and(|(_, due)| due == dispatch);
+    if pending {
+        return Ok(());
+    }
+    schedule(after, block, dispatch)
+}
+
+/// Forgets the context's pending timeout once its dispatch is over.
+pub fn clear(block: &ControlBlock, dispatch: DispatchId) {
+    let mut timer = lock(&block.timer);
+    if timer.due.is_some_and(|(_, due)| due == dispatch) {
+        timer.due = None;
+    }
+}
+
+fn run(watchdog: &Watchdog) {
+    loop {
+        let mut timers = lock(&watchdog.timers);
+        let now = Instant::now();
+        match timers.heap.peek().map(|Reverse(entry)| entry.at) {
+            None => drop(wait(&watchdog.changed, timers)),
+            Some(at) if at > now => {
+                drop(wait_timeout(
+                    &watchdog.changed,
+                    timers,
+                    at.saturating_duration_since(now),
+                ));
+            }
+            Some(_) => {
+                let mut due = Vec::new();
+                while timers
+                    .heap
+                    .peek()
+                    .is_some_and(|Reverse(entry)| entry.at <= now)
+                {
+                    if let Some(Reverse(entry)) = timers.heap.pop() {
+                        due.push(entry.block);
+                    }
+                }
+                // Lock order: the heap is released before any context's timer
+                // or termination cell is taken.
+                drop(timers);
+                for block in due.iter().filter_map(Weak::upgrade) {
+                    fire(watchdog, &block, now);
+                }
+            }
+        }
+    }
+}
+
+fn fire(watchdog: &Watchdog, block: &Arc<ControlBlock>, now: Instant) {
+    let mut timer = lock(&block.timer);
+    timer.queued = None;
+    let due = timer.due;
+    match due {
+        Some((at, _)) if at <= now => timer.due = None,
+        Some((at, _)) => timer.queued = Some(at),
+        None => {}
+    }
+    drop(timer);
+    match due {
+        Some((at, dispatch)) if at <= now => {
+            block.term.request(Interrupt::Timeout(dispatch));
+        }
+        Some((at, _)) => watchdog.push(at, Arc::downgrade(block)),
+        None => {}
+    }
+}

data/crates/mini_racer_engine/src/process/workers.rs

@@ -0,0 +1,165 @@
+use std::sync::{Once, OnceLock};
+use std::time::Duration;
+
+use mini_racer_sync::WorkerQueue;
+
+use crate::process::platform::{self, Mode};
+use crate::sys::WorkerTask;
+
+// V8 and rusty_v8 hold a platform's pool to this many threads.
+const MOST_THREADS: usize = 16;
+// V8's own workers get the system's default thread stack, 8 MiB on Linux.
+const MIN_STACK_BYTES: usize = 8 << 20;
+const STACK_HEADROOM_BYTES: usize = 1 << 20;
+
+#[derive(Clone, Copy)]
+struct Size {
+    threads: usize,
+    stack_bytes: usize,
+}
+
+// Set before V8 initializes, so V8 sizes its jobs by this pool from the start,
+// and read without the flags lock, which a fork may leave held.
+static SIZE: OnceLock<Size> = OnceLock::new();
+
+/// Sizes every process's pool as V8 would have sized its own for the
+/// platform mode: what `rusty_v8` makes of a request for the default, or the
+/// one thread the single-threaded platform keeps.
+pub fn configure() {
+    let threads = match platform::mode() {
+        Mode::SingleThreaded => 1,
+        Mode::MultiThreaded => crate::sys::processors_online().clamp(1, MOST_THREADS),
+    };
+    // V8 lets a task on a worker thread use `--stack_size` of its stack, as it
+    // lets a runner.
+    let stack_bytes = platform::stack_size_kb().map_or(MIN_STACK_BYTES, |kb| {
+        kb.saturating_mul(1024)
+            .saturating_add(STACK_HEADROOM_BYTES)
+            .max(MIN_STACK_BYTES)
+    });
+    let _ = SIZE.set(Size {
+        threads,
+        stack_bytes,
+    });
+}
+
+/// How many worker threads a process runs, which V8 reads as its platform's.
+pub fn threads() -> usize {
+    SIZE.get().map_or(1, |size| size.threads)
+}
+
+/// Where V8's worker tasks go: the current process's pool. A child never
+/// posts to its parent's, whose threads it does not have.
+pub fn post(task: WorkerTask, delay: Duration) {
+    super::fork::current().workers().post(task, delay);
+}
+
+/// One process's worker threads, started at its first worker task.
+pub struct Workers {
+    queue: WorkerQueue<WorkerTask>,
+    started: Once,
+}
+
+impl Default for Workers {
+    fn default() -> Self {
+        Self {
+            queue: WorkerQueue::default(),
+            started: Once::new(),
+        }
+    }
+}
+
+impl Workers {
+    fn post(&'static self, task: WorkerTask, delay: Duration) {
+        self.queue.post(task, delay);
+        self.started.call_once(|| self.start());
+    }
+
+    fn start(&'static self) {
+        let Some(&Size {
+            threads,
+            stack_bytes,
+        }) = SIZE.get()
+        else {
+            return;
+        };
+        for _ in 0..threads {
+            let spawned = std::thread::Builder::new()
+                .name("mini_racer_rs worker".to_owned())
+                .stack_size(stack_bytes)
+                .spawn(move || {
+                    loop {
+                        self.queue.run_next(WorkerTask::run);
+                    }
+                });
+            if spawned.is_err() {
+                break;
+            }
+        }
+    }
+
+    /// Starts no task until `resume`, and waits up to `bound` for the
+    /// running ones to end. Returns whether none is running.
+    pub fn pause(&self, bound: Duration) -> bool {
+        self.queue.pause(bound)
+    }
+
+    pub fn resume(&self) {
+        self.queue.resume();
+    }
+}
+
+/// Taken by every test that fills or times the process's pool, so tests
+/// sharing a process take turns with it.
+#[cfg(test)]
+pub static TESTS: std::sync::Mutex<()> = std::sync::Mutex::new(());
+
+#[cfg(test)]
+mod tests {
+    use std::sync::mpsc;
+    use std::sync::{Arc, Barrier};
+    use std::time::Duration;
+
+    use super::Workers;
+    use crate::sys::testing::worker_task;
+
+    // A pause waits for the task running, holds a task posted meanwhile, and
+    // the resume lets it run.
+    #[test]
+    fn a_pause_waits_for_the_running_task_and_holds_new_ones_until_resumed() {
+        crate::process::ensure_initialized();
+        let workers: &'static Workers = Box::leak(Box::default());
+        let started = Arc::new(Barrier::new(2));
+        let release = Arc::new(Barrier::new(2));
+        let (ran, order) = mpsc::channel();
+        {
+            let (started, release, ran) = (Arc::clone(&started), Arc::clone(&release), ran.clone());
+            workers.post(
+                worker_task(Box::new(move || {
+                    started.wait();
+                    release.wait();
+                    std::thread::sleep(Duration::from_millis(20));
+                    ran.send("running").expect("receiver");
+                })),
+                Duration::ZERO,
+            );
+        }
+        started.wait();
+        let pausing = std::thread::spawn(|| workers.pause(Duration::from_secs(10)));
+        std::thread::sleep(Duration::from_millis(30));
+        assert!(!pausing.is_finished());
+        workers.post(
+            worker_task(Box::new(move || ran.send("posted").expect("receiver"))),
+            Duration::ZERO,
+        );
+        release.wait();
+        assert!(pausing.join().expect("pause"));
+        assert_eq!(order.try_recv(), Ok("running"));
+        assert_eq!(
+            order.recv_timeout(Duration::from_millis(50)),
+            Err(mpsc::RecvTimeoutError::Timeout)
+        );
+        workers.resume();
+        assert_eq!(order.recv_timeout(Duration::from_secs(10)), Ok("posted"));
+    }
+}

data/crates/mini_racer_engine/src/process.rs

@@ -0,0 +1,69 @@
+pub mod code_cache;
+pub mod fork;
+pub mod platform;
+pub(crate) mod tasks;
+pub(crate) mod watchdog;
+pub(crate) mod workers;
+
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Once, OnceLock};
+
+static INIT: Once = Once::new();
+// The platform points into it for the life of the process.
+static PLATFORM_VTABLE: OnceLock<Box<crate::sys::PlatformVtable>> = OnceLock::new();
+static NEXT_THREAD: AtomicU64 = AtomicU64::new(1);
+
+thread_local! {
+    static THREAD: u64 = NEXT_THREAD.fetch_add(1, Ordering::Relaxed);
+}
+
+/// Names the calling thread for the life of the process; never 0.
+#[must_use]
+pub fn thread_token() -> u64 {
+    THREAD.with(|token| *token)
+}
+
+pub fn ensure_initialized() {
+    INIT.call_once(|| {
+        let _ = v8::icu::set_common_data_78(deno_core_icudata::ICU_DATA);
+        for flag in platform::freeze() {
+            v8::V8::set_flags_from_string(&flag);
+        }
+        workers::configure();
+        // Unprotected: on PKU-capable CPUs the protected platform requires every
+        // V8 thread to descend from the initializing thread, which Ruby threads
+        // and per-context runners do not.
+        // Worker tasks go to `workers`, whose threads each process starts for
+        // itself, as threads do not survive a fork. V8's own pool keeps the one
+        // thread rusty_v8 cannot go below, idle for good.
+        let mut platform = v8::new_custom_platform(1, false, true, tasks::Foreground);
+        let vtable = PLATFORM_VTABLE.get_or_init(|| crate::sys::worker_vtable(&platform));
+        crate::sys::use_vtable(&mut platform, vtable);
+        v8::V8::initialize_platform(platform.make_shared());
+        v8::V8::initialize();
+        crate::sys::register_fork_handlers();
+    });
+}
+
+/// Whether evals in the shapes `ExecJS` and react-rails send once per call run a
+/// template compiled once per context: `MINI_RACER_RS_FAST_CALLS=off` turns
+/// that off. First read on a Ruby thread, by `ContextHandle::spawn`, where
+/// nothing in Ruby can be changing the environment at the same time.
+pub(crate) fn fast_calls() -> bool {
+    static ENABLED: OnceLock<bool> = OnceLock::new();
+    *ENABLED.get_or_init(|| {
+        std::env::var_os("MINI_RACER_RS_FAST_CALLS").is_none_or(|value| value != "off")
+    })
+}
+
+/// Tasks V8 posted for an isolate no runner had registered, dropped unrun.
+/// Snapshot builds post some; a context's isolate should never get one.
+#[must_use]
+pub fn unserved_tasks() -> u64 {
+    tasks::unserved()
+}
+
+#[must_use]
+pub fn v8_version() -> &'static str {
+    v8::V8::get_version()
+}