1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-12-24 16:19:12 -05:00
denoland-deno/ops
Matt Mastracci 8fe9b8a4cc
refactor(ops): ops2 supports result in fast path (#19603)
Implements `Result` in fast-calls. Note that the approach here is
slightly different. Rather than store the last result in the `OpState`,
we put it into the `OpCtx` which saves us a lookup and lock in the error
case. We do not have to lock this field as it's guaranteed only one
runtime and thread can ever access it.

The fastcall path for many ops can avoid doing a great deal of work,
even for `Result` return values. In the previous iteration of `ops`, all
`Result`-returning functions would fetch and lock the `OpState`,
regardless of whether it was used or not.
2023-06-25 16:36:09 +02:00
..
op2 refactor(ops): ops2 supports result in fast path (#19603) 2023-06-25 16:36:09 +02:00
optimizer_tests refactor(core): remove force_op_registration and cleanup JsRuntimeForSnapshot (#19353) 2023-06-03 14:22:32 -06:00
tests/compile_fail fix(ops): disallow memory slices as inputs to async ops (#16738) 2023-01-15 07:40:01 +00:00
attrs.rs feat(ops): relational ops (#18023) 2023-03-05 13:30:22 +05:30
Cargo.toml refactor(ops): Adding op2 macro and implementing in a couple of places (#19534) 2023-06-24 13:54:10 +02:00
deno.rs chore: use rustfmt imports_granularity option (#17421) 2023-01-14 23:18:58 -05:00
fast_call.rs refactor(core): simplify op types and codegeneration (#18843) 2023-04-26 20:02:27 +02:00
lib.rs refactor(ops): Adding op2 macro and implementing in a couple of places (#19534) 2023-06-24 13:54:10 +02:00
optimizer.rs perf(ops): directly respond for eager ops (#18683) 2023-04-13 14:32:47 +02:00
README.md feat(ops): fast calls for Wasm (#16776) 2022-11-27 19:24:28 +05:30

deno_ops

proc_macro for generating highly optimized V8 functions from Deno ops.

// Declare an op.
#[op(fast)]
pub fn op_add(_: &mut OpState, a: i32, b: i32) -> i32 {
  a + b
}

// Register with an extension.
Extension::builder()
  .ops(vec![op_add::decl()])
  .build();

Performance

The macro can optimize away code, short circuit fast paths and generate a Fast API impl.

Cases where code is optimized away:

  • -> () skips serde_v8 and rv.set calls.
  • -> Result<(), E> skips serde_v8 and rv.set calls for Ok() branch.
  • -> ResourceId or -> [int] types will use specialized method like v8::ReturnValue::set_uint32. A fast path for SMI.
  • -> Result<ResourceId, E> or -> Result<[int], E> types will be optimized like above for the Ok() branch.

Fast calls

The macro will infer and try to auto generate V8 fast API call trait impl for sync ops with:

  • arguments: integers, bool, &mut OpState, &[u8], &mut [u8], &[u32], &mut [u32]
  • return_type: integers, bool

The #[op(fast)] attribute should be used to enforce fast call generation at compile time.

Trait gen for async ops & a ZeroCopyBuf equivalent type is planned and will be added soon.

Wasm calls

The #[op(wasm)] attribute should be used for calls expected to be called from Wasm. This enables the fast call generation and allows seamless WasmMemory integration for generic and fast calls.

#[op(wasm)]
pub fn op_args_get(
  offset: i32,
  buffer_offset: i32,
  memory: Option<&[u8]>, // Must be last parameter. Some(..) when entered from Wasm.
) {
  // ...
}