v8, v2: reuse reducer arguments DataView across calls

Author: Centril

crates/core/src/host/v8/mod.rs

@@ -52,8 +52,8 @@ use tokio::sync::oneshot;
 use tracing::Instrument;
 use v8::script_compiler::{compile_module, Source};
 use v8::{
-    scope_with_context, Context, Function, Isolate, Local, MapFnTo, OwnedIsolate, PinScope, ResolveModuleCallback,
-    ScriptOrigin, Value,
+    scope_with_context, ArrayBuffer, Context, Function, Isolate, Local, MapFnTo, OwnedIsolate, PinScope,
+    ResolveModuleCallback, ScriptOrigin, Value,
 };
 
 mod budget;
@@ -615,10 +615,17 @@ async fn spawn_instance_worker(
         let instance_env = InstanceEnv::new(replica_ctx.clone(), scheduler);
         scope.set_slot(JsInstanceEnv::new(instance_env));
 
+        // Create a zero-initialized buffer for holding reducer args.
+        // Arguments needing more space will not use this.
+        const REDUCER_ARGS_BUFFER_SIZE: usize = 4_096; // 1 page.
+        let buf = ArrayBuffer::new(scope, REDUCER_ARGS_BUFFER_SIZE);
+        let reducer_args_data_view = v8::DataView::new(scope, buf, 0, buf.byte_length());
+
         let mut inst = V8Instance {
             scope,
             replica_ctx,
             hooks: &hooks,
+            reducer_args_data_view,
         };
 
         // Process requests to the worker.
@@ -807,7 +814,8 @@ fn call_free_fun<'scope>(
 struct V8Instance<'a, 'scope, 'isolate> {
     scope: &'a mut PinScope<'scope, 'isolate>,
     replica_ctx: &'a Arc<ReplicaContext>,
-    hooks: &'a HookFunctions<'a>,
+    hooks: &'a HookFunctions<'scope>,
+    reducer_args_data_view: Local<'scope, v8::DataView>,
 }
 
 impl WasmInstance for V8Instance<'_, '_, '_> {
@@ -825,7 +833,7 @@ impl WasmInstance for V8Instance<'_, '_, '_> {
 
     fn call_reducer(&mut self, op: ReducerOp<'_>, budget: FunctionBudget) -> ReducerExecuteResult {
         common_call(self.scope, budget, op, |scope, op| {
-            Ok(call_call_reducer(scope, self.hooks, op)?)
+            Ok(call_call_reducer(scope, self.hooks, op, self.reducer_args_data_view)?)
         })
         .map_result(|call_result| call_result.and_then(|res| res.map_err(ExecutionError::User)))
     }
@@ -975,7 +983,9 @@ mod test {
                     timestamp: Timestamp::from_micros_since_unix_epoch(24),
                     args: &ArgsTuple::nullary(),
                 };
-                Ok(call_call_reducer(scope, &hooks, op)?)
+                let buffer = v8::ArrayBuffer::new(scope, 4096);
+                let data_view = v8::DataView::new(scope, buffer, 0, 4096);
+                Ok(call_call_reducer(scope, &hooks, op, data_view)?)
             })
         };
 

crates/core/src/host/v8/syscall/mod.rs

@@ -74,14 +74,15 @@ fn resolve_sys_module_inner<'scope>(
 /// Calls the registered `__call_reducer__` function hook.
 ///
 /// This handles any (future) ABI version differences.
-pub(super) fn call_call_reducer(
-    scope: &mut PinScope<'_, '_>,
-    hooks: &HookFunctions<'_>,
+pub(super) fn call_call_reducer<'scope>(
+    scope: &mut PinScope<'scope, '_>,
+    hooks: &HookFunctions<'scope>,
     op: ReducerOp<'_>,
+    reducer_args_data_view: Local<'scope, v8::DataView>,
 ) -> ExcResult<ReducerResult> {
     match hooks.abi {
         AbiVersion::V1 => v1::call_call_reducer(scope, hooks, op),
-        AbiVersion::V2 => v2::call_call_reducer(scope, hooks, op),
+        AbiVersion::V2 => v2::call_call_reducer(scope, hooks, op, reducer_args_data_view),
     }
 }
 

crates/core/src/host/v8/syscall/v2.rs

