From 0a5ee08e2b8927016f9f8d2afe0ac30e9ac0e81f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?P=C3=A9ter=20Szil=C3=A1gyi?= <peterke@gmail.com>
Date: Wed, 24 Feb 2016 13:29:47 +0200
Subject: Godeps, eth, tests: update ethash, used shared for testing
---
Godeps/Godeps.json | 144 ++++-
.../ethash/cmake/modules/CMakeParseArguments.cmake | 161 -----
.../ethash/cmake/modules/FindCryptoPP.cmake | 108 ----
.../ethereum/ethash/cmake/modules/FindOpenCL.cmake | 148 -----
.../modules/FindPackageHandleStandardArgs.cmake | 382 ------------
.../ethash/cmake/modules/FindPackageMessage.cmake | 57 --
.../ethereum/ethash/cryptopp/CMakeLists.txt | 13 -
.../src/github.com/ethereum/ethash/ethash.go | 54 +-
.../src/github.com/ethereum/ethash/js/LICENSE | 22 -
.../src/github.com/ethereum/ethash/js/ethash.js | 190 ------
.../src/github.com/ethereum/ethash/js/keccak.js | 404 -------------
.../github.com/ethereum/ethash/js/makekeccak.js | 201 -------
.../src/github.com/ethereum/ethash/js/test.js | 53 --
.../src/github.com/ethereum/ethash/js/util.js | 100 ---
.../ethereum/ethash/src/benchmark/CMakeLists.txt | 58 --
.../ethereum/ethash/src/benchmark/benchmark.cpp | 278 ---------
.../github.com/ethereum/ethash/src/python/core.c | 267 --------
.../ethereum/ethash/test/c/CMakeLists.txt | 66 --
.../src/github.com/ethereum/ethash/test/c/test.cpp | 669 ---------------------
.../src/github.com/ethereum/ethash/test/c/test.sh | 32 -
.../ethereum/ethash/test/python/.gitignore | 1 -
.../ethereum/ethash/test/python/requirements.txt | 3 -
.../github.com/ethereum/ethash/test/python/test.sh | 30 -
.../ethereum/ethash/test/python/test_pyethash.py | 105 ----
.../src/github.com/ethereum/ethash/test/test.sh | 32 -
eth/backend.go | 11 +-
tests/block_test_util.go | 1 +
27 files changed, 190 insertions(+), 3400 deletions(-)
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/CMakeParseArguments.cmake
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindCryptoPP.cmake
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindOpenCL.cmake
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindPackageHandleStandardArgs.cmake
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindPackageMessage.cmake
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/cryptopp/CMakeLists.txt
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/js/LICENSE
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/js/ethash.js
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/js/keccak.js
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/js/makekeccak.js
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/js/test.js
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/js/util.js
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/src/benchmark/CMakeLists.txt
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/src/benchmark/benchmark.cpp
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/src/python/core.c
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/test/c/CMakeLists.txt
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/test/c/test.cpp
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/test/c/test.sh
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/test/python/.gitignore
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/test/python/requirements.txt
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/test/python/test.sh
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/test/python/test_pyethash.py
delete mode 100644 Godeps/_workspace/src/github.com/ethereum/ethash/test/test.sh
diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json
index 2858ef0c9..6010309a2 100644
--- a/Godeps/Godeps.json
+++ b/Godeps/Godeps.json
@@ -20,8 +20,8 @@
},
{
"ImportPath": "github.com/ethereum/ethash",
- "Comment": "v23.1-238-g9401881",
- "Rev": "9401881ab040d1a3b0ae9e4780a115bc284a8a1a"
+ "Comment": "v23.1-240-ga524c9f",
+ "Rev": "a524c9f7d55cb8925567dc201b44ba555862056d"
},
{
"ImportPath": "github.com/fatih/color",
@@ -40,10 +40,38 @@
"ImportPath": "github.com/hashicorp/golang-lru",
"Rev": "a0d98a5f288019575c6d1f4bb1573fef2d1fcdc4"
},
+ {
+ "ImportPath": "github.com/hashicorp/golang-lru/simplelru",
+ "Rev": "a0d98a5f288019575c6d1f4bb1573fef2d1fcdc4"
+ },
{
"ImportPath": "github.com/huin/goupnp",
"Rev": "46bde78b11f3f021f2a511df138be9e2fc7506e8"
},
+ {
+ "ImportPath": "github.com/huin/goupnp/dcps/internetgateway1",
+ "Rev": "46bde78b11f3f021f2a511df138be9e2fc7506e8"
+ },
+ {
+ "ImportPath": "github.com/huin/goupnp/dcps/internetgateway2",
+ "Rev": "46bde78b11f3f021f2a511df138be9e2fc7506e8"
+ },
+ {
+ "ImportPath": "github.com/huin/goupnp/httpu",
+ "Rev": "46bde78b11f3f021f2a511df138be9e2fc7506e8"
+ },
+ {
+ "ImportPath": "github.com/huin/goupnp/scpd",
+ "Rev": "46bde78b11f3f021f2a511df138be9e2fc7506e8"
+ },
+ {
+ "ImportPath": "github.com/huin/goupnp/soap",
+ "Rev": "46bde78b11f3f021f2a511df138be9e2fc7506e8"
+ },
+ {
+ "ImportPath": "github.com/huin/goupnp/ssdp",
+ "Rev": "46bde78b11f3f021f2a511df138be9e2fc7506e8"
+ },
{
"ImportPath": "github.com/jackpal/gateway",
"Rev": "192609c58b8985e645cbe82ddcb28a4362ca0fdc"
@@ -86,10 +114,78 @@
"ImportPath": "github.com/robertkrimen/otto",
"Rev": "53221230c215611a90762720c9042ac782ef74ee"
},
+ {
+ "ImportPath": "github.com/robertkrimen/otto/ast",
+ "Rev": "53221230c215611a90762720c9042ac782ef74ee"
+ },
+ {
+ "ImportPath": "github.com/robertkrimen/otto/dbg",
+ "Rev": "53221230c215611a90762720c9042ac782ef74ee"
+ },
+ {
+ "ImportPath": "github.com/robertkrimen/otto/file",
+ "Rev": "53221230c215611a90762720c9042ac782ef74ee"
+ },
+ {
+ "ImportPath": "github.com/robertkrimen/otto/parser",
+ "Rev": "53221230c215611a90762720c9042ac782ef74ee"
+ },
+ {
+ "ImportPath": "github.com/robertkrimen/otto/registry",
+ "Rev": "53221230c215611a90762720c9042ac782ef74ee"
+ },
+ {
+ "ImportPath": "github.com/robertkrimen/otto/token",
+ "Rev": "53221230c215611a90762720c9042ac782ef74ee"
+ },
{
"ImportPath": "github.com/syndtr/goleveldb/leveldb",
"Rev": "e7e6f5b5ef25adb580feac515f9ccec514d0bda8"
},
+ {
+ "ImportPath": "github.com/syndtr/goleveldb/leveldb/cache",
+ "Rev": "e7e6f5b5ef25adb580feac515f9ccec514d0bda8"
+ },
+ {
+ "ImportPath": "github.com/syndtr/goleveldb/leveldb/comparer",
+ "Rev": "e7e6f5b5ef25adb580feac515f9ccec514d0bda8"
+ },
+ {
+ "ImportPath": "github.com/syndtr/goleveldb/leveldb/errors",
+ "Rev": "e7e6f5b5ef25adb580feac515f9ccec514d0bda8"
+ },
+ {
+ "ImportPath": "github.com/syndtr/goleveldb/leveldb/filter",
+ "Rev": "e7e6f5b5ef25adb580feac515f9ccec514d0bda8"
+ },
+ {
+ "ImportPath": "github.com/syndtr/goleveldb/leveldb/iterator",
+ "Rev": "e7e6f5b5ef25adb580feac515f9ccec514d0bda8"
+ },
+ {
+ "ImportPath": "github.com/syndtr/goleveldb/leveldb/journal",
+ "Rev": "e7e6f5b5ef25adb580feac515f9ccec514d0bda8"
+ },
+ {
+ "ImportPath": "github.com/syndtr/goleveldb/leveldb/memdb",
+ "Rev": "e7e6f5b5ef25adb580feac515f9ccec514d0bda8"
+ },
+ {
+ "ImportPath": "github.com/syndtr/goleveldb/leveldb/opt",
+ "Rev": "e7e6f5b5ef25adb580feac515f9ccec514d0bda8"
+ },
+ {
+ "ImportPath": "github.com/syndtr/goleveldb/leveldb/storage",
+ "Rev": "e7e6f5b5ef25adb580feac515f9ccec514d0bda8"
+ },
+ {
+ "ImportPath": "github.com/syndtr/goleveldb/leveldb/table",
+ "Rev": "e7e6f5b5ef25adb580feac515f9ccec514d0bda8"
+ },
+ {
+ "ImportPath": "github.com/syndtr/goleveldb/leveldb/util",
+ "Rev": "e7e6f5b5ef25adb580feac515f9ccec514d0bda8"
+ },
{
"ImportPath": "golang.org/x/crypto/pbkdf2",
"Rev": "1f22c0103821b9390939b6776727195525381532"
@@ -110,6 +206,14 @@
"ImportPath": "golang.org/x/net/html",
"Rev": "8968c61983e8f51a91b8c0ef25bf739278c89634"
},
+ {
+ "ImportPath": "golang.org/x/net/html/atom",
+ "Rev": "8968c61983e8f51a91b8c0ef25bf739278c89634"
+ },
+ {
+ "ImportPath": "golang.org/x/net/html/charset",
+ "Rev": "8968c61983e8f51a91b8c0ef25bf739278c89634"
+ },
{
"ImportPath": "golang.org/x/net/websocket",
"Rev": "8968c61983e8f51a91b8c0ef25bf739278c89634"
@@ -122,6 +226,42 @@
"ImportPath": "golang.org/x/text/encoding",
"Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
},
+ {
+ "ImportPath": "golang.org/x/text/encoding/charmap",
+ "Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
+ },
+ {
+ "ImportPath": "golang.org/x/text/encoding/htmlindex",
+ "Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
+ },
+ {
+ "ImportPath": "golang.org/x/text/encoding/internal",
+ "Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
+ },
+ {
+ "ImportPath": "golang.org/x/text/encoding/internal/identifier",
+ "Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
+ },
+ {
+ "ImportPath": "golang.org/x/text/encoding/japanese",
+ "Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
+ },
+ {
+ "ImportPath": "golang.org/x/text/encoding/korean",
+ "Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
+ },
+ {
+ "ImportPath": "golang.org/x/text/encoding/simplifiedchinese",
+ "Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
+ },
+ {
+ "ImportPath": "golang.org/x/text/encoding/traditionalchinese",
+ "Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
+ },
+ {
+ "ImportPath": "golang.org/x/text/encoding/unicode",
+ "Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
+ },
{
"ImportPath": "golang.org/x/text/internal/tag",
"Rev": "09761194ac5034a97b2bfad4f5b896b0ac350b3e"
diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/CMakeParseArguments.cmake b/Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/CMakeParseArguments.cmake
deleted file mode 100644
index 8553f38f5..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/CMakeParseArguments.cmake
+++ /dev/null
@@ -1,161 +0,0 @@
-#.rst:
-# CMakeParseArguments
-# -------------------
-#
-#
-#
-# CMAKE_PARSE_ARGUMENTS(<prefix> <options> <one_value_keywords>
-# <multi_value_keywords> args...)
-#
-# CMAKE_PARSE_ARGUMENTS() is intended to be used in macros or functions
-# for parsing the arguments given to that macro or function. It
-# processes the arguments and defines a set of variables which hold the
-# values of the respective options.
-#
-# The <options> argument contains all options for the respective macro,
-# i.e. keywords which can be used when calling the macro without any
-# value following, like e.g. the OPTIONAL keyword of the install()
-# command.
-#
-# The <one_value_keywords> argument contains all keywords for this macro
-# which are followed by one value, like e.g. DESTINATION keyword of the
-# install() command.
-#
-# The <multi_value_keywords> argument contains all keywords for this
-# macro which can be followed by more than one value, like e.g. the
-# TARGETS or FILES keywords of the install() command.
-#
-# When done, CMAKE_PARSE_ARGUMENTS() will have defined for each of the
-# keywords listed in <options>, <one_value_keywords> and
-# <multi_value_keywords> a variable composed of the given <prefix>
-# followed by "_" and the name of the respective keyword. These
-# variables will then hold the respective value from the argument list.
-# For the <options> keywords this will be TRUE or FALSE.
-#
-# All remaining arguments are collected in a variable
-# <prefix>_UNPARSED_ARGUMENTS, this can be checked afterwards to see
-# whether your macro was called with unrecognized parameters.
-#
-# As an example here a my_install() macro, which takes similar arguments
-# as the real install() command:
-#
-# ::
-#
-# function(MY_INSTALL)
-# set(options OPTIONAL FAST)
-# set(oneValueArgs DESTINATION RENAME)
-# set(multiValueArgs TARGETS CONFIGURATIONS)
-# cmake_parse_arguments(MY_INSTALL "${options}" "${oneValueArgs}"
-# "${multiValueArgs}" ${ARGN} )
-# ...
-#
-#
-#
-# Assume my_install() has been called like this:
-#
-# ::
-#
-# my_install(TARGETS foo bar DESTINATION bin OPTIONAL blub)
-#
-#
-#
-# After the cmake_parse_arguments() call the macro will have set the
-# following variables:
-#
-# ::
-#
-# MY_INSTALL_OPTIONAL = TRUE
-# MY_INSTALL_FAST = FALSE (this option was not used when calling my_install()
-# MY_INSTALL_DESTINATION = "bin"
-# MY_INSTALL_RENAME = "" (was not used)
-# MY_INSTALL_TARGETS = "foo;bar"
-# MY_INSTALL_CONFIGURATIONS = "" (was not used)
-# MY_INSTALL_UNPARSED_ARGUMENTS = "blub" (no value expected after "OPTIONAL"
-#
-#
-#
-# You can then continue and process these variables.
-#
-# Keywords terminate lists of values, e.g. if directly after a
-# one_value_keyword another recognized keyword follows, this is
-# interpreted as the beginning of the new option. E.g.
-# my_install(TARGETS foo DESTINATION OPTIONAL) would result in
-# MY_INSTALL_DESTINATION set to "OPTIONAL", but MY_INSTALL_DESTINATION
-# would be empty and MY_INSTALL_OPTIONAL would be set to TRUE therefor.
-
-#=============================================================================
-# Copyright 2010 Alexander Neundorf <neundorf@kde.org>
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distribute this file outside of CMake, substitute the full
-# License text for the above reference.)
-
-
-if(__CMAKE_PARSE_ARGUMENTS_INCLUDED)
- return()
-endif()
-set(__CMAKE_PARSE_ARGUMENTS_INCLUDED TRUE)
-
-
-function(CMAKE_PARSE_ARGUMENTS prefix _optionNames _singleArgNames _multiArgNames)
- # first set all result variables to empty/FALSE
- foreach(arg_name ${_singleArgNames} ${_multiArgNames})
- set(${prefix}_${arg_name})
- endforeach()
-
- foreach(option ${_optionNames})
- set(${prefix}_${option} FALSE)
- endforeach()
-
- set(${prefix}_UNPARSED_ARGUMENTS)
-
- set(insideValues FALSE)
- set(currentArgName)
-
- # now iterate over all arguments and fill the result variables
- foreach(currentArg ${ARGN})
- list(FIND _optionNames "${currentArg}" optionIndex) # ... then this marks the end of the arguments belonging to this keyword
- list(FIND _singleArgNames "${currentArg}" singleArgIndex) # ... then this marks the end of the arguments belonging to this keyword
- list(FIND _multiArgNames "${currentArg}" multiArgIndex) # ... then this marks the end of the arguments belonging to this keyword
-
- if(${optionIndex} EQUAL -1 AND ${singleArgIndex} EQUAL -1 AND ${multiArgIndex} EQUAL -1)
- if(insideValues)
- if("${insideValues}" STREQUAL "SINGLE")
- set(${prefix}_${currentArgName} ${currentArg})
- set(insideValues FALSE)
- elseif("${insideValues}" STREQUAL "MULTI")
- list(APPEND ${prefix}_${currentArgName} ${currentArg})
- endif()
- else()
- list(APPEND ${prefix}_UNPARSED_ARGUMENTS ${currentArg})
- endif()
- else()
- if(NOT ${optionIndex} EQUAL -1)
- set(${prefix}_${currentArg} TRUE)
- set(insideValues FALSE)
- elseif(NOT ${singleArgIndex} EQUAL -1)
- set(currentArgName ${currentArg})
- set(${prefix}_${currentArgName})
- set(insideValues "SINGLE")
- elseif(NOT ${multiArgIndex} EQUAL -1)
- set(currentArgName ${currentArg})
- set(${prefix}_${currentArgName})
- set(insideValues "MULTI")
- endif()
- endif()
-
- endforeach()
-
- # propagate the result variables to the caller:
- foreach(arg_name ${_singleArgNames} ${_multiArgNames} ${_optionNames})
- set(${prefix}_${arg_name} ${${prefix}_${arg_name}} PARENT_SCOPE)
- endforeach()
- set(${prefix}_UNPARSED_ARGUMENTS ${${prefix}_UNPARSED_ARGUMENTS} PARENT_SCOPE)
-
-endfunction()
diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindCryptoPP.cmake b/Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindCryptoPP.cmake
deleted file mode 100644
index 5ca01e446..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindCryptoPP.cmake
+++ /dev/null
@@ -1,108 +0,0 @@
-# Module for locating the Crypto++ encryption library.
-#
-# Customizable variables:
-# CRYPTOPP_ROOT_DIR
-# This variable points to the CryptoPP root directory. On Windows the
-# library location typically will have to be provided explicitly using the
-# -D command-line option. The directory should include the include/cryptopp,
-# lib and/or bin sub-directories.
-#
-# Read-only variables:
-# CRYPTOPP_FOUND
-# Indicates whether the library has been found.
-#
-# CRYPTOPP_INCLUDE_DIRS
-# Points to the CryptoPP include directory.
-#
-# CRYPTOPP_LIBRARIES
-# Points to the CryptoPP libraries that should be passed to
-# target_link_libararies.
-#
-#
-# Copyright (c) 2012 Sergiu Dotenco
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-
-INCLUDE (FindPackageHandleStandardArgs)
-
-FIND_PATH (CRYPTOPP_ROOT_DIR
- NAMES cryptopp/cryptlib.h include/cryptopp/cryptlib.h
- PATHS ENV CRYPTOPPROOT
- DOC "CryptoPP root directory")
-
-# Re-use the previous path:
-FIND_PATH (CRYPTOPP_INCLUDE_DIR
- NAMES cryptopp/cryptlib.h
- HINTS ${CRYPTOPP_ROOT_DIR}
- PATH_SUFFIXES include
- DOC "CryptoPP include directory")
-
-FIND_LIBRARY (CRYPTOPP_LIBRARY_DEBUG
- NAMES cryptlibd cryptoppd
- HINTS ${CRYPTOPP_ROOT_DIR}
- PATH_SUFFIXES lib
- DOC "CryptoPP debug library")
-
-FIND_LIBRARY (CRYPTOPP_LIBRARY_RELEASE
- NAMES cryptlib cryptopp
- HINTS ${CRYPTOPP_ROOT_DIR}
- PATH_SUFFIXES lib
- DOC "CryptoPP release library")
-
-IF (CRYPTOPP_LIBRARY_DEBUG AND CRYPTOPP_LIBRARY_RELEASE)
- SET (CRYPTOPP_LIBRARY
- optimized ${CRYPTOPP_LIBRARY_RELEASE}
- debug ${CRYPTOPP_LIBRARY_DEBUG} CACHE DOC "CryptoPP library")
-ELSEIF (CRYPTOPP_LIBRARY_RELEASE)
- SET (CRYPTOPP_LIBRARY ${CRYPTOPP_LIBRARY_RELEASE} CACHE DOC
- "CryptoPP library")
-ENDIF (CRYPTOPP_LIBRARY_DEBUG AND CRYPTOPP_LIBRARY_RELEASE)
-
-IF (CRYPTOPP_INCLUDE_DIR)
- SET (_CRYPTOPP_VERSION_HEADER ${CRYPTOPP_INCLUDE_DIR}/cryptopp/config.h)
-
- IF (EXISTS ${_CRYPTOPP_VERSION_HEADER})
- FILE (STRINGS ${_CRYPTOPP_VERSION_HEADER} _CRYPTOPP_VERSION_TMP REGEX
- "^#define CRYPTOPP_VERSION[ \t]+[0-9]+$")
-
- STRING (REGEX REPLACE
- "^#define CRYPTOPP_VERSION[ \t]+([0-9]+)" "\\1" _CRYPTOPP_VERSION_TMP
- ${_CRYPTOPP_VERSION_TMP})
-
- STRING (REGEX REPLACE "([0-9]+)[0-9][0-9]" "\\1" CRYPTOPP_VERSION_MAJOR
- ${_CRYPTOPP_VERSION_TMP})
- STRING (REGEX REPLACE "[0-9]([0-9])[0-9]" "\\1" CRYPTOPP_VERSION_MINOR
- ${_CRYPTOPP_VERSION_TMP})
- STRING (REGEX REPLACE "[0-9][0-9]([0-9])" "\\1" CRYPTOPP_VERSION_PATCH
- ${_CRYPTOPP_VERSION_TMP})
-
- SET (CRYPTOPP_VERSION_COUNT 3)
- SET (CRYPTOPP_VERSION
- ${CRYPTOPP_VERSION_MAJOR}.${CRYPTOPP_VERSION_MINOR}.${CRYPTOPP_VERSION_PATCH})
- ENDIF (EXISTS ${_CRYPTOPP_VERSION_HEADER})
-ENDIF (CRYPTOPP_INCLUDE_DIR)
-
-SET (CRYPTOPP_INCLUDE_DIRS ${CRYPTOPP_INCLUDE_DIR})
-SET (CRYPTOPP_LIBRARIES ${CRYPTOPP_LIBRARY})
-
-MARK_AS_ADVANCED (CRYPTOPP_INCLUDE_DIR CRYPTOPP_LIBRARY CRYPTOPP_LIBRARY_DEBUG
- CRYPTOPP_LIBRARY_RELEASE)
-
-FIND_PACKAGE_HANDLE_STANDARD_ARGS (CryptoPP REQUIRED_VARS CRYPTOPP_ROOT_DIR
- CRYPTOPP_INCLUDE_DIR CRYPTOPP_LIBRARY VERSION_VAR CRYPTOPP_VERSION)
\ No newline at end of file
diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindOpenCL.cmake b/Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindOpenCL.cmake
deleted file mode 100644
index 415c95dbd..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindOpenCL.cmake
+++ /dev/null
@@ -1,148 +0,0 @@
-#.rst:
-# FindOpenCL
-# ----------
-#
-# Try to find OpenCL
-#
-# Once done this will define::
-#
-# OpenCL_FOUND - True if OpenCL was found
-# OpenCL_INCLUDE_DIRS - include directories for OpenCL
-# OpenCL_LIBRARIES - link against this library to use OpenCL
-# OpenCL_VERSION_STRING - Highest supported OpenCL version (eg. 1.2)
-# OpenCL_VERSION_MAJOR - The major version of the OpenCL implementation
-# OpenCL_VERSION_MINOR - The minor version of the OpenCL implementation
-#
-# The module will also define two cache variables::
-#
-# OpenCL_INCLUDE_DIR - the OpenCL include directory
-# OpenCL_LIBRARY - the path to the OpenCL library
-#
-
-#=============================================================================
-# Copyright 2014 Matthaeus G. Chajdas
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distribute this file outside of CMake, substitute the full
-# License text for the above reference.)
-
-function(_FIND_OPENCL_VERSION)
- include(CheckSymbolExists)
- include(CMakePushCheckState)
- set(CMAKE_REQUIRED_QUIET ${OpenCL_FIND_QUIETLY})
-
- CMAKE_PUSH_CHECK_STATE()
- foreach(VERSION "2_0" "1_2" "1_1" "1_0")
- set(CMAKE_REQUIRED_INCLUDES "${OpenCL_INCLUDE_DIR}")
-
- if(APPLE)
- CHECK_SYMBOL_EXISTS(
- CL_VERSION_${VERSION}
- "${OpenCL_INCLUDE_DIR}/OpenCL/cl.h"
- OPENCL_VERSION_${VERSION})
- else()
- CHECK_SYMBOL_EXISTS(
- CL_VERSION_${VERSION}
- "${OpenCL_INCLUDE_DIR}/CL/cl.h"
- OPENCL_VERSION_${VERSION})
- endif()
-
- if(OPENCL_VERSION_${VERSION})
- string(REPLACE "_" "." VERSION "${VERSION}")
- set(OpenCL_VERSION_STRING ${VERSION} PARENT_SCOPE)
- string(REGEX MATCHALL "[0-9]+" version_components "${VERSION}")
- list(GET version_components 0 major_version)
- list(GET version_components 1 minor_version)
- set(OpenCL_VERSION_MAJOR ${major_version} PARENT_SCOPE)
- set(OpenCL_VERSION_MINOR ${minor_version} PARENT_SCOPE)
- break()
- endif()
- endforeach()
- CMAKE_POP_CHECK_STATE()
-endfunction()
-
-find_path(OpenCL_INCLUDE_DIR
- NAMES
- CL/cl.h OpenCL/cl.h
- PATHS
- ENV "PROGRAMFILES(X86)"
- ENV AMDAPPSDKROOT
- ENV INTELOCLSDKROOT
- ENV NVSDKCOMPUTE_ROOT
- ENV CUDA_PATH
- ENV ATISTREAMSDKROOT
- PATH_SUFFIXES
- include
- OpenCL/common/inc
- "AMD APP/include")
-
-_FIND_OPENCL_VERSION()
-
-if(WIN32)
- if(CMAKE_SIZEOF_VOID_P EQUAL 4)
- find_library(OpenCL_LIBRARY
- NAMES OpenCL
- PATHS
- ENV "PROGRAMFILES(X86)"
- ENV AMDAPPSDKROOT
- ENV INTELOCLSDKROOT
- ENV CUDA_PATH
- ENV NVSDKCOMPUTE_ROOT
- ENV ATISTREAMSDKROOT
- PATH_SUFFIXES
- "AMD APP/lib/x86"
- lib/x86
- lib/Win32
- OpenCL/common/lib/Win32)
- elseif(CMAKE_SIZEOF_VOID_P EQUAL 8)
- find_library(OpenCL_LIBRARY
- NAMES OpenCL
- PATHS
- ENV "PROGRAMFILES(X86)"
- ENV AMDAPPSDKROOT
- ENV INTELOCLSDKROOT
- ENV CUDA_PATH
- ENV NVSDKCOMPUTE_ROOT
- ENV ATISTREAMSDKROOT
- PATH_SUFFIXES
- "AMD APP/lib/x86_64"
- lib/x86_64
- lib/x64
- OpenCL/common/lib/x64)
- endif()
-else()
- find_library(OpenCL_LIBRARY
- NAMES OpenCL
- PATHS
- ENV "PROGRAMFILES(X86)"
- ENV AMDAPPSDKROOT
- ENV INTELOCLSDKROOT
- ENV CUDA_PATH
- ENV NVSDKCOMPUTE_ROOT
- ENV ATISTREAMSDKROOT
- PATH_SUFFIXES
- "AMD APP/lib/x86_64"
- lib/x86_64
- lib/x64
- OpenCL/common/lib/x64)
-endif()
-
-set(OpenCL_LIBRARIES ${OpenCL_LIBRARY})
-set(OpenCL_INCLUDE_DIRS ${OpenCL_INCLUDE_DIR})
-
-include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
-find_package_handle_standard_args(
- OpenCL
- FOUND_VAR OpenCL_FOUND
- REQUIRED_VARS OpenCL_LIBRARY OpenCL_INCLUDE_DIR
- VERSION_VAR OpenCL_VERSION_STRING)
-
-mark_as_advanced(
- OpenCL_INCLUDE_DIR
- OpenCL_LIBRARY)
diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindPackageHandleStandardArgs.cmake b/Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindPackageHandleStandardArgs.cmake
deleted file mode 100644
index 6bcf1e788..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindPackageHandleStandardArgs.cmake
+++ /dev/null
@@ -1,382 +0,0 @@
-#.rst:
-# FindPackageHandleStandardArgs
-# -----------------------------
-#
-#
-#
-# FIND_PACKAGE_HANDLE_STANDARD_ARGS(<name> ... )
-#
-# This function is intended to be used in FindXXX.cmake modules files.
-# It handles the REQUIRED, QUIET and version-related arguments to
-# find_package(). It also sets the <packagename>_FOUND variable. The
-# package is considered found if all variables <var1>... listed contain
-# valid results, e.g. valid filepaths.
-#
-# There are two modes of this function. The first argument in both
-# modes is the name of the Find-module where it is called (in original
-# casing).
-#
-# The first simple mode looks like this:
-#
-# ::
-#
-# FIND_PACKAGE_HANDLE_STANDARD_ARGS(<name>
-# (DEFAULT_MSG|"Custom failure message") <var1>...<varN> )
-#
-# If the variables <var1> to <varN> are all valid, then
-# <UPPERCASED_NAME>_FOUND will be set to TRUE. If DEFAULT_MSG is given
-# as second argument, then the function will generate itself useful
-# success and error messages. You can also supply a custom error
-# message for the failure case. This is not recommended.
-#
-# The second mode is more powerful and also supports version checking:
-#
-# ::
-#
-# FIND_PACKAGE_HANDLE_STANDARD_ARGS(NAME
-# [FOUND_VAR <resultVar>]
-# [REQUIRED_VARS <var1>...<varN>]
-# [VERSION_VAR <versionvar>]
-# [HANDLE_COMPONENTS]
-# [CONFIG_MODE]
-# [FAIL_MESSAGE "Custom failure message"] )
-#
-# In this mode, the name of the result-variable can be set either to
-# either <UPPERCASED_NAME>_FOUND or <OriginalCase_Name>_FOUND using the
-# FOUND_VAR option. Other names for the result-variable are not
-# allowed. So for a Find-module named FindFooBar.cmake, the two
-# possible names are FooBar_FOUND and FOOBAR_FOUND. It is recommended
-# to use the original case version. If the FOUND_VAR option is not
-# used, the default is <UPPERCASED_NAME>_FOUND.
-#
-# As in the simple mode, if <var1> through <varN> are all valid,
-# <packagename>_FOUND will be set to TRUE. After REQUIRED_VARS the
-# variables which are required for this package are listed. Following
-# VERSION_VAR the name of the variable can be specified which holds the
-# version of the package which has been found. If this is done, this
-# version will be checked against the (potentially) specified required
-# version used in the find_package() call. The EXACT keyword is also
-# handled. The default messages include information about the required
-# version and the version which has been actually found, both if the
-# version is ok or not. If the package supports components, use the
-# HANDLE_COMPONENTS option to enable handling them. In this case,
-# find_package_handle_standard_args() will report which components have
-# been found and which are missing, and the <packagename>_FOUND variable
-# will be set to FALSE if any of the required components (i.e. not the
-# ones listed after OPTIONAL_COMPONENTS) are missing. Use the option
-# CONFIG_MODE if your FindXXX.cmake module is a wrapper for a
-# find_package(... NO_MODULE) call. In this case VERSION_VAR will be
-# set to <NAME>_VERSION and the macro will automatically check whether
-# the Config module was found. Via FAIL_MESSAGE a custom failure
-# message can be specified, if this is not used, the default message
-# will be displayed.
-#
-# Example for mode 1:
-#
-# ::
-#
-# find_package_handle_standard_args(LibXml2 DEFAULT_MSG
-# LIBXML2_LIBRARY LIBXML2_INCLUDE_DIR)
-#
-#
-#
-# LibXml2 is considered to be found, if both LIBXML2_LIBRARY and
-# LIBXML2_INCLUDE_DIR are valid. Then also LIBXML2_FOUND is set to
-# TRUE. If it is not found and REQUIRED was used, it fails with
-# FATAL_ERROR, independent whether QUIET was used or not. If it is
-# found, success will be reported, including the content of <var1>. On
-# repeated Cmake runs, the same message won't be printed again.
-#
-# Example for mode 2:
-#
-# ::
-#
-# find_package_handle_standard_args(LibXslt
-# FOUND_VAR LibXslt_FOUND
-# REQUIRED_VARS LibXslt_LIBRARIES LibXslt_INCLUDE_DIRS
-# VERSION_VAR LibXslt_VERSION_STRING)
-#
-# In this case, LibXslt is considered to be found if the variable(s)
-# listed after REQUIRED_VAR are all valid, i.e. LibXslt_LIBRARIES and
-# LibXslt_INCLUDE_DIRS in this case. The result will then be stored in
-# LibXslt_FOUND . Also the version of LibXslt will be checked by using
-# the version contained in LibXslt_VERSION_STRING. Since no
-# FAIL_MESSAGE is given, the default messages will be printed.
-#
-# Another example for mode 2:
-#
-# ::
-#
-# find_package(Automoc4 QUIET NO_MODULE HINTS /opt/automoc4)
-# find_package_handle_standard_args(Automoc4 CONFIG_MODE)
-#
-# In this case, FindAutmoc4.cmake wraps a call to find_package(Automoc4
-# NO_MODULE) and adds an additional search directory for automoc4. Here
-# the result will be stored in AUTOMOC4_FOUND. The following
-# FIND_PACKAGE_HANDLE_STANDARD_ARGS() call produces a proper
-# success/error message.
-
-#=============================================================================
-# Copyright 2007-2009 Kitware, Inc.
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distribute this file outside of CMake, substitute the full
-# License text for the above reference.)
-
-include(${CMAKE_CURRENT_LIST_DIR}/FindPackageMessage.cmake)
-include(${CMAKE_CURRENT_LIST_DIR}/CMakeParseArguments.cmake)
-
-# internal helper macro
-macro(_FPHSA_FAILURE_MESSAGE _msg)
- if (${_NAME}_FIND_REQUIRED)
- message(FATAL_ERROR "${_msg}")
- else ()
- if (NOT ${_NAME}_FIND_QUIETLY)
- message(STATUS "${_msg}")
- endif ()
- endif ()
-endmacro()
-
-
-# internal helper macro to generate the failure message when used in CONFIG_MODE:
-macro(_FPHSA_HANDLE_FAILURE_CONFIG_MODE)
- # <name>_CONFIG is set, but FOUND is false, this means that some other of the REQUIRED_VARS was not found:
- if(${_NAME}_CONFIG)
- _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: missing: ${MISSING_VARS} (found ${${_NAME}_CONFIG} ${VERSION_MSG})")
- else()
- # If _CONSIDERED_CONFIGS is set, the config-file has been found, but no suitable version.
- # List them all in the error message:
- if(${_NAME}_CONSIDERED_CONFIGS)
- set(configsText "")
- list(LENGTH ${_NAME}_CONSIDERED_CONFIGS configsCount)
- math(EXPR configsCount "${configsCount} - 1")
- foreach(currentConfigIndex RANGE ${configsCount})
- list(GET ${_NAME}_CONSIDERED_CONFIGS ${currentConfigIndex} filename)
- list(GET ${_NAME}_CONSIDERED_VERSIONS ${currentConfigIndex} version)
- set(configsText "${configsText} ${filename} (version ${version})\n")
- endforeach()
- if (${_NAME}_NOT_FOUND_MESSAGE)
- set(configsText "${configsText} Reason given by package: ${${_NAME}_NOT_FOUND_MESSAGE}\n")
- endif()
- _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} ${VERSION_MSG}, checked the following files:\n${configsText}")
-
- else()
- # Simple case: No Config-file was found at all:
- _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: found neither ${_NAME}Config.cmake nor ${_NAME_LOWER}-config.cmake ${VERSION_MSG}")
- endif()
- endif()
-endmacro()
-
-
-function(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FIRST_ARG)
-
-# set up the arguments for CMAKE_PARSE_ARGUMENTS and check whether we are in
-# new extended or in the "old" mode:
- set(options CONFIG_MODE HANDLE_COMPONENTS)
- set(oneValueArgs FAIL_MESSAGE VERSION_VAR FOUND_VAR)
- set(multiValueArgs REQUIRED_VARS)
- set(_KEYWORDS_FOR_EXTENDED_MODE ${options} ${oneValueArgs} ${multiValueArgs} )
- list(FIND _KEYWORDS_FOR_EXTENDED_MODE "${_FIRST_ARG}" INDEX)
-
- if(${INDEX} EQUAL -1)
- set(FPHSA_FAIL_MESSAGE ${_FIRST_ARG})
- set(FPHSA_REQUIRED_VARS ${ARGN})
- set(FPHSA_VERSION_VAR)
- else()
-
- CMAKE_PARSE_ARGUMENTS(FPHSA "${options}" "${oneValueArgs}" "${multiValueArgs}" ${_FIRST_ARG} ${ARGN})
-
- if(FPHSA_UNPARSED_ARGUMENTS)
- message(FATAL_ERROR "Unknown keywords given to FIND_PACKAGE_HANDLE_STANDARD_ARGS(): \"${FPHSA_UNPARSED_ARGUMENTS}\"")
- endif()
-
- if(NOT FPHSA_FAIL_MESSAGE)
- set(FPHSA_FAIL_MESSAGE "DEFAULT_MSG")
- endif()
- endif()
-
-# now that we collected all arguments, process them
-
- if("x${FPHSA_FAIL_MESSAGE}" STREQUAL "xDEFAULT_MSG")
- set(FPHSA_FAIL_MESSAGE "Could NOT find ${_NAME}")
- endif()
-
- # In config-mode, we rely on the variable <package>_CONFIG, which is set by find_package()
- # when it successfully found the config-file, including version checking:
- if(FPHSA_CONFIG_MODE)
- list(INSERT FPHSA_REQUIRED_VARS 0 ${_NAME}_CONFIG)
- list(REMOVE_DUPLICATES FPHSA_REQUIRED_VARS)
- set(FPHSA_VERSION_VAR ${_NAME}_VERSION)
- endif()
-
- if(NOT FPHSA_REQUIRED_VARS)
- message(FATAL_ERROR "No REQUIRED_VARS specified for FIND_PACKAGE_HANDLE_STANDARD_ARGS()")
- endif()
-
- list(GET FPHSA_REQUIRED_VARS 0 _FIRST_REQUIRED_VAR)
-
- string(TOUPPER ${_NAME} _NAME_UPPER)
- string(TOLOWER ${_NAME} _NAME_LOWER)
-
- if(FPHSA_FOUND_VAR)
- if(FPHSA_FOUND_VAR MATCHES "^${_NAME}_FOUND$" OR FPHSA_FOUND_VAR MATCHES "^${_NAME_UPPER}_FOUND$")
- set(_FOUND_VAR ${FPHSA_FOUND_VAR})
- else()
- message(FATAL_ERROR "The argument for FOUND_VAR is \"${FPHSA_FOUND_VAR}\", but only \"${_NAME}_FOUND\" and \"${_NAME_UPPER}_FOUND\" are valid names.")
- endif()
- else()
- set(_FOUND_VAR ${_NAME_UPPER}_FOUND)
- endif()
-
- # collect all variables which were not found, so they can be printed, so the
- # user knows better what went wrong (#6375)
- set(MISSING_VARS "")
- set(DETAILS "")
- # check if all passed variables are valid
- unset(${_FOUND_VAR})
- foreach(_CURRENT_VAR ${FPHSA_REQUIRED_VARS})
- if(NOT ${_CURRENT_VAR})
- set(${_FOUND_VAR} FALSE)
- set(MISSING_VARS "${MISSING_VARS} ${_CURRENT_VAR}")
- else()
- set(DETAILS "${DETAILS}[${${_CURRENT_VAR}}]")
- endif()
- endforeach()
- if(NOT "${${_FOUND_VAR}}" STREQUAL "FALSE")
- set(${_FOUND_VAR} TRUE)
- endif()
-
- # component handling
- unset(FOUND_COMPONENTS_MSG)
- unset(MISSING_COMPONENTS_MSG)
-
- if(FPHSA_HANDLE_COMPONENTS)
- foreach(comp ${${_NAME}_FIND_COMPONENTS})
- if(${_NAME}_${comp}_FOUND)
-
- if(NOT DEFINED FOUND_COMPONENTS_MSG)
- set(FOUND_COMPONENTS_MSG "found components: ")
- endif()
- set(FOUND_COMPONENTS_MSG "${FOUND_COMPONENTS_MSG} ${comp}")
-
- else()
-
- if(NOT DEFINED MISSING_COMPONENTS_MSG)
- set(MISSING_COMPONENTS_MSG "missing components: ")
- endif()
- set(MISSING_COMPONENTS_MSG "${MISSING_COMPONENTS_MSG} ${comp}")
-
- if(${_NAME}_FIND_REQUIRED_${comp})
- set(${_FOUND_VAR} FALSE)
- set(MISSING_VARS "${MISSING_VARS} ${comp}")
- endif()
-
- endif()
- endforeach()
- set(COMPONENT_MSG "${FOUND_COMPONENTS_MSG} ${MISSING_COMPONENTS_MSG}")
- set(DETAILS "${DETAILS}[c${COMPONENT_MSG}]")
- endif()
-
- # version handling:
- set(VERSION_MSG "")
- set(VERSION_OK TRUE)
- set(VERSION ${${FPHSA_VERSION_VAR}})
-
- # check with DEFINED here as the requested or found version may be "0"
- if (DEFINED ${_NAME}_FIND_VERSION)
- if(DEFINED ${FPHSA_VERSION_VAR})
-
- if(${_NAME}_FIND_VERSION_EXACT) # exact version required
- # count the dots in the version string
- string(REGEX REPLACE "[^.]" "" _VERSION_DOTS "${VERSION}")
- # add one dot because there is one dot more than there are components
- string(LENGTH "${_VERSION_DOTS}." _VERSION_DOTS)
- if (_VERSION_DOTS GREATER ${_NAME}_FIND_VERSION_COUNT)
- # Because of the C++ implementation of find_package() ${_NAME}_FIND_VERSION_COUNT
- # is at most 4 here. Therefore a simple lookup table is used.
- if (${_NAME}_FIND_VERSION_COUNT EQUAL 1)
- set(_VERSION_REGEX "[^.]*")
- elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 2)
- set(_VERSION_REGEX "[^.]*\\.[^.]*")
- elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 3)
- set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*")
- else ()
- set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*\\.[^.]*")
- endif ()
- string(REGEX REPLACE "^(${_VERSION_REGEX})\\..*" "\\1" _VERSION_HEAD "${VERSION}")
- unset(_VERSION_REGEX)
- if (NOT ${_NAME}_FIND_VERSION VERSION_EQUAL _VERSION_HEAD)
- set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"")
- set(VERSION_OK FALSE)
- else ()
- set(VERSION_MSG "(found suitable exact version \"${VERSION}\")")
- endif ()
- unset(_VERSION_HEAD)
- else ()
- if (NOT "${${_NAME}_FIND_VERSION}" VERSION_EQUAL "${VERSION}")
- set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"")
- set(VERSION_OK FALSE)
- else ()
- set(VERSION_MSG "(found suitable exact version \"${VERSION}\")")
- endif ()
- endif ()
- unset(_VERSION_DOTS)
-
- else() # minimum version specified:
- if ("${${_NAME}_FIND_VERSION}" VERSION_GREATER "${VERSION}")
- set(VERSION_MSG "Found unsuitable version \"${VERSION}\", but required is at least \"${${_NAME}_FIND_VERSION}\"")
- set(VERSION_OK FALSE)
- else ()
- set(VERSION_MSG "(found suitable version \"${VERSION}\", minimum required is \"${${_NAME}_FIND_VERSION}\")")
- endif ()
- endif()
-
- else()
-
- # if the package was not found, but a version was given, add that to the output:
- if(${_NAME}_FIND_VERSION_EXACT)
- set(VERSION_MSG "(Required is exact version \"${${_NAME}_FIND_VERSION}\")")
- else()
- set(VERSION_MSG "(Required is at least version \"${${_NAME}_FIND_VERSION}\")")
- endif()
-
- endif()
- else ()
- if(VERSION)
- set(VERSION_MSG "(found version \"${VERSION}\")")
- endif()
- endif ()
-
- if(VERSION_OK)
- set(DETAILS "${DETAILS}[v${VERSION}(${${_NAME}_FIND_VERSION})]")
- else()
- set(${_FOUND_VAR} FALSE)
- endif()
-
-
- # print the result:
- if (${_FOUND_VAR})
- FIND_PACKAGE_MESSAGE(${_NAME} "Found ${_NAME}: ${${_FIRST_REQUIRED_VAR}} ${VERSION_MSG} ${COMPONENT_MSG}" "${DETAILS}")
- else ()
-
- if(FPHSA_CONFIG_MODE)
- _FPHSA_HANDLE_FAILURE_CONFIG_MODE()
- else()
- if(NOT VERSION_OK)
- _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: ${VERSION_MSG} (found ${${_FIRST_REQUIRED_VAR}})")
- else()
- _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} (missing: ${MISSING_VARS}) ${VERSION_MSG}")
- endif()
- endif()
-
- endif ()
-
- set(${_FOUND_VAR} ${${_FOUND_VAR}} PARENT_SCOPE)
-
-endfunction()
diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindPackageMessage.cmake b/Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindPackageMessage.cmake
deleted file mode 100644
index a0349d3db..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindPackageMessage.cmake
+++ /dev/null
@@ -1,57 +0,0 @@
-#.rst:
-# FindPackageMessage
-# ------------------
-#
-#
-#
-# FIND_PACKAGE_MESSAGE(<name> "message for user" "find result details")
-#
-# This macro is intended to be used in FindXXX.cmake modules files. It
-# will print a message once for each unique find result. This is useful
-# for telling the user where a package was found. The first argument
-# specifies the name (XXX) of the package. The second argument
-# specifies the message to display. The third argument lists details
-# about the find result so that if they change the message will be
-# displayed again. The macro also obeys the QUIET argument to the
-# find_package command.
-#
-# Example:
-#
-# ::
-#
-# if(X11_FOUND)
-# FIND_PACKAGE_MESSAGE(X11 "Found X11: ${X11_X11_LIB}"
-# "[${X11_X11_LIB}][${X11_INCLUDE_DIR}]")
-# else()
-# ...
-# endif()
-
-#=============================================================================
-# Copyright 2008-2009 Kitware, Inc.
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distribute this file outside of CMake, substitute the full
-# License text for the above reference.)
-
-function(FIND_PACKAGE_MESSAGE pkg msg details)
- # Avoid printing a message repeatedly for the same find result.
- if(NOT ${pkg}_FIND_QUIETLY)
- string(REPLACE "\n" "" details "${details}")
- set(DETAILS_VAR FIND_PACKAGE_MESSAGE_DETAILS_${pkg})
- if(NOT "${details}" STREQUAL "${${DETAILS_VAR}}")
- # The message has not yet been printed.
- message(STATUS "${msg}")
-
- # Save the find details in the cache to avoid printing the same
- # message again.
- set("${DETAILS_VAR}" "${details}"
- CACHE INTERNAL "Details about finding ${pkg}")
- endif()
- endif()
-endfunction()
diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/cryptopp/CMakeLists.txt b/Godeps/_workspace/src/github.com/ethereum/ethash/cryptopp/CMakeLists.txt
deleted file mode 100644
index 6f4280532..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/cryptopp/CMakeLists.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-set(LIBRARY cryptopp)
-
-include_directories(../../cryptopp)
-
-# todo, subset
-file(GLOB HEADERS "../../cryptopp/*.h")
-file(GLOB SOURCE "../../cryptopp/*.cpp")
-
-add_library(${LIBRARY} ${HEADERS} ${SOURCE})
-
-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 2199dbec1..ad59dd5e3 100644
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/ethash.go
+++ b/Godeps/_workspace/src/github.com/ethereum/ethash/ethash.go
@@ -75,6 +75,7 @@ func defaultDir() string {
// and automatic memory management.
type cache struct {
epoch uint64
+ used time.Time
test bool
gen sync.Once // ensures cache is only generated once.
@@ -104,14 +105,13 @@ func freeCache(cache *cache) {
cache.ptr = nil
}
-// Light implements the Verify half of the proof of work.
-// It uses a small in-memory cache to verify the nonces
-// found by Full.
+// Light implements the Verify half of the proof of work. It uses a few small
+// in-memory caches to verify the nonces found by Full.
type Light struct {
- test bool // if set use a smaller cache size
- mu sync.Mutex // protects current
- current *cache // last cache which was generated.
- // TODO: keep multiple caches.
+ test bool // if set use a smaller cache size
+ mu sync.Mutex // protects the per-epoch map of DAGs
+ caches map[uint64]*cache // currently cached verification DAGs
+ NumCaches int // Maximum number of DAGs to cache before eviction (only init, don't modify)
}
// Verify checks whether the block's nonce is valid.
@@ -173,16 +173,36 @@ func hashToH256(in common.Hash) C.ethash_h256_t {
func (l *Light) getCache(blockNum uint64) *cache {
var c *cache
epoch := blockNum / epochLength
- // Update or reuse the last cache.
+
+ // If we have a PoW for that epoch, use that
l.mu.Lock()
- if l.current != nil && l.current.epoch == epoch {
- c = l.current
- } else {
+ if l.caches == nil {
+ l.caches = make(map[uint64]*cache)
+ }
+ if l.NumCaches == 0 {
+ l.NumCaches = 3
+ }
+ c = l.caches[epoch]
+ if c == nil {
+ // No cached DAG, evict the oldest if the cache limit was reached
+ if len(l.caches) >= l.NumCaches {
+ var evict *cache
+ for _, cache := range l.caches {
+ if evict == nil || evict.used.After(cache.used) {
+ evict = cache
+ }
+ }
+ glog.V(logger.Info).Infof("Evicting DAG for epoch %d in favour of epoch %d", evict.epoch, epoch)
+ delete(l.caches, evict.epoch)
+ }
+ // Create and return a new DAG for the epoch
c = &cache{epoch: epoch, test: l.test}
- l.current = c
+ l.caches[epoch] = c
}
+ c.used = time.Now()
l.mu.Unlock()
- // Wait for the cache to finish generating.
+
+ // Wait for generation finish and return the cache
c.generate()
return c
}
@@ -362,9 +382,13 @@ type Ethash struct {
}
// New creates an instance of the proof of work.
-// A single instance of Light is shared across all instances
-// created with New.
func New() *Ethash {
+ return &Ethash{new(Light), &Full{turbo: true}}
+}
+
+// NewShared creates an instance of the proof of work., where a single instance
+// of the Light cache is shared across all instances created with NewShared.
+func NewShared() *Ethash {
return &Ethash{sharedLight, &Full{turbo: true}}
}
diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/js/LICENSE b/Godeps/_workspace/src/github.com/ethereum/ethash/js/LICENSE
deleted file mode 100644
index 070be633d..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/js/LICENSE
+++ /dev/null
@@ -1,22 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2015 Tim Hughes
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/js/ethash.js b/Godeps/_workspace/src/github.com/ethereum/ethash/js/ethash.js
deleted file mode 100644
index bec1284f6..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/js/ethash.js
+++ /dev/null
@@ -1,190 +0,0 @@
-// ethash.js
-// Tim Hughes <tim@twistedfury.com>
-// Revision 19
-
-/*jslint node: true, shadow:true */
-"use strict";
-
-var Keccak = require('./keccak');
-var util = require('./util');
-
-// 32-bit unsigned modulo
-function mod32(x, n)
-{
- return (x>>>0) % (n>>>0);
-}
-
-function fnv(x, y)
-{
- // js integer multiply by 0x01000193 will lose precision
- return ((x*0x01000000 | 0) + (x*0x193 | 0)) ^ y;
-}
-
-function computeCache(params, seedWords)
-{
- var cache = new Uint32Array(params.cacheSize >> 2);
- var cacheNodeCount = params.cacheSize >> 6;
-
- // Initialize cache
- var keccak = new Keccak();
- keccak.digestWords(cache, 0, 16, seedWords, 0, seedWords.length);
- for (var n = 1; n < cacheNodeCount; ++n)
- {
- keccak.digestWords(cache, n<<4, 16, cache, (n-1)<<4, 16);
- }
-
- var tmp = new Uint32Array(16);
-
- // Do randmemohash passes
- for (var r = 0; r < params.cacheRounds; ++r)
- {
- for (var n = 0; n < cacheNodeCount; ++n)
- {
- var p0 = mod32(n + cacheNodeCount - 1, cacheNodeCount) << 4;
- var p1 = mod32(cache[n<<4|0], cacheNodeCount) << 4;
-
- for (var w = 0; w < 16; w=(w+1)|0)
- {
- tmp[w] = cache[p0 | w] ^ cache[p1 | w];
- }
-
- keccak.digestWords(cache, n<<4, 16, tmp, 0, tmp.length);
- }
- }
- return cache;
-}
-
-function computeDagNode(o_node, params, cache, keccak, nodeIndex)
-{
- var cacheNodeCount = params.cacheSize >> 6;
- var dagParents = params.dagParents;
-
- var c = (nodeIndex % cacheNodeCount) << 4;
- var mix = o_node;
- for (var w = 0; w < 16; ++w)
- {
- mix[w] = cache[c|w];
- }
- mix[0] ^= nodeIndex;
- keccak.digestWords(mix, 0, 16, mix, 0, 16);
-
- for (var p = 0; p < dagParents; ++p)
- {
- // compute cache node (word) index
- c = mod32(fnv(nodeIndex ^ p, mix[p&15]), cacheNodeCount) << 4;
-
- for (var w = 0; w < 16; ++w)
- {
- mix[w] = fnv(mix[w], cache[c|w]);
- }
- }
-
- keccak.digestWords(mix, 0, 16, mix, 0, 16);
-}
-
-function computeHashInner(mix, params, cache, keccak, tempNode)
-{
- var mixParents = params.mixParents|0;
- var mixWordCount = params.mixSize >> 2;
- var mixNodeCount = mixWordCount >> 4;
- var dagPageCount = (params.dagSize / params.mixSize) >> 0;
-
- // grab initial first word
- var s0 = mix[0];
-
- // initialise mix from initial 64 bytes
- for (var w = 16; w < mixWordCount; ++w)
- {
- mix[w] = mix[w & 15];
- }
-
- for (var a = 0; a < mixParents; ++a)
- {
- var p = mod32(fnv(s0 ^ a, mix[a & (mixWordCount-1)]), dagPageCount);
- var d = (p * mixNodeCount)|0;
-
- for (var n = 0, w = 0; n < mixNodeCount; ++n, w += 16)
- {
- computeDagNode(tempNode, params, cache, keccak, (d + n)|0);
-
- for (var v = 0; v < 16; ++v)
- {
- mix[w|v] = fnv(mix[w|v], tempNode[v]);
- }
- }
- }
-}
-
-function convertSeed(seed)
-{
- // todo, reconcile with spec, byte ordering?
- // todo, big-endian conversion
- var newSeed = util.toWords(seed);
- if (newSeed === null)
- throw Error("Invalid seed '" + seed + "'");
- return newSeed;
-}
-
-exports.defaultParams = function()
-{
- return {
- cacheSize: 1048384,
- cacheRounds: 3,
- dagSize: 1073739904,
- dagParents: 256,
- mixSize: 128,
- mixParents: 64,
- };
-};
-
-exports.Ethash = function(params, seed)
-{
- // precompute cache and related values
- seed = convertSeed(seed);
- var cache = computeCache(params, seed);
-
- // preallocate buffers/etc
- var initBuf = new ArrayBuffer(96);
- var initBytes = new Uint8Array(initBuf);
- var initWords = new Uint32Array(initBuf);
- var mixWords = new Uint32Array(params.mixSize / 4);
- var tempNode = new Uint32Array(16);
- var keccak = new Keccak();
-
- var retWords = new Uint32Array(8);
- var retBytes = new Uint8Array(retWords.buffer); // supposedly read-only
-
- this.hash = function(header, nonce)
- {
- // compute initial hash
- initBytes.set(header, 0);
- initBytes.set(nonce, 32);
- keccak.digestWords(initWords, 0, 16, initWords, 0, 8 + nonce.length/4);
-
- // compute mix
- for (var i = 0; i != 16; ++i)
- {
- mixWords[i] = initWords[i];
- }
- computeHashInner(mixWords, params, cache, keccak, tempNode);
-
- // compress mix and append to initWords
- for (var i = 0; i != mixWords.length; i += 4)
- {
- initWords[16 + i/4] = fnv(fnv(fnv(mixWords[i], mixWords[i+1]), mixWords[i+2]), mixWords[i+3]);
- }
-
- // final Keccak hashes
- keccak.digestWords(retWords, 0, 8, initWords, 0, 24); // Keccak-256(s + cmix)
- return retBytes;
- };
-
- this.cacheDigest = function()
- {
- return keccak.digest(32, new Uint8Array(cache.buffer));
- };
-};
-
-
-
-
diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/js/keccak.js b/Godeps/_workspace/src/github.com/ethereum/ethash/js/keccak.js
deleted file mode 100644
index 84ddde645..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/js/keccak.js
+++ /dev/null
@@ -1,404 +0,0 @@
-// keccak.js
-// Tim Hughes <tim@twistedfury.com>
-// derived from Markku-Juhani O. Saarinen's C code (http://keccak.noekeon.org/readable_code.html)
-
-/*jslint node: true, shadow:true */
-"use strict";
-
-var Keccak_f1600_RC = new Uint32Array([
- 0x00000001, 0x00000000,
- 0x00008082, 0x00000000,
- 0x0000808a, 0x80000000,
- 0x80008000, 0x80000000,
- 0x0000808b, 0x00000000,
- 0x80000001, 0x00000000,
- 0x80008081, 0x80000000,
- 0x00008009, 0x80000000,
- 0x0000008a, 0x00000000,
- 0x00000088, 0x00000000,
- 0x80008009, 0x00000000,
- 0x8000000a, 0x00000000,
- 0x8000808b, 0x00000000,
- 0x0000008b, 0x80000000,
- 0x00008089, 0x80000000,
- 0x00008003, 0x80000000,
- 0x00008002, 0x80000000,
- 0x00000080, 0x80000000,
- 0x0000800a, 0x00000000,
- 0x8000000a, 0x80000000,
- 0x80008081, 0x80000000,
- 0x00008080, 0x80000000,
- 0x80000001, 0x00000000,
- 0x80008008, 0x80000000
-]);
-
-function keccak_f1600(outState, outOffset, outSize, inState)
-{
- // todo, handle big endian loads
- var a00l = inState[0]|0;
- var a00h = inState[1]|0;
- var a01l = inState[2]|0;
- var a01h = inState[3]|0;
- var a02l = inState[4]|0;
- var a02h = inState[5]|0;
- var a03l = inState[6]|0;
- var a03h = inState[7]|0;
- var a04l = inState[8]|0;
- var a04h = inState[9]|0;
- var a05l = inState[10]|0;
- var a05h = inState[11]|0;
- var a06l = inState[12]|0;
- var a06h = inState[13]|0;
- var a07l = inState[14]|0;
- var a07h = inState[15]|0;
- var a08l = inState[16]|0;
- var a08h = inState[17]|0;
- var a09l = inState[18]|0;
- var a09h = inState[19]|0;
- var a10l = inState[20]|0;
- var a10h = inState[21]|0;
- var a11l = inState[22]|0;
- var a11h = inState[23]|0;
- var a12l = inState[24]|0;
- var a12h = inState[25]|0;
- var a13l = inState[26]|0;
- var a13h = inState[27]|0;
- var a14l = inState[28]|0;
- var a14h = inState[29]|0;
- var a15l = inState[30]|0;
- var a15h = inState[31]|0;
- var a16l = inState[32]|0;
- var a16h = inState[33]|0;
- var a17l = inState[34]|0;
- var a17h = inState[35]|0;
- var a18l = inState[36]|0;
- var a18h = inState[37]|0;
- var a19l = inState[38]|0;
- var a19h = inState[39]|0;
- var a20l = inState[40]|0;
- var a20h = inState[41]|0;
- var a21l = inState[42]|0;
- var a21h = inState[43]|0;
- var a22l = inState[44]|0;
- var a22h = inState[45]|0;
- var a23l = inState[46]|0;
- var a23h = inState[47]|0;
- var a24l = inState[48]|0;
- var a24h = inState[49]|0;
- var b00l, b00h, b01l, b01h, b02l, b02h, b03l, b03h, b04l, b04h;
- var b05l, b05h, b06l, b06h, b07l, b07h, b08l, b08h, b09l, b09h;
- var b10l, b10h, b11l, b11h, b12l, b12h, b13l, b13h, b14l, b14h;
- var b15l, b15h, b16l, b16h, b17l, b17h, b18l, b18h, b19l, b19h;
- var b20l, b20h, b21l, b21h, b22l, b22h, b23l, b23h, b24l, b24h;
- var tl, nl;
- var th, nh;
-
- for (var r = 0; r < 48; r = (r+2)|0)
- {
- // Theta
- b00l = a00l ^ a05l ^ a10l ^ a15l ^ a20l;
- b00h = a00h ^ a05h ^ a10h ^ a15h ^ a20h;
- b01l = a01l ^ a06l ^ a11l ^ a16l ^ a21l;
- b01h = a01h ^ a06h ^ a11h ^ a16h ^ a21h;
- b02l = a02l ^ a07l ^ a12l ^ a17l ^ a22l;
- b02h = a02h ^ a07h ^ a12h ^ a17h ^ a22h;
- b03l = a03l ^ a08l ^ a13l ^ a18l ^ a23l;
- b03h = a03h ^ a08h ^ a13h ^ a18h ^ a23h;
- b04l = a04l ^ a09l ^ a14l ^ a19l ^ a24l;
- b04h = a04h ^ a09h ^ a14h ^ a19h ^ a24h;
- tl = b04l ^ (b01l << 1 | b01h >>> 31);
- th = b04h ^ (b01h << 1 | b01l >>> 31);
- a00l ^= tl;
- a00h ^= th;
- a05l ^= tl;
- a05h ^= th;
- a10l ^= tl;
- a10h ^= th;
- a15l ^= tl;
- a15h ^= th;
- a20l ^= tl;
- a20h ^= th;
- tl = b00l ^ (b02l << 1 | b02h >>> 31);
- th = b00h ^ (b02h << 1 | b02l >>> 31);
- a01l ^= tl;
- a01h ^= th;
- a06l ^= tl;
- a06h ^= th;
- a11l ^= tl;
- a11h ^= th;
- a16l ^= tl;
- a16h ^= th;
- a21l ^= tl;
- a21h ^= th;
- tl = b01l ^ (b03l << 1 | b03h >>> 31);
- th = b01h ^ (b03h << 1 | b03l >>> 31);
- a02l ^= tl;
- a02h ^= th;
- a07l ^= tl;
- a07h ^= th;
- a12l ^= tl;
- a12h ^= th;
- a17l ^= tl;
- a17h ^= th;
- a22l ^= tl;
- a22h ^= th;
- tl = b02l ^ (b04l << 1 | b04h >>> 31);
- th = b02h ^ (b04h << 1 | b04l >>> 31);
- a03l ^= tl;
- a03h ^= th;
- a08l ^= tl;
- a08h ^= th;
- a13l ^= tl;
- a13h ^= th;
- a18l ^= tl;
- a18h ^= th;
- a23l ^= tl;
- a23h ^= th;
- tl = b03l ^ (b00l << 1 | b00h >>> 31);
- th = b03h ^ (b00h << 1 | b00l >>> 31);
- a04l ^= tl;
- a04h ^= th;
- a09l ^= tl;
- a09h ^= th;
- a14l ^= tl;
- a14h ^= th;
- a19l ^= tl;
- a19h ^= th;
- a24l ^= tl;
- a24h ^= th;
-
- // Rho Pi
- b00l = a00l;
- b00h = a00h;
- b10l = a01l << 1 | a01h >>> 31;
- b10h = a01h << 1 | a01l >>> 31;
- b07l = a10l << 3 | a10h >>> 29;
- b07h = a10h << 3 | a10l >>> 29;
- b11l = a07l << 6 | a07h >>> 26;
- b11h = a07h << 6 | a07l >>> 26;
- b17l = a11l << 10 | a11h >>> 22;
- b17h = a11h << 10 | a11l >>> 22;
- b18l = a17l << 15 | a17h >>> 17;
- b18h = a17h << 15 | a17l >>> 17;
- b03l = a18l << 21 | a18h >>> 11;
- b03h = a18h << 21 | a18l >>> 11;
- b05l = a03l << 28 | a03h >>> 4;
- b05h = a03h << 28 | a03l >>> 4;
- b16l = a05h << 4 | a05l >>> 28;
- b16h = a05l << 4 | a05h >>> 28;
- b08l = a16h << 13 | a16l >>> 19;
- b08h = a16l << 13 | a16h >>> 19;
- b21l = a08h << 23 | a08l >>> 9;
- b21h = a08l << 23 | a08h >>> 9;
- b24l = a21l << 2 | a21h >>> 30;
- b24h = a21h << 2 | a21l >>> 30;
- b04l = a24l << 14 | a24h >>> 18;
- b04h = a24h << 14 | a24l >>> 18;
- b15l = a04l << 27 | a04h >>> 5;
- b15h = a04h << 27 | a04l >>> 5;
- b23l = a15h << 9 | a15l >>> 23;
- b23h = a15l << 9 | a15h >>> 23;
- b19l = a23h << 24 | a23l >>> 8;
- b19h = a23l << 24 | a23h >>> 8;
- b13l = a19l << 8 | a19h >>> 24;
- b13h = a19h << 8 | a19l >>> 24;
- b12l = a13l << 25 | a13h >>> 7;
- b12h = a13h << 25 | a13l >>> 7;
- b02l = a12h << 11 | a12l >>> 21;
- b02h = a12l << 11 | a12h >>> 21;
- b20l = a02h << 30 | a02l >>> 2;
- b20h = a02l << 30 | a02h >>> 2;
- b14l = a20l << 18 | a20h >>> 14;
- b14h = a20h << 18 | a20l >>> 14;
- b22l = a14h << 7 | a14l >>> 25;
- b22h = a14l << 7 | a14h >>> 25;
- b09l = a22h << 29 | a22l >>> 3;
- b09h = a22l << 29 | a22h >>> 3;
- b06l = a09l << 20 | a09h >>> 12;
- b06h = a09h << 20 | a09l >>> 12;
- b01l = a06h << 12 | a06l >>> 20;
- b01h = a06l << 12 | a06h >>> 20;
-
- // Chi
- a00l = b00l ^ ~b01l & b02l;
- a00h = b00h ^ ~b01h & b02h;
- a01l = b01l ^ ~b02l & b03l;
- a01h = b01h ^ ~b02h & b03h;
- a02l = b02l ^ ~b03l & b04l;
- a02h = b02h ^ ~b03h & b04h;
- a03l = b03l ^ ~b04l & b00l;
- a03h = b03h ^ ~b04h & b00h;
- a04l = b04l ^ ~b00l & b01l;
- a04h = b04h ^ ~b00h & b01h;
- a05l = b05l ^ ~b06l & b07l;
- a05h = b05h ^ ~b06h & b07h;
- a06l = b06l ^ ~b07l & b08l;
- a06h = b06h ^ ~b07h & b08h;
- a07l = b07l ^ ~b08l & b09l;
- a07h = b07h ^ ~b08h & b09h;
- a08l = b08l ^ ~b09l & b05l;
- a08h = b08h ^ ~b09h & b05h;
- a09l = b09l ^ ~b05l & b06l;
- a09h = b09h ^ ~b05h & b06h;
- a10l = b10l ^ ~b11l & b12l;
- a10h = b10h ^ ~b11h & b12h;
- a11l = b11l ^ ~b12l & b13l;
- a11h = b11h ^ ~b12h & b13h;
- a12l = b12l ^ ~b13l & b14l;
- a12h = b12h ^ ~b13h & b14h;
- a13l = b13l ^ ~b14l & b10l;
- a13h = b13h ^ ~b14h & b10h;
- a14l = b14l ^ ~b10l & b11l;
- a14h = b14h ^ ~b10h & b11h;
- a15l = b15l ^ ~b16l & b17l;
- a15h = b15h ^ ~b16h & b17h;
- a16l = b16l ^ ~b17l & b18l;
- a16h = b16h ^ ~b17h & b18h;
- a17l = b17l ^ ~b18l & b19l;
- a17h = b17h ^ ~b18h & b19h;
- a18l = b18l ^ ~b19l & b15l;
- a18h = b18h ^ ~b19h & b15h;
- a19l = b19l ^ ~b15l & b16l;
- a19h = b19h ^ ~b15h & b16h;
- a20l = b20l ^ ~b21l & b22l;
- a20h = b20h ^ ~b21h & b22h;
- a21l = b21l ^ ~b22l & b23l;
- a21h = b21h ^ ~b22h & b23h;
- a22l = b22l ^ ~b23l & b24l;
- a22h = b22h ^ ~b23h & b24h;
- a23l = b23l ^ ~b24l & b20l;
- a23h = b23h ^ ~b24h & b20h;
- a24l = b24l ^ ~b20l & b21l;
- a24h = b24h ^ ~b20h & b21h;
-
- // Iota
- a00l ^= Keccak_f1600_RC[r|0];
- a00h ^= Keccak_f1600_RC[r|1];
- }
-
- // todo, handle big-endian stores
- outState[outOffset|0] = a00l;
- outState[outOffset|1] = a00h;
- outState[outOffset|2] = a01l;
- outState[outOffset|3] = a01h;
- outState[outOffset|4] = a02l;
- outState[outOffset|5] = a02h;
- outState[outOffset|6] = a03l;
- outState[outOffset|7] = a03h;
- if (outSize == 8)
- return;
- outState[outOffset|8] = a04l;
- outState[outOffset|9] = a04h;
- outState[outOffset|10] = a05l;
- outState[outOffset|11] = a05h;
- outState[outOffset|12] = a06l;
- outState[outOffset|13] = a06h;
- outState[outOffset|14] = a07l;
- outState[outOffset|15] = a07h;
- if (outSize == 16)
- return;
- outState[outOffset|16] = a08l;
- outState[outOffset|17] = a08h;
- outState[outOffset|18] = a09l;
- outState[outOffset|19] = a09h;
- outState[outOffset|20] = a10l;
- outState[outOffset|21] = a10h;
- outState[outOffset|22] = a11l;
- outState[outOffset|23] = a11h;
- outState[outOffset|24] = a12l;
- outState[outOffset|25] = a12h;
- outState[outOffset|26] = a13l;
- outState[outOffset|27] = a13h;
- outState[outOffset|28] = a14l;
- outState[outOffset|29] = a14h;
- outState[outOffset|30] = a15l;
- outState[outOffset|31] = a15h;
- outState[outOffset|32] = a16l;
- outState[outOffset|33] = a16h;
- outState[outOffset|34] = a17l;
- outState[outOffset|35] = a17h;
- outState[outOffset|36] = a18l;
- outState[outOffset|37] = a18h;
- outState[outOffset|38] = a19l;
- outState[outOffset|39] = a19h;
- outState[outOffset|40] = a20l;
- outState[outOffset|41] = a20h;
- outState[outOffset|42] = a21l;
- outState[outOffset|43] = a21h;
- outState[outOffset|44] = a22l;
- outState[outOffset|45] = a22h;
- outState[outOffset|46] = a23l;
- outState[outOffset|47] = a23h;
- outState[outOffset|48] = a24l;
- outState[outOffset|49] = a24h;
-}
-
-var Keccak = function()
-{
- var stateBuf = new ArrayBuffer(200);
- var stateBytes = new Uint8Array(stateBuf);
- var stateWords = new Uint32Array(stateBuf);
-
- this.digest = function(oSize, iBytes)
- {
- for (var i = 0; i < 50; ++i)
- {
- stateWords[i] = 0;
- }
-
- var r = 200 - oSize*2;
- var iLength = iBytes.length;
- var iOffset = 0;
- for ( ; ;)
- {
- var len = iLength < r ? iLength : r;
- for (i = 0; i < len; ++i, ++iOffset)
- {
- stateBytes[i] ^= iBytes[iOffset];
- }
-
- if (iLength < r)
- break;
- iLength -= len;
-
- keccak_f1600(stateWords, 0, 50, stateWords);
- }
-
- stateBytes[iLength] ^= 1;
- stateBytes[r-1] ^= 0x80;
- keccak_f1600(stateWords, 0, 50, stateWords);
- return stateBytes.subarray(0, oSize);
- };
-
- this.digestWords = function(oWords, oOffset, oLength, iWords, iOffset, iLength)
- {
- for (var i = 0; i < 50; ++i)
- {
- stateWords[i] = 0;
- }
-
- var r = 50 - oLength*2;
- for (; ; )
- {
- var len = iLength < r ? iLength : r;
- for (i = 0; i < len; ++i, ++iOffset)
- {
- stateWords[i] ^= iWords[iOffset];
- }
-
- if (iLength < r)
- break;
- iLength -= len;
-
- keccak_f1600(stateWords, 0, 50, stateWords);
- }
-
- stateBytes[iLength<<2] ^= 1;
- stateBytes[(r<<2) - 1] ^= 0x80;
- keccak_f1600(oWords, oOffset, oLength, stateWords);
- };
-};
-
-module.exports = Keccak;
-
-
diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/js/makekeccak.js b/Godeps/_workspace/src/github.com/ethereum/ethash/js/makekeccak.js
deleted file mode 100644
index c4db2b80a..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/js/makekeccak.js
+++ /dev/null
@@ -1,201 +0,0 @@
-#!/usr/bin/env node
-// makekeccak.js
-// Tim Hughes <tim@twistedfury.com>
-
-/*jslint node: true, shadow:true */
-"use strict";
-
-var Keccak_f1600_Rho = [
- 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 2, 14,
- 27, 41, 56, 8, 25, 43, 62, 18, 39, 61, 20, 44
-];
-
-var Keccak_f1600_Pi= [
- 10, 7, 11, 17, 18, 3, 5, 16, 8, 21, 24, 4,
- 15, 23, 19, 13, 12, 2, 20, 14, 22, 9, 6, 1
-];
-
-var Keccak_f1600_RC = [
- 0x00000001, 0x00000000,
- 0x00008082, 0x00000000,
- 0x0000808a, 0x80000000,
- 0x80008000, 0x80000000,
- 0x0000808b, 0x00000000,
- 0x80000001, 0x00000000,
- 0x80008081, 0x80000000,
- 0x00008009, 0x80000000,
- 0x0000008a, 0x00000000,
- 0x00000088, 0x00000000,
- 0x80008009, 0x00000000,
- 0x8000000a, 0x00000000,
- 0x8000808b, 0x00000000,
- 0x0000008b, 0x80000000,
- 0x00008089, 0x80000000,
- 0x00008003, 0x80000000,
- 0x00008002, 0x80000000,
- 0x00000080, 0x80000000,
- 0x0000800a, 0x00000000,
- 0x8000000a, 0x80000000,
- 0x80008081, 0x80000000,
- 0x00008080, 0x80000000,
- 0x80000001, 0x00000000,
- 0x80008008, 0x80000000,
-];
-
-function makeRotLow(lo, hi, n)
-{
- if (n === 0 || n === 32) throw Error("unsupported");
- if ((n & 0x20) !== 0)
- {
- n &= ~0x20;
- var t = hi;
- hi = lo;
- lo = t;
- }
- var hir = hi + " >>> " + (32 - n);
- var los = lo + " << " + n;
- return los + " | " + hir;
-}
-
-function makeRotHigh(lo, hi, n)
-{
- if (n === 0 || n === 32) throw Error("unsupported");
- if ((n & 0x20) !== 0)
- {
- n &= ~0x20;
- var t = hi;
- hi = lo;
- lo = t;
- }
- var his = hi + " << " + n;
- var lor = lo + " >>> " + (32 - n);
- return his + " | " + lor;
-}
-
-function makeKeccak_f1600()
-{
- var format = function(n)
- {
- return n < 10 ? "0"+n : ""+n;
- };
-
- var a = function(n, w)
- {
- return "a" + format(n) + (w !== 0?'h':'l');
- };
-
- var b = function(n, w)
- {
- return "b" + format(n) + (w !== 0?'h':'l');
- };
-
- var str = "";
- str += "function keccak_f1600(outState, outOffset, outSize, inState)\n";
- str += "{\n";
-
- for (var i = 0; i < 25; ++i)
- {
- for (var w = 0; w <= 1; ++w)
- {
- str += "\tvar " + a(i,w) + " = inState["+(i<<1|w)+"]|0;\n";
- }
- }
-
- for (var j = 0; j < 5; ++j)
- {
- str += "\tvar ";
- for (var i = 0; i < 5; ++i)
- {
- if (i !== 0)
- str += ", ";
- str += b(j*5+i,0) + ", " + b(j*5+i,1);
- }
- str += ";\n";
- }
-
- str += "\tvar tl, th;\n";
- str += "\n";
- str += "\tfor (var r = 0; r < 48; r = (r+2)|0)\n";
- str += "\t{\n";
-
-
- // Theta
- str += "\t\t// Theta\n";
- for (var i = 0; i < 5; ++i)
- {
- for (var w = 0; w <= 1; ++w)
- {
- str += "\t\t" + b(i,w) + " = " + a(i,w) + " ^ " + a(i+5,w) + " ^ " + a(i+10,w) + " ^ " + a(i+15,w) + " ^ " + a(i+20,w) + ";\n";
- }
- }
-
- for (var i = 0; i < 5; ++i)
- {
- var i4 = (i + 4) % 5;
- var i1 = (i + 1) % 5;
- str += "\t\ttl = " + b(i4,0) + " ^ (" + b(i1,0) + " << 1 | " + b(i1,1) + " >>> 31);\n";
- str += "\t\tth = " + b(i4,1) + " ^ (" + b(i1,1) + " << 1 | " + b(i1,0) + " >>> 31);\n";
-
- for (var j = 0; j < 25; j = (j+5)|0)
- {
- str += "\t\t" + a((j+i),0) + " ^= tl;\n";
- str += "\t\t" + a((j+i),1) + " ^= th;\n";
- }
- }
-
-
- // Rho Pi
- str += "\n\t\t// Rho Pi\n";
- for (var w = 0; w <= 1; ++w)
- {
- str += "\t\t" + b(0,w) + " = " + a(0,w) + ";\n";
- }
- var opi = 1;
- for (var i = 0; i < 24; ++i)
- {
- var pi = Keccak_f1600_Pi[i];
- str += "\t\t" + b(pi,0) + " = " + makeRotLow(a(opi,0), a(opi,1), Keccak_f1600_Rho[i]) + ";\n";
- str += "\t\t" + b(pi,1) + " = " + makeRotHigh(a(opi,0), a(opi,1), Keccak_f1600_Rho[i]) + ";\n";
- opi = pi;
- }
-
- // Chi
- str += "\n\t\t// Chi\n";
- for (var j = 0; j < 25; j += 5)
- {
- for (var i = 0; i < 5; ++i)
- {
- for (var w = 0; w <= 1; ++w)
- {
- str += "\t\t" + a(j+i,w) + " = " + b(j+i,w) + " ^ ~" + b(j+(i+1)%5,w) + " & " + b(j+(i+2)%5,w) + ";\n";
- }
- }
- }
-
- // Iota
- str += "\n\t\t// Iota\n";
- for (var w = 0; w <= 1; ++w)
- {
- str += "\t\t" + a(0,w) + " ^= Keccak_f1600_RC[r|" + w + "];\n";
- }
-
-
- str += "\t}\n";
-
- for (var i = 0; i < 25; ++i)
- {
- if (i == 4 || i == 8)
- {
- str += "\tif (outSize == " + i*2 + ")\n\t\treturn;\n";
- }
- for (var w = 0; w <= 1; ++w)
- {
- str += "\toutState[outOffset|"+(i<<1|w)+"] = " + a(i,w) + ";\n";
- }
- }
- str += "}\n";
-
- return str;
-}
-
-console.log(makeKeccak_f1600());
diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/js/test.js b/Godeps/_workspace/src/github.com/ethereum/ethash/js/test.js
deleted file mode 100644
index 7ebb733ff..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/js/test.js
+++ /dev/null
@@ -1,53 +0,0 @@
-// test.js
-// Tim Hughes <tim@twistedfury.com>
-
-/*jslint node: true, shadow:true */
-"use strict";
-
-var ethash = require('./ethash');
-var util = require('./util');
-var Keccak = require('./keccak');
-
-// sanity check hash functions
-var src = util.stringToBytes("");
-if (util.bytesToHexString(new Keccak().digest(32, src)) != "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470") throw Error("Keccak-256 failed");
-if (util.bytesToHexString(new Keccak().digest(64, src)) != "0eab42de4c3ceb9235fc91acffe746b29c29a8c366b7c60e4e67c466f36a4304c00fa9caf9d87976ba469bcbe06713b435f091ef2769fb160cdab33d3670680e") throw Error("Keccak-512 failed");
-
-src = new Uint32Array(src.buffer);
-var dst = new Uint32Array(8);
-new Keccak().digestWords(dst, 0, dst.length, src, 0, src.length);
-if (util.wordsToHexString(dst) != "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470") throw Error("Keccak-256 Fast failed");
-
-var dst = new Uint32Array(16);
-new Keccak().digestWords(dst, 0, dst.length, src, 0, src.length);
-if (util.wordsToHexString(dst) != "0eab42de4c3ceb9235fc91acffe746b29c29a8c366b7c60e4e67c466f36a4304c00fa9caf9d87976ba469bcbe06713b435f091ef2769fb160cdab33d3670680e") throw Error("Keccak-512 Fast failed");
-
-
-// init params
-var ethashParams = ethash.defaultParams();
-//ethashParams.cacheRounds = 0;
-
-// create hasher
-var seed = util.hexStringToBytes("9410b944535a83d9adf6bbdcc80e051f30676173c16ca0d32d6f1263fc246466")
-var startTime = new Date().getTime();
-var hasher = new ethash.Ethash(ethashParams, seed);
-console.log('Ethash startup took: '+(new Date().getTime() - startTime) + "ms");
-console.log('Ethash cache hash: ' + util.bytesToHexString(hasher.cacheDigest()));
-
-var testHexString = "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470";
-if (testHexString != util.bytesToHexString(util.hexStringToBytes(testHexString)))
- throw Error("bytesToHexString or hexStringToBytes broken");
-
-
-var header = util.hexStringToBytes("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470");
-var nonce = util.hexStringToBytes("0000000000000000");
-var hash;
-
-startTime = new Date().getTime();
-var trials = 10;
-for (var i = 0; i < trials; ++i)
-{
- hash = hasher.hash(header, nonce);
-}
-console.log("Light client hashes averaged: " + (new Date().getTime() - startTime)/trials + "ms");
-console.log("Hash = " + util.bytesToHexString(hash));
diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/js/util.js b/Godeps/_workspace/src/github.com/ethereum/ethash/js/util.js
deleted file mode 100644
index 79743cd91..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/js/util.js
+++ /dev/null
@@ -1,100 +0,0 @@
-// util.js
-// Tim Hughes <tim@twistedfury.com>
-
-/*jslint node: true, shadow:true */
-"use strict";
-
-function nibbleToChar(nibble)
-{
- return String.fromCharCode((nibble < 10 ? 48 : 87) + nibble);
-}
-
-function charToNibble(chr)
-{
- if (chr >= 48 && chr <= 57)
- {
- return chr - 48;
- }
- if (chr >= 65 && chr <= 70)
- {
- return chr - 65 + 10;
- }
- if (chr >= 97 && chr <= 102)
- {
- return chr - 97 + 10;
- }
- return 0;
-}
-
-function stringToBytes(str)
-{
- var bytes = new Uint8Array(str.length);
- for (var i = 0; i != str.length; ++i)
- {
- bytes[i] = str.charCodeAt(i);
- }
- return bytes;
-}
-
-function hexStringToBytes(str)
-{
- var bytes = new Uint8Array(str.length>>>1);
- for (var i = 0; i != bytes.length; ++i)
- {
- bytes[i] = charToNibble(str.charCodeAt(i<<1 | 0)) << 4;
- bytes[i] |= charToNibble(str.charCodeAt(i<<1 | 1));
- }
- return bytes;
-}
-
-function bytesToHexString(bytes)
-{
- var str = "";
- for (var i = 0; i != bytes.length; ++i)
- {
- str += nibbleToChar(bytes[i] >>> 4);
- str += nibbleToChar(bytes[i] & 0xf);
- }
- return str;
-}
-
-function wordsToHexString(words)
-{
- return bytesToHexString(new Uint8Array(words.buffer));
-}
-
-function uint32ToHexString(num)
-{
- var buf = new Uint8Array(4);
- buf[0] = (num >> 24) & 0xff;
- buf[1] = (num >> 16) & 0xff;
- buf[2] = (num >> 8) & 0xff;
- buf[3] = (num >> 0) & 0xff;
- return bytesToHexString(buf);
-}
-
-function toWords(input)
-{
- if (input instanceof Uint32Array)
- {
- return input;
- }
- else if (input instanceof Uint8Array)
- {
- var tmp = new Uint8Array((input.length + 3) & ~3);
- tmp.set(input);
- return new Uint32Array(tmp.buffer);
- }
- else if (typeof input === typeof "")
- {
- return toWords(stringToBytes(input));
- }
- return null;
-}
-
-exports.stringToBytes = stringToBytes;
-exports.hexStringToBytes = hexStringToBytes;
-exports.bytesToHexString = bytesToHexString;
-exports.wordsToHexString = wordsToHexString;
-exports.uint32ToHexString = uint32ToHexString;
-exports.toWords = toWords;
\ No newline at end of file
diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/src/benchmark/CMakeLists.txt b/Godeps/_workspace/src/github.com/ethereum/ethash/src/benchmark/CMakeLists.txt
deleted file mode 100644
index 3df4ab596..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/src/benchmark/CMakeLists.txt
+++ /dev/null
@@ -1,58 +0,0 @@
-include_directories(..)
-
-set(CMAKE_BUILD_TYPE Release)
-
-if (MSVC)
- add_definitions("/openmp")
-endif()
-
-# enable C++11, should probably be a bit more specific about compiler
-if (NOT MSVC)
- SET(CMAKE_CXX_FLAGS "-std=c++11")
-endif()
-
-if (NOT MPI_FOUND)
- find_package(MPI)
-endif()
-
-if (NOT CRYPTOPP_FOUND)
- find_package(CryptoPP 5.6.2)
-endif()
-
-if (CRYPTOPP_FOUND)
- add_definitions(-DWITH_CRYPTOPP)
- find_package (Threads REQUIRED)
-endif()
-
-if (NOT OpenCL_FOUND)
- find_package(OpenCL)
-endif()
-if (OpenCL_FOUND)
- add_definitions(-DWITH_OPENCL)
- include_directories(${OpenCL_INCLUDE_DIRS})
- list(APPEND FILES ethash_cl_miner.cpp ethash_cl_miner.h)
-endif()
-
-if (MPI_FOUND)
- include_directories(${MPI_INCLUDE_PATH})
- add_executable (Benchmark_MPI_FULL benchmark.cpp)
- target_link_libraries (Benchmark_MPI_FULL ${ETHHASH_LIBS} ${MPI_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
- SET_TARGET_PROPERTIES(Benchmark_MPI_FULL PROPERTIES COMPILE_FLAGS "${COMPILE_FLAGS} ${MPI_COMPILE_FLAGS} -DFULL -DMPI")
-
- add_executable (Benchmark_MPI_LIGHT benchmark.cpp)
- target_link_libraries (Benchmark_MPI_LIGHT ${ETHHASH_LIBS} ${MPI_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
- SET_TARGET_PROPERTIES(Benchmark_MPI_LIGHT PROPERTIES COMPILE_FLAGS "${COMPILE_FLAGS} ${MPI_COMPILE_FLAGS} -DMPI")
-endif()
-
-add_executable (Benchmark_FULL benchmark.cpp)
-target_link_libraries (Benchmark_FULL ${ETHHASH_LIBS} ${CMAKE_THREAD_LIBS_INIT})
-SET_TARGET_PROPERTIES(Benchmark_FULL PROPERTIES COMPILE_FLAGS "${COMPILE_FLAGS} -DFULL")
-
-add_executable (Benchmark_LIGHT benchmark.cpp)
-target_link_libraries (Benchmark_LIGHT ${ETHHASH_LIBS} ${CMAKE_THREAD_LIBS_INIT})
-
-if (OpenCL_FOUND)
- add_executable (Benchmark_CL benchmark.cpp)
- target_link_libraries (Benchmark_CL ${ETHHASH_LIBS} ethash-cl ${CMAKE_THREAD_LIBS_INIT})
- SET_TARGET_PROPERTIES(Benchmark_CL PROPERTIES COMPILE_FLAGS "${COMPILE_FLAGS} -DOPENCL")
-endif()
\ No newline at end of file
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
deleted file mode 100644
index 1a648edf4..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/src/benchmark/benchmark.cpp
+++ /dev/null
@@ -1,278 +0,0 @@
-/*
- This file is part of cpp-ethereum.
-
- cpp-ethereum 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,
- 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 <http://www.gnu.org/licenses/>.
-*/
-/** @file benchmark.cpp
- * @author Tim Hughes <tim@twistedfury.com>
- * @date 2015
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <chrono>
-#include <libethash/ethash.h>
-#include <libethash/util.h>
-#ifdef OPENCL
-#include <libethash-cl/ethash_cl_miner.h>
-#endif
-#include <vector>
-#include <algorithm>
-
-#ifdef WITH_CRYPTOPP
-#include <libethash/sha3_cryptopp.h>
-#include <string>
-
-#else
-#include "libethash/sha3.h"
-#endif // WITH_CRYPTOPP
-
-#undef min
-#undef max
-
-using std::chrono::high_resolution_clock;
-
-#if defined(OPENCL)
-const unsigned trials = 1024*1024*32;
-#elif defined(FULL)
-const unsigned trials = 1024*1024/8;
-#else
-const unsigned trials = 1024*1024/1024;
-#endif
-uint8_t g_hashes[1024*32];
-
-static char nibbleToChar(unsigned nibble)
-{
- return (char) ((nibble >= 10 ? 'a'-10 : '0') + nibble);
-}
-
-static uint8_t charToNibble(char chr)
-{
- if (chr >= '0' && chr <= '9')
- {
- return (uint8_t) (chr - '0');
- }
- if (chr >= 'a' && chr <= 'z')
- {
- return (uint8_t) (chr - 'a' + 10);
- }
- if (chr >= 'A' && chr <= 'Z')
- {
- return (uint8_t) (chr - 'A' + 10);
- }
- return 0;
-}
-
-static std::vector<uint8_t> hexStringToBytes(char const* str)
-{
- std::vector<uint8_t> bytes(strlen(str) >> 1);
- for (unsigned i = 0; i != bytes.size(); ++i)
- {
- bytes[i] = charToNibble(str[i*2 | 0]) << 4;
- bytes[i] |= charToNibble(str[i*2 | 1]);
- }
- return bytes;
-}
-
-static std::string bytesToHexString(uint8_t const* bytes, unsigned size)
-{
- std::string str;
- for (unsigned i = 0; i != size; ++i)
- {
- str += nibbleToChar(bytes[i] >> 4);
- str += nibbleToChar(bytes[i] & 0xf);
- }
- return str;
-}
-
-static std::string bytesToHexString(ethash_h256_t const *hash, unsigned size)
-{
- return bytesToHexString((uint8_t*)hash, size);
-}
-
-extern "C" int main(void)
-{
- // params for ethash
- ethash_params params;
- ethash_params_init(¶ms, 0);
- //params.full_size = 262147 * 4096; // 1GBish;
- //params.full_size = 32771 * 4096; // 128MBish;
- //params.full_size = 8209 * 4096; // 8MBish;
- //params.cache_size = 8209*4096;
- //params.cache_size = 2053*4096;
- ethash_h256_t seed;
- ethash_h256_t previous_hash;
-
- memcpy(&seed, hexStringToBytes("9410b944535a83d9adf6bbdcc80e051f30676173c16ca0d32d6f1263fc246466").data(), 32);
- memcpy(&previous_hash, hexStringToBytes("c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470").data(), 32);
-
- // allocate page aligned buffer for dataset
-#ifdef FULL
- void* full_mem_buf = malloc(params.full_size + 4095);
- void* full_mem = (void*)((uintptr_t(full_mem_buf) + 4095) & ~4095);
-#endif
- void* cache_mem_buf = malloc(params.cache_size + 63);
- void* cache_mem = (void*)((uintptr_t(cache_mem_buf) + 63) & ~63);
-
- ethash_cache cache;
- cache.mem = cache_mem;
-
- // compute cache or full data
- {
- auto startTime = high_resolution_clock::now();
- ethash_mkcache(&cache, ¶ms, &seed);
- auto time = std::chrono::duration_cast<std::chrono::milliseconds>(high_resolution_clock::now() - startTime).count();
-
- ethash_h256_t cache_hash;
- SHA3_256(&cache_hash, (uint8_t const*)cache_mem, params.cache_size);
- debugf("ethash_mkcache: %ums, sha3: %s\n", (unsigned)((time*1000)/CLOCKS_PER_SEC), bytesToHexString(&cache_hash, sizeof(cache_hash)).data());
-
- // print a couple of test hashes
- {
- auto startTime = high_resolution_clock::now();
- ethash_return_value hash;
- ethash_light(&hash, &cache, ¶ms, &previous_hash, 0);
- auto time = std::chrono::duration_cast<std::chrono::milliseconds>(high_resolution_clock::now() - startTime).count();
- debugf("ethash_light test: %ums, %s\n", (unsigned)time, bytesToHexString(&hash.result, 32).data());
- }
-
- #ifdef FULL
- startTime = high_resolution_clock::now();
- ethash_compute_full_data(full_mem, ¶ms, &cache);
- time = std::chrono::duration_cast<std::chrono::milliseconds>(high_resolution_clock::now() - startTime).count();
- debugf("ethash_compute_full_data: %ums\n", (unsigned)time);
- #endif // FULL
- }
-
-#ifdef OPENCL
- ethash_cl_miner miner;
- {
- auto startTime = high_resolution_clock::now();
- if (!miner.init(params, &seed))
- exit(-1);
- auto time = std::chrono::duration_cast<std::chrono::milliseconds>(high_resolution_clock::now() - startTime).count();
- debugf("ethash_cl_miner init: %ums\n", (unsigned)time);
- }
-#endif
-
-
-#ifdef FULL
- {
- auto startTime = high_resolution_clock::now();
- ethash_return_value hash;
- ethash_full(&hash, full_mem, ¶ms, &previous_hash, 0);
- auto time = std::chrono::duration_cast<std::chrono::milliseconds>(high_resolution_clock::now() - startTime).count();
- debugf("ethash_full test: %uns\n", (unsigned)time);
- }
-#endif
-
-#ifdef OPENCL
- // validate 1024 hashes against CPU
- miner.hash(g_hashes, (uint8_t*)&previous_hash, 0, 1024);
- for (unsigned i = 0; i != 1024; ++i)
- {
- ethash_return_value hash;
- ethash_light(&hash, &cache, ¶ms, &previous_hash, i);
- if (memcmp(&hash.result, g_hashes + 32*i, 32) != 0)
- {
- debugf("nonce %u failed: %s %s\n", i, bytesToHexString(g_hashes + 32*i, 32).c_str(), bytesToHexString(&hash.result, 32).c_str());
- static unsigned c = 0;
- if (++c == 16)
- {
- exit(-1);
- }
- }
- }
-
- // ensure nothing else is going on
- miner.finish();
-#endif
-
- auto startTime = high_resolution_clock::now();
- unsigned hash_count = trials;
-
- #ifdef OPENCL
- {
- struct search_hook : ethash_cl_miner::search_hook
- {
- unsigned hash_count;
- std::vector<uint64_t> nonce_vec;
-
- virtual bool found(uint64_t const* nonces, uint32_t count)
- {
- nonce_vec.insert(nonce_vec.end(), nonces, nonces + count);
- return false;
- }
-
- virtual bool searched(uint64_t start_nonce, uint32_t count)
- {
- // do nothing
- hash_count += count;
- return hash_count >= trials;
- }
- };
- search_hook hook;
- hook.hash_count = 0;
-
- miner.search((uint8_t*)&previous_hash, 0x000000ffffffffff, hook);
-
- for (unsigned i = 0; i != hook.nonce_vec.size(); ++i)
- {
- uint64_t nonce = hook.nonce_vec[i];
- ethash_return_value hash;
- ethash_light(&hash, &cache, ¶ms, &previous_hash, nonce);
- debugf("found: %.8x%.8x -> %s\n", unsigned(nonce>>32), unsigned(nonce), bytesToHexString(&hash.result, 32).c_str());
- }
-
- hash_count = hook.hash_count;
- }
- #else
- {
- //#pragma omp parallel for
- for (int nonce = 0; nonce < trials; ++nonce)
- {
- ethash_return_value hash;
- #ifdef FULL
- ethash_full(&hash, full_mem, ¶ms, &previous_hash, nonce);
- #else
- ethash_light(&hash, &cache, ¶ms, &previous_hash, nonce);
- #endif // FULL
- }
- }
- #endif
- auto time = std::chrono::duration_cast<std::chrono::microseconds>(high_resolution_clock::now() - startTime).count();
- debugf("Search took: %ums\n", (unsigned)time/1000);
-
- unsigned read_size = ETHASH_ACCESSES * ETHASH_MIX_BYTES;
-#if defined(OPENCL) || defined(FULL)
- debugf(
- "hashrate: %8.2f Mh/s, bw: %8.2f GB/s\n",
- (double)hash_count * (1000*1000)/time / (1000*1000),
- (double)hash_count*read_size * (1000*1000)/time / (1024*1024*1024)
- );
-#else
- debugf(
- "hashrate: %8.2f Kh/s, bw: %8.2f MB/s\n",
- (double)hash_count * (1000*1000)/time / (1000),
- (double)hash_count*read_size * (1000*1000)/time / (1024*1024)
- );
-#endif
-
- free(cache_mem_buf);
-#ifdef FULL
- free(full_mem_buf);
-#endif
-
- return 0;
-}
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
deleted file mode 100644
index c66e03c54..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/src/python/core.c
+++ /dev/null
@@ -1,267 +0,0 @@
-#include <Python.h>
-#include <alloca.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <time.h>
-#include "../libethash/ethash.h"
-#include "../libethash/internal.h"
-
-#if PY_MAJOR_VERSION >= 3
-#define PY_STRING_FORMAT "y#"
-#define PY_CONST_STRING_FORMAT "y"
-#else
-#define PY_STRING_FORMAT "s#"
-#define PY_CONST_STRING_FORMAT "s"
-#endif
-
-#define MIX_WORDS (ETHASH_MIX_BYTES/4)
-
-static PyObject *
-mkcache_bytes(PyObject *self, PyObject *args) {
- unsigned long block_number;
- unsigned long cache_size;
-
- if (!PyArg_ParseTuple(args, "k", &block_number))
- return 0;
-
- ethash_light_t L = ethash_light_new(block_number);
- PyObject * val = Py_BuildValue(PY_STRING_FORMAT, L->cache, L->cache_size);
- free(L->cache);
- 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, "k" PY_STRING_FORMAT, &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 % ETHASH_HASH_BYTES != 0) {
- char error_message[1024];
- sprintf(error_message, "The size of the cache must be a multiple of %i bytes (was %i)", ETHASH_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(PY_STRING_FORMAT, (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;
- char *header;
- unsigned long block_number;
- unsigned long long nonce;
- int cache_size, header_size;
- if (!PyArg_ParseTuple(args, "k" PY_STRING_FORMAT PY_STRING_FORMAT "K", &block_number, &cache_bytes, &cache_size, &header, &header_size, &nonce))
- 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;
- }
- struct ethash_light *s;
- s = calloc(sizeof(*s), 1);
- s->cache = cache_bytes;
- s->cache_size = cache_size;
- s->block_number = block_number;
- struct ethash_h256 *h;
- h = calloc(sizeof(*h), 1);
- for (int i = 0; i < 32; i++) h->b[i] = header[i];
- struct ethash_return_value out = ethash_light_compute(s, *h, nonce);
- return Py_BuildValue("{" PY_CONST_STRING_FORMAT ":" PY_STRING_FORMAT "," PY_CONST_STRING_FORMAT ":" PY_STRING_FORMAT "}",
- "mix digest", &out.mix_hash, 32,
- "result", &out.result, 32);
-}
-/*
-// hashimoto_full(dataset, header, nonce)
-static PyObject *
-hashimoto_full(PyObject *self, PyObject *args) {
- char *full_bytes;
- char *header;
- unsigned long long nonce;
- int full_size, header_size;
-
- if (!PyArg_ParseTuple(args, PY_STRING_FORMAT PY_STRING_FORMAT "K", &full_bytes, &full_size, &header, &header_size, &nonce))
- return 0;
-
- if (full_size % MIX_WORDS != 0) {
- 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, (ethash_h256_t *) header, nonce);
- return Py_BuildValue("{" PY_CONST_STRING_FORMAT ":" PY_STRING_FORMAT ", " PY_CONST_STRING_FORMAT ":" PY_STRING_FORMAT "}",
- "mix digest", &out.mix_hash, 32,
- "result", &out.result, 32);
-}
-
-// mine(dataset_bytes, header, difficulty_bytes)
-static PyObject *
-mine(PyObject *self, PyObject *args) {
- char *full_bytes;
- char *header;
- char *difficulty;
- srand(time(0));
- uint64_t nonce = ((uint64_t) rand()) << 32 | rand();
- int full_size, header_size, difficulty_size;
-
- if (!PyArg_ParseTuple(args, PY_STRING_FORMAT PY_STRING_FORMAT PY_STRING_FORMAT, &full_bytes, &full_size, &header, &header_size, &difficulty, &difficulty_size))
- return 0;
-
- if (full_size % MIX_WORDS != 0) {
- 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 ethash_h256_t *) header, nonce++);
- // TODO: disagrees with the spec https://github.com/ethereum/wiki/wiki/Ethash#mining
- } while (!ethash_check_difficulty(&out.result, (const ethash_h256_t *) difficulty));
-
- return Py_BuildValue("{" PY_CONST_STRING_FORMAT ":" PY_STRING_FORMAT ", " PY_CONST_STRING_FORMAT ":" PY_STRING_FORMAT ", " PY_CONST_STRING_FORMAT ":K}",
- "mix digest", &out.mix_hash, 32,
- "result", &out.result, 32,
- "nonce", nonce);
-}
-*/
-
-//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 >= ETHASH_EPOCH_LENGTH * 2048) {
- char error_message[1024];
- sprintf(error_message, "Block number must be less than %i (was %lu)", ETHASH_EPOCH_LENGTH * 2048, block_number);
-
- PyErr_SetString(PyExc_ValueError, error_message);
- return 0;
- }
- ethash_h256_t seedhash = ethash_get_seedhash(block_number);
- return Py_BuildValue(PY_STRING_FORMAT, (char *) &seedhash, 32);
-}
-
-static PyMethodDef PyethashMethods[] =
- {
- {"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(block_number)\n\n"
- "Makes a byte array for the cache for given block number\n"},
- /*{"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(block_number, 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}
- };
-
-#if PY_MAJOR_VERSION >= 3
-static struct PyModuleDef PyethashModule = {
- PyModuleDef_HEAD_INIT,
- "pyethash",
- "...",
- -1,
- PyethashMethods
-};
-
-PyMODINIT_FUNC PyInit_pyethash(void) {
- PyObject *module = PyModule_Create(&PyethashModule);
- // Following Spec: https://github.com/ethereum/wiki/wiki/Ethash#definitions
- PyModule_AddIntConstant(module, "REVISION", (long) ETHASH_REVISION);
- PyModule_AddIntConstant(module, "DATASET_BYTES_INIT", (long) ETHASH_DATASET_BYTES_INIT);
- PyModule_AddIntConstant(module, "DATASET_BYTES_GROWTH", (long) ETHASH_DATASET_BYTES_GROWTH);
- PyModule_AddIntConstant(module, "CACHE_BYTES_INIT", (long) ETHASH_CACHE_BYTES_INIT);
- PyModule_AddIntConstant(module, "CACHE_BYTES_GROWTH", (long) ETHASH_CACHE_BYTES_GROWTH);
- PyModule_AddIntConstant(module, "EPOCH_LENGTH", (long) ETHASH_EPOCH_LENGTH);
- PyModule_AddIntConstant(module, "MIX_BYTES", (long) ETHASH_MIX_BYTES);
- PyModule_AddIntConstant(module, "HASH_BYTES", (long) ETHASH_HASH_BYTES);
- PyModule_AddIntConstant(module, "DATASET_PARENTS", (long) ETHASH_DATASET_PARENTS);
- PyModule_AddIntConstant(module, "CACHE_ROUNDS", (long) ETHASH_CACHE_ROUNDS);
- PyModule_AddIntConstant(module, "ACCESSES", (long) ETHASH_ACCESSES);
- return module;
-}
-#else
-PyMODINIT_FUNC
-initpyethash(void) {
- PyObject *module = Py_InitModule("pyethash", PyethashMethods);
- // Following Spec: https://github.com/ethereum/wiki/wiki/Ethash#definitions
- PyModule_AddIntConstant(module, "REVISION", (long) ETHASH_REVISION);
- PyModule_AddIntConstant(module, "DATASET_BYTES_INIT", (long) ETHASH_DATASET_BYTES_INIT);
- PyModule_AddIntConstant(module, "DATASET_BYTES_GROWTH", (long) ETHASH_DATASET_BYTES_GROWTH);
- PyModule_AddIntConstant(module, "CACHE_BYTES_INIT", (long) ETHASH_CACHE_BYTES_INIT);
- PyModule_AddIntConstant(module, "CACHE_BYTES_GROWTH", (long) ETHASH_CACHE_BYTES_GROWTH);
- PyModule_AddIntConstant(module, "EPOCH_LENGTH", (long) ETHASH_EPOCH_LENGTH);
- PyModule_AddIntConstant(module, "MIX_BYTES", (long) ETHASH_MIX_BYTES);
- PyModule_AddIntConstant(module, "HASH_BYTES", (long) ETHASH_HASH_BYTES);
- PyModule_AddIntConstant(module, "DATASET_PARENTS", (long) ETHASH_DATASET_PARENTS);
- PyModule_AddIntConstant(module, "CACHE_ROUNDS", (long) ETHASH_CACHE_ROUNDS);
- PyModule_AddIntConstant(module, "ACCESSES", (long) ETHASH_ACCESSES);
-}
-#endif
diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/test/c/CMakeLists.txt b/Godeps/_workspace/src/github.com/ethereum/ethash/test/c/CMakeLists.txt
deleted file mode 100644
index f94531c3d..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/test/c/CMakeLists.txt
+++ /dev/null
@@ -1,66 +0,0 @@
-if (MSVC)
- if (NOT BOOST_ROOT)
- set (BOOST_ROOT "$ENV{BOOST_ROOT}")
- endif()
- set (CMAKE_PREFIX_PATH BOOST_ROOT)
-endif()
-
-IF( NOT Boost_FOUND )
- # use multithreaded boost libraries, with -mt suffix
- set(Boost_USE_MULTITHREADED ON)
-
- if (MSVC)
- # TODO handle other msvc versions or it will fail find them
- set(Boost_COMPILER -vc120)
- # use static boost libraries *.lib
- set(Boost_USE_STATIC_LIBS ON)
- elseif (APPLE)
-
- # use static boost libraries *.a
- set(Boost_USE_STATIC_LIBS ON)
-
- elseif (UNIX)
- # use dynamic boost libraries .dll
- set(Boost_USE_STATIC_LIBS OFF)
-
- endif()
- find_package(Boost 1.48.0 COMPONENTS unit_test_framework system filesystem)
-ENDIF()
-
-IF (Boost_FOUND)
- message(STATUS "boost header: ${Boost_INCLUDE_DIRS}")
- message(STATUS "boost libs : ${Boost_LIBRARIES}")
-
- include_directories( ${Boost_INCLUDE_DIR} )
- include_directories(../../src)
-
- link_directories(${Boost_LIBRARY_DIRS})
- file(GLOB HEADERS "*.h")
- if ((NOT MSVC) AND (NOT APPLE))
- ADD_DEFINITIONS(-DBOOST_TEST_DYN_LINK)
- endif()
- if (NOT CRYPTOPP_FOUND)
- find_package (CryptoPP)
- endif()
-
- if (CRYPTOPP_FOUND)
- add_definitions(-DWITH_CRYPTOPP)
- endif()
-
- if (NOT MSVC)
- set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 ")
- endif()
-
- add_executable (Test "./test.cpp" ${HEADERS})
- target_link_libraries(Test ${ETHHASH_LIBS})
- target_link_libraries(Test ${Boost_FILESYSTEM_LIBRARIES})
- target_link_libraries(Test ${Boost_SYSTEM_LIBRARIES})
- target_link_libraries(Test ${Boost_UNIT_TEST_FRAMEWORK_LIBRARIES})
-
- if (CRYPTOPP_FOUND)
- TARGET_LINK_LIBRARIES(Test ${CRYPTOPP_LIBRARIES})
- endif()
-
- enable_testing ()
- add_test(NAME ethash COMMAND Test)
-ENDIF()
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
deleted file mode 100644
index 44e0c385b..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/test/c/test.cpp
+++ /dev/null
@@ -1,669 +0,0 @@
-#include <iomanip>
-#include <libethash/fnv.h>
-#include <libethash/ethash.h>
-#include <libethash/internal.h>
-#include <libethash/io.h>
-
-#ifdef WITH_CRYPTOPP
-
-#include <libethash/sha3_cryptopp.h>
-
-#else
-#include <libethash/sha3.h>
-#endif // WITH_CRYPTOPP
-
-#ifdef _WIN32
-#include <windows.h>
-#include <Shlobj.h>
-#endif
-
-#define BOOST_TEST_MODULE Daggerhashimoto
-#define BOOST_TEST_MAIN
-
-#include <iostream>
-#include <fstream>
-#include <vector>
-#include <boost/filesystem.hpp>
-#include <boost/test/unit_test.hpp>
-
-using namespace std;
-using byte = uint8_t;
-using bytes = std::vector<byte>;
-namespace fs = boost::filesystem;
-
-// Just an alloca "wrapper" to silence uint64_t to size_t conversion warnings in windows
-// consider replacing alloca calls with something better though!
-#define our_alloca(param__) alloca((size_t)(param__))
-
-
-// some functions taken from eth::dev for convenience.
-std::string bytesToHexString(const uint8_t *str, const uint64_t s)
-{
- std::ostringstream ret;
-
- for (size_t i = 0; i < s; ++i)
- ret << std::hex << std::setfill('0') << std::setw(2) << std::nouppercase << (int) str[i];
-
- return ret.str();
-}
-
-std::string blockhashToHexString(ethash_h256_t* _hash)
-{
- return bytesToHexString((uint8_t*)_hash, 32);
-}
-
-int fromHex(char _i)
-{
- if (_i >= '0' && _i <= '9')
- return _i - '0';
- if (_i >= 'a' && _i <= 'f')
- return _i - 'a' + 10;
- if (_i >= 'A' && _i <= 'F')
- return _i - 'A' + 10;
-
- BOOST_REQUIRE_MESSAGE(false, "should never get here");
- return -1;
-}
-
-bytes hexStringToBytes(std::string const& _s)
-{
- unsigned s = (_s[0] == '0' && _s[1] == 'x') ? 2 : 0;
- std::vector<uint8_t> ret;
- ret.reserve((_s.size() - s + 1) / 2);
-
- if (_s.size() % 2)
- try
- {
- ret.push_back(fromHex(_s[s++]));
- }
- catch (...)
- {
- ret.push_back(0);
- }
- for (unsigned i = s; i < _s.size(); i += 2)
- try
- {
- ret.push_back((byte)(fromHex(_s[i]) * 16 + fromHex(_s[i + 1])));
- }
- catch (...){
- ret.push_back(0);
- }
- return ret;
-}
-
-ethash_h256_t stringToBlockhash(std::string const& _s)
-{
- ethash_h256_t ret;
- bytes b = hexStringToBytes(_s);
- memcpy(&ret, b.data(), b.size());
- return ret;
-}
-
-
-
-BOOST_AUTO_TEST_CASE(fnv_hash_check) {
- uint32_t x = 1235U;
- const uint32_t
- y = 9999999U,
- expected = (FNV_PRIME * x) ^y;
-
- x = fnv_hash(x, y);
-
- BOOST_REQUIRE_MESSAGE(x == expected,
- "\nexpected: " << expected << "\n"
- << "actual: " << x << "\n");
-
-}
-
-BOOST_AUTO_TEST_CASE(SHA256_check) {
- ethash_h256_t input;
- ethash_h256_t out;
- memcpy(&input, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
- SHA3_256(&out, (uint8_t*)&input, 32);
- const std::string
- expected = "2b5ddf6f4d21c23de216f44d5e4bdc68e044b71897837ea74c83908be7037cd7",
- actual = bytesToHexString((uint8_t*)&out, 32);
- BOOST_REQUIRE_MESSAGE(expected == actual,
- "\nexpected: " << expected.c_str() << "\n"
- << "actual: " << actual.c_str() << "\n");
-}
-
-BOOST_AUTO_TEST_CASE(SHA512_check) {
- uint8_t input[64], out[64];
- memcpy(input, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 64);
- SHA3_512(out, input, 64);
- const std::string
- expected = "0be8a1d334b4655fe58c6b38789f984bb13225684e86b20517a55ab2386c7b61c306f25e0627c60064cecd6d80cd67a82b3890bd1289b7ceb473aad56a359405",
- actual = bytesToHexString(out, 64);
- BOOST_REQUIRE_MESSAGE(expected == actual,
- "\nexpected: " << expected.c_str() << "\n"
- << "actual: " << actual.c_str() << "\n");
-}
-
-BOOST_AUTO_TEST_CASE(test_swap_endian32) {
- uint32_t v32 = (uint32_t)0xBAADF00D;
- v32 = ethash_swap_u32(v32);
- BOOST_REQUIRE_EQUAL(v32, (uint32_t)0x0DF0ADBA);
-}
-
-BOOST_AUTO_TEST_CASE(test_swap_endian64) {
- uint64_t v64 = (uint64_t)0xFEE1DEADDEADBEEF;
- v64 = ethash_swap_u64(v64);
- BOOST_REQUIRE_EQUAL(v64, (uint64_t)0xEFBEADDEADDEE1FE);
-}
-
-BOOST_AUTO_TEST_CASE(ethash_params_init_genesis_check) {
- uint64_t full_size = ethash_get_datasize(0);
- uint64_t cache_size = ethash_get_cachesize(0);
- BOOST_REQUIRE_MESSAGE(full_size < ETHASH_DATASET_BYTES_INIT,
- "\nfull size: " << full_size << "\n"
- << "should be less than or equal to: " << ETHASH_DATASET_BYTES_INIT << "\n");
- BOOST_REQUIRE_MESSAGE(full_size + 20 * ETHASH_MIX_BYTES >= ETHASH_DATASET_BYTES_INIT,
- "\nfull size + 20*MIX_BYTES: " << full_size + 20 * ETHASH_MIX_BYTES << "\n"
- << "should be greater than or equal to: " << ETHASH_DATASET_BYTES_INIT << "\n");
- BOOST_REQUIRE_MESSAGE(cache_size < ETHASH_DATASET_BYTES_INIT / 32,
- "\ncache size: " << cache_size << "\n"
- << "should be less than or equal to: " << ETHASH_DATASET_BYTES_INIT / 32 << "\n");
-}
-
-BOOST_AUTO_TEST_CASE(ethash_params_init_genesis_calcifide_check) {
- uint64_t full_size = ethash_get_datasize(0);
- uint64_t cache_size = ethash_get_cachesize(0);
- const uint32_t expected_full_size = 1073739904;
- const uint32_t expected_cache_size = 16776896;
- BOOST_REQUIRE_MESSAGE(full_size == expected_full_size,
- "\nexpected: " << expected_cache_size << "\n"
- << "actual: " << full_size << "\n");
- BOOST_REQUIRE_MESSAGE(cache_size == expected_cache_size,
- "\nexpected: " << expected_cache_size << "\n"
- << "actual: " << cache_size << "\n");
-}
-
-BOOST_AUTO_TEST_CASE(ethash_check_difficulty_check) {
- ethash_h256_t hash;
- ethash_h256_t target;
- memcpy(&hash, "11111111111111111111111111111111", 32);
- memcpy(&target, "22222222222222222222222222222222", 32);
- BOOST_REQUIRE_MESSAGE(
- ethash_check_difficulty(&hash, &target),
- "\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 or less difficulty than \"" << hash << "\"\n");
- memcpy(&target, "11111111111111111111111111111112", 32);
- BOOST_REQUIRE_MESSAGE(
- ethash_check_difficulty(&hash, &target), "");
- // "\nexpected \"" << hash << "\" to have the same or less difficulty than \"" << target << "\"\n");
- memcpy(&target, "11111111111111111111111111111110", 32);
- BOOST_REQUIRE_MESSAGE(
- !ethash_check_difficulty(&hash, &target), "");
- // "\nexpected \"" << hash << "\" to have more difficulty than \"" << target << "\"\n");
-}
-
-BOOST_AUTO_TEST_CASE(test_ethash_io_mutable_name) {
- char mutable_name[DAG_MUTABLE_NAME_MAX_SIZE];
- // should have at least 8 bytes provided since this is what we test :)
- ethash_h256_t seed1 = ethash_h256_static_init(0, 10, 65, 255, 34, 55, 22, 8);
- ethash_io_mutable_name(1, &seed1, mutable_name);
- BOOST_REQUIRE_EQUAL(0, strcmp(mutable_name, "full-R1-000a41ff22371608"));
- ethash_h256_t seed2 = ethash_h256_static_init(0, 0, 0, 0, 0, 0, 0, 0);
- ethash_io_mutable_name(44, &seed2, mutable_name);
- BOOST_REQUIRE_EQUAL(0, strcmp(mutable_name, "full-R44-0000000000000000"));
-}
-
-BOOST_AUTO_TEST_CASE(test_ethash_dir_creation) {
- ethash_h256_t seedhash;
- FILE *f = NULL;
- memset(&seedhash, 0, 32);
- BOOST_REQUIRE_EQUAL(
- ETHASH_IO_MEMO_MISMATCH,
- ethash_io_prepare("./test_ethash_directory/", seedhash, &f, 64, false)
- );
- BOOST_REQUIRE(f);
-
- // let's make sure that the directory was created
- BOOST_REQUIRE(fs::is_directory(fs::path("./test_ethash_directory/")));
-
- // cleanup
- fclose(f);
- fs::remove_all("./test_ethash_directory/");
-}
-
-BOOST_AUTO_TEST_CASE(test_ethash_io_memo_file_match) {
- uint64_t full_size;
- uint64_t cache_size;
- ethash_h256_t seed;
- ethash_h256_t hash;
- FILE* f;
- memcpy(&seed, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
- memcpy(&hash, "~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
-
- cache_size = 1024;
- full_size = 1024 * 32;
-
- ethash_light_t light = ethash_light_new_internal(cache_size, &seed);
- ethash_full_t full = ethash_full_new_internal(
- "./test_ethash_directory/",
- seed,
- full_size,
- light,
- NULL
- );
- BOOST_ASSERT(full);
- // let's make sure that the directory was created
- BOOST_REQUIRE(fs::is_directory(fs::path("./test_ethash_directory/")));
- // delete the full here so that memory is properly unmapped and FILE handler freed
- ethash_full_delete(full);
- // and check that we have a match when checking again
- BOOST_REQUIRE_EQUAL(
- ETHASH_IO_MEMO_MATCH,
- ethash_io_prepare("./test_ethash_directory/", seed, &f, full_size, false)
- );
- BOOST_REQUIRE(f);
-
- // cleanup
- fclose(f);
- ethash_light_delete(light);
- fs::remove_all("./test_ethash_directory/");
-}
-
-BOOST_AUTO_TEST_CASE(test_ethash_io_memo_file_size_mismatch) {
- static const int blockn = 0;
- ethash_h256_t seedhash = ethash_get_seedhash(blockn);
- FILE *f = NULL;
- BOOST_REQUIRE_EQUAL(
- ETHASH_IO_MEMO_MISMATCH,
- ethash_io_prepare("./test_ethash_directory/", seedhash, &f, 64, false)
- );
- BOOST_REQUIRE(f);
- fclose(f);
-
- // let's make sure that the directory was created
- BOOST_REQUIRE(fs::is_directory(fs::path("./test_ethash_directory/")));
- // and check that we get the size mismatch detected if we request diffferent size
- BOOST_REQUIRE_EQUAL(
- ETHASH_IO_MEMO_SIZE_MISMATCH,
- ethash_io_prepare("./test_ethash_directory/", seedhash, &f, 65, false)
- );
-
- // cleanup
- fs::remove_all("./test_ethash_directory/");
-}
-
-BOOST_AUTO_TEST_CASE(test_ethash_get_default_dirname) {
- char result[256];
- // this is really not an easy thing to test for in a unit test
- // TODO: Improve this test ...
-#ifdef _WIN32
- char homedir[256];
- BOOST_REQUIRE(SUCCEEDED(SHGetFolderPathA(NULL, CSIDL_PROFILE, NULL, 0, (CHAR*)homedir)));
- BOOST_REQUIRE(ethash_get_default_dirname(result, 256));
- std::string res = std::string(homedir) + std::string("\\AppData\\Local\\Ethash\\");
-#else
- char* homedir = getenv("HOME");
- BOOST_REQUIRE(ethash_get_default_dirname(result, 256));
- std::string res = std::string(homedir) + std::string("/.ethash/");
-#endif
- BOOST_CHECK_MESSAGE(strcmp(res.c_str(), result) == 0,
- "Expected \"" + res + "\" but got \"" + std::string(result) + "\""
- );
-}
-
-BOOST_AUTO_TEST_CASE(light_and_full_client_checks) {
- uint64_t full_size;
- uint64_t cache_size;
- ethash_h256_t seed;
- ethash_h256_t hash;
- ethash_h256_t difficulty;
- ethash_return_value_t light_out;
- ethash_return_value_t full_out;
- memcpy(&seed, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
- memcpy(&hash, "~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
-
- // Set the difficulty
- ethash_h256_set(&difficulty, 0, 197);
- ethash_h256_set(&difficulty, 1, 90);
- for (int i = 2; i < 32; i++)
- ethash_h256_set(&difficulty, i, 255);
-
- cache_size = 1024;
- full_size = 1024 * 32;
-
- ethash_light_t light = ethash_light_new_internal(cache_size, &seed);
- ethash_full_t full = ethash_full_new_internal(
- "./test_ethash_directory/",
- seed,
- full_size,
- light,
- NULL
- );
- BOOST_ASSERT(full);
- {
- const std::string
- expected = "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",
- actual = bytesToHexString((uint8_t const *) light->cache, cache_size);
-
- BOOST_REQUIRE_MESSAGE(expected == actual,
- "\nexpected: " << expected.c_str() << "\n"
- << "actual: " << actual.c_str() << "\n");
- }
- {
- node node;
- ethash_calculate_dag_item(&node, 0, light);
- const std::string
- actual = bytesToHexString((uint8_t const *) &node, sizeof(node)),
- expected = "b1698f829f90b35455804e5185d78f549fcb1bdce2bee006d4d7e68eb154b596be1427769eb1c3c3e93180c760af75f81d1023da6a0ffbe321c153a7c0103597";
- BOOST_REQUIRE_MESSAGE(actual == expected,
- "\n" << "expected: " << expected.c_str() << "\n"
- << "actual: " << actual.c_str() << "\n");
- }
- {
- for (int i = 0; i < full_size / sizeof(node); ++i) {
- for (uint32_t j = 0; j < 32; ++j) {
- node expected_node;
- ethash_calculate_dag_item(&expected_node, j, light);
- const std::string
- actual = bytesToHexString((uint8_t const *) &(full->data[j]), sizeof(node)),
- expected = bytesToHexString((uint8_t const *) &expected_node, sizeof(node));
- BOOST_REQUIRE_MESSAGE(actual == expected,
- "\ni: " << j << "\n"
- << "expected: " << expected.c_str() << "\n"
- << "actual: " << actual.c_str() << "\n");
- }
- }
- }
- {
- uint64_t nonce = 0x7c7c597c;
- full_out = ethash_full_compute(full, hash, nonce);
- BOOST_REQUIRE(full_out.success);
- light_out = ethash_light_compute_internal(light, full_size, hash, nonce);
- BOOST_REQUIRE(light_out.success);
- const std::string
- light_result_string = blockhashToHexString(&light_out.result),
- full_result_string = blockhashToHexString(&full_out.result);
- BOOST_REQUIRE_MESSAGE(light_result_string == full_result_string,
- "\nlight result: " << light_result_string.c_str() << "\n"
- << "full result: " << full_result_string.c_str() << "\n");
- const std::string
- light_mix_hash_string = blockhashToHexString(&light_out.mix_hash),
- full_mix_hash_string = blockhashToHexString(&full_out.mix_hash);
- 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");
- ethash_h256_t check_hash;
- ethash_quick_hash(&check_hash, &hash, nonce, &full_out.mix_hash);
- const std::string check_hash_string = blockhashToHexString(&check_hash);
- BOOST_REQUIRE_MESSAGE(check_hash_string == full_result_string,
- "\ncheck hash string: " << check_hash_string.c_str() << "\n"
- << "full result: " << full_result_string.c_str() << "\n");
- }
- {
- full_out = ethash_full_compute(full, hash, 5);
- BOOST_REQUIRE(full_out.success);
- std::string
- light_result_string = blockhashToHexString(&light_out.result),
- full_result_string = blockhashToHexString(&full_out.result);
- BOOST_REQUIRE_MESSAGE(light_result_string != full_result_string,
- "\nlight result and full result should differ: " << light_result_string.c_str() << "\n");
-
- light_out = ethash_light_compute_internal(light, full_size, hash, 5);
- BOOST_REQUIRE(light_out.success);
- light_result_string = blockhashToHexString(&light_out.result);
- BOOST_REQUIRE_MESSAGE(light_result_string == full_result_string,
- "\nlight result and full result should be the same\n"
- << "light result: " << light_result_string.c_str() << "\n"
- << "full result: " << full_result_string.c_str() << "\n");
- std::string
- light_mix_hash_string = blockhashToHexString(&light_out.mix_hash),
- full_mix_hash_string = blockhashToHexString(&full_out.mix_hash);
- 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"
- );
- }
- ethash_light_delete(light);
- ethash_full_delete(full);
- fs::remove_all("./test_ethash_directory/");
-}
-
-BOOST_AUTO_TEST_CASE(ethash_full_new_when_dag_exists_with_wrong_size) {
- uint64_t full_size;
- uint64_t cache_size;
- ethash_h256_t seed;
- ethash_h256_t hash;
- ethash_return_value_t full_out;
- ethash_return_value_t light_out;
- memcpy(&seed, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
- memcpy(&hash, "~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
-
- cache_size = 1024;
- full_size = 1024 * 32;
-
- // first make a DAG file of "wrong size"
- FILE *f;
- BOOST_REQUIRE_EQUAL(
- ETHASH_IO_MEMO_MISMATCH,
- ethash_io_prepare("./test_ethash_directory/", seed, &f, 64, false)
- );
- fclose(f);
-
- // then create new DAG, which should detect the wrong size and force create a new file
- ethash_light_t light = ethash_light_new_internal(cache_size, &seed);
- BOOST_ASSERT(light);
- ethash_full_t full = ethash_full_new_internal(
- "./test_ethash_directory/",
- seed,
- full_size,
- light,
- NULL
- );
- BOOST_ASSERT(full);
- {
- uint64_t nonce = 0x7c7c597c;
- full_out = ethash_full_compute(full, hash, nonce);
- BOOST_REQUIRE(full_out.success);
- light_out = ethash_light_compute_internal(light, full_size, hash, nonce);
- BOOST_REQUIRE(light_out.success);
- const std::string
- light_result_string = blockhashToHexString(&light_out.result),
- full_result_string = blockhashToHexString(&full_out.result);
- BOOST_REQUIRE_MESSAGE(light_result_string == full_result_string,
- "\nlight result: " << light_result_string.c_str() << "\n"
- << "full result: " << full_result_string.c_str() << "\n");
- const std::string
- light_mix_hash_string = blockhashToHexString(&light_out.mix_hash),
- full_mix_hash_string = blockhashToHexString(&full_out.mix_hash);
- 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");
- ethash_h256_t check_hash;
- ethash_quick_hash(&check_hash, &hash, nonce, &full_out.mix_hash);
- const std::string check_hash_string = blockhashToHexString(&check_hash);
- BOOST_REQUIRE_MESSAGE(check_hash_string == full_result_string,
- "\ncheck hash string: " << check_hash_string.c_str() << "\n"
- << "full result: " << full_result_string.c_str() << "\n");
- }
-
- ethash_light_delete(light);
- ethash_full_delete(full);
- fs::remove_all("./test_ethash_directory/");
-}
-
-static bool g_executed = false;
-static unsigned g_prev_progress = 0;
-static int test_full_callback(unsigned _progress)
-{
- g_executed = true;
- BOOST_CHECK(_progress >= g_prev_progress);
- g_prev_progress = _progress;
- return 0;
-}
-
-static int test_full_callback_that_fails(unsigned _progress)
-{
- return 1;
-}
-
-static int test_full_callback_create_incomplete_dag(unsigned _progress)
-{
- if (_progress >= 30) {
- return 1;
- }
- return 0;
-}
-
-BOOST_AUTO_TEST_CASE(full_client_callback) {
- uint64_t full_size;
- uint64_t cache_size;
- ethash_h256_t seed;
- ethash_h256_t hash;
- memcpy(&seed, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
- memcpy(&hash, "~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
-
- cache_size = 1024;
- full_size = 1024 * 32;
-
- ethash_light_t light = ethash_light_new_internal(cache_size, &seed);
- ethash_full_t full = ethash_full_new_internal(
- "./test_ethash_directory/",
- seed,
- full_size,
- light,
- test_full_callback
- );
- BOOST_ASSERT(full);
- BOOST_CHECK(g_executed);
- BOOST_REQUIRE_EQUAL(g_prev_progress, 100);
-
- ethash_full_delete(full);
- ethash_light_delete(light);
- fs::remove_all("./test_ethash_directory/");
-}
-
-BOOST_AUTO_TEST_CASE(failing_full_client_callback) {
- uint64_t full_size;
- uint64_t cache_size;
- ethash_h256_t seed;
- ethash_h256_t hash;
- memcpy(&seed, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
- memcpy(&hash, "~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
-
- cache_size = 1024;
- full_size = 1024 * 32;
-
- ethash_light_t light = ethash_light_new_internal(cache_size, &seed);
- ethash_full_t full = ethash_full_new_internal(
- "./test_ethash_directory/",
- seed,
- full_size,
- light,
- test_full_callback_that_fails
- );
- BOOST_ASSERT(!full);
- ethash_light_delete(light);
- fs::remove_all("./test_ethash_directory/");
-}
-
-BOOST_AUTO_TEST_CASE(test_incomplete_dag_file) {
- uint64_t full_size;
- uint64_t cache_size;
- ethash_h256_t seed;
- ethash_h256_t hash;
- memcpy(&seed, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
- memcpy(&hash, "~~~X~~~~~~~~~~~~~~~~~~~~~~~~~~~~", 32);
-
- cache_size = 1024;
- full_size = 1024 * 32;
-
- ethash_light_t light = ethash_light_new_internal(cache_size, &seed);
- // create a full but stop at 30%, so no magic number is written
- ethash_full_t full = ethash_full_new_internal(
- "./test_ethash_directory/",
- seed,
- full_size,
- light,
- test_full_callback_create_incomplete_dag
- );
- BOOST_ASSERT(!full);
- FILE *f = NULL;
- // confirm that we get a size_mismatch because the magic number is missing
- BOOST_REQUIRE_EQUAL(
- ETHASH_IO_MEMO_SIZE_MISMATCH,
- ethash_io_prepare("./test_ethash_directory/", seed, &f, full_size, false)
- );
- ethash_light_delete(light);
- fs::remove_all("./test_ethash_directory/");
-}
-
-BOOST_AUTO_TEST_CASE(test_block22_verification) {
- // from POC-9 testnet, epoch 0
- ethash_light_t light = ethash_light_new(22);
- ethash_h256_t seedhash = stringToBlockhash("372eca2454ead349c3df0ab5d00b0b706b23e49d469387db91811cee0358fc6d");
- BOOST_ASSERT(light);
- ethash_return_value_t ret = ethash_light_compute(
- light,
- seedhash,
- 0x495732e0ed7a801cU
- );
- BOOST_REQUIRE_EQUAL(blockhashToHexString(&ret.result), "00000b184f1fdd88bfd94c86c39e65db0c36144d5e43f745f722196e730cb614");
- ethash_h256_t difficulty = ethash_h256_static_init(0x2, 0x5, 0x40);
- BOOST_REQUIRE(ethash_check_difficulty(&ret.result, &difficulty));
- ethash_light_delete(light);
-}
-
-BOOST_AUTO_TEST_CASE(test_block30001_verification) {
- // from POC-9 testnet, epoch 1
- ethash_light_t light = ethash_light_new(30001);
- ethash_h256_t seedhash = stringToBlockhash("7e44356ee3441623bc72a683fd3708fdf75e971bbe294f33e539eedad4b92b34");
- BOOST_ASSERT(light);
- ethash_return_value_t ret = ethash_light_compute(
- light,
- seedhash,
- 0x318df1c8adef7e5eU
- );
- ethash_h256_t difficulty = ethash_h256_static_init(0x17, 0x62, 0xff);
- BOOST_REQUIRE(ethash_check_difficulty(&ret.result, &difficulty));
- ethash_light_delete(light);
-}
-
-BOOST_AUTO_TEST_CASE(test_block60000_verification) {
- // from POC-9 testnet, epoch 2
- ethash_light_t light = ethash_light_new(60000);
- ethash_h256_t seedhash = stringToBlockhash("5fc898f16035bf5ac9c6d9077ae1e3d5fc1ecc3c9fd5bee8bb00e810fdacbaa0");
- BOOST_ASSERT(light);
- ethash_return_value_t ret = ethash_light_compute(
- light,
- seedhash,
- 0x50377003e5d830caU
- );
- ethash_h256_t difficulty = ethash_h256_static_init(0x25, 0xa6, 0x1e);
- BOOST_REQUIRE(ethash_check_difficulty(&ret.result, &difficulty));
- ethash_light_delete(light);
-}
-
-// Test of Full DAG creation with the minimal ethash.h API.
-// Commented out since travis tests would take too much time.
-// Uncomment and run on your own machine if you want to confirm
-// it works fine.
-#if 0
-static int progress_cb(unsigned _progress)
-{
- printf("CREATING DAG. PROGRESS: %u\n", _progress);
- fflush(stdout);
- return 0;
-}
-
-BOOST_AUTO_TEST_CASE(full_dag_test) {
- ethash_light_t light = ethash_light_new(55);
- BOOST_ASSERT(light);
- ethash_full_t full = ethash_full_new(light, progress_cb);
- BOOST_ASSERT(full);
- ethash_light_delete(light);
- ethash_full_delete(full);
-}
-#endif
diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/test/c/test.sh b/Godeps/_workspace/src/github.com/ethereum/ethash/test/c/test.sh
deleted file mode 100644
index 92b6b8b66..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/test/c/test.sh
+++ /dev/null
@@ -1,32 +0,0 @@
-#!/bin/bash
-
-# Strict mode
-set -e
-
-VALGRIND_ARGS="--tool=memcheck"
-VALGRIND_ARGS+=" --leak-check=yes"
-VALGRIND_ARGS+=" --track-origins=yes"
-VALGRIND_ARGS+=" --show-reachable=yes"
-VALGRIND_ARGS+=" --num-callers=20"
-VALGRIND_ARGS+=" --track-fds=yes"
-
-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 )"
-
-rm -rf $TEST_DIR/build
-mkdir -p $TEST_DIR/build
-cd $TEST_DIR/build ;
-cmake ../../.. > /dev/null
-make Test
-./test/c/Test
-
-# If we have valgrind also run memory check tests
-if hash valgrind 2>/dev/null; then
- echo "======== Running tests under valgrind ========";
- cd $TEST_DIR/build/ && valgrind $VALGRIND_ARGS ./test/c/Test
-fi
diff --git a/Godeps/_workspace/src/github.com/ethereum/ethash/test/python/.gitignore b/Godeps/_workspace/src/github.com/ethereum/ethash/test/python/.gitignore
deleted file mode 100644
index c304fd615..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/test/python/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-python-virtual-env/
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
deleted file mode 100644
index 378263c62..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/test/python/requirements.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-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
deleted file mode 100644
index 05c66b550..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/test/python/test.sh
+++ /dev/null
@@ -1,30 +0,0 @@
-#!/bin/bash
-
-# Strict mode
-set -e
-
-if [ -x "$(which virtualenv2)" ] ; then
- VIRTUALENV_EXEC=virtualenv2
-elif [ -x "$(which virtualenv)" ] ; then
- VIRTUALENV_EXEC=virtualenv
-else
- echo "Could not find a suitable version of virtualenv"
- false
-fi
-
-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 )"
-
-[ -d $TEST_DIR/python-virtual-env ] || $VIRTUALENV_EXEC --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
-# force installation of nose in virtualenv even if existing in thereuser's system
-pip install nose -I
-pip install --upgrade --no-deps --force-reinstall -e $TEST_DIR/../..
-cd $TEST_DIR
-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
deleted file mode 100644
index 7eb1b60c7..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/test/python/test_pyethash.py
+++ /dev/null
@@ -1,105 +0,0 @@
-import pyethash
-from random import randint
-
-def test_get_cache_size_not_None():
- for _ in range(100):
- block_num = randint(0,12456789)
- 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.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.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.get_full_size(block_num)
- out2 = pyethash.get_full_size((block_num // pyethash.EPOCH_LENGTH) * pyethash.EPOCH_LENGTH)
- assert out1 == out2
-
-# 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
deleted file mode 100644
index aaeaa878c..000000000
--- a/Godeps/_workspace/src/github.com/ethereum/ethash/test/test.sh
+++ /dev/null
@@ -1,32 +0,0 @@
-#!/bin/bash
-
-# Strict mode
-set -e
-
-SOURCE="${BASH_SOURCE[0]}"
-while [ -h "$SOURCE" ]; do
- DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
- SOURCE="$(readlink "$SOURCE")"
- [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE"
-done
-TEST_DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
-
-echo -e "\n################# Testing JS ##################"
-# TODO: Use mocha and real testing tools instead of rolling our own
-cd $TEST_DIR/../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
-
-# Temporarily commenting out python tests until they conform to the API
-#echo -e "\n################# Testing Python ##################"
-#$TEST_DIR/python/test.sh
-
-echo "################# Testing Go ##################"
-cd $TEST_DIR/.. && go test -timeout 9999s
diff --git a/eth/backend.go b/eth/backend.go
index 2f0bc3ee5..f62ee976d 100644
--- a/eth/backend.go
+++ b/eth/backend.go
@@ -74,6 +74,7 @@ type Config struct {
DocRoot string
AutoDAG bool
PowTest bool
+ PowShared bool
ExtraData []byte
AccountManager *accounts.Manager
@@ -211,14 +212,18 @@ func New(ctx *node.ServiceContext, config *Config) (*Ethereum, error) {
GpobaseCorrectionFactor: config.GpobaseCorrectionFactor,
httpclient: httpclient.New(config.DocRoot),
}
-
- if config.PowTest {
+ switch {
+ case config.PowTest:
glog.V(logger.Info).Infof("ethash used in test mode")
eth.pow, err = ethash.NewForTesting()
if err != nil {
return nil, err
}
- } else {
+ case config.PowShared:
+ glog.V(logger.Info).Infof("ethash used in shared mode")
+ eth.pow = ethash.NewShared()
+
+ default:
eth.pow = ethash.New()
}
//genesis := core.GenesisBlock(uint64(config.GenesisNonce), stateDb)
diff --git a/tests/block_test_util.go b/tests/block_test_util.go
index 6ba8f3d18..f517eddd1 100644
--- a/tests/block_test_util.go
+++ b/tests/block_test_util.go
@@ -178,6 +178,7 @@ func runBlockTest(test *BlockTest) error {
TestGenesisBlock: test.Genesis,
Etherbase: common.Address{},
AccountManager: am,
+ PowShared: true,
}
ethereum, err := eth.New(&node.ServiceContext{EventMux: new(event.TypeMux)}, cfg)
if err != nil {
--
cgit v1.2.3