Merge branch 'develop' into filter_blockHash

eth/main.cpp

@@ -118,6 +118,7 @@ void help()
 #endif
 		<< "    -K,--kill  First kill the blockchain." << endl
 		<< "    -R,--rebuild  Rebuild the blockchain from the existing database." << endl
+		<< "    --genesis-nonce <nonce>  Set the Genesis Nonce to the given hex nonce." << endl
 		<< "    -s,--import-secret <secret>  Import a secret key into the key store and use as the default." << endl
 		<< "    -S,--import-session-secret <secret>  Import a secret key into the key store and use as the default for this session only." << endl
 		<< "    --sign-key <address>  Sign all transactions with the key of the given address." << endl
@@ -470,6 +471,18 @@ int main(int argc, char** argv)
 		}
 		else if ((arg == "-d" || arg == "--path" || arg == "--db-path") && i + 1 < argc)
 			dbPath = argv[++i];
+		else if (arg == "--genesis-nonce" && i + 1 < argc)
+		{
+			try
+			{
+				CanonBlockChain::setGenesisNonce(Nonce(argv[++i]));
+			}
+			catch (...)
+			{
+				cerr << "Bad " << arg << " option: " << argv[i] << endl;
+				return -1;
+			}
+		}
 /*		else if ((arg == "-B" || arg == "--block-fees") && i + 1 < argc)
 		{
 			try

ethminer/MinerAux.h

@@ -127,6 +127,10 @@ public:
 				cerr << "Bad " << arg << " option: " << argv[i] << endl;
 				throw BadArgument();
 			}
+		else if (arg == "--use-chunks")
+		{
+			dagChunks = 4;
+		}
 		else if (arg == "--phone-home" && i + 1 < argc)
 		{
 			string m = argv[++i];
@@ -264,6 +268,7 @@ public:
 			ProofOfWork::GPUMiner::setDefaultPlatform(openclPlatform);
 			ProofOfWork::GPUMiner::setDefaultDevice(openclDevice);
 			ProofOfWork::GPUMiner::setNumInstances(miningThreads);
+			ProofOfWork::GPUMiner::setDagChunks(dagChunks);
 		}
 		if (mode == OperationMode::DAGInit)
 			doInitDAG(initDAG);
@@ -301,6 +306,7 @@ public:
 			<< "    --opencl-platform <n>  When mining using -G/--opencl use OpenCL platform n (default: 0)." << endl
 			<< "    --opencl-device <n>  When mining using -G/--opencl use OpenCL device n (default: 0)." << endl
 			<< "    -t, --mining-threads <n> Limit number of CPU/GPU miners to n (default: use everything available on selected platform)" << endl
+			<< "    --use-chunks When using GPU mining upload the DAG to the GPU in 4 chunks. " << endl
 			;
 	}
 
@@ -488,6 +494,7 @@ private:
 	unsigned openclPlatform = 0;
 	unsigned openclDevice = 0;
 	unsigned miningThreads = UINT_MAX;
+	unsigned dagChunks = 1;
 
 	/// DAG initialisation param.
 	unsigned initDAG = 0;

libdevcore/Log.cpp

@@ -33,7 +33,29 @@ using namespace dev;
 
 // Logging
 int dev::g_logVerbosity = 5;
-map<type_info const*, bool> dev::g_logOverride;
+mutex x_logOverride;
+
+/// Map of Log Channel types to bool, false forces the channel to be disabled, true forces it to be enabled.
+/// If a channel has no entry, then it will output as long as its verbosity (LogChannel::verbosity) is less than
+/// or equal to the currently output verbosity (g_logVerbosity).
+static map<type_info const*, bool> s_logOverride;
+
+LogOverrideAux::LogOverrideAux(std::type_info const* _ch, bool _value):
+	m_ch(_ch)
+{
+	Guard l(x_logOverride);
+	m_old = s_logOverride.count(_ch) ? (int)s_logOverride[_ch] : c_null;
+	s_logOverride[m_ch] = _value;
+}
+
+LogOverrideAux::~LogOverrideAux()
+{
+	Guard l(x_logOverride);
+	if (m_old == c_null)
+		s_logOverride.erase(m_ch);
+	else
+		s_logOverride[m_ch] = (bool)m_old;
+}
 
 #ifdef _WIN32
 const char* LogChannel::name() { return EthGray "..."; }
@@ -55,8 +77,9 @@ LogOutputStreamBase::LogOutputStreamBase(char const* _id, std::type_info const*
 	m_autospacing(_autospacing),
 	m_verbosity(_v)
 {
-	auto it = g_logOverride.find(_info);
-	if ((it != g_logOverride.end() && it->second == true) || (it == g_logOverride.end() && (int)_v <= g_logVerbosity))
+	Guard l(x_logOverride);
+	auto it = s_logOverride.find(_info);
+	if ((it != s_logOverride.end() && it->second == true) || (it == s_logOverride.end() && (int)_v <= g_logVerbosity))
 	{
 		time_t rawTime = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
 		char buf[24];

libdevcore/Log.h

@@ -54,10 +54,24 @@ extern int g_logVerbosity;
 /// The current method that the logging system uses to output the log messages. Defaults to simpleDebugOut().
 extern std::function<void(std::string const&, char const*)> g_logPost;
 
-/// Map of Log Channel types to bool, false forces the channel to be disabled, true forces it to be enabled.
-/// If a channel has no entry, then it will output as long as its verbosity (LogChannel::verbosity) is less than
-/// or equal to the currently output verbosity (g_logVerbosity).
-extern std::map<std::type_info const*, bool> g_logOverride;
+class LogOverrideAux
+{
+protected:
+	LogOverrideAux(std::type_info const* _ch, bool _value);
+	~LogOverrideAux();
+
+private:
+	std::type_info const* m_ch;
+	static const int c_null = -1;
+	int m_old;
+};
+
+template <class Channel>
+class LogOverride: LogOverrideAux
+{
+public:
+	LogOverride(bool _value): LogOverrideAux(&typeid(Channel), _value) {}
+};
 
 /// Temporary changes system's verbosity for specific function. Restores the old verbosity when function returns.
 /// Not thread-safe, use with caution!

libethash-cl/ethash_cl_miner.cpp

@@ -24,6 +24,7 @@
 
 #include <cstdio>
 #include <cstdlib>
+#include <fstream>
 #include <iostream>
 #include <assert.h>
 #include <queue>
@@ -173,9 +174,23 @@ void ethash_cl_miner::finish()
 		m_queue.finish();
 }
 
-bool ethash_cl_miner::init(uint8_t const* _dag, uint64_t _dagSize, unsigned workgroup_size, unsigned _platformId, unsigned _deviceId)
+bool ethash_cl_miner::init(
+	uint8_t const* _dag,
+	uint64_t _dagSize,
+	unsigned workgroup_size,
+	unsigned _platformId,
+	unsigned _deviceId,
+	unsigned _dagChunksNum
+)
 {
+	// for now due to the .cl kernels we can only have either 1 big chunk or 4 chunks
+	assert(_dagChunksNum == 1 || _dagChunksNum == 4);
+	// now create the number of chunk buffers
+	m_dagChunksNum = _dagChunksNum;
+
 	// get all platforms
+	try
+	{
 		std::vector<cl::Platform> platforms;
 		cl::Platform::get(&platforms);
 		if (platforms.empty())
@@ -185,9 +200,7 @@ bool ethash_cl_miner::init(uint8_t const* _dag, uint64_t _dagSize, unsigned work
 		}
 
 		// use selected platform
-
 		_platformId = std::min<unsigned>(_platformId, platforms.size() - 1);
-
 		ETHCL_LOG("Using platform: " << platforms[_platformId].getInfo<CL_PLATFORM_NAME>().c_str());
 
 		// get GPU device of the default platform
@@ -220,6 +233,8 @@ bool ethash_cl_miner::init(uint8_t const* _dag, uint64_t _dagSize, unsigned work
 		m_workgroup_size = ((workgroup_size + 7) / 8) * 8;
 
 		// patch source code
+		// note: ETHASH_CL_MINER_KERNEL is simply ethash_cl_miner_kernel.cl compiled
+		// into a byte array by bin2h.cmake. There is no need to load the file by hand in runtime
 		std::string code(ETHASH_CL_MINER_KERNEL, ETHASH_CL_MINER_KERNEL + ETHASH_CL_MINER_KERNEL_SIZE);
 		add_definition(code, "GROUP_SIZE", m_workgroup_size);
 		add_definition(code, "DAG_SIZE", (unsigned)(_dagSize / ETHASH_MIX_BYTES));
@@ -235,43 +250,89 @@ bool ethash_cl_miner::init(uint8_t const* _dag, uint64_t _dagSize, unsigned work
 		try
 		{
 			program.build({ device });
+			ETHCL_LOG("Printing program log");
+			ETHCL_LOG(program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(device).c_str());
 		}
 		catch (cl::Error err)
 		{
 			ETHCL_LOG(program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(device).c_str());
 			return false;
 		}
+		if (_dagChunksNum == 1)
+		{
+			ETHCL_LOG("Loading single big chunk kernels");
 			m_hash_kernel = cl::Kernel(program, "ethash_hash");
 			m_search_kernel = cl::Kernel(program, "ethash_search");
+		}
+		else
+		{
+			ETHCL_LOG("Loading chunk kernels");
+			m_hash_kernel = cl::Kernel(program, "ethash_hash_chunks");
+			m_search_kernel = cl::Kernel(program, "ethash_search_chunks");
+		}
 
 		// create buffer for dag
-	m_dag = cl::Buffer(m_context, CL_MEM_READ_ONLY, _dagSize);
+		if (_dagChunksNum == 1)
+		{
+			ETHCL_LOG("Creating one big buffer");
+			m_dagChunks.push_back(cl::Buffer(m_context, CL_MEM_READ_ONLY, _dagSize));
+		}
+		else
+			for (unsigned i = 0; i < _dagChunksNum; i++)
+			{
+				// TODO Note: If we ever change to _dagChunksNum other than 4, then the size would need recalculation
+				ETHCL_LOG("Creating buffer for chunk " << i);
+				m_dagChunks.push_back(cl::Buffer(
+					m_context,
+					CL_MEM_READ_ONLY,
+					(i == 3) ? (_dagSize - 3 * ((_dagSize >> 9) << 7)) : (_dagSize >> 9) << 7
+				));
+			}
 
 		// create buffer for header
+		ETHCL_LOG("Creating buffer for header.");
 		m_header = cl::Buffer(m_context, CL_MEM_READ_ONLY, 32);
 
-	// compute dag on CPU
-	try {
-		m_queue.enqueueWriteBuffer(m_dag, CL_TRUE, 0, _dagSize, _dag);
+		if (_dagChunksNum == 1)
+		{
+			ETHCL_LOG("Mapping one big chunk.");
+			m_queue.enqueueWriteBuffer(m_dagChunks[0], CL_TRUE, 0, _dagSize, _dag);
+		}
+		else
+		{
+			// TODO Note: If we ever change to _dagChunksNum other than 4, then the size would need recalculation
+			void* dag_ptr[4];
+			for (unsigned i = 0; i < _dagChunksNum; i++)
+			{
+				ETHCL_LOG("Mapping chunk " << i);
+				dag_ptr[i] = m_queue.enqueueMapBuffer(m_dagChunks[i], true, m_opencl_1_1 ? CL_MAP_WRITE : CL_MAP_WRITE_INVALIDATE_REGION, 0, (i == 3) ? (_dagSize - 3 * ((_dagSize >> 9) << 7)) : (_dagSize >> 9) << 7);
 			}
-	catch (...)
+			for (unsigned i = 0; i < _dagChunksNum; i++)
 			{
-		// didn't work. shitty driver. try allocating in CPU RAM and manually memcpying it.
-		void* dag_ptr = m_queue.enqueueMapBuffer(m_dag, true, m_opencl_1_1 ? CL_MAP_WRITE : CL_MAP_WRITE_INVALIDATE_REGION, 0, _dagSize);
-		memcpy(dag_ptr, _dag, _dagSize);
-		m_queue.enqueueUnmapMemObject(m_dag, dag_ptr);
+				memcpy(dag_ptr[i], (char *)_dag + i*((_dagSize >> 9) << 7), (i == 3) ? (_dagSize - 3 * ((_dagSize >> 9) << 7)) : (_dagSize >> 9) << 7);
+				m_queue.enqueueUnmapMemObject(m_dagChunks[i], dag_ptr[i]);
+			}
 		}
 
 		// create mining buffers
 		for (unsigned i = 0; i != c_num_buffers; ++i)
 		{
+			ETHCL_LOG("Creating mining buffer " << i);
 			m_hash_buf[i] = cl::Buffer(m_context, CL_MEM_WRITE_ONLY | (!m_opencl_1_1 ? CL_MEM_HOST_READ_ONLY : 0), 32 * c_hash_batch_size);
 			m_search_buf[i] = cl::Buffer(m_context, CL_MEM_WRITE_ONLY, (c_max_search_results + 1) * sizeof(uint32_t));
 		}
+	}
+	catch (cl::Error err)
+	{
+		ETHCL_LOG(err.what() << "(" << err.err() << ")");
+		return false;
+	}
 	return true;
 }
 
 void ethash_cl_miner::search(uint8_t const* header, uint64_t target, search_hook& hook)
+{
+	try
 	{
 		struct pending_batch
 		{
@@ -280,7 +341,7 @@ void ethash_cl_miner::search(uint8_t const* header, uint64_t target, search_hook
 		};
 		std::queue<pending_batch> pending;
 
-	uint32_t const c_zero = 0;
+		static uint32_t const c_zero = 0;
 
 		// update header constant buffer
 		m_queue.enqueueWriteBuffer(m_header, false, 0, 32, header);
@@ -295,23 +356,13 @@ void ethash_cl_miner::search(uint8_t const* header, uint64_t target, search_hook
 #endif
 			m_queue.finish();
 
-	/*
-	__kernel void ethash_combined_search(
-		__global hash32_t* g_hashes,			// 0
-		__constant hash32_t const* g_header,	// 1
-		__global hash128_t const* g_dag,		// 2
-		ulong start_nonce,						// 3
-		ulong target,							// 4
-		uint isolate							// 5
-	)
-	*/
+		unsigned argPos = 2;
 		m_search_kernel.setArg(1, m_header);
