Feature-complete RR

crates/wasmtime/Cargo.toml

@@ -63,7 +63,6 @@ hashbrown = { workspace = true, features = ["default-hasher"] }
 bitflags = { workspace = true }
 futures = { workspace = true, features = ["alloc"], optional = true }
 bytes = { workspace = true, optional = true }
-embedded-io = { version = "0.6.1", features = ["alloc"], optional = true }
 
 [target.'cfg(target_os = "windows")'.dependencies.windows-sys]
 workspace = true
@@ -428,4 +427,4 @@ debug = [
 compile-time-builtins = ['dep:wasm-compose', 'dep:tempfile']
 
 # Enable support for the common base infrastructure of record/replay
-rr = ["component-model", "dep:embedded-io"]
+rr = ["component-model"]

crates/wasmtime/src/runtime/rr/core.rs

@@ -6,7 +6,7 @@ pub use events::{
     RRFuncArgVals, ResultEvent, Validate, common_events, component_events, core_events,
     marker_events,
 };
-pub use io::{IOError, RecordWriter, ReplayReader};
+pub use io::{RecordWriter, ReplayReader};
 use serde::{Deserialize, Serialize};
 use wasmtime_environ::{EntityIndex, WasmChecksum};
 
@@ -189,7 +189,7 @@ pub enum ReplayError {
     FailedValidation,
     IncorrectEventVariant,
     InvalidEventPosition,
-    FailedRead(IOError),
+    FailedRead(anyhow::Error),
     EventError(Box<dyn EventError>),
     MissingComponent(WasmChecksum),
     MissingModule(WasmChecksum),

crates/wasmtime/src/runtime/rr/core/io.rs

@@ -3,36 +3,35 @@ use core::any::Any;
 use postcard;
 use serde::{Deserialize, Serialize};
 
-pub type IOError = postcard::Error;
-
 cfg_if::cfg_if! {
     if #[cfg(feature = "std")] {
         use std::io::{Write, Seek, Read};
-        /// An [`Write`] usable for recording in RR
-        ///
-        /// This supports `no_std`, but must be [Send] and [Sync]
+        /// A writer for recording in RR.
         pub trait RecordWriter: Write + Send + Sync + Any {}
         impl<T: Write + Send + Sync + Any> RecordWriter for T {}
 
-        /// An [`Read`] usable for replaying in RR
+        /// A reader for replaying in RR.
         pub trait ReplayReader: Read + Seek + Send + Sync {}
         impl<T: Read + Seek + Send + Sync> ReplayReader for T {}
 
     } else {
-        // `no_std` configuration
-        use embedded_io::{Read, Seek, Write};
+        use core::{convert::AsRef, iter::Extend};
 
-        /// An [`Write`] usable for recording in RR
-        ///
-        /// This supports `no_std`, but must be [Send] and [Sync]
-        pub trait RecordWriter: Write + Send + Sync + Any {}
-        impl<T: Write + Send + Sync + Any> RecordWriter for T {}
+        /// A writer for recording in RR.
+        pub trait RecordWriter: Extend<u8> + Send + Sync + Any {}
+        impl<T: Extend<u8> + Send + Sync + Any> RecordWriter for T {}
 
-        /// An [`Read`] usable for replaying in RR
+        /// A reader for replaying in RR.
         ///
-        /// This supports `no_std`, but must be [Send] and [Sync]
-        pub trait ReplayReader: Read + Seek + Send + Sync {}
-        impl<T: Read + Seek + Send + Sync> ReplayReader for T {}
+        /// In `no_std`, types must provide explicit read/seek capabilities
+        /// to a underlying byte slice through these methods.
+        pub trait ReplayReader: AsRef<[u8]> + Send + Sync {
+            /// Advance the reader's internal cursor by `cnt` bytes
+            fn advance(&mut self, cnt: usize);
+            /// Seek to an absolute position `pos` in the reader
+            fn seek(&mut self, pos: usize);
+        }
+
     }
 }
 
@@ -44,12 +43,13 @@ where
     T: Serialize + ?Sized,
     W: RecordWriter,
 {
-    cfg_if::cfg_if! {
-        if #[cfg(feature = "std")] {
-            postcard::to_io(value, writer)?;
-        } else {
-            postcard::to_eio(value, writer)?;
-        }
+    #[cfg(feature = "std")]
+    {
+        postcard::to_io(value, writer)?;
+    }
+    #[cfg(not(feature = "std"))]
+    {
+        postcard::to_extend(value, writer)?;
     }
     Ok(())
 }
@@ -58,16 +58,21 @@ where
 ///
 /// Currently uses `postcard` deserializer, with optional scratch
 /// buffer to deserialize into
-pub(super) fn from_replay_reader<'a, T, R>(reader: R, scratch: &'a mut [u8]) -> Result<T, IOError>
+pub(super) fn from_replay_reader<'a, T, R>(reader: &'a mut R, scratch: &'a mut [u8]) -> Result<T>
 where
     T: Deserialize<'a>,
-    R: ReplayReader + 'a,
+    R: ReplayReader,
 {
-    cfg_if::cfg_if! {
-        if #[cfg(feature = "std")] {
-            Ok(postcard::from_io((reader, scratch))?.0)
-        } else {
-            Ok(postcard::from_eio((reader, scratch))?.0)
-        }
+    #[cfg(feature = "std")]
+    {
+        Ok(postcard::from_io((reader, scratch))?.0)
+    }
+    #[cfg(not(feature = "std"))]
+    {
+        let bytes = reader.as_ref();
+        let original_len = bytes.len();
+        let (value, new) = postcard::take_from_bytes(bytes)?;
+        reader.advance(new.len() - original_len);
+        Ok(value)
     }
 }