Add an unread constant to the function prologue.

…and a test that shows it makes it through.

TODO: There are other little corners where epoch_interruption comes up in the code where we should mention epoch_interruption_via_mmu_too.

Author: erikrose

crates/cli-flags/src/lib.rs

@@ -296,6 +296,10 @@ wasmtime_option_group! {
         /// Yield when a global epoch counter changes, allowing for async
         /// operation without blocking the executor.
         pub epoch_interruption: Option<bool>,
+        /// Use MMU tricks to speed epoch deadline checks.
+        /// TODO: Document whether this should be used mutually exclusively with
+        /// epoch_interruption.
+        pub epoch_interruption_via_mmu: Option<bool>,
         /// Maximum stack size, in bytes, that wasm is allowed to consume before a
         /// stack overflow is reported.
         pub max_wasm_stack: Option<usize>,
@@ -818,6 +822,9 @@ impl CommonOptions {
         if let Some(enable) = self.wasm.epoch_interruption {
             config.epoch_interruption(enable);
         }
+        if let Some(enable) = self.wasm.epoch_interruption_via_mmu {
+            config.epoch_interruption_via_mmu(enable);
+        }
         if let Some(enable) = self.debug.address_map {
             config.generate_address_map(enable);
         }

crates/cranelift/src/func_environ.rs

@@ -3372,6 +3372,11 @@ impl FuncEnvironment<'_> {
             self.epoch_function_entry(builder);
         }
 
+        if self.tunables.epoch_interruption_via_mmu {
+            builder.ins().iconst(I32, 33); // a useless constant, hopefully not optimized out
+            // NEXT: Dead-load something from the vmctx instead.
+        }
+
         #[cfg(feature = "wmemcheck")]
         if self.compiler.wmemcheck {
             let func_name = self.current_func_name(builder);

crates/environ/src/tunables.rs

@@ -86,6 +86,11 @@ define_tunables! {
         /// Whether or not we use epoch-based interruption.
         pub epoch_interruption: bool,
 
+        /// Whether or not to use MMU tricks to speed epoch deadline checks.
+        /// TODO: Consider whether this should be orthogonal to
+        /// epoch_interruption. If not, combine them into an enum or something.
+        pub epoch_interruption_via_mmu: bool,
+
         /// Whether or not linear memories are allowed to be reallocated after
         /// initial allocation at runtime.
         pub memory_may_move: bool,
@@ -197,6 +202,7 @@ impl Tunables {
             parse_wasm_debuginfo: true,
             consume_fuel: false,
             epoch_interruption: false,
+            epoch_interruption_via_mmu: false,
             memory_may_move: true,
             guard_before_linear_memory: true,
             table_lazy_init: true,

crates/wasmtime/src/config.rs

@@ -669,6 +669,12 @@ impl Config {
         self
     }
 
+    /// Stuff
+    pub fn epoch_interruption_via_mmu(&mut self, enable: bool) -> &mut Self {
+        self.tunables.epoch_interruption_via_mmu = Some(enable);
+        self
+    }
+
     /// Configures the maximum amount of stack space available for
     /// executing WebAssembly code.
     ///

crates/wasmtime/src/engine/serialization.rs

@@ -281,6 +281,7 @@ impl Metadata<'_> {
             parse_wasm_debuginfo,
             consume_fuel,
             epoch_interruption,
+            epoch_interruption_via_mmu,
             memory_may_move,
             guard_before_linear_memory,
             table_lazy_init,
@@ -333,6 +334,11 @@ impl Metadata<'_> {
             other.epoch_interruption,
             "epoch interruption",
         )?;
+        Self::check_bool(
+            epoch_interruption_via_mmu,
+            other.epoch_interruption_via_mmu,
+            "epoch interruption via MMU",
+        )?;
         Self::check_bool(memory_may_move, other.memory_may_move, "memory may move")?;
         Self::check_bool(
             guard_before_linear_memory,

tests/disas/epoch-interruption-mmu.wat

@@ -0,0 +1,20 @@
+;;! target = "x86_64"
+;;! flags = ["-Wepoch-interruption-via-mmu=y"]
+
+(module
+  (memory 0)
+  (func)
+)
+;; function u0:0(i64 vmctx, i64) tail {
+;;     gv0 = vmctx
+;;     gv1 = load.i64 notrap aligned readonly gv0+8
+;;     gv2 = load.i64 notrap aligned gv1+16
+;;     stack_limit = gv2
+;;
+;;                                 block0(v0: i64, v1: i64):
+;; @001b                               v2 = iconst.i32 33
+;; @001c                               jump block1
+;;
+;;                                 block1:
+;; @001c                               return
+;; }