Merge pull request #216 from bytecodealliance/dicej/miri-async-tests

make it easier to run `component-async-tests` with miri

Author: dicej

crates/misc/component-async-tests/Cargo.toml

@@ -27,6 +27,7 @@ wasm-compose = { workspace = true }
 wasmparser = { workspace = true }
 wasmtime = { workspace = true, features = [
   "default",
+  "pulley",
   "cranelift",
   "component-model-async",
 ] }

crates/misc/component-async-tests/src/util.rs

@@ -1,9 +1,14 @@
-use std::sync::{Arc, Mutex, Once};
+use std::collections::HashMap;
+use std::env;
+use std::ops::Deref;
+use std::path::Path;
+use std::sync::{Arc, LazyLock, Once};
 use std::time::Duration;
 
-use anyhow::Result;
+use anyhow::{Result, anyhow, bail};
 use futures::stream::{FuturesUnordered, TryStreamExt};
 use tokio::fs;
+use tokio::sync::Mutex;
 use wasm_compose::composer::ComponentComposer;
 use wasmtime::component::{Component, Linker, ResourceTable};
 use wasmtime::{Config, Engine, Store};
@@ -20,7 +25,14 @@ pub fn config() -> Config {
     init_logger();
 
     let mut config = Config::new();
-    config.cranelift_debug_verifier(true);
+    if env::var_os("MIRI_TEST_CWASM_DIR").is_some() {
+        config.target("pulley64").unwrap();
+        config.memory_reservation(1 << 20);
+        config.memory_guard_size(0);
+        config.signals_based_traps(false);
+    } else {
+        config.cranelift_debug_verifier(true);
+    }
     config.wasm_component_model(true);
     config.wasm_component_model_async(true);
     config.wasm_component_model_async_builtins(true);
@@ -34,7 +46,7 @@ pub fn config() -> Config {
 ///
 /// a is the "root" component, and b is composed into it
 #[allow(unused)]
-pub async fn compose(a: &[u8], b: &[u8]) -> Result<Vec<u8>> {
+async fn compose(a: &[u8], b: &[u8]) -> Result<Vec<u8>> {
     let dir = tempfile::tempdir()?;
 
     let a_file = dir.path().join("a.wasm");
@@ -54,18 +66,111 @@ pub async fn compose(a: &[u8], b: &[u8]) -> Result<Vec<u8>> {
     .compose()
 }
 
+pub async fn make_component(engine: &Engine, components: &[&str]) -> Result<Component> {
+    fn cwasm_name(components: &[&str]) -> Result<String> {
+        if components.is_empty() {
+            Err(anyhow!("expected at least one path"))
+        } else {
+            let names = components
+                .iter()
+                .map(|&path| {
+                    let path = Path::new(path);
+                    if let Some(name) = path.file_name() {
+                        Ok(name)
+                    } else {
+                        Err(anyhow!(
+                            "expected path with at least two components; got: {}",
+                            path.display()
+                        ))
+                    }
+                })
+                .collect::<Result<Vec<_>>>()?;
+
+            Ok(format!(
+                "{}.cwasm",
+                names
+                    .iter()
+                    .map(|name| { name.to_str().unwrap() })
+                    .collect::<Vec<_>>()
+                    .join("+")
+            ))
+        }
+    }
+
+    async fn compile(engine: &Engine, components: &[&str]) -> Result<Vec<u8>> {
+        match components {
+            [component] => engine.precompile_component(&fs::read(component).await?),
+            [a, b] => engine
+                .precompile_component(&compose(&fs::read(a).await?, &fs::read(b).await?).await?),
+            _ => Err(anyhow!("expected one or two paths")),
+        }
+    }
+
+    async fn load(engine: &Engine, components: &[&str]) -> Result<Vec<u8>> {
+        let cwasm_path = if let Some(cwasm_dir) = &env::var_os("MIRI_TEST_CWASM_DIR") {
+            Some(Path::new(cwasm_dir).join(cwasm_name(components)?))
+        } else {
+            None
+        };
+
+        if let Some(cwasm_path) = &cwasm_path {
+            if let Ok(compiled) = fs::read(cwasm_path).await {
+                return Ok(compiled);
+            }
+        }
+
+        if cfg!(miri) {
+            bail!(
+                "Running these tests with miri requires precompiled .cwasm files.\n\
+                 Please set the `MIRI_TEST_CWASM_DIR` environment variable to the\n\
+                 absolute path of a valid directory, then run the test(s)\n\
+                 _without_ miri, and finally run them again _with_ miri."
+            )
+        }
+
+        let compiled = compile(engine, components).await?;
+        if let Some(cwasm_path) = &cwasm_path {
+            fs::write(cwasm_path, &compiled).await?;
+        }
+        Ok(compiled)
+    }
+
+    static CACHE: LazyLock<Mutex<HashMap<Vec<String>, Arc<Mutex<Option<Arc<Vec<u8>>>>>>>> =
+        LazyLock::new(|| Mutex::new(HashMap::new()));
+
+    let compiled = {
+        let entry = CACHE
+            .lock()
+            .await
+            .entry(components.iter().map(|&s| s.to_owned()).collect())
+            .or_insert_with(|| Arc::new(Mutex::new(None)))
+            .clone();
+
+        let mut entry = entry.lock().await;
+        if let Some(component) = entry.deref() {
+            component.clone()
+        } else {
+            let component = Arc::new(load(engine, components).await?);
+            *entry = Some(component.clone());
+            component
+        }
+    };
+
+    Ok(unsafe { Component::deserialize(&engine, &*compiled)? })
+}
+
 #[allow(unused)]
-pub async fn test_run(component: &[u8]) -> Result<()> {
-    test_run_with_count(component, 3).await
+pub async fn test_run(components: &[&str]) -> Result<()> {
+    test_run_with_count(components, 3).await
 }
 
-pub async fn test_run_with_count(component: &[u8], count: usize) -> Result<()> {
+pub async fn test_run_with_count(components: &[&str], count: usize) -> Result<()> {
     let mut config = config();
     config.epoch_interruption(true);
 
     let engine = Engine::new(&config)?;
 
-    let component = Component::new(&engine, component)?;
+    let component = make_component(&engine, components).await?;
 
     let mut linker = Linker::new(&engine);
 
@@ -90,7 +195,7 @@ pub async fn test_run_with_count(component: &[u8], count: usize) -> Result<()> {
             wasi: WasiCtxBuilder::new().inherit_stdio().build(),
             table: ResourceTable::default(),
             continue_: false,
-            wakers: Arc::new(Mutex::new(None)),
+            wakers: Arc::new(std::sync::Mutex::new(None)),
         },
     );
     store.set_epoch_deadline(1);

crates/misc/component-async-tests/tests/scenario/backpressure.rs

@@ -1,7 +1,6 @@
 use anyhow::Result;
-use tokio::fs;
 
-use component_async_tests::util::{compose, test_run};
+use component_async_tests::util::test_run;
 
 // No-op function; we only test this by composing it in `async_backpressure_caller`
 #[allow(
@@ -12,7 +11,9 @@ pub fn async_backpressure_callee() {}
 
 #[tokio::test]
 pub async fn async_backpressure_caller() -> Result<()> {
-    let caller = &fs::read(test_programs_artifacts::ASYNC_BACKPRESSURE_CALLER_COMPONENT).await?;
-    let callee = &fs::read(test_programs_artifacts::ASYNC_BACKPRESSURE_CALLEE_COMPONENT).await?;
-    test_run(&compose(caller, callee).await?).await
+    test_run(&[
+        test_programs_artifacts::ASYNC_BACKPRESSURE_CALLER_COMPONENT,
+        test_programs_artifacts::ASYNC_BACKPRESSURE_CALLEE_COMPONENT,
+    ])
+    .await
 }

crates/misc/component-async-tests/tests/scenario/borrowing.rs

@@ -3,55 +3,73 @@ use std::time::Duration;
 
 use anyhow::Result;
 use futures::stream::{FuturesUnordered, TryStreamExt};
-use tokio::fs;
-use wasmtime::component::{Component, Linker, ResourceTable};
+use wasmtime::component::{Linker, ResourceTable};
 use wasmtime::{Engine, Store};
 use wasmtime_wasi::p2::WasiCtxBuilder;
 
-use component_async_tests::util::{compose, config};
+use component_async_tests::util::{config, make_component};
 
 #[tokio::test]
 pub async fn async_borrowing_caller() -> Result<()> {
-    let caller = &fs::read(test_programs_artifacts::ASYNC_BORROWING_CALLER_COMPONENT).await?;
-    let callee = &fs::read(test_programs_artifacts::ASYNC_BORROWING_CALLEE_COMPONENT).await?;
-    test_run_bool(&compose(caller, callee).await?, false).await
+    test_run_bool(
+        &[
+            test_programs_artifacts::ASYNC_BORROWING_CALLER_COMPONENT,
+            test_programs_artifacts::ASYNC_BORROWING_CALLEE_COMPONENT,
+        ],
+        false,
+    )
+    .await
 }
 
 #[tokio::test]
 async fn async_borrowing_caller_misbehave() -> Result<()> {
-    let caller = &fs::read(test_programs_artifacts::ASYNC_BORROWING_CALLER_COMPONENT).await?;
-    let callee = &fs::read(test_programs_artifacts::ASYNC_BORROWING_CALLEE_COMPONENT).await?;
     let error = format!(
         "{:?}",
-        test_run_bool(&compose(caller, callee).await?, true)
-            .await
-            .unwrap_err()
+        test_run_bool(
+            &[
+                test_programs_artifacts::ASYNC_BORROWING_CALLER_COMPONENT,
+                test_programs_artifacts::ASYNC_BORROWING_CALLEE_COMPONENT
+            ],
+            true
+        )
+        .await
+        .unwrap_err()
     );
     assert!(error.contains("unknown handle index"), "{error}");
     Ok(())
 }
 
 #[tokio::test]
 async fn async_borrowing_callee_misbehave() -> Result<()> {
-    let callee = &fs::read(test_programs_artifacts::ASYNC_BORROWING_CALLEE_COMPONENT).await?;
-    let error = format!("{:?}", test_run_bool(callee, true).await.unwrap_err());
+    let error = format!(
+        "{:?}",
+        test_run_bool(
+            &[test_programs_artifacts::ASYNC_BORROWING_CALLEE_COMPONENT],
+            true
+        )
+        .await
+        .unwrap_err()
+    );
     assert!(error.contains("unknown handle index"), "{error}");
     Ok(())
 }
 
 #[tokio::test]
 pub async fn async_borrowing_callee() -> Result<()> {
-    let callee = &fs::read(test_programs_artifacts::ASYNC_BORROWING_CALLEE_COMPONENT).await?;
-    test_run_bool(callee, false).await
+    test_run_bool(
+        &[test_programs_artifacts::ASYNC_BORROWING_CALLEE_COMPONENT],
+        false,
+    )
+    .await
 }
 
-pub async fn test_run_bool(component: &[u8], v: bool) -> Result<()> {
+pub async fn test_run_bool(components: &[&str], v: bool) -> Result<()> {
     let mut config = config();
     config.epoch_interruption(true);
 
     let engine = Engine::new(&config)?;
 
-    let component = Component::new(&engine, component)?;
+    let component = make_component(&engine, components).await?;
 
     let mut linker = Linker::new(&engine);
 

crates/misc/component-async-tests/tests/scenario/error_context.rs

@@ -1,28 +1,22 @@
 use anyhow::Result;
-use tokio::fs;
 
-use component_async_tests::util::{compose, test_run};
+use component_async_tests::util::test_run;
 
 #[tokio::test]
 pub async fn async_error_context() -> Result<()> {
-    test_run(&fs::read(test_programs_artifacts::ASYNC_ERROR_CONTEXT_COMPONENT).await?).await
+    test_run(&[test_programs_artifacts::ASYNC_ERROR_CONTEXT_COMPONENT]).await
 }
 
 #[tokio::test]
 pub async fn async_error_context_callee() -> Result<()> {
-    test_run(&fs::read(test_programs_artifacts::ASYNC_ERROR_CONTEXT_COMPONENT).await?).await
+    test_run(&[test_programs_artifacts::ASYNC_ERROR_CONTEXT_COMPONENT]).await
 }
 
 #[tokio::test]
 pub async fn async_error_context_caller() -> Result<()> {
-    let caller = &fs::read(test_programs_artifacts::ASYNC_ERROR_CONTEXT_CALLER_COMPONENT).await?;
-    let callee = &fs::read(test_programs_artifacts::ASYNC_ERROR_CONTEXT_CALLEE_COMPONENT).await?;
-    test_run(&compose(caller, callee).await?).await
-}
-
-#[tokio::test]
-async fn async_error_context_roundtrip() -> Result<()> {
-    let caller = &fs::read(test_programs_artifacts::ASYNC_ERROR_CONTEXT_CALLER_COMPONENT).await?;
-    let callee = &fs::read(test_programs_artifacts::ASYNC_ERROR_CONTEXT_CALLEE_COMPONENT).await?;
-    test_run(&compose(caller, callee).await?).await
+    test_run(&[
+        test_programs_artifacts::ASYNC_ERROR_CONTEXT_CALLER_COMPONENT,
+        test_programs_artifacts::ASYNC_ERROR_CONTEXT_CALLEE_COMPONENT,
+    ])
+    .await
 }

crates/misc/component-async-tests/tests/scenario/post_return.rs

@@ -1,7 +1,6 @@
 use anyhow::Result;
-use tokio::fs;
 
-use component_async_tests::util::{compose, test_run};
+use component_async_tests::util::test_run;
 
 // No-op function; we only test this by composing it in `async_post_return_caller`
 #[allow(
@@ -12,7 +11,9 @@ pub fn async_post_return_callee() {}
 
 #[tokio::test]
 pub async fn async_post_return_caller() -> Result<()> {
-    let caller = &fs::read(test_programs_artifacts::ASYNC_POST_RETURN_CALLER_COMPONENT).await?;
-    let callee = &fs::read(test_programs_artifacts::ASYNC_POST_RETURN_CALLEE_COMPONENT).await?;
-    test_run(&compose(caller, callee).await?).await
+    test_run(&[
+        test_programs_artifacts::ASYNC_POST_RETURN_CALLER_COMPONENT,
+        test_programs_artifacts::ASYNC_POST_RETURN_CALLEE_COMPONENT,
+    ])
+    .await
 }

crates/misc/component-async-tests/tests/scenario/read_resource_stream.rs

@@ -1,9 +1,8 @@
 use anyhow::Result;
-use tokio::fs;
 
 use component_async_tests::util::test_run;
 
 #[tokio::test]
 pub async fn async_read_resource_stream() -> Result<()> {
-    test_run(&fs::read(test_programs_artifacts::ASYNC_READ_RESOURCE_STREAM_COMPONENT).await?).await
+    test_run(&[test_programs_artifacts::ASYNC_READ_RESOURCE_STREAM_COMPONENT]).await
 }