Interrupt

[Wavesonics]

Follow-up to #124, split out as requested in review. Built on that branch, so until it merges this PR also shows its commit; only the top commit (runtime: interrupt running calls in interruptible stores) is new here.

Adds a way to stop a running call from another thread, independent of fuel metering.

API

• StoreConfig(interruptible = true) opts a store in.
• interrupt(store) can be called from any thread. The running call traps with InvocationError.Interrupted at its next function entry or loop iteration. It returns an error for a store that isn't interruptible.

Implementation

• Uses the same check sites as fuel. emitFuelCheck() becomes emitCheckpoint(), which picks the dispatcher at compile time: fuel only, interrupt only, or a combined fuel-and-interrupt check, so a store with both settings pays for one dispatch per site. A store with neither emits nothing.
• An interrupt made while no call runs is dropped: the flag is cleared when an outermost call starts. Calls made back into the store from a host function never clear it, so an interrupt raised during a nested call also stops its caller.
• A long-running host function is only stopped once it returns to Wasm code.

Cost
CoreMark on the JVM, 5 alternating runs per configuration, median score:

Store	Score	vs plain
plain	993.5
fuel	947.9	-4.6%
interrupt	953.9	-4.0%
fuel+interrupt	926.9	-6.7%

The runs are noisy (the ranges overlap), so treat these as approximate. ./gradlew :benchmark:coremark --args=<plain|fuel|interrupt|fuel+interrupt> reproduces them.

Tests
Fixture-based tests (interrupt.wat) cover:

• interrupting a store that isn't interruptible;
• stopping a running call;
• the next call running normally;
• dropping an interrupt made while idle;
• how many checks are compiled;
• fuel and interrupt together;
• an interrupt raised in a nested host callback stopping its caller.

A JVM test also interrupts a running loop from another thread.

[CharlieTap]

Good use of super instructions, this is the way to go

[Wavesonics]

Thanks! Glad that fit.

[CharlieTap]

I would move all of this into FunctionInvoker, so it covers invocation of a HostFunction also, its the same thing just a higher entry point

[Wavesonics]

Good call, moved it into FunctionInvoker so directly invoked host functions are covered too. Added a test for a host function that interrupts and then calls back into the store.

[CharlieTap]

Could we use the host callback to signal that execution has started, then send a single interrupt and wait for completion with a timeout? That avoids the startup race and verifies that one interrupt is sufficient.

The current test can hang indefinitely if interruption breaks, a timed wait and daemon worker let it fail without keeping the test JVM alive. We can retain the assertion that the next invocation succeeds.

Roughly:

   val started = CountDownLatch(1)
        val (store, instance) = InterruptTest.instantiate(
            StoreConfig(interruptible = true),
        ) { _, _ ->
            started.countDown()
        }

        val invocation = FutureTask {
            invoke(store, instance, "callback_then_spin")
        }

        thread(isDaemon = true, name = "interrupt-test") {
            invocation.run()
        }

        assertTrue(
            started.await(5, TimeUnit.SECONDS),
            "Wasm execution did not reach the host callback",
        )

        assertEquals(ChasmResult.Success(Unit), interrupt(store))

        assertEquals(
            ChasmResult.Error(
                ChasmError.ExecutionError(InvocationError.Interrupted.toString()),
            ),
            invocation.get(5, TimeUnit.SECONDS),
        )

        assertEquals(
            ChasmResult.Success(listOf(NumberValue.I32(0))),
            invoke(store, instance, "count", listOf(NumberValue.I32(3))),
        )

note I'm using kotlin.concurrent.thread ^^^

[Wavesonics]

Done, thanks for the sketch. I went with it almost as written. The one addition is that the loop now polls a host import, so if the interrupt ever fails the test can release the worker instead of leaving it spinning.

[Wavesonics]

Heads up on one change beyond the review: interrupt() now returns ChasmResult<Boolean, …>, with true if a call was running to receive it. Before, an interrupt landing between calls was dropped silently, even though it reported success. The flag is also now cleared before a call is marked as running, which closes a race at call start. Happy to revert to Unit if you'd prefer to keep the API as it was.