Added temporary CLI support (without async)

Author: arjunr2

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

@@ -488,11 +488,7 @@ impl Drop for ReplayBuffer {
         let mut remaining_events = 0;
         // Cannot use count() in iterator because IO error may loop indefinitely
         while let Some(event) = self.next() {
-            if let Ok(e) = event {
-                println!("Remaining event: {:?}", e);
-            } else {
-                event.unwrap();
-            };
+            event.unwrap();
             remaining_events += 1;
         }
         if remaining_events > 0 {

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

@@ -2,8 +2,9 @@ use crate::component::{self, Component, Val};
 #[cfg(feature = "rr-component")]
 use crate::rr::component_events;
 use crate::rr::{RREvent, ReplayError, Validate, component_hooks::ReplayLoweringPhase};
-use crate::{AsContextMut, Engine, ReplayReader, ReplaySettings, Store};
-use crate::{Module, ValRaw, prelude::*};
+use crate::{
+    AsContextMut, Engine, Module, ReplayReader, ReplaySettings, Store, ValRaw, prelude::*,
+};
 use alloc::collections::BTreeMap;
 use core::mem::MaybeUninit;
 #[cfg(feature = "rr-component")]

src/commands/replay.rs

@@ -24,8 +24,8 @@ pub struct ReplayOptions {
     pub validate: bool,
 
     /// Size of static buffer needed to deserialized variable-length types like String. This is not
-    /// not relevant for basic functional recording/replaying, but may be required to replay traces where
-    /// `validation-metadata` was enabled for recording
+    /// not important for basic functional recording/replaying, but may be required to replay traces where
+    /// `validate` was enabled for recording
     #[arg(short, long, default_value_t = 64)]
     pub deser_buffer_size: usize,
 }

src/commands/run.rs

@@ -17,6 +17,8 @@ use std::path::{Path, PathBuf};
 use std::sync::{Arc, Mutex};
 use std::thread;
 use wasi_common::sync::{Dir, TcpListener, WasiCtxBuilder, ambient_authority};
+#[cfg(feature = "rr")]
+use wasmtime::ReplayEnvironment;
 use wasmtime::{Engine, Func, Module, Store, StoreLimits, Val, ValType};
 use wasmtime_wasi::{WasiCtxView, WasiView};
 
@@ -100,7 +102,16 @@ impl RunCommand {
         self.run.common.init_logging()?;
 
         let mut config = self.run.common.config(None)?;
+        #[cfg(not(feature = "rr"))]
         config.async_support(true);
+        #[cfg(feature = "rr")]
+        if replay_opts.is_some() {
+            // Replay does not support async yet
+            config.async_support(false);
+            config.rr(wasmtime::RRConfig::Replaying);
+        } else {
+            config.async_support(true);
+        }
 
         if self.run.common.wasm.timeout.is_some() {
             config.epoch_interruption(true);
@@ -116,11 +127,6 @@ impl RunCommand {
             None => {}
         }
 
-        #[cfg(feature = "rr")]
-        if replay_opts.is_some() {
-            config.replaying(true);
-        }
-
         let engine = Engine::new(&config)?;
 
         // Read the wasm module binary either as `*.wat` or a raw binary.
@@ -167,7 +173,13 @@ impl RunCommand {
         };
 
         let mut store = Store::new(&engine, host);
+        #[cfg(not(feature = "rr"))]
         self.populate_with_wasi(&mut linker, &mut store, &main)?;
+        // For replay, we don't populate WASI
+        #[cfg(feature = "rr")]
+        if !replay_opts.is_some() {
+            self.populate_with_wasi(&mut linker, &mut store, &main)?;
+        }
 
         store.data_mut().limits = self.run.store_limits();
         store.limiter(|t| &mut t.limits);
@@ -180,6 +192,33 @@ impl RunCommand {
 
         #[cfg(feature = "rr")]
         {
+            // If this is a replay run, skip to replay setup and run to completion
+            //
+            // Note: Right now, replay doesn't inherit any store settings listed
+            // above. This will have to change in the future. In general, replays will
+            // need an "almost exact" superset of the run configurations, but with
+            // certain different options (e.g. fuel consumption).
+            if let Some(opts) = replay_opts {
+                let settings = ReplaySettings {
+                    validate: opts.validate,
+                    deser_buffer_size: opts.deser_buffer_size,
+                    ..Default::default()
+                };
+
+                let mut renv = ReplayEnvironment::new(&engine, settings);
+                match main {
+                    RunTarget::Core(m) => {
+                        renv.add_module(m);
+                    }
+                    RunTarget::Component(c) => {
+                        renv.add_component(c);
+                    }
+                }
+                let mut instance = renv.instantiate(BufReader::new(fs::File::open(opts.trace)?))?;
+                return instance.run_to_completion();
+            }
+
+            // Recording settings for this execution's store
             let record = &self.run.common.record;
             if let Some(path) = &record.path {
                 let default_settings = RecordSettings::default();
@@ -197,18 +236,6 @@ impl RunCommand {
                     store.init_recording(fs::File::create(&path)?, settings)?;
                 }
             }
-
-            if let Some(opts) = replay_opts {
-                let settings = ReplaySettings {
-                    validate: opts.validate,
-                    deser_buffer_size: opts.deser_buffer_size,
-                    ..Default::default()
-                };
-                store.init_replaying(
-                    BufReader::new(fs::File::open(opts.trace).unwrap()),
-                    settings,
-                )?;
-            }
         }
 
         // Always run the module asynchronously to ensure that the module can be