try use cranelift

Author: Ong-art Intel

packages/vm/Cargo.toml

@@ -13,7 +13,7 @@ assert_matches = "1.3.0"
 hex = "0.4"
 parity-wasm = "0.41"
 pwasm-utils = "0.12"
-wasmer = { version = "2.3.0", default-features = false, features = ["jit", "singlepass", "compiler", "universal"] }
+wasmer = { version = "2.3.0", default-features = false, features = ["jit", "singlepass", "compiler", "universal", "cranelift"] }
 wasmer-middlewares = "2.3.0"
 owasm-crypto = { path = "../crypto", version = "0.1.13" }
 tempfile = "3.1.0"

packages/vm/src/lib.rs

@@ -15,9 +15,13 @@ use wasmer_middlewares::metering::{get_remaining_points, MeteringPoints};
 
 use pwasm_utils::{self, rules};
 
-use wasmer::{
-    imports, wasmparser, wasmparser::Operator, CompilerConfig, Function, Singlepass, Store, JIT,
-};
+#[cfg(feature = "cranelift")]
+use wasmer::Cranelift;
+
+#[cfg(not(feature = "cranelift"))]
+use wasmer::Singlepass;
+
+use wasmer::{imports, wasmparser, wasmparser::Operator, CompilerConfig, Function, Store, JIT};
 use wasmer_middlewares::Metering;
 
 use owasm_crypto::ecvrf;
@@ -134,6 +138,21 @@ pub fn compile(code: &[u8]) -> Result<Vec<u8>, Error> {
     elements::serialize(module).map_err(|_| Error::SerializationError)
 }
 
+pub fn new_compile(code: &[u8]) -> Result<Vec<u8>, Error> {
+    // Check that the given Wasm code is indeed a valid Wasm.
+    wasmparser::validate(code).map_err(|_| Error::ValidationError)?;
+
+    // Start the compiling chains.
+    let module = elements::deserialize_buffer(code).map_err(|_| Error::DeserializationError)?;
+    check_wasm_exports(&module)?;
+    check_wasm_imports(&module)?;
+    let module = inject_memory(module)?;
+    let module = inject_stack_height(module)?;
+
+    // Serialize the final Wasm code back to bytes.
+    elements::serialize(module).map_err(|_| Error::SerializationError)
+}
+
 fn require_mem_range(max_range: usize, require_range: usize) -> Result<(), Error> {
     if max_range < require_range {
         return Err(Error::MemoryOutOfBoundError);
@@ -164,7 +183,12 @@ where
 {
     let owasm_env = Environment::new(env, gas);
 
+    #[cfg(feature = "cranelift")]
+    let mut compiler = Cranelift::default();
+
+    #[cfg(not(feature = "cranelift"))]
     let mut compiler = Singlepass::default();
+
     let metering = Arc::new(Metering::new(4294967290, cost));
     compiler.push_middleware(metering);
     let engine = Universal::new(compiler).engine();
@@ -173,9 +197,9 @@ where
     let import_object = imports! {
         "env" => {
             "gas" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>, gas: u32| {
-                env.with_mut_vm(|vm| {
-                    vm.consume_gas(gas)
-                })
+                // env.with_mut_vm(|vm| {
+                //     vm.consume_gas(gas)
+                // })
             }),
             "get_span_size" => Function::new_native_with_env(&store, owasm_env.clone(), |env: &Environment<E>| {
                 env.with_vm(|vm| {
@@ -338,6 +362,7 @@ mod test {
     use parity_wasm::elements;
     use std::io::{Read, Write};
     use std::process::Command;
+    use std::time::Instant;
     use tempfile::NamedTempFile;
 
     pub struct MockEnv {}
@@ -517,6 +542,47 @@ mod test {
         assert_eq!(gas_used, 1000015 as u32);
     }
 
+    #[test]
+    fn test_run_time() {
+        let wasm = wat2wasm(
+            r#"(module
+            (type (func (param i64 i64 i64 i64) (result)))
+            (func
+              (local $idx i32)
+              (local.set $idx (i32.const 0))
+              (block
+                  (loop
+                    (local.set $idx (local.get $idx) (i32.const 1) (i32.add) )
+                    (br_if 0 (i32.lt_u (local.get $idx) (i32.const 1000000)))
+                  )
+                )
+            )
+            (func (;"execute": Resolves with result "beeb";)
+            )
+            (memory 17)
+            (data (i32.const 1048576) "beeb") (;str = "beeb";)
+            (export "prepare" (func 0))
+            (export "execute" (func 1)))
+          "#,
+        );
+        let code = compile(&wasm).unwrap();
+        let new_code = new_compile(&wasm).unwrap();
+        let mut cache = Cache::new(CacheOptions { cache_size: 10000 });
+        let env = MockEnv {};
+
+        let now = Instant::now();
+        let _gas_used = run(&mut cache, &code, 4294967290, true, env).unwrap();
+        let elapsed_time = now.elapsed();
+
+        let env = MockEnv {};
+
+        let now = Instant::now();
+        let _gas_used = run(&mut cache, &new_code, 4294967290, true, env).unwrap();
+        let elapsed_time_2 = now.elapsed();
+
+        assert_eq!(elapsed_time.as_micros(), elapsed_time_2.as_micros());
+    }
+
     #[test]
     fn test_inject_memory_no_memory() {
         let wasm = wat2wasm("(module)");