Merge pull request #2146 from arkpar/bc

Block queue limiting

libdevcore/Common.h

@@ -181,7 +181,7 @@ private:
 
 /// Scope guard for invariant check in a class derived from HasInvariants.
 #if ETH_DEBUG
-#define DEV_INVARIANT_CHECK ::dev::InvariantChecker __dev_invariantCheck(this)
+#define DEV_INVARIANT_CHECK { ::dev::InvariantChecker __dev_invariantCheck(this); }
 #else
 #define DEV_INVARIANT_CHECK (void)0;
 #endif

libdevcore/Log.cpp

@@ -40,7 +40,7 @@ mutex x_logOverride;
 /// or equal to the currently output verbosity (g_logVerbosity).
 static map<type_info const*, bool> s_logOverride;
 
-bool isChannelVisible(std::type_info const* _ch, bool _default)
+bool dev::isChannelVisible(std::type_info const* _ch, bool _default)
 {
 	Guard l(x_logOverride);
 	if (s_logOverride.count(_ch))

libethereum/BlockQueue.cpp

@@ -37,8 +37,16 @@ const char* BlockQueueChannel::name() { return EthOrange "[]>"; }
 const char* BlockQueueChannel::name() { return EthOrange "▣┅▶"; }
 #endif
 
-
-BlockQueue::BlockQueue()
+size_t const c_maxKnownCount = 100000;
+size_t const c_maxKnownSize = 128 * 1024 * 1024;
+size_t const c_maxUnknownCount = 100000;
+size_t const c_maxUnknownSize = 512 * 1024 * 1024; // Block size can be ~50kb
+
+BlockQueue::BlockQueue():
+	m_unknownSize(0),
+	m_knownSize(0),
+	m_unknownCount(0),
+	m_knownCount(0)
 {
 	// Allow some room for other activity
 	unsigned verifierThreads = std::max(thread::hardware_concurrency(), 3U) - 2U;
@@ -57,11 +65,29 @@ BlockQueue::~BlockQueue()
 		i.join();
 }
 
+void BlockQueue::clear()
+{
+	WriteGuard l(m_lock);
+	DEV_INVARIANT_CHECK;
+	Guard l2(m_verification);
+	m_readySet.clear();
+	m_drainingSet.clear();
+	m_verified.clear();
+	m_unverified.clear();
+	m_unknownSet.clear();
+	m_unknown.clear();
+	m_future.clear();
+	m_unknownSize = 0;
+	m_unknownCount = 0;
+	m_knownSize = 0;
+	m_knownCount = 0;
+}
+
 void BlockQueue::verifierBody()
 {
 	while (!m_deleting)
 	{
-		std::pair<h256, bytes> work;
+		UnverifiedBlock work;
 
 		{
 			unique_lock<Mutex> l(m_verification);
@@ -71,12 +97,13 @@ void BlockQueue::verifierBody()
 			swap(work, m_unverified.front());
 			m_unverified.pop_front();
 			BlockInfo bi;
-			bi.mixHash = work.first;
+			bi.mixHash = work.hash;
+			bi.parentHash = work.parentHash;
 			m_verifying.push_back(VerifiedBlock { VerifiedBlockRef { bytesConstRef(), move(bi), Transactions() }, bytes() });
 		}
 
 		VerifiedBlock res;
-		swap(work.second, res.blockData);
+		swap(work.block, res.blockData);
 		try
 		{
 			res.verified = BlockChain::verifyBlock(res.blockData, m_onBad);
@@ -88,13 +115,13 @@ void BlockQueue::verifierBody()
 				// has to be this order as that's how invariants() assumes.
 				WriteGuard l2(m_lock);
 				unique_lock<Mutex> l(m_verification);
-				m_readySet.erase(work.first);
-				m_knownBad.insert(work.first);
+				m_readySet.erase(work.hash);
+				m_knownBad.insert(work.hash);
 			}
 
 			unique_lock<Mutex> l(m_verification);
 			for (auto it = m_verifying.begin(); it != m_verifying.end(); ++it)
-				if (it->verified.info.mixHash == work.first)
+				if (it->verified.info.mixHash == work.hash)
 				{
 					m_verifying.erase(it);
 					goto OK1;
@@ -106,12 +133,13 @@ void BlockQueue::verifierBody()
 
 		bool ready = false;
 		{
+			WriteGuard l2(m_lock);
 			unique_lock<Mutex> l(m_verification);
-			if (!m_verifying.empty() && m_verifying.front().verified.info.mixHash == work.first)
+			if (!m_verifying.empty() && m_verifying.front().verified.info.mixHash == work.hash)
 			{
 				// we're next!
 				m_verifying.pop_front();
-				if (m_knownBad.count(res.verified.info.hash()))
+				if (m_knownBad.count(res.verified.info.parentHash))
 				{
 					m_readySet.erase(res.verified.info.hash());
 					m_knownBad.insert(res.verified.info.hash());
@@ -120,7 +148,7 @@ void BlockQueue::verifierBody()
 					m_verified.push_back(move(res));
 				while (m_verifying.size() && !m_verifying.front().blockData.empty())
 				{
-					if (m_knownBad.count(m_verifying.front().verified.info.hash()))
+					if (m_knownBad.count(m_verifying.front().verified.info.parentHash))
 					{
 						m_readySet.erase(m_verifying.front().verified.info.hash());
 						m_knownBad.insert(res.verified.info.hash());
@@ -134,7 +162,7 @@ void BlockQueue::verifierBody()
 			else
 			{
 				for (auto& i: m_verifying)
-					if (i.verified.info.mixHash == work.first)
+					if (i.verified.info.mixHash == work.hash)
 					{
 						i = move(res);
 						goto OK;
@@ -199,6 +227,8 @@ ImportResult BlockQueue::import(bytesConstRef _block, BlockChain const& _bc, boo
 		if (strftime(buf, 24, "%X", localtime(&bit)) == 0)
 			buf[0] = '\0'; // empty if case strftime fails
 		cblockq << "OK - queued for future [" << bi.timestamp << "vs" << time(0) << "] - will wait until" << buf;
+		m_unknownSize += _block.size();
+		m_unknownCount++;
 		return ImportResult::FutureTime;
 	}
 	else
@@ -207,6 +237,7 @@ ImportResult BlockQueue::import(bytesConstRef _block, BlockChain const& _bc, boo
 		if (m_knownBad.count(bi.parentHash))
 		{
 			m_knownBad.insert(bi.hash());
+			updateBad(bi.hash());
 			// bad parent; this is bad too, note it as such
 			return ImportResult::BadChain;
 		}
@@ -216,6 +247,8 @@ ImportResult BlockQueue::import(bytesConstRef _block, BlockChain const& _bc, boo
 			cblockq << "OK - queued as unknown parent:" << bi.parentHash;
 			m_unknown.insert(make_pair(bi.parentHash, make_pair(h, _block.toBytes())));
 			m_unknownSet.insert(h);
+			m_unknownSize += _block.size();
+			m_unknownCount++;
 
 			return ImportResult::UnknownParent;
 		}
@@ -224,9 +257,11 @@ ImportResult BlockQueue::import(bytesConstRef _block, BlockChain const& _bc, boo
 			// If valid, append to blocks.
 			cblockq << "OK - ready for chain insertion.";
 			DEV_GUARDED(m_verification)
-				m_unverified.push_back(make_pair(h, _block.toBytes()));
+				m_unverified.push_back(UnverifiedBlock { h, bi.parentHash, _block.toBytes() });
 			m_moreToVerify.notify_one();
 			m_readySet.insert(h);
+			m_knownSize += _block.size();
+			m_knownCount++;
 
 			noteReady_WITH_LOCK(h);
 
@@ -235,39 +270,93 @@ ImportResult BlockQueue::import(bytesConstRef _block, BlockChain const& _bc, boo
 	}
 }
 
-bool BlockQueue::doneDrain(h256s const& _bad)
+void BlockQueue::updateBad(h256 const& _bad)
 {
-	WriteGuard l(m_lock);
 	DEV_INVARIANT_CHECK;
-	m_drainingSet.clear();
-	if (_bad.size())
-	{
-		// at least one of them was bad.
-		m_knownBad += _bad;
 	DEV_GUARDED(m_verification)
 	{
+		collectUnknownBad(_bad);
+		bool moreBad = true;
+		while (moreBad)
+		{
+			moreBad = false;
 			std::vector<VerifiedBlock> oldVerified;
 			swap(m_verified, oldVerified);
 			for (auto& b: oldVerified)
-				if (m_knownBad.count(b.verified.info.parentHash))
+				if (m_knownBad.count(b.verified.info.parentHash) || m_knownBad.count(b.verified.info.hash()))
 				{
 					m_knownBad.insert(b.verified.info.hash());
 					m_readySet.erase(b.verified.info.hash());
+					collectUnknownBad(b.verified.info.hash());
+					moreBad = true;
 				}
 				else
 					m_verified.push_back(std::move(b));
+
+			std::deque<UnverifiedBlock> oldUnverified;
+			swap(m_unverified, oldUnverified);
+			for (auto& b: oldUnverified)
+				if (m_knownBad.count(b.parentHash) || m_knownBad.count(b.hash))
+				{
+					m_knownBad.insert(b.hash);
+					m_readySet.erase(b.hash);
+					collectUnknownBad(b.hash);
+					moreBad = true;
+				}
+				else
+					m_unverified.push_back(std::move(b));
+
+			std::deque<VerifiedBlock> oldVerifying;
+			swap(m_verifying, oldVerifying);
+			for (auto& b: oldVerifying)
+				if (m_knownBad.count(b.verified.info.parentHash) || m_knownBad.count(b.verified.info.mixHash))
+				{
+					h256 const& h = b.blockData.size() != 0 ? b.verified.info.hash() : b.verified.info.mixHash;
+					m_knownBad.insert(h);
+					m_readySet.erase(h);
+					collectUnknownBad(h);
+					moreBad = true;
+				}
+				else
+					m_verifying.push_back(std::move(b));
 		}
 	}
-/*		DEV_GUARDED(m_verification)
+	DEV_INVARIANT_CHECK;
+}
+
+void BlockQueue::collectUnknownBad(h256 const& _bad)
+{
+	list<h256> badQueue(1, _bad);
+	while (!badQueue.empty())
+	{
+		auto r = m_unknown.equal_range(badQueue.front());
+		badQueue.pop_front();
+		for (auto it = r.first; it != r.second; ++it)
+		{
+			m_unknownSize -= it->second.second.size();
+			m_unknownCount--;
+			auto newBad = it->second.first;
+			m_unknownSet.erase(newBad);
+			m_knownBad.insert(newBad);
+			badQueue.push_back(newBad);
+		}
+		m_unknown.erase(r.first, r.second);
+	}
+
+}
+
+bool BlockQueue::doneDrain(h256s const& _bad)
+{
+	WriteGuard l(m_lock);
+	DEV_INVARIANT_CHECK;
+	m_drainingSet.clear();
+	if (_bad.size())
 	{
+		// at least one of them was bad.
 		m_knownBad += _bad;
-			m_knownBad += m_readySet;
-			m_readySet.clear();
-			m_verified.clear();
-			m_verifying.clear();
-			m_unverified.clear();
-		}*/
-	return !m_readySet.empty();
+		for (h256 const& b : _bad)
+			updateBad(b);
+	}	return !m_readySet.empty();
 }
 
 void BlockQueue::tick(BlockChain const& _bc)
@@ -291,7 +380,11 @@ void BlockQueue::tick(BlockChain const& _bc)
 			DEV_INVARIANT_CHECK;
 			auto end = m_future.lower_bound(t);
 			for (auto i = m_future.begin(); i != end; ++i)
+			{
+				m_unknownSize -= i->second.second.size();
+				m_unknownCount--;
 				todo.push_back(move(i->second));
+			}
 			m_future.erase(m_future.begin(), end);
 		}
 	}
@@ -322,12 +415,24 @@ QueueStatus BlockQueue::blockStatus(h256 const& _h) const
 			QueueStatus::Unknown;
 }
 
+bool BlockQueue::knownFull() const
+{
+	return m_knownSize > c_maxKnownSize || m_knownCount > c_maxKnownCount;
+}
+
+bool BlockQueue::unknownFull() const
+{
+	return m_unknownSize > c_maxUnknownSize || m_unknownCount > c_maxUnknownCount;
+}
+
 void BlockQueue::drain(VerifiedBlocks& o_out, unsigned _max)
 {
 	WriteGuard l(m_lock);
 	DEV_INVARIANT_CHECK;
+
 	if (m_drainingSet.empty())
 	{
+		bool wasFull = knownFull();
 		DEV_GUARDED(m_verification)
 		{
 			o_out.resize(min<unsigned>(_max, m_verified.size()));
@@ -341,8 +446,13 @@ void BlockQueue::drain(VerifiedBlocks& o_out, unsigned _max)
 			auto h = bs.verified.info.hash();
 			m_drainingSet.insert(h);
 			m_readySet.erase(h);
+			m_knownSize -= bs.verified.block.size();
+			m_knownCount--;
 		}
+		if (wasFull && !knownFull())
+			m_onRoomAvailable();
 	}
+
 }
 
 bool BlockQueue::invariants() const
@@ -363,7 +473,11 @@ void BlockQueue::noteReady_WITH_LOCK(h256 const& _good)
 		for (auto it = r.first; it != r.second; ++it)
 		{
 			DEV_GUARDED(m_verification)
-				m_unverified.push_back(it->second);
+				m_unverified.push_back(UnverifiedBlock { it->second.first, it->first, it->second.second });
+			m_knownSize += it->second.second.size();
+			m_knownCount++;
+			m_unknownSize -= it->second.second.size();
+			m_unknownCount--;
 			auto newReady = it->second.first;
 			m_unknownSet.erase(newReady);
 			m_readySet.insert(newReady);
@@ -374,6 +488,7 @@ void BlockQueue::noteReady_WITH_LOCK(h256 const& _good)
 	}
 	if (notify)
 		m_moreToVerify.notify_all();
+	DEV_INVARIANT_CHECK;
 }
 
 void BlockQueue::retryAllUnknown()
@@ -383,13 +498,17 @@ void BlockQueue::retryAllUnknown()
 	for (auto it = m_unknown.begin(); it != m_unknown.end(); ++it)
 	{
 		DEV_GUARDED(m_verification)
-			m_unverified.push_back(it->second);
+			m_unverified.push_back(UnverifiedBlock { it->second.first, it->first, it->second.second });
 		auto newReady = it->second.first;
 		m_unknownSet.erase(newReady);
 		m_readySet.insert(newReady);
+		m_knownCount++;
 		m_moreToVerify.notify_one();
 	}
 	m_unknown.clear();
+	m_knownSize += m_unknownSize;
+	m_unknownSize = 0;
+	m_unknownCount = 0;
 	m_moreToVerify.notify_all();
 }
 

libethereum/BlockQueue.h

@@ -76,7 +76,7 @@ public:
 	~BlockQueue();
 
 	/// Import a block into the queue.
-	ImportResult import(bytesConstRef _tx, BlockChain const& _bc, bool _isOurs = false);
+	ImportResult import(bytesConstRef _block, BlockChain const& _bc, bool _isOurs = false);
 
 	/// Notes that time has moved on and some blocks that used to be "in the future" may no be valid.
 	void tick(BlockChain const& _bc);
@@ -99,7 +99,7 @@ public:
 	std::pair<unsigned, unsigned> items() const { ReadGuard l(m_lock); return std::make_pair(m_readySet.size(), m_unknownSet.size()); }
 
 	/// Clear everything.
-	void clear() { WriteGuard l(m_lock); DEV_INVARIANT_CHECK; Guard l2(m_verification); m_readySet.clear(); m_drainingSet.clear(); m_verified.clear(); m_unverified.clear(); m_unknownSet.clear(); m_unknown.clear(); m_future.clear(); }
+	void clear();
 
 	/// Return first block with an unknown parent.
 	h256 firstUnknown() const { ReadGuard l(m_lock); return m_unknownSet.size() ? *m_unknownSet.begin() : h256(); }
@@ -111,15 +111,28 @@ public:
 	QueueStatus blockStatus(h256 const& _h) const;
 
 	template <class T> Handler onReady(T const& _t) { return m_onReady.add(_t); }
+	template <class T> Handler onRoomAvailable(T const& _t) { return m_onRoomAvailable.add(_t); }
 
 	template <class T> void setOnBad(T const& _t) { m_onBad = _t; }
 
+	bool knownFull() const;
+	bool unknownFull() const;
+
 private:
+	struct UnverifiedBlock
+	{
+		h256 hash;
+		h256 parentHash;
+		bytes block;
+	};
+
 	void noteReady_WITH_LOCK(h256 const& _b);
 
 	bool invariants() const override;
 
 	void verifierBody();
+	void collectUnknownBad(h256 const& _bad);
+	void updateBad(h256 const& _bad);
 
 	mutable boost::shared_mutex m_lock;									///< General lock for the sets, m_future and m_unknown.
 	h256Hash m_drainingSet;												///< All blocks being imported.
@@ -129,17 +142,22 @@ private:
 	h256Hash m_knownBad;												///< Set of blocks that we know will never be valid.
 	std::multimap<unsigned, std::pair<h256, bytes>> m_future;			///< Set of blocks that are not yet valid. Ordered by timestamp
 	Signal m_onReady;													///< Called when a subsequent call to import blocks will return a non-empty container. Be nice and exit fast.
+	Signal m_onRoomAvailable;											///< Called when space for new blocks becomes availabe after a drain. Be nice and exit fast.
 
 	mutable Mutex m_verification;										///< Mutex that allows writing to m_verified, m_verifying and m_unverified.
 	std::condition_variable m_moreToVerify;								///< Signaled when m_unverified has a new entry.
 	std::vector<VerifiedBlock> m_verified;								///< List of blocks, in correct order, verified and ready for chain-import.
-	std::deque<VerifiedBlock> m_verifying;								///< List of blocks being verified; as long as the second component (bytes) is empty, it's not finished.
-	std::deque<std::pair<h256, bytes>> m_unverified;					///< List of blocks, in correct order, ready for verification.
+	std::deque<VerifiedBlock> m_verifying;								///< List of blocks being verified; as long as the block component (bytes) is empty, it's not finished.
+	std::deque<UnverifiedBlock> m_unverified;							///< List of <block hash, parent hash, block data> in correct order, ready for verification.
 
 	std::vector<std::thread> m_verifiers;								///< Threads who only verify.
 	bool m_deleting = false;											///< Exit condition for verifiers.
 
 	std::function<void(Exception&)> m_onBad;							///< Called if we have a block that doesn't verify.
+	std::atomic<size_t> m_unknownSize;									///< Tracks total size in bytes of all unknown blocks
+	std::atomic<size_t> m_knownSize;									///< Tracks total size in bytes of all known blocks;
+	std::atomic<size_t> m_unknownCount;									///< Tracks total count of unknown blocks. Used to avoid additional syncing
+	std::atomic<size_t> m_knownCount;									///< Tracks total count of known blocks. Used to avoid additional syncing
 };
 
 std::ostream& operator<<(std::ostream& _out, BlockQueueStatus const& _s);

libethereum/EthereumHost.cpp

@@ -39,6 +39,7 @@ using namespace dev::eth;
 using namespace p2p;
 
 unsigned const EthereumHost::c_oldProtocolVersion = 60; //TODO: remove this once v61+ is common
+unsigned const c_chainReorgSize = 30000;
 
 EthereumHost::EthereumHost(BlockChain const& _ch, TransactionQueue& _tq, BlockQueue& _bq, u256 _networkId):
 	HostCapability<EthereumPeer>(),
@@ -48,9 +49,9 @@ EthereumHost::EthereumHost(BlockChain const& _ch, TransactionQueue& _tq, BlockQu
 	m_bq		(_bq),
 	m_networkId	(_networkId)
 {
-	m_bq.onReady([=](){ if (readyForMore()) m_continueSync = true; });
 	m_latestBlockSent = _ch.currentHash();
 	m_hashMan.reset(m_chain.number() + 1);
+	m_bqRoomAvailable = m_bq.onRoomAvailable([this](){ m_continueSync = true; });
 }
 
 EthereumHost::~EthereumHost()
@@ -257,37 +258,43 @@ void EthereumHost::onPeerStatus(EthereumPeer* _peer)
 		_peer->disable("Peer banned for previous bad behaviour.");
 	else
 	{
-		if (_peer->m_protocolVersion != protocolVersion())
-			estimatePeerHashes(_peer);
-		else
+		unsigned estimatedHashes = estimateHashes();
+		if (_peer->m_protocolVersion == protocolVersion())
 		{
 			if (_peer->m_latestBlockNumber > m_chain.number())
 				_peer->m_expectedHashes = (unsigned)_peer->m_latestBlockNumber - m_chain.number();
-			if (m_hashMan.chainSize() < _peer->m_expectedHashes)
+			if (_peer->m_expectedHashes > estimatedHashes)
+				_peer->disable("Too many hashes");
+			else if (m_needSyncHashes && m_hashMan.chainSize() < _peer->m_expectedHashes)
 				m_hashMan.resetToRange(m_chain.number() + 1, _peer->m_expectedHashes);
 		}
+		else
+			_peer->m_expectedHashes = estimatedHashes;
 		continueSync(_peer);
 	}
 }
 
-void EthereumHost::estimatePeerHashes(EthereumPeer* _peer)
+unsigned EthereumHost::estimateHashes()
 {
 	BlockInfo block = m_chain.info();
 	time_t lastBlockTime = (block.hash() == m_chain.genesisHash()) ? 1428192000 : (time_t)block.timestamp;
 	time_t now = time(0);
-	unsigned blockCount = 30000;
+	unsigned blockCount = c_chainReorgSize;
 	if (lastBlockTime > now)
 		clog(NetWarn) << "Clock skew? Latest block is in the future";
 	else
 		blockCount += (now - lastBlockTime) / (unsigned)c_durationLimit;
 	clog(NetAllDetail) << "Estimated hashes: " << blockCount;
-	_peer->m_expectedHashes = blockCount;
+	return blockCount;
 }
 
 void EthereumHost::onPeerHashes(EthereumPeer* _peer, h256s const& _hashes)
 {
 	RecursiveGuard l(x_sync);
-	assert(_peer->m_asking == Asking::Nothing);
+	if (_peer->m_syncHashNumber > 0)
+		_peer->m_syncHashNumber += _hashes.size();
+
+	_peer->setAsking(Asking::Nothing);
 	onPeerHashes(_peer, _hashes, false);
 }
 
@@ -399,7 +406,7 @@ void EthereumHost::onPeerDoneHashes(EthereumPeer* _peer, bool _localChain)
 void EthereumHost::onPeerBlocks(EthereumPeer* _peer, RLP const& _r)
 {
 	RecursiveGuard l(x_sync);
-	assert(_peer->m_asking == Asking::Nothing);
+	_peer->setAsking(Asking::Nothing);
 	unsigned itemCount = _r.itemCount();
 	clog(NetMessageSummary) << "Blocks (" << dec << itemCount << "entries)" << (itemCount ? "" : ": NoMoreBlocks");
 
@@ -588,7 +595,7 @@ void EthereumHost::onPeerAborting(EthereumPeer* _peer)
 
 void EthereumHost::continueSync()
 {
-	clog(NetAllDetail) << "Getting help with downloading hashes and blocks";
+	clog(NetAllDetail) << "Continuing sync for all peers";
 	foreachPeer([&](EthereumPeer* _p)
 	{
 		if (_p->m_asking == Asking::Nothing)
@@ -596,19 +603,19 @@ void EthereumHost::continueSync()
 	});
 }
 
-bool EthereumHost::readyForMore() const
-{
-	auto s = m_bq.status();
-	return s.verified + s.verifying + s.unverified < 1024 && s.unknown < 1024;
-}
-
 void EthereumHost::continueSync(EthereumPeer* _peer)
 {
 	assert(_peer->m_asking == Asking::Nothing);
 	bool otherPeerV60Sync = false;
 	bool otherPeerV61Sync = false;
-	if (m_needSyncHashes && peerShouldGrabChain(_peer))
+	if (m_needSyncHashes)
 	{
+		if (!peerShouldGrabChain(_peer))
+		{
+			_peer->setIdle();
+			return;
+		}
+
 		foreachPeer([&](EthereumPeer* _p)
 		{
 			if (_p != _peer && _p->m_asking == Asking::Hashes)
@@ -656,7 +663,20 @@ void EthereumHost::continueSync(EthereumPeer* _peer)
 	}
 	else if (m_needSyncBlocks && peerCanHelp(_peer)) // Check if this peer can help with downloading blocks
 	{
-		if (readyForMore())
+		// Check block queue status
+		if (m_bq.unknownFull())
+		{
+			clog(NetWarn) << "Too many unknown blocks, restarting sync";
+			m_bq.clear();
+			reset();
+			continueSync();
+		}
+		else if (m_bq.knownFull())
+		{
+			clog(NetAllDetail) << "Waiting for block queue before downloading blocks";
+			_peer->setIdle();
+		}
+		else
 			_peer->requestBlocks();
 	}
 	else
@@ -709,15 +729,7 @@ bool EthereumHost::peerShouldGrabChain(EthereumPeer* _peer) const
 
 bool EthereumHost::isSyncing_UNSAFE() const
 {
-	/// We need actual peer information here to handle the case when we are the first ever peer on the network to mine.
-	/// I.e. on a new private network the first node mining has noone to sync with and should start block propogation immediately.
-	bool syncing = false;
-	foreachPeer([&](EthereumPeer* _p)
-	{
-		if (_p->m_asking != Asking::Nothing)
-			syncing = true;
-	});
-	return syncing;
+	return m_needSyncBlocks || m_needSyncHashes;
 }
 
 HashChainStatus EthereumHost::status()
@@ -725,6 +737,6 @@ HashChainStatus EthereumHost::status()
 	RecursiveGuard l(x_sync);
 	if (m_syncingV61)
 		return HashChainStatus { static_cast<unsigned>(m_hashMan.chainSize()), static_cast<unsigned>(m_hashMan.gotCount()), false };
-	return HashChainStatus { m_estimatedHashes - 30000, static_cast<unsigned>(m_hashes.size()), true };
+	return HashChainStatus { m_estimatedHashes > 0 ? m_estimatedHashes - c_chainReorgSize : 0, static_cast<unsigned>(m_hashes.size()), m_estimatedHashes > 0 };
 }
 

libethereum/EthereumHost.h

@@ -125,12 +125,13 @@ private:
 	bool peerShouldGrabBlocks(EthereumPeer* _peer) const;
 	bool peerShouldGrabChain(EthereumPeer* _peer) const;
 	bool peerCanHelp(EthereumPeer* _peer) const;
+	unsigned estimateHashes();
 	void estimatePeerHashes(EthereumPeer* _peer);
-	bool readyForMore() const;
 
 	BlockChain const& m_chain;
 	TransactionQueue& m_tq;					///< Maintains a list of incoming transactions not yet in a block on the blockchain.
 	BlockQueue& m_bq;						///< Maintains a list of incoming blocks not yet on the blockchain (to be imported).
+	Handler m_bqRoomAvailable;
 
 	u256 m_networkId;
 

libethereum/EthereumPeer.cpp

@@ -265,13 +265,10 @@ bool EthereumPeer::interpret(unsigned _id, RLP const& _r)
 			clog(NetWarn) << "Peer giving us hashes when we didn't ask for them.";
 			break;
 		}
-		setAsking(Asking::Nothing);
 		h256s hashes(itemCount);
 		for (unsigned i = 0; i < itemCount; ++i)
 			hashes[i] = _r[i].toHash<h256>();
 
-		if (m_syncHashNumber > 0)
-			m_syncHashNumber += itemCount;
 		host()->onPeerHashes(this, hashes);
 		break;
 	}
@@ -314,10 +311,7 @@ bool EthereumPeer::interpret(unsigned _id, RLP const& _r)
 		if (m_asking != Asking::Blocks)
 			clog(NetImpolite) << "Peer giving us blocks when we didn't ask for them.";
 		else
-		{
-			setAsking(Asking::Nothing);
 			host()->onPeerBlocks(this, _r);
-		}
 		break;
 	}
 	case NewBlockPacket:

libethereum/State.cpp

@@ -777,6 +777,7 @@ void State::cleanup(bool _fullCommit)
 		paranoia("immediately before database commit", true);
 
 		// Commit the new trie to disk.
+		if (isChannelVisible<StateTrace>()) // Avoid calling toHex if not needed
 			clog(StateTrace) << "Committing to disk: stateRoot" << m_currentBlock.stateRoot << "=" << rootHash() << "=" << toHex(asBytes(m_db.lookup(rootHash())));
 
 		try {
@@ -790,6 +791,7 @@ void State::cleanup(bool _fullCommit)
 		}
 
 		m_db.commit();
+		if (isChannelVisible<StateTrace>()) // Avoid calling toHex if not needed
 			clog(StateTrace) << "Committed: stateRoot" << m_currentBlock.stateRoot << "=" << rootHash() << "=" << toHex(asBytes(m_db.lookup(rootHash())));
 
 		paranoia("immediately after database commit", true);