-	m_search_kernel.setArg(2, m_dag);
-
+		for (unsigned i = 0; i < m_dagChunksNum; ++i, ++argPos)
+			m_search_kernel.setArg(argPos, m_dagChunks[i]);
 		// pass these to stop the compiler unrolling the loops
-	m_search_kernel.setArg(4, target);
-	m_search_kernel.setArg(5, ~0u);
-
+		m_search_kernel.setArg(argPos + 1, target);
+		m_search_kernel.setArg(argPos + 2, ~0u);
 
 		unsigned buf = 0;
 		std::random_device engine;
@@ -320,7 +371,10 @@ void ethash_cl_miner::search(uint8_t const* header, uint64_t target, search_hook
 		{
 			// supply output buffer to kernel
 			m_search_kernel.setArg(0, m_search_buf[buf]);
+			if (m_dagChunksNum == 1)
 				m_search_kernel.setArg(3, start_nonce);
+			else
+				m_search_kernel.setArg(6, start_nonce);
 
 			// execute it!
 			m_queue.enqueueNDRangeKernel(m_search_kernel, cl::NullRange, c_search_batch_size, m_workgroup_size);
@@ -339,12 +393,9 @@ void ethash_cl_miner::search(uint8_t const* header, uint64_t target, search_hook
 
 				uint64_t nonces[c_max_search_results];
 				for (unsigned i = 0; i != num_found; ++i)
-			{
 					nonces[i] = batch.start_nonce + results[i + 1];
-			}
 
 				m_queue.enqueueUnmapMemObject(m_search_buf[batch.buf], results);
-			
 				bool exit = num_found && hook.found(nonces, num_found);
 				exit |= hook.searched(batch.start_nonce, c_search_batch_size); // always report searched before exit
 				if (exit)
@@ -364,4 +415,8 @@ void ethash_cl_miner::search(uint8_t const* header, uint64_t target, search_hook
 			pre_return_event.wait();
 #endif
 	}
-
+	catch (cl::Error err)
+	{
+		ETHCL_LOG(err.what() << "(" << err.err() << ")");
+	}
+}

libethash-cl/ethash_cl_miner.h

@@ -37,10 +37,20 @@ public:
 	static std::string platform_info(unsigned _platformId = 0, unsigned _deviceId = 0);
 	static bool haveSufficientGPUMemory(unsigned _platformId = 0);
 
-	bool init(uint8_t const* _dag, uint64_t _dagSize, unsigned workgroup_size = 64, unsigned _platformId = 0, unsigned _deviceId = 0);
+	bool init(
+		uint8_t const* _dag,
+		uint64_t _dagSize,
+		unsigned workgroup_size = 64,
+		unsigned _platformId = 0,
+		unsigned _deviceId = 0,
+		unsigned _dagChunksNum = 1
+	);
 	void finish();
 	void search(uint8_t const* header, uint64_t target, search_hook& hook);
 
+	void hash_chunk(uint8_t* ret, uint8_t const* header, uint64_t nonce, unsigned count);
+	void search_chunk(uint8_t const* header, uint64_t target, search_hook& hook);
+
 private:
 	enum { c_max_search_results = 63, c_num_buffers = 2, c_hash_batch_size = 1024, c_search_batch_size = 1024*256 };
 
@@ -48,7 +58,8 @@ private:
 	cl::CommandQueue m_queue;
 	cl::Kernel m_hash_kernel;
 	cl::Kernel m_search_kernel;
-	cl::Buffer m_dag;
+	unsigned m_dagChunksNum;
+	std::vector<cl::Buffer> m_dagChunks;
 	cl::Buffer m_header;
 	cl::Buffer m_hash_buf[c_num_buffers];
 	cl::Buffer m_search_buf[c_num_buffers];

libethash-cl/ethash_cl_miner_kernel.cl

@@ -243,6 +243,40 @@ hash64_t init_hash(__constant hash32_t const* header, ulong nonce, uint isolate)
 	return init;
 }
 
+uint inner_loop_chunks(uint4 init, uint thread_id, __local uint* share, __global hash128_t const* g_dag, __global hash128_t const* g_dag1, __global hash128_t const* g_dag2, __global hash128_t const* g_dag3, uint isolate)
+{
+	uint4 mix = init;
+
+	// share init0
+	if (thread_id == 0)
+		*share = mix.x;
+	barrier(CLK_LOCAL_MEM_FENCE);
+	uint init0 = *share;
+
+	uint a = 0;
+	do
+	{
+		bool update_share = thread_id == (a/4) % THREADS_PER_HASH;
+
+		#pragma unroll
+		for (uint i = 0; i != 4; ++i)
+		{
+			if (update_share)
+			{
+				uint m[4] = { mix.x, mix.y, mix.z, mix.w };
+				*share = fnv(init0 ^ (a+i), m[i]) % DAG_SIZE;
+			}
+			barrier(CLK_LOCAL_MEM_FENCE);
+
+			mix = fnv4(mix, *share>=3 * DAG_SIZE / 4 ? g_dag3[*share - 3 * DAG_SIZE / 4].uint4s[thread_id] : *share>=DAG_SIZE / 2 ? g_dag2[*share - DAG_SIZE / 2].uint4s[thread_id] : *share>=DAG_SIZE / 4 ? g_dag1[*share - DAG_SIZE / 4].uint4s[thread_id]:g_dag[*share].uint4s[thread_id]);
+		}
+	} while ((a += 4) != (ACCESSES & isolate));
+
+	return fnv_reduce(mix);
+}
+
+
+
 uint inner_loop(uint4 init, uint thread_id, __local uint* share, __global hash128_t const* g_dag, uint isolate)
 {
 	uint4 mix = init;
@@ -276,6 +310,7 @@ uint inner_loop(uint4 init, uint thread_id, __local uint* share, __global hash12
 	return fnv_reduce(mix);
 }
 
+
 hash32_t final_hash(hash64_t const* init, hash32_t const* mix, uint isolate)
 {
 	ulong state[25];
@@ -347,6 +382,7 @@ typedef union
 	hash32_t mix;
 } compute_hash_share;
 
+
 hash32_t compute_hash(
 	__local compute_hash_share* share,
 	__constant hash32_t const* g_header,
@@ -390,6 +426,53 @@ hash32_t compute_hash(
 	return final_hash(&init, &mix, isolate);
 }
 
+
+hash32_t compute_hash_chunks(
+	__local compute_hash_share* share,
+	__constant hash32_t const* g_header,
+	__global hash128_t const* g_dag,
+	__global hash128_t const* g_dag1,
+	__global hash128_t const* g_dag2,
+	__global hash128_t const* g_dag3,
+	ulong nonce,
+	uint isolate
+	)
+{
+	uint const gid = get_global_id(0);
+
+	// Compute one init hash per work item.
+	hash64_t init = init_hash(g_header, nonce, isolate);
+
+	// Threads work together in this phase in groups of 8.
+	uint const thread_id = gid % THREADS_PER_HASH;
+	uint const hash_id = (gid % GROUP_SIZE) / THREADS_PER_HASH;
+
+	hash32_t mix;
+	uint i = 0;
+	do
+	{
+		// share init with other threads
+		if (i == thread_id)
+			share[hash_id].init = init;
+		barrier(CLK_LOCAL_MEM_FENCE);
+
+		uint4 thread_init = share[hash_id].init.uint4s[thread_id % (64 / sizeof(uint4))];
+		barrier(CLK_LOCAL_MEM_FENCE);
+
+		uint thread_mix = inner_loop_chunks(thread_init, thread_id, share[hash_id].mix.uints, g_dag, g_dag1, g_dag2, g_dag3, isolate);
+
+		share[hash_id].mix.uints[thread_id] = thread_mix;
+		barrier(CLK_LOCAL_MEM_FENCE);
+
+		if (i == thread_id)
+			mix = share[hash_id].mix;
+		barrier(CLK_LOCAL_MEM_FENCE);
+	}
+	while (++i != (THREADS_PER_HASH & isolate));
+
+	return final_hash(&init, &mix, isolate);
+}
+
 __attribute__((reqd_work_group_size(GROUP_SIZE, 1, 1)))
 __kernel void ethash_hash_simple(
 	__global hash32_t* g_hashes,
@@ -415,13 +498,15 @@ __kernel void ethash_search_simple(
 {
 	uint const gid = get_global_id(0);
 	hash32_t hash = compute_hash_simple(g_header, g_dag, start_nonce + gid, isolate);
-	if (as_ulong(as_uchar8(hash.ulongs[0]).s76543210) < target)
+
+	if (hash.ulongs[countof(hash.ulongs)-1] < target)
 	{
-		uint slot = min(MAX_OUTPUTS, atomic_inc(&g_output[0]) + 1);
+		uint slot = min(convert_uint(MAX_OUTPUTS), convert_uint(atomic_inc(&g_output[0]) + 1));
 		g_output[slot] = gid;
 	}
 }
 
+
 __attribute__((reqd_work_group_size(GROUP_SIZE, 1, 1)))
 __kernel void ethash_hash(
 	__global hash32_t* g_hashes,
@@ -458,3 +543,46 @@ __kernel void ethash_search(
 		g_output[slot] = gid;
 	}
 }
+
+__attribute__((reqd_work_group_size(GROUP_SIZE, 1, 1)))
+__kernel void ethash_hash_chunks(
+	__global hash32_t* g_hashes,
+	__constant hash32_t const* g_header,
+	__global hash128_t const* g_dag,
+	__global hash128_t const* g_dag1,
+	__global hash128_t const* g_dag2,
+	__global hash128_t const* g_dag3,
+	ulong start_nonce,
+	uint isolate
+	)
+{
+	__local compute_hash_share share[HASHES_PER_LOOP];
+
+	uint const gid = get_global_id(0);
+	g_hashes[gid] = compute_hash_chunks(share, g_header, g_dag, g_dag1, g_dag2, g_dag3,start_nonce + gid, isolate);
+}
+
+__attribute__((reqd_work_group_size(GROUP_SIZE, 1, 1)))
+__kernel void ethash_search_chunks(
+	__global volatile uint* restrict g_output,
+	__constant hash32_t const* g_header,
+	__global hash128_t const* g_dag,
+	__global hash128_t const* g_dag1,
+	__global hash128_t const* g_dag2,
+	__global hash128_t const* g_dag3,
+	ulong start_nonce,
+	ulong target,
+	uint isolate
+	)
+{
+	__local compute_hash_share share[HASHES_PER_LOOP];
+
+	uint const gid = get_global_id(0);
+	hash32_t hash = compute_hash_chunks(share, g_header, g_dag, g_dag1, g_dag2, g_dag3, start_nonce + gid, isolate);
+
+	if (as_ulong(as_uchar8(hash.ulongs[0]).s76543210) < target)
+	{
+		uint slot = min(convert_uint(MAX_OUTPUTS), convert_uint(atomic_inc(&g_output[0]) + 1));
+		g_output[slot] = gid;
+	}
+}

libethcore/Common.cpp

@@ -46,6 +46,12 @@ const unsigned c_databaseBaseVersion = 9;
 const unsigned c_databaseVersionModifier = 0;
 #endif
 
+#if ETH_FRONTIER
+Network const c_network = Network::Frontier;
+#else
+Network const c_network = Network::Olympic;
+#endif
+
 const unsigned c_databaseVersion = c_databaseBaseVersion + (c_databaseVersionModifier << 8) + (ProofOfWork::revision() << 9);
 
 vector<pair<u256, string>> const& units()

libethcore/Common.h

@@ -43,6 +43,14 @@ extern const unsigned c_minorProtocolVersion;
 /// Current database version.
 extern const unsigned c_databaseVersion;
 
+/// The network id.
+enum class Network
+{
+	Olympic = 0,
+	Frontier = 1
+};
+extern const Network c_network;
+
 /// User-friendly string representation of the amount _b in wei.
 std::string formatBalance(bigint const& _b);
 

libethcore/Ethash.cpp

@@ -285,6 +285,7 @@ private:
 unsigned Ethash::GPUMiner::s_platformId = 0;
 unsigned Ethash::GPUMiner::s_deviceId = 0;
 unsigned Ethash::GPUMiner::s_numInstances = 0;
+unsigned Ethash::GPUMiner::s_dagChunks = 1;
 
 Ethash::GPUMiner::GPUMiner(ConstructionInfo const& _ci):
 	Miner(_ci),
@@ -345,7 +346,7 @@ void Ethash::GPUMiner::workLoop()
 				this_thread::sleep_for(chrono::milliseconds(500));
 			}
 			bytesConstRef dagData = dag->data();
-			m_miner->init(dagData.data(), dagData.size(), 32, s_platformId, device);
+			m_miner->init(dagData.data(), dagData.size(), 32, s_platformId, device, s_dagChunks);
 		}
 
 		uint64_t upper64OfBoundary = (uint64_t)(u64)((u256)w.boundary >> 192);

libethcore/Ethash.h

@@ -89,6 +89,7 @@ public:
 		static std::string platformInfo();
 		static bool haveSufficientGPUMemory() { return false; }
 		static void setDefaultPlatform(unsigned) {}
+		static void setDagChunks(unsigned) {}
 		static void setDefaultDevice(unsigned) {}
 		static void setNumInstances(unsigned _instances) { s_numInstances = std::min<unsigned>(_instances, std::thread::hardware_concurrency()); }
 	protected:
@@ -121,6 +122,7 @@ public:
 		static void setDefaultPlatform(unsigned _id) { s_platformId = _id; }
 		static void setDefaultDevice(unsigned _id) { s_deviceId = _id; }
 		static void setNumInstances(unsigned _instances) { s_numInstances = std::min<unsigned>(_instances, getNumDevices()); }
+		static void setDagChunks(unsigned _dagChunks) { s_dagChunks = _dagChunks; }
 
 	protected:
 		void kickOff() override;
@@ -139,6 +141,7 @@ public:
 		static unsigned s_platformId;
 		static unsigned s_deviceId;
 		static unsigned s_numInstances;
+		static unsigned s_dagChunks;
 	};
 #else
 	using GPUMiner = CPUMiner;

libethcore/Params.cpp

@@ -20,6 +20,7 @@
  */
 
 #include "Params.h"
+#include "Common.h"
 
 using namespace std;
 namespace dev
@@ -35,7 +36,7 @@ u256 const c_minGasLimit = 125000;
 u256 const c_gasLimitBoundDivisor = 1024;
 u256 const c_minimumDifficulty = 131072;
 u256 const c_difficultyBoundDivisor = 2048;
-u256 const c_durationLimit = 8;
+u256 const c_durationLimit = c_network == Network::Olympic ? 8 : 12;
 //--- END: AUTOGENERATED FROM /feeStructure.json
 
 }

libethereum/BlockQueue.cpp

@@ -81,7 +81,7 @@ void BlockQueue::verifierBody()
 				res.first.populate(res.second, CheckEverything, work.first);
 				res.first.verifyInternals(&res.second);
 			}
