perf(core/ops): avoid allocs when returning primitives (denoland#10149)

core/benches/op_baseline.rs

@@ -3,10 +3,10 @@ use bencher::{benchmark_group, benchmark_main, Bencher};
 use deno_core::error::AnyError;
 use deno_core::op_async;
 use deno_core::op_sync;
+use deno_core::serialize_op_result;
 use deno_core::v8;
 use deno_core::JsRuntime;
 use deno_core::Op;
-use deno_core::OpResponse;
 use deno_core::OpState;
 use deno_core::ZeroCopyBuf;
 
@@ -17,8 +17,9 @@ fn create_js_runtime() -> JsRuntime {
  let mut runtime = JsRuntime::new(Default::default());
  runtime.register_op("pi_json", op_sync(|_, _: (), _| Ok(314159)));
  runtime.register_op("pi_async", op_async(op_pi_async));
- runtime
- .register_op("nop", |_, _, _| Op::Sync(OpResponse::Value(Box::new(9))));
+ runtime.register_op("nop", |state, _, _| {
+ Op::Sync(serialize_op_result(Ok(9), state))
+ });
 
  // Init ops
  runtime

core/lib.rs

@@ -5,6 +5,7 @@ mod bindings;
 pub mod error;
 mod flags;
 mod gotham_state;
+mod minvalue;
 mod module_specifier;
 mod modules;
 mod normalize_path;

core/minvalue.rs

@@ -0,0 +1,95 @@
+use rusty_v8 as v8;
+use std::any::TypeId;
+
+/// SerializablePkg exists to provide a fast path for op returns,
+/// allowing them to avoid boxing primtives (ints/floats/bool/unit/...)
+pub enum SerializablePkg {
+ MinValue(MinValue),
+ Serializable(Box<dyn serde_v8::Serializable>),
+}
+
+impl SerializablePkg {
+ pub fn to_v8<'a>(
+ &self,
+ scope: &mut v8::HandleScope<'a>,
+ ) -> Result<v8::Local<'a, v8::Value>, serde_v8::Error> {
+ match &*self {
+ Self::MinValue(x) => serde_v8::to_v8(scope, x),
+ Self::Serializable(x) => x.to_v8(scope),
+ }
+ }
+}
+
+/// MinValue serves as a lightweight serializable wrapper around primitives
+/// so that we can use them for async values
+#[derive(Clone, Copy)]
+pub enum MinValue {
+ Unit(()),
+ Bool(bool),
+ Int8(i8),
+ Int16(i16),
+ Int32(i32),
+ Int64(i64),
+ UInt8(u8),
+ UInt16(u16),
+ UInt32(u32),
+ UInt64(u64),
+ Float32(f32),
+ Float64(f64),
+}
+
+impl serde::Serialize for MinValue {
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: serde::Serializer,
+ {
+ match *self {
+ Self::Unit(_) => serializer.serialize_unit(),
+ Self::Bool(x) => serializer.serialize_bool(x),
+ Self::Int8(x) => serializer.serialize_i8(x),
+ Self::Int16(x) => serializer.serialize_i16(x),
+ Self::Int32(x) => serializer.serialize_i32(x),
+ Self::Int64(x) => serializer.serialize_i64(x),
+ Self::UInt8(x) => serializer.serialize_u8(x),
+ Self::UInt16(x) => serializer.serialize_u16(x),
+ Self::UInt32(x) => serializer.serialize_u32(x),
+ Self::UInt64(x) => serializer.serialize_u64(x),
+ Self::Float32(x) => serializer.serialize_f32(x),
+ Self::Float64(x) => serializer.serialize_f64(x),
+ }
+ }
+}
+
+impl<T: serde::Serialize + 'static> From<T> for SerializablePkg {
+ fn from(x: T) -> Self {
+ let tid = TypeId::of::<T>();
+
+ if tid == TypeId::of::<()>() {
+ Self::MinValue(MinValue::Unit(()))
+ } else if tid == TypeId::of::<bool>() {
+ Self::MinValue(MinValue::Bool(unsafe { std::mem::transmute_copy(&x) }))
+ } else if tid == TypeId::of::<i8>() {
+ Self::MinValue(MinValue::Int8(unsafe { std::mem::transmute_copy(&x) }))
+ } else if tid == TypeId::of::<i16>() {
+ Self::MinValue(MinValue::Int16(unsafe { std::mem::transmute_copy(&x) }))
+ } else if tid == TypeId::of::<i32>() {
+ Self::MinValue(MinValue::Int32(unsafe { std::mem::transmute_copy(&x) }))
+ } else if tid == TypeId::of::<i64>() {
+ Self::MinValue(MinValue::Int64(unsafe { std::mem::transmute_copy(&x) }))
+ } else if tid == TypeId::of::<u8>() {
+ Self::MinValue(MinValue::UInt8(unsafe { std::mem::transmute_copy(&x) }))
+ } else if tid == TypeId::of::<u16>() {
+ Self::MinValue(MinValue::UInt16(unsafe { std::mem::transmute_copy(&x) }))
+ } else if tid == TypeId::of::<u32>() {
+ Self::MinValue(MinValue::UInt32(unsafe { std::mem::transmute_copy(&x) }))
+ } else if tid == TypeId::of::<u64>() {
+ Self::MinValue(MinValue::UInt64(unsafe { std::mem::transmute_copy(&x) }))
+ } else if tid == TypeId::of::<f32>() {
+ Self::MinValue(MinValue::Float32(unsafe { std::mem::transmute_copy(&x) }))
+ } else if tid == TypeId::of::<f64>() {
+ Self::MinValue(MinValue::Float64(unsafe { std::mem::transmute_copy(&x) }))
+ } else {
+ Self::Serializable(Box::new(x))
+ }
+ }
+}

