feat(ops): Fast zero copy string arguments (#16777)

Uses SeqOneByteString optimization to do zero-copy `&str` arguments in fast calls. - [x] Depends on denoland/rusty_v8#1129 - [x] Depends on https://chromium-review.googlesource.com/c/v8/v8/+/4036884 - [x] Disable in async ops - [x] Make it work with owned `String` with an extra alloc in fast path. - [x] Support `Cow<'_, str>`. Owned for slow case, Borrowed for fast case ```rust #[op] fn op_string_len(s: &str) -> u32 { str.len() as u32 } ```
denoland · Dec 2, 2022 · 9b2b8df · 9b2b8df
1 parent 075854e
commit 9b2b8df
Show file tree

Hide file tree

Showing 34 changed files with 805 additions and 98 deletions.
diff --git a/cli/bench/console.js b/cli/bench/console.js
@@ -1,8 +1,3 @@
 // Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
 const count = 100000;
-
-const start = Date.now();
 for (let i = 0; i < count; i++) console.log("Hello World");
-const elapsed = Date.now() - start;
-const rate = Math.floor(count / (elapsed / 1000));
-console.log(`time ${elapsed} ms rate ${rate}`);
diff --git a/cli/bench/encode_into.js b/cli/bench/encode_into.js
@@ -1,19 +1,18 @@
 // 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;
+count = count ? parseInt(count, 10) : 10000000;
 
 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));
+  if (--total) bench(fun);
 }
 
 const encoder = new TextEncoder();

diff --git a/cli/bench/webstorage.js b/cli/bench/webstorage.js
@@ -0,0 +1,21 @@
+// Copyright 2018-2022 the Deno authors. All rights reserved. MIT license.
+
+// Note: when benchmarking across different Deno version, make sure to clear
+// the DENO_DIR cache.
+let [total, count] = typeof Deno !== "undefined" ? Deno.args : [];
+
+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(i);
+  const elapsed = Date.now() - start;
+  const rate = Math.floor(count / (elapsed / 1000));
+  console.log(`time ${elapsed} ms rate ${rate}`);
+  if (--total) queueMicrotask(() => bench(fun));
+}
+
+localStorage.clear();
+localStorage.setItem("foo", "bar");
+bench(() => localStorage.getItem("foo"));
diff --git a/cli/tsc/mod.rs b/cli/tsc/mod.rs
@@ -683,9 +683,9 @@ pub fn resolve_npm_package_reference_types(
 }
 
 #[op]
