V8Runtime: don't init V8 until neccessary

Author: Centril

crates/core/src/host/host_controller.rs

@@ -9,6 +9,7 @@ use crate::db::db_metrics::DB_METRICS;
 use crate::db::relational_db::{self, DiskSizeFn, RelationalDB, Txdata};
 use crate::db::{self, spawn_tx_metrics_recorder};
 use crate::energy::{EnergyMonitor, EnergyQuanta, NullEnergyMonitor};
+use crate::host::module_host::ModuleRuntime as _;
 use crate::host::v8::V8Runtime;
 use crate::messages::control_db::{Database, HostType};
 use crate::module_host_context::ModuleCreationContext;
@@ -113,7 +114,7 @@ struct HostRuntimes {
 impl HostRuntimes {
     fn new(data_dir: Option<&ServerDataDir>) -> Arc<Self> {
         let wasmtime = WasmtimeRuntime::new(data_dir);
-        let v8 = V8Runtime::new();
+        let v8 = V8Runtime::default();
         Arc::new(Self { wasmtime, v8 })
     }
 }

crates/core/src/host/module_host.rs

@@ -12,6 +12,7 @@ use crate::execution_context::{ExecutionContext, ReducerContext, Workload, Workl
 use crate::hash::Hash;
 use crate::identity::Identity;
 use crate::messages::control_db::Database;
+use crate::module_host_context::ModuleCreationContext;
 use crate::replica_context::ReplicaContext;
 use crate::sql::ast::SchemaViewer;
 use crate::sql::parser::RowLevelExpr;
@@ -306,6 +307,12 @@ impl ReducersMap {
     }
 }
 
+/// A runtime that can create modules.
+pub trait ModuleRuntime {
+    /// Creates a module based on the context `mcc`.
+    fn make_actor(&self, mcc: ModuleCreationContext<'_>) -> anyhow::Result<impl Module>;
+}
+
 pub trait DynModule: Send + Sync + 'static {
     fn replica_ctx(&self) -> &Arc<ReplicaContext>;
     fn scheduler(&self) -> &Scheduler;

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

@@ -1,33 +1,45 @@
 use crate::{
     db::datastore::locking_tx_datastore::MutTxId,
     host::{
-        module_host::{DynModule, Module, ModuleInfo, ModuleInstance},
+        module_host::{DynModule, Module, ModuleInfo, ModuleInstance, ModuleRuntime},
         Scheduler,
     },
     module_host_context::ModuleCreationContext,
     replica_context::ReplicaContext,
 };
 use anyhow::anyhow;
-use std::sync::{Arc, Once};
+use std::sync::{Arc, LazyLock};
 
 use super::module_host::CallReducerParams;
 
+/// The V8 runtime, for modules written in e.g., JS or TypeScript.
+#[derive(Default)]
 pub struct V8Runtime {
     _priv: (),
 }
 
-impl V8Runtime {
+impl ModuleRuntime for V8Runtime {
+    fn make_actor(&self, mcc: ModuleCreationContext<'_>) -> anyhow::Result<impl Module> {
+        V8_RUNTIME_GLOBAL.make_actor(mcc)
+    }
+}
+
+static V8_RUNTIME_GLOBAL: LazyLock<V8RuntimeInner> = LazyLock::new(V8RuntimeInner::new);
+
+/// The actual V8 runtime, with initialization of V8.
+struct V8RuntimeInner {
+    _priv: (),
+}
+
+impl V8RuntimeInner {
     #[allow(clippy::new_without_default)]
-    pub fn new() -> Self {
-        static V8_INIT: Once = Once::new();
-        V8_INIT.call_once(|| {
-            // TODO
-        });
+    const fn new() -> Self {
+        // TODO: actually setup V8.
 
         Self { _priv: () }
     }
 
-    pub fn make_actor(&self, _: ModuleCreationContext<'_>) -> anyhow::Result<impl Module> {
+    fn make_actor(&self, _: ModuleCreationContext<'_>) -> anyhow::Result<impl Module> {
         Err::<JsModule, _>(anyhow!("v8_todo"))
     }
 }

crates/core/src/host/wasm_common/module_host_actor.rs

@@ -122,8 +122,6 @@ pub enum DescribeError {
     Decode(#[from] DecodeError),
     #[error(transparent)]
     RuntimeError(anyhow::Error),
-    #[error("unimplemented RawModuleDef version")]
-    UnimplementedRawModuleDefVersion,
 }
 
 impl<T: WasmModule> WasmModuleHostActor<T> {

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

@@ -7,6 +7,7 @@ use wasmtime::{Engine, Linker, Module, StoreContext, StoreContextMut};
 
 use crate::energy::{EnergyQuanta, ReducerBudget};
 use crate::error::NodesError;
+use crate::host::module_host::ModuleRuntime;
 use crate::module_host_context::ModuleCreationContext;
 
 mod wasm_instance_env;
@@ -80,11 +81,10 @@ impl WasmtimeRuntime {
         config.cache_config_load(tmpfile.path())?;
         Ok(())
     }
+}
 
-    pub fn make_actor(
-        &self,
-        mcc: ModuleCreationContext,
-    ) -> Result<impl super::module_host::Module, ModuleCreationError> {
+impl ModuleRuntime for WasmtimeRuntime {
+    fn make_actor(&self, mcc: ModuleCreationContext) -> anyhow::Result<impl super::module_host::Module> {
         let module = Module::new(&self.engine, &mcc.program.bytes).map_err(ModuleCreationError::WasmCompileError)?;
 
         let func_imports = module