perf(web): optimize encodeInto()

cli/bench/encode_into.js

@@ -0,0 +1,23 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+const queueMicrotask = globalThis.queueMicrotask || process.nextTick;
+let [total, count] = typeof Deno !== "undefined"
+  ? Deno.args
+  : [process.argv[2], process.argv[3]];
+
+total = total ? parseInt(total, 0) : 50;
+count = count ? parseInt(count, 10) : 1000000;
+
+function bench(fun) {
+  const start = Date.now();
+  for (let i = 0; i < count; i++) fun();
+  const elapsed = Date.now() - start;
+  const rate = Math.floor(count / (elapsed / 1000));
+  console.log(`time ${elapsed} ms rate ${rate}`);
+  if (--total) queueMicrotask(() => bench(fun));
+}
+
+const encoder = new TextEncoder();
+const data = "hello world";
+const out = new Uint8Array(100);
+
+bench(() => encoder.encodeInto(data, out));

core/Cargo.toml

@@ -33,7 +33,7 @@ serde_json = { version = "1.0.79", features = ["preserve_order"] }
 serde_v8 = { version = "0.61.0", path = "../serde_v8" }
 sourcemap = "=6.0.1"
 url = { version = "2.3.1", features = ["serde", "expose_internals"] }
-v8 = { version = "0.49.0", default-features = false }
+v8 = { version = "0.50.0", default-features = false }
 
 [[example]]
 name = "http_bench_json_ops"

core/runtime.rs

@@ -726,7 +726,7 @@ impl JsRuntime {
     {
       let scope = &mut self.handle_scope();
       let o = Self::grab_global::<v8::Object>(scope, "Deno.core.ops").unwrap();
-      let names = o.get_own_property_names(scope).unwrap();
+      let names = o.get_own_property_names(scope, Default::default()).unwrap();
       for i in 0..names.length() {
         let key = names.get_index(scope, i).unwrap();
         o.delete(scope, key);

ext/web/08_text_encoding.js

@@ -199,10 +199,16 @@
         context: "Argument 2",
         allowShared: true,
       });
-      return ops.op_encoding_encode_into(source, destination);
+      ops.op_encoding_encode_into(source, destination, encodeIntoBuf);
+      return {
+        read: encodeIntoBuf[0],
+        written: encodeIntoBuf[1],
+      };
     }
   }
 
+  const encodeIntoBuf = new Uint32Array(2);
+
   webidl.configurePrototype(TextEncoder);
   const TextEncoderPrototype = TextEncoder.prototype;
 

ext/web/lib.rs

@@ -10,7 +10,9 @@ use deno_core::error::type_error;
 use deno_core::error::AnyError;
 use deno_core::include_js_files;
 use deno_core::op;
+use deno_core::serde_v8;
 use deno_core::url::Url;
+use deno_core::v8;
 use deno_core::ByteString;
 use deno_core::CancelHandle;
 use deno_core::Extension;
@@ -19,11 +21,11 @@ use deno_core::Resource;
 use deno_core::ResourceId;
 use deno_core::U16String;
 use deno_core::ZeroCopyBuf;
+
 use encoding_rs::CoderResult;
 use encoding_rs::Decoder;
 use encoding_rs::DecoderResult;
 use encoding_rs::Encoding;
-use serde::Serialize;
 use std::borrow::Cow;
 use std::cell::RefCell;
 use std::fmt;
@@ -314,46 +316,29 @@ impl Resource for TextDecoderResource {
   }
 }
 