-fn op_is_node_file(state: &mut OpState, path: String) -> bool {
+fn op_is_node_file(state: &mut OpState, path: &str) -> bool {
   let state = state.borrow::<State>();
-  match ModuleSpecifier::parse(&path) {
+  match ModuleSpecifier::parse(path) {
     Ok(specifier) => state
       .maybe_npm_resolver
       .as_ref()

diff --git a/core/ops_builtin.rs b/core/ops_builtin.rs
@@ -107,7 +107,7 @@ pub fn op_metrics(state: &mut OpState) -> (OpMetrics, Vec<OpMetrics>) {
 
 /// Builtin utility to print to stdout/stderr
 #[op]
-pub fn op_print(msg: String, is_err: bool) -> Result<(), Error> {
+pub fn op_print(msg: &str, is_err: bool) -> Result<(), Error> {
   if is_err {
     stderr().write_all(msg.as_bytes())?;
     stderr().flush().unwrap();
@@ -152,12 +152,12 @@ pub fn op_wasm_streaming_feed(
 pub fn op_wasm_streaming_set_url(
   state: &mut OpState,
   rid: ResourceId,
-  url: String,
+  url: &str,
 ) -> Result<(), Error> {
   let wasm_streaming =
     state.resource_table.get::<WasmStreamingResource>(rid)?;
 
-  wasm_streaming.0.borrow_mut().set_url(&url);
+  wasm_streaming.0.borrow_mut().set_url(url);
 
   Ok(())
 }

diff --git a/ext/node/lib.rs b/ext/node/lib.rs
@@ -262,7 +262,7 @@ fn op_require_proxy_path(filename: String) -> String {
 }
 
 #[op]
-fn op_require_is_request_relative(request: String) -> bool {
+fn op_require_is_request_relative(request: &str) -> bool {
   if request.starts_with("./") || request.starts_with("../") || request == ".."
   {
     return true;

diff --git a/ext/url/00_url.js b/ext/url/00_url.js
@@ -56,12 +56,12 @@
   function opUrlParse(href, maybeBase) {
     let status;
     if (maybeBase === undefined) {
-      status = ops.op_url_parse(href, componentsBuf.buffer);
+      status = ops.op_url_parse(href, componentsBuf);
     } else {
-      status = core.ops.op_url_parse_with_base(
+      status = ops.op_url_parse_with_base(
         href,
         maybeBase,
-        componentsBuf.buffer,
+        componentsBuf,
       );
     }
     return getSerialization(status, href);
@@ -71,7 +71,7 @@
     if (status === 0) {
       return href;
     } else if (status === 1) {
-      return core.ops.op_url_get_serialization();
+      return ops.op_url_get_serialization();
     } else {
       throw new TypeError("Invalid URL");
     }

diff --git a/ext/url/lib.rs b/ext/url/lib.rs
@@ -41,11 +41,11 @@ pub fn init() -> Extension {
 #[op]
 pub fn op_url_parse_with_base(
   state: &mut OpState,
-  href: String,
-  base_href: String,
-  buf: &mut [u8],
+  href: &str,
+  base_href: &str,
+  buf: &mut [u32],
 ) -> u32 {
-  let base_url = match Url::parse(&base_href) {
+  let base_url = match Url::parse(base_href) {
     Ok(url) => url,
     Err(_) => return ParseStatus::Err as u32,
   };
@@ -67,8 +67,8 @@ pub fn op_url_get_serialization(state: &mut OpState) -> String {
 }
 
 /// Parse `href` without a `base_url`. Fills the out `buf` with URL components.
-#[op]
-pub fn op_url_parse(state: &mut OpState, href: String, buf: &mut [u8]) -> u32 {
+#[op(fast)]
+pub fn op_url_parse(state: &mut OpState, href: &str, buf: &mut [u32]) -> u32 {
   parse_url(state, href, None, buf)
 }
 
@@ -99,15 +99,14 @@ pub fn op_url_parse(state: &mut OpState, href: String, buf: &mut [u8]) -> u32 {
 #[inline]
 fn parse_url(
   state: &mut OpState,
-  href: String,
+  href: &str,
   base_href: Option<&Url>,
-  buf: &mut [u8],
+  buf: &mut [u32],
 ) -> u32 {
-  match Url::options().base_url(base_href).parse(&href) {
+  match Url::options().base_url(base_href).parse(href) {
     Ok(url) => {
       let inner_url = quirks::internal_components(&url);
 
-      let buf: &mut [u32] = as_u32_slice(buf);
       buf[0] = inner_url.scheme_end;
       buf[1] = inner_url.username_end;
       buf[2] = inner_url.host_start;

diff --git a/ext/web/blob.rs b/ext/web/blob.rs
@@ -252,9 +252,9 @@ pub fn op_blob_create_object_url(
 #[op]
 pub fn op_blob_revoke_object_url(
   state: &mut deno_core::OpState,
-  url: String,
+  url: &str,
 ) -> Result<(), AnyError> {
-  let url = Url::parse(&url)?;
+  let url = Url::parse(url)?;
   let blob_store = state.borrow::<BlobStore>();
   blob_store.remove_object_url(&url);
   Ok(())

diff --git a/ext/web/compression.rs b/ext/web/compression.rs
@@ -41,11 +41,11 @@ impl Resource for CompressionResource {
 #[op]
 pub fn op_compression_new(
   state: &mut OpState,
-  format: String,
+  format: &str,
   is_decoder: bool,
 ) -> ResourceId {
   let w = Vec::new();
-  let inner = match (format.as_str(), is_decoder) {
+  let inner = match (format, is_decoder) {
     ("deflate", true) => Inner::DeflateDecoder(ZlibDecoder::new(w)),
     ("deflate", false) => {
       Inner::DeflateEncoder(ZlibEncoder::new(w, Compression::default()))

diff --git a/ext/web/lib.rs b/ext/web/lib.rs
@@ -270,7 +270,7 @@ fn op_encoding_decode_single(
 #[op]
 fn op_encoding_new_decoder(
   state: &mut OpState,
-  label: String,
+  label: &str,
   fatal: bool,
   ignore_bom: bool,
 ) -> Result<ResourceId, AnyError> {
@@ -352,25 +352,43 @@ impl Resource for TextDecoderResource {
   }
 }
 
-#[op(v8)]
+#[op]
 fn op_encoding_encode_into(
-  scope: &mut v8::HandleScope,
-  input: serde_v8::Value,
+  input: Cow<'_, str>,
   buffer: &mut [u8],
   out_buf: &mut [u32],
-) -> Result<(), AnyError> {
-  let s = v8::Local::<v8::String>::try_from(input.v8_value)?;
-
-  let mut nchars = 0;
-  out_buf[1] = s.write_utf8(
-    scope,
-    buffer,
-    Some(&mut nchars),
-    v8::WriteOptions::NO_NULL_TERMINATION
-      | v8::WriteOptions::REPLACE_INVALID_UTF8,
-  ) as u32;
-  out_buf[0] = nchars as u32;
-  Ok(())
+) {
+  // 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
+  };
+
+  buffer[..boundary].copy_from_slice(input[..boundary].as_bytes());
+
+  // The `read` output parameter is measured in UTF-16 code units.
+  out_buf[0] = match input {
+    // Borrowed Cow strings are zero-copy views into the V8 heap.
+    // Thus, they are guarantee to be SeqOneByteString.
+    Cow::Borrowed(v) => v[..boundary].len() as u32,
+    Cow::Owned(v) => v[..boundary].encode_utf16().count() as u32,
+  };
+  out_buf[1] = boundary as u32;
 }
 
 #[op(v8)]

diff --git a/ext/webstorage/lib.rs b/ext/webstorage/lib.rs
@@ -139,8 +139,8 @@ pub fn op_webstorage_key(
 #[op]
 pub fn op_webstorage_set(
   state: &mut OpState,
-  key: String,
-  value: String,
+  key: &str,
+  value: &str,
   persistent: bool,
 ) -> Result<(), AnyError> {
   let conn = get_webstorage(state, persistent)?;
@@ -184,7 +184,7 @@ pub fn op_webstorage_get(
 #[op]
 pub fn op_webstorage_remove(
   state: &mut OpState,
-  key_name: String,
+  key_name: &str,
   persistent: bool,
 ) -> Result<(), AnyError> {
   let conn = get_webstorage(state, persistent)?;

diff --git a/ops/fast_call.rs b/ops/fast_call.rs
@@ -403,7 +403,9 @@ fn q_fast_ty(v: &FastValue) -> Quote {
     FastValue::F64 => q!({ f64 }),
     FastValue::Bool => q!({ bool }),
     FastValue::V8Value => q!({ v8::Local<v8::Value> }),
-    FastValue::Uint8Array | FastValue::Uint32Array => unreachable!(),
+    FastValue::Uint8Array
+    | FastValue::Uint32Array
+    | FastValue::SeqOneByteString => unreachable!(),
   }
 }
 
@@ -421,6 +423,7 @@ fn q_fast_ty_variant(v: &FastValue) -> Quote {
     FastValue::V8Value => q!({ V8Value }),
     FastValue::Uint8Array => q!({ TypedArray(CType::Uint8) }),
     FastValue::Uint32Array => q!({ TypedArray(CType::Uint32) }),
+    FastValue::SeqOneByteString => q!({ SeqOneByteString }),
   }
 }
 

diff --git a/ops/lib.rs b/ops/lib.rs
@@ -400,14 +400,31 @@ fn codegen_arg(
     return quote! { let #ident = (); };
   }
   // Fast path for `String`
-  if is_string(&**ty) {
+  if let Some(is_ref) = is_string(&**ty) {
+    let ref_block = if is_ref {
+      quote! { let #ident = #ident.as_ref(); }
+    } else {
+      quote! {}
+    };
     return quote! {
       let #ident = match #core::v8::Local::<#core::v8::String>::try_from(args.get(#idx as i32)) {
         Ok(v8_string) => #core::serde_v8::to_utf8(v8_string, scope),
         Err(_) => {
           return #core::_ops::throw_type_error(scope, format!("Expected string at position {}", #idx));
         }
       };
+      #ref_block
+    };
+  }
+  // Fast path for `Cow<'_, str>`
+  if is_cow_str(&**ty) {
+    return quote! {
+      let #ident = match #core::v8::Local::<#core::v8::String>::try_from(args.get(#idx as i32)) {
+        Ok(v8_string) => ::std::borrow::Cow::Owned(#core::serde_v8::to_utf8(v8_string, scope)),
+        Err(_) => {
+          return #core::_ops::throw_type_error(scope, format!("Expected string at position {}", #idx));
+        }
+      };
     };
   }
   // Fast path for `Option<String>`
@@ -618,14 +635,25 @@ fn is_result(ty: impl ToTokens) -> bool {
   }
 }
 
-fn is_string(ty: impl ToTokens) -> bool {
-  tokens(ty) == "String"
+fn is_string(ty: impl ToTokens) -> Option<bool> {
+  let toks = tokens(ty);
+  if toks == "String" {
+    return Some(false);
+  }
+  if toks == "& str" {
+    return Some(true);
+  }
+  None
 }
 
 fn is_option_string(ty: impl ToTokens) -> bool {
   tokens(ty) == "Option < String >"
 }
 
+fn is_cow_str(ty: impl ToTokens) -> bool {
+  tokens(&ty).starts_with("Cow <") && tokens(&ty).ends_with("str >")
+}
+
 enum SliceType {
   U8,
   U8Mut,