Ability to switch GPU/CPU mining on the fly.

CMakeLists.txt

@@ -62,6 +62,8 @@ function(configureProject)
 	if (GUI)
 		add_definitions(-DETH_GUI)
 	endif()
+
+	add_definitions(-DETH_TRUE)
 endfunction()
 
 set(CPPETHEREUM 1)

alethzero/Main.ui

@@ -150,6 +150,7 @@
      <string>&amp;Tools</string>
     </property>
     <addaction name="mine"/>
+    <addaction name="turboMining"/>
     <addaction name="separator"/>
     <addaction name="newTransaction"/>
     <addaction name="newAccount"/>
@@ -176,7 +177,6 @@
     <addaction name="killBlockchain"/>
     <addaction name="inject"/>
     <addaction name="forceMining"/>
-    <addaction name="turboMining"/>
     <addaction name="separator"/>
     <addaction name="usePrivate"/>
     <addaction name="jitvm"/>
@@ -1608,14 +1608,6 @@ font-size: 14pt</string>
     <string>&amp;Enable LLL Optimizer</string>
    </property>
   </action>
-  <action name="turboMining">
-   <property name="checkable">
-    <bool>true</bool>
-   </property>
-   <property name="text">
-    <string>&amp;Reserved Debug 1</string>
-   </property>
-  </action>
   <action name="localNetworking">
    <property name="checkable">
     <bool>true</bool>
@@ -1679,6 +1671,14 @@ font-size: 14pt</string>
     <string>&amp;NatSpec Enabled</string>
    </property>
   </action>
+  <action name="turboMining">
+   <property name="checkable">
+    <bool>true</bool>
+   </property>
+   <property name="text">
+    <string>&amp;GPU Mining</string>
+   </property>
+  </action>
  </widget>
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>

alethzero/MainWin.cpp

@@ -707,6 +707,7 @@ void Main::writeSettings()
 	s.setValue("upnp", ui->upnp->isChecked());
 	s.setValue("forceAddress", ui->forcePublicIP->text());
 	s.setValue("forceMining", ui->forceMining->isChecked());
+	s.setValue("turboMining", ui->turboMining->isChecked());
 	s.setValue("paranoia", ui->paranoia->isChecked());
 	s.setValue("natSpec", ui->natSpec->isChecked());
 	s.setValue("showAll", ui->showAll->isChecked());
@@ -777,6 +778,8 @@ void Main::readSettings(bool _skipGeometry)
 	ui->dropPeers->setChecked(false);
 	ui->forceMining->setChecked(s.value("forceMining", false).toBool());
 	on_forceMining_triggered();
+	ui->turboMining->setChecked(s.value("turboMining", false).toBool());
+	on_turboMining_triggered();
 	ui->paranoia->setChecked(s.value("paranoia", false).toBool());
 	ui->natSpec->setChecked(s.value("natSpec", true).toBool());
 	ui->showAll->setChecked(s.value("showAll", false).toBool());

eth/main.cpp

@@ -273,7 +273,6 @@ int main(int argc, char** argv)
 	unsigned mining = ~(unsigned)0;
 	int miners = -1;
 	bool forceMining = false;
-	bool turboMining = false;
 	KeyPair us = KeyPair::create();
 	Address coinbase = us.address();
 
@@ -466,8 +465,6 @@ int main(int argc, char** argv)
 			bootstrap = true;
 		else if (arg == "-f" || arg == "--force-mining")
 			forceMining = true;
-		else if (arg == "-T" || arg == "--turbo-mining")
-			turboMining = true;
 		else if (arg == "-i" || arg == "--interactive")
 			interactive = true;
 #if ETH_JSONRPC
@@ -632,7 +629,6 @@ int main(int argc, char** argv)
 	{
 		c->setGasPricer(gasPricer);
 		c->setForceMining(forceMining);
-		c->setTurboMining(turboMining);
 		c->setAddress(coinbase);
 	}
 

libethcore/ProofOfWork.cpp

