Upgrade wasmtime dependencies (#37)

Author: kawamuray

build.gradle

@@ -51,7 +51,7 @@ test {
         showExceptions true
         showCauses true
         showStackTraces true
-        showStandardStreams false
+        showStandardStreams true
     }
 }
 
@@ -94,7 +94,7 @@ task metaProperties() {
     }
 }
 
-def javah4xVersion = '0.1.0'
+def javah4xVersion = '0.2.0'
 task downloadJavah4x(type: Download) {
     src "https://github.com/kawamuray/javah4x/releases/download/v${javah4xVersion}/javah4x-bin-${javah4xVersion}.zip"
     dest new File(project.buildDir, "tmp")
@@ -112,7 +112,6 @@ task generateJniInterfaces(type:JavaExec) {
             'io.github.kawamuray.wasmtime.Engine',
             'io.github.kawamuray.wasmtime.Func',
             'io.github.kawamuray.wasmtime.Instance',
-            'io.github.kawamuray.wasmtime.InterruptHandle',
             'io.github.kawamuray.wasmtime.Linker',
             'io.github.kawamuray.wasmtime.Memory',
             'io.github.kawamuray.wasmtime.Module',

src/main/java/io/github/kawamuray/wasmtime/Config.java

@@ -22,14 +22,96 @@ long innerPtr() {
     /// By default this option is `false`.
     public native Config debugInfo(boolean enable);
 
-    /// Configures whether functions and loops will be interruptable via the
-    /// [`Store::interruptHandle`] method.
-    ///
-    /// For more information see the documentation on
-    /// [`Store::interruptHandle`].
-    ///
-    /// By default this option is `false`.
-    public native Config interruptable(boolean enable);
+    /// Enables epoch-based interruption.
+    ///
+    /// When executing code in async mode, we sometimes want to
+    /// implement a form of cooperative timeslicing: long-running Wasm
+    /// guest code should periodically yield to the executor
+    /// loop. This yielding could be implemented by using "fuel" (see
+    /// [`consume_fuel`](Config::consume_fuel)). However, fuel
+    /// instrumentation is somewhat expensive: it modifies the
+    /// compiled form of the Wasm code so that it maintains a precise
+    /// instruction count, frequently checking this count against the
+    /// remaining fuel. If one does not need this precise count or
+    /// deterministic interruptions, and only needs a periodic
+    /// interrupt of some form, then It would be better to have a more
+    /// lightweight mechanism.
+    ///
+    /// Epoch-based interruption is that mechanism. There is a global
+    /// "epoch", which is a counter that divides time into arbitrary
+    /// periods (or epochs). This counter lives on the
+    /// [`Engine`](crate::Engine) and can be incremented by calling
+    /// [`Engine::increment_epoch`](crate::Engine::increment_epoch).
+    /// Epoch-based instrumentation works by setting a "deadline
+    /// epoch". The compiled code knows the deadline, and at certain
+    /// points, checks the current epoch against that deadline. It
+    /// will yield if the deadline has been reached.
+    ///
+    /// The idea is that checking an infrequently-changing counter is
+    /// cheaper than counting and frequently storing a precise metric
+    /// (instructions executed) locally. The interruptions are not
+    /// deterministic, but if the embedder increments the epoch in a
+    /// periodic way (say, every regular timer tick by a thread or
+    /// signal handler), then we can ensure that all async code will
+    /// yield to the executor within a bounded time.
+    ///
+    /// The deadline check cannot be avoided by malicious wasm code. It is safe
+    /// to use epoch deadlines to limit the execution time of untrusted
+    /// code.
+    ///
+    /// The [`Store`](crate::Store) tracks the deadline, and controls
+    /// what happens when the deadline is reached during
+    /// execution. Several behaviors are possible:
+    ///
+    /// - Trap if code is executing when the epoch deadline is
+    ///   met. See
+    ///   [`Store::epoch_deadline_trap`](crate::Store::epoch_deadline_trap).
+    ///
+    /// - Call an arbitrary function. This function may chose to trap or
+    ///   increment the epoch. See
+    ///   [`Store::epoch_deadline_callback`](crate::Store::epoch_deadline_callback).
+    ///
+    /// - Yield to the executor loop, then resume when the future is
+    ///   next polled. See
+    ///   [`Store::epoch_deadline_async_yield_and_update`](crate::Store::epoch_deadline_async_yield_and_update).
+    ///
+    /// Trapping is the default. The yielding behaviour may be used for
+    /// the timeslicing behavior described above.
+    ///
+    /// This feature is available with or without async support.
+    /// However, without async support, the timeslicing behaviour is
+    /// not available. This means epoch-based interruption can only
+    /// serve as a simple external-interruption mechanism.
+    ///
+    /// An initial deadline must be set before executing code by calling
+    /// [`Store::set_epoch_deadline`](crate::Store::set_epoch_deadline). If this
+    /// deadline is not configured then wasm will immediately trap.
+    ///
+    /// ## When to use fuel vs. epochs
+    ///
+    /// In general, epoch-based interruption results in faster
+    /// execution. This difference is sometimes significant: in some
+    /// measurements, up to 2-3x. This is because epoch-based
+    /// interruption does less work: it only watches for a global
+    /// rarely-changing counter to increment, rather than keeping a
+    /// local frequently-changing counter and comparing it to a
+    /// deadline.
+    ///
+    /// Fuel, in contrast, should be used when *deterministic*
+    /// yielding or trapping is needed. For example, if it is required
+    /// that the same function call with the same starting state will
+    /// always either complete or trap with an out-of-fuel error,
+    /// deterministically, then fuel with a fixed bound should be
+    /// used.
+    ///
+    /// # See Also
+    ///
+    /// - [`Engine::increment_epoch`](crate::Engine::increment_epoch)
+    /// - [`Store::set_epoch_deadline`](crate::Store::set_epoch_deadline)
+    /// - [`Store::epoch_deadline_trap`](crate::Store::epoch_deadline_trap)
+    /// - [`Store::epoch_deadline_callback`](crate::Store::epoch_deadline_callback)
+    /// - [`Store::epoch_deadline_async_yield_and_update`](crate::Store::epoch_deadline_async_yield_and_update)
+    public native Config epochInterruption(boolean enable);
 
     /// Configures the maximum amount of native stack space available to
     /// executing WebAssembly code.

src/main/java/io/github/kawamuray/wasmtime/Engine.java

@@ -25,6 +25,8 @@ public Engine(Config config){
         this(newEngineWithConfig(config));
     }
 
+    public native void incrementEpoch();
+
     @Override
     public native void dispose();
 

src/main/java/io/github/kawamuray/wasmtime/ImportType.java

@@ -13,9 +13,6 @@ public enum Type {
         GLOBAL,
         TABLE,
         MEMORY,
-        // TODO: Currently Unsupported
-        INSTANCE,
-        MODULE
     }
 
     @Getter

src/main/java/io/github/kawamuray/wasmtime/InterruptHandle.java

@@ -50,9 +50,7 @@ public T data() {
         return (T) storedData();
     }
 
-    public InterruptHandle interruptHandle() {
-        return new InterruptHandle(interruptHandlePtr());
-    }
+    public native void setEpochDeadline(long ticksBeyondCurrent);
 
     @Override
     public native void dispose();
@@ -64,6 +62,4 @@ public InterruptHandle interruptHandle() {
     private native Object storedData();
 
     public native void gc();
-
-    private native long interruptHandlePtr();
 }

src/main/java/io/github/kawamuray/wasmtime/Store.java

@@ -9,21 +9,59 @@
 @Accessors(fluent = true)
 @AllArgsConstructor
 public class Trap {
-    public enum Type {
+    public enum Reason {
         MESSAGE,
         I32_EXIT,
+        INSTRUCTION_TRAP,
     }
 
-    Type type;
+    public enum TrapCode {
+        UNKNOWN,
+        // The current stack space was exhausted.
+        STACK_OVERFLOW,
+        // An out-of-bounds memory access.
+        MEMORY_OUT_OF_BOUNDS,
+        // A wasm atomic operation was presented with a not-naturally-aligned linear-memory address.
+        HEAP_MISALIGNED,
+        // An out-of-bounds access to a table.
+        TABLE_OUT_OF_BOUNDS,
+        // Indirect call to a null table entry.
+        INDIRECT_CALL_TO_NULL,
+        // Signature mismatch on indirect call.
+        BAD_SIGNATURE,
+        // An integer arithmetic operation caused an overflow.
+        INTEGER_OVERFLOW,
+        // An integer division by zero.
+        INTEGER_DIVISION_BY_ZERO,
+        // Failed float-to-int conversion.
+        BAD_CONVERSION_TO_INTEGER,
+        // Code that was supposed to have been unreachable was reached.
+        UNREACHABLE_CODE_REACHED,
+        // Execution has potentially run too long and may be interrupted.
+        INTERRUPT,
+        // When the `component-model` feature is enabled this trap represents a
+        // function that was `canon lift`'d, then `canon lower`'d, then called.
+        // This combination of creation of a function in the component model
+        // generates a function that always traps and, when called, produces this
+        // flavor of trap.
+        ALWAYS_TRAP_ADAPTER,
+    }
+
+    Reason reason;
     String message;
     int exitCode;
+    TrapCode trapCode;
 
     public static Trap fromMessage(@NonNull String message) {
-        return new Trap(Type.MESSAGE, message, 0);
+        return new Trap(Reason.MESSAGE, message, 0, null);
     }
 
     public static Trap fromExitCode(int exitCode) {
-        return new Trap(Type.I32_EXIT, null, exitCode);
+        return new Trap(Reason.I32_EXIT, null, exitCode, null);
+    }
+
+    public static Trap fromTrapCode(TrapCode trapCode) {
+        return new Trap(Reason.INSTRUCTION_TRAP, null, 0, trapCode);
     }
 
     public static Trap fromException(Throwable e) {

src/main/java/io/github/kawamuray/wasmtime/Trap.java

@@ -7,6 +7,7 @@
 import java.util.Optional;
 import java.util.concurrent.atomic.AtomicInteger;
 
+import io.github.kawamuray.wasmtime.Trap.Reason;
 import io.github.kawamuray.wasmtime.wasi.WasiCtx;
 import io.github.kawamuray.wasmtime.wasi.WasiCtxBuilder;
 
@@ -131,7 +132,7 @@ public void testWasiExitTrap() {
                 func.call(store);
             } catch (TrapException e) {
                 Trap trap = e.trap();
-                assertEquals(trap.type(), Trap.Type.I32_EXIT);
+                assertEquals(trap.reason(), Reason.I32_EXIT);
                 assertEquals(trap.exitCode(), 42);
             }
         }

src/test/java/io/github/kawamuray/wasmtime/FuncTest.java

@@ -0,0 +1,52 @@
+package io.github.kawamuray.wasmtime;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+
+import org.junit.Test;
+
+import io.github.kawamuray.wasmtime.Trap.TrapCode;
+import io.github.kawamuray.wasmtime.WasmFunctions.Consumer0;
+
+public class TrapTest {
+    private static final String INTERRUPT_WAT = "(module\n"
+                                                + "  (func (export \"run\")\n"
+                                                + "    (loop\n"
+                                                + "      br 0)\n"
+                                                + "  )\n"
+                                                + ")\n";
+
+    @Test
+    public void interrupt() {
+        try (Engine engine = new Engine(new Config().epochInterruption(true));
+             Store<Void> store = new Store<>(null, engine)) {
+            store.setEpochDeadline(1);
+
+            // Compile and instantiate a small example with an infinite loop.
+            try (Module module = new Module(engine, INTERRUPT_WAT.getBytes(StandardCharsets.UTF_8));
+                 Instance instance = new Instance(store, module, Collections.emptyList());
+                 Func runFn = instance.getFunc(store, "run").get()) {
+                Consumer0 run = WasmFunctions.consumer(store, runFn);
+
+                new Thread(() -> {
+                    try {
+                        Thread.sleep(1);
+                    } catch (InterruptedException e) {
+                        throw new RuntimeException(e);
+                    }
+                    engine.incrementEpoch();
+                }).start();
+
+                try {
+                    run.accept();
+                    fail("no trap received");
+                } catch (TrapException e) {
+                    assertEquals(TrapCode.INTERRUPT, e.trap().trapCode());
+                }
+            }
+        }
+    }
+}

src/test/java/io/github/kawamuray/wasmtime/TrapTest.java

@@ -11,8 +11,8 @@ crate_type = ["cdylib"]
 jni = "0.19.0"
 thiserror = "1.0.30"
 anyhow = "1.0.56"
-wasmtime = "0.35.2"
-wasmtime-wasi = "0.35.2"
-wasi-common = "0.35.2"
-wasi-cap-std-sync = "0.35.2"
-cap-std = "0.24.2"
+wasmtime = "0.40.0"
+wasmtime-wasi = "0.40.0"
+wasi-common = "0.40.0"
+wasi-cap-std-sync = "0.40.0"
+cap-std = "0.25.2"