runtime: Enable Cranelift OptLevel::Speed for WASM compilation

Switch the default Cranelift optimization level from `None` to `Speed`,
improving WASM handler execution performance. The optimization level is
configurable via the `GRAPH_WASM_OPT_LEVEL` environment variable
(valid values: `none`, `speed`, `speed_and_size`; default: `speed`).

This is safe because Cranelift adheres to the Wasm spec and NaN
canonicalization is already enabled. The increased compilation time is a
one-time cost per module, amortized over thousands of triggers.

Author: lutter

graph/src/env/mappings.rs

@@ -82,6 +82,22 @@ pub struct EnvVarsMapping {
     /// Maximum backoff time for FDS requests. Set by
     /// `GRAPH_FDS_MAX_BACKOFF` in seconds, defaults to 600.
     pub fds_max_backoff: Duration,
+
+    /// Cranelift optimization level for WASM compilation.
+    ///
+    /// Set by the environment variable `GRAPH_WASM_OPT_LEVEL`. Valid values
+    /// are `none`, `speed`, and `speed_and_size`. The default value is
+    /// `speed`.
+    pub wasm_opt_level: WasmOptLevel,
+}
+
+/// Cranelift optimization level for WASM compilation. Maps to
+/// `wasmtime::OptLevel` without introducing a dependency on wasmtime.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum WasmOptLevel {
+    None,
+    Speed,
+    SpeedAndSize,
 }
 
 // This does not print any values avoid accidentally leaking any sensitive env vars
@@ -91,6 +107,32 @@ impl fmt::Debug for EnvVarsMapping {
     }
 }
 
+impl fmt::Display for WasmOptLevel {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            WasmOptLevel::None => write!(f, "none"),
+            WasmOptLevel::Speed => write!(f, "speed"),
+            WasmOptLevel::SpeedAndSize => write!(f, "speed_and_size"),
+        }
+    }
+}
+
+impl FromStr for WasmOptLevel {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "none" => Ok(WasmOptLevel::None),
+            "speed" => Ok(WasmOptLevel::Speed),
+            "speed_and_size" => Ok(WasmOptLevel::SpeedAndSize),
+            _ => Err(format!(
+                "invalid GRAPH_WASM_OPT_LEVEL '{}', expected 'none', 'speed', or 'speed_and_size'",
+                s
+            )),
+        }
+    }
+}
+
 impl TryFrom<InnerMappingHandlers> for EnvVarsMapping {
     type Error = anyhow::Error;
 
@@ -121,6 +163,7 @@ impl TryFrom<InnerMappingHandlers> for EnvVarsMapping {
             disable_declared_calls: x.disable_declared_calls.0,
             store_errors_are_nondeterministic: x.store_errors_are_nondeterministic.0,
             fds_max_backoff: Duration::from_secs(x.fds_max_backoff),
+            wasm_opt_level: x.wasm_opt_level,
         };
         Ok(vars)
     }
@@ -164,6 +207,8 @@ pub struct InnerMappingHandlers {
     store_errors_are_nondeterministic: EnvVarBoolean,
     #[envconfig(from = "GRAPH_FDS_MAX_BACKOFF", default = "600")]
     fds_max_backoff: u64,
+    #[envconfig(from = "GRAPH_WASM_OPT_LEVEL", default = "speed")]
+    wasm_opt_level: WasmOptLevel,
 }
 
 fn validate_ipfs_cache_location(path: PathBuf) -> Result<PathBuf, anyhow::Error> {

graph/src/env/mod.rs

@@ -11,6 +11,8 @@ use semver::Version;
 
 use self::graphql::*;
 use self::mappings::*;
+
+pub use self::mappings::WasmOptLevel;
 use self::store::*;
 use crate::{
     components::{store::BlockNumber, subgraph::SubgraphVersionSwitchingMode},

runtime/wasm/src/mapping.rs

@@ -291,14 +291,19 @@ impl ValidModule {
             .map_err(|_| anyhow!("Failed to inject gas counter"))?;
         let raw_module = parity_module.into_bytes()?;
 
-        // We currently use Cranelift as a compilation engine. Cranelift is an optimizing compiler,
-        // but that should not cause determinism issues since it adheres to the Wasm spec. Still we
-        // turn off optional optimizations to be conservative.
+        // We use Cranelift as a compilation engine. Cranelift is an optimizing compiler, but that
+        // should not cause determinism issues since it adheres to the Wasm spec and NaN
+        // canonicalization is enabled below. The optimization level is configurable via
+        // GRAPH_WASM_OPT_LEVEL (default: speed).
         let mut config = wasmtime::Config::new();
         config.strategy(wasmtime::Strategy::Cranelift);
         config.epoch_interruption(true);
         config.cranelift_nan_canonicalization(true); // For NaN determinism.
-        config.cranelift_opt_level(wasmtime::OptLevel::None);
+        config.cranelift_opt_level(match ENV_VARS.mappings.wasm_opt_level {
+            graph::env::WasmOptLevel::None => wasmtime::OptLevel::None,
+            graph::env::WasmOptLevel::Speed => wasmtime::OptLevel::Speed,
+            graph::env::WasmOptLevel::SpeedAndSize => wasmtime::OptLevel::SpeedAndSize,
+        });
         config.max_wasm_stack(ENV_VARS.mappings.max_stack_size);
         config.async_support(true);