-			catch (InvalidNonce&)
+			catch (InvalidBlockNonce&)
 			{
 				badBlock(res.second, "Invalid block nonce");
 				cwarn << "  Nonce:" << res.first.nonce.hex();

libethereum/CanonBlockChain.cpp

@@ -72,6 +72,7 @@ std::unordered_map<Address, Account> const& dev::eth::genesisState()
 
 std::unique_ptr<BlockInfo> CanonBlockChain::s_genesis;
 boost::shared_mutex CanonBlockChain::x_genesis;
+Nonce CanonBlockChain::s_nonce(u64(42));
 
 bytes CanonBlockChain::createGenesisBlock()
 {
@@ -87,12 +88,33 @@ bytes CanonBlockChain::createGenesisBlock()
 	}
 
 	block.appendList(15)
-			<< h256() << EmptyListSHA3 << h160() << stateRoot << EmptyTrie << EmptyTrie << LogBloom() << c_genesisDifficulty << 0 << c_genesisGasLimit << 0 << (unsigned)0 << string() << h256() << Nonce(u64(42));
+			<< h256() << EmptyListSHA3 << h160() << stateRoot << EmptyTrie << EmptyTrie << LogBloom() << c_genesisDifficulty << 0 << c_genesisGasLimit << 0 << (unsigned)0 << string() << h256() << s_nonce;
 	block.appendRaw(RLPEmptyList);
 	block.appendRaw(RLPEmptyList);
 	return block.out();
 }
 
