From 57dfe99aa5b2b3673871c716c6a7a6c0010f8f19 Mon Sep 17 00:00:00 2001
From: Peter Huene <peter@huene.dev>
Date: Fri, 5 Mar 2021 20:55:51 -0800
Subject: [PATCH] Run wast tests with both instance allocators.

This commit adds a "pooling" variant to the wast tests that uses the pooling
instance allocation strategy.

This should help with the test coverage of the pooling instance allocator.
---
 .github/workflows/main.yml |  1 +
 build.rs                   | 20 ++++++++++++++++----
 tests/all/wast.rs          | 31 +++++++++++++++++++++++++++++--
 3 files changed, 46 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 8b69ccfec2..47efbda923 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -305,6 +305,7 @@ jobs:
     - run: |
         cargo test --features uffd -p wasmtime-runtime instance::allocator::pooling
         cargo test --features uffd -p wasmtime-cli pooling_allocator
+        cargo test --features uffd -p wasmtime-cli wast::Cranelift
       if: matrix.os == 'ubuntu-latest'
       env:
         RUST_BACKTRACE: 1
diff --git a/build.rs b/build.rs
index 5393166913..a41bbf844b 100644
--- a/build.rs
+++ b/build.rs
@@ -111,7 +111,8 @@ fn test_directory(
 
     let testsuite = &extract_name(path);
     for entry in dir_entries.iter() {
-        write_testsuite_tests(out, entry, testsuite, strategy)?;
+        write_testsuite_tests(out, entry, testsuite, strategy, false)?;
+        write_testsuite_tests(out, entry, testsuite, strategy, true)?;
     }
 
     Ok(dir_entries.len())
@@ -148,6 +149,7 @@ fn write_testsuite_tests(
     path: impl AsRef<Path>,
     testsuite: &str,
     strategy: &str,
+    pooling: bool,
 ) -> anyhow::Result<()> {
     let path = path.as_ref();
     let testname = extract_name(path);
@@ -160,14 +162,24 @@ fn write_testsuite_tests(
         )?;
     } else if ignore(testsuite, &testname, strategy) {
         writeln!(out, "#[ignore]")?;
+    } else if pooling {
+        // Ignore on aarch64 due to using QEMU for running tests (limited memory)
+        writeln!(out, r#"#[cfg_attr(target_arch = "aarch64", ignore)]"#)?;
     }
-    writeln!(out, "fn r#{}() {{", &testname)?;
+
+    writeln!(
+        out,
+        "fn r#{}{}() {{",
+        &testname,
+        if pooling { "_pooling" } else { "" }
+    )?;
     writeln!(out, "    let _ = env_logger::try_init();")?;
     writeln!(
         out,
-        "    crate::wast::run_wast(r#\"{}\"#, crate::wast::Strategy::{}).unwrap();",
+        "    crate::wast::run_wast(r#\"{}\"#, crate::wast::Strategy::{}, {}).unwrap();",
         path.display(),
-        strategy
+        strategy,
+        pooling
     )?;
     writeln!(out, "}}")?;
     writeln!(out)?;
diff --git a/tests/all/wast.rs b/tests/all/wast.rs
index 362dca274b..fd8a4f3a5b 100644
--- a/tests/all/wast.rs
+++ b/tests/all/wast.rs
@@ -1,5 +1,8 @@
 use std::path::Path;
-use wasmtime::{Config, Engine, Store, Strategy};
+use wasmtime::{
+    Config, Engine, InstanceAllocationStrategy, InstanceLimits, ModuleLimits,
+    PoolingAllocationStrategy, Store, Strategy,
+};
 use wasmtime_wast::WastContext;
 
 include!(concat!(env!("OUT_DIR"), "/wast_testsuite_tests.rs"));
@@ -7,7 +10,7 @@ include!(concat!(env!("OUT_DIR"), "/wast_testsuite_tests.rs"));
 // Each of the tests included from `wast_testsuite_tests` will call this
 // function which actually executes the `wast` test suite given the `strategy`
 // to compile it.
-fn run_wast(wast: &str, strategy: Strategy) -> anyhow::Result<()> {
+fn run_wast(wast: &str, strategy: Strategy, pooling: bool) -> anyhow::Result<()> {
     let wast = Path::new(wast);
 
     let simd = wast.iter().any(|s| s == "simd");
@@ -44,6 +47,30 @@ fn run_wast(wast: &str, strategy: Strategy) -> anyhow::Result<()> {
         cfg.static_memory_maximum_size(0);
     }
 
+    if pooling {
+        // The limits here are crafted such that the wast tests should pass.
+        // However, these limits may become insufficient in the future as the wast tests change.
+        // If a wast test fails because of a limit being "exceeded" or if memory/table
+        // fails to grow, the values here will need to be adjusted.
+        cfg.with_allocation_strategy(InstanceAllocationStrategy::Pooling {
+            strategy: PoolingAllocationStrategy::NextAvailable,
+            module_limits: ModuleLimits {
+                imported_memories: 2,
+                imported_tables: 2,
+                imported_globals: 11,
+                memories: 2,
+                tables: 4,
+                globals: 11,
+                memory_pages: 805,
+                ..Default::default()
+            },
+            instance_limits: InstanceLimits {
+                count: 450,
+                ..Default::default()
+            },
+        })?;
+    }
+
     let store = Store::new(&Engine::new(&cfg));
     let mut wast_context = WastContext::new(store);
     wast_context.register_spectest()?;