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

@@ -17,10 +17,19 @@ profilemozjs = ['mozjs_sys/profilemozjs']
 crown = ['mozjs_sys/crown']
 
 [dependencies]
+encoding_rs = "0.8.35"
 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

@@ -48,6 +48,7 @@ use log::debug;
 use mozjs_sys::jsgc::Rooted;
 use std::borrow::Cow;
 use std::mem;
+use std::mem::MaybeUninit;
 use std::rc::Rc;
 use std::{ptr, slice};
 
@@ -525,6 +526,16 @@ impl FromJSValConvertible for f64 {
     }
 }
 
+/// Copies chars to the string
+unsafe fn fast_copy(chars: &[u8]) -> String {
+    let mut v = Vec::with_capacity(chars.len() * 2);
+    v.set_len(chars.len() * 2);
+    let real_size = encoding_rs::mem::convert_latin1_to_utf8(chars, v.as_mut_slice());
+
+    v.truncate(real_size);
+    String::from_utf8_unchecked(v)
+}
+
 /// 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 {
@@ -535,9 +546,7 @@ pub unsafe fn latin1_to_string(cx: *mut JSContext, s: *mut JSString) -> String {
     assert!(!chars.is_null());
 
     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));
-    s
+    fast_copy(chars)
 }
 
 /// Converts a `JSString` into a `String`, regardless of used encoding.

mozjs/tests/external_string.rs

@@ -36,21 +36,13 @@ fn external_string() {
         ));
         let _ac = JSAutoRealm::new(context, global.get());
 
-        let latin1_base = "test latin-1";
-        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
-        ));
-        assert_eq!(jsstr_to_string(context, latin1_jsstr.get()), latin1_base);
+        test_latin1_string(context, "test latin1");
+        test_latin1_string(context, "abcdefghijklmnop"); // exactly 16 bytes
+        test_latin1_string(context, "abcdefghijklmnopq"); // 17 bytes
+        test_latin1_string(context, "abcdefghijklmno"); // 15 bytes
+        test_latin1_string(context, "abcdefghijklmnopqrstuvwxyzabcdef"); //32 bytes
+        test_latin1_string(context, "abcdefghijklmnopqrstuvwxyzabcde"); //31 bytes
+        test_latin1_string(context, "abcdefghijklmnopqrstuvwxyzabcdefg"); //33 bytes
 
         let utf16_base = "test utf-16 $€ \u{10437}\u{24B62}";
         let utf16_boxed = utf16_base
@@ -74,6 +66,24 @@ fn external_string() {
     }
 }
 
+#[cfg(test)]
+unsafe fn test_latin1_string(context: *mut mozjs::jsapi::JSContext, latin1_base: &str) {
+    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
+    ));
+    assert_eq!(jsstr_to_string(context, latin1_jsstr.get()), latin1_base);
+}
+
 static EXTERNAL_STRING_CALLBACKS_TRAPS: JSExternalStringCallbacksTraps =
     JSExternalStringCallbacksTraps {
         latin1Finalize: Some(latin1::finalize),