feat: [EXC-1767] Enable tail_call in wasmtime. (#2826)

Enables the wasmtime feature
[tail_call](https://github.com/WebAssembly/tail-call/blob/master/proposals/tail-call/Overview.md).

Benchmarks show that using `return_call` instead of `call` can improve
performance significantly, but the improvement depends on the depth of
the call stack. In short, with reasonable assumptions about call depth,
the improvement is about 1.5x, so the cost for `return_call` and
`return_call_indirect` are adjusted downward to incentivize the use of
this optimization by the toolchains.

---------

Co-authored-by: Michael Weigelt <michael.weigelt@dfinity.com>

Author: michael-weigelt

rs/embedders/src/wasm_utils/instrumentation.rs

@@ -427,8 +427,13 @@ pub fn instruction_to_cost(i: &Operator, mem_type: WasmMemoryType) -> u64 {
 
         // Call instructions are of cost 20. Validated in benchmarks.
         // The cost is adjusted to 5 and 10 after benchmarking with real canisters.
-        Operator::Call { .. } | Operator::ReturnCall { .. } => 5,
-        Operator::CallIndirect { .. } | Operator::ReturnCallIndirect { .. } => 10,
+        Operator::Call { .. } => 5,
+        Operator::CallIndirect { .. } => 10,
+
+        // ReturnCall instructions are on average approx. 1.5 times faster than Call
+        // instructions (shown by relative benchmarks).
+        Operator::ReturnCall { .. } => 3,
+        Operator::ReturnCallIndirect { .. } => 6,
 
         // Return, drop, unreachable and nop instructions are of cost 1.
         Operator::Return { .. } | Operator::Drop | Operator::Unreachable | Operator::Nop => 1,

rs/embedders/src/wasm_utils/validation.rs

@@ -1449,8 +1449,7 @@ pub fn wasmtime_validation_config(embedders_config: &EmbeddersConfig) -> wasmtim
     config.wasm_reference_types(true);
     // The relaxed SIMD instructions are disable for determinism.
     config.wasm_relaxed_simd(false);
-    // Tail calls may be enabled in the future.
-    config.wasm_tail_call(false);
+    config.wasm_tail_call(true);
     // WebAssembly extended-const proposal is disabled.
     config.wasm_extended_const(false);
 

rs/embedders/src/wasmtime_embedder/wasmtime_embedder_tests.rs

@@ -170,16 +170,10 @@ fn test_wasmtime_system_api() {
 
 #[test]
 fn test_initial_wasmtime_config() {
-    // The following proposals should be disabled: tail_call, simd, relaxed_simd,
+    // The following proposals should be disabled: simd, relaxed_simd,
     // threads, multi_memory, exceptions, extended_const, component_model,
     // function_references, memory_control, gc
     for (proposal, _url, wat, expected_err_msg) in [
-        (
-            "tail_call",
-            "https://github.com/WebAssembly/tail-call/",
-            "(module (func $f1 return_call $f2) (func $f2))",
-            "tail calls support is not enabled",
-        ),
         (
             "relaxed_simd",
             "https://github.com/WebAssembly/relaxed-simd/",

rs/execution_environment/benches/lib/src/wat_builder.rs

@@ -87,6 +87,20 @@ impl Block {
         if code.contains("$empty_return_call") {
             self.import("(func $empty_return_call (result i32) return_call $empty)");
         }
+        if code.contains("$recursive_call") {
+            self.import(
+                &RECURSIVE
+                    .replace("<NAME>", "$recursive_call")
+                    .replace("<RETURN>", ""),
+            );
+        }
+        if code.contains("$recursive_return_call") {
+            self.import(
+                &RECURSIVE
+                    .replace("<NAME>", "$recursive_return_call")
+                    .replace("<RETURN>", "return_"),
+            );
+        }
         if code.contains("$result_i32") || code.contains("table.get") || code.contains("table.size")
         {
             self.import("(type $result_i32 (func (result i32)))")
@@ -213,3 +227,18 @@ pub fn src_type(op: &str) -> &'static str {
     // Fallback to the destination type, i.e. for `i64.eqz` returns `i64`.
     dst_type(op)
 }
+
+const RECURSIVE: &str = r#"
+(func <NAME> (param $n i32) (result i32)
+    (i32.eqz (local.get $n))
+    (if (result i32)
+      (then
+      	(local.get $n)
+      )
+      (else
+      	(i32.sub (local.get $n) (i32.const 1))
+        (<RETURN>call <NAME>)
+      )
+    )
+)
+"#;

rs/execution_environment/benches/wasm_instructions/basic.rs

@@ -479,6 +479,21 @@ pub fn benchmarks() -> Vec<Benchmark> {
         "ctrlop/call_indirect",
         "(global.set $x_i32 (call_indirect (type $result_i32) (i32.const 7)))",
     ));
+    // This benchmark inevitably contains many more instructions than the one we wish to
+    // benchmark, so the absolute values of the results are not very interesting.
+    // What matters is the comparison with the 'recursive_call*' results below, which
+    // shows that 'return_call' is at least as efficient as 'call'. The deeper the call-
+    // stack, the larger the improvement. In the call-depth range 1-10000, 'return_call'
+    // is approximately 1.5 times faster on average than 'call'.
+    benchmarks.extend(benchmark_with_confirmation(
+        "ctrlop/recursive_return_call*",
+        "(global.set $x_i32 (call $recursive_return_call (i32.const 10)))",
+    ));
+    // This is a reference for the 'return_call' benchmark above.
+    benchmarks.extend(benchmark_with_confirmation(
+        "ctrlop/recursive_call*",
+        "(global.set $x_i32 (call $recursive_call (i32.const 10)))",
+    ));
 
     benchmarks
 }

rs/execution_environment/benches/wasm_instructions/wasm_coverage.sh

@@ -16,7 +16,7 @@ PROPOSAL_TO_OP_URL="https://raw.githubusercontent.com/bytecodealliance/wasm-tool
 # The file with Wasm operator to Wasm instruction mapping.
 OP_TO_INSTR_URL="https://raw.githubusercontent.com/bytecodealliance/wasm-tools/main/crates/wast/src/core/expr.rs"
 # The Wasm proposal to exclude from the coverage, i.e. unsupported Wasm proposals.
-EXCLUDE_PROPOSALS="tail_call|relaxed_simd|threads|multi_memory|exceptions|memory64|extended_const|component_model|function_references|memory_control|gc|shared_everything_threads"
+EXCLUDE_PROPOSALS="relaxed_simd|threads|multi_memory|exceptions|memory64|extended_const|component_model|function_references|memory_control|gc|shared_everything_threads"
 
 # Extract `instruction_to_cost` function from the file.
 instruction_to_cost=$(sed -n '/pub fn instruction_to_cost/,/^[}]/{p}' "${INSTRUCTION_TO_COST_FILE}")