Optimize: Make lowerreturn optional and specialize host function return with empty args

Author: arjunr2

crates/wasmtime/src/runtime/component/func/options.rs

@@ -450,14 +450,25 @@ impl<'a, T: 'static> LowerContext<'a, T> {
                         _ => bail!("HostFuncReturn encountered in invalid phase"),
                     }
                     // End of the lowering process (for host calls)
-                    if let Some(e) = lowering_error {
-                        return Err(e.into());
+                    if let Some(err) = lowering_error {
+                        return Err(err.into());
                     }
                     if let Some(storage) = result_storage.as_deref_mut() {
                         e.args.into_raw_slice(storage);
                     }
                     complete = true;
                 }
+                RREvent::HostFuncReturnEmptyEvent => {
+                    match phase {
+                        ReplayLoweringPhase::HostFuncReturn => {}
+                        _ => bail!("HostFuncReturnEmpty encountered in invalid phase"),
+                    }
+                    // End of the lowering process (for host calls)
+                    if let Some(err) = lowering_error {
+                        return Err(err.into());
+                    }
+                    complete = true;
+                }
                 RREvent::ComponentWasmFuncEntry(e) => {
                     match phase {
                         ReplayLoweringPhase::WasmFuncEntry => {}
@@ -487,16 +498,16 @@ impl<'a, T: 'static> LowerContext<'a, T> {
                 RREvent::ComponentLowerFlatReturn(e) => {
                     if run_validate {
                         lower_stack.pop().ok_or(ReplayError::InvalidEventPosition)?;
+                        lowering_error = e.0.ret().map_err(Into::into).err();
                     }
-                    lowering_error = e.0.ret().map_err(Into::into).err();
                 }
                 RREvent::ComponentLowerMemoryReturn(e) => {
                     if run_validate {
                         lower_store_stack
                             .pop()
                             .ok_or(ReplayError::InvalidEventPosition)?;
+                        lowering_error = e.0.ret().map_err(Into::into).err();
                     }
-                    lowering_error = e.0.ret().map_err(Into::into).err();
                 }
                 RREvent::ComponentMemorySliceWrite(e) => {
                     let offset = e.offset as usize;

crates/wasmtime/src/runtime/rr/backend/crimp.rs

@@ -120,7 +120,9 @@ rr_event! {
     /// Nop Event
     Nop,
     /// Event signalling the end of a trace
-    Eof
+    Eof,
+    /// Specialized variant of `HostFuncReturnEvent` with empty args.
+    HostFuncReturnEmptyEvent
     ;
     /// The signature of the trace, enabling trace integrity during replay.
     ///

crates/wasmtime/src/runtime/rr/hooks/component_hooks.rs

@@ -4,7 +4,8 @@ use crate::ValRaw;
 use crate::component::{ComponentInstanceId, func::LowerContext};
 #[cfg(feature = "rr")]
 use crate::rr::{
-    RRFuncArgVals, RRFuncArgValsConvertable, RecordBuffer, Recorder, ResultEvent, Validate,
+    RREvent, RRFuncArgVals, RRFuncArgValsConvertable, RecordBuffer, Recorder, ResultEvent,
+    Validate,
     common_events::{HostFuncEntryEvent, HostFuncReturnEvent, WasmFuncReturnEvent},
     component_events::{
         InstantiationEvent, LowerFlatEntryEvent, LowerFlatReturnEvent, LowerMemoryEntryEvent,
@@ -153,9 +154,13 @@ pub fn record_host_func_return(
     store: &mut StoreOpaque,
 ) -> Result<()> {
     #[cfg(feature = "rr")]
-    store.record_event(|| HostFuncReturnEvent {
-        args: RRFuncArgVals::from_flat_storage(args, flat_results),
-    })?;
+    if args.is_empty() {
+        store.record_event(|| RREvent::HostFuncReturnEmptyEvent)?;
+    } else {
+        store.record_event(|| HostFuncReturnEvent {
+            args: RRFuncArgVals::from_flat_storage(args, flat_results),
+        })?;
+    }
     #[cfg(not(feature = "rr"))]
     let _ = (args, flat_results, store);
     Ok(())
@@ -181,9 +186,9 @@ where
         })?;
     let store_result = lower_store(cx, ty, offset);
     #[cfg(feature = "rr")]
-    cx.store
-        .0
-        .record_event(|| LowerMemoryReturnEvent(ResultEvent::from_anyhow_result(&store_result)))?;
+    cx.store.0.record_event_validation(|| {
+        LowerMemoryReturnEvent(ResultEvent::from_anyhow_result(&store_result))
+    })?;
     store_result
 }
 
@@ -203,9 +208,9 @@ where
         .record_event_validation(|| LowerFlatEntryEvent { ty })?;
     let lower_result = lower(cx, ty);
     #[cfg(feature = "rr")]
-    cx.store
-        .0
-        .record_event(|| LowerFlatReturnEvent(ResultEvent::from_anyhow_result(&lower_result)))?;
+    cx.store.0.record_event_validation(|| {
+        LowerFlatReturnEvent(ResultEvent::from_anyhow_result(&lower_result))
+    })?;
     lower_result
 }