-CanonBlockChain::CanonBlockChain(std::string const& _path, WithExisting _we, ProgressCallback const& _pc): BlockChain(CanonBlockChain::createGenesisBlock(), _path, _we, _pc)
+CanonBlockChain::CanonBlockChain(std::string const& _path, WithExisting _we, ProgressCallback const& _pc):
+	BlockChain(createGenesisBlock(), _path, _we, _pc)
 {
 }
+
+void CanonBlockChain::setGenesisNonce(Nonce const& _n)
+{
+	WriteGuard l(x_genesis);
+	s_nonce = _n;
+	s_genesis.reset();
+}
+
+BlockInfo const& CanonBlockChain::genesis()
+{
+	UpgradableGuard l(x_genesis);
+	if (!s_genesis)
+	{
+		auto gb = createGenesisBlock();
+		UpgradeGuard ul(l);
+		s_genesis.reset(new BlockInfo);
+		s_genesis->populate(&gb);
+	}
+	return *s_genesis;
+}

libethereum/CanonBlockChain.h

@@ -59,16 +59,22 @@ public:
 	~CanonBlockChain() {}
 
 	/// @returns the genesis block header.
-		static BlockInfo const& genesis() { UpgradableGuard l(x_genesis); if (!s_genesis) { auto gb = createGenesisBlock(); UpgradeGuard ul(l); s_genesis.reset(new BlockInfo); s_genesis->populate(&gb); } return *s_genesis; }
+	static BlockInfo const& 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.
 	static bytes createGenesisBlock();
 
