Update ethash

Godeps/Godeps.json

@@ -22,8 +22,8 @@
 		},
 		{
 			"ImportPath": "github.com/ethereum/ethash",
-			"Comment": "v23.1-33-g6ecb8e6",
+			"Comment": "v23.1-72-g0ac34ad",
-			"Rev": "6ecb8e610d60240187b44f61e66b06198c26fae6"
+			"Rev": "0ac34ad51ef0ffdae66b344603bb4e9e2a149b2a"
 		},
 		{
 			"ImportPath": "github.com/ethereum/serpent-go",

Godeps/_workspace/src/github.com/ethereum/ethash/.travis.yml

@@ -1,6 +1,14 @@
+# making our travis.yml play well with C++11 by obtaining g++4.8
+# Taken from this file:
+# https://github.com/beark/ftl/blob/master/.travis.yml
 before_install:
-        - sudo apt-get update -qq
+  - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
-        - sudo apt-get install -qq wget cmake gcc bash libboost-test-dev nodejs python-pip python-dev
+  - sudo apt-get update -y -qq
-        - sudo pip install virtualenv -q
 
+install:
+  - sudo apt-get install -qq --yes --force-yes g++-4.8
+  - sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 50
+  # need to explicitly request version 1.48 since by default we get 1.46 which does not work with C++11
+  - sudo apt-get install -qq wget cmake bash libboost-test1.48-dev libboost-system1.48-dev libboost-filesystem1.48-dev nodejs python-pip python-dev
+  - sudo pip install virtualenv -q
 script: "./test/test.sh"

Godeps/_workspace/src/github.com/ethereum/ethash/CMakeLists.txt

@@ -18,4 +18,4 @@ if (OpenCL_FOUND)
 	add_subdirectory(src/libethash-cl)
 endif()
 add_subdirectory(src/benchmark EXCLUDE_FROM_ALL)
-add_subdirectory(test/c EXCLUDE_FROM_ALL)
+add_subdirectory(test/c)

Godeps/_workspace/src/github.com/ethereum/ethash/ethash.go

@@ -85,7 +85,7 @@ func makeParamsAndCache(chainManager pow.ChainManager, blockNum uint64) (*Params
 		Epoch:  blockNum / epochLength,
 	}
 	C.ethash_params_init(paramsAndCache.params, C.uint32_t(uint32(blockNum)))
-	paramsAndCache.cache.mem = C.malloc(paramsAndCache.params.cache_size)
+	paramsAndCache.cache.mem = C.malloc(C.size_t(paramsAndCache.params.cache_size))
 
 	seedHash, err := GetSeedHash(blockNum)
 	if err != nil {
@@ -100,14 +100,14 @@ func makeParamsAndCache(chainManager pow.ChainManager, blockNum uint64) (*Params
 	return paramsAndCache, nil
 }
 
-func (pow *Ethash) UpdateCache(force bool) error {
+func (pow *Ethash) UpdateCache(blockNum uint64, force bool) error {
 	pow.cacheMutex.Lock()
 	defer pow.cacheMutex.Unlock()
 
-	thisEpoch := pow.chainManager.CurrentBlock().NumberU64() / epochLength
+	thisEpoch := blockNum / epochLength
 	if force || pow.paramsAndCache.Epoch != thisEpoch {
 		var err error
-		pow.paramsAndCache, err = makeParamsAndCache(pow.chainManager, pow.chainManager.CurrentBlock().NumberU64())
+		pow.paramsAndCache, err = makeParamsAndCache(pow.chainManager, blockNum)
 		if err != nil {
 			panic(err)
 		}
@@ -118,7 +118,7 @@ func (pow *Ethash) UpdateCache(force bool) error {
 
 func makeDAG(p *ParamsAndCache) *DAG {
 	d := &DAG{
-		dag:            C.malloc(p.params.full_size),
+		dag:            C.malloc(C.size_t(p.params.full_size)),
 		file:           false,
 		paramsAndCache: p,
 	}
@@ -386,13 +386,13 @@ func (pow *Ethash) verify(hash common.Hash, mixDigest common.Hash, difficulty *b
 	if blockNum/epochLength < pow.paramsAndCache.Epoch {
 		var err error
 		// If we can't make the params for some reason, this block is invalid
-		pAc, err = makeParamsAndCache(pow.chainManager, blockNum)
+		pAc, err = makeParamsAndCache(pow.chainManager, blockNum+1)
 		if err != nil {
-			powlogger.Infoln(err)
+			powlogger.Infoln("big fucking eror", err)
 			return false
 		}
 	} else {
-		pow.UpdateCache(false)
+		pow.UpdateCache(blockNum, false)
 		pow.cacheMutex.RLock()
 		defer pow.cacheMutex.RUnlock()
 		pAc = pow.paramsAndCache

Godeps/_workspace/src/github.com/ethereum/ethash/src/benchmark/CMakeLists.txt

@@ -6,6 +6,11 @@ if (MSVC)
 	add_definitions("/openmp")
 endif()
 
+# enable C++11, should probably be a bit more specific about compiler
+if (NOT MSVC)
+    SET(CMAKE_CXX_FLAGS "-std=c++11")
+endif()
+
 if (NOT MPI_FOUND)
     find_package(MPI)
 endif()

Godeps/_workspace/src/github.com/ethereum/ethash/src/benchmark/benchmark.cpp

@@ -21,7 +21,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-#include <time.h>
+#include <chrono>
 #include <libethash/ethash.h>
 #include <libethash/util.h>
 #ifdef OPENCL
@@ -41,6 +41,8 @@
 #undef min
 #undef max
 
+using std::chrono::high_resolution_clock;
+
 #if defined(OPENCL)
 const unsigned trials = 1024*1024*32;
 #elif defined(FULL)
@@ -122,50 +124,50 @@ extern "C" int main(void)
 	
 	// compute cache or full data
 	{
-		clock_t startTime = clock();
+		auto startTime = high_resolution_clock::now();
 		ethash_mkcache(&cache, &params, seed);
-		clock_t time = clock() - startTime;
+		auto time = std::chrono::duration_cast<std::chrono::milliseconds>(high_resolution_clock::now() - startTime).count();
 
 		uint8_t cache_hash[32];
 		SHA3_256(cache_hash, (uint8_t const*)cache_mem, params.cache_size);
-		debugf("ethash_mkcache: %ums, sha3: %s\n", (unsigned)((time*1000)/CLOCKS_PER_SEC), bytesToHexString(cache_hash,sizeof(cache_hash)).data());
+		debugf("ethash_mkcache: %ums, sha3: %s\n", (unsigned)time, bytesToHexString(cache_hash,sizeof(cache_hash)).data());
 
 		// print a couple of test hashes
 		{
-			const clock_t startTime = clock();
+			auto startTime = high_resolution_clock::now();
 			ethash_return_value hash;
 			ethash_light(&hash, &cache, &params, previous_hash, 0);
-			const clock_t time = clock() - startTime;
+			auto time = std::chrono::duration_cast<std::chrono::milliseconds>(high_resolution_clock::now() - startTime).count();
-			debugf("ethash_light test: %ums, %s\n", (unsigned)((time*1000)/CLOCKS_PER_SEC), bytesToHexString(hash.result, 32).data());
+			debugf("ethash_light test: %ums, %s\n", (unsigned)time, bytesToHexString(hash.result, 32).data());
 		}
 
 		#ifdef FULL
-			startTime = clock();
+			startTime = high_resolution_clock::now();
 			ethash_compute_full_data(full_mem, &params, &cache);
-			time = clock() - startTime;
+			time = std::chrono::duration_cast<std::chrono::milliseconds>(high_resolution_clock::now() - startTime).count();
-			debugf("ethash_compute_full_data: %ums\n", (unsigned)((time*1000)/CLOCKS_PER_SEC));
+			debugf("ethash_compute_full_data: %ums\n", (unsigned)time);
 		#endif // FULL
 	}
 
 #ifdef OPENCL
 	ethash_cl_miner miner;
 	{
-		const clock_t startTime = clock();
+		auto startTime = high_resolution_clock::now();
 		if (!miner.init(params, seed))
 			exit(-1);
-		const clock_t time = clock() - startTime;
+		auto time = std::chrono::duration_cast<std::chrono::milliseconds>(high_resolution_clock::now() - startTime).count();
-        debugf("ethash_cl_miner init: %ums\n", (unsigned)((time*1000)/CLOCKS_PER_SEC));
+        debugf("ethash_cl_miner init: %ums\n", (unsigned)time);
 	}
 #endif
 
 
 #ifdef FULL
     {
-        const clock_t startTime = clock();
+        auto startTime = high_resolution_clock::now();
 		ethash_return_value hash;
         ethash_full(&hash, full_mem, &params, previous_hash, 0);
-        const clock_t time = clock() - startTime;
+        auto time = std::chrono::duration_cast<std::chrono::milliseconds>(high_resolution_clock::now() - startTime).count();
-        debugf("ethash_full test: %uns, %s\n", (unsigned)((time*1000000)/CLOCKS_PER_SEC), bytesToHexString(hash.result, 32).data());
+        debugf("ethash_full test: %uns, %s\n", (unsigned)time);
     }
 #endif
 
@@ -186,10 +188,12 @@ extern "C" int main(void)
 			}
 		}
 	}
+	
+	// ensure nothing else is going on
+	miner.finish();
 #endif
 
-
+	auto startTime = high_resolution_clock::now();
-	clock_t startTime = clock();
 	unsigned hash_count = trials;
 	
 	#ifdef OPENCL
@@ -201,7 +205,7 @@ extern "C" int main(void)
 
 			virtual bool found(uint64_t const* nonces, uint32_t count)
 			{
-				nonce_vec.assign(nonces, nonces + count);
+				nonce_vec.insert(nonce_vec.end(), nonces, nonces + count);
 				return false;
 			}
 
@@ -241,15 +245,23 @@ extern "C" int main(void)
 		}
 	}
 	#endif
-	
+	auto time = std::chrono::duration_cast<std::chrono::microseconds>(high_resolution_clock::now() - startTime).count();
-	clock_t time = std::max((clock_t)1u, clock() - startTime);
+	debugf("Search took: %ums\n", (unsigned)time/1000);
-	
+
 	unsigned read_size = ACCESSES * MIX_BYTES;
-	debugf(			
+#if defined(OPENCL) || defined(FULL)
-		"hashrate: %8u, bw: %6u MB/s\n",
+	debugf(
-		(unsigned)(((uint64_t)hash_count*CLOCKS_PER_SEC)/time),
+		"hashrate: %8.2f Mh/s, bw: %8.2f GB/s\n",
-		(unsigned)((((uint64_t)hash_count*read_size*CLOCKS_PER_SEC)/time) / (1024*1024))
+		(double)hash_count * (1000*1000)/time / (1000*1000),
+		(double)hash_count*read_size * (1000*1000)/time / (1024*1024*1024)
 		);
+#else
+	debugf(
+		"hashrate: %8.2f Kh/s, bw: %8.2f MB/s\n",
+		(double)hash_count * (1000*1000)/time / (1000),
+		(double)hash_count*read_size * (1000*1000)/time / (1024*1024)
+		);
+#endif
 
 	free(cache_mem_buf);
 #ifdef FULL

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/CMakeLists.txt

@@ -1,3 +1,5 @@
+cmake_minimum_required(VERSION 2.8)
+
 set(LIBRARY ethash-cl)
 set(CMAKE_BUILD_TYPE Release)
 
@@ -28,11 +30,16 @@ if (NOT MSVC)
     endif ()
 endif()
 
+set(OpenCL_FOUND TRUE)
+set(OpenCL_INCLUDE_DIRS /usr/include/CL)
+set(OpenCL_LIBRARIES -lOpenCL)
+
 if (NOT OpenCL_FOUND)
 	find_package(OpenCL)
 endif()
 
 if (OpenCL_FOUND)
+	set(CMAKE_CXX_FLAGS "-std=c++11 -Wall -Wno-unknown-pragmas -Wextra -Werror -pedantic -fPIC ${CMAKE_CXX_FLAGS}")
 	include_directories(${OpenCL_INCLUDE_DIRS} ${CMAKE_CURRENT_BINARY_DIR})
 	include_directories(..)
 	add_library(${LIBRARY} ethash_cl_miner.cpp ethash_cl_miner.h cl.hpp)

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/ethash_cl_miner.cpp

@@ -22,6 +22,8 @@
 
 #define _CRT_SECURE_NO_WARNINGS
 
+#include <cstdio>
+#include <cstdlib>
 #include <assert.h>
 #include <queue>
 #include <vector>
@@ -52,6 +54,14 @@ ethash_cl_miner::ethash_cl_miner()
 {
 }
 
+void ethash_cl_miner::finish()
+{
+	if (m_queue())
+	{
+		m_queue.finish();
+	}
+}
+
 bool ethash_cl_miner::init(ethash_params const& params, const uint8_t seed[32], unsigned workgroup_size)
 {
 	// store params
@@ -95,7 +105,7 @@ bool ethash_cl_miner::init(ethash_params const& params, const uint8_t seed[32],
 	}
 
 	// create context
-	m_context = cl::Context(std::vector<cl::Device>(&device, &device+1));
+	m_context = cl::Context(std::vector<cl::Device>(&device, &device + 1));
 	m_queue = cl::CommandQueue(m_context, device);
 
 	// use requested workgroup size, but we require multiple of 8
@@ -308,6 +318,10 @@ void ethash_cl_miner::search(uint8_t const* header, uint64_t target, search_hook
 			if (exit)
 				break;
 
+			// reset search buffer if we're still going
+			if (num_found)
+				m_queue.enqueueWriteBuffer(m_search_buf[batch.buf], true, 0, 4, &c_zero);
+
 			pending.pop();
 		}
 	}

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/ethash_cl_miner.h

@@ -21,6 +21,7 @@ public:
 
 	bool init(ethash_params const& params, const uint8_t seed[32], unsigned workgroup_size = 64);
 
+	void finish();
 	void hash(uint8_t* ret, uint8_t const* header, uint64_t nonce, unsigned count);
 	void search(uint8_t const* header, uint64_t target, search_hook& hook);
 

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/CMakeLists.txt

@@ -12,6 +12,7 @@ endif()
 
 set(FILES 	util.c
           	util.h
+          	io.c
           	internal.c
           	ethash.h
           	endian.h
@@ -19,6 +20,12 @@ set(FILES 	util.c
           	fnv.h
           	data_sizes.h)
 
+if (MSVC)
+	list(APPEND FILES io_win32.c)
+else()
+	list(APPEND FILES io_posix.c)
+endif()
+
 if (NOT CRYPTOPP_FOUND)
 	find_package(CryptoPP 5.6.2)
 endif()

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/data_sizes.h

@@ -48,7 +48,7 @@ extern "C" {
 //             Sow[i*HashBytes]; j++]]]][[2]][[1]]
 
 
-static const size_t dag_sizes[2048] = {
+static const uint64_t dag_sizes[2048] = {
         1073739904U, 1082130304U, 1090514816U, 1098906752U, 1107293056U,
         1115684224U, 1124070016U, 1132461952U, 1140849536U, 1149232768U,
         1157627776U, 1166013824U, 1174404736U, 1182786944U, 1191180416U,
@@ -477,7 +477,7 @@ static const size_t dag_sizes[2048] = {
 //         While[! PrimeQ[i], i--];
 //         Sow[i*HashBytes]; j++]]]][[2]][[1]]
 
-const size_t cache_sizes[2048] = {
+const uint64_t cache_sizes[2048] = {
         16776896U, 16907456U, 17039296U, 17170112U, 17301056U, 17432512U, 17563072U,
         17693888U, 17824192U, 17955904U, 18087488U, 18218176U, 18349504U, 18481088U,
         18611392U, 18742336U, 18874304U, 19004224U, 19135936U, 19267264U, 19398208U,

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/ethash.h

@@ -43,26 +43,26 @@ extern "C" {
 #endif
 
 typedef struct ethash_params {
-    size_t full_size;               // Size of full data set (in bytes, multiple of mix size (128)).
+	uint64_t full_size;               // Size of full data set (in bytes, multiple of mix size (128)).
-    size_t cache_size;              // Size of compute cache (in bytes, multiple of node size (64)).
+	uint64_t cache_size;              // Size of compute cache (in bytes, multiple of node size (64)).
 } ethash_params;
 
 typedef struct ethash_return_value {
-    uint8_t result[32];
+	uint8_t result[32];
-    uint8_t mix_hash[32];
+	uint8_t mix_hash[32];
 } ethash_return_value;
 
-size_t ethash_get_datasize(const uint32_t block_number);
+uint64_t ethash_get_datasize(const uint32_t block_number);
-size_t ethash_get_cachesize(const uint32_t block_number);
+uint64_t ethash_get_cachesize(const uint32_t block_number);
 
 // initialize the parameters
 static inline void ethash_params_init(ethash_params *params, const uint32_t block_number) {
-    params->full_size = ethash_get_datasize(block_number);
+	params->full_size = ethash_get_datasize(block_number);
-    params->cache_size = ethash_get_cachesize(block_number);
+	params->cache_size = ethash_get_cachesize(block_number);
 }
 
 typedef struct ethash_cache {
-    void *mem;
+	void *mem;
 } ethash_cache;
 
 void ethash_mkcache(ethash_cache *cache, ethash_params const *params, const uint8_t seed[32]);
@@ -72,44 +72,51 @@ void ethash_light(ethash_return_value *ret, ethash_cache const *cache, ethash_pa
 void ethash_get_seedhash(uint8_t seedhash[32], const uint32_t block_number);
 
 static inline void ethash_prep_light(void *cache, ethash_params const *params, const uint8_t seed[32]) {
-    ethash_cache c;
+	ethash_cache c;
-    c.mem = cache;
+	c.mem = cache;
-    ethash_mkcache(&c, params, seed);
+	ethash_mkcache(&c, params, seed);
 }
 
 static inline void ethash_compute_light(ethash_return_value *ret, void const *cache, ethash_params const *params, const uint8_t header_hash[32], const uint64_t nonce) {
-    ethash_cache c;
+	ethash_cache c;
-    c.mem = (void *) cache;
+	c.mem = (void *) cache;
-    ethash_light(ret, &c, params, header_hash, nonce);
+	ethash_light(ret, &c, params, header_hash, nonce);
 }
 
 static inline void ethash_prep_full(void *full, ethash_params const *params, void const *cache) {
-    ethash_cache c;
+	ethash_cache c;
-    c.mem = (void *) cache;
+	c.mem = (void *) cache;
-    ethash_compute_full_data(full, params, &c);
+	ethash_compute_full_data(full, params, &c);
 }
 
 static inline void ethash_compute_full(ethash_return_value *ret, void const *full, ethash_params const *params, const uint8_t header_hash[32], const uint64_t nonce) {
-    ethash_full(ret, full, params, header_hash, nonce);
+	ethash_full(ret, full, params, header_hash, nonce);
 }
 
-// Returns if hash is less than or equal to difficulty
+/// @brief Compare two s256-bit big-endian values.
-static inline int ethash_check_difficulty(
+/// @returns 1 if @a a is less than or equal to @a b, 0 otherwise.
-        const uint8_t hash[32],
+/// Both parameters are 256-bit big-endian values.
-        const uint8_t difficulty[32]) {
+static inline int ethash_leq_be256(const uint8_t a[32], const uint8_t b[32]) {
-    // Difficulty is big endian
+	// Boundary is big endian
-    for (int i = 0; i < 32; i++) {
+	for (int i = 0; i < 32; i++) {
-        if (hash[i] == difficulty[i]) continue;
+		if (a[i] == b[i])
-        return hash[i] < difficulty[i];
+			continue;
-    }
+		return a[i] < b[i];
-    return 1;
+	}
+	return 1;
 }
 
-int ethash_quick_check_difficulty(
+/// Perofrms a cursory check on the validity of the nonce.
-        const uint8_t header_hash[32],
+/// @returns 1 if the nonce may possibly be valid for the given header_hash & boundary.
-        const uint64_t nonce,
+/// @p boundary equivalent to 2 ^ 256 / block_difficulty, represented as a 256-bit big-endian.
-        const uint8_t mix_hash[32],
+int ethash_preliminary_check_boundary(
-        const uint8_t difficulty[32]);
+	const uint8_t header_hash[32],
+	const uint64_t nonce,
+	const uint8_t mix_hash[32],
+	const uint8_t boundary[32]);
+
+#define ethash_quick_check_difficulty ethash_preliminary_check_boundary
+#define ethash_check_difficulty ethash_leq_be256
 
 #ifdef __cplusplus
 }

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/internal.c

@@ -37,12 +37,12 @@
 #include "sha3.h"
 #endif // WITH_CRYPTOPP
 
-size_t ethash_get_datasize(const uint32_t block_number) {
+uint64_t ethash_get_datasize(const uint32_t block_number) {
     assert(block_number / EPOCH_LENGTH < 2048);
     return dag_sizes[block_number / EPOCH_LENGTH];
 }
 
-size_t ethash_get_cachesize(const uint32_t block_number) {
+uint64_t ethash_get_cachesize(const uint32_t block_number) {
     assert(block_number / EPOCH_LENGTH < 2048);
     return cache_sizes[block_number / EPOCH_LENGTH];
 }
@@ -280,15 +280,15 @@ void ethash_get_seedhash(uint8_t seedhash[32], const uint32_t block_number) {
         SHA3_256(seedhash, seedhash, 32);
 }
 
-int ethash_quick_check_difficulty(
+int ethash_preliminary_check_boundary(
         const uint8_t header_hash[32],
         const uint64_t nonce,
         const uint8_t mix_hash[32],
-        const uint8_t difficulty[32]) {
+		const uint8_t difficulty[32]) {
 
-    uint8_t return_hash[32];
+	uint8_t return_hash[32];
     ethash_quick_hash(return_hash, header_hash, nonce, mix_hash);
-    return ethash_check_difficulty(return_hash, difficulty);
+	return ethash_leq_be256(return_hash, difficulty);
 }
 
 void ethash_full(ethash_return_value *ret, void const *full_mem, ethash_params const *params, const uint8_t previous_hash[32], const uint64_t nonce) {
@@ -297,4 +297,4 @@ void ethash_full(ethash_return_value *ret, void const *full_mem, ethash_params c
 
 void ethash_light(ethash_return_value *ret, ethash_cache const *cache, ethash_params const *params, const uint8_t previous_hash[32], const uint64_t nonce) {
     ethash_hash(ret, NULL, cache, params, previous_hash, nonce);
-}
+}

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/io.c

@@ -0,0 +1,89 @@
+/*
+  This file is part of ethash.
+
+  ethash is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  ethash is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ethash.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file io.c
+ * @author Lefteris Karapetsas <lefteris@ethdev.com>
+ * @date 2015
+ */
+#include "io.h"
+#include <string.h>
+#include <stdio.h>
+
+// silly macro to save some typing
+#define PASS_ARR(c_) (c_), sizeof(c_)
+
+static bool ethash_io_write_file(char const *dirname,
+                                 char const* filename,
+                                 size_t filename_length,
+                                 void const* data,
+                                 size_t data_size)
+{
+    bool ret = false;
+    char *fullname = ethash_io_create_filename(dirname, filename, filename_length);
+    if (!fullname) {
+        return false;
+    }
+    FILE *f = fopen(fullname, "wb");
+    if (!f) {
+        goto free_name;
+    }
+    if (data_size != fwrite(data, 1, data_size, f)) {
+        goto close;
+    }
+
+    ret = true;
+close:
+    fclose(f);
+free_name:
+    free(fullname);
+    return ret;
+}
+
+bool ethash_io_write(char const *dirname,
+                     ethash_params const* params,
+                     ethash_blockhash_t seedhash,
+                     void const* cache,
+                     uint8_t **data,
+                     uint64_t *data_size)
+{
+    char info_buffer[DAG_MEMO_BYTESIZE];
+    // allocate the bytes
+    uint8_t *temp_data_ptr = malloc((size_t)params->full_size);
+    if (!temp_data_ptr) {
+        goto end;
+    }
+    ethash_compute_full_data(temp_data_ptr, params, cache);
+
+    if (!ethash_io_write_file(dirname, PASS_ARR(DAG_FILE_NAME), temp_data_ptr, (size_t)params->full_size)) {
+        goto fail_free;
+    }
+
+    ethash_io_serialize_info(REVISION, seedhash, info_buffer);
+    if (!ethash_io_write_file(dirname, PASS_ARR(DAG_MEMO_NAME), info_buffer, DAG_MEMO_BYTESIZE)) {
+        goto fail_free;
+    }
+
+    *data = temp_data_ptr;
+    *data_size = params->full_size;
+    return true;
+
+fail_free:
+    free(temp_data_ptr);
+end:
+    return false;
+}
+
+#undef PASS_ARR

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/io.h

@@ -0,0 +1,116 @@
+/*
+  This file is part of ethash.
+
+  ethash is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  ethash is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ethash.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file io.h
+ * @author Lefteris Karapetsas <lefteris@ethdev.com>
+ * @date 2015
+ */
+#pragma once
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include "ethash.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct ethash_blockhash { uint8_t b[32]; } ethash_blockhash_t;
+
+static const char DAG_FILE_NAME[] = "full";
+static const char DAG_MEMO_NAME[] = "full.info";
+// MSVC thinks that "static const unsigned int" is not a compile time variable. Sorry for the #define :(
+#define DAG_MEMO_BYTESIZE 36
+
+/// Possible return values of @see ethash_io_prepare
+enum ethash_io_rc {
+    ETHASH_IO_FAIL = 0,      ///< There has been an IO failure
+    ETHASH_IO_MEMO_MISMATCH, ///< Memo file either did not exist or there was content mismatch
+    ETHASH_IO_MEMO_MATCH,    ///< Memo file existed and contents matched. No need to do anything
+};
+
+/**
+ * Prepares io for ethash
+ *
+ * Create the DAG directory if it does not exist, and check if the memo file matches.
+ * If it does not match then it's deleted to pave the way for @ref ethash_io_write()
+ *
+ * @param dirname        A null terminated c-string of the path of the ethash
+ *                       data directory. If it does not exist it's created.
+ * @param seedhash       The seedhash of the current block number
+ * @return               For possible return values @see enum ethash_io_rc
+ */
+enum ethash_io_rc ethash_io_prepare(char const *dirname, ethash_blockhash_t seedhash);
+/**
+ * Fully computes data and writes it to the file on disk.
+ *
+ * This function should be called after @see ethash_io_prepare() and only if
+ * its return value is @c ETHASH_IO_MEMO_MISMATCH. Will write both the full data
+ * and the memo file.
+ *
+ * @param[in] dirname        A null terminated c-string of the path of the ethash
+ *                           data directory. Has to exist.
+ * @param[in] params         An ethash_params object containing the full size
+ *                           and the cache size
+ * @param[in] seedhash       The seedhash of the current block number
+ * @param[in] cache          The cache data. Would have usually been calulated by
+ *                           @see ethash_prep_light().
+ * @param[out] data          Pass a pointer to uint8_t by reference here. If the
+ *                           function is succesfull then this point to the allocated
+ *                           data calculated by @see ethash_prep_full(). Memory
+ *                           ownership is transfered to the callee. Remember that
+ *                           you eventually need to free this with a call to free().
+ * @param[out] data_size     Pass a uint64_t by value. If the function is succesfull
+ *                           then this will contain the number of bytes allocated
+ *                           for @a data.
+ * @return                   True for success and false in case of failure.
+ */
+bool ethash_io_write(char const *dirname,
+                     ethash_params const* params,
+                     ethash_blockhash_t seedhash,
+                     void const* cache,
+                     uint8_t **data,
+                     uint64_t *data_size);
+
+static inline void ethash_io_serialize_info(uint32_t revision,
+                                            ethash_blockhash_t seed_hash,
+                                            char *output)
+{
+    // if .info is only consumed locally we don't really care about endianess
+    memcpy(output, &revision, 4);
+    memcpy(output + 4, &seed_hash, 32);
+}
+
+static inline char *ethash_io_create_filename(char const *dirname,
+                                              char const* filename,
+                                              size_t filename_length)
+{
+    // in C the cast is not needed, but a C++ compiler will complain for invalid conversion
+    char *name = (char*)malloc(strlen(dirname) + filename_length);
+    if (!name) {
+        return NULL;
+    }
+
+    name[0] = '\0';
+    strcat(name, dirname);
+    strcat(name, filename);
+    return name;
+}
+
+
+#ifdef __cplusplus
+}
+#endif

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/io_posix.c

@@ -0,0 +1,76 @@
+/*
+  This file is part of ethash.
+
+  ethash is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  ethash is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ethash.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file io_posix.c
+ * @author Lefteris Karapetsas <lefteris@ethdev.com>
+ * @date 2015
+ */
+
+#include "io.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <libgen.h>
+#include <stdio.h>
+#include <unistd.h>
+
+enum ethash_io_rc ethash_io_prepare(char const *dirname, ethash_blockhash_t seedhash)
+{
+    char read_buffer[DAG_MEMO_BYTESIZE];
+    char expect_buffer[DAG_MEMO_BYTESIZE];
+    enum ethash_io_rc ret = ETHASH_IO_FAIL;
+
+    // assert directory exists, full owner permissions and read/search for others
+    int rc = mkdir(dirname, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
+    if (rc == -1 && errno != EEXIST) {
+        goto end;
+    }
+
+    char *memofile = ethash_io_create_filename(dirname, DAG_MEMO_NAME, sizeof(DAG_MEMO_NAME));
+    if (!memofile) {
+        goto end;
+    }
+
+    // try to open memo file
+    FILE *f = fopen(memofile, "rb");
+    if (!f) {
+        // file does not exist, so no checking happens. All is fine.
+        ret = ETHASH_IO_MEMO_MISMATCH;
+        goto free_memo;
+    }
+
+    if (fread(read_buffer, 1, DAG_MEMO_BYTESIZE, f) != DAG_MEMO_BYTESIZE) {
+        goto close;
+    }
+
+    ethash_io_serialize_info(REVISION, seedhash, expect_buffer);
+    if (memcmp(read_buffer, expect_buffer, DAG_MEMO_BYTESIZE) != 0) {
+        // we have different memo contents so delete the memo file
+        if (unlink(memofile) != 0) {
+            goto close;
+        }
+        ret = ETHASH_IO_MEMO_MISMATCH;
+    }
+
+    ret = ETHASH_IO_MEMO_MATCH;
+
+close:
+    fclose(f);
+free_memo:
+    free(memofile);
+end:
+    return ret;
+}

Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/io_win32.c

@@ -0,0 +1,73 @@
+/*
+  This file is part of ethash.
+
+  ethash is free software: you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation, either version 3 of the License, or
+  (at your option) any later version.
+
+  ethash is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with ethash.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/** @file io_win32.c
+ * @author Lefteris Karapetsas <lefteris@ethdev.com>
+ * @date 2015
+ */
+
+#include "io.h"
+#include <direct.h>
+#include <errno.h>
+#include <stdio.h>
+
+enum ethash_io_rc ethash_io_prepare(char const *dirname, ethash_blockhash_t seedhash)
+{
+    char read_buffer[DAG_MEMO_BYTESIZE];
+    char expect_buffer[DAG_MEMO_BYTESIZE];
+    enum ethash_io_rc ret = ETHASH_IO_FAIL;
+
+    // assert directory exists
+    int rc = _mkdir(dirname);
+    if (rc == -1 && errno != EEXIST) {
+        goto end;
+    }
+
+    char *memofile = ethash_io_create_filename(dirname, DAG_MEMO_NAME, sizeof(DAG_MEMO_NAME));
+    if (!memofile) {
+        goto end;
+    }
+
+    // try to open memo file
+    FILE *f = fopen(memofile, "rb");
+    if (!f) {
+        // file does not exist, so no checking happens. All is fine.
+        ret = ETHASH_IO_MEMO_MISMATCH;
+        goto free_memo;
+    }
+
+    if (fread(read_buffer, 1, DAG_MEMO_BYTESIZE, f) != DAG_MEMO_BYTESIZE) {
+        goto close;
+    }
+
+    ethash_io_serialize_info(REVISION, seedhash, expect_buffer);
+    if (memcmp(read_buffer, expect_buffer, DAG_MEMO_BYTESIZE) != 0) {
+        // we have different memo contents so delete the memo file
+        if (_unlink(memofile) != 0) {
+            goto close;
+        }
+        ret = ETHASH_IO_MEMO_MISMATCH;
+    }
+
+    ret = ETHASH_IO_MEMO_MATCH;
+
+close:
+    fclose(f);
+free_memo:
+    free(memofile);
+end:
+    return ret;
+}

Godeps/_workspace/src/github.com/ethereum/ethash/src/python/core.c

@@ -5,6 +5,14 @@
 #include <time.h>
 #include "../libethash/ethash.h"
 
+#if PY_MAJOR_VERSION >= 3
+#define PY_STRING_FORMAT "y#"
+#define PY_CONST_STRING_FORMAT "y"
+#else
+#define PY_STRING_FORMAT "s#"
+#define PY_CONST_STRING_FORMAT "s"
+#endif
+
 #define MIX_WORDS (MIX_BYTES/4)
 
 static PyObject *
@@ -46,7 +54,7 @@ mkcache_bytes(PyObject *self, PyObject *args) {
     unsigned long cache_size;
     int seed_len;
 
-    if (!PyArg_ParseTuple(args, "ks#", &cache_size, &seed, &seed_len))
+    if (!PyArg_ParseTuple(args, "k" PY_STRING_FORMAT, &cache_size, &seed, &seed_len))
         return 0;
 
     if (seed_len != 32) {
@@ -62,7 +70,7 @@ mkcache_bytes(PyObject *self, PyObject *args) {
     ethash_cache cache;
     cache.mem = malloc(cache_size);
     ethash_mkcache(&cache, &params, (uint8_t *) seed);
-    PyObject * val = Py_BuildValue("s#", cache.mem, cache_size);
+    PyObject * val = Py_BuildValue(PY_STRING_FORMAT, cache.mem, cache_size);
     free(cache.mem);
     return val;
 }
@@ -74,7 +82,7 @@ calc_dataset_bytes(PyObject *self, PyObject *args) {
     unsigned long full_size;
     int cache_size;
 
-    if (!PyArg_ParseTuple(args, "ks#", &full_size, &cache_bytes, &cache_size))
+    if (!PyArg_ParseTuple(args, "k" PY_STRING_FORMAT, &full_size, &cache_bytes, &cache_size))
         return 0;
 
     if (full_size % MIX_WORDS != 0) {
@@ -98,7 +106,7 @@ calc_dataset_bytes(PyObject *self, PyObject *args) {
     cache.mem = (void *) cache_bytes;
     void *mem = malloc(params.full_size);
     ethash_compute_full_data(mem, &params, &cache);
-    PyObject * val = Py_BuildValue("s#", (char *) mem, full_size);
+    PyObject * val = Py_BuildValue(PY_STRING_FORMAT, (char *) mem, full_size);
     free(mem);
     return val;
 }
@@ -111,7 +119,7 @@ hashimoto_light(PyObject *self, PyObject *args) {
     unsigned long long nonce;
     int cache_size, header_size;
 
-    if (!PyArg_ParseTuple(args, "ks#s#K", &full_size, &cache_bytes, &cache_size, &header, &header_size, &nonce))
+    if (!PyArg_ParseTuple(args, "k" PY_STRING_FORMAT PY_STRING_FORMAT "K", &full_size, &cache_bytes, &cache_size, &header, &header_size, &nonce))
         return 0;
 
     if (full_size % MIX_WORDS != 0) {
@@ -143,7 +151,7 @@ hashimoto_light(PyObject *self, PyObject *args) {
     ethash_cache cache;
     cache.mem = (void *) cache_bytes;
     ethash_light(&out, &cache, &params, (uint8_t *) header, nonce);
-    return Py_BuildValue("{s:s#,s:s#}",
+    return Py_BuildValue("{" PY_CONST_STRING_FORMAT ":" PY_STRING_FORMAT "," PY_CONST_STRING_FORMAT ":" PY_STRING_FORMAT "}",
             "mix digest", out.mix_hash, 32,
             "result", out.result, 32);
 }
@@ -155,7 +163,7 @@ hashimoto_full(PyObject *self, PyObject *args) {
     unsigned long long nonce;
     int full_size, header_size;
 
-    if (!PyArg_ParseTuple(args, "s#s#K", &full_bytes, &full_size, &header, &header_size, &nonce))
+    if (!PyArg_ParseTuple(args, PY_STRING_FORMAT PY_STRING_FORMAT "K", &full_bytes, &full_size, &header, &header_size, &nonce))
         return 0;
 
     if (full_size % MIX_WORDS != 0) {
@@ -177,7 +185,7 @@ hashimoto_full(PyObject *self, PyObject *args) {
     ethash_params params;
     params.full_size = (size_t) full_size;
     ethash_full(&out, (void *) full_bytes, &params, (uint8_t *) header, nonce);
-    return Py_BuildValue("{s:s#, s:s#}",
+    return Py_BuildValue("{" PY_CONST_STRING_FORMAT ":" PY_STRING_FORMAT ", " PY_CONST_STRING_FORMAT ":" PY_STRING_FORMAT "}",
             "mix digest", out.mix_hash, 32,
             "result", out.result, 32);
 }
@@ -190,7 +198,7 @@ mine(PyObject *self, PyObject *args) {
     uint64_t nonce = ((uint64_t) rand()) << 32 | rand();
     int full_size, header_size, difficulty_size;
 
-    if (!PyArg_ParseTuple(args, "s#s#s#", &full_bytes, &full_size, &header, &header_size, &difficulty, &difficulty_size))
+    if (!PyArg_ParseTuple(args, PY_STRING_FORMAT PY_STRING_FORMAT PY_STRING_FORMAT, &full_bytes, &full_size, &header, &header_size, &difficulty, &difficulty_size))
         return 0;
 
     if (full_size % MIX_WORDS != 0) {
@@ -224,7 +232,7 @@ mine(PyObject *self, PyObject *args) {
         // TODO: disagrees with the spec https://github.com/ethereum/wiki/wiki/Ethash#mining
     } while (!ethash_check_difficulty(out.result, (const uint8_t *) difficulty));
 
-    return Py_BuildValue("{s:s#, s:s#, s:K}",
+    return Py_BuildValue("{" PY_CONST_STRING_FORMAT ":" PY_STRING_FORMAT ", " PY_CONST_STRING_FORMAT ":" PY_STRING_FORMAT ", " PY_CONST_STRING_FORMAT ":K}",
             "mix digest", out.mix_hash, 32,
             "result", out.result, 32,
             "nonce", nonce);
@@ -245,7 +253,7 @@ get_seedhash(PyObject *self, PyObject *args) {
     }
     uint8_t seedhash[32];
     ethash_get_seedhash(seedhash, block_number);
-    return Py_BuildValue("s#", (char *) seedhash, 32);
+    return Py_BuildValue(PY_STRING_FORMAT, (char *) seedhash, 32);
 }
 
 static PyMethodDef PyethashMethods[] =
@@ -287,6 +295,32 @@ static PyMethodDef PyethashMethods[] =
                 {NULL, NULL, 0, NULL}
         };
 
+#if PY_MAJOR_VERSION >= 3
+static struct PyModuleDef PyethashModule = {
+    PyModuleDef_HEAD_INIT,
+    "pyethash",
+    "...",
+    -1,
+    PyethashMethods
+};
+
+PyMODINIT_FUNC PyInit_pyethash(void) {
+    PyObject *module =  PyModule_Create(&PyethashModule);
+    // Following Spec: https://github.com/ethereum/wiki/wiki/Ethash#definitions
+    PyModule_AddIntConstant(module, "REVISION", (long) REVISION);
+    PyModule_AddIntConstant(module, "DATASET_BYTES_INIT", (long) DATASET_BYTES_INIT);
+    PyModule_AddIntConstant(module, "DATASET_BYTES_GROWTH", (long) DATASET_BYTES_GROWTH);
+    PyModule_AddIntConstant(module, "CACHE_BYTES_INIT", (long) CACHE_BYTES_INIT);
+    PyModule_AddIntConstant(module, "CACHE_BYTES_GROWTH", (long) CACHE_BYTES_GROWTH);
+    PyModule_AddIntConstant(module, "EPOCH_LENGTH", (long) EPOCH_LENGTH);
+    PyModule_AddIntConstant(module, "MIX_BYTES", (long) MIX_BYTES);
+    PyModule_AddIntConstant(module, "HASH_BYTES", (long) HASH_BYTES);
+    PyModule_AddIntConstant(module, "DATASET_PARENTS", (long) DATASET_PARENTS);
+    PyModule_AddIntConstant(module, "CACHE_ROUNDS", (long) CACHE_ROUNDS);
+    PyModule_AddIntConstant(module, "ACCESSES", (long) ACCESSES);
+    return module;
+}
+#else
 PyMODINIT_FUNC
 initpyethash(void) {
     PyObject *module = Py_InitModule("pyethash", PyethashMethods);
@@ -303,3 +337,4 @@ initpyethash(void) {
     PyModule_AddIntConstant(module, "CACHE_ROUNDS", (long) CACHE_ROUNDS);
     PyModule_AddIntConstant(module, "ACCESSES", (long) ACCESSES);
 }
+#endif

Godeps/_workspace/src/github.com/ethereum/ethash/test/c/CMakeLists.txt

@@ -1,5 +1,30 @@
+if (MSVC)
+    if (NOT BOOST_ROOT)
+        set (BOOST_ROOT "$ENV{BOOST_ROOT}")
+    endif()
+    set (CMAKE_PREFIX_PATH BOOST_ROOT)
+endif()
+
 IF( NOT Boost_FOUND )
-    find_package(Boost COMPONENTS unit_test_framework)
+    # use multithreaded boost libraries, with -mt suffix
+    set(Boost_USE_MULTITHREADED ON)
+
+    if (MSVC)
+        # TODO handle other msvc versions or it will fail find them
+        set(Boost_COMPILER -vc120)
+        # use static boost libraries *.lib
+        set(Boost_USE_STATIC_LIBS ON)
+    elseif (APPLE)
+
+        # use static boost libraries *.a
+        set(Boost_USE_STATIC_LIBS ON)
+
+    elseif (UNIX)
+        # use dynamic boost libraries .dll
+        set(Boost_USE_STATIC_LIBS OFF)
+
+    endif()
+    find_package(Boost 1.48.0 COMPONENTS unit_test_framework system filesystem)
 ENDIF()
 
 IF( Boost_FOUND )
@@ -8,21 +33,29 @@ IF( Boost_FOUND )
 
     link_directories ( ${Boost_LIBRARY_DIRS} )
     file(GLOB HEADERS "*.h")
-    ADD_DEFINITIONS(-DBOOST_TEST_DYN_LINK)
+    if (NOT MSVC)
-
+        ADD_DEFINITIONS(-DBOOST_TEST_DYN_LINK)
+    endif()
     if (NOT CRYPTOPP_FOUND)
-	    find_package (CryptoPP)
+        find_package (CryptoPP)
     endif()
 
     if (CRYPTOPP_FOUND)
-	    add_definitions(-DWITH_CRYPTOPP)
+        add_definitions(-DWITH_CRYPTOPP)
     endif()
 
+   if (NOT MSVC)
+        set(CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS} -std=c++11 ")
+   endif()
+
     add_executable (Test test.cpp ${HEADERS})
-    target_link_libraries (Test ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY} ${ETHHASH_LIBS})
+    target_link_libraries(Test ${ETHHASH_LIBS})
+    target_link_libraries(Test ${Boost_FILESYSTEM_LIBRARIES})
+    target_link_libraries(Test ${Boost_SYSTEM_LIBRARIES})
+    target_link_libraries (Test ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
 
     if (CRYPTOPP_FOUND)
-	    TARGET_LINK_LIBRARIES(Test ${CRYPTOPP_LIBRARIES})
+        TARGET_LINK_LIBRARIES(Test ${CRYPTOPP_LIBRARIES})
     endif()
 
     enable_testing ()

Godeps/_workspace/src/github.com/ethereum/ethash/test/c/test.cpp

@@ -2,6 +2,7 @@
 #include <libethash/fnv.h>
 #include <libethash/ethash.h>
 #include <libethash/internal.h>
+#include <libethash/io.h>
 
 #ifdef WITH_CRYPTOPP
 
@@ -14,13 +15,23 @@
 #define BOOST_TEST_MODULE Daggerhashimoto
 #define BOOST_TEST_MAIN
 
-#include <boost/test/unit_test.hpp>
 #include <iostream>
+#include <fstream>
+#include <vector>
+#include <boost/filesystem.hpp>
+#include <boost/test/unit_test.hpp>
 
-std::string bytesToHexString(const uint8_t *str, const size_t s) {
+using namespace std;
+namespace fs = boost::filesystem;
+
+// Just an alloca "wrapper" to silence uint64_t to size_t conversion warnings in windows
+// consider replacing alloca calls with something better though!
+#define our_alloca(param__) alloca((size_t)(param__))
+
+std::string bytesToHexString(const uint8_t *str, const uint64_t s) {
     std::ostringstream ret;
 
-    for (int i = 0; i < s; ++i)
+    for (size_t i = 0; i < s; ++i)
         ret << std::hex << std::setfill('0') << std::setw(2) << std::nouppercase << (int) str[i];
 
     return ret.str();
@@ -108,9 +119,9 @@ BOOST_AUTO_TEST_CASE(light_and_full_client_checks) {
     params.cache_size = 1024;
     params.full_size = 1024 * 32;
     ethash_cache cache;
-    cache.mem = alloca(params.cache_size);
+    cache.mem = our_alloca(params.cache_size);
     ethash_mkcache(&cache, &params, seed);
-    node *full_mem = (node *) alloca(params.full_size);
+    node *full_mem = (node *) our_alloca(params.full_size);
     ethash_compute_full_data(full_mem, &params, &cache);
 
     {
@@ -225,4 +236,147 @@ BOOST_AUTO_TEST_CASE(ethash_check_difficulty_check) {
     BOOST_REQUIRE_MESSAGE(
             !ethash_check_difficulty(hash, target),
             "\nexpected \"" << hash << "\" to have more difficulty than \"" << target << "\"\n");
-}
+}
+
+BOOST_AUTO_TEST_CASE(test_ethash_dir_creation) {
+    ethash_blockhash_t seedhash;
+    memset(&seedhash, 0, 32);
+    BOOST_REQUIRE_EQUAL(
+        ETHASH_IO_MEMO_MISMATCH,
+        ethash_io_prepare("./test_ethash_directory/", seedhash)
+    );
+
+    // let's make sure that the directory was created
+    BOOST_REQUIRE(fs::is_directory(fs::path("./test_ethash_directory/")));
+
+    // cleanup
+    fs::remove_all("./test_ethash_directory/");
+}
+
+BOOST_AUTO_TEST_CASE(test_ethash_io_write_files_are_created) {
+    ethash_blockhash_t seedhash;
+    static const int blockn = 0;
+    ethash_get_seedhash((uint8_t*)&seedhash, blockn);
+    BOOST_REQUIRE_EQUAL(
+        ETHASH_IO_MEMO_MISMATCH,
+        ethash_io_prepare("./test_ethash_directory/", seedhash)
+    );
+
+ // let's make sure that the directory was created
+    BOOST_REQUIRE(fs::is_directory(fs::path("./test_ethash_directory/")));
+
+    ethash_cache cache;
+    ethash_params params;
+    uint8_t *data;
+    uint64_t size;
+    ethash_params_init(&params, blockn);
+    params.cache_size = 1024;
+    params.full_size = 1024 * 32;
+    cache.mem = our_alloca(params.cache_size);
+    ethash_mkcache(&cache, &params, (uint8_t*)&seedhash);
+
+    BOOST_REQUIRE(
+        ethash_io_write("./test_ethash_directory/", &params, seedhash, &cache, &data, &size)
+    );
+
+    BOOST_REQUIRE(fs::exists(fs::path("./test_ethash_directory/full")));
+    BOOST_REQUIRE(fs::exists(fs::path("./test_ethash_directory/full.info")));
+
+    // cleanup
+    fs::remove_all("./test_ethash_directory/");
+    free(data);
+}
+
+BOOST_AUTO_TEST_CASE(test_ethash_io_memo_file_match) {
+    ethash_blockhash_t seedhash;
+    static const int blockn = 0;
+    ethash_get_seedhash((uint8_t*)&seedhash, blockn);
+    BOOST_REQUIRE_EQUAL(
+        ETHASH_IO_MEMO_MISMATCH,
+        ethash_io_prepare("./test_ethash_directory/", seedhash)
+    );
+
+    // let's make sure that the directory was created
+    BOOST_REQUIRE(fs::is_directory(fs::path("./test_ethash_directory/")));
+
+    ethash_cache cache;
+    ethash_params params;
+    uint8_t *data;
+    uint64_t size;
+    ethash_params_init(&params, blockn);
+    params.cache_size = 1024;
+    params.full_size = 1024 * 32;
+    cache.mem = our_alloca(params.cache_size);
+    ethash_mkcache(&cache, &params, (uint8_t*)&seedhash);
+
+    BOOST_REQUIRE(
+        ethash_io_write("./test_ethash_directory/", &params, seedhash, &cache, &data, &size)
+    );
+
+    BOOST_REQUIRE(fs::exists(fs::path("./test_ethash_directory/full")));
+    BOOST_REQUIRE(fs::exists(fs::path("./test_ethash_directory/full.info")));
+
+    BOOST_REQUIRE_EQUAL(
+        ETHASH_IO_MEMO_MATCH,
+        ethash_io_prepare("./test_ethash_directory/", seedhash)
+    );
+
+    // cleanup
+    fs::remove_all("./test_ethash_directory/");
+    free(data);
+}
+
+// could have used dev::contentsNew but don't wanna try to import
+// libdevcore just for one function
+static std::vector<char> readFileIntoVector(char const* filename)
+{
+    ifstream ifs(filename, ios::binary|ios::ate);
+    ifstream::pos_type pos = ifs.tellg();
+
+    std::vector<char> result((unsigned int)pos);
+
+    ifs.seekg(0, ios::beg);
+    ifs.read(&result[0], pos);
+
+    return result;
+}
+
+BOOST_AUTO_TEST_CASE(test_ethash_io_memo_file_contents) {
+    ethash_blockhash_t seedhash;
+    static const int blockn = 0;
+    ethash_get_seedhash((uint8_t*)&seedhash, blockn);
+    BOOST_REQUIRE_EQUAL(
+        ETHASH_IO_MEMO_MISMATCH,
+        ethash_io_prepare("./test_ethash_directory/", seedhash)
+    );
+
+    // let's make sure that the directory was created
+    BOOST_REQUIRE(fs::is_directory(fs::path("./test_ethash_directory/")));
+
+    ethash_cache cache;
+    ethash_params params;
+    uint8_t *data;
+    uint64_t size;
+    ethash_params_init(&params, blockn);
+    params.cache_size = 1024;
+    params.full_size = 1024 * 32;
+    cache.mem = our_alloca(params.cache_size);
+    ethash_mkcache(&cache, &params, (uint8_t*)&seedhash);
+
+    BOOST_REQUIRE(
+        ethash_io_write("./test_ethash_directory/", &params, seedhash, &cache, &data, &size)
+    );
+
+    BOOST_REQUIRE(fs::exists(fs::path("./test_ethash_directory/full")));
+    BOOST_REQUIRE(fs::exists(fs::path("./test_ethash_directory/full.info")));
+
+    char expect_buffer[DAG_MEMO_BYTESIZE];
+    ethash_io_serialize_info(REVISION, seedhash, expect_buffer);
+    auto vec = readFileIntoVector("./test_ethash_directory/full.info");
+    BOOST_REQUIRE_EQUAL(vec.size(), DAG_MEMO_BYTESIZE);
+    BOOST_REQUIRE(memcmp(expect_buffer, &vec[0], DAG_MEMO_BYTESIZE) == 0);
+
+    // cleanup
+    fs::remove_all("./test_ethash_directory/");
+    free(data);
+}

Godeps/_workspace/src/github.com/ethereum/ethash/test/go/test.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-
-# Strict mode
-set -e
-
-SOURCE="${BASH_SOURCE[0]}"
-while [ -h "$SOURCE" ]; do
-  DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
-  SOURCE="$(readlink "$SOURCE")"
-  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE"
-done
-TEST_DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
-
-export GOPATH=${HOME}/.go
-export PATH=$PATH:$GOPATH/bin 
-echo "# getting go dependencies (can take some time)..."
-cd ${TEST_DIR}/../.. && go get 
-cd ${GOPATH}/src/github.com/ethereum/go-ethereum
-git checkout poc-9
-cd ${TEST_DIR} && go test

eth/backend.go

@@ -296,7 +296,7 @@ func (s *Ethereum) PeersInfo() (peersinfo []*PeerInfo) {
 
 func (s *Ethereum) ResetWithGenesisBlock(gb *types.Block) {
 	s.chainManager.ResetWithGenesisBlock(gb)
-	s.pow.UpdateCache(true)
+	s.pow.UpdateCache(0, true)
 }
 
 func (s *Ethereum) StartMining() error {