-#[derive(Serialize)]
-#[serde(rename_all = "camelCase")]
-struct EncodeIntoResult {
-  read: usize,
-  written: usize,
-}
-
-#[op]
+#[op(v8)]
 fn op_encoding_encode_into(
-  input: String,
+  scope: &mut v8::HandleScope,
+  input: serde_v8::Value,
   buffer: &mut [u8],
-) -> EncodeIntoResult {
-  // Since `input` is already UTF-8, we can simply find the last UTF-8 code
-  // point boundary from input that fits in `buffer`, and copy the bytes up to
-  // that point.
-  let boundary = if buffer.len() >= input.len() {
-    input.len()
-  } else {
-    let mut boundary = buffer.len();
-
-    // The maximum length of a UTF-8 code point is 4 bytes.
-    for _ in 0..4 {
-      if input.is_char_boundary(boundary) {
-        break;
-      }
-      debug_assert!(boundary > 0);
-      boundary -= 1;
-    }
-
-    debug_assert!(input.is_char_boundary(boundary));
-    boundary
+  out_buf: &mut [u8],
+) {
+  let s = v8::Local::<v8::String>::try_from(input.v8_value).unwrap();
+  assert!(out_buf.len() % 4 == 0);
+  // SAFETY: `out_buf` is guaranteed to be aligned to 4 bytes.
+  let out_buf: &mut [u32] = unsafe {
+    std::slice::from_raw_parts_mut(
+      out_buf.as_mut_ptr() as *mut u32,
+      out_buf.len() / std::mem::size_of::<u32>(),
+    )
   };
-
-  buffer[..boundary].copy_from_slice(input[..boundary].as_bytes());
-
-  EncodeIntoResult {
-    // The `read` output parameter is measured in UTF-16 code units.
-    read: input[..boundary].encode_utf16().count(),
-    written: boundary,
-  }
+  out_buf[1] = s.write_utf8(
+    scope,
+    buffer,
+    Some(&mut (out_buf[0] as usize)),
+    v8::WriteOptions::NO_NULL_TERMINATION
+      | v8::WriteOptions::REPLACE_INVALID_UTF8,
+  ) as u32;
 }
 
 /// Creates a [`CancelHandle`] resource that can be used to cancel invocations of certain ops.

ops/lib.rs

@@ -729,31 +729,26 @@ fn codegen_arg(
     return quote! {
       let #ident = {
         let value = args.get(#idx as i32);
-        if let Ok(view) = #core::v8::Local::<#core::v8::ArrayBufferView>::try_from(value) {
-          let (offset, len) = (view.byte_offset(), view.byte_length());
-          let buffer = match view.buffer(scope) {
-              Some(v) => v,
-              None => {
-                return #core::_ops::throw_type_error(scope, format!("Expected ArrayBufferView at position {}", #idx));
-              }
-          };
-          let store = buffer.get_backing_store();
-          if store.is_shared() {
-            return #core::_ops::throw_type_error(scope, format!("Expected non-shared ArrayBufferView at position {}", #idx));
-          }
-          unsafe { #mutability *(&store[offset..offset + len] as *const _ as *mut #ptr_ty) }
-        } else {
-          let b: #core::v8::Local<#core::v8::ArrayBuffer> = match value.try_into() {
-            Ok(v) => v,
-            Err(_) => {
-              return #core::_ops::throw_type_error(scope, format!("Expected ArrayBuffer at position {}", #idx));
+        match #core::v8::Local::<#core::v8::ArrayBuffer>::try_from(value) {
+          Ok(b) => {
+            let store = b.data() as *mut u8;
+            unsafe { ::std::slice::from_raw_parts_mut(store, b.byte_length()) }
+          },
+          Err(_) => {
+            if let Ok(view) = #core::v8::Local::<#core::v8::ArrayBufferView>::try_from(value) {
+              let (offset, len) = (view.byte_offset(), view.byte_length());
+              let buffer = match view.buffer(scope) {
+                  Some(v) => v,
+                  None => {
+                    return #core::_ops::throw_type_error(scope, format!("Expected ArrayBufferView at position {}", #idx));
+                  }
+              };
+              let store = buffer.data() as *mut u8;
+              unsafe { ::std::slice::from_raw_parts_mut(store.add(offset), len) }
+            } else {
+              return #core::_ops::throw_type_error(scope, format!("Expected ArrayBufferView at position {}", #idx));
             }
-          };
-          let store = b.get_backing_store();
-          if store.is_shared() {
-            return #core::_ops::throw_type_error(scope, format!("Expected non-shared ArrayBufferView at position {}", #idx));
           }
-          unsafe { #mutability *(&store[0..b.byte_length()] as *const _ as *mut #ptr_ty) }
         }
       };
     };

serde_v8/Cargo.toml

@@ -18,7 +18,7 @@ derive_more = "0.99.17"
 serde = { version = "1.0.136", features = ["derive"] }
 serde_bytes = "0.11"
 smallvec = { version = "1.8", features = ["union"] }
-v8 = { version = "0.49.0", default-features = false }
+v8 = { version = "0.50.0", default-features = false }
 
 [dev-dependencies]
 bencher = "0.1"

serde_v8/de.rs

@@ -325,7 +325,8 @@ impl<'de, 'a, 'b, 's, 'x> de::Deserializer<'de>
       };
       visitor.visit_map(map)
     } else {
-      let prop_names = obj.get_own_property_names(self.scope);
+      let prop_names =
+        obj.get_own_property_names(self.scope, Default::default());
       let keys: Vec<magic::Value> = match prop_names {
         Some(names) => from_v8(self.scope, names.into()).unwrap(),
         None => vec![],
@@ -410,7 +411,8 @@ impl<'de, 'a, 'b, 's, 'x> de::Deserializer<'de>
       let obj = v8::Local::<v8::Object>::try_from(self.input).unwrap();
       // Unpack single-key
       let tag = {
-        let prop_names = obj.get_own_property_names(self.scope);
+        let prop_names =
+          obj.get_own_property_names(self.scope, Default::default());
         let prop_names = prop_names.ok_or(Error::ExpectedEnum)?;
         if prop_names.length() != 1 {
           return Err(Error::LengthMismatch);