Factored out core RR interface into separate crate; fix rr tests to just disable async with component-model-async

Author: arjunr2

Cargo.lock

@@ -272,6 +272,7 @@ wasmtime-slab = { path = "crates/slab", version = "=40.0.0", package = 'wasmtime
 wasmtime-jit-icache-coherence = { path = "crates/jit-icache-coherence", version = "=40.0.0", package = 'wasmtime-internal-jit-icache-coherence' }
 wasmtime-wit-bindgen = { path = "crates/wit-bindgen", version = "=40.0.0", package = 'wasmtime-internal-wit-bindgen' }
 wasmtime-math = { path = "crates/math", version = "=40.0.0", package = 'wasmtime-internal-math'  }
+wasmtime-rr = { path = "crates/rr", version = "40.0.0" }
 wasmtime-unwinder = { path = "crates/unwinder", version = "=40.0.0", package = 'wasmtime-internal-unwinder' }
 wasmtime-wizer = { path = "crates/wizer", version = "40.0.0" }
 

Cargo.toml

@@ -17,6 +17,7 @@
 //!
 //! Note that this entire module is gated behind the `component-model` Cargo
 //! feature.
+use serde::{Deserialize, Serialize};
 
 /// Canonical ABI-defined constant for the maximum number of "flat" parameters
 /// to a wasm function, or the maximum number of parameters a core wasm function
@@ -272,3 +273,7 @@ declare_builtin_index! {
     /// An index type for component builtin functions.
     pub struct ComponentBuiltinFunctionIndex: foreach_builtin_component_function;
 }
+
+/// Return value from `resource.drop` builtin.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
+pub struct ResourceDropRet(pub Option<u32>);

crates/environ/src/component.rs

@@ -0,0 +1,28 @@
+[package]
+name = "wasmtime-rr"
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+documentation = "https://docs.rs/wasmtime-rr"
+description = "Record-replay interface for Wasm modules and components"
+license = "Apache-2.0 WITH LLVM-exception"
+repository = "https://github.com/bytecodealliance/wasmtime"
+
+[lints]
+workspace = true
+
+[package.metadata.docs.rs]
+all-features = true
+
+[dependencies]
+wasmtime-environ = { workspace = true, features = ["component-model"] }
+serde = { workspace = true }
+postcard = { workspace = true }
+anyhow = { workspace = true }
+log = { workspace = true }
+cfg-if = { workspace = true }
+
+[features]
+default = ["std"]
+std = ["postcard/use-std", "wasmtime-environ/std"]

crates/rr/Cargo.toml

@@ -1,10 +1,7 @@
-use super::ReplayError;
-use crate::rr::FlatBytes;
-use crate::{AsContextMut, Val, prelude::*};
-use crate::{ValRaw, ValType};
+use crate::ReplayError;
+use anyhow::Result;
 use core::fmt;
 use serde::{Deserialize, Serialize};
-use wasmtime_environ::component::FlatTypesStorage;
 
 /// A serde compatible representation of errors produced during execution
 /// of certain events
@@ -26,12 +23,12 @@ pub trait EventError: core::error::Error + Send + Sync + 'static {
 #[derive(Serialize, Deserialize, Clone, PartialEq)]
 pub struct RRFuncArgVals {
     /// Flat data vector of bytes
-    bytes: Vec<u8>,
+    pub bytes: Vec<u8>,
     /// Descriptor vector of sizes of each flat types
     ///
     /// The length of this vector equals the number of flat types,
     /// and the sum of this vector equals the length of `bytes`
-    sizes: Vec<u8>,
+    pub sizes: Vec<u8>,
 }
 
 impl fmt::Debug for RRFuncArgVals {
@@ -58,60 +55,6 @@ impl fmt::Debug for RRFuncArgVals {
     }
 }
 
-impl RRFuncArgVals {
-    /// Construct [`RRFuncArgVals`] from raw value buffer and a flat size iterator
-    #[inline]
-    pub fn from_flat_iter<T>(args: &[T], flat: impl Iterator<Item = u8>) -> RRFuncArgVals
-    where
-        T: FlatBytes,
-    {
-        let mut bytes = Vec::new();
-        let mut sizes = Vec::new();
-        for (flat_size, arg) in flat.zip(args.iter()) {
-            bytes.extend_from_slice(unsafe { &arg.bytes(flat_size) });
-            sizes.push(flat_size);
-        }
-        RRFuncArgVals { bytes, sizes }
-    }
-
-    /// Construct [`RRFuncArgVals`] from raw value buffer and a [`FlatTypesStorage`]
-    #[inline]
-    pub fn from_flat_storage<T>(args: &[T], flat: FlatTypesStorage) -> RRFuncArgVals
-    where
-        T: FlatBytes,
-    {
-        RRFuncArgVals::from_flat_iter(args, flat.iter32())
-    }
-
-    /// Encode [`RRFuncArgVals`] back into raw value buffer
-    #[inline]
-    pub fn into_raw_slice<T>(self, raw_args: &mut [T])
-    where
-        T: FlatBytes,
-    {
-        let mut pos = 0;
-        for (flat_size, dst) in self.sizes.into_iter().zip(raw_args.iter_mut()) {
-            *dst = T::from_bytes(&self.bytes[pos..pos + flat_size as usize]);
-            pos += flat_size as usize;
-        }
-    }
-
-    /// Generate a vector of [`crate::Val`] from [`RRFuncArgVals`] and [`ValType`]s
-    #[inline]
-    pub fn to_val_vec(self, mut store: impl AsContextMut, val_types: Vec<ValType>) -> Vec<Val> {
-        let mut pos = 0;
-        let mut vals = Vec::new();
-        for (flat_size, val_type) in self.sizes.into_iter().zip(val_types.into_iter()) {
-            let raw = ValRaw::from_bytes(&self.bytes[pos..pos + flat_size as usize]);
-            // SAFETY: The safety contract here is the same as that of [`Val::from_raw`].
-            // The caller must ensure that raw has the type provided.
-            vals.push(unsafe { Val::from_raw(&mut store, raw, val_type) });
-            pos += flat_size as usize;
-        }
-        vals
-    }
-}
-
 /// Trait signifying types that can be validated on replay
 ///
 /// All `PartialEq` types are directly validatable with themselves.
@@ -234,7 +177,6 @@ macro_rules! event_error_types {
 /// Marker events should be injectable at any point in a record
 /// trace without impacting functional correctness of replay
 pub mod marker_events {
-    use crate::prelude::*;
     use serde::{Deserialize, Serialize};
 
     /// A Nop event

…s/wasmtime/src/runtime/rr/core/events.rs crates/rr/src/events.rscrates/wasmtime/src/runtime/rr/core/events.rs renamed to crates/rr/src/events.rs crates/wasmtime/src/runtime/rr/core/events.rs renamed to crates/rr/src/events.rs

@@ -1,50 +1,53 @@
 //! Module comprising of component model wasm events
 
 use super::*;
-use crate::component::ComponentInstanceId;
-use crate::vm::component::libcalls::ResourceDropRet;
 use wasmtime_environ::{
     self, WasmChecksum,
-    component::{ExportIndex, InterfaceType},
+    component::{ExportIndex, InterfaceType, ResourceDropRet},
 };
 
-/// Beginning marker for a Wasm component function call from host
+/// Representation of a component instance identifier during record/replay.
+///
+/// This ID is tied to component instantiation events in the trace, and used
+/// during replay to refer to specific component instances.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Ord, PartialOrd)]
+pub struct RRComponentInstanceId(pub u32);
+
+/// Beginning marker for a Wasm component function call from host.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct WasmFuncBeginEvent {
-    /// Instance ID for the component instance
-    pub instance: ComponentInstanceId,
-    /// Export index for the invoked function
-    pub func_idx: ExportIndex,
+    /// Instance ID for the component instance.
+    pub instance: RRComponentInstanceId,
+    /// Export index for the invoked function.
+    pub func_index: ExportIndex,
 }
 
-/// A [`Component`] instantiatation event
+/// A instantiatation event for a Wasm component.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Ord, PartialOrd)]
 pub struct InstantiationEvent {
     /// Checksum of the bytecode used to instantiate the component
     pub component: WasmChecksum,
-    /// Instance ID for the instantiated component
-    pub instance: ComponentInstanceId,
+    /// Instance ID for the instantiated component.
+    pub instance: RRComponentInstanceId,
 }
 
-/// A call to `post_return` (after the function call)
+/// A call to `post_return` (after the function call).
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct PostReturnEvent {
-    /// Instance ID for the component instance
-    pub instance: ComponentInstanceId,
-    /// Export index for the function on which post_return is invoked
-    pub func_idx: ExportIndex,
+    /// Instance ID for the component instance.
+    pub instance: RRComponentInstanceId,
+    /// Export index for the function on which post_return is invoked.
+    pub func_index: ExportIndex,
 }
 
-/// A call event from Host into a Wasm component function
+/// A call event from Host into a Wasm component function.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct WasmFuncEntryEvent {
-    /// Raw values passed across call boundary
+    /// Raw values passed across call boundary.
     pub args: RRFuncArgVals,
 }
 
-/// A reallocation call event in the Component Model canonical ABI
-///
-/// Usually performed during lowering of complex [`ComponentType`]s to Wasm
+/// A reallocation call event in the Wasm Component Model canonical ABI.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ReallocEntryEvent {
     pub old_addr: usize,
@@ -53,13 +56,13 @@ pub struct ReallocEntryEvent {
     pub new_size: usize,
 }
 
-/// Entry to a type lowering invocation to flat destination
+/// Entry to a type lowering invocation to flat destination.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct LowerFlatEntryEvent {
     pub ty: InterfaceType,
 }
 
