From 95711bc2dd0af71c741871007cecad12be8076ad Mon Sep 17 00:00:00 2001 From: obscuren Date: Sat, 14 Mar 2015 16:42:05 +0100 Subject: [PATCH] Updated ethash --- Godeps/Godeps.json | 4 +- .../src/github.com/ethereum/ethash/.gitignore | 2 + .../github.com/ethereum/ethash/CMakeLists.txt | 10 +- .../github.com/ethereum/ethash/MANIFEST.in | 17 + .../src/github.com/ethereum/ethash/Makefile | 7 +- .../ethereum/ethash/cryptopp/CMakeLists.txt | 2 +- .../src/github.com/ethereum/ethash/ethash.go | 296 +++++--- .../ethereum/ethash/pyethash/.gitignore | 2 - .../ethereum/ethash/pyethash/__init__.py | 3 - .../src/github.com/ethereum/ethash/setup.py | 22 +- .../ethash/src/benchmark/benchmark.cpp | 2 +- .../ethash/src/libethash-cl/CMakeLists.txt | 29 +- .../ethash/src/libethash-cl/bin2h.cmake | 3 +- .../src/libethash-cl/ethash_cl_miner.cpp | 59 +- .../ethash/src/libethash-cl/ethash_cl_miner.h | 1 + .../ethash/src/libethash/CMakeLists.txt | 1 - .../ethash/src/libethash/data_sizes.h | 649 +++++++++--------- .../ethereum/ethash/src/libethash/ethash.h | 51 +- .../ethereum/ethash/src/libethash/internal.c | 100 +-- .../ethereum/ethash/src/libethash/internal.h | 2 +- .../ethash/src/libethash/sha3_cryptopp.cpp | 8 +- .../ethereum/ethash/src/libethash/util.h | 8 +- .../ethereum/ethash/src/python/core.c | 303 +++++++- .../ethereum/ethash/test/c/test.cpp | 52 +- .../ethereum/ethash/test/go/ethash_test.go | 82 +++ .../ethereum/ethash/test/go/test.sh | 20 + .../ethash/test/python/requirements.txt | 1 + .../ethereum/ethash/test/python/test.sh | 4 +- .../ethash/test/python/test_pyethash.py | 104 ++- .../github.com/ethereum/ethash/test/test.sh | 7 +- 30 files changed, 1254 insertions(+), 597 deletions(-) create mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/MANIFEST.in delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/pyethash/.gitignore delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/pyethash/__init__.py create mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/test/go/ethash_test.go create mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/test/go/test.sh diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json index e0a932f8b..988c21d4f 100644 --- a/Godeps/Godeps.json +++ b/Godeps/Godeps.json @@ -22,8 +22,8 @@ }, { "ImportPath": "github.com/ethereum/ethash", - "Comment": "v17-64-ga323708", - "Rev": "a323708b8c4d253b8567bf6c72727d1aec302225" + "Comment": "v23-11-g5376ec8", + "Rev": "5376ec8816d6bf787d4fc91a08b4527bc5e1f469" }, { "ImportPath": "github.com/ethereum/serpent-go", diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/.gitignore b/Godeps/_workspace/src/github.com/ethereum/ethash/.gitignore index 3162bd828..da074e6b3 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/.gitignore +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/.gitignore @@ -8,3 +8,5 @@ pyethash.egg-info/ *.so *~ *.swp +MANIFEST +dist/ diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/CMakeLists.txt b/Godeps/_workspace/src/github.com/ethereum/ethash/CMakeLists.txt index c93395bf8..79f2e5335 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/CMakeLists.txt +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/CMakeLists.txt @@ -1,7 +1,7 @@ cmake_minimum_required(VERSION 2.8.7) project(ethash) -set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/") +set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/modules/") set(ETHHASH_LIBS ethash) if (WIN32 AND WANT_CRYPTOPP) @@ -10,6 +10,12 @@ endif() add_subdirectory(src/libethash) # bin2h.cmake doesn't work -#add_subdirectory(src/libethash-cl EXCLUDE_FROM_ALL) +if (NOT OpenCL_FOUND) + find_package(OpenCL) +endif() + +if (OpenCL_FOUND) + add_subdirectory(src/libethash-cl) +endif() add_subdirectory(src/benchmark EXCLUDE_FROM_ALL) add_subdirectory(test/c EXCLUDE_FROM_ALL) diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/MANIFEST.in b/Godeps/_workspace/src/github.com/ethereum/ethash/MANIFEST.in new file mode 100644 index 000000000..74e73c8be --- /dev/null +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/MANIFEST.in @@ -0,0 +1,17 @@ +include setup.py + +# C sources +include src/libethash/internal.c +include src/libethash/sha3.c +include src/libethash/util.c +include src/python/core.c + +# Headers +include src/libethash/compiler.h +include src/libethash/data_sizes.h +include src/libethash/endian.h +include src/libethash/ethash.h +include src/libethash/fnv.h +include src/libethash/internal.h +include src/libethash/sha3.h +include src/libethash/util.h diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/Makefile b/Godeps/_workspace/src/github.com/ethereum/ethash/Makefile index e2630581e..741d3b56d 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/Makefile +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/Makefile @@ -1,3 +1,6 @@ -.PHONY: clean +.PHONY: clean test +test: + ./test/test.sh + clean: - rm -rf *.so pyethash.egg-info/ build/ test/python/python-virtual-env/ test/c/build/ pyethash/*.{so,pyc} + rm -rf *.so pyethash.egg-info/ build/ test/python/python-virtual-env/ test/c/build/ pyethash.so test/python/*.pyc dist/ MANIFEST diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/cryptopp/CMakeLists.txt b/Godeps/_workspace/src/github.com/ethereum/ethash/cryptopp/CMakeLists.txt index 4cd9f36c6..6f4280532 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/cryptopp/CMakeLists.txt +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/cryptopp/CMakeLists.txt @@ -8,6 +8,6 @@ file(GLOB SOURCE "../../cryptopp/*.cpp") add_library(${LIBRARY} ${HEADERS} ${SOURCE}) -set(CRYPTOPP_INCLUDE_DIRS "../.." PARENT_SCOPE) +set(CRYPTOPP_INCLUDE_DIRS "../.." "../../../" PARENT_SCOPE) set(CRYPTOPP_LIBRARIES ${LIBRARY} PARENT_SCOPE) set(CRYPTOPP_FOUND TRUE PARENT_SCOPE) diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/ethash.go b/Godeps/_workspace/src/github.com/ethereum/ethash/ethash.go index bf184020a..6f1302bb8 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/ethash.go +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/ethash.go @@ -1,3 +1,13 @@ +/* +################################################################################### +################################################################################### +#################### #################### +#################### EDIT AND YOU SHALL FEEL MY WRATH - jeff #################### +#################### #################### +################################################################################### +################################################################################### +*/ + package ethash /* @@ -11,8 +21,8 @@ import "C" import ( "bytes" "encoding/binary" + "fmt" "io/ioutil" - "log" "math/big" "math/rand" "os" @@ -21,25 +31,26 @@ import ( "time" "unsafe" + "github.com/ethereum/go-ethereum/crypto" "github.com/ethereum/go-ethereum/ethutil" "github.com/ethereum/go-ethereum/logger" "github.com/ethereum/go-ethereum/pow" ) -var tt256 = new(big.Int).Exp(big.NewInt(2), big.NewInt(256), big.NewInt(0)) +var minDifficulty = new(big.Int).Exp(big.NewInt(2), big.NewInt(256), big.NewInt(0)) var powlogger = logger.NewLogger("POW") -type DAG struct { - SeedBlockNum uint64 - dag unsafe.Pointer // full GB of memory for dag - file bool +type ParamsAndCache struct { + params *C.ethash_params + cache *C.ethash_cache + Epoch uint64 } -type ParamsAndCache struct { - params *C.ethash_params - cache *C.ethash_cache - SeedBlockNum uint64 +type DAG struct { + dag unsafe.Pointer // full GB of memory for dag + file bool + paramsAndCache *ParamsAndCache } type Ethash struct { @@ -48,10 +59,9 @@ type Ethash struct { chainManager pow.ChainManager dag *DAG paramsAndCache *ParamsAndCache - nextdag unsafe.Pointer ret *C.ethash_return_value - dagMutex *sync.Mutex - cacheMutex *sync.Mutex + dagMutex *sync.RWMutex + cacheMutex *sync.RWMutex } func parseNonce(nonce []byte) (uint64, error) { @@ -65,151 +75,212 @@ func parseNonce(nonce []byte) (uint64, error) { const epochLength uint64 = 30000 -func GetSeedBlockNum(blockNum uint64) uint64 { - var seedBlockNum uint64 = 0 - if blockNum > epochLength { - seedBlockNum = ((blockNum - 1) / epochLength) * epochLength +func makeParamsAndCache(chainManager pow.ChainManager, blockNum uint64) (*ParamsAndCache, error) { + if blockNum >= epochLength*2048 { + return nil, fmt.Errorf("block number is out of bounds (value %v, limit is %v)", blockNum, epochLength*2048) } - return seedBlockNum -} - -/* -XXX THIS DOESN'T WORK!! NEEDS FIXING -blockEpoch will underflow and wrap around causing massive issues -func GetSeedBlockNum(blockNum uint64) uint64 { - var seedBlockNum uint64 = 0 - if blockNum > epochLength { - seedBlockNum = ((blockNum - 1) / epochLength) * epochLength - } - return seedBlockNum -} -*/ - -func makeParamsAndCache(chainManager pow.ChainManager, blockNum uint64) *ParamsAndCache { - seedBlockNum := GetSeedBlockNum(blockNum) paramsAndCache := &ParamsAndCache{ - params: new(C.ethash_params), - cache: new(C.ethash_cache), - SeedBlockNum: seedBlockNum, + params: new(C.ethash_params), + cache: new(C.ethash_cache), + Epoch: blockNum / epochLength, } - C.ethash_params_init(paramsAndCache.params, C.uint32_t(seedBlockNum)) + C.ethash_params_init(paramsAndCache.params, C.uint32_t(uint32(blockNum))) paramsAndCache.cache.mem = C.malloc(paramsAndCache.params.cache_size) - seedHash := chainManager.GetBlockByNumber(seedBlockNum).SeedHash() - log.Println("Making Cache") + seedHash, err := GetSeedHash(blockNum) + if err != nil { + return nil, err + } + + powlogger.Infoln("Making Cache") start := time.Now() C.ethash_mkcache(paramsAndCache.cache, paramsAndCache.params, (*C.uint8_t)(unsafe.Pointer(&seedHash[0]))) - log.Println("Took:", time.Since(start)) + powlogger.Infoln("Took:", time.Since(start)) - return paramsAndCache + return paramsAndCache, nil } -func (pow *Ethash) updateCache() { +func (pow *Ethash) UpdateCache(force bool) error { pow.cacheMutex.Lock() - seedNum := GetSeedBlockNum(pow.chainManager.CurrentBlock().NumberU64()) - if pow.paramsAndCache.SeedBlockNum != seedNum { - pow.paramsAndCache = makeParamsAndCache(pow.chainManager, pow.chainManager.CurrentBlock().NumberU64()) + thisEpoch := pow.chainManager.CurrentBlock().NumberU64() + if force || pow.paramsAndCache.Epoch != thisEpoch { + var err error + pow.paramsAndCache, err = makeParamsAndCache(pow.chainManager, pow.chainManager.CurrentBlock().NumberU64()) + if err != nil { + panic(err) + } } pow.cacheMutex.Unlock() + return nil } func makeDAG(p *ParamsAndCache) *DAG { d := &DAG{ - dag: C.malloc(p.params.full_size), - SeedBlockNum: p.SeedBlockNum, + dag: C.malloc(p.params.full_size), + file: false, + paramsAndCache: p, } + + donech := make(chan string) + go func() { + t := time.NewTicker(5 * time.Second) + tstart := time.Now() + done: + for { + select { + case <-t.C: + powlogger.Infof("... still generating DAG (%v) ...\n", time.Since(tstart).Seconds()) + case str := <-donech: + powlogger.Infof("... %s ...\n", str) + break done + } + } + }() C.ethash_compute_full_data(d.dag, p.params, p.cache) + donech <- "DAG generation completed" return d } -func (pow *Ethash) writeDagToDisk(dag *DAG, seedNum uint64) *os.File { - data := C.GoBytes(unsafe.Pointer(dag.dag), C.int(pow.paramsAndCache.params.full_size)) +func (pow *Ethash) writeDagToDisk(dag *DAG, epoch uint64) *os.File { + if epoch > 2048 { + panic(fmt.Errorf("Epoch must be less than 2048 (is %v)", epoch)) + } + data := C.GoBytes(unsafe.Pointer(dag.dag), C.int(dag.paramsAndCache.params.full_size)) file, err := os.Create("/tmp/dag") if err != nil { panic(err) } - num := make([]byte, 8) - binary.BigEndian.PutUint64(num, seedNum) + dataEpoch := make([]byte, 8) + binary.BigEndian.PutUint64(dataEpoch, epoch) - file.Write(num) + file.Write(dataEpoch) file.Write(data) return file } func (pow *Ethash) UpdateDAG() { - pow.cacheMutex.Lock() - pow.dagMutex.Lock() + blockNum := pow.chainManager.CurrentBlock().NumberU64() + if blockNum >= epochLength*2048 { + // This will crash in the 2030s or 2040s + panic(fmt.Errorf("Current block number is out of bounds (value %v, limit is %v)", blockNum, epochLength*2048)) + } - seedNum := GetSeedBlockNum(pow.chainManager.CurrentBlock().NumberU64()) - if pow.dag == nil || pow.dag.SeedBlockNum != seedNum { + pow.dagMutex.Lock() + defer pow.dagMutex.Unlock() + thisEpoch := blockNum / epochLength + if pow.dag == nil || pow.dag.paramsAndCache.Epoch != thisEpoch { if pow.dag != nil && pow.dag.dag != nil { C.free(pow.dag.dag) pow.dag.dag = nil } + if pow.dag != nil && pow.dag.paramsAndCache.cache.mem != nil { + C.free(pow.dag.paramsAndCache.cache.mem) + pow.dag.paramsAndCache.cache.mem = nil + } + + // Make the params and cache for the DAG + paramsAndCache, err := makeParamsAndCache(pow.chainManager, blockNum) + if err != nil { + panic(err) + } + + // TODO: On non-SSD disks, loading the DAG from disk takes longer than generating it in memory + pow.paramsAndCache = paramsAndCache path := path.Join("/", "tmp", "dag") pow.dag = nil - log.Println("Generating dag") + powlogger.Infoln("Retrieving DAG") start := time.Now() file, err := os.Open(path) if err != nil { - log.Printf("No dag found in '%s'. Generating new dago(takes a while)...", path) - pow.dag = makeDAG(pow.paramsAndCache) - file = pow.writeDagToDisk(pow.dag, seedNum) + powlogger.Infof("No DAG found. Generating new DAG in '%s' (this takes a while)...\n", path) + pow.dag = makeDAG(paramsAndCache) + file = pow.writeDagToDisk(pow.dag, thisEpoch) + pow.dag.file = true } else { data, err := ioutil.ReadAll(file) if err != nil { - panic(err) + powlogger.Infof("DAG load err: %v\n", err) } - num := binary.BigEndian.Uint64(data[0:8]) - if num < seedNum { - log.Printf("Old found. Generating new dag (takes a while)...") - pow.dag = makeDAG(pow.paramsAndCache) - file = pow.writeDagToDisk(pow.dag, seedNum) + if len(data) < 8 { + powlogger.Infof("DAG in '%s' is less than 8 bytes, it must be corrupted. Generating new DAG (this takes a while)...\n", path) + pow.dag = makeDAG(paramsAndCache) + file = pow.writeDagToDisk(pow.dag, thisEpoch) + pow.dag.file = true } else { - data = data[8:] - pow.dag = &DAG{ - dag: unsafe.Pointer(&data[0]), - file: true, - SeedBlockNum: pow.paramsAndCache.SeedBlockNum, + dataEpoch := binary.BigEndian.Uint64(data[0:8]) + if dataEpoch < thisEpoch { + powlogger.Infof("DAG in '%s' is stale. Generating new DAG (this takes a while)...\n", path) + pow.dag = makeDAG(paramsAndCache) + file = pow.writeDagToDisk(pow.dag, thisEpoch) + pow.dag.file = true + } else if dataEpoch > thisEpoch { + // FIXME + panic(fmt.Errorf("Saved DAG in '%s' reports to be from future epoch %v (current epoch is %v)\n", path, dataEpoch, thisEpoch)) + } else if len(data) != (int(paramsAndCache.params.full_size) + 8) { + powlogger.Infof("DAG in '%s' is corrupted. Generating new DAG (this takes a while)...\n", path) + pow.dag = makeDAG(paramsAndCache) + file = pow.writeDagToDisk(pow.dag, thisEpoch) + pow.dag.file = true + } else { + data = data[8:] + pow.dag = &DAG{ + dag: unsafe.Pointer(&data[0]), + file: true, + paramsAndCache: paramsAndCache, + } } } } - log.Println("Took:", time.Since(start)) + powlogger.Infoln("Took:", time.Since(start)) file.Close() } - - pow.dagMutex.Unlock() - pow.cacheMutex.Unlock() } func New(chainManager pow.ChainManager) *Ethash { + paramsAndCache, err := makeParamsAndCache(chainManager, chainManager.CurrentBlock().NumberU64()) + if err != nil { + panic(err) + } + return &Ethash{ turbo: true, - paramsAndCache: makeParamsAndCache(chainManager, chainManager.CurrentBlock().NumberU64()), + paramsAndCache: paramsAndCache, chainManager: chainManager, dag: nil, - cacheMutex: new(sync.Mutex), - dagMutex: new(sync.Mutex), + cacheMutex: new(sync.RWMutex), + dagMutex: new(sync.RWMutex), } } func (pow *Ethash) DAGSize() uint64 { - return uint64(pow.paramsAndCache.params.full_size) + return uint64(pow.dag.paramsAndCache.params.full_size) } func (pow *Ethash) CacheSize() uint64 { return uint64(pow.paramsAndCache.params.cache_size) } -func (pow *Ethash) GetSeedHash(blockNum uint64) []byte { - seednum := GetSeedBlockNum(blockNum) - return pow.chainManager.GetBlockByNumber(seednum).SeedHash() +func GetSeedHash(blockNum uint64) ([]byte, error) { + if blockNum >= epochLength*2048 { + return nil, fmt.Errorf("block number is out of bounds (value %v, limit is %v)", blockNum, epochLength*2048) + } + + epoch := blockNum / epochLength + seedHash := make([]byte, 32) + var i uint64 + for i = 0; i < 32; i++ { + seedHash[i] = 0 + } + for i = 0; i < epoch; i++ { + seedHash = crypto.Sha3(seedHash) + } + return seedHash, nil } func (pow *Ethash) Stop() { @@ -224,17 +295,18 @@ func (pow *Ethash) Stop() { if pow.dag.dag != nil && !pow.dag.file { C.free(pow.dag.dag) } + if pow.dag != nil && pow.dag.paramsAndCache != nil && pow.dag.paramsAndCache.cache.mem != nil { + C.free(pow.dag.paramsAndCache.cache.mem) + pow.dag.paramsAndCache.cache.mem = nil + } pow.dag.dag = nil } func (pow *Ethash) Search(block pow.Block, stop <-chan struct{}) (uint64, []byte, []byte) { - //pow.UpdateDAG() + pow.UpdateDAG() - // Not very elegant, multiple mining instances are not supported - //pow.dagMutex.Lock() - //pow.cacheMutex.Lock() - //defer pow.cacheMutex.Unlock() - //defer pow.dagMutex.Unlock() + pow.dagMutex.RLock() + defer pow.dagMutex.RUnlock() r := rand.New(rand.NewSource(time.Now().UnixNano())) miningHash := block.HashNoNonce() @@ -246,7 +318,7 @@ func (pow *Ethash) Search(block pow.Block, stop <-chan struct{}) (uint64, []byte nonce := uint64(r.Int63()) cMiningHash := (*C.uint8_t)(unsafe.Pointer(&miningHash[0])) - target := new(big.Int).Div(tt256, diff) + target := new(big.Int).Div(minDifficulty, diff) var ret C.ethash_return_value for { @@ -262,14 +334,17 @@ func (pow *Ethash) Search(block pow.Block, stop <-chan struct{}) (uint64, []byte hashes := ((float64(1e9) / float64(elapsed)) * float64(i-starti)) / 1000 pow.HashRate = int64(hashes) - C.ethash_full(&ret, pow.dag.dag, pow.paramsAndCache.params, cMiningHash, C.uint64_t(nonce)) + C.ethash_full(&ret, pow.dag.dag, pow.dag.paramsAndCache.params, cMiningHash, C.uint64_t(nonce)) result := ethutil.Bytes2Big(C.GoBytes(unsafe.Pointer(&ret.result[0]), C.int(32))) + // TODO: disagrees with the spec https://github.com/ethereum/wiki/wiki/Ethash#mining if result.Cmp(target) <= 0 { mixDigest := C.GoBytes(unsafe.Pointer(&ret.mix_hash[0]), C.int(32)) - - return nonce, mixDigest, pow.GetSeedHash(block.NumberU64()) - + seedHash, err := GetSeedHash(block.NumberU64()) // This seedhash is useless + if err != nil { + panic(err) + } + return nonce, mixDigest, seedHash } nonce += 1 @@ -283,32 +358,41 @@ func (pow *Ethash) Search(block pow.Block, stop <-chan struct{}) (uint64, []byte } func (pow *Ethash) Verify(block pow.Block) bool { - // Make sure the SeedHash is set correctly - if bytes.Compare(block.SeedHash(), pow.GetSeedHash(block.NumberU64())) != 0 { - return false - } return pow.verify(block.HashNoNonce(), block.MixDigest(), block.Difficulty(), block.NumberU64(), block.Nonce()) } func (pow *Ethash) verify(hash []byte, mixDigest []byte, difficulty *big.Int, blockNum uint64, nonce uint64) bool { - // First check: make sure header, mixDigest, nonce are correct without hitting the DAG + // Make sure the block num is valid + if blockNum >= epochLength*2048 { + powlogger.Infoln(fmt.Sprintf("Block number exceeds limit, invalid (value is %v, limit is %v)", + blockNum, epochLength*2048)) + return false + } + + // First check: make sure header, mixDigest, nonce are correct without hitting the cache // This is to prevent DOS attacks chash := (*C.uint8_t)(unsafe.Pointer(&hash[0])) cnonce := C.uint64_t(nonce) - target := new(big.Int).Div(tt256, difficulty) + target := new(big.Int).Div(minDifficulty, difficulty) var pAc *ParamsAndCache // If its an old block (doesn't use the current cache) // get the cache for it but don't update (so we don't need the mutex) - // Otherwise, it's the current block or a future. + // Otherwise, it's the current block or a future block. // If current, updateCache will do nothing. - if GetSeedBlockNum(blockNum) < pow.paramsAndCache.SeedBlockNum { - pAc = makeParamsAndCache(pow.chainManager, blockNum) + 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) + if err != nil { + powlogger.Infoln(err) + return false + } } else { - pow.updateCache() - pow.cacheMutex.Lock() - defer pow.cacheMutex.Unlock() + pow.UpdateCache(false) + pow.cacheMutex.RLock() + defer pow.cacheMutex.RUnlock() pAc = pow.paramsAndCache } diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/pyethash/.gitignore b/Godeps/_workspace/src/github.com/ethereum/ethash/pyethash/.gitignore deleted file mode 100644 index e1374b866..000000000 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/pyethash/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -pyethash.egg-info/ -*.so diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/pyethash/__init__.py b/Godeps/_workspace/src/github.com/ethereum/ethash/pyethash/__init__.py deleted file mode 100644 index fca037dba..000000000 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/pyethash/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -import pyethash.core -core = pyethash.core -EPOCH_LENGTH = 30000 diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/setup.py b/Godeps/_workspace/src/github.com/ethereum/ethash/setup.py index 4e27aad6c..29d6ad6d2 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/setup.py +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/setup.py @@ -1,21 +1,33 @@ #!/usr/bin/env python from distutils.core import setup, Extension -pyethash_core = Extension('pyethash.core', +pyethash = Extension('pyethash', sources = [ 'src/python/core.c', 'src/libethash/util.c', 'src/libethash/internal.c', - 'src/libethash/sha3.c' + 'src/libethash/sha3.c'], + depends = [ + 'src/libethash/ethash.h', + 'src/libethash/compiler.h', + 'src/libethash/data_sizes.h', + 'src/libethash/endian.h', + 'src/libethash/ethash.h', + 'src/libethash/fnv.h', + 'src/libethash/internal.h', + 'src/libethash/sha3.h', + 'src/libethash/util.h' ], - extra_compile_args = ["-std=gnu99"]) + extra_compile_args = ["-Isrc/", "-std=gnu99", "-Wall"]) setup ( name = 'pyethash', author = "Matthew Wampler-Doty", author_email = "matthew.wampler.doty@gmail.com", license = 'GPL', - version = '1.0', + version = '23', + url = 'https://github.com/ethereum/ethash', + download_url = 'https://github.com/ethereum/ethash/tarball/v23', description = 'Python wrappers for ethash, the ethereum proof of work hashing function', - ext_modules = [pyethash_core], + ext_modules = [pyethash], ) 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 4c8f700c5..7dae4f18c 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 @@ -31,7 +31,7 @@ #include #ifdef WITH_CRYPTOPP -#include +#include #include #else 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 fe563aae4..f37471cf3 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 @@ -2,14 +2,39 @@ set(LIBRARY ethash-cl) set(CMAKE_BUILD_TYPE Release) include(bin2h.cmake) -bin2h(SOURCE_FILE ethash_cl_miner_kernel.cl VARIABLE_NAME ethash_cl_miner_kernel HEADER_FILE ${CMAKE_CURRENT_BINARY_DIR}/ethash_cl_miner_kernel.h) +bin2h(SOURCE_FILE ethash_cl_miner_kernel.cl + VARIABLE_NAME ethash_cl_miner_kernel + HEADER_FILE ${CMAKE_CURRENT_BINARY_DIR}/ethash_cl_miner_kernel.h) + +if (NOT MSVC) + # Initialize CXXFLAGS for c++11 + set(CMAKE_CXX_FLAGS "-Wall -std=c++11") + set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g") + set(CMAKE_CXX_FLAGS_MINSIZEREL "-Os -DNDEBUG") + set(CMAKE_CXX_FLAGS_RELEASE "-O4 -DNDEBUG") + set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g") + + # Compiler-specific C++11 activation. + if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") + execute_process( + COMMAND ${CMAKE_CXX_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION) + if (NOT (GCC_VERSION VERSION_GREATER 4.7 OR GCC_VERSION VERSION_EQUAL 4.7)) + message(FATAL_ERROR "${PROJECT_NAME} requires g++ 4.7 or greater.") + endif () + elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++") + else () + message(FATAL_ERROR "Your C++ compiler does not support C++11.") + endif () +endif() if (NOT OpenCL_FOUND) find_package(OpenCL) endif() + if (OpenCL_FOUND) include_directories(${OpenCL_INCLUDE_DIRS} ${CMAKE_CURRENT_BINARY_DIR}) include_directories(..) - add_library(${LIBRARY} ethash_cl_miner.cpp ethash_cl_miner.h) + add_library(${LIBRARY} ethash_cl_miner.cpp ethash_cl_miner.h cl.hpp) TARGET_LINK_LIBRARIES(${LIBRARY} ${OpenCL_LIBRARIES} ethash) endif() diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/bin2h.cmake b/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/bin2h.cmake index e224c1a67..90ca9cc5b 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/bin2h.cmake +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/bin2h.cmake @@ -68,8 +68,7 @@ function(BIN2H) string(REGEX REPLACE ", $" "" arrayValues ${arrayValues}) # converts the variable name into proper C identifier - # TODO: fix for legacy cmake - IF (${CMAKE_VERSION} GREATER 2.8.10) + IF (${CMAKE_VERSION} GREATER 2.8.10) # fix for legacy cmake string(MAKE_C_IDENTIFIER "${BIN2H_VARIABLE_NAME}" BIN2H_VARIABLE_NAME) ENDIF() string(TOUPPER "${BIN2H_VARIABLE_NAME}" BIN2H_VARIABLE_NAME) 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 c0dbea21d..18133256a 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 @@ -24,15 +24,22 @@ #include #include +#include #include "ethash_cl_miner.h" #include "ethash_cl_miner_kernel.h" #include +#define ETHASH_BYTES 32 + +// workaround lame platforms +#if !CL_VERSION_1_2 +#define CL_MAP_WRITE_INVALIDATE_REGION CL_MAP_WRITE +#define CL_MEM_HOST_READ_ONLY 0 +#endif + #undef min #undef max -#define HASH_BYTES 32 - static void add_definition(std::string& source, char const* id, unsigned value) { char buf[256]; @@ -41,6 +48,7 @@ static void add_definition(std::string& source, char const* id, unsigned value) } ethash_cl_miner::ethash_cl_miner() +: m_opencl_1_1() { } @@ -71,11 +79,23 @@ bool ethash_cl_miner::init(ethash_params const& params, const uint8_t seed[32], } // use default device - cl::Device& device = devices[0]; - debugf("Using device: %s\n", device.getInfo().c_str()); + unsigned device_num = 0; + cl::Device& device = devices[device_num]; + std::string device_version = device.getInfo(); + debugf("Using device: %s (%s)\n", device.getInfo().c_str(),device_version.c_str()); + + if (strncmp("OpenCL 1.0", device_version.c_str(), 10) == 0) + { + debugf("OpenCL 1.0 is not supported.\n"); + return false; + } + if (strncmp("OpenCL 1.1", device_version.c_str(), 10) == 0) + { + m_opencl_1_1 = true; + } // create context - m_context = cl::Context({device}); + 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 @@ -120,7 +140,7 @@ bool ethash_cl_miner::init(ethash_params const& params, const uint8_t seed[32], ethash_mkcache(&cache, ¶ms, seed); // if this throws then it's because we probably need to subdivide the dag uploads for compatibility - void* dag_ptr = m_queue.enqueueMapBuffer(m_dag, true, CL_MAP_WRITE_INVALIDATE_REGION, 0, params.full_size); + void* dag_ptr = m_queue.enqueueMapBuffer(m_dag, true, m_opencl_1_1 ? CL_MAP_WRITE : CL_MAP_WRITE_INVALIDATE_REGION, 0, params.full_size); ethash_compute_full_data(dag_ptr, ¶ms, &cache); m_queue.enqueueUnmapMemObject(m_dag, dag_ptr); @@ -130,7 +150,7 @@ bool ethash_cl_miner::init(ethash_params const& params, const uint8_t seed[32], // create mining buffers for (unsigned i = 0; i != c_num_buffers; ++i) { - m_hash_buf[i] = cl::Buffer(m_context, CL_MEM_WRITE_ONLY | CL_MEM_HOST_READ_ONLY, 32*c_hash_batch_size); + m_hash_buf[i] = cl::Buffer(m_context, CL_MEM_WRITE_ONLY | (!m_opencl_1_1 ? CL_MEM_HOST_READ_ONLY : 0), 32*c_hash_batch_size); m_search_buf[i] = cl::Buffer(m_context, CL_MEM_WRITE_ONLY, (c_max_search_results + 1) * sizeof(uint32_t)); } return true; @@ -176,7 +196,6 @@ void ethash_cl_miner::hash(uint8_t* ret, uint8_t const* header, uint64_t nonce, m_hash_kernel.setArg(0, m_hash_buf[buf]); // execute it! - clock_t start_time = clock(); m_queue.enqueueNDRangeKernel( m_hash_kernel, cl::NullRange, @@ -196,8 +215,8 @@ void ethash_cl_miner::hash(uint8_t* ret, uint8_t const* header, uint64_t nonce, pending_batch const& batch = pending.front(); // could use pinned host pointer instead, but this path isn't that important. - uint8_t* hashes = (uint8_t*)m_queue.enqueueMapBuffer(m_hash_buf[batch.buf], true, CL_MAP_READ, 0, batch.count * HASH_BYTES); - memcpy(ret + batch.base*HASH_BYTES, hashes, batch.count*HASH_BYTES); + uint8_t* hashes = (uint8_t*)m_queue.enqueueMapBuffer(m_hash_buf[batch.buf], true, CL_MAP_READ, 0, batch.count * ETHASH_BYTES); + memcpy(ret + batch.base*ETHASH_BYTES, hashes, batch.count*ETHASH_BYTES); m_queue.enqueueUnmapMemObject(m_hash_buf[batch.buf], hashes); pending.pop(); @@ -223,8 +242,19 @@ void ethash_cl_miner::search(uint8_t const* header, uint64_t target, search_hook { m_queue.enqueueWriteBuffer(m_search_buf[i], false, 0, 4, &c_zero); } + +#if CL_VERSION_1_2 cl::Event pre_return_event; - m_queue.enqueueBarrierWithWaitList(NULL, &pre_return_event); + if (!m_opencl_1_1) + { + m_queue.enqueueBarrierWithWaitList(NULL, &pre_return_event); + } + else +#else + { + m_queue.finish(); + } +#endif /* __kernel void ethash_combined_search( @@ -284,6 +314,11 @@ void ethash_cl_miner::search(uint8_t const* header, uint64_t target, search_hook } // not safe to return until this is ready - pre_return_event.wait(); +#if CL_VERSION_1_2 + if (!m_opencl_1_1) + { + pre_return_event.wait(); + } +#endif } 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 f37100d91..3fb98b5b7 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 @@ -40,4 +40,5 @@ private: cl::Buffer m_hash_buf[c_num_buffers]; cl::Buffer m_search_buf[c_num_buffers]; unsigned m_workgroup_size; + bool m_opencl_1_1; }; \ No newline at end of file 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 7bc147af7..38fc821c0 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 @@ -2,7 +2,6 @@ set(LIBRARY ethash) if (CPPETHEREUM) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC") -#else () endif () set(CMAKE_BUILD_TYPE Release) 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 a10d4c42c..3b747b3ea 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 @@ -20,8 +20,6 @@ * @date 2015 */ -// TODO: Update this after ~3.5 years - #pragma once #include @@ -33,23 +31,24 @@ extern "C" { #include -// 2048 Epochs worth of tabulated DAG sizes +// 2048 Epochs (~20 years) worth of tabulated DAG sizes // Generated with the following Mathematica Code: -// GetDataSizes[n_] := Module[{ -// DataSetSizeBytesInit = 2^30, -// MixBytes = 128, -// DataSetGrowth = 2^23, +// GetCacheSizes[n_] := Module[{ +// CacheSizeBytesInit = 2^24, +// CacheGrowth = 2^17, +// HashBytes = 64, // j = 0}, -// Reap[ -// While[j < n, -// Module[{i = -// Floor[(DataSetSizeBytesInit + DataSetGrowth * j) / MixBytes]}, -// While[! PrimeQ[i], i--]; -// Sow[i*MixBytes]; j++]]]][[2]][[1]] +// Reap[ +// While[j < n, +// Module[{i = +// Floor[(CacheSizeBytesInit + CacheGrowth * j) / HashBytes]}, +// While[! PrimeQ[i], i--]; +// Sow[i*HashBytes]; j++]]]][[2]][[1]] + -static const size_t dag_sizes[] = { +static const size_t dag_sizes[2048] = { 1073739904U, 1082130304U, 1090514816U, 1098906752U, 1107293056U, 1115684224U, 1124070016U, 1132461952U, 1140849536U, 1149232768U, 1157627776U, 1166013824U, 1174404736U, 1182786944U, 1191180416U, @@ -478,300 +477,334 @@ static const size_t dag_sizes[] = { // While[! PrimeQ[i], i--]; // Sow[i*HashBytes]; j++]]]][[2]][[1]] -const size_t cache_sizes[] = { - 1048384U, 1055552U, 1064512U, 1072832U, 1080896U, 1089344U, 1096768U, - 1104448U, 1113664U, 1121216U, 1130176U, 1138624U, 1146304U, 1155008U, - 1162816U, 1171264U, 1179328U, 1187392U, 1195456U, 1203392U, 1210816U, - 1220416U, 1227712U, 1236416U, 1244608U, 1253312U, 1261376U, 1268416U, - 1277632U, 1285696U, 1294016U, 1302208U, 1310656U, 1318336U, 1326784U, - 1334848U, 1342912U, 1350848U, 1359808U, 1366208U, 1376192U, 1383488U, - 1392448U, 1400384U, 1408832U, 1416512U, 1425344U, 1433408U, 1440704U, - 1449664U, 1458112U, 1466048U, 1474496U, 1482688U, 1490752U, 1498688U, - 1507136U, 1515328U, 1523264U, 1531456U, 1539904U, 1547584U, 1556288U, - 1564352U, 1572544U, 1580608U, 1588544U, 1596992U, 1605568U, 1612096U, - 1621952U, 1630144U, 1637696U, 1645888U, 1654336U, 1662784U, 1671104U, - 1679168U, 1686848U, 1695296U, 1702208U, 1711168U, 1720256U, 1727552U, - 1736128U, 1744576U, 1751488U, 1760576U, 1769408U, 1777472U, 1785664U, - 1793984U, 1801664U, 1810112U, 1818304U, 1826624U, 1834816U, 1842752U, - 1851328U, 1858112U, 1867456U, 1875904U, 1883968U, 1892288U, 1899712U, - 1908416U, 1916608U, 1924544U, 1932992U, 1940672U, 1948736U, 1956928U, - 1965632U, 1973824U, 1982144U, 1989824U, 1998784U, 2006848U, 2014784U, - 2022848U, 2031424U, 2038976U, 2047424U, 2055616U, 2064064U, 2072384U, - 2080448U, 2088512U, 2095936U, 2104768U, 2113472U, 2121664U, 2127808U, - 2137792U, 2146112U, 2153408U, 2162624U, 2170304U, 2178496U, 2186944U, - 2195392U, 2203456U, 2211136U, 2219968U, 2227648U, 2236096U, 2244416U, - 2250944U, 2260928U, 2268736U, 2276672U, 2283328U, 2293696U, 2301632U, - 2309312U, 2317888U, 2325952U, 2334656U, 2342848U, 2350144U, 2358848U, - 2366656U, 2375488U, 2383552U, 2391616U, 2400064U, 2407616U, 2415808U, - 2424256U, 2432704U, 2439616U, 2448704U, 2457152U, 2464064U, 2473792U, - 2482112U, 2489792U, 2497472U, 2506432U, 2514752U, 2522816U, 2531264U, - 2539456U, 2547136U, 2555456U, 2564032U, 2572096U, 2578496U, 2587712U, - 2595776U, 2604736U, 2613056U, 2620736U, 2629184U, 2637632U, 2645824U, - 2653888U, 2662208U, 2670016U, 2678464U, 2686912U, 2694464U, 2703296U, - 2710976U, 2719424U, 2727104U, 2736064U, 2743232U, 2752192U, 2760512U, - 2768704U, 2777024U, 2785088U, 2792512U, 2800576U, 2809024U, 2817856U, - 2826176U, 2833984U, 2840896U, 2850752U, 2858048U, 2867008U, 2875328U, - 2883392U, 2891584U, 2899648U, 2908096U, 2915648U, 2924224U, 2932672U, - 2940736U, 2948672U, 2956736U, 2964928U, 2973248U, 2981824U, 2988992U, - 2997184U, 3005248U, 3013952U, 3022144U, 3030592U, 3037376U, 3046976U, - 3055552U, 3063616U, 3070784U, 3079744U, 3087808U, 3096512U, 3103808U, - 3111872U, 3121088U, 3128896U, 3137216U, 3144896U, 3153856U, 3161152U, - 3169984U, 3178432U, 3186496U, 3194816U, 3203008U, 3210176U, 3218624U, - 3227072U, 3235264U, 3243712U, 3250496U, 3259456U, 3268544U, 3276736U, - 3283648U, 3292736U, 3301184U, 3308224U, 3317696U, 3324736U, 3333184U, - 3342272U, 3348544U, 3357248U, 3365312U, 3374912U, 3383104U, 3390784U, - 3399488U, 3407296U, 3414976U, 3424192U, 3432256U, 3440576U, 3448768U, - 3456832U, 3464896U, 3473216U, 3480128U, 3489344U, 3497408U, 3505856U, - 3514048U, 3521344U, 3530432U, 3538624U, 3546304U, 3555008U, 3563072U, - 3571648U, 3579712U, 3587392U, 3595456U, 3603904U, 3612352U, 3620416U, - 3628864U, 3636928U, 3645248U, 3652928U, 3660992U, 3669184U, 3677888U, - 3685952U, 3694528U, 3702592U, 3710528U, 3719104U, 3727168U, 3735488U, - 3742784U, 3751232U, 3759424U, 3765184U, 3775808U, 3783872U, 3792832U, - 3800768U, 3808832U, 3816256U, 3825344U, 3832768U, 3841856U, 3849536U, - 3857344U, 3866432U, 3874496U, 3882304U, 3890752U, 3899072U, 3907264U, - 3914816U, 3923008U, 3930688U, 3939904U, 3947968U, 3956416U, 3964736U, - 3972544U, 3981248U, 3988928U, 3997376U, 4005824U, 4012864U, 4020928U, - 4030144U, 4038592U, 4045504U, 4054592U, 4063168U, 4071104U, 4079552U, - 4087232U, 4095808U, 4103872U, 4111168U, 4120384U, 4127936U, 4136512U, - 4144832U, 4153024U, 4160704U, 4169408U, 4177216U, 4186048U, 4193344U, - 4202048U, 4210496U, 4217536U, 4227008U, 4235072U, 4243264U, 4251584U, - 4259392U, 4267712U, 4275776U, 4284352U, 4291904U, 4300096U, 4307648U, - 4316992U, 4325056U, 4333376U, 4341056U, 4349888U, 4357568U, 4366016U, - 4374464U, 4382528U, 4390208U, 4398656U, 4407232U, 4413632U, 4423616U, - 4431808U, 4439744U, 4447936U, 4455872U, 4463296U, 4472128U, 4480576U, - 4489024U, 4497344U, 4505152U, 4512448U, 4520896U, 4530112U, 4537664U, - 4546496U, 4554688U, 4562752U, 4570816U, 4579264U, 4586944U, 4595648U, - 4603712U, 4611392U, 4619072U, 4628032U, 4635584U, 4643776U, 4652864U, - 4660672U, 4669376U, 4677056U, 4684096U, 4693184U, 4702144U, 4710208U, - 4718528U, 4726336U, 4734272U, 4742464U, 4750784U, 4759232U, 4767296U, - 4775872U, 4783808U, 4791872U, 4797376U, 4808512U, 4816192U, 4825024U, - 4832704U, 4841024U, 4849472U, 4856512U, 4865984U, 4874176U, 4882112U, - 4889792U, 4898752U, 4906688U, 4913984U, 4922816U, 4931008U, 4938944U, - 4946624U, 4955584U, 4964032U, 4972096U, 4980032U, 4988864U, 4997056U, - 5004992U, 5012288U, 5020096U, 5029312U, 5037632U, 5045696U, 5052224U, - 5062592U, 5070784U, 5078848U, 5086784U, 5095232U, 5100736U, 5111488U, - 5119936U, 5127104U, 5136064U, 5143616U, 5151424U, 5160256U, 5168704U, - 5175232U, 5185472U, 5192384U, 5199296U, 5209664U, 5218112U, 5225536U, - 5233472U, 5242816U, 5250496U, 5258944U, 5267264U, 5274944U, 5283776U, - 5290048U, 5300032U, 5308096U, 5316544U, 5323328U, 5331904U, 5340736U, - 5349056U, 5356864U, 5365312U, 5372096U, 5381696U, 5390272U, 5398336U, - 5405888U, 5413696U, 5422784U, 5430976U, 5439424U, 5446976U, 5455808U, - 5463616U, 5471168U, 5480128U, 5488064U, 5494592U, 5504704U, 5513152U, - 5521216U, 5529536U, 5536576U, 5544256U, 5554112U, 5559616U, 5570368U, - 5577664U, 5586752U, 5594944U, 5603008U, 5611456U, 5619392U, 5627584U, - 5634368U, 5643328U, 5651264U, 5659328U, 5667008U, 5675584U, 5684416U, - 5692864U, 5701568U, 5709632U, 5717056U, 5725376U, 5734336U, 5740096U, - 5750336U, 5758912U, 5766848U, 5775296U, 5782976U, 5790784U, 5799616U, - 5807936U, 5815232U, 5823808U, 5832256U, 5840192U, 5848768U, 5856832U, - 5864896U, 5873344U, 5879872U, 5888576U, 5897792U, 5905216U, 5914432U, - 5920448U, 5930944U, 5938624U, 5947328U, 5955392U, 5963456U, 5971648U, - 5979328U, 5988032U, 5995712U, 6003904U, 6012736U, 6021056U, 6029248U, - 6037184U, 6045632U, 6053312U, 6061376U, 6070208U, 6077504U, 6086464U, - 6094784U, 6101696U, 6110912U, 6118592U, 6127168U, 6135616U, 6143296U, - 6150208U, 6158912U, 6168128U, 6175808U, 6182464U, 6192832U, 6201152U, - 6209344U, 6217664U, 6224576U, 6233408U, 6241472U, 6249664U, 6258496U, - 6266816U, 6275008U, 6281152U, 6291136U, 6299456U, 6306752U, 6314816U, - 6323776U, 6332096U, 6339392U, 6348224U, 6356288U, 6364096U, 6373184U, - 6381376U, 6389696U, 6397504U, 6404416U, 6413632U, 6421952U, 6430016U, - 6437824U, 6446912U, 6454592U, 6463168U, 6471616U, 6478144U, 6487232U, - 6496192U, 6504128U, 6511936U, 6520256U, 6528832U, 6536896U, 6544576U, - 6553408U, 6561472U, 6569792U, 6577216U, 6586304U, 6592448U, 6601024U, - 6610624U, 6619072U, 6627136U, 6634816U, 6643264U, 6650816U, 6659776U, - 6667712U, 6675904U, 6682688U, 6691904U, 6700864U, 6709184U, 6717376U, - 6724544U, 6733504U, 6741824U, 6749888U, 6756032U, 6766528U, 6773056U, - 6782912U, 6790976U, 6798016U, 6807488U, 6815168U, 6823744U, 6832064U, - 6840128U, 6847552U, 6855872U, 6864064U, 6872128U, 6880576U, 6889408U, - 6897472U, 6905792U, 6913472U, 6920896U, 6930368U, 6938432U, 6946624U, - 6953536U, 6963136U, 6971072U, 6979136U, 6986944U, 6995392U, 7003712U, - 7012288U, 7019072U, 7028416U, 7036352U, 7044416U, 7051712U, 7060672U, - 7069376U, 7077568U, 7085504U, 7092544U, 7102016U, 7110592U, 7118656U, - 7126208U, 7135168U, 7143104U, 7150912U, 7159744U, 7167808U, 7175744U, - 7184192U, 7191232U, 7200448U, 7207744U, 7216576U, 7224128U, 7233472U, - 7241536U, 7249856U, 7256512U, 7264832U, 7274048U, 7282112U, 7290176U, - 7298752U, 7306688U, 7315136U, 7322816U, 7331392U, 7339456U, 7347776U, - 7356224U, 7364288U, 7371712U, 7380928U, 7387456U, 7396544U, 7404352U, - 7413568U, 7421632U, 7429696U, 7436864U, 7446464U, 7454144U, 7461952U, - 7470784U, 7478336U, 7487296U, 7495616U, 7503424U, 7511872U, 7520192U, - 7527616U, 7536448U, 7544512U, 7551424U, 7560128U, 7568576U, 7577536U, - 7583552U, 7592512U, 7600448U, 7610048U, 7618496U, 7626176U, 7634752U, - 7642816U, 7651264U, 7659328U, 7667008U, 7675456U, 7683136U, 7691584U, - 7700416U, 7707584U, 7716416U, 7724224U, 7733056U, 7740608U, 7749184U, - 7756096U, 7765952U, 7774016U, 7781824U, 7790528U, 7798592U, 7805888U, - 7814336U, 7822784U, 7831232U, 7839296U, 7847104U, 7855552U, 7863616U, - 7872448U, 7880128U, 7888576U, 7896256U, 7905088U, 7912768U, 7920448U, - 7928768U, 7937344U, 7945792U, 7953728U, 7959488U, 7970752U, 7978816U, - 7987136U, 7994816U, 8003392U, 8011712U, 8019904U, 8027456U, 8035264U, - 8044352U, 8052544U, 8060224U, 8069056U, 8076736U, 8084672U, 8093504U, - 8101312U, 8110016U, 8117696U, 8125888U, 8134592U, 8142016U, 8149952U, - 8159168U, 8166976U, 8175296U, 8183488U, 8191808U, 8199616U, 8207296U, - 8216128U, 8224576U, 8232256U, 8241088U, 8248256U, 8257472U, 8264128U, - 8273728U, 8281792U, 8290112U, 8297152U, 8305216U, 8314816U, 8322752U, - 8330944U, 8339392U, 8347072U, 8355392U, 8363968U, 8371904U, 8379328U, - 8388544U, 8394944U, 8404544U, 8412736U, 8421184U, 8429504U, 8437696U, - 8445376U, 8452544U, 8460736U, 8470208U, 8478016U, 8486848U, 8494144U, - 8503232U, 8511296U, 8519488U, 8527424U, 8534464U, 8543936U, 8552384U, - 8558912U, 8568128U, 8575936U, 8584256U, 8593216U, 8601536U, 8608832U, - 8616896U, 8625728U, 8634176U, 8641856U, 8649664U, 8658112U, 8666176U, - 8674112U, 8682944U, 8691136U, 8699456U, 8707648U, 8716096U, 8724416U, - 8732608U, 8740672U, 8748352U, 8756032U, 8764864U, 8773568U, 8781376U, - 8789824U, 8796992U, 8806208U, 8814272U, 8822336U, 8830912U, 8838848U, - 8847296U, 8854336U, 8863552U, 8871488U, 8879296U, 8887616U, 8894528U, - 8904512U, 8911424U, 8920768U, 8928704U, 8936128U, 8944576U, 8953664U, - 8960576U, 8970176U, 8977984U, 8986304U, 8994112U, 9002432U, 9011008U, - 9018176U, 9026624U, 9035584U, 9043904U, 9052096U, 9059264U, 9068096U, - 9075904U, 9084224U, 9092288U, 9100352U, 9108928U, 9116992U, 9125824U, - 9133504U, 9141824U, 9150272U, 9157952U, 9164608U, 9174848U, 9182912U, - 9190976U, 9199552U, 9205312U, 9215936U, 9222592U, 9232192U, 9240512U, - 9248704U, 9256256U, 9264832U, 9272896U, 9281344U, 9288896U, 9297088U, - 9305536U, 9313984U, 9322304U, 9329728U, 9337792U, 9346112U, 9355072U, - 9363136U, 9371072U, 9378752U, 9387712U, 9395648U, 9404224U, 9411008U, - 9420608U, 9428416U, 9436864U, 9445312U, 9453376U, 9460928U, 9468736U, - 9477824U, 9485248U, 9493696U, 9502144U, 9509056U, 9518528U, 9527104U, - 9535424U, 9543616U, 9551296U, 9559744U, 9568192U, 9576256U, 9584576U, - 9591872U, 9600704U, 9608384U, 9615808U, 9624512U, 9633472U, 9641536U, - 9649856U, 9658048U, 9665728U, 9674432U, 9682496U, 9691072U, 9699136U, - 9707072U, 9715136U, 9722176U, 9732032U, 9740096U, 9747904U, 9756352U, - 9764288U, 9771584U, 9780544U, 9789376U, 9796928U, 9804224U, 9813952U, - 9822016U, 9829696U, 9838016U, 9845824U, 9852992U, 9863104U, 9870656U, - 9878464U, 9887552U, 9895744U, 9903808U, 9912128U, 9920192U, 9927616U, - 9936064U, 9944768U, 9952576U, 9960128U, 9969472U, 9977152U, 9985216U, - 9994048U, 10001216U, 10007744U, 10018496U, 10026944U, 10035136U, 10042432U, - 10051264U, 10059584U, 10067648U, 10075712U, 10083904U, 10091456U, 10100672U, - 10108864U, 10116928U, 10124864U, 10133056U, 10140736U, 10149824U, 10156736U, - 10165952U, 10173376U, 10182208U, 10190528U, 10198336U, 10206272U, 10213696U, - 10223296U, 10231744U, 10238656U, 10247488U, 10256192U, 10263872U, 10272448U, - 10280896U, 10288448U, 10296512U, 10305088U, 10313536U, 10321088U, 10330048U, - 10337984U, 10346176U, 10354112U, 10362304U, 10369088U, 10377152U, 10386752U, - 10394816U, 10403648U, 10411712U, 10418624U, 10427968U, 10436032U, 10444736U, - 10452928U, 10459712U, 10468672U, 10476608U, 10484416U, 10491328U, 10501952U, - 10509376U, 10517824U, 10526528U, 10534336U, 10542656U, 10549696U, 10559168U, - 10566592U, 10575808U, 10583488U, 10590656U, 10599488U, 10607936U, 10616768U, - 10624832U, 10630336U, 10640576U, 10649536U, 10655168U, 10665152U, 10674112U, - 10682176U, 10690496U, 10698176U, 10705216U, 10715072U, 10722752U, 10731328U, - 10739264U, 10746688U, 10754752U, 10761664U, 10770752U, 10779712U, 10787776U, - 10796608U, 10803392U, 10812352U, 10821056U, 10828736U, 10837952U, 10846144U, - 10853824U, 10861376U, 10869952U, 10877248U, 10887104U, 10895296U, 10903232U, - 10910912U, 10918976U, 10927936U, 10935872U, 10944448U, 10952384U, 10960832U, - 10968512U, 10977088U, 10985024U, 10992832U, 11000896U, 11009984U, 11018048U, - 11026112U, 11034304U, 11042624U, 11050432U, 11058368U, 11064512U, 11075392U, - 11083712U, 11091776U, 11099584U, 11107904U, 11115968U, 11124416U, 11131712U, - 11141056U, 11148608U, 11157184U, 11165248U, 11173312U, 11180992U, 11189056U, - 11197376U, 11206592U, 11214656U, 11222336U, 11230784U, 11238464U, 11246528U, - 11254976U, 11263552U, 11271872U, 11279552U, 11288512U, 11296576U, 11304256U, - 11312192U, 11320768U, 11329216U, 11336384U, 11345216U, 11352512U, 11362112U, - 11369408U, 11378624U, 11386688U, 11394496U, 11402816U, 11411264U, 11418688U, - 11427776U, 11435584U, 11444032U, 11452096U, 11459648U, 11467072U, 11476928U, - 11484992U, 11493184U, 11500352U, 11509312U, 11517248U, 11524928U, 11534144U, - 11542208U, 11550272U, 11556416U, 11566784U, 11574208U, 11581376U, 11589568U, - 11599552U, 11607104U, 11616064U, 11623616U, 11632576U, 11639872U, 11648704U, - 11657024U, 11664704U, 11672896U, 11681216U, 11689792U, 11697856U, 11705536U, - 11714368U, 11722688U, 11730496U, 11737408U, 11745728U, 11754304U, 11763008U, - 11770816U, 11779648U, 11788096U, 11795776U, 11804608U, 11812544U, 11820992U, - 11829184U, 11837248U, 11844928U, 11852096U, 11860928U, 11869888U, 11878336U, - 11886272U, 11894336U, 11902144U, 11910848U, 11919296U, 11925952U, 11934784U, - 11943616U, 11951552U, 11960128U, 11968192U, 11976512U, 11983168U, 11992768U, - 12000832U, 12008896U, 12016832U, 12025408U, 12033856U, 12042176U, 12049984U, - 12058048U, 12066112U, 12073792U, 12082624U, 12091328U, 12098752U, 12106816U, - 12115904U, 12124096U, 12131776U, 12140224U, 12148672U, 12156736U, 12164032U, - 12173248U, 12181184U, 12186176U, 12197824U, 12205888U, 12213952U, 12218944U, - 12230336U, 12238784U, 12246592U, 12254272U, 12262336U, 12269888U, 12279104U, - 12287936U, 12295744U, 12304064U, 12312512U, 12319936U, 12328768U, 12337088U, - 12344896U, 12352832U, 12361408U, 12368704U, 12377152U, 12384832U, 12394432U, - 12402496U, 12409024U, 12417728U, 12426688U, 12433216U, 12443584U, 12450752U, - 12459968U, 12468032U, 12475712U, 12484544U, 12492608U, 12500416U, 12508352U, - 12517184U, 12525376U, 12532288U, 12541888U, 12549568U, 12556864U, 12565568U, - 12574528U, 12582208U, 12590528U, 12598592U, 12607424U, 12615488U, 12623552U, - 12631744U, 12638656U, 12647744U, 12656576U, 12664768U, 12672832U, 12680896U, - 12688576U, 12697408U, 12704192U, 12713408U, 12721216U, 12729664U, 12738496U, - 12745792U, 12754496U, 12762688U, 12769472U, 12779456U, 12787648U, 12795712U, - 12804032U, 12812224U, 12819008U, 12828352U, 12836672U, 12844736U, 12851648U, - 12859456U, 12868672U, 12877504U, 12885568U, 12892864U, 12902336U, 12909376U, - 12918208U, 12926656U, 12934976U, 12942784U, 12951104U, 12959552U, 12967744U, - 12976064U, 12984256U, 12991936U, 12999488U, 13007936U, 13016768U, 13021504U, - 13033024U, 13041472U, 13049408U, 13057472U, 13065664U, 13072064U, 13081408U, - 13089344U, 13098688U, 13107008U, 13115072U, 13122752U, 13130944U, 13139648U, - 13147712U, 13155776U, 13162432U, 13172672U, 13180864U, 13188928U, 13196992U, - 13203392U, 13213504U, 13219264U, 13228736U, 13236928U, 13244992U, 13253056U, - 13262528U, 13269952U, 13278784U, 13285952U, 13295552U, 13303616U, 13311808U, - 13319744U, 13328192U, 13336256U, 13344704U, 13352384U, 13360576U, 13369024U, - 13377344U, 13385408U, 13393216U, 13401664U, 13410112U, 13418176U, 13426496U, - 13434688U, 13442368U, 13451072U, 13459136U, 13466944U, 13475648U, 13482944U, - 13491904U, 13500352U, 13508288U, 13516736U, 13524416U, 13532224U, 13541312U, - 13549504U, 13556288U, 13564736U, 13573184U, 13581376U, 13587008U, 13598656U, - 13605952U, 13612864U, 13622464U, 13631168U, 13639616U, 13647808U, 13655104U, - 13663424U, 13671872U, 13680064U, 13688768U, 13696576U, 13705024U, 13712576U, - 13721536U, 13729216U, 13737664U, 13746112U, 13753024U, 13759552U, 13770304U, - 13777856U, 13786688U, 13793984U, 13802176U, 13811264U, 13819328U, 13827904U, - 13835456U, 13844416U, 13851584U, 13860544U, 13868992U, 13877056U, 13884608U, - 13893184U, 13901248U, 13909696U, 13917632U, 13925056U, 13934528U, 13942336U, - 13950784U, 13959104U, 13966912U, 13975232U, 13982656U, 13991872U, 13999936U, - 14007872U, 14016064U, 14024512U, 14032064U, 14040896U, 14049088U, 14057408U, - 14065088U, 14072896U, 14081344U, 14089664U, 14097856U, 14106304U, 14114752U, - 14122688U, 14130752U, 14138816U, 14147008U, 14155072U, 14163904U, 14170432U, - 14180288U, 14187328U, 14196032U, 14204864U, 14212672U, 14220736U, 14229056U, - 14237504U, 14245568U, 14253632U, 14261824U, 14269888U, 14278592U, 14286656U, - 14293696U, 14302784U, 14309696U, 14317504U, 14326336U, 14335936U, 14343232U, - 14352064U, 14359232U, 14368064U, 14376512U, 14384576U, 14393024U, 14401472U, - 14409536U, 14416832U, 14424512U, 14433856U, 14440768U, 14449984U, 14458816U, - 14465728U, 14474816U, 14482112U, 14491328U, 14499392U, 14506816U, 14516032U, - 14524352U, 14531392U, 14540224U, 14547392U, 14556992U, 14565184U, 14573248U, - 14580928U, 14588864U, 14596928U, 14606272U, 14613824U, 14622656U, 14630464U, - 14638912U, 14646976U, 14655296U, 14661952U, 14671808U, 14679872U, 14687936U, - 14696384U, 14704576U, 14710336U, 14720192U, 14729152U, 14736448U, 14745152U, - 14752448U, 14761792U, 14769856U, 14777024U, 14785984U, 14792384U, 14802752U, - 14810816U, 14819264U, 14827328U, 14835136U, 14843072U, 14851264U, 14860096U, - 14867648U, 14876096U, 14884544U, 14892736U, 14900672U, 14907968U, 14917312U, - 14924864U, 14933824U, 14939968U, 14950336U, 14957632U, 14966464U, 14974912U, - 14982592U, 14991296U, 14999104U, 15006272U, 15015232U, 15023936U, 15031616U, - 15040448U, 15047488U, 15055552U, 15063616U, 15073216U, 15079744U, 15088064U, - 15097664U, 15105344U, 15113792U, 15122368U, 15130048U, 15137728U, 15146176U, - 15154112U, 15162688U, 15171392U, 15179456U, 15187264U, 15194176U, 15204032U, - 15212224U, 15220544U, 15227456U, 15237056U, 15245248U, 15253184U, 15261632U, - 15269824U, 15277376U, 15285824U, 15293888U, 15301568U, 15310784U, 15318848U, - 15325504U, 15335104U, 15343168U, 15350848U, 15359936U, 15367232U, 15373376U, - 15384256U, 15392576U, 15400384U, 15408832U, 15417152U, 15424832U, 15433024U, - 15441344U, 15449152U, 15457088U, 15466432U, 15474112U, 15482816U, 15488576U, - 15499072U, 15505856U, 15514816U, 15523264U, 15531584U, 15540032U, 15547328U, - 15553984U, 15564608U, 15571904U, 15579968U, 15589312U, 15597376U, 15605696U, - 15612992U, 15621824U, 15630016U, 15638464U, 15646144U, 15654592U, 15662912U, - 15671104U, 15677248U, 15686848U, 15693376U, 15701696U, 15712064U, 15720256U, - 15728576U, 15736384U, 15744704U, 15752512U, 15761344U, 15769024U, 15777728U, - 15785152U, 15793984U, 15802048U, 15809984U, 15817024U, 15825856U, 15834944U, - 15843008U, 15849664U, 15859136U, 15866432U, 15876032U, 15884096U, 15892288U, - 15900608U, 15908416U, 15916864U, 15924928U, 15930176U, 15941056U, 15949504U, - 15957824U, 15965632U, 15973952U, 15982528U, 15990592U, 15998272U, 16006976U, - 16012736U, 16023104U, 16031296U, 16039616U, 16048064U, 16055744U, 16064192U, - 16071488U, 16080832U, 16088768U, 16097216U, 16104896U, 16112704U, 16121792U, - 16129856U, 16138048U, 16146112U, 16154176U, 16162624U, 16170688U, 16177856U, - 16186816U, 16195136U, 16202176U, 16211648U, 16220096U, 16228288U, 16235584U, - 16244672U, 16252864U, 16260544U, 16269248U, 16277056U, 16285504U, 16291648U, - 16301632U, 16309312U, 16318144U, 16326208U, 16333888U, 16342336U, 16351168U, - 16359232U, 16367552U, 16375616U, 16383296U, 16391744U, 16398016U, 16407616U, - 16415936U, 16424896U, 16432448U, 16440896U, 16449088U, 16457024U, 16465472U, - 16474048U, 16481216U, 16490048U, 16498624U, 16505792U, 16513984U, 16523072U, - 16531136U, 16538944U, 16547264U, 16555328U, 16563776U, 16570816U, 16578112U, - 16587712U, 16596544U, 16604992U, 16613312U, 16620608U, 16629568U, 16637888U, - 16645696U, 16653632U, 16661696U, 16669888U, 16677568U, 16686272U, 16695232U, - 16703168U, 16710464U, 16719424U, 16726592U, 16733888U, 16744384U, 16752448U, - 16760768U, 16768448U, 16776896U, 16785344U, 16793536U, 16801216U, 16809664U, - 16818112U, 16826176U, 16833472U, 16842688U, 16850752U, 16859072U, 16866368U, - 16875328U, 16883392U, 16891712U, 16899776U, 16907456U, 16915264U, 16924352U, - 16931776U, 16940608U, 16949056U, 16957376U, 16965056U, 16973248U, 16981696U, - 16990144U, 16997056U, 17005888U, 17014208U, 17021504U, 17031104U, 17039296U, - 17046976U, 17055424U, 17062592U, 17070016U, 17079488U, 17087936U, 17096512U, - 17104576U, 17113024U, 17121088U, 17129408U, 17136832U, 17145664U, 17152832U, - 17161792U, 17170112U, 17177792U, 17186368U, 17194304U, 17202496U, 17211328U, - 17218624U, 17227712U, 17233984U, 17243584U, 17251904U, 17259712U, 17266624U, - 17276608U, 17284672U, 17292224U, 17301056U, 17309632U, 17317568U, 17326016U, - 17333824U, 17342272U, 17350208U, 17358784U, 17366848U, 17374912U, 17382592U, - 17390656U, 17399488U, 17406784U, 17413952U, 17423936U, 17432512U, 17440448U, - 17447744U, 17456704U, 17464768U, 17472064U, 17481536U, 17489344U, 17495488U, - 17505728U, 17513792U, 17522368U, 17530816U, 17538112U, 17546944U, 17555264U, - 17563072U, 17569856U, 17579456U, 17587904U, 17596352U, 17603776U, 17611712U, - 17620672U, 17628992U, 17637184U, 17645504U, 17653568U, 17661632U, 17669824U, - 17677376U, 17686208U, 17693888U, 17702336U, 17710144U, 17718208U, 17726528U, - 17734336U, 17743808U, 17751872U, 17759936U, 17766592U, 17776448U, 17784512U, - 17791936U, 17801152U, 17809216U, 17817152U +const size_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, + 19529408U, 19660096U, 19791424U, 19922752U, 20053952U, 20184896U, 20315968U, + 20446912U, 20576576U, 20709184U, 20840384U, 20971072U, 21102272U, 21233216U, + 21364544U, 21494848U, 21626816U, 21757376U, 21887552U, 22019392U, 22151104U, + 22281536U, 22412224U, 22543936U, 22675264U, 22806464U, 22935872U, 23068096U, + 23198272U, 23330752U, 23459008U, 23592512U, 23723968U, 23854912U, 23986112U, + 24116672U, 24247616U, 24378688U, 24509504U, 24640832U, 24772544U, 24903488U, + 25034432U, 25165376U, 25296704U, 25427392U, 25558592U, 25690048U, 25820096U, + 25951936U, 26081728U, 26214208U, 26345024U, 26476096U, 26606656U, 26737472U, + 26869184U, 26998208U, 27131584U, 27262528U, 27393728U, 27523904U, 27655744U, + 27786688U, 27917888U, 28049344U, 28179904U, 28311488U, 28441792U, 28573504U, + 28700864U, 28835648U, 28966208U, 29096768U, 29228608U, 29359808U, 29490752U, + 29621824U, 29752256U, 29882816U, 30014912U, 30144448U, 30273728U, 30406976U, + 30538432U, 30670784U, 30799936U, 30932672U, 31063744U, 31195072U, 31325248U, + 31456192U, 31588288U, 31719232U, 31850432U, 31981504U, 32110784U, 32243392U, + 32372672U, 32505664U, 32636608U, 32767808U, 32897344U, 33029824U, 33160768U, + 33289664U, 33423296U, 33554368U, 33683648U, 33816512U, 33947456U, 34076992U, + 34208704U, 34340032U, 34471744U, 34600256U, 34734016U, 34864576U, 34993984U, + 35127104U, 35258176U, 35386688U, 35518528U, 35650624U, 35782336U, 35910976U, + 36044608U, 36175808U, 36305728U, 36436672U, 36568384U, 36699968U, 36830656U, + 36961984U, 37093312U, 37223488U, 37355072U, 37486528U, 37617472U, 37747904U, + 37879232U, 38009792U, 38141888U, 38272448U, 38403392U, 38535104U, 38660672U, + 38795584U, 38925632U, 39059264U, 39190336U, 39320768U, 39452096U, 39581632U, + 39713984U, 39844928U, 39974848U, 40107968U, 40238144U, 40367168U, 40500032U, + 40631744U, 40762816U, 40894144U, 41023552U, 41155904U, 41286208U, 41418304U, + 41547712U, 41680448U, 41811904U, 41942848U, 42073792U, 42204992U, 42334912U, + 42467008U, 42597824U, 42729152U, 42860096U, 42991552U, 43122368U, 43253696U, + 43382848U, 43515712U, 43646912U, 43777088U, 43907648U, 44039104U, 44170432U, + 44302144U, 44433344U, 44564288U, 44694976U, 44825152U, 44956864U, 45088448U, + 45219008U, 45350464U, 45481024U, 45612608U, 45744064U, 45874496U, 46006208U, + 46136768U, 46267712U, 46399424U, 46529344U, 46660672U, 46791488U, 46923328U, + 47053504U, 47185856U, 47316928U, 47447872U, 47579072U, 47710144U, 47839936U, + 47971648U, 48103232U, 48234176U, 48365248U, 48496192U, 48627136U, 48757312U, + 48889664U, 49020736U, 49149248U, 49283008U, 49413824U, 49545152U, 49675712U, + 49807168U, 49938368U, 50069056U, 50200256U, 50331584U, 50462656U, 50593472U, + 50724032U, 50853952U, 50986048U, 51117632U, 51248576U, 51379904U, 51510848U, + 51641792U, 51773248U, 51903296U, 52035136U, 52164032U, 52297664U, 52427968U, + 52557376U, 52690112U, 52821952U, 52952896U, 53081536U, 53213504U, 53344576U, + 53475776U, 53608384U, 53738816U, 53870528U, 54000832U, 54131776U, 54263744U, + 54394688U, 54525248U, 54655936U, 54787904U, 54918592U, 55049152U, 55181248U, + 55312064U, 55442752U, 55574336U, 55705024U, 55836224U, 55967168U, 56097856U, + 56228672U, 56358592U, 56490176U, 56621888U, 56753728U, 56884928U, 57015488U, + 57146816U, 57278272U, 57409216U, 57540416U, 57671104U, 57802432U, 57933632U, + 58064576U, 58195264U, 58326976U, 58457408U, 58588864U, 58720192U, 58849984U, + 58981696U, 59113024U, 59243456U, 59375552U, 59506624U, 59637568U, 59768512U, + 59897792U, 60030016U, 60161984U, 60293056U, 60423872U, 60554432U, 60683968U, + 60817216U, 60948032U, 61079488U, 61209664U, 61341376U, 61471936U, 61602752U, + 61733696U, 61865792U, 61996736U, 62127808U, 62259136U, 62389568U, 62520512U, + 62651584U, 62781632U, 62910784U, 63045056U, 63176128U, 63307072U, 63438656U, + 63569216U, 63700928U, 63831616U, 63960896U, 64093888U, 64225088U, 64355392U, + 64486976U, 64617664U, 64748608U, 64879424U, 65009216U, 65142464U, 65273792U, + 65402816U, 65535424U, 65666752U, 65797696U, 65927744U, 66060224U, 66191296U, + 66321344U, 66453056U, 66584384U, 66715328U, 66846656U, 66977728U, 67108672U, + 67239104U, 67370432U, 67501888U, 67631296U, 67763776U, 67895104U, 68026304U, + 68157248U, 68287936U, 68419264U, 68548288U, 68681408U, 68811968U, 68942912U, + 69074624U, 69205568U, 69337024U, 69467584U, 69599168U, 69729472U, 69861184U, + 69989824U, 70122944U, 70253888U, 70385344U, 70515904U, 70647232U, 70778816U, + 70907968U, 71040832U, 71171648U, 71303104U, 71432512U, 71564992U, 71695168U, + 71826368U, 71958464U, 72089536U, 72219712U, 72350144U, 72482624U, 72613568U, + 72744512U, 72875584U, 73006144U, 73138112U, 73268672U, 73400128U, 73530944U, + 73662272U, 73793344U, 73924544U, 74055104U, 74185792U, 74316992U, 74448832U, + 74579392U, 74710976U, 74841664U, 74972864U, 75102784U, 75233344U, 75364544U, + 75497024U, 75627584U, 75759296U, 75890624U, 76021696U, 76152256U, 76283072U, + 76414144U, 76545856U, 76676672U, 76806976U, 76937792U, 77070016U, 77200832U, + 77331392U, 77462464U, 77593664U, 77725376U, 77856448U, 77987776U, 78118336U, + 78249664U, 78380992U, 78511424U, 78642496U, 78773056U, 78905152U, 79033664U, + 79166656U, 79297472U, 79429568U, 79560512U, 79690816U, 79822784U, 79953472U, + 80084672U, 80214208U, 80346944U, 80477632U, 80608576U, 80740288U, 80870848U, + 81002048U, 81133504U, 81264448U, 81395648U, 81525952U, 81657536U, 81786304U, + 81919808U, 82050112U, 82181312U, 82311616U, 82443968U, 82573376U, 82705984U, + 82835776U, 82967744U, 83096768U, 83230528U, 83359552U, 83491264U, 83622464U, + 83753536U, 83886016U, 84015296U, 84147776U, 84277184U, 84409792U, 84540608U, + 84672064U, 84803008U, 84934336U, 85065152U, 85193792U, 85326784U, 85458496U, + 85589312U, 85721024U, 85851968U, 85982656U, 86112448U, 86244416U, 86370112U, + 86506688U, 86637632U, 86769344U, 86900672U, 87031744U, 87162304U, 87293632U, + 87424576U, 87555392U, 87687104U, 87816896U, 87947968U, 88079168U, 88211264U, + 88341824U, 88473152U, 88603712U, 88735424U, 88862912U, 88996672U, 89128384U, + 89259712U, 89390272U, 89521984U, 89652544U, 89783872U, 89914816U, 90045376U, + 90177088U, 90307904U, 90438848U, 90569152U, 90700096U, 90832832U, 90963776U, + 91093696U, 91223744U, 91356992U, 91486784U, 91618496U, 91749824U, 91880384U, + 92012224U, 92143552U, 92273344U, 92405696U, 92536768U, 92666432U, 92798912U, + 92926016U, 93060544U, 93192128U, 93322816U, 93453632U, 93583936U, 93715136U, + 93845056U, 93977792U, 94109504U, 94240448U, 94371776U, 94501184U, 94632896U, + 94764224U, 94895552U, 95023424U, 95158208U, 95287744U, 95420224U, 95550016U, + 95681216U, 95811904U, 95943872U, 96075328U, 96203584U, 96337856U, 96468544U, + 96599744U, 96731072U, 96860992U, 96992576U, 97124288U, 97254848U, 97385536U, + 97517248U, 97647808U, 97779392U, 97910464U, 98041408U, 98172608U, 98303168U, + 98434496U, 98565568U, 98696768U, 98827328U, 98958784U, 99089728U, 99220928U, + 99352384U, 99482816U, 99614272U, 99745472U, 99876416U, 100007104U, + 100138048U, 100267072U, 100401088U, 100529984U, 100662592U, 100791872U, + 100925248U, 101056064U, 101187392U, 101317952U, 101449408U, 101580608U, + 101711296U, 101841728U, 101973824U, 102104896U, 102235712U, 102366016U, + 102498112U, 102628672U, 102760384U, 102890432U, 103021888U, 103153472U, + 103284032U, 103415744U, 103545152U, 103677248U, 103808576U, 103939648U, + 104070976U, 104201792U, 104332736U, 104462528U, 104594752U, 104725952U, + 104854592U, 104988608U, 105118912U, 105247808U, 105381184U, 105511232U, + 105643072U, 105774784U, 105903296U, 106037056U, 106167872U, 106298944U, + 106429504U, 106561472U, 106691392U, 106822592U, 106954304U, 107085376U, + 107216576U, 107346368U, 107478464U, 107609792U, 107739712U, 107872192U, + 108003136U, 108131392U, 108265408U, 108396224U, 108527168U, 108657344U, + 108789568U, 108920384U, 109049792U, 109182272U, 109312576U, 109444928U, + 109572928U, 109706944U, 109837888U, 109969088U, 110099648U, 110230976U, + 110362432U, 110492992U, 110624704U, 110755264U, 110886208U, 111017408U, + 111148864U, 111279296U, 111410752U, 111541952U, 111673024U, 111803456U, + 111933632U, 112066496U, 112196416U, 112328512U, 112457792U, 112590784U, + 112715968U, 112852672U, 112983616U, 113114944U, 113244224U, 113376448U, + 113505472U, 113639104U, 113770304U, 113901376U, 114031552U, 114163264U, + 114294592U, 114425536U, 114556864U, 114687424U, 114818624U, 114948544U, + 115080512U, 115212224U, 115343296U, 115473472U, 115605184U, 115736128U, + 115867072U, 115997248U, 116128576U, 116260288U, 116391488U, 116522944U, + 116652992U, 116784704U, 116915648U, 117046208U, 117178304U, 117308608U, + 117440192U, 117569728U, 117701824U, 117833024U, 117964096U, 118094656U, + 118225984U, 118357312U, 118489024U, 118617536U, 118749632U, 118882112U, + 119012416U, 119144384U, 119275328U, 119406016U, 119537344U, 119668672U, + 119798464U, 119928896U, 120061376U, 120192832U, 120321728U, 120454336U, + 120584512U, 120716608U, 120848192U, 120979136U, 121109056U, 121241408U, + 121372352U, 121502912U, 121634752U, 121764416U, 121895744U, 122027072U, + 122157632U, 122289088U, 122421184U, 122550592U, 122682944U, 122813888U, + 122945344U, 123075776U, 123207488U, 123338048U, 123468736U, 123600704U, + 123731264U, 123861952U, 123993664U, 124124608U, 124256192U, 124386368U, + 124518208U, 124649024U, 124778048U, 124911296U, 125041088U, 125173696U, + 125303744U, 125432896U, 125566912U, 125696576U, 125829056U, 125958592U, + 126090304U, 126221248U, 126352832U, 126483776U, 126615232U, 126746432U, + 126876608U, 127008704U, 127139392U, 127270336U, 127401152U, 127532224U, + 127663552U, 127794752U, 127925696U, 128055232U, 128188096U, 128319424U, + 128449856U, 128581312U, 128712256U, 128843584U, 128973632U, 129103808U, + 129236288U, 129365696U, 129498944U, 129629888U, 129760832U, 129892288U, + 130023104U, 130154048U, 130283968U, 130416448U, 130547008U, 130678336U, + 130807616U, 130939456U, 131071552U, 131202112U, 131331776U, 131464384U, + 131594048U, 131727296U, 131858368U, 131987392U, 132120256U, 132250816U, + 132382528U, 132513728U, 132644672U, 132774976U, 132905792U, 133038016U, + 133168832U, 133299392U, 133429312U, 133562048U, 133692992U, 133823296U, + 133954624U, 134086336U, 134217152U, 134348608U, 134479808U, 134607296U, + 134741056U, 134872384U, 135002944U, 135134144U, 135265472U, 135396544U, + 135527872U, 135659072U, 135787712U, 135921472U, 136052416U, 136182848U, + 136313792U, 136444864U, 136576448U, 136707904U, 136837952U, 136970048U, + 137099584U, 137232064U, 137363392U, 137494208U, 137625536U, 137755712U, + 137887424U, 138018368U, 138149824U, 138280256U, 138411584U, 138539584U, + 138672832U, 138804928U, 138936128U, 139066688U, 139196864U, 139328704U, + 139460032U, 139590208U, 139721024U, 139852864U, 139984576U, 140115776U, + 140245696U, 140376512U, 140508352U, 140640064U, 140769856U, 140902336U, + 141032768U, 141162688U, 141294016U, 141426496U, 141556544U, 141687488U, + 141819584U, 141949888U, 142080448U, 142212544U, 142342336U, 142474432U, + 142606144U, 142736192U, 142868288U, 142997824U, 143129408U, 143258944U, + 143392448U, 143523136U, 143653696U, 143785024U, 143916992U, 144045632U, + 144177856U, 144309184U, 144440768U, 144570688U, 144701888U, 144832448U, + 144965056U, 145096384U, 145227584U, 145358656U, 145489856U, 145620928U, + 145751488U, 145883072U, 146011456U, 146144704U, 146275264U, 146407232U, + 146538176U, 146668736U, 146800448U, 146931392U, 147062336U, 147193664U, + 147324224U, 147455936U, 147586624U, 147717056U, 147848768U, 147979456U, + 148110784U, 148242368U, 148373312U, 148503232U, 148635584U, 148766144U, + 148897088U, 149028416U, 149159488U, 149290688U, 149420224U, 149551552U, + 149683136U, 149814976U, 149943616U, 150076352U, 150208064U, 150338624U, + 150470464U, 150600256U, 150732224U, 150862784U, 150993088U, 151125952U, + 151254976U, 151388096U, 151519168U, 151649728U, 151778752U, 151911104U, + 152042944U, 152174144U, 152304704U, 152435648U, 152567488U, 152698816U, + 152828992U, 152960576U, 153091648U, 153222976U, 153353792U, 153484096U, + 153616192U, 153747008U, 153878336U, 154008256U, 154139968U, 154270912U, + 154402624U, 154533824U, 154663616U, 154795712U, 154926272U, 155057984U, + 155188928U, 155319872U, 155450816U, 155580608U, 155712064U, 155843392U, + 155971136U, 156106688U, 156237376U, 156367424U, 156499264U, 156630976U, + 156761536U, 156892352U, 157024064U, 157155008U, 157284416U, 157415872U, + 157545536U, 157677248U, 157810496U, 157938112U, 158071744U, 158203328U, + 158334656U, 158464832U, 158596288U, 158727616U, 158858048U, 158988992U, + 159121216U, 159252416U, 159381568U, 159513152U, 159645632U, 159776192U, + 159906496U, 160038464U, 160169536U, 160300352U, 160430656U, 160563008U, + 160693952U, 160822208U, 160956352U, 161086784U, 161217344U, 161349184U, + 161480512U, 161611456U, 161742272U, 161873216U, 162002752U, 162135872U, + 162266432U, 162397888U, 162529216U, 162660032U, 162790976U, 162922048U, + 163052096U, 163184576U, 163314752U, 163446592U, 163577408U, 163707968U, + 163839296U, 163969984U, 164100928U, 164233024U, 164364224U, 164494912U, + 164625856U, 164756672U, 164887616U, 165019072U, 165150016U, 165280064U, + 165412672U, 165543104U, 165674944U, 165805888U, 165936832U, 166067648U, + 166198336U, 166330048U, 166461248U, 166591552U, 166722496U, 166854208U, + 166985408U, 167116736U, 167246656U, 167378368U, 167508416U, 167641024U, + 167771584U, 167903168U, 168034112U, 168164032U, 168295744U, 168427456U, + 168557632U, 168688448U, 168819136U, 168951616U, 169082176U, 169213504U, + 169344832U, 169475648U, 169605952U, 169738048U, 169866304U, 169999552U, + 170131264U, 170262464U, 170393536U, 170524352U, 170655424U, 170782016U, + 170917696U, 171048896U, 171179072U, 171310784U, 171439936U, 171573184U, + 171702976U, 171835072U, 171966272U, 172097216U, 172228288U, 172359232U, + 172489664U, 172621376U, 172747712U, 172883264U, 173014208U, 173144512U, + 173275072U, 173407424U, 173539136U, 173669696U, 173800768U, 173931712U, + 174063424U, 174193472U, 174325696U, 174455744U, 174586816U, 174718912U, + 174849728U, 174977728U, 175109696U, 175242688U, 175374272U, 175504832U, + 175636288U, 175765696U, 175898432U, 176028992U, 176159936U, 176291264U, + 176422592U, 176552512U, 176684864U, 176815424U, 176946496U, 177076544U, + 177209152U, 177340096U, 177470528U, 177600704U, 177731648U, 177864256U, + 177994816U, 178126528U, 178257472U, 178387648U, 178518464U, 178650176U, + 178781888U, 178912064U, 179044288U, 179174848U, 179305024U, 179436736U, + 179568448U, 179698496U, 179830208U, 179960512U, 180092608U, 180223808U, + 180354752U, 180485696U, 180617152U, 180748096U, 180877504U, 181009984U, + 181139264U, 181272512U, 181402688U, 181532608U, 181663168U, 181795136U, + 181926592U, 182057536U, 182190016U, 182320192U, 182451904U, 182582336U, + 182713792U, 182843072U, 182976064U, 183107264U, 183237056U, 183368384U, + 183494848U, 183631424U, 183762752U, 183893824U, 184024768U, 184154816U, + 184286656U, 184417984U, 184548928U, 184680128U, 184810816U, 184941248U, + 185072704U, 185203904U, 185335616U, 185465408U, 185596352U, 185727296U, + 185859904U, 185989696U, 186121664U, 186252992U, 186383552U, 186514112U, + 186645952U, 186777152U, 186907328U, 187037504U, 187170112U, 187301824U, + 187429184U, 187562048U, 187693504U, 187825472U, 187957184U, 188087104U, + 188218304U, 188349376U, 188481344U, 188609728U, 188743616U, 188874304U, + 189005248U, 189136448U, 189265088U, 189396544U, 189528128U, 189660992U, + 189791936U, 189923264U, 190054208U, 190182848U, 190315072U, 190447424U, + 190577984U, 190709312U, 190840768U, 190971328U, 191102656U, 191233472U, + 191364032U, 191495872U, 191626816U, 191758016U, 191888192U, 192020288U, + 192148928U, 192282176U, 192413504U, 192542528U, 192674752U, 192805952U, + 192937792U, 193068608U, 193198912U, 193330496U, 193462208U, 193592384U, + 193723456U, 193854272U, 193985984U, 194116672U, 194247232U, 194379712U, + 194508352U, 194641856U, 194772544U, 194900672U, 195035072U, 195166016U, + 195296704U, 195428032U, 195558592U, 195690304U, 195818176U, 195952576U, + 196083392U, 196214336U, 196345792U, 196476736U, 196607552U, 196739008U, + 196869952U, 197000768U, 197130688U, 197262784U, 197394368U, 197523904U, + 197656384U, 197787584U, 197916608U, 198049472U, 198180544U, 198310208U, + 198442432U, 198573632U, 198705088U, 198834368U, 198967232U, 199097792U, + 199228352U, 199360192U, 199491392U, 199621696U, 199751744U, 199883968U, + 200014016U, 200146624U, 200276672U, 200408128U, 200540096U, 200671168U, + 200801984U, 200933312U, 201062464U, 201194944U, 201326144U, 201457472U, + 201588544U, 201719744U, 201850816U, 201981632U, 202111552U, 202244032U, + 202374464U, 202505152U, 202636352U, 202767808U, 202898368U, 203030336U, + 203159872U, 203292608U, 203423296U, 203553472U, 203685824U, 203816896U, + 203947712U, 204078272U, 204208192U, 204341056U, 204472256U, 204603328U, + 204733888U, 204864448U, 204996544U, 205125568U, 205258304U, 205388864U, + 205517632U, 205650112U, 205782208U, 205913536U, 206044736U, 206176192U, + 206307008U, 206434496U, 206569024U, 206700224U, 206831168U, 206961856U, + 207093056U, 207223616U, 207355328U, 207486784U, 207616832U, 207749056U, + 207879104U, 208010048U, 208141888U, 208273216U, 208404032U, 208534336U, + 208666048U, 208796864U, 208927424U, 209059264U, 209189824U, 209321792U, + 209451584U, 209582656U, 209715136U, 209845568U, 209976896U, 210106432U, + 210239296U, 210370112U, 210501568U, 210630976U, 210763712U, 210894272U, + 211024832U, 211156672U, 211287616U, 211418176U, 211549376U, 211679296U, + 211812032U, 211942592U, 212074432U, 212204864U, 212334016U, 212467648U, + 212597824U, 212727616U, 212860352U, 212991424U, 213120832U, 213253952U, + 213385024U, 213515584U, 213645632U, 213777728U, 213909184U, 214040128U, + 214170688U, 214302656U, 214433728U, 214564544U, 214695232U, 214826048U, + 214956992U, 215089088U, 215219776U, 215350592U, 215482304U, 215613248U, + 215743552U, 215874752U, 216005312U, 216137024U, 216267328U, 216399296U, + 216530752U, 216661696U, 216790592U, 216923968U, 217054528U, 217183168U, + 217316672U, 217448128U, 217579072U, 217709504U, 217838912U, 217972672U, + 218102848U, 218233024U, 218364736U, 218496832U, 218627776U, 218759104U, + 218888896U, 219021248U, 219151936U, 219281728U, 219413056U, 219545024U, + 219675968U, 219807296U, 219938624U, 220069312U, 220200128U, 220331456U, + 220461632U, 220592704U, 220725184U, 220855744U, 220987072U, 221117888U, + 221249216U, 221378368U, 221510336U, 221642048U, 221772736U, 221904832U, + 222031808U, 222166976U, 222297536U, 222428992U, 222559936U, 222690368U, + 222820672U, 222953152U, 223083968U, 223213376U, 223345984U, 223476928U, + 223608512U, 223738688U, 223869376U, 224001472U, 224132672U, 224262848U, + 224394944U, 224524864U, 224657344U, 224788288U, 224919488U, 225050432U, + 225181504U, 225312704U, 225443776U, 225574592U, 225704768U, 225834176U, + 225966784U, 226097216U, 226229824U, 226360384U, 226491712U, 226623424U, + 226754368U, 226885312U, 227015104U, 227147456U, 227278528U, 227409472U, + 227539904U, 227669696U, 227802944U, 227932352U, 228065216U, 228196288U, + 228326464U, 228457792U, 228588736U, 228720064U, 228850112U, 228981056U, + 229113152U, 229243328U, 229375936U, 229505344U, 229636928U, 229769152U, + 229894976U, 230030272U, 230162368U, 230292416U, 230424512U, 230553152U, + 230684864U, 230816704U, 230948416U, 231079616U, 231210944U, 231342016U, + 231472448U, 231603776U, 231733952U, 231866176U, 231996736U, 232127296U, + 232259392U, 232388672U, 232521664U, 232652608U, 232782272U, 232914496U, + 233043904U, 233175616U, 233306816U, 233438528U, 233569984U, 233699776U, + 233830592U, 233962688U, 234092224U, 234221888U, 234353984U, 234485312U, + 234618304U, 234749888U, 234880832U, 235011776U, 235142464U, 235274048U, + 235403456U, 235535936U, 235667392U, 235797568U, 235928768U, 236057152U, + 236190272U, 236322752U, 236453312U, 236583616U, 236715712U, 236846528U, + 236976448U, 237108544U, 237239104U, 237371072U, 237501632U, 237630784U, + 237764416U, 237895232U, 238026688U, 238157632U, 238286912U, 238419392U, + 238548032U, 238681024U, 238812608U, 238941632U, 239075008U, 239206336U, + 239335232U, 239466944U, 239599168U, 239730496U, 239861312U, 239992384U, + 240122816U, 240254656U, 240385856U, 240516928U, 240647872U, 240779072U, + 240909632U, 241040704U, 241171904U, 241302848U, 241433408U, 241565248U, + 241696192U, 241825984U, 241958848U, 242088256U, 242220224U, 242352064U, + 242481856U, 242611648U, 242744896U, 242876224U, 243005632U, 243138496U, + 243268672U, 243400384U, 243531712U, 243662656U, 243793856U, 243924544U, + 244054592U, 244187072U, 244316608U, 244448704U, 244580032U, 244710976U, + 244841536U, 244972864U, 245104448U, 245233984U, 245365312U, 245497792U, + 245628736U, 245759936U, 245889856U, 246021056U, 246152512U, 246284224U, + 246415168U, 246545344U, 246675904U, 246808384U, 246939584U, 247070144U, + 247199552U, 247331648U, 247463872U, 247593536U, 247726016U, 247857088U, + 247987648U, 248116928U, 248249536U, 248380736U, 248512064U, 248643008U, + 248773312U, 248901056U, 249036608U, 249167552U, 249298624U, 249429184U, + 249560512U, 249692096U, 249822784U, 249954112U, 250085312U, 250215488U, + 250345792U, 250478528U, 250608704U, 250739264U, 250870976U, 251002816U, + 251133632U, 251263552U, 251395136U, 251523904U, 251657792U, 251789248U, + 251919424U, 252051392U, 252182464U, 252313408U, 252444224U, 252575552U, + 252706624U, 252836032U, 252968512U, 253099712U, 253227584U, 253361728U, + 253493056U, 253623488U, 253754432U, 253885504U, 254017216U, 254148032U, + 254279488U, 254410432U, 254541376U, 254672576U, 254803264U, 254933824U, + 255065792U, 255196736U, 255326528U, 255458752U, 255589952U, 255721408U, + 255851072U, 255983296U, 256114624U, 256244416U, 256374208U, 256507712U, + 256636096U, 256768832U, 256900544U, 257031616U, 257162176U, 257294272U, + 257424448U, 257555776U, 257686976U, 257818432U, 257949632U, 258079552U, + 258211136U, 258342464U, 258473408U, 258603712U, 258734656U, 258867008U, + 258996544U, 259127744U, 259260224U, 259391296U, 259522112U, 259651904U, + 259784384U, 259915328U, 260045888U, 260175424U, 260308544U, 260438336U, + 260570944U, 260700992U, 260832448U, 260963776U, 261092672U, 261226304U, + 261356864U, 261487936U, 261619648U, 261750592U, 261879872U, 262011968U, + 262143424U, 262274752U, 262404416U, 262537024U, 262667968U, 262799296U, + 262928704U, 263061184U, 263191744U, 263322944U, 263454656U, 263585216U, + 263716672U, 263847872U, 263978944U, 264108608U, 264241088U, 264371648U, + 264501184U, 264632768U, 264764096U, 264895936U, 265024576U, 265158464U, + 265287488U, 265418432U, 265550528U, 265681216U, 265813312U, 265943488U, + 266075968U, 266206144U, 266337728U, 266468032U, 266600384U, 266731072U, + 266862272U, 266993344U, 267124288U, 267255616U, 267386432U, 267516992U, + 267648704U, 267777728U, 267910592U, 268040512U, 268172096U, 268302784U, + 268435264U, 268566208U, 268696256U, 268828096U, 268959296U, 269090368U, + 269221312U, 269352256U, 269482688U, 269614784U, 269745856U, 269876416U, + 270007616U, 270139328U, 270270272U, 270401216U, 270531904U, 270663616U, + 270791744U, 270924736U, 271056832U, 271186112U, 271317184U, 271449536U, + 271580992U, 271711936U, 271843136U, 271973056U, 272105408U, 272236352U, + 272367296U, 272498368U, 272629568U, 272759488U, 272891456U, 273022784U, + 273153856U, 273284672U, 273415616U, 273547072U, 273677632U, 273808448U, + 273937088U, 274071488U, 274200896U, 274332992U, 274463296U, 274595392U, + 274726208U, 274857536U, 274988992U, 275118656U, 275250496U, 275382208U, + 275513024U, 275643968U, 275775296U, 275906368U, 276037184U, 276167872U, + 276297664U, 276429376U, 276560576U, 276692672U, 276822976U, 276955072U, + 277085632U, 277216832U, 277347008U, 277478848U, 277609664U, 277740992U, + 277868608U, 278002624U, 278134336U, 278265536U, 278395328U, 278526784U, + 278657728U, 278789824U, 278921152U, 279052096U, 279182912U, 279313088U, + 279443776U, 279576256U, 279706048U, 279838528U, 279969728U, 280099648U, + 280230976U, 280361408U, 280493632U, 280622528U, 280755392U, 280887104U, + 281018176U, 281147968U, 281278912U, 281411392U, 281542592U, 281673152U, + 281803712U, 281935552U, 282066496U, 282197312U, 282329024U, 282458816U, + 282590272U, 282720832U, 282853184U, 282983744U, 283115072U, 283246144U, + 283377344U, 283508416U, 283639744U, 283770304U, 283901504U, 284032576U, + 284163136U, 284294848U, 284426176U, 284556992U, 284687296U, 284819264U, + 284950208U, 285081536U }; #ifdef __cplusplus 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 82421b868..a7159de65 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 @@ -1,18 +1,18 @@ /* - This file is part of cpp-ethereum. + This file is part of ethash. - cpp-ethereum is free software: you can redistribute it and/or modify + 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. - cpp-ethereum is distributed in the hope that it will be useful, + 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 cpp-ethereum. If not, see . + along with ethash. If not, see . */ /** @file ethash.h @@ -26,13 +26,15 @@ #include #include "compiler.h" -#define REVISION 20 -#define DAGSIZE_BYTES_INIT 1073741824U // 2**30 -#define DAG_GROWTH 8388608U // 2**23 -#define CACHE_MULTIPLIER 1024 +#define REVISION 23 +#define DATASET_BYTES_INIT 1073741824U // 2**30 +#define DATASET_BYTES_GROWTH 8388608U // 2**23 +#define CACHE_BYTES_INIT 1073741824U // 2**24 +#define CACHE_BYTES_GROWTH 131072U // 2**17 #define EPOCH_LENGTH 30000U #define MIX_BYTES 128 -#define DAG_PARENTS 256 +#define HASH_BYTES 64 +#define DATASET_PARENTS 256 #define CACHE_ROUNDS 3 #define ACCESSES 64 @@ -60,19 +62,38 @@ static inline void ethash_params_init(ethash_params *params, const uint32_t bloc } 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]); void ethash_compute_full_data(void *mem, ethash_params const *params, ethash_cache const *cache); void ethash_full(ethash_return_value *ret, void const *full_mem, ethash_params const *params, const uint8_t header_hash[32], const uint64_t nonce); void ethash_light(ethash_return_value *ret, ethash_cache const *cache, ethash_params const *params, const uint8_t header_hash[32], const uint64_t nonce); +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); } -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); } -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); } -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); } +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); +} + +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); +} + +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); +} + +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); +} +// 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]) { @@ -81,7 +102,7 @@ static inline int ethash_check_difficulty( if (hash[i] == difficulty[i]) continue; return hash[i] < difficulty[i]; } - return 0; + return 1; } int ethash_quick_check_difficulty( 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 a2b82d375..0a7e767e7 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 @@ -1,12 +1,12 @@ /* - This file is part of cpp-ethereum. + This file is part of ethash. - cpp-ethereum is free software: you can redistribute it and/or modify + 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. - cpp-ethereum is distributed in the hope that it will be useful, + 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. @@ -14,7 +14,7 @@ You should have received a copy of the GNU General Public License along with cpp-ethereum. If not, see . */ -/** @file dash.cpp +/** @file internal.c * @author Tim Hughes * @author Matthew Wampler-Doty * @date 2015 @@ -38,12 +38,12 @@ #endif // WITH_CRYPTOPP size_t ethash_get_datasize(const uint32_t block_number) { - assert(block_number / EPOCH_LENGTH < 500); + assert(block_number / EPOCH_LENGTH < 2048); return dag_sizes[block_number / EPOCH_LENGTH]; } size_t ethash_get_cachesize(const uint32_t block_number) { - assert(block_number / EPOCH_LENGTH < 500); + assert(block_number / EPOCH_LENGTH < 2048); return cache_sizes[block_number / EPOCH_LENGTH]; } @@ -55,7 +55,7 @@ void static ethash_compute_cache_nodes( ethash_params const *params, const uint8_t seed[32]) { assert((params->cache_size % sizeof(node)) == 0); - uint32_t const num_nodes = (uint32_t)(params->cache_size / sizeof(node)); + uint32_t const num_nodes = (uint32_t) (params->cache_size / sizeof(node)); SHA3_512(nodes[0].bytes, seed, 32); @@ -68,10 +68,9 @@ void static ethash_compute_cache_nodes( uint32_t const idx = nodes[i].words[0] % num_nodes; node data; data = nodes[(num_nodes - 1 + i) % num_nodes]; - for (unsigned w = 0; w != NODE_WORDS; ++w) - { - data.words[w] ^= nodes[idx].words[w]; - } + for (unsigned w = 0; w != NODE_WORDS; ++w) { + data.words[w] ^= nodes[idx].words[w]; + } SHA3_512(nodes[i].bytes, data.bytes, sizeof(data)); } } @@ -86,7 +85,7 @@ void static ethash_compute_cache_nodes( } void ethash_mkcache( - ethash_cache *cache, + ethash_cache *cache, ethash_params const *params, const uint8_t seed[32]) { node *nodes = (node *) cache->mem; @@ -99,13 +98,13 @@ void ethash_calculate_dag_item( const struct ethash_params *params, const struct ethash_cache *cache) { - uint32_t num_parent_nodes = (uint32_t)(params->cache_size / sizeof(node)); + uint32_t num_parent_nodes = (uint32_t) (params->cache_size / sizeof(node)); node const *cache_nodes = (node const *) cache->mem; node const *init = &cache_nodes[node_index % num_parent_nodes]; - memcpy(ret, init, sizeof(node)); - ret->words[0] ^= node_index; - SHA3_512(ret->bytes, ret->bytes, sizeof(node)); + memcpy(ret, init, sizeof(node)); + ret->words[0] ^= node_index; + SHA3_512(ret->bytes, ret->bytes, sizeof(node)); #if defined(_M_X64) && ENABLE_SSE __m128i const fnv_prime = _mm_set1_epi32(FNV_PRIME); @@ -115,12 +114,11 @@ void ethash_calculate_dag_item( __m128i xmm3 = ret->xmm[3]; #endif - for (unsigned i = 0; i != DAG_PARENTS; ++i) - { - uint32_t parent_index = ((node_index ^ i)*FNV_PRIME ^ ret->words[i % NODE_WORDS]) % num_parent_nodes; + for (unsigned i = 0; i != DATASET_PARENTS; ++i) { + uint32_t parent_index = ((node_index ^ i) * FNV_PRIME ^ ret->words[i % NODE_WORDS]) % num_parent_nodes; node const *parent = &cache_nodes[parent_index]; - #if defined(_M_X64) && ENABLE_SSE +#if defined(_M_X64) && ENABLE_SSE { xmm0 = _mm_mullo_epi32(xmm0, fnv_prime); xmm1 = _mm_mullo_epi32(xmm1, fnv_prime); @@ -143,10 +141,10 @@ void ethash_calculate_dag_item( ret->words[w] = fnv_hash(ret->words[w], parent->words[w]); } } - #endif +#endif } - SHA3_512(ret->bytes, ret->bytes, sizeof(node)); + SHA3_512(ret->bytes, ret->bytes, sizeof(node)); } void ethash_compute_full_data( @@ -164,7 +162,7 @@ void ethash_compute_full_data( } static void ethash_hash( - ethash_return_value * ret, + ethash_return_value *ret, node const *full_nodes, ethash_cache const *cache, ethash_params const *params, @@ -174,7 +172,7 @@ static void ethash_hash( assert((params->full_size % MIX_WORDS) == 0); // pack hash and nonce together into first 40 bytes of s_mix - assert(sizeof(node)*8 == 512); + assert(sizeof(node) * 8 == 512); node s_mix[MIX_NODES + 1]; memcpy(s_mix[0].bytes, header_hash, 32); @@ -193,23 +191,21 @@ static void ethash_hash( } #endif - node* const mix = s_mix + 1; + node *const mix = s_mix + 1; for (unsigned w = 0; w != MIX_WORDS; ++w) { mix->words[w] = s_mix[0].words[w % NODE_WORDS]; } unsigned const page_size = sizeof(uint32_t) * MIX_WORDS, - num_full_pages = (unsigned)(params->full_size / page_size); + num_full_pages = (unsigned) (params->full_size / page_size); - for (unsigned i = 0; i != ACCESSES; ++i) - { - uint32_t const index = ((s_mix->words[0] ^ i)*FNV_PRIME ^ mix->words[i % MIX_WORDS]) % num_full_pages; + for (unsigned i = 0; i != ACCESSES; ++i) { + uint32_t const index = ((s_mix->words[0] ^ i) * FNV_PRIME ^ mix->words[i % MIX_WORDS]) % num_full_pages; - for (unsigned n = 0; n != MIX_NODES; ++n) - { - const node * dag_node = &full_nodes[MIX_NODES * index + n]; + for (unsigned n = 0; n != MIX_NODES; ++n) { + const node *dag_node = &full_nodes[MIX_NODES * index + n]; if (!full_nodes) { node tmp_node; @@ -217,7 +213,7 @@ static void ethash_hash( dag_node = &tmp_node; } - #if defined(_M_X64) && ENABLE_SSE +#if defined(_M_X64) && ENABLE_SSE { __m128i fnv_prime = _mm_set1_epi32(FNV_PRIME); __m128i xmm0 = _mm_mullo_epi32(fnv_prime, mix[n].xmm[0]); @@ -235,20 +231,19 @@ static void ethash_hash( mix[n].words[w] = fnv_hash(mix[n].words[w], dag_node->words[w]); } } - #endif +#endif } } - // compress mix - for (unsigned w = 0; w != MIX_WORDS; w += 4) - { - uint32_t reduction = mix->words[w+0]; - reduction = reduction*FNV_PRIME ^ mix->words[w+1]; - reduction = reduction*FNV_PRIME ^ mix->words[w+2]; - reduction = reduction*FNV_PRIME ^ mix->words[w+3]; - mix->words[w/4] = reduction; - } + // compress mix + for (unsigned w = 0; w != MIX_WORDS; w += 4) { + uint32_t reduction = mix->words[w + 0]; + reduction = reduction * FNV_PRIME ^ mix->words[w + 1]; + reduction = reduction * FNV_PRIME ^ mix->words[w + 2]; + reduction = reduction * FNV_PRIME ^ mix->words[w + 3]; + mix->words[w / 4] = reduction; + } #if BYTE_ORDER != LITTLE_ENDIAN for (unsigned w = 0; w != MIX_WORDS/4; ++w) { @@ -258,7 +253,7 @@ static void ethash_hash( memcpy(ret->mix_hash, mix->bytes, 32); // final Keccak hash - SHA3_256(ret->result, s_mix->bytes, 64+32); // Keccak-256(s + compressed_mix) + SHA3_256(ret->result, s_mix->bytes, 64 + 32); // Keccak-256(s + compressed_mix) } void ethash_quick_hash( @@ -267,7 +262,7 @@ void ethash_quick_hash( const uint64_t nonce, const uint8_t mix_hash[32]) { - uint8_t buf[64+32]; + uint8_t buf[64 + 32]; memcpy(buf, header_hash, 32); #if BYTE_ORDER != LITTLE_ENDIAN nonce = fix_endian64(nonce); @@ -275,7 +270,14 @@ void ethash_quick_hash( memcpy(&(buf[32]), &nonce, 8); SHA3_512(buf, buf, 40); memcpy(&(buf[64]), mix_hash, 32); - SHA3_256(return_hash, buf, 64+32); + SHA3_256(return_hash, buf, 64 + 32); +} + +void ethash_get_seedhash(uint8_t seedhash[32], const uint32_t block_number) { + memset(seedhash, 0, 32); + const uint32_t epochs = block_number / EPOCH_LENGTH; + for (uint32_t i = 0; i < epochs; ++i) + SHA3_256(seedhash, seedhash, 32); } int ethash_quick_check_difficulty( @@ -289,10 +291,10 @@ int ethash_quick_check_difficulty( return ethash_check_difficulty(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) { +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) { ethash_hash(ret, (node const *) full_mem, NULL, params, previous_hash, nonce); } -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) { +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/internal.h b/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/internal.h index bcbacdaa4..ddd06e8f4 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/internal.h +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/internal.h @@ -3,7 +3,7 @@ #include "endian.h" #include "ethash.h" -#define ENABLE_SSE 1 +#define ENABLE_SSE 0 #if defined(_M_X64) && ENABLE_SSE #include diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/sha3_cryptopp.cpp b/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/sha3_cryptopp.cpp index 9454ce04a..6cbbcad8f 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/sha3_cryptopp.cpp +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/sha3_cryptopp.cpp @@ -1,18 +1,18 @@ /* - This file is part of cpp-ethereum. + This file is part of ethash. - cpp-ethereum is free software: you can redistribute it and/or modify + 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. - cpp-ethereum is distributed in the hope that it will be useful, + 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 cpp-ethereum. If not, see . + along with ethash. If not, see . */ /** @file sha3.cpp diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/util.h b/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/util.h index 2f59076f6..ba8957815 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/util.h +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash/util.h @@ -1,18 +1,18 @@ /* - This file is part of cpp-ethereum. + This file is part of ethash. - cpp-ethereum is free software: you can redistribute it and/or modify + 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. - cpp-ethereum is distributed in the hope that it will be useful, + 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 cpp-ethereum. If not, see . + along with ethash. If not, see . */ /** @file util.h * @author Tim Hughes 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 f7d8be156..359735998 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 @@ -1,64 +1,305 @@ #include #include #include +#include +#include #include "../libethash/ethash.h" -static PyObject* -get_cache_size(PyObject* self, PyObject* args) -{ +#define MIX_WORDS (MIX_BYTES/4) + +static PyObject * +get_cache_size(PyObject *self, PyObject *args) { unsigned long block_number; if (!PyArg_ParseTuple(args, "k", &block_number)) - return 0; + return 0; + if (block_number >= EPOCH_LENGTH * 2048) { + char error_message[1024]; + sprintf(error_message, "Block number must be less than %i (was %lu)", EPOCH_LENGTH * 2048, block_number); + + PyErr_SetString(PyExc_ValueError, error_message); + return 0; + } + return Py_BuildValue("i", ethash_get_cachesize(block_number)); } -static PyObject* -get_full_size(PyObject* self, PyObject* args) -{ +static PyObject * +get_full_size(PyObject *self, PyObject *args) { unsigned long block_number; if (!PyArg_ParseTuple(args, "k", &block_number)) - return 0; + return 0; + if (block_number >= EPOCH_LENGTH * 2048) { + char error_message[1024]; + sprintf(error_message, "Block number must be less than %i (was %lu)", EPOCH_LENGTH * 2048, block_number); + + PyErr_SetString(PyExc_ValueError, error_message); + return 0; + } + return Py_BuildValue("i", ethash_get_datasize(block_number)); } -static PyObject* -mkcache(PyObject* self, PyObject* args) -{ - char * seed; +static PyObject * +mkcache_bytes(PyObject *self, PyObject *args) { + char *seed; unsigned long cache_size; int seed_len; if (!PyArg_ParseTuple(args, "ks#", &cache_size, &seed, &seed_len)) - return 0; + return 0; + + if (seed_len != 32) { + char error_message[1024]; + sprintf(error_message, "Seed must be 32 bytes long (was %i)", seed_len); - if (seed_len != 32) - { - PyErr_SetString(PyExc_ValueError, - "Seed must be 32 bytes long"); - return 0; + PyErr_SetString(PyExc_ValueError, error_message); + return 0; } - printf("cache size: %lu\n", cache_size); ethash_params params; params.cache_size = (size_t) cache_size; ethash_cache cache; - cache.mem = alloca(cache_size); + cache.mem = malloc(cache_size); ethash_mkcache(&cache, ¶ms, (uint8_t *) seed); - return PyString_FromStringAndSize(cache.mem, cache_size); + PyObject * val = Py_BuildValue("s#", cache.mem, cache_size); + free(cache.mem); + return val; +} + + +static PyObject * +calc_dataset_bytes(PyObject *self, PyObject *args) { + char *cache_bytes; + unsigned long full_size; + int cache_size; + + if (!PyArg_ParseTuple(args, "ks#", &full_size, &cache_bytes, &cache_size)) + return 0; + + if (full_size % MIX_WORDS != 0) { + char error_message[1024]; + sprintf(error_message, "The size of data set must be a multiple of %i bytes (was %lu)", MIX_WORDS, full_size); + PyErr_SetString(PyExc_ValueError, error_message); + return 0; + } + + if (cache_size % HASH_BYTES != 0) { + char error_message[1024]; + sprintf(error_message, "The size of the cache must be a multiple of %i bytes (was %i)", HASH_BYTES, cache_size); + PyErr_SetString(PyExc_ValueError, error_message); + return 0; + } + + ethash_params params; + params.cache_size = (size_t) cache_size; + params.full_size = (size_t) full_size; + ethash_cache cache; + 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); + free(mem); + return val; +} + +// hashimoto_light(full_size, cache, header, nonce) +static PyObject * +hashimoto_light(PyObject *self, PyObject *args) { + char *cache_bytes, *header; + unsigned long full_size; + 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)) + return 0; + + if (full_size % MIX_WORDS != 0) { + char error_message[1024]; + sprintf(error_message, "The size of data set must be a multiple of %i bytes (was %lu)", MIX_WORDS, full_size); + PyErr_SetString(PyExc_ValueError, error_message); + return 0; + } + + if (cache_size % HASH_BYTES != 0) { + char error_message[1024]; + sprintf(error_message, "The size of the cache must be a multiple of %i bytes (was %i)", HASH_BYTES, cache_size); + PyErr_SetString(PyExc_ValueError, error_message); + return 0; + } + + if (header_size != 32) { + char error_message[1024]; + sprintf(error_message, "Seed must be 32 bytes long (was %i)", header_size); + PyErr_SetString(PyExc_ValueError, error_message); + return 0; + } + + + ethash_return_value out; + ethash_params params; + params.cache_size = (size_t) cache_size; + params.full_size = (size_t) full_size; + ethash_cache cache; + cache.mem = (void *) cache_bytes; + ethash_light(&out, &cache, ¶ms, (uint8_t *) header, nonce); + return Py_BuildValue("{s:s#,s:s#}", + "mix digest", out.mix_hash, 32, + "result", out.result, 32); +} + +// hashimoto_full(dataset, header, nonce) +static PyObject * +hashimoto_full(PyObject *self, PyObject *args) { + char *full_bytes, *header; + unsigned long long nonce; + int full_size, header_size; + + if (!PyArg_ParseTuple(args, "s#s#K", &full_bytes, &full_size, &header, &header_size, &nonce)) + return 0; + + if (full_size % MIX_WORDS != 0) { + char error_message[1024]; + sprintf(error_message, "The size of data set must be a multiple of %i bytes (was %i)", MIX_WORDS, full_size); + PyErr_SetString(PyExc_ValueError, error_message); + return 0; + } + + if (header_size != 32) { + char error_message[1024]; + sprintf(error_message, "Header must be 32 bytes long (was %i)", header_size); + PyErr_SetString(PyExc_ValueError, error_message); + return 0; + } + + + ethash_return_value out; + 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#}", + "mix digest", out.mix_hash, 32, + "result", out.result, 32); } +// mine(dataset_bytes, header, difficulty_bytes) +static PyObject * +mine(PyObject *self, PyObject *args) { + char *full_bytes, *header, *difficulty; + srand(time(0)); + 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)) + return 0; + + if (full_size % MIX_WORDS != 0) { + char error_message[1024]; + sprintf(error_message, "The size of data set must be a multiple of %i bytes (was %i)", MIX_WORDS, full_size); + PyErr_SetString(PyExc_ValueError, error_message); + return 0; + } + + if (header_size != 32) { + char error_message[1024]; + sprintf(error_message, "Header must be 32 bytes long (was %i)", header_size); + PyErr_SetString(PyExc_ValueError, error_message); + return 0; + } + + if (difficulty_size != 32) { + char error_message[1024]; + sprintf(error_message, "Difficulty must be an array of 32 bytes (only had %i)", difficulty_size); + PyErr_SetString(PyExc_ValueError, error_message); + return 0; + } + + ethash_return_value out; + ethash_params params; + params.full_size = (size_t) full_size; + + // TODO: Multi threading? + do { + ethash_full(&out, (void *) full_bytes, ¶ms, (const uint8_t *) header, nonce++); + // 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}", + "mix digest", out.mix_hash, 32, + "result", out.result, 32, + "nonce", nonce); +} + +//get_seedhash(block_number) +static PyObject * +get_seedhash(PyObject *self, PyObject *args) { + unsigned long block_number; + if (!PyArg_ParseTuple(args, "k", &block_number)) + return 0; + if (block_number >= EPOCH_LENGTH * 2048) { + char error_message[1024]; + sprintf(error_message, "Block number must be less than %i (was %lu)", EPOCH_LENGTH * 2048, block_number); + + PyErr_SetString(PyExc_ValueError, error_message); + return 0; + } + uint8_t seedhash[32]; + ethash_get_seedhash(seedhash, block_number); + return Py_BuildValue("s#", (char *) seedhash, 32); +} -static PyMethodDef CoreMethods[] = -{ - {"get_cache_size", get_cache_size, METH_VARARGS, "Get the cache size for a given block number"}, - {"get_full_size", get_full_size, METH_VARARGS, "Get the full size for a given block number"}, - {"mkcache", mkcache, METH_VARARGS, "Makes the cache for given parameters and seed hash"}, - {NULL, NULL, 0, NULL} -}; +static PyMethodDef PyethashMethods[] = + { + {"get_cache_size", get_cache_size, METH_VARARGS, + "get_cache_size(block_number)\n\n" + "Get the cache size for a given block number\n" + "\nExample:\n" + ">>> get_cache_size(0)\n" + "1048384"}, + {"get_full_size", get_full_size, METH_VARARGS, + "get_full_size(block_number)\n\n" + "Get the full size for a given block number\n" + "\nExample:\n" + ">>> get_full_size(0)\n" + "1073739904" + }, + {"get_seedhash", get_seedhash, METH_VARARGS, + "get_seedhash(block_number)\n\n" + "Gets the seedhash for a block."}, + {"mkcache_bytes", mkcache_bytes, METH_VARARGS, + "mkcache_bytes(size, header)\n\n" + "Makes a byte array for the cache for given cache size and seed hash\n" + "\nExample:\n" + ">>> pyethash.mkcache_bytes( 1024, \"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\").encode('hex')" + "\"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\""}, + {"calc_dataset_bytes", calc_dataset_bytes, METH_VARARGS, + "calc_dataset_bytes(full_size, cache_bytes)\n\n" + "Makes a byte array for the dataset for a given size given cache bytes"}, + {"hashimoto_light", hashimoto_light, METH_VARARGS, + "hashimoto_light(full_size, cache_bytes, header, nonce)\n\n" + "Runs the hashimoto hashing function just using cache bytes. Takes an int (full_size), byte array (cache_bytes), another byte array (header), and an int (nonce). Returns an object containing the mix digest, and hash result."}, + {"hashimoto_full", hashimoto_full, METH_VARARGS, + "hashimoto_full(dataset_bytes, header, nonce)\n\n" + "Runs the hashimoto hashing function using the dataset bytes. Useful for testing. Returns an object containing the mix digest (byte array), and hash result (another byte array)."}, + {"mine", mine, METH_VARARGS, + "mine(dataset_bytes, header, difficulty_bytes)\n\n" + "Mine for an adequate header. Returns an object containing the mix digest (byte array), hash result (another byte array) and nonce (an int)."}, + {NULL, NULL, 0, NULL} + }; PyMODINIT_FUNC -initcore(void) -{ - (void) Py_InitModule("core", CoreMethods); +initpyethash(void) { + PyObject *module = Py_InitModule("pyethash", PyethashMethods); + // 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); } 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 336713cb7..21cb251fc 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 @@ -4,7 +4,9 @@ #include #ifdef WITH_CRYPTOPP + #include + #else #include #endif // WITH_CRYPTOPP @@ -28,7 +30,7 @@ BOOST_AUTO_TEST_CASE(fnv_hash_check) { uint32_t x = 1235U; const uint32_t y = 9999999U, - expected = (FNV_PRIME * x) ^ y; + expected = (FNV_PRIME * x) ^y; x = fnv_hash(x, y); @@ -65,43 +67,50 @@ BOOST_AUTO_TEST_CASE(SHA512_check) { BOOST_AUTO_TEST_CASE(ethash_params_init_genesis_check) { ethash_params params; ethash_params_init(¶ms, 0); - BOOST_REQUIRE_MESSAGE(params.full_size < DAGSIZE_BYTES_INIT, + BOOST_REQUIRE_MESSAGE(params.full_size < DATASET_BYTES_INIT, "\nfull size: " << params.full_size << "\n" - << "should be less than or equal to: " << DAGSIZE_BYTES_INIT << "\n"); - BOOST_REQUIRE_MESSAGE(params.full_size + 20*MIX_BYTES >= DAGSIZE_BYTES_INIT, - "\nfull size + 20*MIX_BYTES: " << params.full_size + 20*MIX_BYTES << "\n" - << "should be greater than or equal to: " << DAGSIZE_BYTES_INIT << "\n"); - BOOST_REQUIRE_MESSAGE(params.cache_size < DAGSIZE_BYTES_INIT / 32, + << "should be less than or equal to: " << DATASET_BYTES_INIT << "\n"); + BOOST_REQUIRE_MESSAGE(params.full_size + 20 * MIX_BYTES >= DATASET_BYTES_INIT, + "\nfull size + 20*MIX_BYTES: " << params.full_size + 20 * MIX_BYTES << "\n" + << "should be greater than or equal to: " << DATASET_BYTES_INIT << "\n"); + BOOST_REQUIRE_MESSAGE(params.cache_size < DATASET_BYTES_INIT / 32, "\ncache size: " << params.cache_size << "\n" - << "should be less than or equal to: " << DAGSIZE_BYTES_INIT / 32 << "\n"); + << "should be less than or equal to: " << DATASET_BYTES_INIT / 32 << "\n"); } BOOST_AUTO_TEST_CASE(ethash_params_init_genesis_calcifide_check) { ethash_params params; ethash_params_init(¶ms, 0); const uint32_t expected_full_size = 1073739904; - const uint32_t expected_cache_size = 1048384; - BOOST_REQUIRE_MESSAGE(params.full_size == expected_full_size, + const uint32_t expected_cache_size = 16776896; + BOOST_REQUIRE_MESSAGE(params.full_size == expected_full_size, "\nexpected: " << expected_cache_size << "\n" << "actual: " << params.full_size << "\n"); - BOOST_REQUIRE_MESSAGE(params.cache_size == expected_cache_size, + BOOST_REQUIRE_MESSAGE(params.cache_size == expected_cache_size, "\nexpected: " << expected_cache_size << "\n" << "actual: " << params.cache_size << "\n"); } BOOST_AUTO_TEST_CASE(light_and_full_client_checks) { ethash_params params; - uint8_t seed[32], hash[32]; + uint8_t seed[32], hash[32], difficulty[32]; ethash_return_value light_out, full_out; memcpy(seed, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32); memcpy(hash, "~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32); + + // Set the difficulty + difficulty[0] = 197; + difficulty[1] = 90; + for (int i = 2; i < 32; i++) + difficulty[i] = (uint8_t) 255; + ethash_params_init(¶ms, 0); params.cache_size = 1024; params.full_size = 1024 * 32; ethash_cache cache; cache.mem = alloca(params.cache_size); ethash_mkcache(&cache, ¶ms, seed); - node * full_mem = (node *) alloca(params.full_size); + node *full_mem = (node *) alloca(params.full_size); ethash_compute_full_data(full_mem, ¶ms, &cache); { @@ -115,7 +124,6 @@ BOOST_AUTO_TEST_CASE(light_and_full_client_checks) { } - { node node; ethash_calculate_dag_item(&node, 0, ¶ms, &cache); @@ -128,7 +136,7 @@ BOOST_AUTO_TEST_CASE(light_and_full_client_checks) { } { - for (int i = 0 ; i < params.full_size / sizeof(node) ; ++i ) { + for (int i = 0; i < params.full_size / sizeof(node); ++i) { for (uint32_t j = 0; j < 32; ++j) { node expected_node; ethash_calculate_dag_item(&expected_node, j, ¶ms, &cache); @@ -187,6 +195,12 @@ BOOST_AUTO_TEST_CASE(light_and_full_client_checks) { BOOST_REQUIRE_MESSAGE(full_mix_hash_string == light_mix_hash_string, "\nlight mix hash: " << light_mix_hash_string.c_str() << "\n" << "full mix hash: " << full_mix_hash_string.c_str() << "\n"); + BOOST_REQUIRE_MESSAGE(ethash_check_difficulty(full_out.result, difficulty), + "ethash_check_difficulty failed" + ); + BOOST_REQUIRE_MESSAGE(ethash_quick_check_difficulty(hash, 5U, full_out.mix_hash, difficulty), + "ethash_quick_check_difficulty failed" + ); } } @@ -199,14 +213,14 @@ BOOST_AUTO_TEST_CASE(ethash_check_difficulty_check) { memcpy(target, "22222222222222222222222222222222", 32); BOOST_REQUIRE_MESSAGE( ethash_check_difficulty(hash, target), - "\nexpected \"" << hash << "\" to have less difficulty than \"" << target << "\"\n"); + "\nexpected \"" << std::string((char *) hash, 32).c_str() << "\" to have the same or less difficulty than \"" << std::string((char *) target, 32).c_str() << "\"\n"); BOOST_REQUIRE_MESSAGE( - !ethash_check_difficulty(hash, hash), - "\nexpected \"" << hash << "\" to have the same difficulty as \"" << hash << "\"\n"); + ethash_check_difficulty(hash, hash), + "\nexpected \"" << hash << "\" to have the same or less difficulty than \"" << hash << "\"\n"); memcpy(target, "11111111111111111111111111111112", 32); BOOST_REQUIRE_MESSAGE( ethash_check_difficulty(hash, target), - "\nexpected \"" << hash << "\" to have less difficulty than \"" << target << "\"\n"); + "\nexpected \"" << hash << "\" to have the same or less difficulty than \"" << target << "\"\n"); memcpy(target, "11111111111111111111111111111110", 32); BOOST_REQUIRE_MESSAGE( !ethash_check_difficulty(hash, target), diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/test/go/ethash_test.go b/Godeps/_workspace/src/github.com/ethereum/ethash/test/go/ethash_test.go new file mode 100644 index 000000000..67ca51702 --- /dev/null +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/test/go/ethash_test.go @@ -0,0 +1,82 @@ +package ethashTest + +import ( + "bytes" + "crypto/rand" + "encoding/hex" + "log" + "math/big" + "testing" + + "github.com/ethereum/ethash" + "github.com/ethereum/go-ethereum/core" + "github.com/ethereum/go-ethereum/ethdb" +) + +func TestEthash(t *testing.T) { + seedHash := make([]byte, 32) + _, err := rand.Read(seedHash) + if err != nil { + panic(err) + } + + db, err := ethdb.NewMemDatabase() + if err != nil { + panic(err) + } + + blockProcessor, err := core.NewCanonical(5, db) + if err != nil { + panic(err) + } + + log.Println("Block Number: ", blockProcessor.ChainManager().CurrentBlock().Number()) + + e := ethash.New(blockProcessor.ChainManager()) + + miningHash := make([]byte, 32) + if _, err := rand.Read(miningHash); err != nil { + panic(err) + } + diff := big.NewInt(10000) + log.Println("difficulty", diff) + + nonce := uint64(0) + + ghash_full := e.FullHash(nonce, miningHash) + log.Printf("ethash full (on nonce): %x %x\n", ghash_full, nonce) + + ghash_light := e.LightHash(nonce, miningHash) + log.Printf("ethash light (on nonce): %x %x\n", ghash_light, nonce) + + if bytes.Compare(ghash_full, ghash_light) != 0 { + t.Errorf("full: %x, light: %x", ghash_full, ghash_light) + } +} + +func TestGetSeedHash(t *testing.T) { + seed0, err := ethash.GetSeedHash(0) + if err != nil { + t.Errorf("Failed to get seedHash for block 0: %v", err) + } + if bytes.Compare(seed0, []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}) != 0 { + log.Printf("seedHash for block 0 should be 0s, was: %v\n", seed0) + } + seed1, err := ethash.GetSeedHash(30000) + if err != nil { + t.Error(err) + } + + // From python: + // > from pyethash import get_seedhash + // > get_seedhash(30000) + expectedSeed1, err := hex.DecodeString("290decd9548b62a8d60345a988386fc84ba6bc95484008f6362f93160ef3e563") + if err != nil { + t.Error(err) + } + + if bytes.Compare(seed1, expectedSeed1) != 0 { + log.Printf("seedHash for block 1 should be: %v,\nactual value: %v\n", expectedSeed1, seed1) + } + +} 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 new file mode 100644 index 000000000..c6224858e --- /dev/null +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/test/go/test.sh @@ -0,0 +1,20 @@ +#!/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/Godeps/_workspace/src/github.com/ethereum/ethash/test/python/requirements.txt b/Godeps/_workspace/src/github.com/ethereum/ethash/test/python/requirements.txt index 1f38dc3c7..378263c62 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/test/python/requirements.txt +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/test/python/requirements.txt @@ -1,2 +1,3 @@ pyethereum==0.7.522 nose==1.3.4 +pysha3==0.3 \ No newline at end of file diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/test/python/test.sh b/Godeps/_workspace/src/github.com/ethereum/ethash/test/python/test.sh index 4a547d157..95cea0215 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/test/python/test.sh +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/test/python/test.sh @@ -14,6 +14,6 @@ TEST_DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )" [ -d $TEST_DIR/python-virtual-env ] || virtualenv --system-site-packages $TEST_DIR/python-virtual-env source $TEST_DIR/python-virtual-env/bin/activate pip install -r $TEST_DIR/requirements.txt > /dev/null -pip install -e $TEST_DIR/../.. > /dev/null +pip install --upgrade --no-deps --force-reinstall -e $TEST_DIR/../.. cd $TEST_DIR -nosetests --with-doctest -v +nosetests --with-doctest -v --nocapture diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/test/python/test_pyethash.py b/Godeps/_workspace/src/github.com/ethereum/ethash/test/python/test_pyethash.py index ca9321e92..7eb1b60c7 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/test/python/test_pyethash.py +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/test/python/test_pyethash.py @@ -4,42 +4,102 @@ from random import randint def test_get_cache_size_not_None(): for _ in range(100): block_num = randint(0,12456789) - out = pyethash.core.get_cache_size(block_num) + out = pyethash.get_cache_size(block_num) assert out != None def test_get_full_size_not_None(): for _ in range(100): block_num = randint(0,12456789) - out = pyethash.core.get_full_size(block_num) + out = pyethash.get_full_size(block_num) assert out != None def test_get_cache_size_based_on_EPOCH(): for _ in range(100): block_num = randint(0,12456789) - out1 = pyethash.core.get_cache_size(block_num) - out2 = pyethash.core.get_cache_size((block_num // pyethash.EPOCH_LENGTH) * pyethash.EPOCH_LENGTH) + out1 = pyethash.get_cache_size(block_num) + out2 = pyethash.get_cache_size((block_num // pyethash.EPOCH_LENGTH) * pyethash.EPOCH_LENGTH) assert out1 == out2 def test_get_full_size_based_on_EPOCH(): for _ in range(100): block_num = randint(0,12456789) - out1 = pyethash.core.get_full_size(block_num) - out2 = pyethash.core.get_full_size((block_num // pyethash.EPOCH_LENGTH) * pyethash.EPOCH_LENGTH) + out1 = pyethash.get_full_size(block_num) + out2 = pyethash.get_full_size((block_num // pyethash.EPOCH_LENGTH) * pyethash.EPOCH_LENGTH) assert out1 == out2 -#def test_get_params_based_on_EPOCH(): -# block_num = 123456 -# out1 = pyethash.core.get_params(block_num) -# out2 = pyethash.core.get_params((block_num // pyethash.EPOCH_LENGTH) * pyethash.EPOCH_LENGTH) -# assert out1["DAG Size"] == out2["DAG Size"] -# assert out1["Cache Size"] == out2["Cache Size"] -# -#def test_get_params_returns_different_values_based_on_different_block_input(): -# out1 = pyethash.core.get_params(123456) -# out2 = pyethash.core.get_params(12345) -# assert out1["DAG Size"] != out2["DAG Size"] -# assert out1["Cache Size"] != out2["Cache Size"] -# -#def test_get_cache_smoke_test(): -# params = pyethash.core.get_params(123456) -# assert pyethash.core.mkcache(params, "~~~~") != None +# See light_and_full_client_checks in test.cpp +def test_mkcache_is_as_expected(): + actual = pyethash.mkcache_bytes( + 1024, + "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~").encode('hex') + expected = "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" + assert actual == expected + +def test_calc_dataset_is_not_None(): + cache = pyethash.mkcache_bytes( + 1024, + "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~") + assert pyethash.calc_dataset_bytes(1024 * 32, cache) != None + +def test_light_and_full_agree(): + cache = pyethash.mkcache_bytes( + 1024, + "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~") + full_size = 1024 * 32 + header = "~~~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~" + light_result = pyethash.hashimoto_light(full_size, cache, header, 0) + dataset = pyethash.calc_dataset_bytes(full_size, cache) + full_result = pyethash.hashimoto_full(dataset, header, 0) + assert light_result["mix digest"] != None + assert len(light_result["mix digest"]) == 32 + assert light_result["mix digest"] == full_result["mix digest"] + assert light_result["result"] != None + assert len(light_result["result"]) == 32 + assert light_result["result"] == full_result["result"] + +def int_to_bytes(i): + b = [] + for _ in range(32): + b.append(chr(i & 0xff)) + i >>= 8 + b.reverse() + return "".join(b) + +def test_mining_basic(): + easy_difficulty = int_to_bytes(2**256 - 1) + assert easy_difficulty.encode('hex') == 'f' * 64 + cache = pyethash.mkcache_bytes( + 1024, + "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~") + full_size = 1024 * 32 + header = "~~~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~" + dataset = pyethash.calc_dataset_bytes(full_size, cache) + # Check type of outputs + assert type(pyethash.mine(dataset,header,easy_difficulty)) == dict + assert type(pyethash.mine(dataset,header,easy_difficulty)["nonce"]) == long + assert type(pyethash.mine(dataset,header,easy_difficulty)["mix digest"]) == str + assert type(pyethash.mine(dataset,header,easy_difficulty)["result"]) == str + +def test_mining_doesnt_always_return_the_same_value(): + easy_difficulty1 = int_to_bytes(int(2**256 * 0.999)) + # 1 in 1000 difficulty + easy_difficulty2 = int_to_bytes(int(2**256 * 0.001)) + assert easy_difficulty1 != easy_difficulty2 + cache = pyethash.mkcache_bytes( + 1024, + "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~") + full_size = 1024 * 32 + header = "~~~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~" + dataset = pyethash.calc_dataset_bytes(full_size, cache) + # Check type of outputs + assert pyethash.mine(dataset, header, easy_difficulty1)['nonce'] != pyethash.mine(dataset, header, easy_difficulty2)['nonce'] + +def test_get_seedhash(): + assert pyethash.get_seedhash(0).encode('hex') == '0' * 64 + import hashlib, sha3 + expected = pyethash.get_seedhash(0) + #print "checking seed hashes:", + for i in range(0, 30000*2048, 30000): + #print i // 30000, + assert pyethash.get_seedhash(i) == expected + expected = hashlib.sha3_256(expected).digest() diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/test/test.sh b/Godeps/_workspace/src/github.com/ethereum/ethash/test/test.sh index eb38f6dfc..fd3508609 100644 --- a/Godeps/_workspace/src/github.com/ethereum/ethash/test/test.sh +++ b/Godeps/_workspace/src/github.com/ethereum/ethash/test/test.sh @@ -14,7 +14,12 @@ TEST_DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )" echo -e "\n################# Testing JS ##################" # TODO: Use mocha and real testing tools instead of rolling our own cd $TEST_DIR/../js -node test.js +if [ -x "$(which nodejs)" ] ; then + nodejs test.js +fi +if [ -x "$(which node)" ] ; then + node test.js +fi echo -e "\n################# Testing C ##################" $TEST_DIR/c/test.sh -- GitLab