load module in parallel

Author: learnforpractice

contracts/eosiolib_native/vm_api.h

@@ -347,6 +347,8 @@ int get_option(const char* option, char *result, int size);
 #define  VM_TYPE_JAVA                     12
 #define  VM_TYPE_WABT                     13
 
+#define VM_MODULE_NOT_FOUND                        1000
+
 #ifdef __cplusplus
 }
 #endif

libraries/chain/include/eosio/chain/wasm_interface_private.hpp

@@ -56,8 +56,6 @@ namespace eosio { namespace chain {
       wasm_interface_impl(wasm_interface::vm_type vm) {
 #if defined(_WAVM)
          runtime_interface = std::make_unique<webassembly::wavm::wavm_runtime>();
-#elif defined(_BINARYEN)
-         runtime_interface = std::make_unique<webassembly::binaryen::binaryen_runtime>();
 #elif defined(_WABT)
          runtime_interface = std::make_unique<webassembly::wabt_runtime::wabt_runtime>();
 #else
@@ -91,14 +89,14 @@ namespace eosio { namespace chain {
          char code_id[8*4];
 
          {
-            std::lock_guard<std::mutex> lock(m);
-
             code = get_code( receiver, &size );
             get_code_id(receiver, code_id, sizeof(code_id));
             if (size <= 0) {
                EOS_ASSERT(false, asset_type_exception, "code size should not be zero");
             }
 
+            std::lock_guard<std::mutex> lock(m);
+
             auto it = instantiation_cache.find(receiver);
             if (it != instantiation_cache.end()) {
                if (0 == memcmp(code_id, it->second->code_id, sizeof(code_id))) {
@@ -115,14 +113,24 @@ namespace eosio { namespace chain {
          if (!preload) {
             pause_billing_timer();
          }
+#ifdef _WAVM
+         unload_module(receiver);
+         load_module_async(receiver, code, size);
+         {
+            std::lock_guard<std::mutex> lock(m);
+            return instantiation_cache.end()->second;
+         }
+#elif defined(_WABT)
          return load_module(receiver, code, size);
+#endif
       }
 
 
-       void load_module_async(uint64_t receiver, const char* code, size_t size) {
-          load_module(receiver, code, size);
-          //send a transaction to indicate that module is loaded by BP.
-       }
+      void load_module_async(uint64_t receiver, const char* code, size_t size) {
+         boost::thread t( [receiver, &code, size, this]() {
+            load_module(receiver, code, size);
+         } );
+      }
 
       std::unique_ptr<wasm_instantiated_module_interface>& load_module(uint64_t receiver, const char* code, size_t size) {
          IR::Module module;
@@ -149,6 +157,7 @@ namespace eosio { namespace chain {
          } catch(const IR::ValidationException& e) {
             EOS_ASSERT(false, wasm_serialization_error, e.message.c_str());
          }
+
          {
             std::lock_guard<std::mutex> lock(m);
             instantiation_cache[receiver] = runtime_interface->instantiate_module((const char*)bytes.data(), bytes.size(), parse_initial_memory(module));

libraries/vm/vm_wasm/wasm_interface.cpp

@@ -64,19 +64,28 @@ namespace eosio { namespace chain {
       }
       validate(code, size);
 
-//      my->get_instantiated_module(account);
+      my->get_instantiated_module(account);
       return 0;
    }
 
    uint64_t wasm_interface::call(string& func, vector<uint64_t>& args) {
-      return my->get_instantiated_module()->call(func, args);
+      try {
+         uint64_t receiver = get_vm_api()->current_receiver();
+         auto& module = my->get_instantiated_module(receiver);
+         if (!module.get()) {
+            return VM_MODULE_NOT_FOUND;
+         }
+         module->call(func, args);
+      } catch ( const wasm_exit& ){
+      }
+      return 1;
    }
 
    int wasm_interface::apply( uint64_t receiver, uint64_t account, uint64_t act ) {
       try {
          auto& module = my->get_instantiated_module(receiver);
          if (!module.get()) {
-            return 0;
+            return VM_MODULE_NOT_FOUND;
          }
          module->apply(receiver, account, act);
       } catch ( const wasm_exit& ){

libraries/vm_manager/vm_manager.cpp

@@ -576,6 +576,7 @@ int vm_manager::setcode(int vm_type, uint64_t account) {
 }
 
 int vm_manager::apply(int type, uint64_t receiver, uint64_t account, uint64_t act) {
+#if 0
    if (is_trusted_account(account)) {
 
    } else {
@@ -584,6 +585,7 @@ int vm_manager::apply(int type, uint64_t receiver, uint64_t account, uint64_t ac
          type = VM_TYPE_IPC;
       }
    }
+#endif
    return local_apply(type, receiver, account, act);
 }
 
@@ -605,6 +607,11 @@ int vm_manager::local_apply(int vm_type, uint64_t receiver, uint64_t account, ui
             }
          }
       }
+#if 0
+      if (receiver == N(eosio.token) || receiver == N(eosio)) {
+         vm_type = VM_TYPE_WAVM;
+      }
+#endif
       if (vm_runtime == 0) {
          vm_type = VM_TYPE_WAVM;
       } else if (vm_runtime == 1) {
@@ -619,7 +626,12 @@ int vm_manager::local_apply(int vm_type, uint64_t receiver, uint64_t account, ui
    if (itr == vm_map.end()) {
       return 0;
    }
-   itr->second->apply(receiver, account, act);
+   int ret = itr->second->apply(receiver, account, act);
+   if (VM_MODULE_NOT_FOUND == ret) {
+      if (VM_TYPE_WAVM == vm_type) {
+         vm_map[VM_TYPE_WABT]->apply(receiver, account, act);
+      }
+   }
    return 1;
 }