Thread-safe blockchain.

libethereum/BlockChain.cpp

@@ -40,7 +40,7 @@ namespace eth
 
 std::ostream& operator<<(std::ostream& _out, BlockChain const& _bc)
 {
-	string cmp = toBigEndianString(_bc.m_lastBlockHash);
+	string cmp = toBigEndianString(_bc.currentHash());
 	auto it = _bc.m_extrasDB->NewIterator(_bc.m_readOptions);
 	for (it->SeekToFirst(); it->Valid(); it->Next())
 		if (it->key().ToString() != "best")
@@ -87,6 +87,21 @@ std::map<Address, AddressState> const& eth::genesisState()
 }
 
 BlockInfo* BlockChain::s_genesis = nullptr;
+boost::shared_mutex BlockChain::x_genesis;
+
+ldb::Slice eth::toSlice(h256 _h, unsigned _sub)
+{
+#if ALL_COMPILERS_ARE_CPP11_COMPLIANT
+	static thread_local h256 h = _h ^ h256(u256(_sub));
+	return ldb::Slice((char const*)&h, 32);
+#else
+	static boost::thread_specific_ptr<h256> t_h;
+	if (!t_h.get())
+		t_h.reset(new h256);
+	*t_h = _h ^ h256(u256(_sub));
+	return ldb::Slice((char const*)t_h.get(), 32);
+#endif
+}
 
 bytes BlockChain::createGenesisBlock()
 {
@@ -144,9 +159,10 @@ BlockChain::BlockChain(std::string _path, bool _killExisting)
 	// TODO: Implement ability to rebuild details map from DB.
 	std::string l;
 	m_extrasDB->Get(m_readOptions, ldb::Slice("best"), &l);
+
 	m_lastBlockHash = l.empty() ? m_genesisHash : *(h256*)l.data();
 
-	cnote << "Opened blockchain DB. Latest: " << m_lastBlockHash;
+	cnote << "Opened blockchain DB. Latest: " << currentHash();
 }
 
 BlockChain::~BlockChain()
@@ -181,20 +197,6 @@ h256s BlockChain::attemptImport(bytes const& _block, OverlayDB const& _stateDB)
 #endif
 }
 
-inline ldb::Slice toSlice(h256 _h, unsigned _sub = 0)
-{
-#if ALL_COMPILERS_ARE_CPP11_COMPLIANT
-	static thread_local h256 h = _h ^ h256(u256(_sub));
-	return ldb::Slice((char const*)&h, 32);
-#else
-	static boost::thread_specific_ptr<h256> t_h;
-	if (!t_h.get())
-		t_h.reset(new h256);
-	*t_h = _h ^ h256(u256(_sub));
-	return ldb::Slice((char const*)t_h.get(), 32);
-#endif
-}
-
 h256s BlockChain::import(bytes const& _block, OverlayDB const& _db)
 {
 	// VERIFY: populates from the block and checks the block is internally coherent.
@@ -267,10 +269,16 @@ h256s BlockChain::import(bytes const& _block, OverlayDB const& _db)
 #endif
 		// All ok - insert into DB
 		{
-			lock_guard<recursive_mutex> l(m_lock);
+			WriteGuard l(x_details);
 			m_details[newHash] = BlockDetails((uint)pd.number + 1, td, bi.parentHash, {}, b);
 			m_details[bi.parentHash].children.push_back(newHash);
+		}
+		{
+			WriteGuard l(x_blooms);
 			m_blooms[newHash] = bb;
+		}
+		{
+			WriteGuard l(x_traces);
 			m_traces[newHash] = bt;
 		}
 
@@ -296,10 +304,14 @@ h256s BlockChain::import(bytes const& _block, OverlayDB const& _db)
 
 	h256s ret;
 	// This might be the new best block...
-	if (td > details(m_lastBlockHash).totalDifficulty)
+	h256 last = currentHash();
+	if (td > details(last).totalDifficulty)
 	{
-		ret = treeRoute(m_lastBlockHash, newHash);
-		m_lastBlockHash = newHash;
+		ret = treeRoute(last, newHash);
+		{
+			WriteGuard l(x_lastBlockHash);
+			m_lastBlockHash = newHash;
+		}
 		m_extrasDB->Put(m_writeOptions, ldb::Slice("best"), ldb::Slice((char const*)&newHash, 32));
 		clog(BlockChainNote) << "   Imported and best. Has" << (details(bi.parentHash).children.size() - 1) << "siblings. Route:";
 		for (auto r: ret)
@@ -307,7 +319,7 @@ h256s BlockChain::import(bytes const& _block, OverlayDB const& _db)
 	}
 	else
 	{
-		clog(BlockChainNote) << "   Imported but not best (oTD:" << details(m_lastBlockHash).totalDifficulty << ", TD:" << td << ")";
+		clog(BlockChainNote) << "   Imported but not best (oTD:" << details(last).totalDifficulty << ", TD:" << td << ")";
 	}
 	return ret;
 }
