Scripts: a String object's character is read along its rope when the copy does not fit

When the flattened copy of a String object's concatenated string would pass the heap limit
before a collection can run, the indexed read walks the rope to the unit instead, taking a
unit of fuel for each node it visits, so no copy is made.
This commit is contained in:
dotCooCoo committed 2026-11-11 22:57:35 -08:00
1 parent 40283f4a38
commit c2c560eeaa
3 files changed
+80 -32

No files matched your search

+27 -11
View File
@@ -209,7 +209,8 @@ pub(crate) struct Interp {
/// Bytes of the copies [`Self::get_own_property`] made flattening the rope of a String
/// object, which the heap's total adds before the next limit check.
flattened: std::cell::Cell<usize>,
/// Fuel for the units those copies took, which the next step takes.
/// Fuel for the units those copies took and the rope nodes it read in place, which the next
/// step takes.
pub(crate) flattened_fuel: std::cell::Cell<u64>,
/// The global code's default XML namespace URI (ECMA-357 section 12.1).
pub(crate) xml_default_uri: Key,
@@ -1246,18 +1247,33 @@ impl Interp {
if let Some(i) = array_index(k)
&& (i as usize) < s.len()
{
if s.is_rope() {
// Flattening copies the units. The run ends here when the fuel for the
// copy is not left; otherwise the next step takes it, and the next limit
// check adds the copy's bytes.
let fuel = self.flattened_fuel.get().saturating_add((s.len() / crate::string_builtins::UNITS_PER_FUEL) as u64 + 1);
if fuel > self.fuel {
return Err(Abrupt::Limit(LimitKind::Fuel));
let unit = if s.is_rope() {
let owed = self.flattened_fuel.get();
let flattened = self.flattened.get().saturating_add(string_bytes(s.len()));
if self.heap.bytes.saturating_add(flattened) > self.limits.heap_bytes {
// The copy does not fit without a collection, which needs `&mut self`:
// the unit is read along the rope instead, a unit of fuel per node.
let Some((unit, visited)) = s.unit_at(i as usize, self.fuel.saturating_sub(owed)) else {
return Err(Abrupt::Limit(LimitKind::Fuel));
};
self.flattened_fuel.set(owed.saturating_add(visited));
unit
} else {
// Flattening copies the units. The run ends here when the fuel for
// the copy is not left; otherwise the next step takes it, and the
// next limit check adds the copy's bytes.
let fuel = owed.saturating_add((s.len() / crate::string_builtins::UNITS_PER_FUEL) as u64 + 1);
if fuel > self.fuel {
return Err(Abrupt::Limit(LimitKind::Fuel));
}
self.flattened_fuel.set(fuel);
self.flattened.set(flattened);
s.flat().get(i as usize).copied()
}
self.flattened_fuel.set(fuel);
self.flattened.set(self.flattened.get().saturating_add(string_bytes(s.len())));
} else {
s.flat().get(i as usize).copied()
}
let unit = s.flat().get(i as usize).copied().unwrap_or(0);
.unwrap_or(0);
return Ok(Some(Prop::Data { value: Value::String(Str::from_units(vec![unit])), flags: ENUMERABLE }));
}
}
+25 -21
View File
@@ -314,23 +314,15 @@ fn operators_and_builtins_count_a_flattened_rope_against_the_heap() {
// Three ropes of about 524,288 units, each 1 MiB once flat, with a 3 MiB heap.
let build = "var s = 'x'; for (var i = 0; i < 19; i++) s = s + s; var t = s + 'y', u = s + 'z';";
let limits = Limits { heap_bytes: 3 << 20, ..Limits::default() };
let not_stopped: Vec<_> = [
"X < 'a'",
"X == 1",
"+X",
"X[0]",
"new String(X)[0]",
"({})[{ toString: function () { return X; } }]",
"JSON.stringify(0, null, X)",
"[1].join(X)",
]
.into_iter()
.filter(|read| {
let src = format!("{build} {}; {}; {}; 0", read.replace('X', "s"), read.replace('X', "t"), read.replace('X', "u"));
let result = Realm::with_options(Options::default(), limits.clone()).run(&src);
!matches!(result, Err(ref e) if e.kind == RunErrorKind::Limit(LimitKind::Heap))
})
.collect();
let not_stopped: Vec<_> =
["X < 'a'", "X == 1", "+X", "X[0]", "({})[{ toString: function () { return X; } }]", "JSON.stringify(0, null, X)", "[1].join(X)"]
.into_iter()
.filter(|read| {
let src = format!("{build} {}; {}; {}; 0", read.replace('X', "s"), read.replace('X', "t"), read.replace('X', "u"));
let result = Realm::with_options(Options::default(), limits.clone()).run(&src);
!matches!(result, Err(ref e) if e.kind == RunErrorKind::Limit(LimitKind::Heap))
})
.collect();
assert!(not_stopped.is_empty(), "not stopped by the heap limit: {not_stopped:?}");
}
@@ -386,10 +378,22 @@ fn a_string_object_counts_its_flattened_rope_against_the_heap() {
let lengths =
Realm::with_options(Options::default(), limits.clone()).run(&format!("{build} Object(s).length + new String(t).length + Object(u).length"));
assert_eq!(lengths, Ok(JsValue::Number(1_572_866.0)));
for read in ["Object(X)[0]", "new String(X)[0]", "0 in Object(X)", "Object(X).hasOwnProperty(0)", "X.first()"] {
let src = format!("{build} {}; {}; {}; 0", read.replace('X', "s"), read.replace('X', "t"), read.replace('X', "u"));
let e = fail_with(Realm::with_options(Options::default(), limits.clone()), &src);
assert_eq!(e.kind, RunErrorKind::Limit(LimitKind::Heap), "{read}: {e:?}");
// Two copies fit. The third read finds no room for its copy and reads the unit along the
// rope, so the live heap stays within the limit.
for (read, expected) in [
("Object(X)[0]", "xxx"),
("new String(X)[0]", "xxx"),
("0 in Object(X)", "truetruetrue"),
("Object(X).hasOwnProperty(0)", "truetruetrue"),
("X.first()", "xxx"),
("Object(X)[524288]", "undefinedyz"),
] {
let src = format!("{build} '' + ({}) + ({}) + ({})", read.replace('X', "s"), read.replace('X', "t"), read.replace('X', "u"));
let mut realm = Realm::with_options(Options::default(), limits.clone());
assert_eq!(realm.run(&src), Ok(JsValue::String(expected.into())), "{read}");
let interp = realm.interp();
interp.collect_garbage();
assert!(interp.heap.bytes <= limits.heap_bytes, "{read}: {} bytes live", interp.heap.bytes);
}
let wrapped =
Realm::with_options(Options::default(), Limits::default()).run(&format!("{build} Object(t)[524288] + new String(u)[524288] + t.first()"));
+28
View File
@@ -163,6 +163,34 @@ impl Str {
flat
}
/// The code unit at `i` read along the rope without flattening it, visiting at most
/// `max_nodes` nodes: `None` when that is not enough, otherwise the unit (when `i` is in
/// range) and the number of nodes visited.
pub(crate) fn unit_at(&self, mut i: usize, max_nodes: u64) -> Option<(Option<u16>, u64)> {
let mut node = self.clone();
let mut visited = 0u64;
loop {
visited += 1;
if visited > max_nodes {
return None;
}
let next = match &*node.0.borrow() {
Node::Flat(f) => return Some((f.get(i).copied(), visited)),
Node::Concat { left, right, .. } => {
let left_len = left.len();
if i < left_len {
left.clone()
} else {
i -= left_len;
right.clone()
}
}
Node::Taken => return Some((None, visited)),
};
node = next;
}
}
pub(crate) fn to_rust_string(&self) -> String {
String::from_utf16_lossy(&self.flat())
}