core/ops.rs

@@ -4,6 +4,7 @@ use crate::error::bad_resource_id;
 use crate::error::type_error;
 use crate::error::AnyError;
 use crate::gotham_state::GothamState;
+use crate::minvalue::SerializablePkg;
 use crate::resources::ResourceId;
 use crate::resources::ResourceTable;
 use crate::runtime::GetErrorClassFn;
@@ -61,7 +62,7 @@ impl<'a, 'b, 'c> OpPayload<'a, 'b, 'c> {
 }
 
 pub enum OpResponse {
- Value(Box<dyn serde_v8::Serializable>),
+ Value(OpResult),
  Buffer(Box<[u8]>),
 }
 
@@ -74,13 +75,23 @@ pub enum Op {
  NotFound,
 }
 
-#[derive(Serialize)]
-#[serde(untagged)]
-pub enum OpResult<R> {
- Ok(R),
+pub enum OpResult {
+ Ok(SerializablePkg),
  Err(OpError),
 }
 
+impl OpResult {
+ pub fn to_v8<'a>(
+ &self,
+ scope: &mut v8::HandleScope<'a>,
+ ) -> Result<v8::Local<'a, v8::Value>, serde_v8::Error> {
+ match self {
+ Self::Ok(x) => x.to_v8(scope),
+ Self::Err(err) => serde_v8::to_v8(scope, err),
+ }
+ }
+}
+
 #[derive(Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct OpError {
@@ -93,13 +104,13 @@ pub fn serialize_op_result<R: Serialize + 'static>(
  result: Result<R, AnyError>,
  state: Rc<RefCell<OpState>>,
 ) -> OpResponse {
- OpResponse::Value(Box::new(match result {
- Ok(v) => OpResult::Ok(v),
+ OpResponse::Value(match result {
+ Ok(v) => OpResult::Ok(v.into()),
  Err(err) => OpResult::Err(OpError {
  class_name: (state.borrow().get_error_class_fn)(&err),
  message: err.to_string(),
  }),
- }))
+ })
 }
 
 /// Maintains the resources and ops inside a JS runtime.

core/runtime.rs

@@ -1501,18 +1501,19 @@ pub mod tests {
  }
 
  fn dispatch(
- op_state: Rc<RefCell<OpState>>,
+ rc_op_state: Rc<RefCell<OpState>>,
  payload: OpPayload,
  buf: Option<ZeroCopyBuf>,
  ) -> Op {
- let op_state_ = op_state.borrow();
+ let rc_op_state2 = rc_op_state.clone();
+ let op_state_ = rc_op_state2.borrow();
  let test_state = op_state_.borrow::<TestState>();
  test_state.dispatch_count.fetch_add(1, Ordering::Relaxed);
  match test_state.mode {
  Mode::Async => {
  let control: u8 = payload.deserialize().unwrap();
  assert_eq!(control, 42);
- let resp = (0, OpResponse::Value(Box::new(43)));
+ let resp = (0, serialize_op_result(Ok(43), rc_op_state));
  Op::Async(Box::pin(futures::future::ready(resp)))
  }
  Mode::AsyncUnref => {
@@ -1521,7 +1522,7 @@ pub mod tests {
  let fut = async {
  // This future never finish.
  futures::future::pending::<()>().await;
- (0, OpResponse::Value(Box::new(43)))
+ (0, serialize_op_result(Ok(43), rc_op_state))
  };
  Op::AsyncUnref(Box::pin(fut))
  }
@@ -1531,7 +1532,7 @@ pub mod tests {
  assert_eq!(buf.len(), 1);
  }
 
- let resp = OpResponse::Value(Box::new(43));
+ let resp = serialize_op_result(Ok(43), rc_op_state);
  Op::Async(Box::pin(futures::future::ready((0, resp))))
  }
  }
@@ -1972,11 +1973,11 @@ pub mod tests {
  let dispatch_count = Arc::new(AtomicUsize::new(0));
  let dispatch_count_ = dispatch_count.clone();
 
- let dispatcher = move |_state, payload: OpPayload, _buf| -> Op {
+ let dispatcher = move |state, payload: OpPayload, _buf| -> Op {
  dispatch_count_.fetch_add(1, Ordering::Relaxed);
  let control: u8 = payload.deserialize().unwrap();
  assert_eq!(control, 42);
- let resp = (0, OpResponse::Value(Box::new(43)));
+ let resp = (0, serialize_op_result(Ok(43), state));
  Op::Async(Box::pin(futures::future::ready(resp)))
  };