@@ -347,7 +359,6 @@ h256s BlockChain::treeRoute(h256 _from, h256 _to, h256* o_common) const
 
 void BlockChain::checkConsistency()
 {
-	lock_guard<recursive_mutex> l(m_lock);
 	m_details.clear();
 	ldb::Iterator* it = m_db->NewIterator(m_readOptions);
 	for (it->SeekToFirst(); it->Valid(); it->Next())
@@ -371,15 +382,17 @@ bytes BlockChain::block(h256 _hash) const
 	if (_hash == m_genesisHash)
 		return m_genesisBlock;
 
-	lock_guard<recursive_mutex> l(m_lock);
-
-	auto it = m_cache.find(_hash);
-	if (it != m_cache.end())
-		return it->second;
+	{
+		ReadGuard l(x_cache);
+		auto it = m_cache.find(_hash);
+		if (it != m_cache.end())
+			return it->second;
+	}
 
 	string d;
 	m_db->Get(m_readOptions, ldb::Slice((char const*)&_hash, 32), &d);
 
+	WriteGuard l(x_cache);
 	m_cache[_hash].resize(d.size());
 	memcpy(m_cache[_hash].data(), d.data(), d.size());
 
@@ -389,11 +402,6 @@ bytes BlockChain::block(h256 _hash) const
 	return m_cache[_hash];
 }
 
-eth::uint BlockChain::number(h256 _hash) const
-{
-	return details(_hash).number;
-}
-
 h256 BlockChain::numberHash(unsigned _n) const
 {
 	if (!_n)
@@ -402,69 +410,3 @@ h256 BlockChain::numberHash(unsigned _n) const
 	for (; _n < details().number; ++_n, ret = details(ret).parent) {}
 	return ret;
 }
-
-BlockDetails BlockChain::details(h256 _h) const
-{
-	lock_guard<recursive_mutex> l(m_lock);
-
-	BlockDetailsHash::const_iterator it = m_details.find(_h);
-	if (it != m_details.end())
-		return it->second;
-
-	std::string s;
-	m_extrasDB->Get(m_readOptions, toSlice(_h), &s);
-	if (s.empty())
-	{
-//			cout << "Not found in DB: " << _h << endl;
-		return NullBlockDetails;
-	}
-	{
-		bool ok;
-		tie(it, ok) = m_details.insert(std::make_pair(_h, BlockDetails(RLP(s))));
-	}
-	return it->second;
-}
-
-BlockBlooms BlockChain::blooms(h256 _h) const
-{
-	lock_guard<recursive_mutex> l(m_lock);
-
-	BlockBloomsHash::const_iterator it = m_blooms.find(_h);
-	if (it != m_blooms.end())
-		return it->second;
-
-	std::string s;
-	m_extrasDB->Get(m_readOptions, toSlice(_h, 1), &s);
-	if (s.empty())
-	{
-//			cout << "Not found in DB: " << _h << endl;
-		return NullBlockBlooms;
-	}
-	{
-		bool ok;
-		tie(it, ok) = m_blooms.insert(std::make_pair(_h, BlockBlooms(RLP(s))));
-	}
-	return it->second;
-}
-
-BlockTraces BlockChain::traces(h256 _h) const
-{
-	lock_guard<recursive_mutex> l(m_lock);
-
-	BlockTracesHash::const_iterator it = m_traces.find(_h);
-	if (it != m_traces.end())
-		return it->second;
-
-	std::string s;
-	m_extrasDB->Get(m_readOptions, toSlice(_h, 2), &s);
-	if (s.empty())
-	{
-//			cout << "Not found in DB: " << _h << endl;
-		return NullBlockTraces;
-	}
-	{
-		bool ok;
-		tie(it, ok) = m_traces.insert(std::make_pair(_h, BlockTraces(RLP(s))));
-	}
-	return it->second;
-}

libethereum/BlockChain.h

@@ -22,6 +22,7 @@
 #pragma once
 
 #include <mutex>
+#include <boost/thread.hpp>
 #include <libethential/Log.h>
 #include <libethcore/CommonEth.h>
 #include <libethcore/BlockInfo.h>
