Gav Wood
10 years ago
62 changed files with 2003 additions and 958 deletions
@ -0,0 +1,21 @@ |
|||
The MIT License (MIT) |
|||
|
|||
Copyright (c) 2015 Paweł Bylica <chfast@gmail.com> |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a copy |
|||
of this software and associated documentation files (the "Software"), to deal |
|||
in the Software without restriction, including without limitation the rights |
|||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|||
copies of the Software, and to permit persons to whom the Software is |
|||
furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in all |
|||
copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|||
SOFTWARE. |
|||
@ -0,0 +1,43 @@ |
|||
# The Ethereum EVM JIT |
|||
|
|||
EVM JIT is a library for just-in-time compilation of Ethereum EVM code. |
|||
It can be used to substitute classic interpreter-like EVM Virtual Machine in Ethereum client. |
|||
|
|||
## Build |
|||
|
|||
### Linux / Ubuntu |
|||
|
|||
1. Install llvm-3.5-dev package |
|||
1. For Ubuntu 14.04 using LLVM deb packages source: http://llvm.org/apt |
|||
2. For Ubuntu 14.10 using Ubuntu packages |
|||
2. Build library with cmake |
|||
1. `mkdir build && cd $_` |
|||
2. `cmake .. && make` |
|||
3. Install library |
|||
1. `sudo make install` |
|||
2. `sudo ldconfig` |
|||
|
|||
### OSX |
|||
|
|||
1. Install llvm35 |
|||
1. `brew install llvm35 --disable-shared --HEAD` |
|||
2. Build library with cmake |
|||
1. `mkdir build && cd $_` |
|||
2. `cmake -DLLVM_DIR=/usr/local/lib/llvm-3.5/share/llvm/cmake .. && make` |
|||
3. Install library |
|||
1. `make install` (with admin rights?) |
|||
|
|||
### Windows |
|||
|
|||
Ask me. |
|||
|
|||
## Options |
|||
|
|||
Options to evmjit library can be passed by environmental variables, e.g. `EVMJIT_CACHE=0 testeth --jit`. |
|||
|
|||
Option | Default value | Description |
|||
------------- | ------------- | ---------------------------------------------- |
|||
EVMJIT_CACHE | 1 | Enables on disk cache for compiled EVM objects |
|||
EVMJIT_DUMP | 0 | Dumps generated LLVM module to standard output |
|||
|
|||
|
|||
@ -0,0 +1,10 @@ |
|||
|
|||
#define EVMJIT_VERSION "${EVMJIT_VERSION}" |
|||
#define EVMJIT_VERSION_MAJOR ${EVMJIT_VERSION_MAJOR} |
|||
#define EVMJIT_VERSION_MINOR ${EVMJIT_VERSION_MINOR} |
|||
#define EVMJIT_VERSION_PATCH ${EVMJIT_VERSION_PATCH} |
|||
#define EVMJIT_VERSION_PRERELEASE "${EVMJIT_VERSION_PRERELEASE}" |
|||
#define EVMJIT_VERSION_FULL "${EVMJIT_VERSION_FULL}" |
|||
|
|||
#define LLVM_VERSION "${LLVM_PACKAGE_VERSION}" |
|||
#define LLVM_ASSERTIONS "${LLVM_ENABLE_ASSERTIONS}" |
|||
@ -0,0 +1,97 @@ |
|||
#include "ExecStats.h" |
|||
|
|||
#include <iostream> |
|||
#include <iomanip> |
|||
#include <cassert> |
|||
|
|||
#include "Utils.h" |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
namespace jit |
|||
{ |
|||
|
|||
void ExecStats::stateChanged(ExecState _state) |
|||
{ |
|||
if (!CHECK(m_state != ExecState::Finished)) |
|||
return; |
|||
|
|||
auto now = clock::now(); |
|||
if (_state != ExecState::Started) |
|||
{ |
|||
assert(time[(int)m_state] == ExecStats::duration::zero()); |
|||
time[(int)m_state] = now - m_tp; |
|||
} |
|||
m_state = _state; |
|||
m_tp = now; |
|||
} |
|||
|
|||
namespace |
|||
{ |
|||
struct StatsAgg |
|||
{ |
|||
using unit = std::chrono::microseconds; |
|||
ExecStats::duration tot = ExecStats::duration::zero(); |
|||
ExecStats::duration min = ExecStats::duration::max(); |
|||
ExecStats::duration max = ExecStats::duration::zero(); |
|||
size_t count = 0; |
|||
|
|||
void update(ExecStats::duration _d) |
|||
{ |
|||
++count; |
|||
tot += _d; |
|||
min = _d < min ? _d : min; |
|||
max = _d > max ? _d : max; |
|||
} |
|||
|
|||
void output(char const* _name, std::ostream& _os) |
|||
{ |
|||
auto avg = tot / count; |
|||
_os << std::setfill(' ') |
|||
<< std::setw(12) << std::left << _name |
|||
<< std::setw(10) << std::right << std::chrono::duration_cast<unit>(tot).count() |
|||
<< std::setw(10) << std::right << std::chrono::duration_cast<unit>(avg).count() |
|||
<< std::setw(10) << std::right << std::chrono::duration_cast<unit>(min).count() |
|||
<< std::setw(10) << std::right << std::chrono::duration_cast<unit>(max).count() |
|||
<< std::endl; |
|||
} |
|||
}; |
|||
|
|||
char const* getExecStateName(ExecState _state) |
|||
{ |
|||
switch (_state) |
|||
{ |
|||
case ExecState::Started: return "Start"; |
|||
case ExecState::CacheLoad: return "CacheLoad"; |
|||
case ExecState::CacheWrite: return "CacheWrite"; |
|||
case ExecState::Compilation: return "Compilation"; |
|||
case ExecState::CodeGen: return "CodeGen"; |
|||
case ExecState::Execution: return "Execution"; |
|||
case ExecState::Return: return "Return"; |
|||
case ExecState::Finished: return "Finish"; |
|||
} |
|||
return nullptr; |
|||
} |
|||
} |
|||
|
|||
StatsCollector::~StatsCollector() |
|||
{ |
|||
if (stats.empty()) |
|||
return; |
|||
|
|||
std::cout << " [us] total avg min max\n"; |
|||
for (int i = 0; i < (int)ExecState::Finished; ++i) |
|||
{ |
|||
StatsAgg agg; |
|||
for (auto&& s : stats) |
|||
agg.update(s->time[i]); |
|||
|
|||
agg.output(getExecStateName(ExecState(i)), std::cout); |
|||
} |
|||
} |
|||
|
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,43 @@ |
|||
#pragma once |
|||
|
|||
#include <chrono> |
|||
|
|||
#include "ExecutionEngine.h" |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
namespace jit |
|||
{ |
|||
|
|||
class ExecStats : public ExecutionEngineListener |
|||
{ |
|||
public: |
|||
using clock = std::chrono::high_resolution_clock; |
|||
using duration = clock::duration; |
|||
using time_point = clock::time_point; |
|||
|
|||
std::string id; |
|||
duration time[(int)ExecState::Finished] = {}; |
|||
|
|||
void stateChanged(ExecState _state) override; |
|||
|
|||
private: |
|||
ExecState m_state = {}; |
|||
time_point m_tp = {}; |
|||
|
|||
}; |
|||
|
|||
|
|||
class StatsCollector |
|||
{ |
|||
public: |
|||
std::vector<std::unique_ptr<ExecStats>> stats; |
|||
|
|||
~StatsCollector(); |
|||
}; |
|||
|
|||
} |
|||
} |
|||
} |
|||
@ -1,239 +1,260 @@ |
|||
#include "Memory.h" |
|||
|
|||
#include <vector> |
|||
#include <iostream> |
|||
#include <iomanip> |
|||
#include <cstdint> |
|||
#include <cassert> |
|||
|
|||
#include <llvm/IR/GlobalVariable.h> |
|||
#include <llvm/IR/Function.h> |
|||
#include <llvm/IR/IntrinsicInst.h> |
|||
|
|||
#include "Type.h" |
|||
#include "Runtime.h" |
|||
#include "GasMeter.h" |
|||
#include "Endianness.h" |
|||
#include "RuntimeManager.h" |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
namespace jit |
|||
{ |
|||
|
|||
Memory::Memory(RuntimeManager& _runtimeManager, GasMeter& _gasMeter): |
|||
RuntimeHelper(_runtimeManager), // TODO: RuntimeHelper not needed
|
|||
m_gasMeter(_gasMeter) |
|||
{ |
|||
llvm::Type* resizeArgs[] = {Type::RuntimePtr, Type::WordPtr}; |
|||
m_resize = llvm::Function::Create(llvm::FunctionType::get(Type::BytePtr, resizeArgs, false), llvm::Function::ExternalLinkage, "mem_resize", getModule()); |
|||
llvm::AttrBuilder attrBuilder; |
|||
attrBuilder.addAttribute(llvm::Attribute::NoAlias).addAttribute(llvm::Attribute::NoCapture).addAttribute(llvm::Attribute::NonNull).addAttribute(llvm::Attribute::ReadOnly); |
|||
m_resize->setAttributes(llvm::AttributeSet::get(m_resize->getContext(), 1, attrBuilder)); |
|||
|
|||
m_require = createRequireFunc(_gasMeter); |
|||
m_loadWord = createFunc(false, Type::Word, _gasMeter); |
|||
m_storeWord = createFunc(true, Type::Word, _gasMeter); |
|||
m_storeByte = createFunc(true, Type::Byte, _gasMeter); |
|||
} |
|||
|
|||
llvm::Function* Memory::createRequireFunc(GasMeter& _gasMeter) |
|||
{ |
|||
llvm::Type* argTypes[] = {Type::RuntimePtr, Type::Word, Type::Word}; |
|||
auto func = llvm::Function::Create(llvm::FunctionType::get(Type::Void, argTypes, false), llvm::Function::PrivateLinkage, "mem.require", getModule()); |
|||
auto rt = func->arg_begin(); |
|||
rt->setName("rt"); |
|||
auto offset = rt->getNextNode(); |
|||
offset->setName("offset"); |
|||
auto size = offset->getNextNode(); |
|||
size->setName("size"); |
|||
|
|||
auto preBB = llvm::BasicBlock::Create(func->getContext(), "Pre", func); |
|||
auto checkBB = llvm::BasicBlock::Create(func->getContext(), "Check", func); |
|||
auto resizeBB = llvm::BasicBlock::Create(func->getContext(), "Resize", func); |
|||
auto returnBB = llvm::BasicBlock::Create(func->getContext(), "Return", func); |
|||
|
|||
InsertPointGuard guard(m_builder); // Restores insert point at function exit
|
|||
|
|||
// BB "Pre": Ignore checks with size 0
|
|||
m_builder.SetInsertPoint(preBB); |
|||
auto sizeIsZero = m_builder.CreateICmpEQ(size, Constant::get(0)); |
|||
m_builder.CreateCondBr(sizeIsZero, returnBB, checkBB); |
|||
|
|||
// BB "Check"
|
|||
m_builder.SetInsertPoint(checkBB); |
|||
auto uaddWO = llvm::Intrinsic::getDeclaration(getModule(), llvm::Intrinsic::uadd_with_overflow, Type::Word); |
|||
auto uaddRes = m_builder.CreateCall2(uaddWO, offset, size, "res"); |
|||
auto sizeRequired = m_builder.CreateExtractValue(uaddRes, 0, "sizeReq"); |
|||
auto overflow1 = m_builder.CreateExtractValue(uaddRes, 1, "overflow1"); |
|||
auto rtPtr = getRuntimeManager().getRuntimePtr(); |
|||
auto sizePtr = m_builder.CreateStructGEP(rtPtr, 4); |
|||
auto currSize = m_builder.CreateLoad(sizePtr, "currSize"); |
|||
auto tooSmall = m_builder.CreateICmpULE(currSize, sizeRequired, "tooSmall"); |
|||
auto resizeNeeded = m_builder.CreateOr(tooSmall, overflow1, "resizeNeeded"); |
|||
m_builder.CreateCondBr(resizeNeeded, resizeBB, returnBB); // OPT branch weights?
|
|||
|
|||
// BB "Resize"
|
|||
m_builder.SetInsertPoint(resizeBB); |
|||
// Check gas first
|
|||
uaddRes = m_builder.CreateCall2(uaddWO, sizeRequired, Constant::get(31), "res"); |
|||
auto wordsRequired = m_builder.CreateExtractValue(uaddRes, 0); |
|||
auto overflow2 = m_builder.CreateExtractValue(uaddRes, 1, "overflow2"); |
|||
auto overflow = m_builder.CreateOr(overflow1, overflow2, "overflow"); |
|||
wordsRequired = m_builder.CreateSelect(overflow, Constant::get(-1), wordsRequired); |
|||
wordsRequired = m_builder.CreateUDiv(wordsRequired, Constant::get(32), "wordsReq"); |
|||
sizeRequired = m_builder.CreateMul(wordsRequired, Constant::get(32), "roundedSizeReq"); |
|||
auto words = m_builder.CreateUDiv(currSize, Constant::get(32), "words"); // size is always 32*k
|
|||
auto newWords = m_builder.CreateSub(wordsRequired, words, "addtionalWords"); |
|||
_gasMeter.countMemory(newWords); |
|||
// Resize
|
|||
m_builder.CreateStore(sizeRequired, sizePtr); |
|||
auto newData = m_builder.CreateCall2(m_resize, rt, sizePtr, "newData"); |
|||
auto dataPtr = m_builder.CreateStructGEP(rtPtr, 3); |
|||
m_builder.CreateStore(newData, dataPtr); |
|||
m_builder.CreateBr(returnBB); |
|||
|
|||
// BB "Return"
|
|||
m_builder.SetInsertPoint(returnBB); |
|||
m_builder.CreateRetVoid(); |
|||
return func; |
|||
} |
|||
|
|||
llvm::Function* Memory::createFunc(bool _isStore, llvm::Type* _valueType, GasMeter&) |
|||
{ |
|||
auto isWord = _valueType == Type::Word; |
|||
|
|||
llvm::Type* storeArgs[] = {Type::RuntimePtr, Type::Word, _valueType}; |
|||
llvm::Type* loadArgs[] = {Type::RuntimePtr, Type::Word}; |
|||
auto name = _isStore ? isWord ? "mstore" : "mstore8" : "mload"; |
|||
auto funcType = _isStore ? llvm::FunctionType::get(Type::Void, storeArgs, false) : llvm::FunctionType::get(Type::Word, loadArgs, false); |
|||
auto func = llvm::Function::Create(funcType, llvm::Function::PrivateLinkage, name, getModule()); |
|||
|
|||
InsertPointGuard guard(m_builder); // Restores insert point at function exit
|
|||
|
|||
m_builder.SetInsertPoint(llvm::BasicBlock::Create(func->getContext(), {}, func)); |
|||
auto rt = func->arg_begin(); |
|||
rt->setName("rt"); |
|||
auto index = rt->getNextNode(); |
|||
index->setName("index"); |
|||
|
|||
auto valueSize = _valueType->getPrimitiveSizeInBits() / 8; |
|||
this->require(index, Constant::get(valueSize)); |
|||
auto ptr = getBytePtr(index); |
|||
if (isWord) |
|||
ptr = m_builder.CreateBitCast(ptr, Type::WordPtr, "wordPtr"); |
|||
if (_isStore) |
|||
{ |
|||
llvm::Value* value = index->getNextNode(); |
|||
value->setName("value"); |
|||
if (isWord) |
|||
value = Endianness::toBE(m_builder, value); |
|||
m_builder.CreateStore(value, ptr); |
|||
m_builder.CreateRetVoid(); |
|||
} |
|||
else |
|||
{ |
|||
llvm::Value* ret = m_builder.CreateLoad(ptr); |
|||
ret = Endianness::toNative(m_builder, ret); |
|||
m_builder.CreateRet(ret); |
|||
} |
|||
|
|||
return func; |
|||
} |
|||
|
|||
|
|||
llvm::Value* Memory::loadWord(llvm::Value* _addr) |
|||
{ |
|||
return createCall(m_loadWord, {getRuntimeManager().getRuntimePtr(), _addr}); |
|||
} |
|||
|
|||
void Memory::storeWord(llvm::Value* _addr, llvm::Value* _word) |
|||
{ |
|||
createCall(m_storeWord, {getRuntimeManager().getRuntimePtr(), _addr, _word}); |
|||
} |
|||
|
|||
void Memory::storeByte(llvm::Value* _addr, llvm::Value* _word) |
|||
{ |
|||
auto byte = m_builder.CreateTrunc(_word, Type::Byte, "byte"); |
|||
createCall(m_storeByte, {getRuntimeManager().getRuntimePtr(), _addr, byte}); |
|||
} |
|||
|
|||
llvm::Value* Memory::getData() |
|||
{ |
|||
auto rtPtr = getRuntimeManager().getRuntimePtr(); |
|||
auto dataPtr = m_builder.CreateStructGEP(rtPtr, 3); |
|||
return m_builder.CreateLoad(dataPtr, "data"); |
|||
} |
|||
|
|||
llvm::Value* Memory::getSize() |
|||
{ |
|||
auto rtPtr = getRuntimeManager().getRuntimePtr(); |
|||
auto sizePtr = m_builder.CreateStructGEP(rtPtr, 4); |
|||
return m_builder.CreateLoad(sizePtr, "size"); |
|||
} |
|||
|
|||
llvm::Value* Memory::getBytePtr(llvm::Value* _index) |
|||
{ |
|||
auto idx = m_builder.CreateTrunc(_index, Type::Size, "idx"); // Never allow memory index be a type bigger than i64
|
|||
return m_builder.CreateGEP(getData(), idx, "ptr"); |
|||
} |
|||
|
|||
void Memory::require(llvm::Value* _offset, llvm::Value* _size) |
|||
{ |
|||
createCall(m_require, {getRuntimeManager().getRuntimePtr(), _offset, _size}); |
|||
} |
|||
|
|||
void Memory::copyBytes(llvm::Value* _srcPtr, llvm::Value* _srcSize, llvm::Value* _srcIdx, |
|||
llvm::Value* _destMemIdx, llvm::Value* _reqBytes) |
|||
{ |
|||
require(_destMemIdx, _reqBytes); |
|||
|
|||
// Additional copy cost
|
|||
// TODO: This round ups to 32 happens in many places
|
|||
auto copyWords = m_builder.CreateUDiv(m_builder.CreateAdd(_reqBytes, Constant::get(31)), Constant::get(32)); |
|||
m_gasMeter.countCopy(copyWords); |
|||
|
|||
// Algorithm:
|
|||
// isOutsideData = idx256 >= size256
|
|||
// idx64 = trunc idx256
|
|||
// size64 = trunc size256
|
|||
// dataLeftSize = size64 - idx64 // safe if not isOutsideData
|
|||
// reqBytes64 = trunc _reqBytes // require() handles large values
|
|||
// bytesToCopy0 = select(reqBytes64 > dataLeftSize, dataSizeLeft, reqBytes64) // min
|
|||
// bytesToCopy = select(isOutsideData, 0, bytesToCopy0)
|
|||
|
|||
auto isOutsideData = m_builder.CreateICmpUGE(_srcIdx, _srcSize); |
|||
auto idx64 = m_builder.CreateTrunc(_srcIdx, Type::lowPrecision); |
|||
auto size64 = m_builder.CreateTrunc(_srcSize, Type::lowPrecision); |
|||
auto dataLeftSize = m_builder.CreateNUWSub(size64, idx64); |
|||
auto reqBytes64 = m_builder.CreateTrunc(_reqBytes, Type::lowPrecision); |
|||
auto outOfBound = m_builder.CreateICmpUGT(reqBytes64, dataLeftSize); |
|||
auto bytesToCopyInner = m_builder.CreateSelect(outOfBound, dataLeftSize, reqBytes64); |
|||
auto zero64 = llvm::ConstantInt::get(Type::lowPrecision, 0); // TODO: Cache common constants
|
|||
auto bytesToCopy = m_builder.CreateSelect(isOutsideData, zero64, bytesToCopyInner); |
|||
|
|||
auto src = m_builder.CreateGEP(_srcPtr, idx64, "src"); |
|||
auto dstIdx = m_builder.CreateTrunc(_destMemIdx, Type::Size, "dstIdx"); // Never allow memory index be a type bigger than i64
|
|||
auto dst = m_builder.CreateGEP(getData(), dstIdx, "dst"); |
|||
m_builder.CreateMemCpy(dst, src, bytesToCopy, 0); |
|||
} |
|||
|
|||
} |
|||
} |
|||
} |
|||
|
|||
|
|||
extern "C" |
|||
{ |
|||
using namespace dev::eth::jit; |
|||
|
|||
EXPORT byte* mem_resize(Runtime* _rt, i256* _size) // TODO: Use uint64 as size OR use realloc in LLVM IR
|
|||
{ |
|||
auto size = _size->a; // Trunc to 64-bit
|
|||
auto& memory = _rt->getMemory(); |
|||
memory.resize(size); |
|||
return memory.data(); |
|||
} |
|||
} |
|||
#include "Memory.h" |
|||
|
|||
#include "preprocessor/llvm_includes_start.h" |
|||
#include <llvm/IR/IntrinsicInst.h> |
|||
#include "preprocessor/llvm_includes_end.h" |
|||
|
|||
#include "Type.h" |
|||
#include "Runtime.h" |
|||
#include "GasMeter.h" |
|||
#include "Endianness.h" |
|||
#include "RuntimeManager.h" |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
namespace jit |
|||
{ |
|||
|
|||
Memory::Memory(RuntimeManager& _runtimeManager, GasMeter& _gasMeter): |
|||
RuntimeHelper(_runtimeManager), // TODO: RuntimeHelper not needed
|
|||
m_gasMeter(_gasMeter) |
|||
{} |
|||
|
|||
llvm::Function* Memory::getRequireFunc() |
|||
{ |
|||
auto& func = m_require; |
|||
if (!func) |
|||
{ |
|||
llvm::Type* argTypes[] = {Type::RuntimePtr, Type::Word, Type::Word}; |
|||
func = llvm::Function::Create(llvm::FunctionType::get(Type::Void, argTypes, false), llvm::Function::PrivateLinkage, "mem.require", getModule()); |
|||
auto rt = func->arg_begin(); |
|||
rt->setName("rt"); |
|||
auto offset = rt->getNextNode(); |
|||
offset->setName("offset"); |
|||
auto size = offset->getNextNode(); |
|||
size->setName("size"); |
|||
|
|||
llvm::Type* resizeArgs[] = {Type::RuntimePtr, Type::WordPtr}; |
|||
auto resize = llvm::Function::Create(llvm::FunctionType::get(Type::BytePtr, resizeArgs, false), llvm::Function::ExternalLinkage, "mem_resize", getModule()); |
|||
llvm::AttrBuilder attrBuilder; |
|||
attrBuilder.addAttribute(llvm::Attribute::NoAlias).addAttribute(llvm::Attribute::NoCapture).addAttribute(llvm::Attribute::NonNull).addAttribute(llvm::Attribute::ReadOnly); |
|||
resize->setAttributes(llvm::AttributeSet::get(resize->getContext(), 1, attrBuilder)); |
|||
|
|||
auto preBB = llvm::BasicBlock::Create(func->getContext(), "Pre", func); |
|||
auto checkBB = llvm::BasicBlock::Create(func->getContext(), "Check", func); |
|||
auto resizeBB = llvm::BasicBlock::Create(func->getContext(), "Resize", func); |
|||
auto returnBB = llvm::BasicBlock::Create(func->getContext(), "Return", func); |
|||
|
|||
InsertPointGuard guard(m_builder); // Restores insert point at function exit
|
|||
|
|||
// BB "Pre": Ignore checks with size 0
|
|||
m_builder.SetInsertPoint(preBB); |
|||
auto sizeIsZero = m_builder.CreateICmpEQ(size, Constant::get(0)); |
|||
m_builder.CreateCondBr(sizeIsZero, returnBB, checkBB); |
|||
|
|||
// BB "Check"
|
|||
m_builder.SetInsertPoint(checkBB); |
|||
auto uaddWO = llvm::Intrinsic::getDeclaration(getModule(), llvm::Intrinsic::uadd_with_overflow, Type::Word); |
|||
auto uaddRes = m_builder.CreateCall2(uaddWO, offset, size, "res"); |
|||
auto sizeRequired = m_builder.CreateExtractValue(uaddRes, 0, "sizeReq"); |
|||
auto overflow1 = m_builder.CreateExtractValue(uaddRes, 1, "overflow1"); |
|||
auto rtPtr = getRuntimeManager().getRuntimePtr(); |
|||
auto sizePtr = m_builder.CreateStructGEP(rtPtr, 4); |
|||
auto currSize = m_builder.CreateLoad(sizePtr, "currSize"); |
|||
auto tooSmall = m_builder.CreateICmpULE(currSize, sizeRequired, "tooSmall"); |
|||
auto resizeNeeded = m_builder.CreateOr(tooSmall, overflow1, "resizeNeeded"); |
|||
m_builder.CreateCondBr(resizeNeeded, resizeBB, returnBB); // OPT branch weights?
|
|||
|
|||
// BB "Resize"
|
|||
m_builder.SetInsertPoint(resizeBB); |
|||
// Check gas first
|
|||
uaddRes = m_builder.CreateCall2(uaddWO, sizeRequired, Constant::get(31), "res"); |
|||
auto wordsRequired = m_builder.CreateExtractValue(uaddRes, 0); |
|||
auto overflow2 = m_builder.CreateExtractValue(uaddRes, 1, "overflow2"); |
|||
auto overflow = m_builder.CreateOr(overflow1, overflow2, "overflow"); |
|||
wordsRequired = m_builder.CreateSelect(overflow, Constant::get(-1), wordsRequired); |
|||
wordsRequired = m_builder.CreateUDiv(wordsRequired, Constant::get(32), "wordsReq"); |
|||
sizeRequired = m_builder.CreateMul(wordsRequired, Constant::get(32), "roundedSizeReq"); |
|||
auto words = m_builder.CreateUDiv(currSize, Constant::get(32), "words"); // size is always 32*k
|
|||
auto newWords = m_builder.CreateSub(wordsRequired, words, "addtionalWords"); |
|||
m_gasMeter.countMemory(newWords); |
|||
// Resize
|
|||
m_builder.CreateStore(sizeRequired, sizePtr); |
|||
auto newData = m_builder.CreateCall2(resize, rt, sizePtr, "newData"); |
|||
auto dataPtr = m_builder.CreateStructGEP(rtPtr, 3); |
|||
m_builder.CreateStore(newData, dataPtr); |
|||
m_builder.CreateBr(returnBB); |
|||
|
|||
// BB "Return"
|
|||
m_builder.SetInsertPoint(returnBB); |
|||
m_builder.CreateRetVoid(); |
|||
} |
|||
return func; |
|||
} |
|||
|
|||
llvm::Function* Memory::createFunc(bool _isStore, llvm::Type* _valueType, GasMeter&) |
|||
{ |
|||
auto isWord = _valueType == Type::Word; |
|||
|
|||
llvm::Type* storeArgs[] = {Type::RuntimePtr, Type::Word, _valueType}; |
|||
llvm::Type* loadArgs[] = {Type::RuntimePtr, Type::Word}; |
|||
auto name = _isStore ? isWord ? "mstore" : "mstore8" : "mload"; |
|||
auto funcType = _isStore ? llvm::FunctionType::get(Type::Void, storeArgs, false) : llvm::FunctionType::get(Type::Word, loadArgs, false); |
|||
auto func = llvm::Function::Create(funcType, llvm::Function::PrivateLinkage, name, getModule()); |
|||
|
|||
InsertPointGuard guard(m_builder); // Restores insert point at function exit
|
|||
|
|||
m_builder.SetInsertPoint(llvm::BasicBlock::Create(func->getContext(), {}, func)); |
|||
auto rt = func->arg_begin(); |
|||
rt->setName("rt"); |
|||
auto index = rt->getNextNode(); |
|||
index->setName("index"); |
|||
|
|||
auto valueSize = _valueType->getPrimitiveSizeInBits() / 8; |
|||
this->require(index, Constant::get(valueSize)); |
|||
auto ptr = getBytePtr(index); |
|||
if (isWord) |
|||
ptr = m_builder.CreateBitCast(ptr, Type::WordPtr, "wordPtr"); |
|||
if (_isStore) |
|||
{ |
|||
llvm::Value* value = index->getNextNode(); |
|||
value->setName("value"); |
|||
if (isWord) |
|||
value = Endianness::toBE(m_builder, value); |
|||
m_builder.CreateStore(value, ptr); |
|||
m_builder.CreateRetVoid(); |
|||
} |
|||
else |
|||
{ |
|||
llvm::Value* ret = m_builder.CreateLoad(ptr); |
|||
ret = Endianness::toNative(m_builder, ret); |
|||
m_builder.CreateRet(ret); |
|||
} |
|||
|
|||
return func; |
|||
} |
|||
|
|||
llvm::Function* Memory::getLoadWordFunc() |
|||
{ |
|||
auto& func = m_loadWord; |
|||
if (!func) |
|||
func = createFunc(false, Type::Word, m_gasMeter); |
|||
return func; |
|||
} |
|||
|
|||
llvm::Function* Memory::getStoreWordFunc() |
|||
{ |
|||
auto& func = m_storeWord; |
|||
if (!func) |
|||
func = createFunc(true, Type::Word, m_gasMeter); |
|||
return func; |
|||
} |
|||
|
|||
llvm::Function* Memory::getStoreByteFunc() |
|||
{ |
|||
auto& func = m_storeByte; |
|||
if (!func) |
|||
func = createFunc(true, Type::Byte, m_gasMeter); |
|||
return func; |
|||
} |
|||
|
|||
|
|||
llvm::Value* Memory::loadWord(llvm::Value* _addr) |
|||
{ |
|||
return createCall(getLoadWordFunc(), {getRuntimeManager().getRuntimePtr(), _addr}); |
|||
} |
|||
|
|||
void Memory::storeWord(llvm::Value* _addr, llvm::Value* _word) |
|||
{ |
|||
createCall(getStoreWordFunc(), {getRuntimeManager().getRuntimePtr(), _addr, _word}); |
|||
} |
|||
|
|||
void Memory::storeByte(llvm::Value* _addr, llvm::Value* _word) |
|||
{ |
|||
auto byte = m_builder.CreateTrunc(_word, Type::Byte, "byte"); |
|||
createCall(getStoreByteFunc(), {getRuntimeManager().getRuntimePtr(), _addr, byte}); |
|||
} |
|||
|
|||
llvm::Value* Memory::getData() |
|||
{ |
|||
auto rtPtr = getRuntimeManager().getRuntimePtr(); |
|||
auto dataPtr = m_builder.CreateStructGEP(rtPtr, 3); |
|||
return m_builder.CreateLoad(dataPtr, "data"); |
|||
} |
|||
|
|||
llvm::Value* Memory::getSize() |
|||
{ |
|||
auto rtPtr = getRuntimeManager().getRuntimePtr(); |
|||
auto sizePtr = m_builder.CreateStructGEP(rtPtr, 4); |
|||
return m_builder.CreateLoad(sizePtr, "size"); |
|||
} |
|||
|
|||
llvm::Value* Memory::getBytePtr(llvm::Value* _index) |
|||
{ |
|||
auto idx = m_builder.CreateTrunc(_index, Type::Size, "idx"); // Never allow memory index be a type bigger than i64
|
|||
return m_builder.CreateGEP(getData(), idx, "ptr"); |
|||
} |
|||
|
|||
void Memory::require(llvm::Value* _offset, llvm::Value* _size) |
|||
{ |
|||
if (auto constant = llvm::dyn_cast<llvm::ConstantInt>(_size)) |
|||
{ |
|||
if (!constant->getValue()) |
|||
return; |
|||
} |
|||
createCall(getRequireFunc(), {getRuntimeManager().getRuntimePtr(), _offset, _size}); |
|||
} |
|||
|
|||
void Memory::copyBytes(llvm::Value* _srcPtr, llvm::Value* _srcSize, llvm::Value* _srcIdx, |
|||
llvm::Value* _destMemIdx, llvm::Value* _reqBytes) |
|||
{ |
|||
require(_destMemIdx, _reqBytes); |
|||
|
|||
// Additional copy cost
|
|||
// TODO: This round ups to 32 happens in many places
|
|||
auto reqBytes = m_builder.CreateTrunc(_reqBytes, Type::Gas); |
|||
auto copyWords = m_builder.CreateUDiv(m_builder.CreateNUWAdd(reqBytes, m_builder.getInt64(31)), m_builder.getInt64(32)); |
|||
m_gasMeter.countCopy(copyWords); |
|||
|
|||
// Algorithm:
|
|||
// isOutsideData = idx256 >= size256
|
|||
// idx64 = trunc idx256
|
|||
// size64 = trunc size256
|
|||
// dataLeftSize = size64 - idx64 // safe if not isOutsideData
|
|||
// reqBytes64 = trunc _reqBytes // require() handles large values
|
|||
// bytesToCopy0 = select(reqBytes64 > dataLeftSize, dataSizeLeft, reqBytes64) // min
|
|||
// bytesToCopy = select(isOutsideData, 0, bytesToCopy0)
|
|||
|
|||
auto isOutsideData = m_builder.CreateICmpUGE(_srcIdx, _srcSize); |
|||
auto idx64 = m_builder.CreateTrunc(_srcIdx, Type::Size); |
|||
auto size64 = m_builder.CreateTrunc(_srcSize, Type::Size); |
|||
auto dataLeftSize = m_builder.CreateNUWSub(size64, idx64); |
|||
auto outOfBound = m_builder.CreateICmpUGT(reqBytes, dataLeftSize); |
|||
auto bytesToCopyInner = m_builder.CreateSelect(outOfBound, dataLeftSize, reqBytes); |
|||
auto bytesToCopy = m_builder.CreateSelect(isOutsideData, m_builder.getInt64(0), bytesToCopyInner); |
|||
|
|||
auto src = m_builder.CreateGEP(_srcPtr, idx64, "src"); |
|||
auto dstIdx = m_builder.CreateTrunc(_destMemIdx, Type::Size, "dstIdx"); // Never allow memory index be a type bigger than i64
|
|||
auto dst = m_builder.CreateGEP(getData(), dstIdx, "dst"); |
|||
m_builder.CreateMemCpy(dst, src, bytesToCopy, 0); |
|||
} |
|||
|
|||
} |
|||
} |
|||
} |
|||
|
|||
|
|||
extern "C" |
|||
{ |
|||
using namespace dev::eth::jit; |
|||
|
|||
EXPORT byte* mem_resize(Runtime* _rt, i256* _size) // TODO: Use uint64 as size OR use realloc in LLVM IR
|
|||
{ |
|||
auto size = _size->a; // Trunc to 64-bit
|
|||
auto& memory = _rt->getMemory(); |
|||
memory.resize(size); |
|||
return memory.data(); |
|||
} |
|||
} |
|||
|
|||
@ -1,46 +1,40 @@ |
|||
|
|||
#pragma once |
|||
|
|||
#include <csetjmp> |
|||
#include "RuntimeData.h" |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
namespace jit |
|||
{ |
|||
|
|||
using StackImpl = std::vector<i256>; |
|||
using MemoryImpl = bytes; |
|||
using jmp_buf_ref = decltype(&std::jmp_buf{}[0]); |
|||
|
|||
class Runtime |
|||
{ |
|||
public: |
|||
Runtime(RuntimeData* _data, Env* _env); |
|||
|
|||
Runtime(const Runtime&) = delete; |
|||
Runtime& operator=(const Runtime&) = delete; |
|||
|
|||
StackImpl& getStack() { return m_stack; } |
|||
MemoryImpl& getMemory() { return m_memory; } |
|||
Env* getEnvPtr() { return &m_env; } |
|||
|
|||
bytes_ref getReturnData() const; |
|||
jmp_buf_ref getJmpBuf() { return m_jmpBuf; } |
|||
|
|||
private: |
|||
RuntimeData& m_data; ///< Pointer to data. Expected by compiled contract.
|
|||
Env& m_env; ///< Pointer to environment proxy. Expected by compiled contract.
|
|||
jmp_buf_ref m_currJmpBuf; ///< Pointer to jump buffer. Expected by compiled contract.
|
|||
byte* m_memoryData = nullptr; |
|||
i256 m_memorySize; |
|||
std::jmp_buf m_jmpBuf; |
|||
StackImpl m_stack; |
|||
MemoryImpl m_memory; |
|||
}; |
|||
|
|||
} |
|||
} |
|||
} |
|||
#pragma once |
|||
|
|||
#include "RuntimeData.h" |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
namespace jit |
|||
{ |
|||
|
|||
using StackImpl = std::vector<i256>; |
|||
using MemoryImpl = bytes; |
|||
|
|||
class Runtime |
|||
{ |
|||
public: |
|||
Runtime(RuntimeData* _data, Env* _env); |
|||
|
|||
Runtime(const Runtime&) = delete; |
|||
Runtime& operator=(const Runtime&) = delete; |
|||
|
|||
StackImpl& getStack() { return m_stack; } |
|||
MemoryImpl& getMemory() { return m_memory; } |
|||
|
|||
bytes_ref getReturnData() const; |
|||
|
|||
private: |
|||
RuntimeData& m_data; ///< Pointer to data. Expected by compiled contract.
|
|||
Env& m_env; ///< Pointer to environment proxy. Expected by compiled contract.
|
|||
void* m_currJmpBuf = nullptr; ///< Pointer to jump buffer. Expected by compiled contract.
|
|||
byte* m_memoryData = nullptr; |
|||
i256 m_memorySize; |
|||
StackImpl m_stack; |
|||
MemoryImpl m_memory; |
|||
}; |
|||
|
|||
} |
|||
} |
|||
} |
|||
|
|||
@ -0,0 +1,5 @@ |
|||
#if defined(_MSC_VER) |
|||
#pragma warning(pop) |
|||
#else |
|||
#pragma GCC diagnostic pop |
|||
#endif |
|||
@ -0,0 +1,8 @@ |
|||
#if defined(_MSC_VER) |
|||
#pragma warning(push) |
|||
#pragma warning(disable: 4267 4244 4800) |
|||
#else |
|||
#pragma GCC diagnostic push |
|||
#pragma GCC diagnostic ignored "-Wunused-parameter" |
|||
#pragma GCC diagnostic ignored "-Wconversion" |
|||
#endif |
|||
@ -0,0 +1,108 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum is free software: you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation, either version 3 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
cpp-ethereum is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU General Public License |
|||
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file AccountHolder.cpp
|
|||
* @authors: |
|||
* Christian R <c@ethdev.com> |
|||
* Lefteris Karapetsas <lefteris@ethdev.com> |
|||
* @date 2015 |
|||
*/ |
|||
|
|||
#include "AccountHolder.h" |
|||
#include <random> |
|||
#include <ctime> |
|||
#include <libdevcore/Guards.h> |
|||
#include <libethereum/Client.h> |
|||
|
|||
using namespace std; |
|||
using namespace dev; |
|||
using namespace dev::eth; |
|||
|
|||
vector<TransactionSkeleton> g_emptyQueue; |
|||
static std::mt19937 g_randomNumberGenerator(time(0)); |
|||
static Mutex x_rngMutex; |
|||
|
|||
void AccountHolder::setAccounts(vector<KeyPair> const& _accounts) |
|||
{ |
|||
m_accounts.clear(); |
|||
for (auto const& keyPair: _accounts) |
|||
{ |
|||
m_accounts.push_back(keyPair.address()); |
|||
m_keyPairs[keyPair.address()] = keyPair; |
|||
} |
|||
} |
|||
|
|||
vector<Address> AccountHolder::getAllAccounts() const |
|||
{ |
|||
vector<Address> accounts = m_accounts; |
|||
for (auto const& pair: m_proxyAccounts) |
|||
if (!isRealAccount(pair.first)) |
|||
accounts.push_back(pair.first); |
|||
return accounts; |
|||
} |
|||
|
|||
Address const& AccountHolder::getDefaultTransactAccount() const |
|||
{ |
|||
if (m_accounts.empty()) |
|||
return ZeroAddress; |
|||
Address const* bestMatch = &m_accounts.front(); |
|||
for (auto const& account: m_accounts) |
|||
if (m_client()->balanceAt(account) > m_client()->balanceAt(*bestMatch)) |
|||
bestMatch = &account; |
|||
return *bestMatch; |
|||
} |
|||
|
|||
int AccountHolder::addProxyAccount(const Address& _account) |
|||
{ |
|||
Guard g(x_rngMutex); |
|||
int id = std::uniform_int_distribution<int>(1)(g_randomNumberGenerator); |
|||
id = int(u256(FixedHash<32>(sha3(bytesConstRef((byte*)(&id), sizeof(int) / sizeof(byte)))))); |
|||
if (isProxyAccount(_account) || id == 0 || m_transactionQueues.count(id)) |
|||
return 0; |
|||
m_proxyAccounts.insert(make_pair(_account, id)); |
|||
m_transactionQueues[id].first = _account; |
|||
return id; |
|||
} |
|||
|
|||
bool AccountHolder::removeProxyAccount(unsigned _id) |
|||
{ |
|||
if (!m_transactionQueues.count(_id)) |
|||
return false; |
|||
m_proxyAccounts.erase(m_transactionQueues[_id].first); |
|||
m_transactionQueues.erase(_id); |
|||
return true; |
|||
} |
|||
|
|||
void AccountHolder::queueTransaction(TransactionSkeleton const& _transaction) |
|||
{ |
|||
if (!m_proxyAccounts.count(_transaction.from)) |
|||
return; |
|||
int id = m_proxyAccounts[_transaction.from]; |
|||
m_transactionQueues[id].second.push_back(_transaction); |
|||
} |
|||
|
|||
vector<TransactionSkeleton> const& AccountHolder::getQueuedTransactions(int _id) const |
|||
{ |
|||
if (!m_transactionQueues.count(_id)) |
|||
return g_emptyQueue; |
|||
return m_transactionQueues.at(_id).second; |
|||
} |
|||
|
|||
void AccountHolder::clearQueue(int _id) |
|||
{ |
|||
if (m_transactionQueues.count(_id)) |
|||
m_transactionQueues.at(_id).second.clear(); |
|||
} |
|||
@ -0,0 +1,74 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum is free software: you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation, either version 3 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
cpp-ethereum is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU General Public License |
|||
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/** @file AccountHolder.h
|
|||
* @authors: |
|||
* Christian R <c@ethdev.com> |
|||
* Lefteris Karapetsas <lefteris@ethdev.com> |
|||
* @date 2015 |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <functional> |
|||
#include <vector> |
|||
#include <map> |
|||
#include <libdevcrypto/Common.h> |
|||
#include <libethcore/CommonJS.h> |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
class Interface; |
|||
} |
|||
|
|||
/**
|
|||
* Manages real accounts (where we know the secret key) and proxy accounts (where transactions |
|||
* to be sent from these accounts are forwarded to a proxy on the other side). |
|||
*/ |
|||
class AccountHolder |
|||
{ |
|||
public: |
|||
explicit AccountHolder(std::function<eth::Interface*()> const& _client): m_client(_client) {} |
|||
|
|||
/// Sets or resets the list of real accounts.
|
|||
void setAccounts(std::vector<KeyPair> const& _accounts); |
|||
std::vector<Address> const& getRealAccounts() const { return m_accounts; } |
|||
bool isRealAccount(Address const& _account) const { return m_keyPairs.count(_account) > 0; } |
|||
bool isProxyAccount(Address const& _account) const { return m_proxyAccounts.count(_account) > 0; } |
|||
Secret const& secretKey(Address const& _account) const { return m_keyPairs.at(_account).secret(); } |
|||
std::vector<Address> getAllAccounts() const; |
|||
Address const& getDefaultTransactAccount() const; |
|||
|
|||
int addProxyAccount(Address const& _account); |
|||
bool removeProxyAccount(unsigned _id); |
|||
void queueTransaction(eth::TransactionSkeleton const& _transaction); |
|||
|
|||
std::vector<eth::TransactionSkeleton> const& getQueuedTransactions(int _id) const; |
|||
void clearQueue(int _id); |
|||
|
|||
private: |
|||
using TransactionQueue = std::vector<eth::TransactionSkeleton>; |
|||
|
|||
std::map<Address, KeyPair> m_keyPairs; |
|||
std::vector<Address> m_accounts; |
|||
std::map<Address, int> m_proxyAccounts; |
|||
std::map<int, std::pair<Address, TransactionQueue>> m_transactionQueues; |
|||
std::function<eth::Interface*()> m_client; |
|||
}; |
|||
|
|||
} |
|||
@ -0,0 +1,74 @@ |
|||
/*
|
|||
This file is part of cpp-ethereum. |
|||
|
|||
cpp-ethereum is free software: you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation, either version 3 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
cpp-ethereum is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU General Public License |
|||
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|||
*/ |
|||
/**
|
|||
* @author Christian R <c@ethdev.com> |
|||
* @date 2015 |
|||
* Unit tests for the account holder used by the WebThreeStubServer. |
|||
*/ |
|||
|
|||
#include <boost/test/unit_test.hpp> |
|||
#include <libweb3jsonrpc/AccountHolder.h> |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace test |
|||
{ |
|||
|
|||
BOOST_AUTO_TEST_SUITE(AccountHolderTest) |
|||
|
|||
BOOST_AUTO_TEST_CASE(ProxyAccountUseCase) |
|||
{ |
|||
AccountHolder h = AccountHolder(std::function<eth::Interface*()>()); |
|||
BOOST_CHECK(h.getAllAccounts().empty()); |
|||
BOOST_CHECK(h.getRealAccounts().empty()); |
|||
Address addr("abababababababababababababababababababab"); |
|||
Address addr2("abababababababababababababababababababab"); |
|||
int id = h.addProxyAccount(addr); |
|||
BOOST_CHECK(h.getQueuedTransactions(id).empty()); |
|||
// register it again
|
|||
int secondID = h.addProxyAccount(addr); |
|||
BOOST_CHECK(h.getQueuedTransactions(secondID).empty()); |
|||
|
|||
eth::TransactionSkeleton t1; |
|||
eth::TransactionSkeleton t2; |
|||
t1.from = addr; |
|||
t1.data = fromHex("12345678"); |
|||
t2.from = addr; |
|||
t2.data = fromHex("abcdef"); |
|||
BOOST_CHECK(h.getQueuedTransactions(id).empty()); |
|||
h.queueTransaction(t1); |
|||
BOOST_CHECK_EQUAL(1, h.getQueuedTransactions(id).size()); |
|||
h.queueTransaction(t2); |
|||
BOOST_REQUIRE_EQUAL(2, h.getQueuedTransactions(id).size()); |
|||
|
|||
// second proxy should not see transactions
|
|||
BOOST_CHECK(h.getQueuedTransactions(secondID).empty()); |
|||
|
|||
BOOST_CHECK(h.getQueuedTransactions(id)[0].data == t1.data); |
|||
BOOST_CHECK(h.getQueuedTransactions(id)[1].data == t2.data); |
|||
|
|||
h.clearQueue(id); |
|||
BOOST_CHECK(h.getQueuedTransactions(id).empty()); |
|||
// removing fails because it never existed
|
|||
BOOST_CHECK(!h.removeProxyAccount(secondID)); |
|||
BOOST_CHECK(h.removeProxyAccount(id)); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_SUITE_END() |
|||
|
|||
} |
|||
} |
|||
Loading…
Reference in new issue