Add all init*Engine() static functions, TestVm.Init test, and all warm() implementations.

Signed-off-by: Rachel Green <[email protected]>

Author: rachgreen33

include/proxy-wasm/v8.h

@@ -21,6 +21,7 @@
 
 namespace proxy_wasm {
 
+bool initv8Engine();
 std::unique_ptr<WasmVm> createV8Vm();
 
 } // namespace proxy_wasm

include/proxy-wasm/wamr.h

@@ -21,6 +21,7 @@
 
 namespace proxy_wasm {
 
+bool initWamrEngine();
 std::unique_ptr<WasmVm> createWamrVm();
 
 } // namespace proxy_wasm

include/proxy-wasm/wasmtime.h

@@ -18,6 +18,7 @@
 
 namespace proxy_wasm {
 
+bool initWasmtimeEngine();
 std::unique_ptr<WasmVm> createWasmtimeVm();
 
 } // namespace proxy_wasm

src/v8/v8.cc

@@ -757,6 +757,8 @@ std::string V8::getPluginFailMessage(std::string_view function_name, wasm::own<w
 
 } // namespace v8
 
+bool initV8Engine() { return v8::engine() != nullptr; }
+
 std::unique_ptr<WasmVm> createV8Vm() { return std::make_unique<v8::V8>(); }
 
 } // namespace proxy_wasm

src/wamr/wamr.cc

@@ -121,9 +121,16 @@ class Wamr : public WasmVm {
   std::unordered_map<std::string, WasmFuncPtr> module_functions_;
 };
 
+void Wamr::initStore() {
+  if (store_ != nullptr) {
+    return;
+  }
+  store_ = wasm_store_new(engine());
+}
+
 bool Wamr::load(std::string_view bytecode, std::string_view precompiled,
                 const std::unordered_map<uint32_t, std::string> & /*function_names*/) {
-  store_ = wasm_store_new(engine());
+  initStore();
   if (store_ == nullptr) {
     return false;
   }
@@ -699,8 +706,12 @@ void Wamr::getModuleFunctionImpl(std::string_view function_name,
   };
 };
 
+void Wamr::warm() { initStore(); }
+
 } // namespace wamr
 
+bool initWamrEngine() { return wamr::engine() != nullptr; }
+
 std::unique_ptr<WasmVm> createWamrVm() { return std::make_unique<wamr::Wamr>(); }
 
 } // namespace proxy_wasm

src/wasmedge/wasmedge.cc

@@ -317,13 +317,19 @@ bool WasmEdge::load(std::string_view bytecode, std::string_view /*precompiled*/,
   return true;
 }
 
+void WasmEdge::initStore() {
+  if (store_ != nullptr) {
+    return;
+  }
+  store_ = WasmEdge_StoreCreate();
+}
+
 bool WasmEdge::link(std::string_view /*debug_name*/) {
   assert(ast_module_ != nullptr);
 
   // Create store and register imports.
-  if (store_ == nullptr) {
-    store_ = WasmEdge_StoreCreate();
-  }
+  initStore();
+  
   if (store_ == nullptr) {
     return false;
   }
@@ -612,8 +618,12 @@ void WasmEdge::getModuleFunctionImpl(std::string_view function_name,
   };
 }
 
+void WasmEdge::warm() { initStore(); }
+
 } // namespace WasmEdge
 
+bool initWasmEdgeEngine() { return wasmedge::engine() != nullptr; }
+
 std::unique_ptr<WasmVm> createWasmEdgeVm() { return std::make_unique<WasmEdge::WasmEdge>(); }
 
 } // namespace proxy_wasm

src/wasmtime/wasmtime.cc

@@ -103,6 +103,9 @@ class Wasmtime : public WasmVm {
 
   void warm() override {}
 
+  // Initialize the V8 engine and store if necessary.
+  void initStore();
+
   WasmStorePtr store_;
   WasmModulePtr module_;
   WasmSharedModulePtr shared_module_;
@@ -114,9 +117,15 @@ class Wasmtime : public WasmVm {
   std::unordered_map<std::string, WasmFuncPtr> module_functions_;
 };
 
+void Wasmtime::initStore() {
+  if (store_ != nullptr) {
+    return;
+  }
+  store_ = wasm_store_new(engine());
+
 bool Wasmtime::load(std::string_view bytecode, std::string_view /*precompiled*/,
                     const std::unordered_map<uint32_t, std::string> & /*function_names*/) {
-  store_ = wasm_store_new(engine());
+  initStore();
   if (store_ == nullptr) {
     return false;
   }
@@ -696,8 +705,12 @@ void Wasmtime::getModuleFunctionImpl(std::string_view function_name,
   };
 };
 
+void Wasmtime::warm() { initStore(); }
+
 } // namespace wasmtime
 
+bool initWasmtimeEngine() { return wasmtime::engine() != nullptr; }
+
 std::unique_ptr<WasmVm> createWasmtimeVm() { return std::make_unique<wasmtime::Wasmtime>(); }
 
 } // namespace proxy_wasm

test/wasm_vm_test.cc

@@ -30,6 +30,46 @@ INSTANTIATE_TEST_SUITE_P(WasmEngines, TestVm, testing::ValuesIn(getWasmEngines()
                            return info.param;
                          });
 
+TEST_P(TestVm, Init) {
+  std::chrono::time_point<std::chrono::steady_clock> time2;
+
+  auto time1 = std::chrono::steady_clock::now();
+  if (engine_ == "v8") {
+#if defined(PROXY_WASM_HOST_ENGINE_V8)
+    EXPECT_TRUE(proxy_wasm::initV8Engine());
+    time2 = std::chrono::steady_clock::now();
+    EXPECT_TRUE(proxy_wasm::initV8Engine());
+#endif
+  } else if (engine_ == "wamr") {
+#if defined(PROXY_WASM_HOST_ENGINE_WAMR)
+    EXPECT_TRUE(proxy_wasm::initWamrEngine());
+    time2 = std::chrono::steady_clock::now();
+    EXPECT_TRUE(proxy_wasm::initWamrEngine());
+#endif
+  } else if (engine_ == "wasmtime") {
+#if defined(PROXY_WASM_HOST_ENGINE_WASMTIME)
+    EXPECT_TRUE(proxy_wasm::initWasmtimeEngine());
+    time2 = std::chrono::steady_clock::now();
+    EXPECT_TRUE(proxy_wasm::initWasmtimeEngine());
+#endif
+  } else {
+    return;
+  }
+  auto time3 = std::chrono::steady_clock::now();
+
+  auto cold = std::chrono::duration_cast<std::chrono::nanoseconds>(time2 - time1).count();
+  auto warm = std::chrono::duration_cast<std::chrono::nanoseconds>(time3 - time2).count();
+
+  std::cout << "\"cold\" engine time: " << cold << "ns" << std::endl;
+  std::cout << "\"warm\" engine time: " << warm << "ns" << std::endl;
+
+  // Verify that getting a "warm" engine takes less than 10us.
+  EXPECT_LE(warm, 10000);
+
+  // Verify that getting a "warm" engine takes at least 50x less time than getting a "cold" one.
+  EXPECT_LE(warm * 50, cold);
+}
+
 TEST_P(TestVm, Basic) {
   if (engine_ == "wasmedge") {
     EXPECT_EQ(vm_->cloneable(), proxy_wasm::Cloneable::NotCloneable);