mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-19 17:05:55 +01:00
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:
1 parent
40283f4a38
commit
c2c560eeaa
3 files changed
+80
-32
No files matched your search
+27
-11
@@ -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
@@ -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()"));
|
||||
|
||||
@@ -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())
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user