@@ -45,12 +45,12 @@ namespace dev
 namespace eth
 {
 
-bool EthashCPU::verify(BlockInfo const& _header)
+bool EthashPoW::verify(BlockInfo const& _header)
 {
 	return Ethasher::verify(_header);
 }
 
-std::pair<MineInfo, EthashCPU::Proof> EthashCPU::mine(BlockInfo const& _header, unsigned _msTimeout, bool _continue, bool _turbo)
+std::pair<MineInfo, EthashCPU::Proof> EthashCPU::mine(BlockInfo const& _header, unsigned _msTimeout, bool _continue)
 {
 	Ethasher::Miner m(_header);
 
@@ -67,8 +67,6 @@ std::pair<MineInfo, EthashCPU::Proof> EthashCPU::mine(BlockInfo const& _header,
 	//
 	// evaluate until we run out of time
 	auto startTime = std::chrono::steady_clock::now();
-	if (!_turbo)
-		std::this_thread::sleep_for(std::chrono::milliseconds(_msTimeout * 90 / 100));
 	double best = 1e99;	// high enough to be effectively infinity :)
 	Proof result;
 	unsigned hashCount = 0;
@@ -102,7 +100,7 @@ std::pair<MineInfo, EthashCPU::Proof> EthashCPU::mine(BlockInfo const& _header,
 	return ret;
 }
 
-#if ETH_ETHASHCL
+#if ETH_ETHASHCL || !ETH_TRUE
 
 /*
 class ethash_cl_miner
@@ -186,12 +184,7 @@ EthashCL::~EthashCL()
 {
 }
 
-bool EthashCL::verify(BlockInfo const& _header)
-{
-	return Ethasher::verify(_header);
-}
-
-std::pair<MineInfo, Ethash::Proof> EthashCL::mine(BlockInfo const& _header, unsigned _msTimeout, bool, bool)
+std::pair<MineInfo, Ethash::Proof> EthashCL::mine(BlockInfo const& _header, unsigned _msTimeout, bool)
 {
 	if (!m_lastHeader || m_lastHeader.seedHash() != _header.seedHash())
 	{
@@ -201,7 +194,7 @@ std::pair<MineInfo, Ethash::Proof> EthashCL::mine(BlockInfo const& _header, unsi
 		auto cb = [&](void* d) {
 			Ethasher::get()->readFull(_header, d);
 		};
-		m_miner->init(Ethasher::params(_header), cb);
+		m_miner->init(Ethasher::params(_header), cb, 32);
 	}
 	if (m_lastHeader != _header)
 	{
@@ -209,7 +202,6 @@ std::pair<MineInfo, Ethash::Proof> EthashCL::mine(BlockInfo const& _header, unsi
 		static std::random_device s_eng;
 		auto hh = _header.headerHash(WithoutNonce);
 		uint64_t upper64OfBoundary = (uint64_t)(u64)((u256)_header.boundary() >> 192);
-		cdebug << "Mining with headerhash" << hh << "from nonce" << m_last << "with boundary" << _header.boundary() << " (" << upper64OfBoundary << ")";
 		m_miner->search(hh.data(), upper64OfBoundary, *m_hook);
 	}
 	m_lastHeader = _header;
@@ -221,11 +213,9 @@ std::pair<MineInfo, Ethash::Proof> EthashCL::mine(BlockInfo const& _header, unsi
 		for (auto const& n: found)
 		{
 			auto result = Ethasher::eval(_header, n);
-			cdebug << "Got nonce " << n << "gives result" << result.value;
 			if (result.value < _header.boundary())
 				return std::make_pair(MineInfo(true), EthashCL::Proof{n, result.mixHash});
 		}
-		assert(false);
 	}
 	return std::make_pair(MineInfo(false), EthashCL::Proof());
 }

libethcore/ProofOfWork.h

@@ -51,7 +51,7 @@ struct MineInfo
 	bool completed = false;
 };
 
-class EthashCPU
+class EthashPoW
 {
 public:
 	struct Proof
@@ -61,31 +61,32 @@ public:
 	};
 
 	static bool verify(BlockInfo const& _header);
-	std::pair<MineInfo, Proof> mine(BlockInfo const& _header, unsigned _msTimeout = 100, bool _continue = true, bool _turbo = false);
 	static void assignResult(Proof const& _r, BlockInfo& _header) { _header.nonce = _r.nonce; _header.mixHash = _r.mixHash; }
 
+	virtual unsigned defaultTimeout() const { return 100; }
+	virtual std::pair<MineInfo, Proof> mine(BlockInfo const& _header, unsigned _msTimeout = 100, bool _continue = true) = 0;
+};
+
+class EthashCPU: public EthashPoW
+{
+public:
+	std::pair<MineInfo, Proof> mine(BlockInfo const& _header, unsigned _msTimeout = 100, bool _continue = true) override;
+
 protected:
 	Nonce m_last;
 };
 
-#if ETH_ETHASHCL
+#if ETH_ETHASHCL || !ETH_TRUE
 class EthashCLHook;
 
-class EthashCL
+class EthashCL: public EthashPoW
 {
 public:
-	struct Proof
-	{
-		Nonce nonce;
-		h256 mixHash;
-	};
-
 	EthashCL();
 	~EthashCL();
 
-	static bool verify(BlockInfo const& _header);
-	std::pair<MineInfo, Proof> mine(BlockInfo const& _header, unsigned _msTimeout = 100, bool _continue = true, bool _turbo = false);
-	static void assignResult(Proof const& _r, BlockInfo& _header) { _header.nonce = _r.nonce; _header.mixHash = _r.mixHash; }
+	std::pair<MineInfo, Proof> mine(BlockInfo const& _header, unsigned _msTimeout = 100, bool _continue = true) override;
+	unsigned defaultTimeout() const override { return 500; }
 
 protected:
 	Nonce m_last;
@@ -107,8 +108,9 @@ public:
 	using Proof = Nonce;
 
 	static bool verify(BlockInfo const& _header) { return (bigint)(u256)Evaluator::eval(_header.headerHash(WithoutNonce), _header.nonce) <= (bigint(1) << 256) / _header.difficulty; }
-	inline std::pair<MineInfo, Proof> mine(BlockInfo const& _header, unsigned _msTimeout = 100, bool _continue = true, bool _turbo = false);
+	inline std::pair<MineInfo, Proof> mine(BlockInfo const& _header, unsigned _msTimeout = 100, bool _continue = true);
 	static void assignResult(Proof const& _r, BlockInfo& _header) { _header.nonce = _r; }
+	unsigned defaultTimeout() const { return 100; }
 
 protected:
 	Nonce m_last;
@@ -125,7 +127,7 @@ using SHA3ProofOfWork = ProofOfWorkEngine<SHA3Evaluator>;
 using ProofOfWork = Ethash;
 
 template <class Evaluator>
-std::pair<MineInfo, typename ProofOfWorkEngine<Evaluator>::Proof> ProofOfWorkEngine<Evaluator>::mine(BlockInfo const& _header, unsigned _msTimeout, bool _continue, bool _turbo)
+std::pair<MineInfo, typename ProofOfWorkEngine<Evaluator>::Proof> ProofOfWorkEngine<Evaluator>::mine(BlockInfo const& _header, unsigned _msTimeout, bool _continue)
 {
 	auto headerHashWithoutNonce = _header.headerHash(WithoutNonce);
 	auto difficulty = _header.difficulty;
@@ -142,8 +144,6 @@ std::pair<MineInfo, typename ProofOfWorkEngine<Evaluator>::Proof> ProofOfWorkEng
 	//
 	// evaluate until we run out of time
 	auto startTime = std::chrono::steady_clock::now();
-	if (!_turbo)
-		std::this_thread::sleep_for(std::chrono::milliseconds(_msTimeout * 90 / 100));
 	double best = 1e99;	// high enough to be effectively infinity :)
 	ProofOfWorkEngine<Evaluator>::Proof solution;
 	unsigned h = 0;

libethereum/Client.cpp

@@ -345,11 +345,10 @@ void Client::setForceMining(bool _enable)
 void Client::setMiningThreads(unsigned _threads)
 {
 	stopMining();
-#if ETH_ETHASHCL
-	(void)_threads;
-	unsigned t = 1;
-#else
 	auto t = _threads ? _threads : thread::hardware_concurrency();
+#if ETH_ETHASHCL || !ETH_TRUE
+	if (m_turboMining)
+		t = 1;
 #endif
 	WriteGuard l(x_localMiners);
 	m_localMiners.clear();
@@ -368,6 +367,15 @@ MineProgress Client::miningProgress() const
 	return ret;
 }
 
+uint64_t Client::hashrate() const
+{
+	uint64_t ret;
+	ReadGuard l(x_localMiners);
+	for (LocalMiner const& m: m_localMiners)
+		ret += m.miningProgress().hashes / m.miningProgress().ms;
+	return ret / 1000;
+}
+
 std::list<MineInfo> Client::miningHistory()
 {
 	std::list<MineInfo> ret;

libethereum/Client.h

@@ -188,25 +188,27 @@ public:
 	bool forceMining() const { return m_forceMining; }
 	/// Enable/disable forcing of mining to happen, even without transactions.
 	void setForceMining(bool _enable);
-	/// Are we mining as fast as we can?
+	/// Are we allowed to GPU mine?
 	bool turboMining() const { return m_turboMining; }
-	/// Enable/disable fast mining.
-	void setTurboMining(bool _enable = true) { m_turboMining = _enable; }
+	/// Enable/disable GPU mining.
+	void setTurboMining(bool _enable = true) { bool was = isMining(); stopMining(); m_turboMining = _enable; setMiningThreads(0); if (was) startMining(); }
 
 	/// Stops mining and sets the number of mining threads (0 for automatic).
-	virtual void setMiningThreads(unsigned _threads = 0);
+	void setMiningThreads(unsigned _threads = 0) override;
 	/// Get the effective number of mining threads.
-	virtual unsigned miningThreads() const { ReadGuard l(x_localMiners); return m_localMiners.size(); }
+	unsigned miningThreads() const override { ReadGuard l(x_localMiners); return m_localMiners.size(); }
 	/// Start mining.
 	/// NOT thread-safe - call it & stopMining only from a single thread
-	virtual void startMining() { startWorking(); { ReadGuard l(x_localMiners); for (auto& m: m_localMiners) m.start(); } }
+	void startMining() override { startWorking(); { ReadGuard l(x_localMiners); for (auto& m: m_localMiners) m.start(); } }
 	/// Stop mining.
 	/// NOT thread-safe
-	virtual void stopMining() { { ReadGuard l(x_localMiners); for (auto& m: m_localMiners) m.stop(); } }
+	void stopMining() override { { ReadGuard l(x_localMiners); for (auto& m: m_localMiners) m.stop(); } }
 	/// Are we mining now?
-	virtual bool isMining() { { ReadGuard l(x_localMiners); if (!m_localMiners.empty() && m_localMiners[0].isRunning()) return true; } return false; }
+	bool isMining() const override { { ReadGuard l(x_localMiners); if (!m_localMiners.empty() && m_localMiners[0].isRunning()) return true; } return false; }
+	/// Are we mining now?
+	uint64_t hashrate() const override;
 	/// Check the progress of the mining.
-	virtual MineProgress miningProgress() const;
+	MineProgress miningProgress() const override;
 	/// Get and clear the mining history.
 	std::list<MineInfo> miningHistory();
 

libethereum/ClientBase.h

@@ -146,7 +146,8 @@ public:
 	virtual unsigned miningThreads() const override { BOOST_THROW_EXCEPTION(InterfaceNotSupported("dev::eth::ClientBase::miningThreads")); }
 	virtual void startMining() override { BOOST_THROW_EXCEPTION(InterfaceNotSupported("dev::eth::ClientBase::startMining")); }
 	virtual void stopMining() override { BOOST_THROW_EXCEPTION(InterfaceNotSupported("dev::eth::ClientBase::stopMining")); }
-	virtual bool isMining() override { BOOST_THROW_EXCEPTION(InterfaceNotSupported("dev::eth::ClientBase::isMining")); }
+	virtual bool isMining() const override { BOOST_THROW_EXCEPTION(InterfaceNotSupported("dev::eth::ClientBase::isMining")); }
+	virtual uint64_t hashrate() const override { BOOST_THROW_EXCEPTION(InterfaceNotSupported("dev::eth::ClientBase::hashrate")); }
 	virtual eth::MineProgress miningProgress() const override { BOOST_THROW_EXCEPTION(InterfaceNotSupported("dev::eth::ClientBase::miningProgress")); }
 	virtual std::pair<h256, u256> getWork() override { BOOST_THROW_EXCEPTION(InterfaceNotSupported("dev::eth::ClientBase::getWork")); }
 	virtual bool submitWork(eth::ProofOfWork::Proof const&) override { BOOST_THROW_EXCEPTION(InterfaceNotSupported("dev::eth::ClientBase::submitWork")); }

libethereum/Interface.h

@@ -183,7 +183,9 @@ public:
 	/// NOT thread-safe
 	virtual void stopMining() = 0;
 	/// Are we mining now?
-	virtual bool isMining() = 0;
+	virtual bool isMining() const = 0;
+	/// Current hash rate.
+	virtual uint64_t hashrate() const = 0;
 
 	/// Get hash of the current block to be mined minus the nonce (the 'work hash').
 	virtual std::pair<h256, u256> getWork() = 0;

libethereum/Miner.cpp

@@ -34,12 +34,14 @@ LocalMiner::LocalMiner(MinerHost* _host, unsigned _id):
 	AsyncMiner(_host, _id),
 	Worker("miner-" + toString(_id))
 {
+	m_pow.reset(_host->turbo() ? new Ethash : (Ethash*)new EthashCPU);
 }
 
 void LocalMiner::setup(MinerHost* _host, unsigned _id)
 {
 	AsyncMiner::setup(_host, _id);
 	setName("miner-" + toString(m_id));
+	m_pow.reset(_host->turbo() ? new Ethash : (Ethash*)new EthashCPU);
 }
 
 void LocalMiner::doWork()
@@ -66,7 +68,7 @@ void LocalMiner::doWork()
 		if (m_miningStatus == Mining)
 		{
 			// Mine for a while.
-			MineInfo mineInfo = m_mineState.mine(100, m_host->turbo());
+			MineInfo mineInfo = m_mineState.mine(m_pow.get());
 
 			{
 				Guard l(x_mineInfo);

libethereum/Miner.h

@@ -60,8 +60,8 @@ public:
 	virtual void setupState(State& _s) = 0;		///< Reset the given State object to the one that should be being mined.
 	virtual void onProgressed() {}				///< Called once some progress has been made.
 	virtual void onComplete() {}				///< Called once a block is found.
-	virtual bool turbo() const = 0;				///< @returns true iff the Miner should mine as fast as possible.
 	virtual bool force() const = 0;				///< @returns true iff the Miner should mine regardless of the number of transactions.
+	virtual bool turbo() const = 0;				///< @returns true iff the Miner should use GPU if possible.
 };
 
 class Miner
@@ -93,7 +93,7 @@ public:
 	virtual void stop() {}
 
 	/// @returns true iff the mining has been start()ed. It may still not be actually mining, depending on the host's turbo() & force().
-	virtual bool isRunning() { return false; }
+	virtual bool isRunning() const { return false; }
 
 protected:
 	MinerHost* m_host = nullptr;			///< Our host.
@@ -122,10 +122,10 @@ public:
 	LocalMiner(MinerHost* _host, unsigned _id = 0);
 
 	/// Move-constructor.
-	LocalMiner(LocalMiner&& _m): Worker((Worker&&)_m) { std::swap(m_host, _m.m_host); }
+	LocalMiner(LocalMiner&& _m): Worker((Worker&&)_m) { std::swap(m_host, _m.m_host); std::swap(m_pow, _m.m_pow); }
 
 	/// Move-assignment.
-	LocalMiner& operator=(LocalMiner&& _m) { Worker::operator=((Worker&&)_m); std::swap(m_host, _m.m_host); return *this; }
+	LocalMiner& operator=(LocalMiner&& _m) { Worker::operator=((Worker&&)_m); std::swap(m_host, _m.m_host); std::swap(m_pow, _m.m_pow); return *this; }
 
 	/// Destructor. Stops miner.
 	~LocalMiner() { stop(); }
@@ -143,7 +143,7 @@ public:
 	virtual void noteStateChange() override { m_miningStatus = Preparing; }
 
 	/// @returns true iff the mining has been start()ed. It may still not be actually mining, depending on the host's turbo() & force().
-	bool isRunning() { return isWorking(); }
+	bool isRunning() const override { return isWorking(); }
 
 	/// @returns true if mining is complete.
 	virtual bool isComplete() const override { return m_miningStatus == Mined; }
@@ -167,8 +167,9 @@ private:
 	enum MiningStatus { Waiting, Preparing, Mining, Mined, Stopping, Stopped };
 	MiningStatus m_miningStatus = Waiting;	///< TODO: consider mutex/atomic variable.
 	State m_mineState;						///< The state on which we are mining, generally equivalent to m_postMine.
+	std::unique_ptr<EthashPoW> m_pow;		///< Our miner.
 
-	mutable std::mutex x_mineInfo;			///< Lock for the mining progress & history.
+	mutable Mutex x_mineInfo;				///< Lock for the mining progress & history.
 	MineProgress m_mineProgress;			///< What's our progress?
 	std::list<MineInfo> m_mineHistory;		///< What the history of our mining?
 };

libethereum/State.cpp

@@ -856,33 +856,12 @@ void State::commitToMine(BlockChain const& _bc)
 	m_committedToMine = true;
 }
 
-MineInfo State::mine(unsigned _msTimeout, bool _turbo)
-{
-	// Update difficulty according to timestamp.
-	m_currentBlock.difficulty = m_currentBlock.calculateDifficulty(m_previousBlock);
-
-	MineInfo ret;
-	// TODO: Miner class that keeps dagger between mine calls (or just non-polling mining).
-	ProofOfWork::Proof r;
-	tie(ret, r) = m_pow.mine(m_currentBlock, _msTimeout, true, _turbo);
-
-	if (!ret.completed)
-		m_currentBytes.clear();
-	else
-	{
-		ProofOfWork::assignResult(r, m_currentBlock);
-		cnote << "Completed" << m_currentBlock.headerHash(WithoutNonce).abridged() << m_currentBlock.nonce.abridged() << m_currentBlock.difficulty << ProofOfWork::verify(m_currentBlock);
-	}
-
-	return ret;
-}
-
 bool State::completeMine(ProofOfWork::Proof const& _nonce)
 {
 	ProofOfWork::assignResult(_nonce, m_currentBlock);
 
-	if (!m_pow.verify(m_currentBlock))
-		return false;
+//	if (!m_pow.verify(m_currentBlock))
+//		return false;
 
 	cnote << "Completed" << m_currentBlock.headerHash(WithoutNonce).abridged() << m_currentBlock.nonce.abridged() << m_currentBlock.difficulty << ProofOfWork::verify(m_currentBlock);
 

libethereum/State.h

@@ -168,7 +168,25 @@ public:
 	/// This function is thread-safe. You can safely have other interactions with this object while it is happening.
 	/// @param _msTimeout Timeout before return in milliseconds.
 	/// @returns Information on the mining.
-	MineInfo mine(unsigned _msTimeout = 1000, bool _turbo = false);
+	template <class ProofOfWork> MineInfo mine(ProofOfWork* _pow)
+	{
+		// Update difficulty according to timestamp.
+		m_currentBlock.difficulty = m_currentBlock.calculateDifficulty(m_previousBlock);
+
+		MineInfo ret;
+		typename ProofOfWork::Proof r;
+		std::tie(ret, r) = _pow->mine(m_currentBlock, _pow->defaultTimeout(), true);
+
+		if (!ret.completed)
+			m_currentBytes.clear();
+		else
+		{
+			ProofOfWork::assignResult(r, m_currentBlock);
+			cnote << "Completed" << m_currentBlock.headerHash(WithoutNonce).abridged() << m_currentBlock.nonce.abridged() << m_currentBlock.difficulty << ProofOfWork::verify(m_currentBlock);
+		}
+
+		return ret;
+	}
 
 	/** Commit to DB and build the final block if the previous call to mine()'s result is completion.
 	 * Typically looks like:
@@ -371,8 +389,6 @@ private:
 
 	Address m_ourAddress;						///< Our address (i.e. the address to which fees go).
 
-	ProofOfWork m_pow;							///< The PoW mining class.
-
 	u256 m_blockReward;
 
 	static std::string c_defaultPath;

libweb3jsonrpc/WebThreeStubServerBase.cpp

@@ -296,6 +296,11 @@ string WebThreeStubServerBase::eth_coinbase()
 	return toJS(client()->address());
 }
 
+string WebThreeStubServerBase::eth_hashrate()
+{
+	return toJS(client()->hashrate());
+}
+
 bool WebThreeStubServerBase::eth_mining()
 {
 	return client()->isMining();

libweb3jsonrpc/WebThreeStubServerBase.h

@@ -78,6 +78,7 @@ public:
 	virtual bool net_listening();
 
 	virtual std::string eth_protocolVersion();
+	virtual std::string eth_hashrate();
 	virtual std::string eth_coinbase();
 	virtual bool eth_mining();
 	virtual std::string eth_gasPrice();

libweb3jsonrpc/abstractwebthreestubserver.h

@@ -18,6 +18,7 @@ class AbstractWebThreeStubServer : public jsonrpc::AbstractServer<AbstractWebThr
             this->bindAndAddMethod(jsonrpc::Procedure("net_peerCount", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_STRING,  NULL), &AbstractWebThreeStubServer::net_peerCountI);
             this->bindAndAddMethod(jsonrpc::Procedure("net_listening", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_BOOLEAN,  NULL), &AbstractWebThreeStubServer::net_listeningI);
             this->bindAndAddMethod(jsonrpc::Procedure("eth_protocolVersion", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_STRING,  NULL), &AbstractWebThreeStubServer::eth_protocolVersionI);
+            this->bindAndAddMethod(jsonrpc::Procedure("eth_hashrate", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_STRING,  NULL), &AbstractWebThreeStubServer::eth_hashrateI);
             this->bindAndAddMethod(jsonrpc::Procedure("eth_coinbase", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_STRING,  NULL), &AbstractWebThreeStubServer::eth_coinbaseI);
             this->bindAndAddMethod(jsonrpc::Procedure("eth_mining", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_BOOLEAN,  NULL), &AbstractWebThreeStubServer::eth_miningI);
             this->bindAndAddMethod(jsonrpc::Procedure("eth_gasPrice", jsonrpc::PARAMS_BY_POSITION, jsonrpc::JSON_STRING,  NULL), &AbstractWebThreeStubServer::eth_gasPriceI);
@@ -98,6 +99,11 @@ class AbstractWebThreeStubServer : public jsonrpc::AbstractServer<AbstractWebThr
             (void)request;
             response = this->eth_protocolVersion();
         }
+        inline virtual void eth_hashrateI(const Json::Value &request, Json::Value &response)
+        {
+            (void)request;
+            response = this->eth_hashrate();
+        }
         inline virtual void eth_coinbaseI(const Json::Value &request, Json::Value &response)
         {
             (void)request;
@@ -309,6 +315,7 @@ class AbstractWebThreeStubServer : public jsonrpc::AbstractServer<AbstractWebThr
         virtual std::string net_peerCount() = 0;
         virtual bool net_listening() = 0;
         virtual std::string eth_protocolVersion() = 0;
+        virtual std::string eth_hashrate() = 0;
         virtual std::string eth_coinbase() = 0;
         virtual bool eth_mining() = 0;
         virtual std::string eth_gasPrice() = 0;

libweb3jsonrpc/spec.json

@@ -7,6 +7,7 @@
             { "name": "net_listening", "params": [], "order": [], "returns" : false },
 
 			{ "name": "eth_protocolVersion", "params": [], "order": [], "returns" : "" },
+			{ "name": "eth_hashrate", "params": [], "order": [], "returns" : "" },
 			{ "name": "eth_coinbase", "params": [], "order": [], "returns" : "" },
             { "name": "eth_mining", "params": [], "order": [], "returns" : false },
             { "name": "eth_gasPrice", "params": [], "order": [], "returns" : "" },

mix/MixClient.cpp

@@ -250,7 +250,8 @@ void MixClient::mine()
 {
 	WriteGuard l(x_state);
 	m_state.commitToMine(bc());
-	while (!m_state.mine(100, true).completed) {}
+	ProofOfWork pow;
+	while (!m_state.mine(&pow).completed) {}
 	m_state.completeMine();
 	bc().import(m_state.blockData(), m_stateDB);
 	m_state.sync(bc());
@@ -391,11 +392,16 @@ void MixClient::stopMining()
 	//no-op
 }
 
-bool MixClient::isMining()
+bool MixClient::isMining() const
 {
 	return false;
 }
 
+uint64_t MixClient::hashrate() const
+{
+	return 0;
+}
+
 eth::MineProgress MixClient::miningProgress() const
 {
 	return eth::MineProgress();

mix/MixClient.h

@@ -67,7 +67,8 @@ public:
 	unsigned miningThreads() const override;
 	void startMining() override;
 	void stopMining() override;
-	bool isMining() override;
+	bool isMining() const override;
+	uint64_t hashrate() const override;
 	eth::MineProgress miningProgress() const override;
 	std::pair<h256, u256> getWork() override { return std::pair<h256, u256>(); }
 	bool submitWork(eth::ProofOfWork::Proof const&) override { return false; }

test/blockchain.cpp

@@ -192,7 +192,8 @@ void doBlockchainTests(json_spirit::mValue& _v, bool _fillin)
 					state.sync(bc, txs, gp);
 					state.commitToMine(bc);
 					MineInfo info;
-					for (info.completed = false; !info.completed; info = state.mine()) {}
+					ProofOfWork pow;
+					for (info.completed = false; !info.completed; info = state.mine(&pow)) {}
 					state.completeMine();
 				}
 				catch (Exception const& _e)
@@ -577,7 +578,7 @@ void overwriteBlockHeader(BlockInfo& _currentBlockHeader, mObject& _blObj)
 			std::pair<MineInfo, Ethash::Proof> ret;
 			while (!ProofOfWork::verify(_currentBlockHeader))
 			{
-				ret = pow.mine(_currentBlockHeader, 1000, true, true);
+				ret = pow.mine(_currentBlockHeader, 1000, true);
 				Ethash::assignResult(ret.second, _currentBlockHeader);
 			}
 		}
@@ -623,7 +624,7 @@ void updatePoW(BlockInfo& _bi)
 	std::pair<MineInfo, Ethash::Proof> ret;
 	while (!ProofOfWork::verify(_bi))
 	{
-		ret = pow.mine(_bi, 10000, true, true);
+		ret = pow.mine(_bi, 10000, true);
 		Ethash::assignResult(ret.second, _bi);
 	}
 	_bi.noteDirty();

test/stateOriginal.cpp

@@ -68,7 +68,8 @@ BOOST_AUTO_TEST_CASE(Complex)
 
 	// Mine to get some ether!
 	s.commitToMine(bc);
-	while (!s.mine(100, true).completed) {}
+	ProofOfWork pow;
+	while (!s.mine(&pow).completed) {}
 	s.completeMine();
 	bc.attemptImport(s.blockData(), stateDB);
 
@@ -88,7 +89,7 @@ BOOST_AUTO_TEST_CASE(Complex)
 	// Mine to get some ether and set in stone.
 	s.commitToMine(bc);
 	s.commitToMine(bc);
-	while (!s.mine(100, true).completed) {}
+	while (!s.mine(&pow).completed) {}
 	s.completeMine();
 	bc.attemptImport(s.blockData(), stateDB);
 

test/webthreestubclient.h

@@ -72,6 +72,16 @@ class WebThreeStubClient : public jsonrpc::Client
             else
                 throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
         }
+        std::string eth_hashrate() throw (jsonrpc::JsonRpcException)
+        {
+            Json::Value p;
+            p = Json::nullValue;
+            Json::Value result = this->CallMethod("eth_hashrate",p);
+            if (result.isString())
+                return result.asString();
+            else
+                throw jsonrpc::JsonRpcException(jsonrpc::Errors::ERROR_CLIENT_INVALID_RESPONSE, result.toStyledString());
+        }
         std::string eth_coinbase() throw (jsonrpc::JsonRpcException)
         {
             Json::Value p;