forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-22 04:36:42 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Clean up ExecutionEngine

Browse source
This commit is contained in:
Paweł Bylica 2014-12-31 14:29:49 +01:00
parent de024259c2
commit 28a062318c
3 changed files with 3 additions and 76 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
libevmjit/Cache.cpp
View file

@ -10,42 +10,10 @@ namespace eth
{ {
namespace jit namespace jit
{ {
namespace
{
using CacheMap = std::unordered_map<Cache::Key, ExecBundle>;
CacheMap& getCacheMap()
{
static CacheMap map;
return map;
}
}
//#define LOG(...) std::cerr << "CACHE " //#define LOG(...) std::cerr << "CACHE "
#define LOG(...) std::ostream(nullptr) #define LOG(...) std::ostream(nullptr)
ExecBundle& Cache::registerExec(Cache::Key _key, ExecBundle&& _exec)
{
auto& map = getCacheMap();
auto r = map.insert(std::make_pair(_key, std::move(_exec)));
assert(r.second && "Updating cached objects not supported");
LOG() << "add\n";
return r.first->second; // return exec, now owned by cache
}
ExecBundle* Cache::findExec(Cache::Key _key)
{
auto& map = getCacheMap();
auto it = map.find(_key);
if (it != map.end())
{
LOG() << "hit\n";
return &it->second;
}
LOG() << "miss\n";
return nullptr;
}
ObjectCache* Cache::getObjectCache() ObjectCache* Cache::getObjectCache()
{ {
static ObjectCache objectCache; static ObjectCache objectCache;

23
libevmjit/Cache.h
View file

@ -13,24 +13,6 @@ namespace eth
namespace jit namespace jit
{ {
/// A bundle of objects and information needed for a contract execution
class ExecBundle
{
public:
llvm::ExecutionEngine* engine = nullptr;
std::string mainFuncName;
ExecBundle() = default;
ExecBundle(ExecBundle&& _other):
engine(std::move(_other.engine)),
mainFuncName(std::move(_other.mainFuncName))
{}
ExecBundle(ExecBundle const&) = delete;
void operator=(ExecBundle) = delete;
};
class ObjectCache : public llvm::ObjectCache class ObjectCache : public llvm::ObjectCache
{ {
public: public:
@ -51,11 +33,6 @@ private:
class Cache class Cache
{ {
public: public:
using Key = std::string;
static ExecBundle& registerExec(Key _key, ExecBundle&& _exec);
static ExecBundle* findExec(Key _key);
static ObjectCache* getObjectCache(); static ObjectCache* getObjectCache();
}; };

24
libevmjit/ExecutionEngine.cpp
View file

@ -2,10 +2,6 @@
#include <chrono> #include <chrono>
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#include <llvm/IR/LLVMContext.h>
#include <llvm/IR/Module.h> #include <llvm/IR/Module.h>
#include <llvm/ADT/Triple.h> #include <llvm/ADT/Triple.h>
#include <llvm/ExecutionEngine/ExecutionEngine.h> #include <llvm/ExecutionEngine/ExecutionEngine.h>
@ -13,12 +9,8 @@
#include <llvm/ExecutionEngine/GenericValue.h> #include <llvm/ExecutionEngine/GenericValue.h>
#include <llvm/ExecutionEngine/MCJIT.h> #include <llvm/ExecutionEngine/MCJIT.h>
#include <llvm/Support/TargetSelect.h> #include <llvm/Support/TargetSelect.h>
#include <llvm/Support/Signals.h>
#include <llvm/Support/PrettyStackTrace.h>
#include <llvm/Support/Host.h> #include <llvm/Support/Host.h>
#pragma GCC diagnostic pop
#include "Runtime.h" #include "Runtime.h"
#include "Memory.h" #include "Memory.h"
#include "Stack.h" #include "Stack.h"
@ -42,7 +34,6 @@ ReturnCode ExecutionEngine::run(bytes const& _code, RuntimeData* _data, Env* _en
namespace namespace
{ {
typedef ReturnCode(*EntryFuncPtr)(Runtime*); typedef ReturnCode(*EntryFuncPtr)(Runtime*);
ReturnCode runEntryFunc(EntryFuncPtr _mainFunc, Runtime* _runtime) ReturnCode runEntryFunc(EntryFuncPtr _mainFunc, Runtime* _runtime)
@ -59,7 +50,6 @@ ReturnCode runEntryFunc(EntryFuncPtr _mainFunc, Runtime* _runtime)
return returnCode; return returnCode;
} }
} }
ReturnCode ExecutionEngine::run(std::unique_ptr<llvm::Module> _module, RuntimeData* _data, Env* _env, bytes const& _code) ReturnCode ExecutionEngine::run(std::unique_ptr<llvm::Module> _module, RuntimeData* _data, Env* _env, bytes const& _code)
@ -72,12 +62,8 @@ ReturnCode ExecutionEngine::run(std::unique_ptr<llvm::Module> _module, RuntimeDa
static std::unique_ptr<llvm::ExecutionEngine> ee; // TODO: Use Managed Objects from LLVM? static std::unique_ptr<llvm::ExecutionEngine> ee; // TODO: Use Managed Objects from LLVM?
EntryFuncPtr entryFuncPtr{}; EntryFuncPtr entryFuncPtr{};
Runtime runtime(_data, _env);
auto&& mainFuncName = _module->getModuleIdentifier(); auto&& mainFuncName = _module->getModuleIdentifier();
Runtime runtime(_data, _env); // TODO: I don't know why but it must be created before getFunctionAddress() calls
if (!ee) if (!ee)
{ {
@ -118,22 +104,18 @@ ReturnCode ExecutionEngine::run(std::unique_ptr<llvm::Module> _module, RuntimeDa
} }
assert(entryFuncPtr); assert(entryFuncPtr);
auto executionStartTime = std::chrono::high_resolution_clock::now(); auto executionStartTime = std::chrono::high_resolution_clock::now();
//auto mainFunc = (EntryFuncPtr)ee->getFunctionAddress(mainFuncName);
auto returnCode = runEntryFunc(entryFuncPtr, &runtime); auto returnCode = runEntryFunc(entryFuncPtr, &runtime);
if (returnCode == ReturnCode::Return) if (returnCode == ReturnCode::Return)
this->returnData = runtime.getReturnData(); this->returnData = runtime.getReturnData();
auto executionEndTime = std::chrono::high_resolution_clock::now(); auto executionEndTime = std::chrono::high_resolution_clock::now();
clog(JIT) << " + " << std::chrono::duration_cast<std::chrono::milliseconds>(executionEndTime - executionStartTime).count() << " ms "; clog(JIT) << " + " << std::chrono::duration_cast<std::chrono::milliseconds>(executionEndTime - executionStartTime).count() << " ms\n";
clog(JIT) << "\n";
return returnCode; return returnCode;
} }
} }
} }
} }