Change the internal structure of JsString for performance (#4455)

This is the first in a series of PR to improve the performance of
strings in Boa.

The first step was to introduce a new type of strings, `SliceString`,
which contains a strong pointer to another string and start/end indices.
This allows for very fast slicing of strings. This initially came at a
performance cost by having an enumeration of kinds of strings. An
intermediate experiment was introduced to have the kind be a tag on the
internal JsString pointer. This still came as a cost as it required bit
operations to figure out which function to call.

Finally, I moved to using a `vtable`. This helped with many points:
1. as fast as before. Before this PR, there was still a deref of a
pointer when accessing internal fields.
2. we can now introduce many other types (which will come in their
separate PRs).
3. this makes the code to clone/drop/as_str (and even construction) more
streamline as each function is their own implementation.

The biggest drawback is now we are operating with a bit more pointer and
unsafe code. I made sure that all code was passing both debug, release
and miri tests on boa_string and boa_engine's builtins::string suite.

This `vtable` bring slightly better performance (depending on the test,
about 90-110%, but overall 2-3% better than the `main` branch), even
though we only directly improved string slicing operations.

The next suite of PRs are going to cover more string types:
1. since strings are constant and unmutable, include the length in the
vtable directly instead of relying on a function call.
2. also because of the above, splitting latin1 and utf-16 string kinds
to remove conditionals on a lot of sub functions.
3. have a concat string that makes concatenation instant, similar to how
slice improve concatenation

Also, there might still be some slicing that creates new strings from
existing ones without using SliceString. Those can be improved greatly.

Please note the `benches/scripts/strings/slice.js` test is twice as fast
with this branch than with `main`.

The performance table for this PR:

| Test | Main | PR  |
|---|-----|-----|
| Richards | 218 | 233 |
| DeltaBlue | 234 | 244 |
| Crypto | 184 | 208 |
| RayTrace | 502 | 485 |
| EarleyBoyer | 595 | 584 |
| RegExp | 88.1 | 83  |
| Splay | 905 | 837 |
| NavierStokes | 413 | 467 |
|---| --- | --- |
| TOTAL | 313 | 320 |

Author: hansl

Cargo.lock

@@ -14,12 +14,14 @@ members = [
     "cli",
     # UTILS
     "utils/*",
+    # BENCHES
+    "benches",
 ]
 
 exclude = [
     "tests/fuzz", # Does weird things on Windows tests
-    "tests/src",  # Just a hack to have fuzz inside tests
-    "tests/wpt",  # Should not run WPT by default.
+    "tests/src", # Just a hack to have fuzz inside tests
+    "tests/wpt", # Should not run WPT by default.
 ]
 
 [workspace.package]

Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "boa_benches"
+version = "0.1.0"
+edition = "2024"
+publish = false
+
+[dependencies]
+boa_engine.workspace = true
+boa_runtime.workspace = true
+
+[dev-dependencies]
+criterion.workspace = true
+walkdir = "2"
+
+[target.x86_64-unknown-linux-gnu.dev-dependencies]
+jemallocator.workspace = true
+
+[[bench]]
+name = "scripts"
+harness = false

benches/Cargo.toml

@@ -0,0 +1,69 @@
+#![allow(unused_crate_dependencies, missing_docs)]
+use boa_engine::{
+    Context, JsValue, Source, js_string, optimizer::OptimizerOptions, script::Script,
+};
+use criterion::{Criterion, criterion_group, criterion_main};
+use std::path::Path;
+
+#[cfg(all(target_arch = "x86_64", target_os = "linux", target_env = "gnu"))]
+#[global_allocator]
+static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;
+
+fn bench_scripts(c: &mut Criterion) {
+    let scripts_dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("scripts");
+
+    let scripts: Vec<_> = walkdir::WalkDir::new(&scripts_dir)
+        .into_iter()
+        .filter_map(|e| e.ok())
+        .filter(|e| e.path().extension().is_some_and(|ext| ext == "js"))
+        .collect();
+
+    for entry in scripts {
+        let path = entry.path();
+        let code = std::fs::read_to_string(path).unwrap();
+
+        // Create a nice benchmark name from the relative path
+        let name = path
+            .strip_prefix(&scripts_dir)
+            .unwrap()
+            .with_extension("")
+            .display()
+            .to_string();
+
+        let context = &mut Context::default();
+
+        // Disable optimizations
+        context.set_optimizer_options(OptimizerOptions::empty());
+
+        // Register runtime for console.log support
+        boa_runtime::register(
+            boa_runtime::extensions::ConsoleExtension(boa_runtime::NullLogger),
+            None,
+            context,
+        )
+        .expect("Runtime registration failed");
+
+        // Parse and compile once, outside the benchmark loop
+        let script = Script::parse(Source::from_bytes(&code), None, context).unwrap();
+        script.codeblock(context).unwrap();
+
+        // Evaluate once to define the main function
+        script.evaluate(context).unwrap();
+
+        // Get the main function
+        let function = context
+            .global_object()
+            .get(js_string!("main"), context)
+            .unwrap_or_else(|_| panic!("No main function defined in script: {}", path.display()))
+            .as_callable()
+            .unwrap_or_else(|| panic!("'main' is not a function in script: {}", path.display()))
+            .clone();
+
+        c.bench_function(&format!("{name} (Execution)"), |b| {
+            b.iter(|| function.call(&JsValue::undefined(), &[], context));
+        });
+    }
+}
+
+criterion_group!(benches, bench_scripts);
+criterion_main!(benches);

benches/benches/scripts.rs

@@ -0,0 +1,9 @@
+// This script should take a few seconds to run.
+const kIterationCount = 10_000;
+const base = "abcdefghijklmnopqrstuvwxyz".repeat(10_000_000);
+
+function main() {
+  for (let i = 0; i < kIterationCount; i++) {
+    base.slice(i * 100, i * 100 + 20000);
+  }
+}

benches/scripts/strings/slice.js

@@ -0,0 +1,8 @@
+// This script should take a few seconds to run.
+const kIterationCount = 10_000;
+const base = "abcdefghijklmnopqrstuvwxyz".repeat(1_000);
+
+function main() {
+  const k = base.split("a").length;
+  console.log(k);
+}

benches/scripts/strings/split.js

@@ -0,0 +1 @@
+#![allow(unused_crate_dependencies)]

benches/src/lib.rs

@@ -784,7 +784,8 @@ impl String {
             Ok(js_string!().into())
         } else {
             // 13. Return the substring of S from from to to.
-            Ok(js_string!(string.get_expect(from..to)).into())
+            // SAFETY: We already checked that `from` and `to` are within bounds.
+            Ok(unsafe { JsString::slice_unchecked(&string, from, to).into() })
         }
     }
 
