Merge pull request #5713 from ethereum/propagate-blocks-pow

Propagate blocks after PoW validation

Author: halfalicious

CHANGELOG.md

@@ -34,6 +34,7 @@
 - Changed: [#5675](https://github.com/ethereum/aleth/pull/5675) Disconnect from peer when syncing is disabled for peer.
 - Changed: [#5676](https://github.com/ethereum/aleth/pull/5676) When receiving large batches of new block hashes, process up to 1024 hashes instead of disabling the peer.
 - Changed: [#5719](https://github.com/ethereum/aleth/pull/5719) Enable support for Visual Studio 2017 on Windows.
+- Changed: [#5713](https://github.com/ethereum/aleth/pull/5713) Propagate new blocks after PoW check rather than after import into the blockchain.
 - Removed: [#5631](https://github.com/ethereum/aleth/pull/5631) Removed PARANOID build option.
 - Fixed: [#5562](https://github.com/ethereum/aleth/pull/5562) Don't send header request messages to peers that haven't sent us Status yet.
 - Fixed: [#5581](https://github.com/ethereum/aleth/pull/5581) Fixed finding neighbour nodes in Discovery.

libethcore/Common.h

@@ -90,7 +90,7 @@ struct ImportRoute
 {
 	h256s deadBlocks;
 	h256s liveBlocks;
-	std::vector<Transaction> goodTranactions;
+	std::vector<Transaction> goodTransactions;
 };
 
 enum class ImportResult

libethereum/BlockChain.cpp

@@ -1,23 +1,6 @@
-/*
-    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 BlockChain.cpp
- * @author Gav Wood <i@gavwood.com>
- * @date 2014
- */
+// Aleth: Ethereum C++ client, tools and libraries.
+// Copyright 2019 Aleth Authors.
+// Licensed under the GNU General Public License, Version 3.
 
 #include "BlockChain.h"
 
@@ -436,19 +419,28 @@ string BlockChain::dumpDatabase() const
     return oss.str();
 }
 
-tuple<ImportRoute, bool, unsigned> BlockChain::sync(BlockQueue& _bq, OverlayDB const& _stateDB, unsigned _max)
+tuple<ImportRoute, bool, unsigned> BlockChain::sync(
+    BlockQueue& _bq, OverlayDB const& _stateDB, unsigned _max)
 {
-//  _bq.tick(*this);
+    //  _bq.tick(*this);
 
     VerifiedBlocks blocks;
     _bq.drain(blocks, _max);
 
+    std::tuple<ImportRoute, h256s, unsigned> const importResult = sync(blocks, _stateDB);
+    bool const moreBlocks = _bq.doneDrain(std::get<1>(importResult));
+    return {std::get<0>(importResult), moreBlocks, std::get<2>(importResult)};
+}
+
+tuple<ImportRoute, h256s, unsigned> BlockChain::sync(
+    VerifiedBlocks const& _blocks, OverlayDB const& _stateDB)
+{
     h256s fresh;
     h256s dead;
-    h256s badBlocks;
     Transactions goodTransactions;
     unsigned count = 0;
-    for (VerifiedBlock const& block: blocks)
+    h256s badBlockHashes;
+    for (VerifiedBlock const& block : _blocks)
     {
         do {
             try
@@ -459,8 +451,8 @@ tuple<ImportRoute, bool, unsigned> BlockChain::sync(BlockQueue& _bq, OverlayDB c
                     r = import(block.verified, _stateDB, (ImportRequirements::Everything & ~ImportRequirements::ValidSeal & ~ImportRequirements::CheckUncles) != 0);
                 fresh += r.liveBlocks;
                 dead += r.deadBlocks;
-                goodTransactions.reserve(goodTransactions.size() + r.goodTranactions.size());
-                std::move(std::begin(r.goodTranactions), std::end(r.goodTranactions), std::back_inserter(goodTransactions));
+                goodTransactions.reserve(goodTransactions.size() + r.goodTransactions.size());
+                std::move(std::begin(r.goodTransactions), std::end(r.goodTransactions), std::back_inserter(goodTransactions));
                 ++count;
             }
             catch (dev::eth::AlreadyHaveBlock const&)
@@ -473,7 +465,7 @@ tuple<ImportRoute, bool, unsigned> BlockChain::sync(BlockQueue& _bq, OverlayDB c
                 cwarn << "ODD: Import queue contains block with unknown parent.";// << LogTag::Error << boost::current_exception_diagnostic_information();
                 // NOTE: don't reimport since the queue should guarantee everything in the right order.
                 // Can't continue - chain bad.
-                badBlocks.push_back(block.verified.info.hash());
+                badBlockHashes.push_back(block.verified.info.hash());
             }
             catch (dev::eth::FutureTime const&)
             {
@@ -488,16 +480,16 @@ tuple<ImportRoute, bool, unsigned> BlockChain::sync(BlockQueue& _bq, OverlayDB c
             }
             catch (Exception& ex)
             {
-//              cnote << "Exception while importing block. Someone (Jeff? That you?) seems to be giving us dodgy blocks!";// << LogTag::Error << diagnostic_information(ex);
+                // cnote << "Exception while importing block. Someone (Jeff? That you?) seems to be giving us dodgy blocks!";// << LogTag::Error << diagnostic_information(ex);
                 if (m_onBad)
                     m_onBad(ex);
                 // NOTE: don't reimport since the queue should guarantee everything in the right order.
                 // Can't continue - chain  bad.
-                badBlocks.push_back(block.verified.info.hash());
+                badBlockHashes.push_back(block.verified.info.hash());
             }
         } while (false);
     }
-    return make_tuple(ImportRoute{dead, fresh, goodTransactions}, _bq.doneDrain(badBlocks), count);
+    return {ImportRoute{dead, fresh, goodTransactions}, badBlockHashes, count};
 }
 
 pair<ImportResult, ImportRoute> BlockChain::attemptImport(bytes const& _block, OverlayDB const& _stateDB, bool _mustBeNew) noexcept

libethereum/BlockChain.h

@@ -1,23 +1,6 @@
-/*
-    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 BlockChain.h
- * @author Gav Wood <i@gavwood.com>
- * @date 2014
- */
+// Aleth: Ethereum C++ client, tools and libraries.
+// Copyright 2019 Aleth Authors.
+// Licensed under the GNU General Public License, Version 3.
 
 #pragma once
 
@@ -118,8 +101,18 @@ class BlockChain
     void process();
 
     /// Sync the chain with any incoming blocks. All blocks should, if processed in order.
-    /// @returns fresh blocks, dead blocks and true iff there are additional blocks to be processed waiting.
-    std::tuple<ImportRoute, bool, unsigned> sync(BlockQueue& _bq, OverlayDB const& _stateDB, unsigned _max);
+    /// @returns tuple with three members - the first (ImportRoute) contains hashes of fresh blocks
+    /// and dead blocks as well as a list of imported transactions. The second is a bool which is
+    /// true iff there are additional blocks to be processed. The third is the imported block count.
+    std::tuple<ImportRoute, bool, unsigned> sync(
+        BlockQueue& _bq, OverlayDB const& _stateDB, unsigned _max);
+
+    /// Import the supplied blocks into the chain. Blocks should be processed in order.
+    /// @returns a tuple with three members - the first (ImportRoute) contains fresh blocks, dead
+    /// blocks and imported transactions. The second contains hashes of bad blocks. The third
+    /// contains the imported block count.
+    std::tuple<ImportRoute, h256s, unsigned> sync(
+        VerifiedBlocks const& _blocks, OverlayDB const& _stateDB);
 
     /// Attempt to import the given block directly into the BlockChain and sync with the state DB.
     /// @returns the block hashes of any blocks that came into/went out of the canonical block chain.

libethereum/Client.cpp

@@ -43,6 +43,10 @@ static_assert(BOOST_VERSION >= 106400, "Wrong boost headers version");
 
 namespace
 {
+constexpr unsigned c_syncMinBlockCount = 1;
+constexpr unsigned c_syncMaxBlockCount = 1000;
+constexpr double c_targetDurationS = 1;
+
 std::string filtersToString(h256Hash const& _fs)
 {
     std::stringstream str;
@@ -377,18 +381,29 @@ void Client::appendFromBlock(h256 const& _block, BlockPolarity _polarity, h256Ha
     }
 }
 
-unsigned static const c_syncMin = 1;
-unsigned static const c_syncMax = 1000;
-double static const c_targetDuration = 1;
-
 void Client::syncBlockQueue()
 {
 //  cdebug << "syncBlockQueue()";
 
     ImportRoute ir;
+    h256s badBlockHashes;
     unsigned count;
     Timer t;
-    tie(ir, m_syncBlockQueue, count) = bc().sync(m_bq, m_stateDB, m_syncAmount);
+
+    // The verified blocks list needs to be a shared_ptr since we propagate them on the network
+    // thread and import them into our local chain on the client thread.
+    std::shared_ptr<VerifiedBlocks> verifiedBlocks = std::make_shared<VerifiedBlocks>();
+    m_bq.drain(*verifiedBlocks, m_syncAmount);
+
+    // Propagate new blocks to peers before importing them into the chain.
+    auto h = m_host.lock();
+    assert(h);  // capability is owned by Host and should be available for the duration of the
+                // Client's lifetime
+    h->propagateNewBlocks(verifiedBlocks);
+
+    std::tie(ir, badBlockHashes, count) = bc().sync(*verifiedBlocks, m_stateDB);
+    m_syncBlockQueue = m_bq.doneDrain(badBlockHashes);
+
     double elapsed = t.elapsed();
 
     if (count)
@@ -397,10 +412,10 @@ void Client::syncBlockQueue()
                       << (count / elapsed) << " blocks/s) in #" << bc().number();
     }
 
-    if (elapsed > c_targetDuration * 1.1 && count > c_syncMin)
-        m_syncAmount = max(c_syncMin, count * 9 / 10);
-    else if (count == m_syncAmount && elapsed < c_targetDuration * 0.9 && m_syncAmount < c_syncMax)
-        m_syncAmount = min(c_syncMax, m_syncAmount * 11 / 10 + 1);
+    if (elapsed > c_targetDurationS * 1.1 && count > c_syncMinBlockCount)
+        m_syncAmount = max(c_syncMinBlockCount, count * 9 / 10);
+    else if (count == m_syncAmount && elapsed < c_targetDurationS * 0.9 && m_syncAmount < c_syncMaxBlockCount)
+        m_syncAmount = min(c_syncMaxBlockCount, m_syncAmount * 11 / 10 + 1);
     if (ir.liveBlocks.empty())
         return;
     onChainChanged(ir);
@@ -557,8 +572,8 @@ void Client::onChainChanged(ImportRoute const& _ir)
     h256Hash changeds;
     onDeadBlocks(_ir.deadBlocks, changeds);
     vector<h256> goodTransactions;
-    goodTransactions.reserve(_ir.goodTranactions.size());
-    for (auto const& t: _ir.goodTranactions)
+    goodTransactions.reserve(_ir.goodTransactions.size());
+    for (auto const& t: _ir.goodTransactions)
     {
         LOG(m_loggerDetail) << "Safely dropping transaction " << t.sha3();
         m_tq.dropGood(t);