From 09ae512ccb4d8a36a0c6c1a700b48fdd3f9fc6c2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bartek=20Iwa=C5=84czuk?= <biwanczuk@gmail.com>
Date: Fri, 11 Mar 2022 23:07:02 +0100
Subject: feat: "deno bench" subcommand (#13713)

This commit adds "deno bench" subcommand and "Deno.bench()"
API that allows to register bench cases.

The API is modelled after "Deno.test()" and "deno test" subcommand.

Currently the output is rudimentary and bench cases and not
subject to "ops" and "resource" sanitizers.

Co-authored-by: evan <github@evan.lol>
---
 cli/ops/bench.rs | 99 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 cli/ops/mod.rs   |  1 +
 2 files changed, 100 insertions(+)
 create mode 100644 cli/ops/bench.rs

(limited to 'cli/ops')

diff --git a/cli/ops/bench.rs b/cli/ops/bench.rs
new file mode 100644
index 000000000..b535e1236
--- /dev/null
+++ b/cli/ops/bench.rs
@@ -0,0 +1,99 @@
+use crate::tools::bench::BenchEvent;
+use deno_core::error::generic_error;
+use deno_core::error::AnyError;
+use deno_core::op_sync;
+use deno_core::Extension;
+use deno_core::ModuleSpecifier;
+use deno_core::OpState;
+use deno_runtime::permissions::create_child_permissions;
+use deno_runtime::permissions::ChildPermissionsArg;
+use deno_runtime::permissions::Permissions;
+use std::time;
+use tokio::sync::mpsc::UnboundedSender;
+use uuid::Uuid;
+
+pub fn init(sender: UnboundedSender<BenchEvent>) -> Extension {
+  Extension::builder()
+    .ops(vec![
+      (
+        "op_pledge_test_permissions",
+        op_sync(op_pledge_test_permissions),
+      ),
+      (
+        "op_restore_test_permissions",
+        op_sync(op_restore_test_permissions),
+      ),
+      ("op_get_bench_origin", op_sync(op_get_bench_origin)),
+      ("op_dispatch_bench_event", op_sync(op_dispatch_bench_event)),
+      ("op_bench_now", op_sync(op_bench_now)),
+    ])
+    .state(move |state| {
+      state.put(sender.clone());
+      Ok(())
+    })
+    .build()
+}
+
+#[derive(Clone)]
+struct PermissionsHolder(Uuid, Permissions);
+
+pub fn op_pledge_test_permissions(
+  state: &mut OpState,
+  args: ChildPermissionsArg,
+  _: (),
+) -> Result<Uuid, AnyError> {
+  let token = Uuid::new_v4();
+  let parent_permissions = state.borrow_mut::<Permissions>();
+  let worker_permissions = create_child_permissions(parent_permissions, args)?;
+  let parent_permissions = parent_permissions.clone();
+
+  state.put::<PermissionsHolder>(PermissionsHolder(token, parent_permissions));
+
+  // NOTE: This call overrides current permission set for the worker
+  state.put::<Permissions>(worker_permissions);
+
+  Ok(token)
+}
+
+pub fn op_restore_test_permissions(
+  state: &mut OpState,
+  token: Uuid,
+  _: (),
+) -> Result<(), AnyError> {
+  if let Some(permissions_holder) = state.try_take::<PermissionsHolder>() {
+    if token != permissions_holder.0 {
+      panic!("restore test permissions token does not match the stored token");
+    }
+
+    let permissions = permissions_holder.1;
+    state.put::<Permissions>(permissions);
+    Ok(())
+  } else {
+    Err(generic_error("no permissions to restore"))
+  }
+}
+
+fn op_get_bench_origin(
+  state: &mut OpState,
+  _: (),
+  _: (),
+) -> Result<String, AnyError> {
+  Ok(state.borrow::<ModuleSpecifier>().to_string())
+}
+
+fn op_dispatch_bench_event(
+  state: &mut OpState,
+  event: BenchEvent,
+  _: (),
+) -> Result<(), AnyError> {
+  let sender = state.borrow::<UnboundedSender<BenchEvent>>().clone();
+  sender.send(event).ok();
+
+  Ok(())
+}
+
+fn op_bench_now(state: &mut OpState, _: (), _: ()) -> Result<u64, AnyError> {
+  let ns = state.borrow::<time::Instant>().elapsed().as_nanos();
+  let ns_u64 = u64::try_from(ns)?;
+  Ok(ns_u64)
+}
diff --git a/cli/ops/mod.rs b/cli/ops/mod.rs
index 34b310b20..05f1426ec 100644
--- a/cli/ops/mod.rs
+++ b/cli/ops/mod.rs
@@ -3,6 +3,7 @@
 use crate::proc_state::ProcState;
 use deno_core::Extension;
 
+pub mod bench;
 mod errors;
 mod runtime_compiler;
 pub mod testing;
-- 
cgit v1.2.3