@@ -1887,7 +1888,8 @@ impl String {
         let to = max(final_start, final_end);
 
         // 10. Return the substring of S from from to to.
-        Ok(js_string!(string.get_expect(from..to)).into())
+        // SAFETY: We already checked that `from` and `to` are within bounds.
+        Ok(unsafe { JsString::slice_unchecked(&string, from, to).into() })
     }
 
     /// `String.prototype.split ( separator, limit )`
@@ -1983,7 +1985,7 @@ impl String {
         while let Some(index) = j {
             // a. Let T be the substring of S from i to j.
             // b. Append T as the last element of substrings.
-            substrings.push(this_str.get_expect(i..index).into());
+            substrings.push(this_str.slice(i, index));
 
             // c. If the number of elements of substrings is lim, return ! CreateArrayFromList(substrings).
             if substrings.len() == lim {
@@ -2002,7 +2004,7 @@ impl String {
 
         // 15. Let T be the substring of S from i.
         // 16. Append T to substrings.
-        substrings.push(JsString::from(this_str.get_expect(i..)));
+        substrings.push(this_str.slice(i, this_str.len()));
 
         // 17. Return ! CreateArrayFromList(substrings).
         Ok(

core/engine/src/builtins/string/mod.rs

@@ -564,7 +564,8 @@ pub(crate) fn ordinary_set_prototype_of(
         // c. Else,
         // i. If p.[[GetPrototypeOf]] is not the ordinary object internal method defined
         // in 10.1.1, set done to true.
-        else if proto.vtable().__get_prototype_of__ as usize != ordinary_get_prototype_of as usize
+        else if proto.vtable().__get_prototype_of__ as usize
+            != ordinary_get_prototype_of as *const () as usize
         {
             break;
         }

core/engine/src/object/internal_methods/mod.rs

@@ -55,9 +55,8 @@ macro_rules! js_string {
         $crate::string::JsString::default()
     };
     ($s:literal) => {const {
-        const LITERAL: &$crate::string::JsStr<'static> = &$crate::js_str!($s);
-
-        $crate::string::JsString::from_static_js_str(LITERAL)
+        const LITERAL: $crate::string::StaticString = $crate::string::StaticString::new($crate::js_str!($s));
+        $crate::string::JsString::from_static(&LITERAL)
     }};
     ($s:expr) => {
         $crate::string::JsString::from($s)