+	/// Alter the value of the genesis block's nonce.
+	/// @warning Unless you're very careful, make sure you call this right at the start of the
+	/// program, before anything has had the chance to use this class at all.
+	static void setGenesisNonce(Nonce const& _n);
+
 private:
 	/// Static genesis info and its lock.
 	static boost::shared_mutex x_genesis;
 	static std::unique_ptr<BlockInfo> s_genesis;
+	static Nonce s_nonce;
 };
 
 }

libethereum/Client.cpp

@@ -47,8 +47,11 @@ VersionChecker::VersionChecker(string const& _dbPath):
 		(void)protocolVersion;
 		auto minorProtocolVersion = (unsigned)status[1];
 		auto databaseVersion = (unsigned)status[2];
+		h256 ourGenesisHash = CanonBlockChain::genesis().hash();
+		auto genesisHash = status.itemCount() > 3 ? (h256)status[3] : ourGenesisHash;
+
 		m_action =
-			databaseVersion != c_databaseVersion ?
+			databaseVersion != c_databaseVersion || genesisHash != ourGenesisHash ?
 				WithExisting::Kill
 			: minorProtocolVersion != eth::c_minorProtocolVersion ?
 				WithExisting::Verify
@@ -73,7 +76,7 @@ void VersionChecker::setOk()
 		{
 			cwarn << "Unhandled exception! Failed to create directory: " << m_path << "\n" << boost::current_exception_diagnostic_information();
 		}
