mini_racer_rs 1.0.2 → 1.0.4

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

@@ -9,6 +9,7 @@ use crate::process::code_cache::Key;
 const MAX_SOURCES: usize = 8;
 const MAX_BYTES: usize = 256 << 20;
 const MAX_REFUSED: usize = 8;
+const MAX_SWEPT: usize = 8;
 
 /// A large script's source as V8 stores a string of it: a byte a unit when
 /// every unit fits Latin-1, two otherwise. Never changed once made.
@@ -63,8 +64,9 @@ impl Units {
 
 /// One copy of each large script's source, outside every V8 heap.
 ///
-/// A script is kept once the process has seen it before, and every context
-/// compiling it then reads the kept copy in place of one on its own heap.
+/// A script is kept by the first context to compile it, and every context
+/// compiling it, that one included, reads the kept copy in place of one on
+/// its own heap.
 /// Each string V8 makes from one holds a reference to it, which V8 hands back
 /// when the string dies (`sys::external_string`). A source is dropped only
 /// when no string holds one, so V8 never releases the last reference itself.
@@ -72,6 +74,8 @@ pub struct Sources {
     list: Mutex<List>,
     // How many sources, and how many bytes of them, may be kept and read.
     bounds: (usize, usize),
+    // The number the next context's reads are told apart by.
+    next_reader: AtomicU64,
     made: AtomicU64,
     reads: AtomicU64,
     conversions: AtomicU64,
@@ -91,6 +95,9 @@ struct List {
     // left or, as invalid UTF-8, unbounded, so that while it is among the last
     // `MAX_REFUSED` refused it is not converted again without room for it.
     refused: Vec<(Key, usize)>,
+    // The last `MAX_SWEPT` sources swept, so one made again, which a second
+    // context has now read after all, is kept as such.
+    swept: Vec<Key>,
 }
 
 struct Kept {
@@ -99,23 +106,60 @@ struct Kept {
     // The references from this process's list and every ancestor's, which a
     // forked child never touches again; the strings reading it hold the rest.
     held: usize,
+    readers: Readers,
+}
+
+// The contexts that have read a kept source. One alone, as a script evaluated
+// once has, gains nothing from a copy no string reads any more; a source more
+// have read is likely to be read again, and an inherited one is only copied
+// again if a child drops it, so both stay until a new source needs the room.
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Readers {
+    One(u64),
+    Many,
 }
 
 impl Kept {
     fn unread(&self) -> bool {
         self.units.references() == self.held
     }
+
+    fn spent(&self) -> bool {
+        matches!(self.readers, Readers::One(_)) && self.unread()
+    }
 }
 
 impl List {
-    fn find(&mut self, key: &Key) -> Option<Units> {
+    fn find(&mut self, key: &Key, reader: u64) -> Option<Units> {
         let at = self.kept.iter().position(|kept| kept.key == *key)?;
-        let found = self.kept.remove(at);
+        let mut found = self.kept.remove(at);
+        if found.readers != Readers::One(reader) {
+            found.readers = Readers::Many;
+        }
         let units = found.units.clone();
         self.kept.push(found);
         Some(units)
     }
 
+    // V8's release of a string touches only the count, so a copy whose last
+    // string has gone waits for the next `Sources::units` call.
+    fn sweep(&mut self) -> Vec<Kept> {
+        let spent: Vec<Kept> = self.kept.extract_if(.., |kept| kept.spent()).collect();
+        for kept in &spent {
+            if self.swept.len() >= MAX_SWEPT {
+                self.swept.remove(0);
+            }
+            self.swept.push(kept.key.clone());
+        }
+        spent
+    }
+
+    fn unswept(&mut self, key: &Key) -> bool {
+        let before = self.swept.len();
+        self.swept.retain(|swept| swept != key);
+        self.swept.len() < before
+    }
+
     // Whether `bytes` more fit beside what strings still read, which nothing
     // can drop.
     fn room(&self, bytes: usize, (sources, most): (usize, usize)) -> bool {
@@ -161,30 +205,43 @@ impl Sources {
         Self {
             list: Mutex::default(),
             bounds: (sources, bytes),
+            next_reader: AtomicU64::new(0),
             made: AtomicU64::new(0),
             reads: AtomicU64::new(0),
             conversions: AtomicU64::new(0),
         }
     }
 
+    /// A number for a new context to read shared sources as, told apart from
+    /// every other context of this process.
+    pub(crate) fn reader(&self) -> u64 {
+        self.next_reader.fetch_add(1, Ordering::Relaxed)
+    }
+
     /// The shared source of the script `text` under `key`, kept from the first
-    /// context that asks for it. `None` leaves the context its own copy: the
-    /// source is invalid UTF-8, or too large for what is kept and still read.
-    /// Only a source that may fit is converted, outside the lock.
-    pub(crate) fn units(&self, key: &Key, text: &JsText) -> Option<Units> {
+    /// context that asks for it, for the context `reader`. `None` leaves the
+    /// context its own copy: the source is invalid UTF-8, or too large for
+    /// what is kept and still read. Only a source that may fit is converted,
+    /// outside the lock. Every call looks up the requested source, then drops
+    /// each other copy that no string reads and that one context alone ever
+    /// read.
+    pub(crate) fn units(&self, key: &Key, text: &JsText, reader: u64) -> Option<Units> {
         let mut list = lock(&self.list);
-        if let Some(units) = list.find(key) {
-            return Some(units);
-        }
-        if !list.room(list.least_bytes(key, text), self.bounds) {
-            return None;
-        }
+        // Found before the sweep, so a copy the context before this one left
+        // unread is read again, and kept, rather than copied again.
+        let found = list.find(key, reader);
+        let spent = list.sweep();
+        let room = found.is_none() && list.room(list.least_bytes(key, text), self.bounds);
         drop(list);
+        drop(spent);
+        if !room {
+            return found;
+        }
         self.conversions.fetch_add(1, Ordering::Relaxed);
         let units = Units::of(text);
         let mut list = lock(&self.list);
         // Made meanwhile by a context loading the same script.
-        if let Some(found) = list.find(key) {
+        if let Some(found) = list.find(key, reader) {
             return Some(found);
         }
         let bytes = units.as_ref().map_or(usize::MAX, Units::bytes);
@@ -211,13 +268,20 @@ impl Sources {
             };
             dropped.push(list.kept.remove(at));
         }
+        let readers = if list.unswept(key) {
+            Readers::Many
+        } else {
+            Readers::One(reader)
+        };
         list.kept.push(Kept {
             key: key.clone(),
             units: units.clone(),
             held: 1,
+            readers,
         });
         drop(list);
-        // Freed once the lock is released, as a large source takes a while.
+        // Freed once the lock is released, as a large source takes a while,
+        // like the spent copies above.
         drop(dropped);
         self.made.fetch_add(1, Ordering::Relaxed);
         Some(units)
@@ -242,9 +306,11 @@ impl Sources {
                         key: kept.key.clone(),
                         units: kept.units.clone(),
                         held: kept.held + 1,
+                        readers: Readers::Many,
                     })
                     .collect(),
                 refused: list.refused.clone(),
+                swept: list.swept.clone(),
             })
             .unwrap_or_default();
         Self {
@@ -291,16 +357,14 @@ mod tests {
     use crate::control::JsText;
     use crate::process::code_cache::{CodeCache, Key};
 
-    // A script's key once the code cache has seen it twice.
+    // A script's key, as its first sighting in a context sharing it has it.
     fn key(text: &JsText) -> Key {
         let cache: &'static CodeCache = Box::leak(Box::default());
-        let name = JsText::from("bundle.js");
-        let _ = cache.plan(&name, text, None);
         cache
-            .plan(&name, text, None)
+            .plan(&JsText::from("bundle.js"), text, None, true)
             .key()
             .cloned()
-            .unwrap_or_else(|| panic!("a second sighting has a key"))
+            .unwrap_or_else(|| panic!("a shared first sighting has a key"))
     }
 
     fn script(seed: u8) -> JsText {
@@ -356,8 +420,8 @@ mod tests {
         let sources = Sources::default();
         let text = script(1);
         let key = key(&text);
-        let first = one_byte(sources.units(&key, &text));
-        let second = one_byte(sources.units(&key, &text));
+        let first = one_byte(sources.units(&key, &text, sources.reader()));
+        let second = one_byte(sources.units(&key, &text, sources.reader()));
         assert!(Arc::ptr_eq(&first, &second));
         assert_eq!(sources.made(), 1);
         assert_eq!(sources.reading(), 2);
@@ -377,6 +441,12 @@ mod tests {
         }
     }
 
+    // A copy two contexts have read, the second still reading it.
+    fn shared(sources: &Sources, key: &Key, text: &JsText) -> Option<Units> {
+        drop(sources.units(key, text, sources.reader()));
+        sources.units(key, text, sources.reader())
+    }
+
     #[test]
     fn a_source_still_read_is_kept_and_an_unread_one_makes_room() {
         let sources = Sources::default();
@@ -386,31 +456,108 @@ mod tests {
         let mut read: Vec<Option<Units>> = texts
             .iter()
             .zip(&keys)
-            .map(|(text, key)| sources.units(key, text))
+            .map(|(text, key)| shared(&sources, key, text))
             .collect();
         let extra = script(100);
         let extra_key = key(&extra);
-        assert!(sources.units(&extra_key, &extra).is_none());
+        assert!(shared(&sources, &extra_key, &extra).is_none());
         drop(read.remove(3));
         drop(read.remove(0));
-        drop(sources.units(&keys[3], &texts[3]));
+        drop(sources.units(&keys[3], &texts[3], sources.reader()));
         // Of the two unread, the least recently used makes room.
-        assert!(sources.units(&extra_key, &extra).is_some());
+        assert!(shared(&sources, &extra_key, &extra).is_some());
         let made = sources.made();
         assert_eq!(made, u64::from(count) + 1);
-        drop(sources.units(&keys[3], &texts[3]));
+        drop(sources.units(&keys[3], &texts[3], sources.reader()));
         assert_eq!(sources.made(), made);
-        drop(sources.units(&keys[0], &texts[0]));
+        drop(sources.units(&keys[0], &texts[0], sources.reader()));
         assert_eq!(sources.made(), made + 1);
         for (at, held) in [1, 2, 4, 5, 6, 7].into_iter().zip(&read) {
             assert!(same(
-                sources.units(&keys[at], &texts[at]).as_ref(),
+                sources
+                    .units(&keys[at], &texts[at], sources.reader())
+                    .as_ref(),
                 held.as_ref()
             ));
         }
         assert_eq!(sources.made(), made + 1);
     }
 
+    // One context's copy, however often it read it, waits for no new source
+    // once no string reads it: the next call drops and frees it.
+    #[test]
+    fn a_copy_one_context_read_goes_at_the_next_call_once_unread() {
+        let sources = Sources::default();
+        let (text, other) = (script(70), script(71));
+        let (key, other_key) = (key(&text), key(&other));
+        let reader = sources.reader();
+        let first = one_byte(sources.units(&key, &text, reader));
+        let again = one_byte(sources.units(&key, &text, reader));
+        assert!(Arc::ptr_eq(&first, &again));
+        let copy = Arc::downgrade(&first);
+        drop((first, again));
+        assert!(copy.upgrade().is_some());
+        drop(sources.units(&other_key, &other, sources.reader()));
+        assert!(copy.upgrade().is_none());
+        drop(sources.units(&key, &text, sources.reader()));
+        assert_eq!(sources.made(), 3);
+    }
+
+    #[test]
+    fn a_copy_two_contexts_read_in_turn_stays_once_unread() {
+        let sources = Sources::default();
+        let (text, other) = (script(72), script(73));
+        let (key, other_key) = (key(&text), key(&other));
+        let copy = Arc::downgrade(&one_byte(shared(&sources, &key, &text)));
+        drop(sources.units(&other_key, &other, sources.reader()));
+        let again = one_byte(sources.units(&key, &text, sources.reader()));
+        assert!(
+            copy.upgrade()
+                .is_some_and(|copy| Arc::ptr_eq(&copy, &again))
+        );
+        assert_eq!(sources.made(), 2);
+    }
+
+    #[test]
+    fn a_copy_a_second_context_reads_while_the_first_does_stays_once_unread() {
+        let sources = Sources::default();
+        let (text, other) = (script(74), script(75));
+        let (key, other_key) = (key(&text), key(&other));
+        let first = one_byte(sources.units(&key, &text, sources.reader()));
+        let second = one_byte(sources.units(&key, &text, sources.reader()));
+        let copy = Arc::downgrade(&first);
+        drop((first, second));
+        drop(sources.units(&other_key, &other, sources.reader()));
+        let again = one_byte(sources.units(&key, &text, sources.reader()));
+        assert!(
+            copy.upgrade()
+                .is_some_and(|copy| Arc::ptr_eq(&copy, &again))
+        );
+        assert_eq!(sources.made(), 2);
+    }
+
+    // Contexts loading two scripts in turn, each gone before the next, sweep
+    // each other's copy; a copy made again after its sweep is kept as one more
+    // than one context read, so each script is converted twice in all.
+    #[test]
+    fn scripts_loaded_in_turn_by_short_lived_contexts_stay_after_their_second_copy() {
+        let sources = Sources::default();
+        let texts = [script(78), script(79)];
+        let keys = texts.each_ref().map(key);
+        for _ in 0..2 {
+            for (key, text) in keys.iter().zip(&texts) {
+                drop(sources.units(key, text, sources.reader()));
+            }
+        }
+        assert_eq!(sources.made(), 4);
+        for _ in 0..3 {
+            for (key, text) in keys.iter().zip(&texts) {
+                drop(sources.units(key, text, sources.reader()));
+            }
+        }
+        assert_eq!(sources.made(), 4);
+    }
+
     #[test]
     fn a_full_list_converts_nothing() {
         let sources = Sources::default();
@@ -418,18 +565,26 @@ mod tests {
         let read: Vec<Option<Units>> = (40..40 + count)
             .map(|seed| {
                 let text = script(seed);
-                sources.units(&key(&text), &text)
+                sources.units(&key(&text), &text, sources.reader())
             })
             .collect();
         let converted = sources.conversions();
         let extra = script(100);
         let extra_key = key(&extra);
         for _ in 0..3 {
-            assert!(sources.units(&extra_key, &extra).is_none());
+            assert!(
+                sources
+                    .units(&extra_key, &extra, sources.reader())
+                    .is_none()
+            );
         }
         assert_eq!(sources.conversions(), converted);
         drop(read);
-        assert!(sources.units(&extra_key, &extra).is_some());
+        assert!(
+            sources
+                .units(&extra_key, &extra, sources.reader())
+                .is_some()
+        );
         assert_eq!(sources.conversions(), converted + 1);
     }
 
@@ -440,21 +595,29 @@ mod tests {
     fn a_source_is_converted_only_while_it_may_fit() {
         let sources = Sources::bounded(MAX_SOURCES, 5 << 20);
         let read = script(50);
-        let still_read = sources.units(&key(&read), &read);
+        let still_read = sources.units(&key(&read), &read, sources.reader());
         assert!(still_read.is_some());
         let too_large = JsText::Latin1(vec![51; 4 << 20]);
-        assert!(sources.units(&key(&too_large), &too_large).is_none());
+        assert!(
+            sources
+                .units(&key(&too_large), &too_large, sources.reader())
+                .is_none()
+        );
         assert_eq!(sources.conversions(), 1);
         let mut astral = vec![b'a'; 2 << 20];
         astral.extend_from_slice("\u{1F600}".as_bytes());
         let astral = JsText::Utf8(astral);
         let astral_key = key(&astral);
         for _ in 0..3 {
-            assert!(sources.units(&astral_key, &astral).is_none());
+            assert!(
+                sources
+                    .units(&astral_key, &astral, sources.reader())
+                    .is_none()
+            );
         }
         assert_eq!(sources.conversions(), 2);
         drop(still_read);
-        assert!(two_byte(sources.units(&astral_key, &astral)).len() > 2 << 20);
+        assert!(two_byte(sources.units(&astral_key, &astral, sources.reader())).len() > 2 << 20);
         assert_eq!((sources.conversions(), sources.made()), (3, 2));
     }
 
@@ -466,7 +629,11 @@ mod tests {
         let invalid = JsText::Utf8(invalid);
         let invalid_key = key(&invalid);
         for _ in 0..3 {
-            assert!(sources.units(&invalid_key, &invalid).is_none());
+            assert!(
+                sources
+                    .units(&invalid_key, &invalid, sources.reader())
+                    .is_none()
+            );
         }
         assert_eq!((sources.conversions(), sources.made()), (1, 0));
     }
@@ -476,32 +643,56 @@ mod tests {
         let parent: &'static Sources = Box::leak(Box::default());
         let text = script(2);
         let key = key(&text);
-        let shared = parent.units(&key, &text);
+        let shared = parent.units(&key, &text, parent.reader());
         let child = parent.inherited();
-        let in_child = child.units(&key, &text);
+        let in_child = child.units(&key, &text, child.reader());
         assert!(same(shared.as_ref(), in_child.as_ref()));
         assert_eq!(child.reading(), 2);
         let copy = Arc::downgrade(&one_byte(shared));
         drop(in_child);
+        // Sources the child still reads fill its list, so the unread
+        // inherited copy makes room.
         let count = u8::try_from(MAX_SOURCES).unwrap_or(u8::MAX);
-        for seed in 30..30 + count {
-            let other = script(seed);
-            drop(child.units(&self::key(&other), &other));
-        }
+        let others: Vec<Option<Units>> = (30..30 + count)
+            .map(|seed| {
+                let other = script(seed);
+                child.units(&self::key(&other), &other, child.reader())
+            })
+            .collect();
         assert_eq!(copy.strong_count(), 1);
-        let again = one_byte(child.units(&key, &text));
+        drop(others);
+        let again = one_byte(child.units(&key, &text, child.reader()));
         assert!(
             !copy
                 .upgrade()
                 .is_some_and(|copy| Arc::ptr_eq(&copy, &again))
         );
-        let from_parent = one_byte(parent.units(&key, &text));
+        let from_parent = one_byte(parent.units(&key, &text, parent.reader()));
         assert!(
             copy.upgrade()
                 .is_some_and(|copy| Arc::ptr_eq(&copy, &from_parent))
         );
     }
 
+    // Dropping an inherited copy frees nothing in a child, and its next
+    // context loading the script would copy it again, so the child keeps
+    // one only its parent's context read.
+    #[test]
+    fn a_child_keeps_an_inherited_copy_one_context_read() {
+        let parent: &'static Sources = Box::leak(Box::default());
+        let (text, other) = (script(76), script(77));
+        let (key, other_key) = (key(&text), key(&other));
+        let copy = Arc::downgrade(&one_byte(parent.units(&key, &text, parent.reader())));
+        let child = parent.inherited();
+        drop(child.units(&other_key, &other, child.reader()));
+        let in_child = one_byte(child.units(&key, &text, child.reader()));
+        assert!(
+            copy.upgrade()
+                .is_some_and(|copy| Arc::ptr_eq(&copy, &in_child))
+        );
+        assert_eq!(child.made(), 1);
+    }
+
     // A child's inherited copies stay read while its parent's strings hold
     // them, so a child forked with a full list must not convert either.
     #[test]
@@ -511,14 +702,14 @@ mod tests {
         let read: Vec<Option<Units>> = (60..60 + count)
             .map(|seed| {
                 let text = script(seed);
-                parent.units(&key(&text), &text)
+                parent.units(&key(&text), &text, parent.reader())
             })
             .collect();
         let child = parent.inherited();
         let extra = script(110);
         let extra_key = key(&extra);
         for _ in 0..3 {
-            assert!(child.units(&extra_key, &extra).is_none());
+            assert!(child.units(&extra_key, &extra, child.reader()).is_none());
         }
         assert_eq!(child.conversions(), 0);
         drop(read);
@@ -529,11 +720,14 @@ mod tests {
         let parent = Sources::default();
         let text = script(3);
         let key = key(&text);
-        let shared = one_byte(parent.units(&key, &text));
+        let shared = one_byte(parent.units(&key, &text, parent.reader()));
         let held = parent.list.lock();
         let child = parent.inherited();
         drop(held);
-        assert!(!Arc::ptr_eq(&shared, &one_byte(child.units(&key, &text))));
+        assert!(!Arc::ptr_eq(
+            &shared,
+            &one_byte(child.units(&key, &text, child.reader()))
+        ));
         assert_eq!(child.made(), 1);
     }
 }

data/crates/mini_racer_engine/src/runner.rs

@@ -62,6 +62,9 @@ struct Runtime {
     freed: AtomicBool,
     // The startup snapshot this isolate began from, for the code cache's key.
     snapshot: Option<u64>,
+    // Tells this context's reads of a shared source from other contexts', as
+    // a copy only one context read is dropped once no string reads it.
+    reader: u64,
     // Large scripts to cache once their dispatch is over, so making a cache
     // never counts against a timeout.
     uncached: Mutex<Vec<Uncached>>,
@@ -142,6 +145,7 @@ impl Runtime {
             running: AtomicU32::new(0),
             freed: AtomicBool::new(false),
             snapshot,
+            reader: generation.sources().reader(),
             uncached: Mutex::default(),
             hoisting: Mutex::default(),
             frames: Mutex::default(),
@@ -770,10 +774,12 @@ fn evaluate(
     }
     let plan = if large(source) {
         runtime.freed.store(true, Ordering::Relaxed);
-        runtime
-            .generation
-            .code_cache()
-            .plan(filename, source, runtime.snapshot)
+        runtime.generation.code_cache().plan(
+            filename,
+            source,
+            runtime.snapshot,
+            shares_sources(runtime),
+        )
     } else {
         Plan::Compile(None)
     };
@@ -796,21 +802,25 @@ fn evaluate(
     Ok(reply)
 }
 
-// A large script the process has seen before reads its source from the copy
-// every context compiling it shares, outside the V8 heap. `max_memory:`
-// measures the heap, where mini_racer keeps the source, so a context with it
-// keeps its own copy.
+// `max_memory:` measures the heap, where mini_racer keeps the source, so a
+// context with it keeps its own copy.
+fn shares_sources(runtime: &Runtime) -> bool {
+    runtime.block.config.max_memory.is_none()
+}
+
+// A large script reads its source from the copy every context compiling it
+// shares, outside the V8 heap, made by the first of them.
 fn shared_source<'s>(
     scope: &v8::PinScope<'s, '_>,
     runtime: &Runtime,
     key: Option<&Key>,
     source: &JsText,
 ) -> Option<v8::Local<'s, v8::String>> {
-    if runtime.block.config.max_memory.is_some() {
+    if !shares_sources(runtime) {
         return None;
     }
     let sources = runtime.generation.sources();
-    let string = sys::external_string(scope, &sources.units(key?, source)?)?;
+    let string = sys::external_string(scope, &sources.units(key?, source, runtime.reader)?)?;
     sources.read();
     Some(string)
 }

data/crates/mini_racer_wire/src/decode.rs

@@ -85,6 +85,12 @@ pub trait Visitor {
 
     fn end(&mut self, frame: Self::Frame) -> Result<Self::Value, Self::Error>;
 
+    /// A key that is a string, for an entry of `frame` other than an error's
+    /// fields, which would otherwise reach `scalar` as text.
+    fn key(&mut self, _frame: &Self::Frame, text: Text<'_>) -> Result<Self::Value, Self::Error> {
+        self.scalar(Scalar::Text(text))
+    }
+
     /// Remembers `value` as V8's object `id` for later back references. Ids
     /// arrive in increasing order, except that a container whose `begin`
     /// returned no value is registered when it ends.
@@ -650,11 +656,27 @@ impl<'a, 'v, V: Visitor> Decoder<'a, 'v, V> {
     }
 
     fn insert(&mut self, frame: &mut V::Frame, depth: u32) -> Result<(), DecodeError<V::Error>> {
-        let key = self.value(Self::child(depth)?)?;
-        let value = self.value(Self::child(depth)?)?;
+        let depth = Self::child(depth)?;
+        let key = self.entry_key(frame, depth)?;
+        let value = self.value(depth)?;
         Self::visit(self.visitor.insert(frame, key, value))
     }
 
+    // A key that is not a string is read again as a value: handing `value` its
+    // tag would split `value` in two, and the half with the containers takes
+    // them all inline. Out of line, so `insert` stays inside the container's
+    // frame; a deep result repeats every frame on the way down.
+    #[inline(never)]
+    fn entry_key(&mut self, frame: &V::Frame, depth: u32) -> Decoded<V> {
+        let start = self.reader;
+        let tag = self.tag()?;
+        if let Some(text) = self.text(tag)? {
+            return Self::visit(self.visitor.key(frame, text));
+        }
+        self.reader = start;
+        self.value(depth)
+    }
+
     // Reads keyed entries up to `end`, which may follow padding only if a key does.
     fn entries(
         &mut self,