Drop evaluation by full DAG

Author: chfast

ethminer/MinerAux.h

@@ -596,15 +596,6 @@ class MinerCLI
 	MinerType minerType() const { return m_minerType; }
 
 private:
-	void doInitDAG(unsigned _n)
-	{
-		h256 seedHash = EthashAux::seedHash(_n);
-		cout << "Initializing DAG for epoch beginning #" << (_n / 30000 * 30000) << " (seedhash " << seedHash.abridged() << "). This will take a while." << endl;
-		EthashAux::full(seedHash, true);
-		exit(0);
-	}
-
-
 
 	void doBenchmark(MinerType _m, unsigned _warmupDuration = 15, unsigned _trialDuration = 3, unsigned _trials = 5)
 	{
@@ -787,7 +778,6 @@ class MinerCLI
 			f.start("cuda", false);
 		EthashProofOfWork::WorkPackage current, previous;
 		std::mutex x_current;
-		EthashAux::FullType dag;
 		while (m_running)
 			try
 			{

libdevcore/Common.h

@@ -40,14 +40,8 @@
 #include <boost/multiprecision/cpp_int.hpp>
 #include "vector_ref.h"
 
-// CryptoPP defines byte in the global namespace, so must we.
 using byte = uint8_t;
 
-#define DEV_IGNORE_EXCEPTIONS(X) try { X; } catch (...) {}
-
-#define DEV_IF_NO_ELSE(X) if(!(X)){}else
-#define DEV_IF_THROWS(X) try{X;}catch(...)
-
 namespace dev
 {
 

libethash-cl/ethash_cl_miner.cpp

@@ -33,7 +33,6 @@
 #include <random>
 #include <atomic>
 #include <sstream>
-#include <libethash/util.h>
 #include <libethash/ethash.h>
 #include <libethash/internal.h>
 #include "ethash_cl_miner.h"

libethash/CMakeLists.txt

@@ -2,22 +2,16 @@ if (NOT MSVC)
 	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99")
 endif()
 
-set(FILES 	util.h
-          	io.c
-          	internal.c
-          	ethash.h
-          	endian.h
-          	compiler.h
-          	fnv.h
-          	data_sizes.h)
-
-if (MSVC)
-	list(APPEND FILES util_win32.c io_win32.c mmap_win32.c)
-else()
-	list(APPEND FILES io_posix.c)
-endif()
-
-list(APPEND FILES sha3.c sha3.h)
+set(FILES
+	internal.c
+	ethash.h
+	endian.h
+	compiler.h
+	fnv.h
+	data_sizes.h
+	sha3.c
+	sha3.h
+)
 
 add_library(ethash ${FILES})
 

libethash/ethash.h

@@ -37,8 +37,6 @@
 #define ETHASH_DATASET_PARENTS 256
 #define ETHASH_CACHE_ROUNDS 3
 #define ETHASH_ACCESSES 64
-#define ETHASH_DAG_MAGIC_NUM_SIZE 8
-#define ETHASH_DAG_MAGIC_NUM 0xFEE1DEADBADDCAFE
 
 #ifdef __cplusplus
 extern "C" {
@@ -47,19 +45,8 @@ extern "C" {
 /// Type of a seedhash/blockhash e.t.c.
 typedef struct ethash_h256 { uint8_t b[32]; } ethash_h256_t;
 
-// convenience macro to statically initialize an h256_t
-// usage:
-// ethash_h256_t a = ethash_h256_static_init(1, 2, 3, ... )
-// have to provide all 32 values. If you don't provide all the rest
-// will simply be unitialized (not guranteed to be 0)
-#define ethash_h256_static_init(...)			\
-	{ {__VA_ARGS__} }
-
 struct ethash_light;
 typedef struct ethash_light* ethash_light_t;
-struct ethash_full;
-typedef struct ethash_full* ethash_full_t;
-typedef int(*ethash_callback_t)(unsigned);
 
 typedef struct ethash_return_value {
 	ethash_h256_t result;
@@ -94,49 +81,6 @@ ethash_return_value_t ethash_light_compute(
 	uint64_t nonce
 );
 
-/**
- * Allocate and initialize a new ethash_full handler
- *
- * @param light         The light handler containing the cache.
- * @param callback      A callback function with signature of @ref ethash_callback_t
- *                      It accepts an unsigned with which a progress of DAG calculation
- *                      can be displayed. If all goes well the callback should return 0.
- *                      If a non-zero value is returned then DAG generation will stop.
- *                      Be advised. A progress value of 100 means that DAG creation is
- *                      almost complete and that this function will soon return succesfully.
- *                      It does not mean that the function has already had a succesfull return.
- * @return              Newly allocated ethash_full handler or NULL in case of
- *                      ERRNOMEM or invalid parameters used for @ref ethash_compute_full_data()
- */
-ethash_full_t ethash_full_new(ethash_light_t light, const char * custom_dir_name, ethash_callback_t callback);
-
-/**
- * Frees a previously allocated ethash_full handler
- * @param full    The light handler to free
- */
-void ethash_full_delete(ethash_full_t full);
-/**
- * Calculate the full client data
- *
- * @param full           The full client handler
- * @param header_hash    The header hash to pack into the mix
- * @param nonce          The nonce to pack into the mix
- * @return               An object of ethash_return_value to hold the return value
- */
-ethash_return_value_t ethash_full_compute(
-	ethash_full_t full,
-	ethash_h256_t const header_hash,
-	uint64_t nonce
-);
-/**
- * Get a pointer to the full DAG data
- */
-void const* ethash_full_dag(ethash_full_t full);
-/**
- * Get the size of the DAG data
- */
-uint64_t ethash_full_dag_size(ethash_full_t full);
-
 /**
  * Calculate the seedhash for a given block number
  */

libethash/internal.c

@@ -23,23 +23,12 @@
 #include <assert.h>
 #include <inttypes.h>
 #include <stddef.h>
-#include <errno.h>
-#include <math.h>
-#include "mmap.h"
 #include "ethash.h"
 #include "fnv.h"
 #include "endian.h"
 #include "internal.h"
 #include "data_sizes.h"
-#include "io.h"
-
-#ifdef WITH_CRYPTOPP
-
-#include "sha3_cryptopp.h"
-
-#else
 #include "sha3.h"
-#endif // WITH_CRYPTOPP
 
 uint64_t ethash_get_datasize(uint64_t const block_number)
 {
@@ -142,35 +131,6 @@ void ethash_calculate_dag_item(
 	SHA3_512(ret->bytes, ret->bytes, sizeof(node));
 }
 
-bool ethash_compute_full_data(
-	void* mem,
-	uint64_t full_size,
-	ethash_light_t const light,
-	ethash_callback_t callback
-)
-{
-	if (full_size % (sizeof(uint32_t) * MIX_WORDS) != 0 ||
-		(full_size % sizeof(node)) != 0) {
-		return false;
-	}
-	uint32_t const max_n = (uint32_t)(full_size / sizeof(node));
-	node* full_nodes = mem;
-	double const progress_change = 1.0f / max_n;
-	double progress = 0.0f;
-	// now compute full nodes
-	for (uint32_t n = 0; n != max_n; ++n) {
-		if (callback &&
-			n % (max_n / 100) == 0 &&
-			callback((unsigned int)(ceil(progress * 100.0f))) != 0) {
-
-			return false;
-		}
-		progress += progress_change;
-		ethash_calculate_dag_item(&(full_nodes[n]), n, light);
-	}
-	return true;
-}
-
 static bool ethash_hash(
 	ethash_return_value_t* ret,
 	node const* full_nodes,
@@ -254,22 +214,6 @@ static bool ethash_hash(
 	return true;
 }
 
-void ethash_quick_hash(
-	ethash_h256_t* return_hash,
-	ethash_h256_t const* header_hash,
-	uint64_t const nonce,
-	ethash_h256_t const* mix_hash
-)
-{
-	uint8_t buf[64 + 32];
-	memcpy(buf, header_hash, 32);
-	fix_endian64_same(nonce);
-	memcpy(&(buf[32]), &nonce, 8);
-	SHA3_512(buf, buf, 40);
-	memcpy(&(buf[64]), mix_hash, 32);
-	SHA3_256(return_hash, buf, 64 + 32);
-}
-
 ethash_h256_t ethash_get_seedhash(uint64_t block_number)
 {
 	ethash_h256_t ret;
@@ -280,19 +224,6 @@ ethash_h256_t ethash_get_seedhash(uint64_t block_number)
 	return ret;
 }
 
-bool ethash_quick_check_difficulty(
-	ethash_h256_t const* header_hash,
-	uint64_t const nonce,
-	ethash_h256_t const* mix_hash,
-	ethash_h256_t const* boundary
-)
-{
-
-	ethash_h256_t return_hash;
-	ethash_quick_hash(&return_hash, header_hash, nonce, mix_hash);
-	return ethash_check_difficulty(&return_hash, boundary);
-}
-
 ethash_light_t ethash_light_new_internal(uint64_t cache_size, ethash_h256_t const* seed)
 {
 	struct ethash_light *ret;
@@ -359,153 +290,3 @@ ethash_return_value_t ethash_light_compute(
 	uint64_t full_size = ethash_get_datasize(light->block_number);
 	return ethash_light_compute_internal(light, full_size, header_hash, nonce);
 }
-
-static bool ethash_mmap(struct ethash_full* ret, FILE* f)
-{
-	int fd;
-	char* mmapped_data;
-	errno = 0;
-	ret->file = f;
-	if ((fd = ethash_fileno(ret->file)) == -1) {
-		return false;
-	}
-	mmapped_data = mmap(
-		NULL,
-		(size_t)ret->file_size + ETHASH_DAG_MAGIC_NUM_SIZE,
-		PROT_READ | PROT_WRITE,
-		MAP_SHARED,
-		fd,
-		0
-	);
-	if (mmapped_data == MAP_FAILED) {
-		return false;
-	}
-	ret->data = (node*)(mmapped_data + ETHASH_DAG_MAGIC_NUM_SIZE);
-	return true;
-}
-
-ethash_full_t ethash_full_new_internal(
-	char const* dirname,
-	ethash_h256_t const seed_hash,
-	uint64_t full_size,
-	ethash_light_t const light,
-	ethash_callback_t callback
-)
-{
-	struct ethash_full* ret;
-	FILE *f = NULL;
-	ret = calloc(sizeof(*ret), 1);
-	if (!ret) {
-		return NULL;
-	}
-	ret->file_size = (size_t)full_size;
-	switch (ethash_io_prepare(dirname, seed_hash, &f, (size_t)full_size, false)) {
-	case ETHASH_IO_FAIL:
-		// ethash_io_prepare will do all ETHASH_CRITICAL() logging in fail case
-		goto fail_free_full;
-	case ETHASH_IO_MEMO_MATCH:
-		if (!ethash_mmap(ret, f)) {
-			ETHASH_CRITICAL("mmap failure()");
-			goto fail_close_file;
-		}
-		return ret;
-	case ETHASH_IO_MEMO_SIZE_MISMATCH:
-		// if a DAG of same filename but unexpected size is found, silently force new file creation
-		if (ethash_io_prepare(dirname, seed_hash, &f, (size_t)full_size, true) != ETHASH_IO_MEMO_MISMATCH) {
-			ETHASH_CRITICAL("Could not recreate DAG file after finding existing DAG with unexpected size.");
-			goto fail_free_full;
-		}
-		// fallthrough to the mismatch case here, DO NOT go through match
-	case ETHASH_IO_MEMO_MISMATCH:
-		if (!ethash_mmap(ret, f)) {
-			ETHASH_CRITICAL("mmap failure()");
-			goto fail_close_file;
-		}
-		break;
-	}
-
-	if (!ethash_compute_full_data(ret->data, full_size, light, callback)) {
-		ETHASH_CRITICAL("Failure at computing DAG data.");
-		goto fail_free_full_data;
-	}
-
-	// after the DAG has been filled then we finalize it by writting the magic number at the beginning
-	if (fseek(f, 0, SEEK_SET) != 0) {
-		ETHASH_CRITICAL("Could not seek to DAG file start to write magic number.");
-		goto fail_free_full_data;
-	}
-	uint64_t const magic_num = ETHASH_DAG_MAGIC_NUM;
-	if (fwrite(&magic_num, ETHASH_DAG_MAGIC_NUM_SIZE, 1, f) != 1) {
-		ETHASH_CRITICAL("Could not write magic number to DAG's beginning.");
-		goto fail_free_full_data;
-	}
-	if (fflush(f) != 0) {// make sure the magic number IS there
-		ETHASH_CRITICAL("Could not flush memory mapped data to DAG file. Insufficient space?");
-		goto fail_free_full_data;
-	}
-	return ret;
-
-fail_free_full_data:
-	// could check that munmap(..) == 0 but even if it did not can't really do anything here
-	munmap(ret->data, (size_t)full_size);
-fail_close_file:
-	fclose(ret->file);
-fail_free_full:
-	free(ret);
-	return NULL;
-}
-
-ethash_full_t ethash_full_new(ethash_light_t light, const char * custom_dir_name, ethash_callback_t callback)
-{
-	char strbuf[256];
-
-	if (strcmp(custom_dir_name, "") != 0) 
-		strcpy(strbuf, custom_dir_name);
-	else 
-		if (!ethash_get_default_dirname(strbuf, 256)) {
-			return NULL;
-		}
-	uint64_t full_size = ethash_get_datasize(light->block_number);
-	ethash_h256_t seedhash = ethash_get_seedhash(light->block_number);
-	return ethash_full_new_internal(strbuf, seedhash, full_size, light, callback);
-}
-
-void ethash_full_delete(ethash_full_t full)
-{
-	// could check that munmap(..) == 0 but even if it did not can't really do anything here
-	munmap(full->data, (size_t)full->file_size);
-	if (full->file) {
-		fclose(full->file);
-	}
-	free(full);
-}
-
-ethash_return_value_t ethash_full_compute(
-	ethash_full_t full,
-	ethash_h256_t const header_hash,
-	uint64_t nonce
-)
-{
-	ethash_return_value_t ret;
-	ret.success = true;
-	if (!ethash_hash(
-		&ret,
-		(node const*)full->data,
-		NULL,
-		full->file_size,
-		header_hash,
-		nonce)) {
-		ret.success = false;
-	}
-	return ret;
-}
-
-void const* ethash_full_dag(ethash_full_t full)
-{
-	return full->data;
-}
-
-uint64_t ethash_full_dag_size(ethash_full_t full)
-{
-	return full->file_size;
-}

libethash/internal.h

@@ -31,53 +31,11 @@ typedef union node {
 
 } node;
 
-static inline uint8_t ethash_h256_get(ethash_h256_t const* hash, unsigned int i)
-{
-	return hash->b[i];
-}
-
-static inline void ethash_h256_set(ethash_h256_t* hash, unsigned int i, uint8_t v)
-{
-	hash->b[i] = v;
-}
-
 static inline void ethash_h256_reset(ethash_h256_t* hash)
 {
 	memset(hash, 0, 32);
 }
 
-// Returns if hash is less than or equal to boundary (2^256/difficulty)
-static inline bool ethash_check_difficulty(
-	ethash_h256_t const* hash,
-	ethash_h256_t const* boundary
-)
-{
-	// Boundary is big endian
-	for (int i = 0; i < 32; i++) {
-		if (ethash_h256_get(hash, i) == ethash_h256_get(boundary, i)) {
-			continue;
-		}
-		return ethash_h256_get(hash, i) < ethash_h256_get(boundary, i);
-	}
-	return true;
-}
-
-/**
- *  Difficulty quick check for POW preverification
- *
- * @param header_hash      The hash of the header
- * @param nonce            The block's nonce
- * @param mix_hash         The mix digest hash
- * @param boundary         The boundary is defined as (2^256 / difficulty)
- * @return                 true for succesful pre-verification and false otherwise
- */
-bool ethash_quick_check_difficulty(
-	ethash_h256_t const* header_hash,
-	uint64_t const nonce,
-	ethash_h256_t const* mix_hash,
-	ethash_h256_t const* boundary
-);
-
 struct ethash_light {
 	void* cache;
 	uint64_t cache_size;
@@ -111,69 +69,15 @@ ethash_return_value_t ethash_light_compute_internal(
 	uint64_t nonce
 );
 
-struct ethash_full {
-	FILE* file;
-	uint64_t file_size;
-	node* data;
-};
-
-/**
- * Allocate and initialize a new ethash_full handler. Internal version.
- *
- * @param dirname        The directory in which to put the DAG file.
- * @param seedhash       The seed hash of the block. Used in the DAG file naming.
- * @param full_size      The size of the full data in bytes.
- * @param cache          A cache object to use that was allocated with @ref ethash_cache_new().
- *                       Iff this function succeeds the ethash_full_t will take memory
- *                       memory ownership of the cache and free it at deletion. If
- *                       not then the user still has to handle freeing of the cache himself.
- * @param callback       A callback function with signature of @ref ethash_callback_t
- *                       It accepts an unsigned with which a progress of DAG calculation
- *                       can be displayed. If all goes well the callback should return 0.
- *                       If a non-zero value is returned then DAG generation will stop.
- * @return               Newly allocated ethash_full handler or NULL in case of
- *                       ERRNOMEM or invalid parameters used for @ref ethash_compute_full_data()
- */
-ethash_full_t ethash_full_new_internal(
-	char const* dirname,
-	ethash_h256_t const seed_hash,
-	uint64_t full_size,
-	ethash_light_t const light,
-	ethash_callback_t callback
-);
-
 void ethash_calculate_dag_item(
 	node* const ret,
 	uint32_t node_index,
 	ethash_light_t const cache
 );
 
-void ethash_quick_hash(
-	ethash_h256_t* return_hash,
-	ethash_h256_t const* header_hash,
-	const uint64_t nonce,
-	ethash_h256_t const* mix_hash
-);
-
 uint64_t ethash_get_datasize(uint64_t const block_number);
 uint64_t ethash_get_cachesize(uint64_t const block_number);
 
-/**
- * Compute the memory data for a full node's memory
- *
- * @param mem         A pointer to an ethash full's memory
- * @param full_size   The size of the full data in bytes
- * @param cache       A cache object to use in the calculation
- * @param callback    The callback function. Check @ref ethash_full_new() for details.
- * @return            true if all went fine and false for invalid parameters
- */
-bool ethash_compute_full_data(
-	void* mem,
-	uint64_t full_size,
-	ethash_light_t const light,
-	ethash_callback_t callback
-);
-
 #ifdef __cplusplus
 }
 #endif

libethash/io.c

@@ -20,35 +20,13 @@
  */
 
 #include "EthashAux.h"
-
-#include <boost/detail/endian.hpp>
-#include <chrono>
-#include <array>
-#include <thread>
-#include <libdevcore/Common.h>
-#include <libdevcore/Guards.h>
-#include <libdevcore/Log.h>
-#include <libdevcore/SHA3.h>
 #include <libethash/internal.h>
-#include <libethash/io.h>
-#include "BlockInfo.h"
-#include "Exceptions.h"
 
 using namespace std;
 using namespace chrono;
 using namespace dev;
 using namespace eth;
 
-const char* DAGChannel::name() { return EthGreen "DAG"; }
-
-EthashAux* dev::eth::EthashAux::s_this = nullptr;
-char  dev::eth::EthashAux::s_dagDirName[256] = "";
-
-const unsigned EthashProofOfWork::defaultLocalWorkSize = 64;
-const unsigned EthashProofOfWork::defaultGlobalWorkSizeMultiplier = 4096; // * CL_DEFAULT_LOCAL_WORK_SIZE
-const unsigned EthashProofOfWork::defaultMSPerBatch = 0;
-const EthashProofOfWork::WorkPackage EthashProofOfWork::NullWorkPackage = EthashProofOfWork::WorkPackage();
-
 h256 const& BlockHeaderRaw::seedHash() const
 {
 	if (!m_seedHash)
@@ -58,14 +36,8 @@ h256 const& BlockHeaderRaw::seedHash() const
 
 EthashAux* EthashAux::get()
 {
-    static std::once_flag flag;
-    std::call_once(flag, []{s_this = new EthashAux();});
-    return s_this;
-}
-
-char * EthashAux::dagDirName()
-{
-	return s_dagDirName;
+	static EthashAux instance;
+	return &instance;
 }
 
 h256 EthashAux::seedHash(unsigned _number)
@@ -82,12 +54,8 @@ h256 EthashAux::seedHash(unsigned _number)
 			n = get()->m_seedHashes.size() - 1;
 		}
 		get()->m_seedHashes.resize(epoch + 1);
-//		cdebug << "Searching for seedHash of epoch " << epoch;
 		for (; n <= epoch; ++n, ret = sha3(ret))
-		{
 			get()->m_seedHashes[n] = ret;
-//			cdebug << "Epoch" << n << "is" << ret;
-		}
 	}
 	return get()->m_seedHashes[epoch];
 }
@@ -99,7 +67,6 @@ uint64_t EthashAux::number(h256 const& _seedHash)
 	auto epochIter = get()->m_epochs.find(_seedHash);
 	if (epochIter == get()->m_epochs.end())
 	{
-		//		cdebug << "Searching for seedHash " << _seedHash;
 		for (h256 h; h != _seedHash && epoch < 2048; ++epoch, h = sha3(h), get()->m_epochs[h] = epoch) {}
 		if (epoch == 2048)
 		{
@@ -140,97 +107,6 @@ bytesConstRef EthashAux::LightAllocation::data() const
 	return bytesConstRef((byte const*)light->cache, size);
 }
 
-EthashAux::FullAllocation::FullAllocation(ethash_light_t _light, ethash_callback_t _cb)
-{
-//	cdebug << "About to call ethash_full_new...";
-	full = ethash_full_new(_light, EthashAux::dagDirName(), _cb);
-//	cdebug << "Called OK.";
-	if (!full)
-	{
-		clog(DAGChannel) << "DAG Generation Failure. Reason: "  << strerror(errno);
-		BOOST_THROW_EXCEPTION(ExternalFunctionFailure("ethash_full_new"));
-	}
-}
-
-EthashAux::FullAllocation::~FullAllocation()
-{
-	ethash_full_delete(full);
-}
-
-bytesConstRef EthashAux::FullAllocation::data() const
-{
-	return bytesConstRef((byte const*)ethash_full_dag(full), size());
-}
-
-static std::function<int(unsigned)> s_dagCallback;
-static int dagCallbackShim(unsigned _p)
-{
-	clog(DAGChannel) << "Generating DAG file. Progress: " << toString(_p) << "%";
-	return s_dagCallback ? s_dagCallback(_p) : 0;
-}
-
-EthashAux::FullType EthashAux::full(h256 const& _seedHash, bool _createIfMissing, function<int(unsigned)> const& _f)
-{
-	FullType ret;
-	auto l = light(_seedHash);
-
-	DEV_GUARDED(get()->x_fulls)
-		if ((ret = get()->m_fulls[_seedHash].lock()))
-			return ret;
-
-	if (_createIfMissing || computeFull(_seedHash, false) == 100)
-	{
-		s_dagCallback = _f;
-		ret = make_shared<FullAllocation>(l->light, dagCallbackShim);
-
-		DEV_GUARDED(get()->x_fulls)
-			get()->m_fulls[_seedHash] = ret;
-	}
-
-	return ret;
-}
-
-unsigned EthashAux::computeFull(h256 const& _seedHash, bool _createIfMissing)
-{
-	Guard l(get()->x_fulls);
-	uint64_t blockNumber;
-
-	DEV_IF_THROWS(blockNumber = EthashAux::number(_seedHash))
-	{
-		return 0;
-	}
-
-	if (FullType ret = get()->m_fulls[_seedHash].lock())
-	{
-		return 100;
-	}
-
-	if (_createIfMissing && (!get()->m_fullGenerator || !get()->m_fullGenerator->joinable()))
-	{
-		get()->m_fullProgress = 0;
-		get()->m_generatingFullNumber = blockNumber / ETHASH_EPOCH_LENGTH * ETHASH_EPOCH_LENGTH;
-		get()->m_fullGenerator = unique_ptr<thread>(new thread([=](){
-			cnote << "Loading full DAG of seedhash: " << _seedHash;
-			get()->full(_seedHash, true, [](unsigned p){ get()->m_fullProgress = p; return 0; });
-			cnote << "Full DAG loaded";
-			get()->m_fullProgress = 0;
-			get()->m_generatingFullNumber = NotGenerating;
-		}));
-	}
-
-	return (get()->m_generatingFullNumber == blockNumber) ? get()->m_fullProgress : 0;
-}
-
-
-
-EthashProofOfWork::Result EthashAux::FullAllocation::compute(h256 const& _headerHash, Nonce const& _nonce) const
-{
-	ethash_return_value_t r = ethash_full_compute(full, *(ethash_h256_t*)_headerHash.data(), (uint64_t)(u64)_nonce);
-	if (!r.success)
-		BOOST_THROW_EXCEPTION(DAGCreationFailure());
-	return EthashProofOfWork::Result{h256((uint8_t*)&r.result, h256::ConstructFromPointer), h256((uint8_t*)&r.mix_hash, h256::ConstructFromPointer)};
-}
-
 EthashProofOfWork::Result EthashAux::LightAllocation::compute(h256 const& _headerHash, Nonce const& _nonce) const
 {
 	ethash_return_value r = ethash_light_compute(light, *(ethash_h256_t*)_headerHash.data(), (uint64_t)(u64)_nonce);
@@ -239,13 +115,14 @@ EthashProofOfWork::Result EthashAux::LightAllocation::compute(h256 const& _heade
 	return EthashProofOfWork::Result{h256((uint8_t*)&r.result, h256::ConstructFromPointer), h256((uint8_t*)&r.mix_hash, h256::ConstructFromPointer)};
 }
 
-EthashProofOfWork::Result EthashAux::eval(h256 const& _seedHash, h256 const& _headerHash, Nonce const& _nonce)
+EthashProofOfWork::Result EthashAux::eval(h256 const& _seedHash, h256 const& _headerHash, Nonce const& _nonce) noexcept
 {
-	DEV_GUARDED(get()->x_fulls)
-		if (FullType dag = get()->m_fulls[_seedHash].lock())
-			return dag->compute(_headerHash, _nonce);
-	DEV_IF_THROWS(return EthashAux::get()->light(_seedHash)->compute(_headerHash, _nonce))
+	try
+	{
+		return EthashAux::get()->light(_seedHash)->compute(_headerHash, _nonce);
+	}
+	catch(...)
 	{
-		return EthashProofOfWork::Result{ ~h256(), h256() };
+		return EthashProofOfWork::Result{~h256(), h256()};
 	}
 }

libethash/io.h

@@ -32,8 +32,6 @@ namespace dev
 namespace eth
 {
 
-struct DAGChannel: public LogChannel { static const char* name(); static const int verbosity = 1; };
-
 /// Proof of work definition for Ethash.
 struct EthashProofOfWork
 {
@@ -67,24 +65,6 @@ struct EthashProofOfWork
 		uint64_t startNonce = 0;
 		int exSizeBits = -1;
 	};
-
-	static const WorkPackage NullWorkPackage;
-
-	/// Default value of the local work size. Also known as workgroup size.
-	static const unsigned defaultLocalWorkSize;
-	/// Default value of the global work size as a multiplier of the local work size
-	static const unsigned defaultGlobalWorkSizeMultiplier;
-	/// Default value of the milliseconds per global work size (per batch)
-	static const unsigned defaultMSPerBatch;
-
-};
-
-enum class DAGEraseMode
-{
-	None,
-	Old,
-	Bench,
-	All
 };
 
 class EthashAux
@@ -102,51 +82,20 @@ class EthashAux
 		uint64_t size;
 	};
 
-	struct FullAllocation
-	{
-		FullAllocation(ethash_light_t _light, ethash_callback_t _cb);
-		~FullAllocation();
-		EthashProofOfWork::Result compute(h256 const& _headerHash, Nonce const& _nonce) const;
-		bytesConstRef data() const;
-		uint64_t size() const { return ethash_full_dag_size(full); }
-		ethash_full_t full;
-	};
-
 	using LightType = std::shared_ptr<LightAllocation>;
-	using FullType = std::shared_ptr<FullAllocation>;
 
 	static h256 seedHash(unsigned _number);
 	static uint64_t number(h256 const& _seedHash);
-	static char * dagDirName();
 
 	static LightType light(h256 const& _seedHash);
 
-	static const uint64_t NotGenerating = (uint64_t)-1;
-	/// Kicks off generation of DAG for @a _seedHash and @returns false or @returns true if ready.
-	static unsigned computeFull(h256 const& _seedHash, bool _createIfMissing = true);
-	/// Information on the generation progress.
-	static std::pair<uint64_t, unsigned> fullGeneratingProgress() { return std::make_pair(get()->m_generatingFullNumber, get()->m_fullProgress); }
-	/// Kicks off generation of DAG for @a _blocknumber and blocks until ready; @returns result or empty pointer if not existing and _createIfMissing is false.
-	static FullType full(h256 const& _seedHash, bool _createIfMissing = false, std::function<int(unsigned)> const& _f = std::function<int(unsigned)>());
-	
-
-
-	static EthashProofOfWork::Result eval(h256 const& _seedHash, h256 const& _headerHash, Nonce const& _nonce);
+	static EthashProofOfWork::Result eval(h256 const& _seedHash, h256 const& _headerHash, Nonce const& _nonce) noexcept;
 
 private:
-	EthashAux() {}
-
-	static EthashAux* s_this;
-	static char s_dagDirName[256];
+	EthashAux() = default;
 
 	Mutex x_lights;
-	std::unordered_map<h256, std::shared_ptr<LightAllocation>> m_lights;
-
-	Mutex x_fulls;
-	std::unordered_map<h256, std::weak_ptr<FullAllocation>> m_fulls;
-	std::unique_ptr<std::thread> m_fullGenerator;
-	uint64_t m_generatingFullNumber = NotGenerating;
-	unsigned m_fullProgress;
+	std::unordered_map<h256, LightType> m_lights;
 
 	Mutex x_epochs;
 	std::unordered_map<h256, unsigned> m_epochs;

libethash/io_posix.c

@@ -73,7 +73,6 @@ class EthStratumClientV2 : public Worker
 
 	string m_job;
 	string m_previousJob;
-	EthashAux::FullType m_dag;
 
 	boost::asio::io_service m_io_service;
 	tcp::socket m_socket;