@@ -94,6 +95,13 @@ struct BlockChainNote: public LogChannel { static const char* name() { return "=
 // TODO: Move all this Genesis stuff into Genesis.h/.cpp
 std::map<Address, AddressState> const& genesisState();
 
+using ReadGuard = boost::shared_lock<boost::shared_mutex>;
+using UpgradableGuard = boost::upgrade_lock<boost::shared_mutex>;
+using UpgradeGuard = boost::upgrade_to_unique_lock<boost::shared_mutex>;
+using WriteGuard = boost::unique_lock<boost::shared_mutex>;
+
+ldb::Slice toSlice(h256 _h, unsigned _sub = 0);
+
 /**
  * @brief Implements the blockchain database. All data this gives is disk-backed.
  * @todo Make thread-safe.
@@ -118,35 +126,36 @@ public:
 	h256s import(bytes const& _block, OverlayDB const& _stateDB);
 
 	/// Get the familial details concerning a block (or the most recent mined if none given). Thread-safe.
-	BlockDetails details(h256 _hash) const;
+	BlockDetails details(h256 _hash) const { return queryExtras<BlockDetails, 0>(_hash, m_details, x_details, NullBlockDetails); }
 	BlockDetails details() const { return details(currentHash()); }
 
 	/// Get the transactions' bloom filters of a block (or the most recent mined if none given). Thread-safe.
-	BlockBlooms blooms(h256 _hash) const;
+	BlockBlooms blooms(h256 _hash) const { return queryExtras<BlockBlooms, 1>(_hash, m_blooms, x_blooms, NullBlockBlooms); }
 	BlockBlooms blooms() const { return blooms(currentHash()); }
 
 	/// Get the transactions' trace manifests of a block (or the most recent mined if none given). Thread-safe.
-	BlockTraces traces(h256 _hash) const;
+	BlockTraces traces(h256 _hash) const { return queryExtras<BlockTraces, 2>(_hash, m_traces, x_traces, NullBlockTraces); }
 	BlockTraces traces() const { return traces(currentHash()); }
 
-	/// Get a given block (RLP format). Thread-safe.
+	/// Get a block (RLP format) for the given hash (or the most recent mined if none given). Thread-safe.
 	bytes block(h256 _hash) const;
 	bytes block() const { return block(currentHash()); }
 
-	uint number(h256 _hash) const;
+	/// Get a number for the given hash (or the most recent mined if none given). Thread-safe.
+	uint number(h256 _hash) const { return details(_hash).number; }
 	uint number() const { return number(currentHash()); }
 
 	/// Get a given block (RLP format). Thread-safe.
-	h256 currentHash() const { return m_lastBlockHash; }
+	h256 currentHash() const { ReadGuard l(x_lastBlockHash); return m_lastBlockHash; }
 
-	/// Get the hash of the genesis block.
+	/// Get the hash of the genesis block. Thread-safe.
 	h256 genesisHash() const { return m_genesisHash; }
 
-	/// Get the hash of a block of a given number.
+	/// Get the hash of a block of a given number. Slow; try not to use it too much.
 	h256 numberHash(unsigned _n) const;
 
 	/// @returns the genesis block header.
-	static BlockInfo const& genesis() { if (!s_genesis) { auto gb = createGenesisBlock(); (s_genesis = new BlockInfo)->populate(&gb); } return *s_genesis; }
+	static BlockInfo const& genesis() { UpgradableGuard l(x_genesis); if (!s_genesis) { auto gb = createGenesisBlock(); UpgradeGuard ul(l); (s_genesis = new BlockInfo)->populate(&gb); } return *s_genesis; }
 
 	/// @returns the genesis block as its RLP-encoded byte array.
 	/// @note This is slow as it's constructed anew each call. Consider genesis() instead.
@@ -169,21 +178,49 @@ public:
 	h256s treeRoute(h256 _from, h256 _to, h256* o_common = nullptr) const;
 
 private:
+	template<class T, unsigned N> T queryExtras(h256 _h, std::map<h256, T>& _m, boost::shared_mutex& _x, T const& _n) const
+	{
+		{
+			ReadGuard l(_x);
+			auto it = _m.find(_h);
+			if (it != _m.end())
+				return it->second;
+		}
+
+		std::string s;
+		m_extrasDB->Get(m_readOptions, toSlice(_h, N), &s);
+		if (s.empty())
+		{
+	//			cout << "Not found in DB: " << _h << endl;
+			return _n;
+		}
+
+		WriteGuard l(_x);
+		auto ret = _m.insert(std::make_pair(_h, T(RLP(s))));
+		return ret.first->second;
+	}
+
 	void checkConsistency();
 
-	/// Get fully populated from disk DB.
+	/// The caches of the disk DB and their locks.
+	mutable boost::shared_mutex x_details;
 	mutable BlockDetailsHash m_details;
+	mutable boost::shared_mutex x_blooms;
 	mutable BlockBloomsHash m_blooms;
+	mutable boost::shared_mutex x_traces;
 	mutable BlockTracesHash m_traces;
-
+	mutable boost::shared_mutex x_cache;
 	mutable std::map<h256, bytes> m_cache;
-	mutable std::recursive_mutex m_lock;
 
+	/// The disk DBs. Thread-safe, so no need for locks.
 	ldb::DB* m_db;
 	ldb::DB* m_extrasDB;
 
 	/// Hash of the last (valid) block on the longest chain.
+	mutable boost::shared_mutex x_lastBlockHash;
 	h256 m_lastBlockHash;
+
+	/// Genesis block info.
 	h256 m_genesisHash;
 	bytes m_genesisBlock;
 
@@ -192,6 +229,8 @@ private:
 
 	friend std::ostream& operator<<(std::ostream& _out, BlockChain const& _bc);
 
+	/// Static genesis info and its lock.
+	static boost::shared_mutex x_genesis;
 	static BlockInfo* s_genesis;
 };