perf(core): generate inlined wrappers for async ops (denoland#16428)

V8's JIT can do a better job knowing the argument count and also enable fast call path (in future). This also lets us call async ops without `opAsync`: ```js const { ops } = Deno.core; await ops.op_void_async(); ``` this patch: 4405286 ops/sec main: 3508771 ops/sec
DavidDeSimone · Oct 27, 2022 · 0218796 · 0218796
1 parent bfd9912
commit 0218796
Show file tree

Hide file tree

Showing 10 changed files with 266 additions and 113 deletions.
diff --git a/bench_util/js_runtime.rs b/bench_util/js_runtime.rs
@@ -63,7 +63,6 @@ pub fn bench_js_sync_with(
 
   let code = v8::String::new(scope, looped_src.as_ref()).unwrap();
   let script = v8::Script::compile(scope, code, None).unwrap();
-
   // Run once if profiling, otherwise regular bench loop
   if is_profiling() {
     script.run(scope).unwrap();
@@ -102,7 +101,9 @@ pub fn bench_js_async_with(
   };
   let looped = loop_code(inner_iters, src);
   let src = looped.as_ref();
-
+  runtime
+    .execute_script("init", "Deno.core.initializeAsyncOps();")
+    .unwrap();
   if is_profiling() {
     for _ in 0..opts.profiling_outer {
       tokio_runtime.block_on(inner_async(src, &mut runtime));

diff --git a/cli/bench/async_ops.js b/cli/bench/async_ops.js
@@ -5,7 +5,7 @@ let [total, count] = typeof Deno !== "undefined"
   : [process.argv[2], process.argv[3]];
 
 total = total ? parseInt(total, 0) : 50;
-count = count ? parseInt(count, 10) : 100000;
+count = count ? parseInt(count, 10) : 1000000;
 
 async function bench(fun) {
   const start = Date.now();
@@ -16,4 +16,5 @@ async function bench(fun) {
   if (--total) queueMicrotask(() => bench(fun));
 }
 
-bench(() => Deno.core.opAsync("op_void_async"));
+const { ops } = Deno.core;
+bench(() => ops.op_void_async());
diff --git a/cli/tests/unit/metrics_test.ts b/cli/tests/unit/metrics_test.ts
@@ -84,6 +84,6 @@ Deno.test(function opNamesMatch() {
     // @ts-ignore: Deno.core allowed
     Deno.core.opNames().sort(),
     // @ts-ignore: Deno.core allowed
-    Object.keys(Deno.core.ops).sort(),
+    Object.keys(Deno.core.ops).sort().filter((name) => name !== "asyncOpsInfo"),
   );
 });
diff --git a/core/01_core.js b/core/01_core.js
@@ -28,7 +28,7 @@
     SymbolFor,
     setQueueMicrotask,
   } = window.__bootstrap.primordials;
-  const ops = window.Deno.core.ops;
+  const { ops } = window.Deno.core;
 
   const errorMap = {};
   // Builtin v8 / JS errors
@@ -159,31 +159,74 @@
     return res;
   }
 
-  function opAsync(opName, ...args) {
-    const promiseId = nextPromiseId++;
-    let p = setPromise(promiseId);
-    try {
-      ops[opName](promiseId, ...args);
-    } catch (err) {
-      // Cleanup the just-created promise
-      getPromise(promiseId);
-      // Rethrow the error
-      throw err;
+  function rollPromiseId() {
+    return nextPromiseId++;
+  }
+
+  // Generate async op wrappers. See core/bindings.rs
+  function initializeAsyncOps() {
+    function genAsyncOp(op, name, args) {
+      return new Function(
+        "setPromise",
+        "getPromise",
+        "promiseIdSymbol",
+        "rollPromiseId",
+        "handleOpCallTracing",
+        "op",
+        "unwrapOpResult",
+        "PromisePrototypeThen",
+        `
+        return function ${name}(${args}) {
+          const id = rollPromiseId();
+          let promise = PromisePrototypeThen(setPromise(id), unwrapOpResult);
+          try {
+            op(id, ${args});
+          } catch (err) {
+            // Cleanup the just-created promise
+            getPromise(id);
+            // Rethrow the error
+            throw err;
+          }
+          handleOpCallTracing("${name}", id, promise);
+          promise[promiseIdSymbol] = id;          
+          return promise;
+        }
+      `,
+      )(
+        setPromise,
+        getPromise,
+        promiseIdSymbol,
+        rollPromiseId,
+        handleOpCallTracing,
+        op,
+        unwrapOpResult,
+        PromisePrototypeThen,
+      );
     }
-    p = PromisePrototypeThen(p, unwrapOpResult);
+
+    // { <name>: <argc>, ... }
+    for (const ele of Object.entries(ops.asyncOpsInfo())) {
+      if (!ele) continue;
+      const [name, argc] = ele;
+      const op = ops[name];
+      const args = Array.from({ length: argc }, (_, i) => `arg${i}`).join(", ");
+      ops[name] = genAsyncOp(op, name, args);
+    }
+  }
+
+  function handleOpCallTracing(opName, promiseId, p) {
     if (opCallTracingEnabled) {
-      // Capture a stack trace by creating a new `Error` object. We remove the
-      // first 6 characters (the `Error\n` prefix) to get just the stack trace.
       const stack = StringPrototypeSlice(new Error().stack, 6);
       MapPrototypeSet(opCallTraces, promiseId, { opName, stack });
       p = PromisePrototypeFinally(
         p,
         () => MapPrototypeDelete(opCallTraces, promiseId),
       );
     }
-    // Save the id on the promise so it can later be ref'ed or unref'ed
-    p[promiseIdSymbol] = promiseId;
-    return p;
+  }
+
+  function opAsync(opName, ...args) {
+    return ops[opName](...args);
   }
 
   function refOp(promiseId) {
@@ -303,6 +346,7 @@
   // Extra Deno.core.* exports
   const core = ObjectAssign(globalThis.Deno.core, {
     opAsync,
+    initializeAsyncOps,
     resources,
     metrics,
     registerErrorBuilder,
@@ -322,11 +366,11 @@
     setPromiseHooks,
     close: (rid) => ops.op_close(rid),
     tryClose: (rid) => ops.op_try_close(rid),
-    read: opAsync.bind(null, "op_read"),
-    readAll: opAsync.bind(null, "op_read_all"),
-    write: opAsync.bind(null, "op_write"),
-    writeAll: opAsync.bind(null, "op_write_all"),
-    shutdown: opAsync.bind(null, "op_shutdown"),
+    read: (rid, buffer) => ops.op_read(rid, buffer),
+    readAll: (rid) => ops.op_read_all(rid),
+    write: (rid, buffer) => ops.op_write(rid, buffer),
+    writeAll: (rid, buffer) => ops.op_write_all(rid, buffer),
+    shutdown: (rid) => ops.op_shutdown(rid),
     print: (msg, isErr) => ops.op_print(msg, isErr),
     setMacrotaskCallback: (fn) => ops.op_set_macrotask_callback(fn),
     setNextTickCallback: (fn) => ops.op_set_next_tick_callback(fn),

diff --git a/core/bindings.rs b/core/bindings.rs
@@ -97,6 +97,7 @@ pub fn initialize_context<'s>(
   scope: &mut v8::HandleScope<'s, ()>,
   op_ctxs: &[OpCtx],
   snapshot_loaded: bool,
+  will_snapshot: bool,
 ) -> v8::Local<'s, v8::Context> {
   let scope = &mut v8::EscapableHandleScope::new(scope);
 
@@ -116,7 +117,9 @@ pub fn initialize_context<'s>(
     let ops_obj = JsRuntime::grab_global::<v8::Object>(scope, "Deno.core.ops")
       .expect("Deno.core.ops to exist");
     initialize_ops(scope, ops_obj, op_ctxs, snapshot_loaded);
-
+    if !will_snapshot {
+      initialize_async_ops_info(scope, ops_obj, op_ctxs);
+    }
     return scope.escape(context);
   }
 
@@ -128,8 +131,10 @@ pub fn initialize_context<'s>(
 
   // Bind functions to Deno.core.ops.*
   let ops_obj = JsRuntime::ensure_objs(scope, global, "Deno.core.ops").unwrap();
-
-  initialize_ops(scope, ops_obj, op_ctxs, snapshot_loaded);
+  if !will_snapshot {
+    initialize_async_ops_info(scope, ops_obj, op_ctxs);
+  }
+  initialize_ops(scope, ops_obj, op_ctxs, !will_snapshot);
   scope.escape(context)
 }
 
@@ -590,3 +595,84 @@ pub fn throw_type_error(scope: &mut v8::HandleScope, message: impl AsRef<str>) {
   let exception = v8::Exception::type_error(scope, message);
   scope.throw_exception(exception);
 }
+
+struct AsyncOpsInfo {
+  ptr: *const OpCtx,
+  len: usize,
+}
+
+impl<'s> IntoIterator for &'s AsyncOpsInfo {
+  type Item = &'s OpCtx;
+  type IntoIter = AsyncOpsInfoIterator<'s>;
+
+  fn into_iter(self) -> Self::IntoIter {
+    AsyncOpsInfoIterator {
+      // SAFETY: OpCtx slice is valid for the lifetime of the Isolate
+      info: unsafe { std::slice::from_raw_parts(self.ptr, self.len) },
+      index: 0,
+    }
+  }
+}
+
+struct AsyncOpsInfoIterator<'s> {
+  info: &'s [OpCtx],
+  index: usize,
+}
+
+impl<'s> Iterator for AsyncOpsInfoIterator<'s> {
+  type Item = &'s OpCtx;
+
+  fn next(&mut self) -> Option<Self::Item> {
+    loop {
+      match self.info.get(self.index) {
+        Some(ctx) if ctx.decl.is_async => {
+          self.index += 1;
+          return Some(ctx);
+        }
+        Some(_) => {
+          self.index += 1;
+        }
+        None => return None,
+      }
+    }
+  }
+}
+
+fn async_ops_info(
+  scope: &mut v8::HandleScope,
+  args: v8::FunctionCallbackArguments,
+  mut rv: v8::ReturnValue,
+) {
+  let async_op_names = v8::Object::new(scope);
+  let external: v8::Local<v8::External> = args.data().try_into().unwrap();
+  let info: &AsyncOpsInfo =
+    // SAFETY: external is guaranteed to be a valid pointer to AsyncOpsInfo
+    unsafe { &*(external.value() as *const AsyncOpsInfo) };
+  for ctx in info {
+    let name = v8::String::new(scope, ctx.decl.name).unwrap();
+    let argc = v8::Integer::new(scope, ctx.decl.argc as i32);
+    async_op_names.set(scope, name.into(), argc.into());
+  }
+  rv.set(async_op_names.into());
+}
+
+fn initialize_async_ops_info(
+  scope: &mut v8::HandleScope,
+  ops_obj: v8::Local<v8::Object>,
+  op_ctxs: &[OpCtx],
+) {
+  let key = v8::String::new(scope, "asyncOpsInfo").unwrap();
+  let external = v8::External::new(
+    scope,
+    Box::into_raw(Box::new(AsyncOpsInfo {
+      ptr: op_ctxs as *const [OpCtx] as _,
+      len: op_ctxs.len(),
+    })) as *mut c_void,
+  );
+  let val = v8::Function::builder(async_ops_info)
+    .data(external.into())
+    .build(scope)
+    .unwrap();
+  val.set_name(key);
+  ops_obj.set(scope, key.into(), val.into());
+}
diff --git a/core/examples/http_bench_json_ops.js b/core/examples/http_bench_json_ops.js
@@ -2,6 +2,8 @@
 // This is not a real HTTP server. We read blindly one time into 'requestBuf',
 // then write this fixed 'responseBuf'. The point of this benchmark is to
 // exercise the event loop in a simple yet semi-realistic way.
+Deno.core.initializeAsyncOps();
+
 const requestBuf = new Uint8Array(64 * 1024);
 const responseBuf = new Uint8Array(
   "HTTP/1.1 200 OK\r\nContent-Length: 12\r\n\r\nHello World\n"
@@ -16,7 +18,7 @@ function listen() {
 
 /** Accepts a connection, returns rid. */
 function accept(serverRid) {
-  return Deno.core.opAsync("op_accept", serverRid);
+  return Deno.core.ops.op_accept(serverRid);
 }
 
 async function serve(rid) {

diff --git a/core/extensions.rs b/core/extensions.rs
@@ -16,6 +16,9 @@ pub struct OpDecl {
   pub enabled: bool,
   pub is_async: bool,
   pub is_unstable: bool,
+  /// V8 argument count. Used as an optimization
+  /// hint by `core.initalizeAsyncOps`.
+  pub argc: usize,
   pub is_v8: bool,
   pub fast_fn: Option<Box<dyn FastFunction>>,
 }