-		writeFile(m_path + "/status", rlpList(eth::c_protocolVersion, eth::c_minorProtocolVersion, c_databaseVersion));
+		writeFile(m_path + "/status", rlpList(eth::c_protocolVersion, eth::c_minorProtocolVersion, c_databaseVersion, CanonBlockChain::genesis().hash()));
 	}
 }
 
@@ -662,7 +665,7 @@ void Client::doWork()
 		syncBlockQueue();
 
 	t = true;
-	if (m_syncTransactionQueue.compare_exchange_strong(t, false) && !m_remoteWorking)
+	if (m_syncTransactionQueue.compare_exchange_strong(t, false) && !m_remoteWorking && !isSyncing())
 		syncTransactionQueue();
 
 	tick();

libethereum/State.cpp

@@ -46,7 +46,7 @@ using namespace dev::eth;
 #define ctrace clog(StateTrace)
 #define ETH_TIMED_ENACTMENTS 0
 
-static const u256 c_blockReward = 1500 * finney;
+static const u256 c_blockReward = c_network == Network::Olympic ? (1500 * finney) : (5 * ether);
 
 const char* StateSafeExceptions::name() { return EthViolet "⚙" EthBlue " ℹ"; }
 const char* StateDetail::name() { return EthViolet "⚙" EthWhite " ◌"; }
