Allow to set stack limits from env variables

Author: jiayihu

Cargo.toml

@@ -21,6 +21,7 @@ num-traits = { version = "0.2.8", default-features = false }
 libc = { version = "0.2.58", optional = true}
 errno = { version = "0.2.4", optional = true }
 downcast-rs = { version = "1.2.0", default-features = false }
+once_cell = { version = "1.4.1", default-features = false }
 
 [dev-dependencies]
 assert_matches = "1.1"

src/module.rs

@@ -477,7 +477,7 @@ impl ModuleInstance {
     /// a module which `start` function is not called.
     /// In order to complete instantiatiation `start` function must be called. However, there are
     /// situations where you might need to do additional setup before calling `start` function.
-    /// For such sitations this separation might be useful.
+    /// For such situations this separation might be useful.
     ///
     /// See [`NotStartedModuleRef`] for details.
     ///

src/runner.rs

@@ -14,14 +14,25 @@ use alloc::{boxed::Box, vec::Vec};
 use core::fmt;
 use core::ops;
 use core::{u32, usize};
+use once_cell::unsync::Lazy;
 use parity_wasm::elements::Local;
 use validation::{DEFAULT_MEMORY_INDEX, DEFAULT_TABLE_INDEX};
 
 /// Maximum number of bytes on the value stack.
-pub const DEFAULT_VALUE_STACK_LIMIT: usize = 1024 * 1024;
+pub const DEFAULT_VALUE_STACK_LIMIT: Lazy<usize> = Lazy::new(|| {
+    option_env!("WASMI_VALUE_STACK_LIMIT")
+        .and_then(|x| x.parse::<usize>().ok())
+        .unwrap_or(1024)
+        * 1024
+});
 
 /// Maximum number of levels on the call stack.
-pub const DEFAULT_CALL_STACK_LIMIT: usize = 64 * 1024;
+pub const DEFAULT_CALL_STACK_LIMIT: Lazy<usize> = Lazy::new(|| {
+    option_env!("WASMI_CALL_STACK_LIMIT")
+        .and_then(|x| x.parse::<usize>().ok())
+        .unwrap_or(64)
+        * 1024
+});
 
 /// This is a wrapper around u64 to allow us to treat runtime values as a tag-free `u64`
 /// (where if the runtime value is <64 bits the upper bits are 0). This is safe, since
@@ -1517,16 +1528,16 @@ impl StackRecycler {
     fn recreate_value_stack(this: &mut Option<&mut Self>) -> ValueStack {
         let limit = this
             .as_ref()
-            .map_or(DEFAULT_VALUE_STACK_LIMIT, |this| this.value_stack_limit)
+            .map_or(DEFAULT_VALUE_STACK_LIMIT.clone(), |this| {
+                this.value_stack_limit
+            })
             / ::core::mem::size_of::<RuntimeValueInternal>();
 
         let buf = this
             .as_mut()
             .and_then(|this| this.value_stack_buf.take())
             .unwrap_or_else(|| {
-                let mut buf = Vec::new();
-                buf.reserve_exact(limit);
-                buf.resize(limit, RuntimeValueInternal(0));
+                let buf = vec![RuntimeValueInternal(0); limit];
                 buf.into_boxed_slice()
             });
 
@@ -1536,7 +1547,9 @@ impl StackRecycler {
     fn recreate_call_stack(this: &mut Option<&mut Self>) -> CallStack {
         let limit = this
             .as_ref()
-            .map_or(DEFAULT_CALL_STACK_LIMIT, |this| this.call_stack_limit);
+            .map_or(DEFAULT_CALL_STACK_LIMIT.clone(), |this| {
+                this.call_stack_limit
+            });
 
         let buf = this
             .as_mut()
@@ -1556,6 +1569,9 @@ impl StackRecycler {
 
 impl Default for StackRecycler {
     fn default() -> Self {
-        Self::with_limits(DEFAULT_VALUE_STACK_LIMIT, DEFAULT_CALL_STACK_LIMIT)
+        Self::with_limits(
+            DEFAULT_VALUE_STACK_LIMIT.clone(),
+            DEFAULT_CALL_STACK_LIMIT.clone(),
+        )
     }
 }