EOS-VM Optimized Compiler

CMakeLists.txt

@@ -74,6 +74,10 @@ if(CMAKE_SIZEOF_VOID_P EQUAL 8 AND NOT WIN32)
    if(LLVM_VERSION_MAJOR VERSION_LESS 7 OR LLVM_VERSION_MAJOR VERSION_GREATER 9)
 	   message(FATAL_ERROR "EOSIO requires an LLVM version 7.0 to 9.0")
    endif()
+
+   if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux" AND "${CMAKE_SYSTEM_PROCESSOR}" STREQUAL "x86_64")
+      list(APPEND EOSIO_WASM_RUNTIMES eos-vm-oc)
+   endif()
 endif()
 
 if(UNIX)

libraries/chain/CMakeLists.txt

@@ -20,6 +20,33 @@ if("wavm" IN_LIST EOSIO_WASM_RUNTIMES)
    set(CHAIN_WAVM_SOURCES "webassembly/wavm.cpp")
 endif()
 
+if("eos-vm-oc" IN_LIST EOSIO_WASM_RUNTIMES)
+   set(CHAIN_EOSVMOC_SOURCES webassembly/eos-vm-oc/code_cache.cpp
+                             webassembly/eos-vm-oc/executor.cpp
+                             webassembly/eos-vm-oc/memory.cpp
+                             webassembly/eos-vm-oc/intrinsic.cpp
+                             webassembly/eos-vm-oc/LLVMJIT.cpp
+                             webassembly/eos-vm-oc/LLVMEmitIR.cpp
+                             webassembly/eos-vm-oc/compile_monitor.cpp
+                             webassembly/eos-vm-oc/compile_trampoline.cpp
+                             webassembly/eos-vm-oc/ipc_helpers.cpp
+                             webassembly/eos-vm-oc/gs_seg_helpers.c
+                             webassembly/eos-vm-oc.cpp)
+
+   if(LLVM_VERSION VERSION_LESS 7.1 AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+      enable_language(ASM-LLVMWAR)
+      list(APPEND CHAIN_EOSVMOC_SOURCES webassembly/eos-vm-oc/llvmWARshim.llvmwar)
+   else()
+      list(APPEND CHAIN_EOSVMOC_SOURCES webassembly/eos-vm-oc/llvmWARshim.cpp)
+   endif()
+
+   llvm_map_components_to_libnames(LLVM_LIBS support core passes mcjit native orcjit)
+   include_directories(${LLVM_INCLUDE_DIRS})
+   add_definitions(${LLVM_DEFINITIONS})
+
+   option(EOSVMOC_ENABLE_DEVELOPER_OPTIONS "enable developer options for EOS-VM OC" OFF)
+endif()
+
 ## SORT .cpp by most likely to change / break compile
 add_library( eosio_chain
              merkle.cpp
@@ -56,6 +83,7 @@ add_library( eosio_chain
 
              ${CHAIN_WAVM_SOURCES}
              webassembly/wabt.cpp
+             ${CHAIN_EOSVMOC_SOURCES}
 
 #             get_config.cpp
 #
@@ -76,7 +104,7 @@ add_library( eosio_chain
              )
 
 target_link_libraries( eosio_chain fc chainbase Logging IR WAST WASM Runtime
-                       softfloat builtins wabt
+                       softfloat builtins wabt ${LLVM_LIBS}
                      )
 target_include_directories( eosio_chain
                             PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include" "${CMAKE_CURRENT_BINARY_DIR}/include"
@@ -85,12 +113,21 @@ target_include_directories( eosio_chain
                                    "${CMAKE_BINARY_DIR}/libraries/wabt"
                             )
 
+if("eos-vm-oc" IN_LIST EOSIO_WASM_RUNTIMES)
+   target_link_libraries(eosio_chain "-Wl,-wrap=main")
+endif()
+
 foreach(RUNTIME ${EOSIO_WASM_RUNTIMES})
    string(TOUPPER "${RUNTIME}" RUNTIMEUC)
    string(REPLACE "-" "_" RUNTIMEUC ${RUNTIMEUC})
    target_compile_definitions(eosio_chain PUBLIC "EOSIO_${RUNTIMEUC}_RUNTIME_ENABLED")
 endforeach()
 
+if(EOSVMOC_ENABLE_DEVELOPER_OPTIONS)
+   message(WARNING "EOS-VM OC Developer Options are enabled; these are NOT supported")
+   target_compile_definitions(eosio_chain PUBLIC EOSIO_EOS_VM_OC_DEVELOPER)
+endif()
+
 install( TARGETS eosio_chain
    RUNTIME DESTINATION ${CMAKE_INSTALL_FULL_BINDIR}
    LIBRARY DESTINATION ${CMAKE_INSTALL_FULL_LIBDIR}

libraries/chain/controller.cpp

@@ -291,7 +291,7 @@ struct controller_impl {
         cfg.reversible_cache_size, false, cfg.db_map_mode, cfg.db_hugepage_paths ),
     blog( cfg.blocks_dir ),
     fork_db( cfg.state_dir ),
-    wasmif( cfg.wasm_runtime, db ),
+    wasmif( cfg.wasm_runtime, cfg.eosvmoc_tierup, db, cfg.state_dir, cfg.eosvmoc_config ),
     resource_limits( db ),
     authorization( s, db ),
     protocol_features( std::move(pfs) ),

libraries/chain/include/eosio/chain/controller.hpp

@@ -9,6 +9,7 @@
 #include <eosio/chain/account_object.hpp>
 #include <eosio/chain/snapshot.hpp>
 #include <eosio/chain/protocol_feature_manager.hpp>
+#include <eosio/chain/webassembly/eos-vm-oc/config.hpp>
 
 namespace chainbase {
    class database;
@@ -82,6 +83,8 @@ namespace eosio { namespace chain {
             bool                     disable_all_subjective_mitigations = false; //< for testing purposes only
 
             wasm_interface::vm_type  wasm_runtime = chain::config::default_wasm_runtime;
+            eosvmoc::config          eosvmoc_config;
+            bool                     eosvmoc_tierup         = false;
 
             db_read_mode             read_mode              = db_read_mode::SPECULATIVE;
             validation_mode          block_validation_mode  = validation_mode::FULL;

libraries/chain/include/eosio/chain/wasm_interface.hpp

@@ -11,6 +11,7 @@ namespace eosio { namespace chain {
    class apply_context;
    class wasm_runtime_interface;
    class controller;
+   namespace eosvmoc { struct config; }
 
    struct wasm_exit {
       int32_t code = 0;
@@ -73,10 +74,11 @@ namespace eosio { namespace chain {
       public:
          enum class vm_type {
             wavm,
-            wabt
+            wabt,
+            eos_vm_oc
          };
 
-         wasm_interface(vm_type vm, const chainbase::database& db);
+         wasm_interface(vm_type vm, bool eosvmoc_tierup, const chainbase::database& d, const boost::filesystem::path data_dir, const eosvmoc::config& eosvmoc_config);
          ~wasm_interface();
 
          //call before dtor to skip what can be minutes of dtor overhead with some runtimes; can cause leaks
@@ -108,4 +110,4 @@ namespace eosio{ namespace chain {
    std::istream& operator>>(std::istream& in, wasm_interface::vm_type& runtime);
 }}
 
-FC_REFLECT_ENUM( eosio::chain::wasm_interface::vm_type, (wavm)(wabt) )
+FC_REFLECT_ENUM( eosio::chain::wasm_interface::vm_type, (wavm)(wabt)(eos_vm_oc) )

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

@@ -3,6 +3,11 @@
 #include <eosio/chain/wasm_interface.hpp>
 #include <eosio/chain/webassembly/wavm.hpp>
 #include <eosio/chain/webassembly/wabt.hpp>
+#ifdef EOSIO_EOS_VM_OC_RUNTIME_ENABLED
+#include <eosio/chain/webassembly/eos-vm-oc.hpp>
+#else
+#define _REGISTER_EOSVMOC_INTRINSIC(CLS, MOD, METHOD, WASM_SIG, NAME, SIG)
+#endif
 #include <eosio/chain/webassembly/runtime_interface.hpp>
 #include <eosio/chain/wasm_eosio_injection.hpp>
 #include <eosio/chain/transaction_context.hpp>
@@ -24,6 +29,8 @@ using boost::multi_index_container;
 
 namespace eosio { namespace chain {
 
+   namespace eosvmoc { struct config; }
+
    struct wasm_interface_impl {
       struct wasm_cache_entry {
          digest_type                                          code_hash;
@@ -37,15 +44,35 @@ namespace eosio { namespace chain {
       struct by_first_block_num;
       struct by_last_block_num;
 
-      wasm_interface_impl(wasm_interface::vm_type vm, const chainbase::database& d) : db(d) {
+#ifdef EOSIO_EOS_VM_OC_RUNTIME_ENABLED
+      struct eosvmoc_tier {
+         eosvmoc_tier(const boost::filesystem::path& d, const eosvmoc::config& c, const chainbase::database& db) : cc(d, c, db), exec(cc) {}
+         eosvmoc::code_cache_async cc;
+         eosvmoc::executor exec;
+         eosvmoc::memory mem;
+      };
+#endif
+
+      wasm_interface_impl(wasm_interface::vm_type vm, bool eosvmoc_tierup, const chainbase::database& d, const boost::filesystem::path data_dir, const eosvmoc::config& eosvmoc_config) : db(d), wasm_runtime_time(vm) {
 #ifdef EOSIO_WAVM_RUNTIME_ENABLED
          if(vm == wasm_interface::vm_type::wavm)
             runtime_interface = std::make_unique<webassembly::wavm::wavm_runtime>();
 #endif
          if(vm == wasm_interface::vm_type::wabt)
             runtime_interface = std::make_unique<webassembly::wabt_runtime::wabt_runtime>();
+#ifdef EOSIO_EOS_VM_OC_RUNTIME_ENABLED
+         if(vm == wasm_interface::vm_type::eos_vm_oc)
+            runtime_interface = std::make_unique<webassembly::eosvmoc::eosvmoc_runtime>(data_dir, eosvmoc_config, d);
+#endif
          if(!runtime_interface)
             EOS_THROW(wasm_exception, "${r} wasm runtime not supported on this platform and/or configuration", ("r", vm));
+
+#ifdef EOSIO_EOS_VM_OC_RUNTIME_ENABLED
+         if(eosvmoc_tierup) {
+            EOS_ASSERT(vm != wasm_interface::vm_type::eos_vm_oc, wasm_exception, "You can't use EOS-VM OC as the base runtime when tier up is activated");
+            eosvmoc.emplace(data_dir, eosvmoc_config, d);
+         }
+#endif
       }
 
       ~wasm_interface_impl() {
@@ -84,7 +111,13 @@ namespace eosio { namespace chain {
 
       void current_lib(uint32_t lib) {
          //anything last used before or on the LIB can be evicted
-         wasm_instantiation_cache.get<by_last_block_num>().erase(wasm_instantiation_cache.get<by_last_block_num>().begin(), wasm_instantiation_cache.get<by_last_block_num>().upper_bound(lib));
+         const auto first_it = wasm_instantiation_cache.get<by_last_block_num>().begin();
+         const auto last_it  = wasm_instantiation_cache.get<by_last_block_num>().upper_bound(lib);
+#ifdef EOSIO_EOS_VM_OC_RUNTIME_ENABLED
+         if(eosvmoc) for(auto it = first_it; it != last_it; it++)
+            eosvmoc->cc.free_code(it->code_hash, it->vm_version);
+#endif
+         wasm_instantiation_cache.get<by_last_block_num>().erase(first_it, last_it);
       }
 
       const std::unique_ptr<wasm_instantiated_module_interface>& get_instantiated_module( const digest_type& code_hash, const uint8_t& vm_type,
@@ -125,8 +158,14 @@ namespace eosio { namespace chain {
                EOS_ASSERT(false, wasm_serialization_error, e.message.c_str());
             }
 
-            wasm_injections::wasm_binary_injection<true> injector(module);
-            injector.inject();
+            if(wasm_runtime_time == wasm_interface::vm_type::wabt || wasm_runtime_time == wasm_interface::vm_type::wavm) {
+               wasm_injections::wasm_binary_injection<true> injector(module);
+               injector.inject();
+            }
+            else {
+               wasm_injections::wasm_binary_injection<false> injector(module);
+               injector.inject();
+            }
 
             std::vector<U8> bytes;
             try {
@@ -140,7 +179,7 @@ namespace eosio { namespace chain {
             }
 
             wasm_instantiation_cache.modify(it, [&](auto& c) {
-               c.module = runtime_interface->instantiate_module((const char*)bytes.data(), bytes.size(), parse_initial_memory(module));
+               c.module = runtime_interface->instantiate_module((const char*)bytes.data(), bytes.size(), parse_initial_memory(module), code_hash, vm_type, vm_version);
             });
          }
          return it->module;
@@ -166,6 +205,11 @@ namespace eosio { namespace chain {
       wasm_cache_index wasm_instantiation_cache;
 
       const chainbase::database& db;
+      const wasm_interface::vm_type wasm_runtime_time;
+
+#ifdef EOSIO_EOS_VM_OC_RUNTIME_ENABLED
+      fc::optional<eosvmoc_tier> eosvmoc;
+#endif
    };
 
 #define _ADD_PAREN_1(...) ((__VA_ARGS__)) _ADD_PAREN_2
@@ -176,6 +220,7 @@ namespace eosio { namespace chain {
 
 #define _REGISTER_INTRINSIC_EXPLICIT(CLS, MOD, METHOD, WASM_SIG, NAME, SIG)\
    _REGISTER_WAVM_INTRINSIC(CLS, MOD, METHOD, WASM_SIG, NAME, SIG)\
+   _REGISTER_EOSVMOC_INTRINSIC(CLS, MOD, METHOD, WASM_SIG, NAME, SIG)\
    _REGISTER_WABT_INTRINSIC(CLS, MOD, METHOD, WASM_SIG, NAME, SIG)
 
 #define _REGISTER_INTRINSIC4(CLS, MOD, METHOD, WASM_SIG, NAME, SIG)\