@@ -22,15 +22,16 @@ use crate::host::wasm_common::module_host_actor::{
     AnonymousViewOp, ProcedureOp, ReducerOp, ReducerResult, ViewOp, ViewReturnData,
 };
 use crate::host::wasm_common::{err_to_errno_and_log, RowIterIdx, TimingSpan, TimingSpanIdx};
-use crate::host::AbiCall;
+use crate::host::{AbiCall, ArgsTuple};
 use anyhow::Context;
 use bytes::Bytes;
+use core::ptr::NonNull;
 use spacetimedb_lib::{bsatn, ConnectionId, Identity, RawModuleDef, Timestamp};
 use spacetimedb_primitives::{errno, ColId, IndexId, ProcedureId, ReducerId, TableId, ViewFnPtr};
 use spacetimedb_sats::u256;
 use v8::{
     callback_scope, ConstructorBehavior, Function, FunctionCallbackArguments, Isolate, Local, Module, Object,
-    PinCallbackScope, PinScope,
+    PinCallbackScope, PinScope, Value,
 };
 
 macro_rules! create_synthetic_module {
@@ -384,10 +385,11 @@ fn register_hooks_v2_0<'scope>(scope: &mut PinScope<'scope, '_>, args: FunctionC
 }
 
 /// Calls the `__call_reducer__` function `fun`.
-pub(super) fn call_call_reducer(
-    scope: &mut PinScope<'_, '_>,
-    hooks: &HookFunctions<'_>,
+pub(super) fn call_call_reducer<'scope>(
+    scope: &mut PinScope<'scope, '_>,
+    hooks: &HookFunctions<'scope>,
     op: ReducerOp<'_>,
+    reducer_args_data_view: Local<'scope, v8::DataView>,
 ) -> ExcResult<ReducerResult> {
     let ReducerOp {
         id: ReducerId(reducer_id),
@@ -402,7 +404,8 @@ pub(super) fn call_call_reducer(
     let sender = serialize_to_js(scope, &sender.to_u256())?;
     let conn_id: v8::Local<'_, v8::Value> = serialize_to_js(scope, &conn_id.to_u128())?;
     let timestamp = serialize_to_js(scope, &timestamp.to_micros_since_unix_epoch())?;
-    let reducer_args = make_dataview(scope, <Box<[u8]>>::from(&**reducer_args.get_bsatn())).into();
+    let reducer_args = reducer_args_to_value(scope, reducer_args, reducer_args_data_view);
+
     let args = &[reducer_id, sender, conn_id, timestamp, reducer_args];
 
     // Call the function.
@@ -418,6 +421,43 @@ pub(super) fn call_call_reducer(
     Ok(user_res)
 }
 
+/// Converts `args` into a `Value`.
+fn reducer_args_to_value<'scope>(
+    scope: &mut PinScope<'scope, '_>,
+    args: &ArgsTuple,
+    buffer: Local<'scope, v8::DataView>,
+) -> Local<'scope, Value> {
+    let reducer_args = &**args.get_bsatn();
+
+    let len = reducer_args.len();
+    let dv = if len <= buffer.byte_length() {
+        // We can use the buffer.
+        let dst_ptr = NonNull::new(buffer.data())
+            .expect("backing store byte length should be > 0")
+            .cast::<u8>();
+
+        // Copy `reducer_args` into `buffer`.
+        let mut dst_ptr = NonNull::slice_from_raw_parts(dst_ptr, len);
+        // SAFETY: We know `dst_ptr` to be:
+        // - trivially properly aligned due to `u8`s alignment being 1.
+        // - non-null as it was derived from `NonNull`.
+        // - the range is within the allocation of `buffer`
+        //   as `len <= buffer.byte_length()`,
+        //   so `buffer` is dereferenceable.
+        // - `dst` will point to a valid `[u8]` as it was zero-initialized.
+        // - nothing is aliasing the pointer.
+        let dst = unsafe { dst_ptr.as_mut() };
+        dst.copy_from_slice(reducer_args);
+
+        buffer
+    } else {
+        // Fall back to allocating new buffers.
+        make_dataview(scope, <Box<[u8]>>::from(reducer_args))
+    };
+
+    dv.into()
+}
+
 /// Calls the `__call_view__` function `fun`.
 pub(super) fn call_call_view(
     scope: &mut PinScope<'_, '_>,