Add option to preload cache

evmjit/libevmjit/Cache.cpp

@@ -4,6 +4,7 @@
 #include <llvm/IR/Module.h>
 #include <llvm/IR/LLVMContext.h>
 #include <llvm/IR/Instructions.h>
+#include <llvm/ExecutionEngine/ExecutionEngine.h>
 #include <llvm/Support/Path.h>
 #include <llvm/Support/FileSystem.h>
 #include <llvm/Support/raw_os_ostream.h>
@@ -59,6 +60,36 @@ void Cache::clear()
 		fs::remove(it->path());
 }
 
+void Cache::preload(llvm::ExecutionEngine& _ee, std::unordered_map<std::string, uint64_t>& _funcCache)
+{
+	// TODO: Cache dir should be in one place
+	using namespace llvm::sys;
+	llvm::SmallString<256> cachePath;
+	path::system_temp_directory(false, cachePath);
+	path::append(cachePath, "evm_objs");
+
+	// Disable listener
+	auto listener = g_listener;
+	g_listener = nullptr;
+
+	std::error_code err;
+	for (auto it = fs::directory_iterator{cachePath.str(), err}; it != fs::directory_iterator{}; it.increment(err))
+	{
+		auto name = it->path().substr(cachePath.size() + 1);
+		if (auto module = getObject(name))
+		{
+			DLOG(cache) << "Preload: " << name << "\n";
+			_ee.addModule(module.get());
+			module.release();
+			auto addr = _ee.getFunctionAddress(name);
+			assert(addr);
+			_funcCache[std::move(name)] = addr;
+		}
+	}
+
+	g_listener = listener;
+}
+
 std::unique_ptr<llvm::Module> Cache::getObject(std::string const& id)
 {
 	if (g_mode != CacheMode::on && g_mode != CacheMode::read)

evmjit/libevmjit/Cache.h

@@ -1,9 +1,15 @@
 #pragma once
 
 #include <memory>
+#include <unordered_map>
 
 #include <llvm/ExecutionEngine/ObjectCache.h>
 
+namespace llvm
+{
+	class ExecutionEngine;
+}
+
 namespace dev
 {
 namespace eth
@@ -18,7 +24,8 @@ enum class CacheMode
 	off,
 	read,
 	write,
-	clear
+	clear,
+	preload
 };
 
 class ObjectCache : public llvm::ObjectCache
@@ -43,6 +50,9 @@ public:
 
 	/// Clears cache storage
 	static void clear();
+
+	/// Loads all available cached objects to ExecutionEngine
+	static void preload(llvm::ExecutionEngine& _ee, std::unordered_map<std::string, uint64_t>& _funcCache);
 };
 
 }

evmjit/libevmjit/ExecutionEngine.cpp

@@ -76,6 +76,7 @@ cl::opt<CacheMode> g_cache{"cache", cl::desc{"Cache compiled EVM code on disk"},
 		clEnumValN(CacheMode::read,  "r", "Read only. No new objects are added to cache."),
 		clEnumValN(CacheMode::write, "w", "Write only. No objects are loaded from cache."),
 		clEnumValN(CacheMode::clear, "c", "Clear the cache storage. Cache is disabled."),
+		clEnumValN(CacheMode::preload, "p", "Preload all cached objects."),
 		clEnumValEnd)};
 cl::opt<bool> g_stats{"st", cl::desc{"Statistics"}};
 cl::opt<bool> g_dump{"dump", cl::desc{"Dump LLVM IR module"}};
@@ -111,8 +112,15 @@ ReturnCode ExecutionEngine::run(RuntimeData* _data, Env* _env)
 	std::unique_ptr<ExecStats> listener{new ExecStats};
 	listener->stateChanged(ExecState::Started);
 
+	bool preloadCache = g_cache == CacheMode::preload;
+	if (preloadCache)
+		g_cache = CacheMode::on;
+
+	// TODO: Do not pseudo-init the cache every time
 	auto objectCache = (g_cache != CacheMode::off && g_cache != CacheMode::clear) ? Cache::getObjectCache(g_cache, listener.get()) : nullptr;
 
+	static std::unordered_map<std::string, uint64_t> funcCache;
+
 	static std::unique_ptr<llvm::ExecutionEngine> ee;
 	if (!ee)
 	{
@@ -138,6 +146,9 @@ ReturnCode ExecutionEngine::run(RuntimeData* _data, Env* _env)
 			return ReturnCode::LLVMConfigError;
 		module.release();  // Successfully created llvm::ExecutionEngine takes ownership of the module
 		ee->setObjectCache(objectCache);
+
+		if (preloadCache)
+			Cache::preload(*ee, funcCache);
 	}
 
 	static StatsCollector statsCollector;
@@ -146,10 +157,9 @@ ReturnCode ExecutionEngine::run(RuntimeData* _data, Env* _env)
 	m_runtime.init(_data, _env);
 
 	EntryFuncPtr entryFuncPtr = nullptr;
-	static std::unordered_map<std::string, EntryFuncPtr> funcCache;
 	auto it = funcCache.find(mainFuncName);
 	if (it != funcCache.end())
-		entryFuncPtr = it->second;
+		entryFuncPtr = (EntryFuncPtr) it->second;
 
 	if (!entryFuncPtr)
 	{
@@ -177,7 +187,8 @@ ReturnCode ExecutionEngine::run(RuntimeData* _data, Env* _env)
 	if (!CHECK(entryFuncPtr))
 		return ReturnCode::LLVMLinkError;
 
-	funcCache[mainFuncName] = entryFuncPtr;
+	if (it == funcCache.end())
+		funcCache[mainFuncName] = (uint64_t) entryFuncPtr;
 
 	listener->stateChanged(ExecState::Execution);
 	auto returnCode = entryFuncPtr(&m_runtime);