getNewWork hook function for openCL GPU thread

Author: cdetrio

libethash-cl/ethash_cl_miner.cpp

@@ -532,15 +532,47 @@ void ethash_cl_miner::search(uint8_t const* header, uint64_t target, search_hook
 				for (unsigned i = 0; i != num_found; ++i)
 					nonces[i] = batch.start_nonce + results[i + 1];
 
-				m_queue.enqueueUnmapMemObject(m_searchBuffer[batch.buf], results);
-				bool exit = num_found && hook.found(nonces, num_found);
-				exit |= hook.searched(batch.start_nonce, m_globalWorkSize); // always report searched before exit
-				if (exit)
-					break;
-
-				// reset search buffer if we're still going
-				if (num_found)
-					m_queue.enqueueWriteBuffer(m_searchBuffer[batch.buf], true, 0, 4, &c_zero);
+				m_queue.enqueueUnmapMemObject(m_searchBuffer[batch.buf], results);				
+				//bool exit = num_found && hook.found(nonces, num_found);
+				// should not exit when a nonce is found.
+				// instead, continue mining on the same header
+				bool exit = false;
+				
+				if (num_found) {
+					// only call hook.found to report solutions
+					bool found_result = hook.found(nonces, num_found);
+				}
+				
+				// check if new work is pending
+				bool pendingNewWork = hook.searched(batch.start_nonce, m_globalWorkSize);
+
+				if (pendingNewWork) {
+					JobForGPU new_work = hook.getNewWork();
+					
+					// routine below is copy/pasted from above
+					m_queue.enqueueWriteBuffer(m_header, false, 0, 32, new_work.header);
+					for (unsigned i = 0; i != c_bufferCount; ++i)
+						m_queue.enqueueWriteBuffer(m_searchBuffer[i], false, 0, 4, &c_zero);
+						
+					#if CL_VERSION_1_2 && 0
+							cl::Event pre_return_event;
+							if (!m_opencl_1_1)
+								m_queue.enqueueBarrierWithWaitList(NULL, &pre_return_event);
+							else
+					#endif
+								m_queue.finish();
+					
+					// TODO: check if target is different before bothering to set it?
+					m_searchKernel.setArg(4, new_work.target);
+					
+					if (_ethStratum) start_nonce = new_work.startN;
+					else start_nonce = uniform_int_distribution<uint64_t>()(engine);
+				} else {
+					// reset search buffer if we're still going
+					if (num_found) {
+						m_queue.enqueueWriteBuffer(m_searchBuffer[batch.buf], true, 0, 4, &c_zero);
+					}
+				}
 
 				pending.pop();
 			}

libethash-cl/ethash_cl_miner.h

@@ -24,6 +24,13 @@
 #include <functional>
 #include <libethash/ethash.h>
 
+struct JobForGPU
+{
+	uint8_t const* header;
+	uint64_t target;
+	uint64_t startN;
+};
+
 class ethash_cl_miner
 {
 private:
@@ -37,6 +44,7 @@ class ethash_cl_miner
 		// reports progress, return true to abort
 		virtual bool found(uint64_t const* nonces, uint32_t count) = 0;
 		virtual bool searched(uint64_t start_nonce, uint32_t count) = 0;
+		virtual JobForGPU getNewWork() = 0;
 	};
 
 	ethash_cl_miner();

libethcore/EthashGPUMiner.cpp

@@ -68,6 +68,12 @@ class EthashCLHook: public ethash_cl_miner::search_hook
 		UniqueGuard l(x_all);
 		m_aborted = m_abort = false;
 	}
+	
+	void notifyNewWork()
+	{
+		UniqueGuard l(x_all);
+		m_workIsNew = true;
+	}
 
 protected:
 	virtual bool found(uint64_t const* _nonces, uint32_t _count) override
@@ -85,14 +91,33 @@ class EthashCLHook: public ethash_cl_miner::search_hook
 //		std::cerr << "Searched " << _count << " from " << _startNonce << std::endl;
 		m_owner->accumulateHashes(_count);
 		m_last = _startNonce + _count;
-		if (m_abort || m_owner->shouldStop())
-			return (m_aborted = true);
-		return false;
+		//if (m_abort || m_owner->shouldStop())
+		//	return (m_aborted = true);
+		//return false;
+		// TODO: still need a way to stop the GPU thread
+		
+		if (m_workIsNew) {
+			return true;
+		} else {
+			return false;
+		}
+		
+	}
+	
+	virtual JobForGPU getNewWork()
+	{
+		UniqueGuard l(x_all);
+		m_workIsNew = false;
+		JobForGPU new_work = m_owner->getWork();
+		printf("new_work header: %02x%02x \n", new_work.header[0], new_work.header[1]);
+		
+		return new_work;
 	}
 
 private:
 	Mutex x_all;
 	uint64_t m_last;
+	bool m_workIsNew = false;
 	bool m_abort = false;
 	Notified<bool> m_aborted = {true};
 	EthashGPUMiner* m_owner = nullptr;
@@ -120,6 +145,19 @@ EthashGPUMiner::~EthashGPUMiner()
 	delete m_hook;
 }
 
+JobForGPU EthashGPUMiner::getWork()
+{
+	WorkPackage w_kick = work();
+	uint64_t upper64OfBoundary = (uint64_t)(u64)((u256)w_kick.boundary >> 192);
+	uint64_t startN;
+	if (w_kick.exSizeBits >= 0)
+		startN = w_kick.startNonce | ((uint64_t)index() << (64 - 4 - w_kick.exSizeBits)); // this can support up to 16 devices
+
+	JobForGPU new_work = {w_kick.headerHash.data(), upper64OfBoundary, startN};
+	
+	return new_work;
+}
+
 bool EthashGPUMiner::report(uint64_t _nonce)
 {
 	Nonce n = (Nonce)(u64)_nonce;
@@ -132,7 +170,14 @@ bool EthashGPUMiner::report(uint64_t _nonce)
 void EthashGPUMiner::kickOff()
 {
 	m_hook->reset();
-	startWorking();
+	
+	if (isWorking()) {
+		// if already mining, notify of new pending work
+		m_hook->notifyNewWork();
+	} else {
+		// first time running.
+		startWorking();
+	}
 }
 
 void EthashGPUMiner::workLoop()
@@ -182,8 +227,11 @@ void EthashGPUMiner::workLoop()
 
 void EthashGPUMiner::pause()
 {
-	m_hook->abort();
-	stopWorking();
+	if (!isWorking()) {
+		// only happens on first pause/kickoff cycle
+		m_hook->abort();
+		stopWorking();
+	}
 }
 
 std::string EthashGPUMiner::platformInfo()

libethcore/EthashGPUMiner.h

@@ -27,6 +27,7 @@
 #include <libdevcore/Worker.h>
 #include "EthashAux.h"
 #include "Miner.h"
+#include <libethash-cl/ethash_cl_miner.h>
 
 class ethash_cl_miner;
 
@@ -74,6 +75,7 @@ class EthashGPUMiner: public Miner, Worker
 private:
 	void workLoop() override;
 	bool report(uint64_t _nonce);
+	JobForGPU getWork();
 
 	using Miner::accumulateHashes;