@@ -592,24 +592,6 @@ string State::vmTrace(bytesConstRef _block, BlockChain const& _bc, ImportRequire
 	return ss.str();
 }
 
-template <class Channel>
-class LogOverride
-{
-public:
-	LogOverride(bool _value): m_old(g_logOverride.count(&typeid(Channel)) ? (int)g_logOverride[&typeid(Channel)] : c_null) { g_logOverride[&typeid(Channel)] = _value; }
-	~LogOverride()
-	{
-		if (m_old == c_null)
-			g_logOverride.erase(&typeid(Channel));
-		else
-			g_logOverride[&typeid(Channel)] = (bool)m_old;
-	}
-
-private:
-	static const int c_null = -1;
-	int m_old;
-};
-
 u256 State::enact(bytesConstRef _block, BlockChain const& _bc, ImportRequirements::value _ir)
 {
 	// m_currentBlock is assumed to be prepopulated and reset.

libp2p/RLPxHandshake.cpp

@@ -184,7 +184,7 @@ void RLPXHandshake::transition(boost::system::error_code _ech)
 		// old packet format
 		// 5 arguments, HelloPacket
 		RLPStream s;
-		s.append((unsigned)0).appendList(5)
+		s.append((unsigned)HelloPacket).appendList(5)
 		<< dev::p2p::c_protocolVersion
 		<< m_host->m_clientVersion
 		<< m_host->caps()
@@ -205,15 +205,16 @@ void RLPXHandshake::transition(boost::system::error_code _ech)
 		m_nextState = StartSession;
 		
 		// read frame header
-		m_handshakeInBuffer.resize(h256::size);
-		ba::async_read(m_socket->ref(), boost::asio::buffer(m_handshakeInBuffer, h256::size), [this, self](boost::system::error_code ec, std::size_t)
+		unsigned const handshakeSize = 32;
+		m_handshakeInBuffer.resize(handshakeSize);
+		ba::async_read(m_socket->ref(), boost::asio::buffer(m_handshakeInBuffer, handshakeSize), [this, self](boost::system::error_code ec, std::size_t)
 		{
 			if (ec)
 				transition(ec);
 			else
 			{
 				/// authenticate and decrypt header
-				if (!m_io->authAndDecryptHeader(bytesRef(m_handshakeInBuffer.data(), h256::size)))
+				if (!m_io->authAndDecryptHeader(bytesRef(m_handshakeInBuffer.data(), m_handshakeInBuffer.size())))
 				{
 					m_nextState = Error;
 					transition();
@@ -235,7 +236,7 @@ void RLPXHandshake::transition(boost::system::error_code _ech)
 				}
 				
 				/// rlp of header has protocol-type, sequence-id[, total-packet-size]
-				bytes headerRLP(header.size() - 3 - h128::size);
+				bytes headerRLP(header.size() - 3 - h128::size);	// this is always 32 - 3 - 16 = 13. wtf?
 				bytesConstRef(&header).cropped(3).copyTo(&headerRLP);
 				
 				/// read padded frame and mac
@@ -255,8 +256,8 @@ void RLPXHandshake::transition(boost::system::error_code _ech)
 							return;
 						}
 						
-						PacketType packetType = (PacketType)(frame[0] == 0x80 ? 0x0 : frame[0]);
-						if (packetType != 0)
+						PacketType packetType = frame[0] == 0x80 ? HelloPacket : (PacketType)frame[0];
+						if (packetType != HelloPacket)
 						{
 							clog(NetTriviaSummary) << (m_originated ? "p2p.connect.egress" : "p2p.connect.ingress") << "hello frame: invalid packet type";
 							m_nextState = Error;