Record and Replay Support for Component Model

crates/cli-flags/src/lib.rs

@@ -6,9 +6,10 @@ use serde::Deserialize;
 use std::{
     fmt, fs,
     path::{Path, PathBuf},
+    sync::Arc,
     time::Duration,
 };
-use wasmtime::Config;
+use wasmtime::{Config, RRConfig, RecordConfig, RecordMetadata, ReplayConfig, ReplayMetadata};
 
 pub mod opt;
 
@@ -478,6 +479,38 @@ wasmtime_option_group! {
     }
 }
 
+wasmtime_option_group! {
+    #[derive(PartialEq, Clone, Deserialize)]
+    #[serde(rename_all = "kebab-case", deny_unknown_fields)]
+    pub struct RecordOptions {
+        /// Filesystem endpoint to store the recorded execution trace
+        pub path: Option<String>,
+        /// Include (optional) signatures to facilitate validation checks during replay
+        /// (see `validate` in replay options).
+        pub validation_metadata: Option<bool>,
+    }
+
+    enum Record {
+        ...
+    }
+}
+
+wasmtime_option_group! {
+    #[derive(PartialEq, Clone, Deserialize)]
+    #[serde(rename_all = "kebab-case", deny_unknown_fields)]
+    pub struct ReplayOptions {
+        /// Filesystem endpoint to read the recorded execution trace from
+        pub path: Option<String>,
+        /// Dynamic validation checks of record signatures to guarantee faithful replay.
+        /// Requires record traces to be generated with `validation_metadata` enabled.
+        pub validate: Option<bool>,
+    }
+
+    enum Replay {
+        ...
+    }
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub struct WasiNnGraph {
     pub format: String,
@@ -528,6 +561,29 @@ pub struct CommonOptions {
     #[serde(skip)]
     wasi_raw: Vec<opt::CommaSeparated<Wasi>>,
 
+    /// Options to enable and configure execution recording, `-R help` to see all.
+    ///
+    /// Generates of a serialized trace of the Wasm module execution that captures all
+    /// non-determinism observable by the module. This trace can subsequently be
+    /// re-executed in a determinstic, embedding-agnostic manner (see the `--replay` option).
+    ///
+    /// Note: Minimal configs for deterministic Wasm semantics will be
+    /// enforced during recording by default (NaN canonicalization, deterministic relaxed SIMD)
+    #[arg(short = 'R', long = "record", value_name = "KEY[=VAL[,..]]")]
+    #[serde(skip)]
+    record_raw: Vec<opt::CommaSeparated<Record>>,
+
+    /// Options to enable and configure execution replay, `-P help` to see all.
+    ///
+    /// Run a determinstic, embedding-agnostic replay execution of the Wasm module
+    /// according to a prior recorded execution trace (see the `--record` option).
+    ///
+    /// Note: Minimal configs for deterministic Wasm semantics will be
+    /// enforced during replay by default (NaN canonicalization, deterministic relaxed SIMD)
+    #[arg(short = 'P', long = "replay", value_name = "KEY[=VAL[,..]]")]
+    #[serde(skip)]
+    replay_raw: Vec<opt::CommaSeparated<Replay>>,
+
     // These fields are filled in by the `configure` method below via the
     // options parsed from the CLI above. This is what the CLI should use.
     #[arg(skip)]
@@ -554,6 +610,14 @@ pub struct CommonOptions {
     #[serde(rename = "wasi", default)]
     pub wasi: WasiOptions,
 
+    #[arg(skip)]
+    #[serde(rename = "record", default)]
+    pub record: RecordOptions,
+
+    #[arg(skip)]
+    #[serde(rename = "replay", default)]
+    pub replay: ReplayOptions,
+
     /// The target triple; default is the host triple
     #[arg(long, value_name = "TARGET")]
     #[serde(skip)]
@@ -600,12 +664,16 @@ impl CommonOptions {
             debug_raw: Vec::new(),
             wasm_raw: Vec::new(),
             wasi_raw: Vec::new(),
+            record_raw: Vec::new(),
+            replay_raw: Vec::new(),
             configured: true,
             opts: Default::default(),
             codegen: Default::default(),
             debug: Default::default(),
             wasm: Default::default(),
             wasi: Default::default(),
+            record: Default::default(),
+            replay: Default::default(),
             target: None,
             config: None,
         }
@@ -623,12 +691,16 @@ impl CommonOptions {
             self.debug = toml_options.debug;
             self.wasm = toml_options.wasm;
             self.wasi = toml_options.wasi;
+            self.record = toml_options.record;
+            self.replay = toml_options.replay;
         }
         self.opts.configure_with(&self.opts_raw);
         self.codegen.configure_with(&self.codegen_raw);
         self.debug.configure_with(&self.debug_raw);
         self.wasm.configure_with(&self.wasm_raw);
         self.wasi.configure_with(&self.wasi_raw);
+        self.record.configure_with(&self.record_raw);
+        self.replay.configure_with(&self.replay_raw);
         Ok(())
     }
 
@@ -970,6 +1042,27 @@ impl CommonOptions {
             true => err,
         }
 
+        let record = &self.record;
+        let replay = &self.replay;
+        let rr_cfg = if let Some(path) = record.path.clone() {
+            Some(RRConfig::from(RecordConfig {
+                writer_initializer: Arc::new(move || Box::new(fs::File::create(&path).unwrap())),
+                metadata: RecordMetadata {
+                    add_validation: record.validation_metadata.unwrap_or(false),
+                },
+            }))
+        } else if let Some(path) = replay.path.clone() {
+            Some(RRConfig::from(ReplayConfig {
+                reader_initializer: Arc::new(move || Box::new(fs::File::open(&path).unwrap())),
+                metadata: ReplayMetadata {
+                    validate: replay.validate.unwrap_or(false),
+                },
+            }))
+        } else {
+            None
+        };
+        config.rr(rr_cfg);
+
         Ok(config)
     }
 
@@ -1074,6 +1167,8 @@ mod tests {
             [debug]
             [wasm]
             [wasi]
+            [record]
+            [replay]
         "#;
         let mut common_options: CommonOptions = toml::from_str(basic_toml).unwrap();
         common_options.config(None).unwrap();
@@ -1195,6 +1290,10 @@ impl fmt::Display for CommonOptions {
             wasm,
             wasi_raw,
             wasi,
+            record_raw,
+            record,
+            replay_raw,
+            replay,
             configured,
             target,
             config,
@@ -1211,13 +1310,17 @@ impl fmt::Display for CommonOptions {
         let wasi_flags;
         let wasm_flags;
         let debug_flags;
+        let record_flags;
+        let replay_flags;
 
         if *configured {
             codegen_flags = codegen.to_options();
             debug_flags = debug.to_options();
             wasi_flags = wasi.to_options();
             wasm_flags = wasm.to_options();
             opts_flags = opts.to_options();
+            record_flags = record.to_options();
+            replay_flags = replay.to_options();
         } else {
             codegen_flags = codegen_raw
                 .iter()
@@ -1228,6 +1331,16 @@ impl fmt::Display for CommonOptions {
             wasi_flags = wasi_raw.iter().flat_map(|t| t.0.iter()).cloned().collect();
             wasm_flags = wasm_raw.iter().flat_map(|t| t.0.iter()).cloned().collect();
             opts_flags = opts_raw.iter().flat_map(|t| t.0.iter()).cloned().collect();
+            record_flags = record_raw
+                .iter()
+                .flat_map(|t| t.0.iter())
+                .cloned()
+                .collect();
+            replay_flags = replay_raw
+                .iter()
+                .flat_map(|t| t.0.iter())
+                .cloned()
+                .collect();
         }
 
         for flag in codegen_flags {
@@ -1245,6 +1358,12 @@ impl fmt::Display for CommonOptions {
         for flag in debug_flags {
             write!(f, "-D{flag} ")?;
         }
+        for flag in record_flags {
+            write!(f, "-R{flag} ")?;
+        }
+        for flag in replay_flags {
+            write!(f, "-P{flag} ")?;
+        }
 
         Ok(())
     }

crates/environ/src/component/artifacts.rs

@@ -18,6 +18,8 @@ pub struct ComponentArtifacts {
     pub types: ComponentTypes,
     /// Serialized metadata about all included core wasm modules.
     pub static_modules: PrimaryMap<StaticModuleIndex, CompiledModuleInfo>,
+    /// A SHA-256 checksum of the source Wasm binary from which the component was compiled
+    pub checksum: [u8; 32],
 }
 
 /// Runtime state that a component retains to support its operation.

crates/wasmtime/Cargo.toml

@@ -45,7 +45,7 @@ wat = { workspace = true, optional = true }
 serde = { workspace = true }
 serde_derive = { workspace = true }
 serde_json = { workspace = true, optional = true }
-postcard = { workspace = true }
+postcard = { workspace = true, features = ["use-std"] }
 indexmap = { workspace = true }
 once_cell = { version = "1.12.0", optional = true }
 rayon = { version = "1.0", optional = true }
@@ -62,6 +62,7 @@ smallvec = { workspace = true, optional = true }
 hashbrown = { workspace = true, features = ["default-hasher"] }
 bitflags = { workspace = true }
 futures = { workspace = true, features = ["alloc"], optional = true }
+sha2 = "0.10.2"
 
 [target.'cfg(target_os = "windows")'.dependencies.windows-sys]
 workspace = true
@@ -393,3 +394,20 @@ component-model-async = [
   "wasmtime-component-macro?/component-model-async",
   "dep:futures"
 ]
+
+# Enables support for record/replay
+rr = ["rr-component", "rr-core"]
+
+# Component model RR support
+rr-component = ["component-model", "std"]
+
+# Core wasm RR support
+rr-core = ["std"]
+
+# Support for type information of recorded events for replay validation
+rr-type-validation = []
+
+# Support for input values to recorded events for replay validation.
+#
+# This can be used to check whether the entire module is truly deterministic
+rr-args-validation = []

crates/wasmtime/src/compile.rs

@@ -26,6 +26,7 @@ use crate::Engine;
 use crate::hash_map::HashMap;
 use crate::hash_set::HashSet;
 use crate::prelude::*;
+use sha2::{Digest, Sha256};
 use std::{
     any::Any,
     borrow::Cow,
@@ -198,6 +199,7 @@ pub(crate) fn build_component_artifacts<T: FinishedObject>(
         ty,
         types,
         static_modules: compilation_artifacts.modules,
+        checksum: Sha256::digest(binary).into(),
     };
     object.serialize_info(&artifacts);