extract InstanceCommon::new + run_describer

crates/core/src/host/module_common.rs

@@ -5,6 +5,7 @@ use crate::{
     energy::EnergyMonitor,
     host::{
         module_host::{DynModule, ModuleInfo},
+        wasm_common::{module_host_actor::DescribeError, DESCRIBE_MODULE_DUNDER},
         Scheduler,
     },
     module_host_context::ModuleCreationContext,
@@ -88,3 +89,22 @@ impl DynModule for ModuleCommon {
         &self.scheduler
     }
 }
+
+/// Runs the describer of modules in `run` and does some logging around it.
+pub(crate) fn run_describer<T>(
+    log_traceback: impl FnOnce(&str, &str, &anyhow::Error),
+    run: impl FnOnce() -> anyhow::Result<T>,
+) -> Result<T, DescribeError> {
+    let describer_func_name = DESCRIBE_MODULE_DUNDER;
+    let start = std::time::Instant::now();
+    log::trace!("Start describer \"{describer_func_name}\"...");
+
+    let result = run();
+
+    let duration = start.elapsed();
+    log::trace!("Describer \"{}\" ran: {} us", describer_func_name, duration.as_micros());
+
+    result
+        .inspect_err(|err| log_traceback("describer", describer_func_name, err))
+        .map_err(DescribeError::RuntimeError)
+}

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

@@ -166,16 +166,7 @@ impl<T: WasmModule> WasmModuleHostActor<T> {
 
 impl<T: WasmModule> WasmModuleHostActor<T> {
     fn make_from_instance(&self, instance: T::Instance) -> WasmModuleInstance<T::Instance> {
-        let common = InstanceCommon {
-            info: self.common.info(),
-            energy_monitor: self.common.energy_monitor(),
-            // will be updated on the first reducer call
-            allocated_memory: 0,
-            metric_wasm_memory_bytes: WORKER_METRICS
-                .wasm_memory_bytes
-                .with_label_values(self.common.database_identity()),
-            trapped: false,
-        };
+        let common = InstanceCommon::new(&self.common);
         WasmModuleInstance { instance, common }
     }
 }
@@ -279,6 +270,19 @@ pub(crate) struct InstanceCommon {
 }
 
 impl InstanceCommon {
+    pub(crate) fn new(module: &ModuleCommon) -> Self {
+        Self {
+            info: module.info(),
+            energy_monitor: module.energy_monitor(),
+            // Will be updated on the first reducer call.
+            allocated_memory: 0,
+            metric_wasm_memory_bytes: WORKER_METRICS
+                .wasm_memory_bytes
+                .with_label_values(module.database_identity()),
+            trapped: false,
+        }
+    }
+
     #[tracing::instrument(level = "trace", skip_all)]
     pub(crate) fn update_database(
         &mut self,

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

@@ -4,6 +4,7 @@ use super::wasm_instance_env::WasmInstanceEnv;
 use super::{Mem, WasmtimeFuel, EPOCH_TICKS_PER_SECOND};
 use crate::energy::ReducerBudget;
 use crate::host::instance_env::InstanceEnv;
+use crate::host::module_common::run_describer;
 use crate::host::wasm_common::module_host_actor::{DescribeError, InitializationError};
 use crate::host::wasm_common::*;
 use crate::util::string_from_utf8_lossy_owned;
@@ -158,29 +159,18 @@ pub struct WasmtimeInstance {
 impl module_host_actor::WasmInstance for WasmtimeInstance {
     fn extract_descriptions(&mut self) -> Result<Vec<u8>, DescribeError> {
         let describer_func_name = DESCRIBE_MODULE_DUNDER;
-        let store = &mut self.store;
 
-        let describer = self.instance.get_func(&mut *store, describer_func_name).unwrap();
-        let describer = describer
-            .typed::<u32, ()>(&mut *store)
+        let describer = self
+            .instance
+            .get_typed_func::<u32, ()>(&mut self.store, describer_func_name)
             .map_err(|_| DescribeError::Signature)?;
 
-        let sink = store.data_mut().setup_standard_bytes_sink();
-
-        let start = std::time::Instant::now();
-        log::trace!("Start describer \"{describer_func_name}\"...");
-
-        let result = describer.call(&mut *store, sink);
-
-        let duration = start.elapsed();
-        log::trace!("Describer \"{}\" ran: {} us", describer_func_name, duration.as_micros());
+        let sink = self.store.data_mut().setup_standard_bytes_sink();
 
-        result
-            .inspect_err(|err| log_traceback("describer", describer_func_name, err))
-            .map_err(DescribeError::RuntimeError)?;
+        run_describer(log_traceback, || describer.call(&mut self.store, sink))?;
 
         // Fetch the bsatn returned by the describer call.
-        let bytes = store.data_mut().take_standard_bytes_sink();
+        let bytes = self.store.data_mut().take_standard_bytes_sink();
 
         Ok(bytes)
     }