v8: use fast static strings for known strings

Author: Centril

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

@@ -2,7 +2,7 @@
 
 use super::error::{exception_already_thrown, ExcResult, ExceptionThrown, ExceptionValue, Throwable, TypeError};
 use super::from_value::{cast, FromValue};
-use super::key_cache::{get_or_create_key_cache, KeyCache};
+use super::string_const::{TAG, VALUE};
 use core::fmt;
 use core::iter::{repeat_n, RepeatN};
 use core::marker::PhantomData;
@@ -19,9 +19,7 @@ pub(super) fn deserialize_js_seed<'de, T: DeserializeSeed<'de>>(
     val: Local<'_, Value>,
     seed: T,
 ) -> ExcResult<T::Output> {
-    let key_cache = get_or_create_key_cache(scope);
-    let key_cache = &mut *key_cache.borrow_mut();
-    let de = Deserializer::new(scope, val, key_cache);
+    let de = Deserializer::new(scope, val);
     seed.deserialize(de).map_err(|e| e.throw(scope))
 }
 
@@ -41,9 +39,9 @@ struct Deserializer<'this, 'scope, 'isolate> {
 
 impl<'this, 'scope, 'isolate> Deserializer<'this, 'scope, 'isolate> {
     /// Creates a new deserializer from `input` in `scope`.
-    fn new(scope: &'this mut PinScope<'scope, 'isolate>, input: Local<'_, Value>, key_cache: &'this mut KeyCache) -> Self {
+    fn new(scope: &'this mut PinScope<'scope, 'isolate>, input: Local<'_, Value>) -> Self {
         let input = Local::new(scope, input);
-        let common = DeserializerCommon { scope, key_cache };
+        let common = DeserializerCommon { scope };
         Deserializer { input, common }
     }
 }
@@ -54,16 +52,11 @@ impl<'this, 'scope, 'isolate> Deserializer<'this, 'scope, 'isolate> {
 struct DeserializerCommon<'this, 'scope, 'isolate> {
     /// The scope of values to deserialize.
     scope: &'this mut PinScope<'scope, 'isolate>,
-    /// A cache for frequently used strings.
-    key_cache: &'this mut KeyCache,
 }
 
 impl<'scope, 'isolate> DeserializerCommon<'_, 'scope, 'isolate> {
     fn reborrow(&mut self) -> DeserializerCommon<'_, 'scope, 'isolate> {
-        DeserializerCommon {
-            scope: self.scope,
-            key_cache: self.key_cache,
-        }
+        DeserializerCommon { scope: self.scope }
     }
 }
 
@@ -161,7 +154,7 @@ impl<'de, 'this, 'scope: 'de> de::Deserializer<'de> for Deserializer<'this, 'sco
 
         // We expect a canonical representation of a sum value in JS to be
         // `{ tag: "foo", value: a_value_for_foo }`.
-        let tag_field = self.common.key_cache.tag(scope);
+        let tag_field = TAG.string(scope);
         let object = cast!(scope, self.input, Object, "object for sum type `{}`", sum_name)?;
 
         // Extract the `tag` field. It needs to contain a string.
@@ -171,7 +164,7 @@ impl<'de, 'this, 'scope: 'de> de::Deserializer<'de> for Deserializer<'this, 'sco
         let tag = cast!(scope, tag, v8::String, "string for sum tag of `{}`", sum_name)?;
 
         // Extract the `value` field.
-        let value_field = self.common.key_cache.value(scope);
+        let value_field = VALUE.string(scope);
         let value = object
             .get(scope, value_field.into())
             .ok_or_else(exception_already_thrown)?;

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

@@ -17,10 +17,7 @@ pub(super) trait FromValue: Sized {
 macro_rules! impl_from_value {
     ($ty:ty, ($val:ident, $scope:ident) => $logic:expr) => {
         impl FromValue for $ty {
-            fn from_value<'scope>(
-                $val: Local<'_, Value>,
-                $scope: &PinScope<'scope, '_>,
-            ) -> ValueResult<'scope, Self> {
+            fn from_value<'scope>($val: Local<'_, Value>, $scope: &PinScope<'scope, '_>) -> ValueResult<'scope, Self> {
                 $logic
             }
         }

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

