diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json index 4c8c8281e..bc7ece021 100644 --- a/Godeps/Godeps.json +++ b/Godeps/Godeps.json @@ -22,8 +22,8 @@ }, { "ImportPath": "github.com/ethereum/ethash", - "Comment": "v23.1-33-g6ecb8e6", - "Rev": "6ecb8e610d60240187b44f61e66b06198c26fae6" + "Comment": "v23.1-72-g0ac34ad", + "Rev": "0ac34ad51ef0ffdae66b344603bb4e9e2a149b2a" }, { "ImportPath": "github.com/ethereum/serpent-go", diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/.travis.yml b/Godeps/_workspace/src/github.com/ethereum/ethash/.travis.yml index 4b929eb69..30e944a68 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/.travis.yml +++ b/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 apt-get install -qq wget cmake gcc bash libboost-test-dev nodejs python-pip python-dev - - sudo pip install virtualenv -q + - sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test + - sudo apt-get update -y -qq +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" diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/CMakeLists.txt b/Godeps/_workspace/src/github.com/ethereum/ethash/CMakeLists.txt index 79f2e5335..ea8c1849a 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/CMakeLists.txt +++ b/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) diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/ethash.go b/Godeps/_workspace/src/github.com/ethereum/ethash/ethash.go index 8746aaca9..6327e4c66 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/ethash.go +++ b/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 diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/src/benchmark/CMakeLists.txt b/Godeps/_workspace/src/github.com/ethereum/ethash/src/benchmark/CMakeLists.txt index e6ba85790..840fe5146 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/src/benchmark/CMakeLists.txt +++ b/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() diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/src/benchmark/benchmark.cpp b/Godeps/_workspace/src/github.com/ethereum/ethash/src/benchmark/benchmark.cpp index 7dae4f18c..17e9e1b7a 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/src/benchmark/benchmark.cpp +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/src/benchmark/benchmark.cpp @@ -21,7 +21,7 @@ #include #include -#include +#include #include #include #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, ¶ms, seed); - clock_t time = clock() - startTime; + auto time = std::chrono::duration_cast(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, ¶ms, previous_hash, 0); - const clock_t time = clock() - startTime; - debugf("ethash_light test: %ums, %s\n", (unsigned)((time*1000)/CLOCKS_PER_SEC), bytesToHexString(hash.result, 32).data()); + auto time = std::chrono::duration_cast(high_resolution_clock::now() - startTime).count(); + 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, ¶ms, &cache); - time = clock() - startTime; - debugf("ethash_compute_full_data: %ums\n", (unsigned)((time*1000)/CLOCKS_PER_SEC)); + time = std::chrono::duration_cast(high_resolution_clock::now() - startTime).count(); + 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; - debugf("ethash_cl_miner init: %ums\n", (unsigned)((time*1000)/CLOCKS_PER_SEC)); + auto time = std::chrono::duration_cast(high_resolution_clock::now() - startTime).count(); + 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, ¶ms, previous_hash, 0); - const clock_t time = clock() - startTime; - debugf("ethash_full test: %uns, %s\n", (unsigned)((time*1000000)/CLOCKS_PER_SEC), bytesToHexString(hash.result, 32).data()); + auto time = std::chrono::duration_cast(high_resolution_clock::now() - startTime).count(); + 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 - - clock_t startTime = clock(); + auto startTime = high_resolution_clock::now(); 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 - - clock_t time = std::max((clock_t)1u, clock() - startTime); - + auto time = std::chrono::duration_cast(high_resolution_clock::now() - startTime).count(); + debugf("Search took: %ums\n", (unsigned)time/1000); + unsigned read_size = ACCESSES * MIX_BYTES; - debugf( - "hashrate: %8u, bw: %6u MB/s\n", - (unsigned)(((uint64_t)hash_count*CLOCKS_PER_SEC)/time), - (unsigned)((((uint64_t)hash_count*read_size*CLOCKS_PER_SEC)/time) / (1024*1024)) +#if defined(OPENCL) || defined(FULL) + debugf( + "hashrate: %8.2f Mh/s, bw: %8.2f GB/s\n", + (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 diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/CMakeLists.txt b/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/CMakeLists.txt index f37471cf3..30fa7ed4b 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/CMakeLists.txt +++ b/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) diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/ethash_cl_miner.cpp b/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/ethash_cl_miner.cpp index d3f0e9611..e668f0622 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/ethash_cl_miner.cpp +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/ethash_cl_miner.cpp @@ -22,6 +22,8 @@ #define _CRT_SECURE_NO_WARNINGS +#include +#include #include #include #include @@ -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(&device, &device+1)); + m_context = cl::Context(std::vector(&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(); } } diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/ethash_cl_miner.h b/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/ethash_cl_miner.h index 3fb98b5b7..7889989e3 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/ethash_cl_miner.h +++ b/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); diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/CMakeLists.txt b/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/CMakeLists.txt index 38fc821c0..c92240086 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/CMakeLists.txt +++ b/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() diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/data_sizes.h b/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/data_sizes.h index 3b747b3ea..cf52ae4f8 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/data_sizes.h +++ b/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, diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/ethash.h b/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/ethash.h index a7159de65..eb3097307 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/ethash.h +++ b/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)). - size_t cache_size; // Size of compute cache (in bytes, multiple of node size (64)). + uint64_t full_size; // Size of full data set (in bytes, multiple of mix size (128)). + 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 mix_hash[32]; + uint8_t result[32]; + uint8_t mix_hash[32]; } ethash_return_value; -size_t ethash_get_datasize(const uint32_t block_number); -size_t ethash_get_cachesize(const uint32_t block_number); +uint64_t ethash_get_datasize(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->cache_size = ethash_get_cachesize(block_number); + params->full_size = ethash_get_datasize(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; - c.mem = cache; - ethash_mkcache(&c, params, seed); + ethash_cache c; + c.mem = cache; + 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; - c.mem = (void *) cache; - ethash_light(ret, &c, params, header_hash, nonce); + ethash_cache c; + c.mem = (void *) cache; + 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; - c.mem = (void *) cache; - ethash_compute_full_data(full, params, &c); + ethash_cache c; + c.mem = (void *) cache; + 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 -static inline int ethash_check_difficulty( - const uint8_t hash[32], - const uint8_t difficulty[32]) { - // Difficulty is big endian - for (int i = 0; i < 32; i++) { - if (hash[i] == difficulty[i]) continue; - return hash[i] < difficulty[i]; - } - return 1; +/// @brief Compare two s256-bit big-endian values. +/// @returns 1 if @a a is less than or equal to @a b, 0 otherwise. +/// Both parameters are 256-bit big-endian values. +static inline int ethash_leq_be256(const uint8_t a[32], const uint8_t b[32]) { + // Boundary is big endian + for (int i = 0; i < 32; i++) { + if (a[i] == b[i]) + continue; + return a[i] < b[i]; + } + return 1; } -int ethash_quick_check_difficulty( - const uint8_t header_hash[32], - const uint64_t nonce, - const uint8_t mix_hash[32], - const uint8_t difficulty[32]); +/// Perofrms a cursory check on the validity of the nonce. +/// @returns 1 if the nonce may possibly be valid for the given header_hash & boundary. +/// @p boundary equivalent to 2 ^ 256 / block_difficulty, represented as a 256-bit big-endian. +int ethash_preliminary_check_boundary( + 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 } diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/internal.c b/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/internal.c index 0a7e767e7..ae9b95065 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/internal.c +++ b/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); -} \ No newline at end of file +} diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/io.c b/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/io.c new file mode 100644 index 000000000..5a8eebae5 --- /dev/null +++ b/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 . +*/ +/** @file io.c + * @author Lefteris Karapetsas + * @date 2015 + */ +#include "io.h" +#include +#include + +// 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 diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/io.h b/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/io.h new file mode 100644 index 000000000..dd611754d --- /dev/null +++ b/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 . +*/ +/** @file io.h + * @author Lefteris Karapetsas + * @date 2015 + */ +#pragma once +#include +#include +#include +#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 diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/io_posix.c b/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/io_posix.c new file mode 100644 index 000000000..693bdf750 --- /dev/null +++ b/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 . +*/ +/** @file io_posix.c + * @author Lefteris Karapetsas + * @date 2015 + */ + +#include "io.h" +#include +#include +#include +#include +#include +#include + +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; +} diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/io_win32.c b/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/io_win32.c new file mode 100644 index 000000000..2cabc939a --- /dev/null +++ b/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 . +*/ +/** @file io_win32.c + * @author Lefteris Karapetsas + * @date 2015 + */ + +#include "io.h" +#include +#include +#include + +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; +} diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/src/python/core.c b/Godeps/_workspace/src/github.com/ethereum/ethash/src/python/core.c index 359735998..1ad973a87 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/src/python/core.c +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/src/python/core.c @@ -5,6 +5,14 @@ #include #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, ¶ms, (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, ¶ms, &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, ¶ms, (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, ¶ms, (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 diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/test/c/CMakeLists.txt b/Godeps/_workspace/src/github.com/ethereum/ethash/test/c/CMakeLists.txt index 02e2aab91..dd91d8a92 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/test/c/CMakeLists.txt +++ b/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 () diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/test/c/test.cpp b/Godeps/_workspace/src/github.com/ethereum/ethash/test/c/test.cpp index 21cb251fc..904f4f74c 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/test/c/test.cpp +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/test/c/test.cpp @@ -2,6 +2,7 @@ #include #include #include +#include #ifdef WITH_CRYPTOPP @@ -14,13 +15,23 @@ #define BOOST_TEST_MODULE Daggerhashimoto #define BOOST_TEST_MAIN -#include #include +#include +#include +#include +#include -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, ¶ms, seed); - node *full_mem = (node *) alloca(params.full_size); + node *full_mem = (node *) our_alloca(params.full_size); ethash_compute_full_data(full_mem, ¶ms, &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"); -} \ No newline at end of file +} + +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(¶ms, blockn); + params.cache_size = 1024; + params.full_size = 1024 * 32; + cache.mem = our_alloca(params.cache_size); + ethash_mkcache(&cache, ¶ms, (uint8_t*)&seedhash); + + BOOST_REQUIRE( + ethash_io_write("./test_ethash_directory/", ¶ms, 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(¶ms, blockn); + params.cache_size = 1024; + params.full_size = 1024 * 32; + cache.mem = our_alloca(params.cache_size); + ethash_mkcache(&cache, ¶ms, (uint8_t*)&seedhash); + + BOOST_REQUIRE( + ethash_io_write("./test_ethash_directory/", ¶ms, 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 readFileIntoVector(char const* filename) +{ + ifstream ifs(filename, ios::binary|ios::ate); + ifstream::pos_type pos = ifs.tellg(); + + std::vector 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(¶ms, blockn); + params.cache_size = 1024; + params.full_size = 1024 * 32; + cache.mem = our_alloca(params.cache_size); + ethash_mkcache(&cache, ¶ms, (uint8_t*)&seedhash); + + BOOST_REQUIRE( + ethash_io_write("./test_ethash_directory/", ¶ms, 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); +} diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/test/go/test.sh b/Godeps/_workspace/src/github.com/ethereum/ethash/test/go/test.sh deleted file mode 100644 index c6224858e..000000000 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/test/go/test.sh +++ /dev/null @@ -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 diff --git a/eth/backend.go b/eth/backend.go index cc4f807bf..ffc970212 100644 --- a/eth/backend.go +++ b/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 {