Improvements to the speed of latin1_to_string.

On the benchmark it improves the encoding from around 9 microsends to 6
microseconds.

This PR also includes the benchmark and setup as criterion benchmark.

Signed-off-by: Narfinger <Narfinger@users.noreply.github.com>

Author: Narfinger

mozjs/Cargo.toml

@@ -21,6 +21,14 @@ libc.workspace = true
 log = "0.4"
 mozjs_sys = { path = "../mozjs-sys" }
 
+[dev-dependencies]
+criterion = "0.6"
+
 [build-dependencies]
 cc.workspace = true
 bindgen.workspace = true
+
+
+[[bench]]
+name = "latin1_string_conversion"
+harness = false

mozjs/benches/latin1_string_conversion.rs

@@ -0,0 +1,96 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use std::ffi::c_void;
+use std::{iter, ptr};
+
+use mozjs::conversions::jsstr_to_string;
+use mozjs::glue::{CreateJSExternalStringCallbacks, JSExternalStringCallbacksTraps};
+use mozjs::jsapi::{
+    JSAutoRealm, JS_NewExternalStringLatin1, JS_NewGlobalObject, OnNewGlobalHookOption,
+};
+use mozjs::rooted;
+use mozjs::rust::{JSEngine, RealmOptions, Runtime, SIMPLE_GLOBAL_CLASS};
+
+fn external_string(c: &mut Criterion) {
+    unsafe {
+        let engine = JSEngine::init().unwrap();
+        let runtime = Runtime::new(engine.handle());
+        let context = runtime.cx();
+        let h_option = OnNewGlobalHookOption::FireOnNewGlobalHook;
+        let c_option = RealmOptions::default();
+        rooted!(in(context) let global = JS_NewGlobalObject(
+            context,
+            &SIMPLE_GLOBAL_CLASS,
+            ptr::null_mut(),
+            h_option,
+            &*c_option,
+        ));
+        let _ac = JSAutoRealm::new(context, global.get());
+
+        let latin1_base =
+            iter::repeat_n("test latin-1 test", 1_000_000).fold(String::new(), |mut acc, x| {
+                acc.push_str(x);
+                acc
+            });
+
+        let latin1_boxed = latin1_base.as_bytes().to_vec().into_boxed_slice();
+        let latin1_chars = Box::into_raw(latin1_boxed).cast::<u8>();
+        let callbacks = CreateJSExternalStringCallbacks(
+            &EXTERNAL_STRING_CALLBACKS_TRAPS,
+            latin1_base.len() as *mut c_void,
+        );
+        rooted!(in(context) let latin1_jsstr = JS_NewExternalStringLatin1(
+            context,
+            latin1_chars,
+            latin1_base.len(),
+            callbacks
+        ));
+        c.bench_function("external_string_latin1", |b| {
+            b.iter(|| {
+                jsstr_to_string(context, latin1_jsstr.get());
+            })
+        });
+    }
+}
+
+static EXTERNAL_STRING_CALLBACKS_TRAPS: JSExternalStringCallbacksTraps =
+    JSExternalStringCallbacksTraps {
+        latin1Finalize: Some(latin1::finalize),
+        latin1SizeOfBuffer: Some(latin1::size_of),
+        utf16Finalize: Some(utf16::finalize),
+        utf16SizeOfBuffer: Some(utf16::size_of),
+    };
+
+mod latin1 {
+    use std::ffi::c_void;
+    use std::slice;
+
+    use mozjs::jsapi::mozilla::MallocSizeOf;
+
+    pub unsafe extern "C" fn finalize(data: *const c_void, chars: *mut u8) {
+        let slice = slice::from_raw_parts_mut(chars, data as usize);
+        let _ = Box::from_raw(slice);
+    }
+
+    pub unsafe extern "C" fn size_of(data: *const c_void, _: *const u8, _: MallocSizeOf) -> usize {
+        data as usize
+    }
+}
+
+mod utf16 {
+    use std::ffi::c_void;
+    use std::slice;
+
+    use mozjs::jsapi::mozilla::MallocSizeOf;
+
+    pub unsafe extern "C" fn finalize(data: *const c_void, chars: *mut u16) {
+        let slice = slice::from_raw_parts_mut(chars, data as usize);
+        let _ = Box::from_raw(slice);
+    }
+
+    pub unsafe extern "C" fn size_of(data: *const c_void, _: *const u16, _: MallocSizeOf) -> usize {
+        data as usize
+    }
+}
+
+criterion_group!(benches, external_string);
+criterion_main!(benches);

mozjs/src/conversions.rs

@@ -525,6 +525,12 @@ impl FromJSValConvertible for f64 {
     }
 }
 
+/// A simple wrapper for ascii compatible chars. This and the mem::transmute call
+/// in latin1_to_string should be replaced when the `ascii_char` feature is stable.
+/// See: <https://github.com/rust-lang/rust/issues/110998>.
+#[repr(transparent)]
+struct AsciiChar(u8);
+
 /// Converts a `JSString`, encoded in "Latin1" (i.e. U+0000-U+00FF encoded as 0x00-0xFF) into a
 /// `String`.
 pub unsafe fn latin1_to_string(cx: *mut JSContext, s: *mut JSString) -> String {
@@ -536,7 +542,14 @@ pub unsafe fn latin1_to_string(cx: *mut JSContext, s: *mut JSString) -> String {
 
     let chars = slice::from_raw_parts(chars, length as usize);
     let mut s = String::with_capacity(length as usize);
-    s.extend(chars.iter().map(|&c| c as char));
+
+    let v = s.as_mut_vec();
+    for c in chars {
+        // This is safe as we are ensured that we only have "Latin1" strings which have the upper
+        // code word 00.
+        v.push(*c);
+    }
+
     s
 }