@@ -4,24 +4,24 @@ use super::module_common::{build_common_module_from_raw, run_describer, ModuleCo
 use super::module_host::{CallReducerParams, DynModule, Module, ModuleInfo, ModuleInstance, ModuleRuntime};
 use super::UpdateDatabaseResult;
 use crate::host::instance_env::{ChunkPool, InstanceEnv};
-use crate::host::v8::error::{BufferTooSmall, JsStackTrace};
-use crate::host::v8::syscall::{register_host_funs, FnRet};
 use crate::host::wasm_common::instrumentation::CallTimes;
 use crate::host::wasm_common::module_host_actor::{
     DescribeError, EnergyStats, ExecuteResult, ExecutionTimings, InstanceCommon, ReducerOp,
 };
 use crate::host::wasm_common::{RowIters, TimingSpanSet};
 use crate::host::wasmtime::{epoch_ticker, ticks_in_duration, EPOCH_TICKS_PER_SECOND};
-use crate::host::ArgsTuple;
-use crate::{host::Scheduler, module_host_context::ModuleCreationContext, replica_context::ReplicaContext};
+use crate::host::{ArgsTuple, Scheduler};
+use crate::{module_host_context::ModuleCreationContext, replica_context::ReplicaContext};
 use core::ffi::c_void;
 use core::sync::atomic::{AtomicBool, Ordering};
 use core::time::Duration;
 use core::{iter, ptr, str};
 use de::deserialize_js;
-use error::{catch_exception, exception_already_thrown, log_traceback, CodeError, TerminationError, Throwable};
+use error::{
+    catch_exception, exception_already_thrown, log_traceback, BufferTooSmall, CodeError, JsStackTrace,
+    TerminationError, Throwable,
+};
 use from_value::cast;
-use key_cache::get_or_create_key_cache;
 use ser::serialize_to_js;
 use spacetimedb_client_api_messages::energy::ReducerBudget;
 use spacetimedb_datastore::locking_tx_datastore::MutTxId;
@@ -30,15 +30,17 @@ use spacetimedb_lib::{ConnectionId, Identity, RawModuleDef, Timestamp};
 use spacetimedb_schema::auto_migrate::MigrationPolicy;
 use std::sync::{Arc, LazyLock};
 use std::time::Instant;
+use string_const::str_from_ident;
+use syscall::{register_host_funs, FnRet};
 use v8::{
     scope, Context, ContextScope, Function, Isolate, IsolateHandle, Local, Object, OwnedIsolate, PinScope, Value,
 };
 
 mod de;
 mod error;
 mod from_value;
-mod key_cache;
 mod ser;
+mod string_const;
 mod syscall;
 mod to_value;
 
@@ -532,9 +534,7 @@ fn call_call_reducer(
     timestamp: i64,
     reducer_args: &ArgsTuple,
 ) -> anyhow::Result<Result<(), Box<str>>> {
-    // Get a cached version of the `__call_reducer__` property.
-    let key_cache = get_or_create_key_cache(scope);
-    let call_reducer_key = key_cache.borrow_mut().call_reducer(scope);
+    let call_reducer_key = str_from_ident!(__call_reducer__).string(scope);
 
     catch_exception(scope, |scope| {
         // Serialize the arguments.
@@ -580,9 +580,7 @@ fn extract_description(program: &str) -> Result<RawModuleDef, DescribeError> {
 
 // Calls the `__describe_module__` function on the global proxy object to extract a [`RawModuleDef`].
 fn call_describe_module(scope: &mut PinScope<'_, '_>) -> anyhow::Result<RawModuleDef> {
-    // Get a cached version of the `__describe_module__` property.
-    let key_cache = get_or_create_key_cache(scope);
-    let describe_module_key = key_cache.borrow_mut().describe_module(scope);
+    let describe_module_key = str_from_ident!(__describe_module__).string(scope);
 
     catch_exception(scope, |scope| {
         // Get the function on the global proxy object and convert to a function.

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

@@ -2,7 +2,7 @@
 
 use super::de::intern_field_name;
 use super::error::{exception_already_thrown, ExcResult, ExceptionThrown, RangeError, Throwable, TypeError};
-use super::key_cache::{get_or_create_key_cache, KeyCache};
+use super::string_const::{TAG, VALUE};
 use super::syscall::FnRet;
 use super::to_value::ToValue;
 use derive_more::From;
@@ -15,32 +15,20 @@ use v8::{Array, ArrayBuffer, IntegrityLevel, Local, Object, PinScope, Uint8Array
 
 /// Serializes `value` into a V8 into `scope`.
 pub(super) fn serialize_to_js<'scope>(scope: &PinScope<'scope, '_>, value: &impl Serialize) -> FnRet<'scope> {
-    let key_cache = get_or_create_key_cache(scope);
-    let key_cache = &mut *key_cache.borrow_mut();
-    value
-        .serialize(Serializer::new(scope, key_cache))
-        .map_err(|e| e.throw(scope))
+    value.serialize(Serializer::new(scope)).map_err(|e| e.throw(scope))
 }
 
 /// Deserializes to V8 values.
+#[derive(Copy, Clone)]
 struct Serializer<'this, 'scope, 'isolate> {
     /// The scope to serialize values into.
     scope: &'this PinScope<'scope, 'isolate>,
-    /// A cache for frequently used strings.
-    key_cache: &'this mut KeyCache,
 }
 
 impl<'this, 'scope, 'isolate> Serializer<'this, 'scope, 'isolate> {
     /// Creates a new serializer into `scope`.
-    pub fn new(scope: &'this PinScope<'scope, 'isolate>, key_cache: &'this mut KeyCache) -> Self {
-        Self { scope, key_cache }
-    }
-
-    fn reborrow(&mut self) -> Serializer<'_, 'scope, 'isolate> {
-        Serializer {
-            scope: self.scope,
-            key_cache: self.key_cache,
-        }
+    pub fn new(scope: &'this PinScope<'scope, 'isolate>) -> Self {
+        Self { scope }
     }
 }
 
@@ -56,7 +44,7 @@ enum Error {
 }
 
 impl<'scope> Throwable<'scope> for Error {
-    fn throw(self, scope: & PinScope<'scope, '_>) -> ExceptionThrown {
+    fn throw(self, scope: &PinScope<'scope, '_>) -> ExceptionThrown {
         match self {
             Self::StringTooLarge(len) => {
                 RangeError(format!("`{len}` bytes is too large to be a JS string")).throw(scope)
@@ -158,22 +146,19 @@ impl<'this, 'scope, 'isolate> ser::Serializer for Serializer<'this, 'scope, 'iso
     }
 
     fn serialize_variant<T: Serialize + ?Sized>(
-        mut self,
+        self,
         tag: u8,
         var_name: Option<&str>,
         value: &T,
     ) -> Result<Self::Ok, Self::Error> {
         // Serialize the payload.
-        let value_value: Local<'scope, Value> = value.serialize(self.reborrow())?;
+        let value_value: Local<'scope, Value> = value.serialize(self)?;
         // Figure out the tag.
         let tag_value: Local<'scope, Value> = intern_field_name(self.scope, var_name, tag as usize).into();
         let values = [tag_value, value_value];
 
         // The property keys are always `"tag"` an `"value"`.
-        let names = [
-            self.key_cache.tag(self.scope).into(),
-            self.key_cache.value(self.scope).into(),
-        ];
+        let names = [TAG.string(self.scope).into(), VALUE.string(self.scope).into()];
 
         // Stitch together the object.
         let prototype = v8::null(self.scope).into();
@@ -196,7 +181,7 @@ impl<'scope> ser::SerializeArray for SerializeArray<'_, 'scope, '_> {
 
     fn serialize_element<T: Serialize + ?Sized>(&mut self, elem: &T) -> Result<(), Self::Error> {
         // Serialize the current `elem`ent.
-        let value = elem.serialize(self.inner.reborrow())?;
+        let value = elem.serialize(self.inner)?;
 
         // Set the value to the array slot at `index`.
         let index = self.next_index;
@@ -243,7 +228,7 @@ impl<'scope> ser::SerializeNamedProduct for SerializeNamedProduct<'_, 'scope, '_
         elem: &T,
     ) -> Result<(), Self::Error> {
         // Serialize the field value.
-        let value = elem.serialize(self.inner.reborrow())?;
+        let value = elem.serialize(self.inner)?;
 
         // Figure out the object property to use.
         let scope = self.inner.scope;

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

@@ -0,0 +1,33 @@
+use v8::{Local, OneByteConst, PinScope, String};
+
+/// A string known at compile time to be ASCII.
+pub(super) struct StringConst(OneByteConst);
+
+impl StringConst {
+    /// Returns a new string that is known to be ASCII and static.
+    pub(super) const fn new(string: &'static str) -> Self {
+        Self(String::create_external_onebyte_const(string.as_bytes()))
+    }
+
+    /// Converts the string to a V8 string.
+    pub(super) fn string<'scope>(&'static self, scope: &PinScope<'scope, '_>) -> Local<'scope, String> {
+        String::new_from_onebyte_const(scope, &self.0)
+            .expect("`create_external_onebyte_const` should've asserted `.len() < kMaxLength`")
+    }
+}
+
+/// Converts an identifier to a compile-time ASCII string.
+#[macro_export]
+macro_rules! str_from_ident {
+    ($ident:ident) => {{
+        const STR: &$crate::host::v8::string_const::StringConst =
+            &$crate::host::v8::string_const::StringConst::new(stringify!($ident));
+        STR
+    }};
+}
+pub(super) use str_from_ident;
+
+/// The `tag` property of a sum object in JS.
+pub(super) const TAG: &StringConst = str_from_ident!(tag);
+/// The `value` property of a sum object in JS.
+pub(super) const VALUE: &StringConst = str_from_ident!(value);

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

@@ -1,12 +1,14 @@
-use super::de::{deserialize_js, scratch_buf, v8_interned_string};
-use super::error::ExcResult;
+use super::de::{deserialize_js, scratch_buf};
+use super::error::{ExcResult, ExceptionThrown};
 use super::ser::serialize_to_js;
-use super::{env_on_isolate, exception_already_thrown};
+use super::string_const::{str_from_ident, StringConst};
+use super::{
+    env_on_isolate, exception_already_thrown, global, BufferTooSmall, CodeError, JsInstanceEnv, JsStackTrace,
+    TerminationError, Throwable,
+};
 use crate::database_logger::{LogLevel, Record};
 use crate::error::NodesError;
 use crate::host::instance_env::InstanceEnv;
-use crate::host::v8::error::ExceptionThrown;
-use crate::host::v8::{global, BufferTooSmall, CodeError, JsInstanceEnv, JsStackTrace, TerminationError, Throwable};
 use crate::host::wasm_common::instrumentation::span;
 use crate::host::wasm_common::{err_to_errno_and_log, RowIterIdx, TimingSpan, TimingSpanIdx};
 use crate::host::AbiCall;
@@ -19,7 +21,9 @@ use v8::{Function, FunctionCallbackArguments, Local, PinScope, Value};
 pub(super) fn register_host_funs(scope: &mut PinScope<'_, '_>) -> ExcResult<()> {
     macro_rules! register {
         ($wrapper:ident, $abi_call:expr, $fun:ident) => {
-            register_host_fun(scope, stringify!($fun), |s, a| $wrapper($abi_call, s, a, $fun))?;
+            register_host_fun(scope, str_from_ident!($fun), |s, a| {
+                $wrapper($abi_call, s, a, $fun)
+            })?;
         };
     }
 
@@ -73,10 +77,10 @@ pub(super) type FnRet<'scope> = ExcResult<Local<'scope, Value>>;
 /// where the function has `name` and `body`
 fn register_host_fun(
     scope: &mut PinScope<'_, '_>,
-    name: &str,
+    name: &'static StringConst,
     body: impl Copy + for<'scope> Fn(&mut PinScope<'scope, '_>, FunctionCallbackArguments<'scope>) -> FnRet<'scope>,
 ) -> ExcResult<()> {
-    let name = v8_interned_string(scope, name).into();
+    let name = name.string(scope).into();
     let fun = Function::new(scope, adapt_fun(body))
         .ok_or_else(exception_already_thrown)?
         .into();