-/// Entry to type lowering invocation to destination in memory
+/// Entry to type lowering invocation to destination in memory.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct LowerMemoryEntryEvent {
     pub ty: InterfaceType,
@@ -69,6 +72,7 @@ pub struct LowerMemoryEntryEvent {
 /// A write to a mutable slice of Wasm linear memory by the host. This is the
 /// fundamental representation of host-written data to Wasm and is usually
 /// performed during lowering of a [`ComponentType`].
+///
 /// Note that this currently signifies a single mutable operation at the smallest granularity
 /// on a given linear memory slice. These can be optimized and coalesced into
 /// larger granularity operations in the future at either the recording or the replay level.
@@ -85,18 +89,20 @@ event_error_types! {
     pub struct BuiltinError(..)
 }
 
+/// Return from a reallocation call in the Component Model canonical ABI, providing
+/// the address of allocation if successful.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ReallocReturnEvent(pub ResultEvent<usize, ReallocError>);
 
-/// Return from type lowering to flat destination
+/// Return from type lowering to flat destination.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct LowerFlatReturnEvent(pub ResultEvent<(), LowerFlatError>);
 
-/// Return from type lowering to destination in memory
+/// Return from type lowering to destination in memory.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct LowerMemoryReturnEvent(pub ResultEvent<(), LowerMemoryError>);
 
-// Macro to generate RR events from the builtin descriptions
+// Macro to generate RR events from the builtin descriptions.
 macro_rules! builtin_events {
     // Main rule matching component function definitions
     (

…/runtime/rr/core/events/common_events.rs crates/rr/src/events/common_events.rscrates/wasmtime/src/runtime/rr/core/events/common_events.rs renamed to crates/rr/src/events/common_events.rs crates/wasmtime/src/runtime/rr/core/events/common_events.rs renamed to crates/rr/src/events/common_events.rs

@@ -0,0 +1,54 @@
+//! Module comprising of core wasm events
+use super::*;
+use wasmtime_environ::{EntityIndex, FuncIndex, WasmChecksum};
+
+/// Representation of a Wasm module instance identifier during record/replay.
+///
+/// This ID is tied to module instantiation events in the trace, and used
+/// during replay to refer to specific module instances.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Ord, PartialOrd)]
+pub struct RRModuleInstanceId(pub u32);
+
+/// Representation of a Wasm module function index during record/replay.
+///
+/// This index is used to identify target call functions within a module during replay.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Ord, PartialOrd)]
+pub struct RRModuleFuncIndex(pub u32);
+
+impl Into<FuncIndex> for RRModuleFuncIndex {
+    fn into(self) -> FuncIndex {
+        FuncIndex::from_u32(self.0)
+    }
+}
+
+impl Into<EntityIndex> for RRModuleFuncIndex {
+    fn into(self) -> EntityIndex {
+        EntityIndex::from(Into::<FuncIndex>::into(self))
+    }
+}
+
+impl From<FuncIndex> for RRModuleFuncIndex {
+    fn from(f: FuncIndex) -> Self {
+        RRModuleFuncIndex(f.as_u32())
+    }
+}
+
+/// A core Wasm module instantiatation event.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Ord, PartialOrd)]
+pub struct InstantiationEvent {
+    /// Checksum of the bytecode used to instantiate the module.
+    pub module: WasmChecksum,
+    /// Instance ID for the instantiated module.
+    pub instance: RRModuleInstanceId,
+}
+
+/// A call event from Host into a core Wasm function.
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct WasmFuncEntryEvent {
+    /// Instance ID for the instantiated module.
+    pub instance: RRModuleInstanceId,
+    /// Function index of callee within the module.
+    pub func_index: RRModuleFuncIndex,
+    /// Raw values passed across call boundary
+    pub args: RRFuncArgVals,
+}

…ntime/rr/core/events/component_events.rs crates/rr/src/events/component_events.rscrates/wasmtime/src/runtime/rr/core/events/component_events.rs renamed to crates/rr/src/events/component_events.rs crates/wasmtime/src/runtime/rr/core/events/component_events.rs renamed to crates/rr/src/events/component_events.rs

@@ -1,4 +1,4 @@
-use crate::prelude::*;
+use anyhow::Result;
 use core::any::Any;
 use postcard;
 use serde::{Deserialize, Serialize};
@@ -133,7 +133,7 @@ cfg_if::cfg_if! {
 /// Serialize and write `value` to a `RecordWriter`
 ///
 /// Currently uses `postcard` serializer
-pub(super) fn to_record_writer<T, W>(value: &T, writer: &mut W) -> Result<()>
+pub fn to_record_writer<T, W>(value: &T, writer: &mut W) -> Result<()>
 where
     T: Serialize + ?Sized,
     W: RecordWriter + ?Sized,
@@ -154,7 +154,7 @@ where
 ///
 /// Currently uses `postcard` deserializer, with optional scratch
 /// buffer to deserialize into
-pub(super) fn from_replay_reader<'a, T, R>(reader: &'a mut R, scratch: &'a mut [u8]) -> Result<T>
+pub fn from_replay_reader<'a, T, R>(reader: &'a mut R, scratch: &'a mut [u8]) -> Result<T>
 where
     T: Deserialize<'a>,
     R: ReplayReader + ?Sized,