Gav Wood
10 years ago
22 changed files with 728 additions and 159 deletions
@ -0,0 +1,91 @@ |
|||
/*
|
|||
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 BlockDeduplicator.cpp |
|||
* @author Christian <c@ethdev.com> |
|||
* @date 2015 |
|||
* Unifies basic blocks that share content. |
|||
*/ |
|||
|
|||
#include <libevmasm/BlockDeduplicator.h> |
|||
#include <functional> |
|||
#include <libevmasm/AssemblyItem.h> |
|||
#include <libevmasm/SemanticInformation.h> |
|||
|
|||
using namespace std; |
|||
using namespace dev; |
|||
using namespace dev::eth; |
|||
|
|||
|
|||
bool BlockDeduplicator::deduplicate() |
|||
{ |
|||
// Compares indices based on the suffix that starts there, ignoring tags and stopping at
|
|||
// opcodes that stop the control flow.
|
|||
function<bool(size_t, size_t)> comparator = [&](size_t _i, size_t _j) |
|||
{ |
|||
if (_i == _j) |
|||
return false; |
|||
|
|||
BlockIterator first(m_items.begin() + _i, m_items.end()); |
|||
BlockIterator second(m_items.begin() + _j, m_items.end()); |
|||
BlockIterator end(m_items.end(), m_items.end()); |
|||
|
|||
if (first != end && (*first).type() == Tag) |
|||
++first; |
|||
if (second != end && (*second).type() == Tag) |
|||
++second; |
|||
|
|||
return std::lexicographical_compare(first, end, second, end); |
|||
}; |
|||
|
|||
set<size_t, function<bool(size_t, size_t)>> blocksSeen(comparator); |
|||
map<u256, u256> tagReplacement; |
|||
for (size_t i = 0; i < m_items.size(); ++i) |
|||
{ |
|||
if (m_items.at(i).type() != Tag) |
|||
continue; |
|||
auto it = blocksSeen.find(i); |
|||
if (it == blocksSeen.end()) |
|||
blocksSeen.insert(i); |
|||
else |
|||
tagReplacement[m_items.at(i).data()] = m_items.at(*it).data(); |
|||
} |
|||
|
|||
bool ret = false; |
|||
for (AssemblyItem& item: m_items) |
|||
if (item.type() == PushTag && tagReplacement.count(item.data())) |
|||
{ |
|||
ret = true; |
|||
item.setData(tagReplacement.at(item.data())); |
|||
} |
|||
return ret; |
|||
} |
|||
|
|||
BlockDeduplicator::BlockIterator& BlockDeduplicator::BlockIterator::operator++() |
|||
{ |
|||
if (it == end) |
|||
return *this; |
|||
if (SemanticInformation::altersControlFlow(*it) && *it != AssemblyItem(eth::Instruction::JUMPI)) |
|||
it = end; |
|||
else |
|||
{ |
|||
++it; |
|||
while (it != end && it->type() == Tag) |
|||
++it; |
|||
} |
|||
return *this; |
|||
} |
|||
@ -0,0 +1,69 @@ |
|||
/*
|
|||
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 BlockDeduplicator.h |
|||
* @author Christian <c@ethdev.com> |
|||
* @date 2015 |
|||
* Unifies basic blocks that share content. |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <cstddef> |
|||
#include <vector> |
|||
#include <functional> |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
|
|||
class AssemblyItem; |
|||
using AssemblyItems = std::vector<AssemblyItem>; |
|||
|
|||
/**
|
|||
* Optimizer class to be used to unify blocks that share content. |
|||
* Modifies the passed vector in place. |
|||
*/ |
|||
class BlockDeduplicator |
|||
{ |
|||
public: |
|||
BlockDeduplicator(AssemblyItems& _items): m_items(_items) {} |
|||
/// @returns true if something was changed
|
|||
bool deduplicate(); |
|||
|
|||
private: |
|||
/// Iterator that skips tags skips to the end if (all branches of) the control
|
|||
/// flow does not continue to the next instruction.
|
|||
struct BlockIterator: std::iterator<std::forward_iterator_tag, AssemblyItem const> |
|||
{ |
|||
public: |
|||
BlockIterator(AssemblyItems::const_iterator _it, AssemblyItems::const_iterator _end): |
|||
it(_it), end(_end) { } |
|||
BlockIterator& operator++(); |
|||
bool operator==(BlockIterator const& _other) const { return it == _other.it; } |
|||
bool operator!=(BlockIterator const& _other) const { return it != _other.it; } |
|||
AssemblyItem const& operator*() const { return *it; } |
|||
AssemblyItems::const_iterator it; |
|||
AssemblyItems::const_iterator end; |
|||
}; |
|||
|
|||
AssemblyItems& m_items; |
|||
}; |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,150 @@ |
|||
/*
|
|||
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 capability.cpp
|
|||
* @author Vladislav Gluhovsky <vlad@ethdev.com> |
|||
* @date May 2015 |
|||
*/ |
|||
|
|||
#include <boost/test/unit_test.hpp> |
|||
#include <chrono> |
|||
#include <thread> |
|||
#include <libp2p/Common.h> |
|||
#include <libp2p/Host.h> |
|||
#include <libp2p/Session.h> |
|||
#include <libp2p/Capability.h> |
|||
#include <libp2p/HostCapability.h> |
|||
|
|||
using namespace std; |
|||
using namespace dev; |
|||
using namespace dev::p2p; |
|||
|
|||
struct P2PFixture |
|||
{ |
|||
P2PFixture() { dev::p2p::NodeIPEndpoint::test_allowLocal = true; } |
|||
~P2PFixture() { dev::p2p::NodeIPEndpoint::test_allowLocal = false; } |
|||
}; |
|||
|
|||
struct VerbosityHolder |
|||
{ |
|||
VerbosityHolder(): oldLogVerbosity(g_logVerbosity) { g_logVerbosity = 10; } |
|||
~VerbosityHolder() { g_logVerbosity = oldLogVerbosity; } |
|||
|
|||
int oldLogVerbosity; |
|||
}; |
|||
|
|||
class TestCapability: public Capability |
|||
{ |
|||
public: |
|||
TestCapability(Session* _s, HostCapabilityFace* _h, unsigned _idOffset): Capability(_s, _h, _idOffset), m_cntReceivedMessages(0), m_testSum(0) {} |
|||
virtual ~TestCapability() {} |
|||
int countReceivedMessages() { return m_cntReceivedMessages; } |
|||
int testSum() { return m_testSum; } |
|||
static std::string name() { return "test"; } |
|||
static u256 version() { return 2; } |
|||
static unsigned messageCount() { return UserPacket + 1; } |
|||
void sendTestMessage(int _i) { RLPStream s; sealAndSend(prep(s, UserPacket, 1) << _i); } |
|||
|
|||
protected: |
|||
virtual bool interpret(unsigned _id, RLP const& _r) override; |
|||
|
|||
int m_cntReceivedMessages; |
|||
int m_testSum; |
|||
}; |
|||
|
|||
bool TestCapability::interpret(unsigned _id, RLP const& _r) |
|||
{ |
|||
cnote << "Capability::interpret(): custom message received"; |
|||
++m_cntReceivedMessages; |
|||
m_testSum += _r[0].toInt(); |
|||
BOOST_ASSERT(_id == UserPacket); |
|||
return (_id == UserPacket); |
|||
} |
|||
|
|||
class TestHostCapability: public HostCapability<TestCapability>, public Worker |
|||
{ |
|||
public: |
|||
TestHostCapability(): Worker("test") {} |
|||
virtual ~TestHostCapability() {} |
|||
|
|||
void sendTestMessage(NodeId const& _id, int _x) |
|||
{ |
|||
for (auto i: peerSessions()) |
|||
if (_id == i.second->id) |
|||
i.first->cap<TestCapability>().get()->sendTestMessage(_x); |
|||
} |
|||
|
|||
std::pair<int, int> retrieveTestData(NodeId const& _id) |
|||
{ |
|||
int cnt = 0; |
|||
int checksum = 0; |
|||
for (auto i: peerSessions()) |
|||
if (_id == i.second->id) |
|||
{ |
|||
cnt += i.first->cap<TestCapability>().get()->countReceivedMessages(); |
|||
checksum += i.first->cap<TestCapability>().get()->testSum(); |
|||
} |
|||
|
|||
return std::pair<int, int>(cnt, checksum); |
|||
} |
|||
}; |
|||
|
|||
BOOST_FIXTURE_TEST_SUITE(p2pCapability, P2PFixture) |
|||
|
|||
BOOST_AUTO_TEST_CASE(capability) |
|||
{ |
|||
VerbosityHolder verbosityHolder; |
|||
cnote << "Testing Capability..."; |
|||
|
|||
const char* const localhost = "127.0.0.1"; |
|||
NetworkPreferences prefs1(localhost, 30301, false); |
|||
NetworkPreferences prefs2(localhost, 30302, false); |
|||
|
|||
Host host1("Test", prefs1); |
|||
auto thc1 = host1.registerCapability(new TestHostCapability()); |
|||
host1.start(); |
|||
|
|||
Host host2("Test", prefs2); |
|||
auto thc2 = host2.registerCapability(new TestHostCapability()); |
|||
host2.start(); |
|||
|
|||
int const step = 10; |
|||
|
|||
for (int i = 0; i < 3000 && (!host1.isStarted() || !host2.isStarted()); i += step) |
|||
this_thread::sleep_for(chrono::milliseconds(step)); |
|||
|
|||
BOOST_REQUIRE(host1.isStarted() && host2.isStarted()); |
|||
host1.requirePeer(host2.id(), NodeIPEndpoint(bi::address::from_string(localhost), prefs2.listenPort, prefs2.listenPort)); |
|||
|
|||
for (int i = 0; i < 3000 && (!host1.peerCount() || !host2.peerCount()); i += step) |
|||
this_thread::sleep_for(chrono::milliseconds(step)); |
|||
|
|||
BOOST_REQUIRE(host1.peerCount() > 0 && host2.peerCount() > 0); |
|||
|
|||
int const target = 7; |
|||
int checksum = 0; |
|||
for (int i = 0; i < target; checksum += i++) |
|||
thc2->sendTestMessage(host1.id(), i); |
|||
|
|||
this_thread::sleep_for(chrono::seconds(1)); |
|||
std::pair<int, int> testData = thc1->retrieveTestData(host2.id()); |
|||
BOOST_REQUIRE_EQUAL(target, testData.first); |
|||
BOOST_REQUIRE_EQUAL(checksum, testData.second); |
|||
} |
|||
|
|||
BOOST_AUTO_TEST_SUITE_END() |
|||
|
|||
|
|||
Loading…
Reference in new issue