mirror of https://github.com/ethereum/go-ethereum
Felix Lange
10 years ago
commit
a91bf01429
@ -0,0 +1,6 @@ |
||||
before_install: |
||||
- sudo apt-get update -qq |
||||
- sudo apt-get install -qq wget cmake gcc bash libboost-test-dev nodejs python-pip python-dev |
||||
- sudo pip install virtualenv -q |
||||
|
||||
script: "./test/test.sh" |
||||
@ -0,0 +1,3 @@ |
||||
.PHONY: clean |
||||
clean: |
||||
rm -rf *.so pyethash.egg-info/ build/ test/python/python-virtual-env/ test/c/build/ pyethash/*.{so,pyc}
|
||||
@ -0,0 +1,7 @@ |
||||
[](https://travis-ci.org/ethereum/ethash) |
||||
|
||||
|
||||
# Ethash |
||||
|
||||
For details on this project, please see the Ethereum wiki: |
||||
https://github.com/ethereum/wiki/wiki/Ethash |
||||
@ -0,0 +1,7 @@ |
||||
# -*- mode: ruby -*- |
||||
# vi: set ft=ruby : |
||||
|
||||
Vagrant.configure(2) do |config| |
||||
config.vm.box = "Ubuntu 12.04" |
||||
config.vm.box_url = "https://cloud-images.ubuntu.com/vagrant/precise/current/precise-server-cloudimg-amd64-vagrant-disk1.box" |
||||
end |
||||
161
Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/CMakeParseArguments.cmake
generated
vendored
161
Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/CMakeParseArguments.cmake
generated
vendored
@ -0,0 +1,161 @@ |
||||
#.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() |
||||
217
Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindOpenCL.cmake
generated
vendored
217
Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindOpenCL.cmake
generated
vendored
@ -1,91 +1,136 @@ |
||||
#.rst: |
||||
# FindOpenCL |
||||
# ---------- |
||||
# |
||||
# This file taken from FindOpenCL project @ http://gitorious.com/findopencl |
||||
# Try to find OpenCL |
||||
# |
||||
# - Try to find OpenCL |
||||
# This module tries to find an OpenCL implementation on your system. It supports |
||||
# AMD / ATI, Apple and NVIDIA implementations, but shoudl work, too. |
||||
# Once done this will define:: |
||||
# |
||||
# Once done this will define |
||||
# OPENCL_FOUND - system has OpenCL |
||||
# OPENCL_INCLUDE_DIRS - the OpenCL include directory |
||||
# OPENCL_LIBRARIES - link these to use OpenCL |
||||
# 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 |
||||
# |
||||
# WIN32 should work, but is untested |
||||
|
||||
FIND_PACKAGE( PackageHandleStandardArgs ) |
||||
|
||||
SET (OPENCL_VERSION_STRING "0.1.0") |
||||
SET (OPENCL_VERSION_MAJOR 0) |
||||
SET (OPENCL_VERSION_MINOR 1) |
||||
SET (OPENCL_VERSION_PATCH 0) |
||||
|
||||
IF (APPLE) |
||||
|
||||
FIND_LIBRARY(OPENCL_LIBRARIES OpenCL DOC "OpenCL lib for OSX") |
||||
FIND_PATH(OPENCL_INCLUDE_DIRS OpenCL/cl.h DOC "Include for OpenCL on OSX") |
||||
FIND_PATH(_OPENCL_CPP_INCLUDE_DIRS OpenCL/cl.hpp DOC "Include for OpenCL CPP bindings on OSX") |
||||
|
||||
ELSE (APPLE) |
||||
|
||||
IF (WIN32) |
||||
|
||||
FIND_PATH(OPENCL_INCLUDE_DIRS CL/cl.h) |
||||
FIND_PATH(_OPENCL_CPP_INCLUDE_DIRS CL/cl.hpp) |
||||
|
||||
# The AMD SDK currently installs both x86 and x86_64 libraries |
||||
# This is only a hack to find out architecture |
||||
IF( ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "AMD64" ) |
||||
SET(OPENCL_LIB_DIR "$ENV{ATISTREAMSDKROOT}/lib/x86_64") |
||||
SET(OPENCL_LIB_DIR "$ENV{ATIINTERNALSTREAMSDKROOT}/lib/x86_64") |
||||
ELSE (${CMAKE_SYSTEM_PROCESSOR} STREQUAL "AMD64") |
||||
SET(OPENCL_LIB_DIR "$ENV{ATISTREAMSDKROOT}/lib/x86") |
||||
SET(OPENCL_LIB_DIR "$ENV{ATIINTERNALSTREAMSDKROOT}/lib/x86") |
||||
ENDIF( ${CMAKE_SYSTEM_PROCESSOR} STREQUAL "AMD64" ) |
||||
|
||||
# find out if the user asked for a 64-bit build, and use the corresponding |
||||
# 64 or 32 bit NVIDIA library paths to the search: |
||||
STRING(REGEX MATCH "Win64" ISWIN64 ${CMAKE_GENERATOR}) |
||||
IF("${ISWIN64}" STREQUAL "Win64") |
||||
FIND_LIBRARY(OPENCL_LIBRARIES OpenCL.lib ${OPENCL_LIB_DIR} $ENV{CUDA_LIB_PATH} $ENV{CUDA_PATH}/lib/x64) |
||||
ELSE("${ISWIN64}" STREQUAL "Win64") |
||||
FIND_LIBRARY(OPENCL_LIBRARIES OpenCL.lib ${OPENCL_LIB_DIR} $ENV{CUDA_LIB_PATH} $ENV{CUDA_PATH}/lib/Win32) |
||||
ENDIF("${ISWIN64}" STREQUAL "Win64") |
||||
|
||||
GET_FILENAME_COMPONENT(_OPENCL_INC_CAND ${OPENCL_LIB_DIR}/../../include ABSOLUTE) |
||||
|
||||
# On Win32 search relative to the library |
||||
FIND_PATH(OPENCL_INCLUDE_DIRS CL/cl.h PATHS "${_OPENCL_INC_CAND}" $ENV{CUDA_INC_PATH} $ENV{CUDA_PATH}/include) |
||||
FIND_PATH(_OPENCL_CPP_INCLUDE_DIRS CL/cl.hpp PATHS "${_OPENCL_INC_CAND}" $ENV{CUDA_INC_PATH} $ENV{CUDA_PATH}/include) |
||||
|
||||
ELSE (WIN32) |
||||
|
||||
# Unix style platforms |
||||
FIND_LIBRARY(OPENCL_LIBRARIES OpenCL |
||||
ENV LD_LIBRARY_PATH |
||||
) |
||||
|
||||
GET_FILENAME_COMPONENT(OPENCL_LIB_DIR ${OPENCL_LIBRARIES} PATH) |
||||
GET_FILENAME_COMPONENT(_OPENCL_INC_CAND ${OPENCL_LIB_DIR}/../../include ABSOLUTE) |
||||
|
||||
# The AMD SDK currently does not place its headers |
||||
# in /usr/include, therefore also search relative |
||||
# to the library |
||||
FIND_PATH(OPENCL_INCLUDE_DIRS CL/cl.h PATHS ${_OPENCL_INC_CAND} "/usr/local/cuda/include") |
||||
FIND_PATH(_OPENCL_CPP_INCLUDE_DIRS CL/cl.hpp PATHS ${_OPENCL_INC_CAND} "/usr/local/cuda/include") |
||||
|
||||
ENDIF (WIN32) |
||||
|
||||
ENDIF (APPLE) |
||||
|
||||
FIND_PACKAGE_HANDLE_STANDARD_ARGS( OpenCL DEFAULT_MSG OPENCL_LIBRARIES OPENCL_INCLUDE_DIRS ) |
||||
|
||||
IF( _OPENCL_CPP_INCLUDE_DIRS ) |
||||
SET( OPENCL_HAS_CPP_BINDINGS TRUE ) |
||||
LIST( APPEND OPENCL_INCLUDE_DIRS ${_OPENCL_CPP_INCLUDE_DIRS} ) |
||||
# This is often the same, so clean up |
||||
LIST( REMOVE_DUPLICATES OPENCL_INCLUDE_DIRS ) |
||||
ENDIF( _OPENCL_CPP_INCLUDE_DIRS ) |
||||
|
||||
MARK_AS_ADVANCED( |
||||
OPENCL_INCLUDE_DIRS |
||||
) |
||||
#============================================================================= |
||||
# 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) |
||||
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) |
||||
|
||||
@ -0,0 +1,382 @@ |
||||
#.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() |
||||
57
Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindPackageMessage.cmake
generated
vendored
57
Godeps/_workspace/src/github.com/ethereum/ethash/cmake/modules/FindPackageMessage.cmake
generated
vendored
@ -0,0 +1,57 @@ |
||||
#.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() |
||||
@ -0,0 +1,22 @@ |
||||
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. |
||||
|
||||
@ -0,0 +1,190 @@ |
||||
// 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)); |
||||
}; |
||||
}; |
||||
|
||||
|
||||
|
||||
|
||||
@ -0,0 +1,404 @@ |
||||
// 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; |
||||
|
||||
|
||||
@ -0,0 +1,201 @@ |
||||
#!/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()); |
||||
@ -0,0 +1,53 @@ |
||||
// 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)); |
||||
@ -0,0 +1,100 @@ |
||||
// 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; |
||||
@ -1,12 +0,0 @@ |
||||
set(LIBRARY ethash-cl) |
||||
set(CMAKE_BUILD_TYPE Release) |
||||
|
||||
if (NOT OPENCL_FOUND) |
||||
find_package(OpenCL) |
||||
endif() |
||||
if (OPENCL_FOUND) |
||||
include_directories(${OPENCL_INCLUDE_DIRS}) |
||||
include_directories(..) |
||||
add_library(${LIBRARY} ethash_cl_miner.cpp ethash_cl_miner.h) |
||||
TARGET_LINK_LIBRARIES(${LIBRARY} ${OPENCL_LIBRARIES} ethash) |
||||
endif() |
||||
15
Godeps/_workspace/src/github.com/ethereum/ethash/libethash-cuda/CMakeLists.txt
generated
vendored
15
Godeps/_workspace/src/github.com/ethereum/ethash/libethash-cuda/CMakeLists.txt
generated
vendored
@ -1,15 +0,0 @@ |
||||
find_package(CUDA) |
||||
|
||||
# Pass options to NVCC |
||||
|
||||
|
||||
if (CUDA_FOUND) |
||||
set(CUDA_NVCC_FLAGS " -gencode;arch=compute_30,code=sm_30; |
||||
-gencode;arch=compute_20,code=sm_20; |
||||
-gencode;arch=compute_11,code=sm_11; |
||||
-gencode;arch=compute_12,code=sm_12; |
||||
-gencode;arch=compute_13,code=sm_13;") |
||||
cuda_add_executable( |
||||
ethash-cuda |
||||
libethash.cu) |
||||
endif() |
||||
@ -1,879 +0,0 @@ |
||||
/* |
||||
Copyright 2009 NVIDIA Corporation. All rights reserved. |
||||
|
||||
NOTICE TO LICENSEE: |
||||
|
||||
This source code and/or documentation ("Licensed Deliverables") are subject |
||||
to NVIDIA intellectual property rights under U.S. and international Copyright |
||||
laws. |
||||
|
||||
These Licensed Deliverables contained herein is PROPRIETARY and CONFIDENTIAL |
||||
to NVIDIA and is being provided under the terms and conditions of a form of |
||||
NVIDIA software license agreement by and between NVIDIA and Licensee ("License |
||||
Agreement") or electronically accepted by Licensee. Notwithstanding any terms |
||||
or conditions to the contrary in the License Agreement, reproduction or |
||||
disclosure of the Licensed Deliverables to any third party without the express |
||||
written consent of NVIDIA is prohibited. |
||||
|
||||
NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE LICENSE AGREEMENT, |
||||
NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THESE LICENSED |
||||
DELIVERABLES FOR ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED |
||||
WARRANTY OF ANY KIND. NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE |
||||
LICENSED DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY, |
||||
NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE. NOTWITHSTANDING ANY |
||||
TERMS OR CONDITIONS TO THE CONTRARY IN THE LICENSE AGREEMENT, IN NO EVENT SHALL |
||||
NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, |
||||
OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER |
||||
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
||||
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THESE LICENSED DELIVERABLES. |
||||
|
||||
U.S. Government End Users. These Licensed Deliverables are a "commercial item" |
||||
as that term is defined at 48 C.F.R. 2.101 (OCT 1995), consisting of |
||||
"commercial computer software" and "commercial computer software documentation" |
||||
as such terms are used in 48 C.F.R. 12.212 (SEPT 1995) and is provided to the |
||||
U.S. Government only as a commercial end item. Consistent with 48 C.F.R.12.212 |
||||
and 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all U.S. Government |
||||
End Users acquire the Licensed Deliverables with only those rights set forth |
||||
herein. |
||||
|
||||
Any use of the Licensed Deliverables in individual and commercial software must |
||||
include, in the user documentation and internal comments to the code, the above |
||||
Disclaimer and U.S. Government End Users Notice. |
||||
*/ |
||||
|
||||
/* |
||||
* cuPrintf.cu |
||||
* |
||||
* This is a printf command callable from within a kernel. It is set |
||||
* up so that output is sent to a memory buffer, which is emptied from |
||||
* the host side - but only after a cudaThreadSynchronize() on the host. |
||||
* |
||||
* Currently, there is a limitation of around 200 characters of output |
||||
* and no more than 10 arguments to a single cuPrintf() call. Issue |
||||
* multiple calls if longer format strings are required. |
||||
* |
||||
* It requires minimal setup, and is *NOT* optimised for performance. |
||||
* For example, writes are not coalesced - this is because there is an |
||||
* assumption that people will not want to printf from every single one |
||||
* of thousands of threads, but only from individual threads at a time. |
||||
* |
||||
* Using this is simple - it requires one host-side call to initialise |
||||
* everything, and then kernels can call cuPrintf at will. Sample code |
||||
* is the easiest way to demonstrate: |
||||
* |
||||
#include "cuPrintf.cu" |
||||
|
||||
__global__ void testKernel(int val) |
||||
{ |
||||
cuPrintf("Value is: %d\n", val); |
||||
} |
||||
|
||||
int main() |
||||
{ |
||||
cudaPrintfInit(); |
||||
testKernel<<< 2, 3 >>>(10); |
||||
cudaPrintfDisplay(stdout, true); |
||||
cudaPrintfEnd(); |
||||
return 0; |
||||
} |
||||
* |
||||
* See the header file, "cuPrintf.cuh" for more info, especially |
||||
* arguments to cudaPrintfInit() and cudaPrintfDisplay(); |
||||
*/ |
||||
|
||||
#ifndef CUPRINTF_CU |
||||
#define CUPRINTF_CU |
||||
|
||||
#include "cuPrintf.cuh" |
||||
#if __CUDA_ARCH__ > 100 // Atomics only used with > sm_10 architecture |
||||
#include <sm_11_atomic_functions.h> |
||||
#endif |
||||
|
||||
// This is the smallest amount of memory, per-thread, which is allowed. |
||||
// It is also the largest amount of space a single printf() can take up |
||||
const static int CUPRINTF_MAX_LEN = 256; |
||||
|
||||
// This structure is used internally to track block/thread output restrictions. |
||||
typedef struct __align__(8) { |
||||
int threadid; // CUPRINTF_UNRESTRICTED for unrestricted |
||||
int blockid; // CUPRINTF_UNRESTRICTED for unrestricted |
||||
} cuPrintfRestriction; |
||||
|
||||
// The main storage is in a global print buffer, which has a known |
||||
// start/end/length. These are atomically updated so it works as a |
||||
// circular buffer. |
||||
// Since the only control primitive that can be used is atomicAdd(), |
||||
// we cannot wrap the pointer as such. The actual address must be |
||||
// calculated from printfBufferPtr by mod-ing with printfBufferLength. |
||||
// For sm_10 architecture, we must subdivide the buffer per-thread |
||||
// since we do not even have an atomic primitive. |
||||
__constant__ static char *globalPrintfBuffer = NULL; // Start of circular buffer (set up by host) |
||||
__constant__ static int printfBufferLength = 0; // Size of circular buffer (set up by host) |
||||
__device__ static cuPrintfRestriction restrictRules; // Output restrictions |
||||
__device__ volatile static char *printfBufferPtr = NULL; // Current atomically-incremented non-wrapped offset |
||||
|
||||
// This is the header preceeding all printf entries. |
||||
// NOTE: It *must* be size-aligned to the maximum entity size (size_t) |
||||
typedef struct __align__(8) { |
||||
unsigned short magic; // Magic number says we're valid |
||||
unsigned short fmtoffset; // Offset of fmt string into buffer |
||||
unsigned short blockid; // Block ID of author |
||||
unsigned short threadid; // Thread ID of author |
||||
} cuPrintfHeader; |
||||
|
||||
// Special header for sm_10 architecture |
||||
#define CUPRINTF_SM10_MAGIC 0xC810 // Not a valid ascii character |
||||
typedef struct __align__(16) { |
||||
unsigned short magic; // sm_10 specific magic number |
||||
unsigned short unused; |
||||
unsigned int thread_index; // thread ID for this buffer |
||||
unsigned int thread_buf_len; // per-thread buffer length |
||||
unsigned int offset; // most recent printf's offset |
||||
} cuPrintfHeaderSM10; |
||||
|
||||
|
||||
// Because we can't write an element which is not aligned to its bit-size, |
||||
// we have to align all sizes and variables on maximum-size boundaries. |
||||
// That means sizeof(double) in this case, but we'll use (long long) for |
||||
// better arch<1.3 support |
||||
#define CUPRINTF_ALIGN_SIZE sizeof(long long) |
||||
|
||||
// All our headers are prefixed with a magic number so we know they're ready |
||||
#define CUPRINTF_SM11_MAGIC (unsigned short)0xC811 // Not a valid ascii character |
||||
|
||||
|
||||
// |
||||
// getNextPrintfBufPtr |
||||
// |
||||
// Grabs a block of space in the general circular buffer, using an |
||||
// atomic function to ensure that it's ours. We handle wrapping |
||||
// around the circular buffer and return a pointer to a place which |
||||
// can be written to. |
||||
// |
||||
// Important notes: |
||||
// 1. We always grab CUPRINTF_MAX_LEN bytes |
||||
// 2. Because of 1, we never worry about wrapping around the end |
||||
// 3. Because of 1, printfBufferLength *must* be a factor of CUPRINTF_MAX_LEN |
||||
// |
||||
// This returns a pointer to the place where we own. |
||||
// |
||||
__device__ static char *getNextPrintfBufPtr() |
||||
{ |
||||
// Initialisation check |
||||
if(!printfBufferPtr) |
||||
return NULL; |
||||
|
||||
// Thread/block restriction check |
||||
if((restrictRules.blockid != CUPRINTF_UNRESTRICTED) && (restrictRules.blockid != (blockIdx.x + gridDim.x*blockIdx.y))) |
||||
return NULL; |
||||
if((restrictRules.threadid != CUPRINTF_UNRESTRICTED) && (restrictRules.threadid != (threadIdx.x + blockDim.x*threadIdx.y + blockDim.x*blockDim.y*threadIdx.z))) |
||||
return NULL; |
||||
|
||||
// Conditional section, dependent on architecture |
||||
#if __CUDA_ARCH__ == 100 |
||||
// For sm_10 architectures, we have no atomic add - this means we must split the |
||||
// entire available buffer into per-thread blocks. Inefficient, but what can you do. |
||||
int thread_count = (gridDim.x * gridDim.y) * (blockDim.x * blockDim.y * blockDim.z); |
||||
int thread_index = threadIdx.x + blockDim.x*threadIdx.y + blockDim.x*blockDim.y*threadIdx.z + |
||||
(blockIdx.x + gridDim.x*blockIdx.y) * (blockDim.x * blockDim.y * blockDim.z); |
||||
|
||||
// Find our own block of data and go to it. Make sure the per-thread length |
||||
// is a precise multiple of CUPRINTF_MAX_LEN, otherwise we risk size and |
||||
// alignment issues! We must round down, of course. |
||||
unsigned int thread_buf_len = printfBufferLength / thread_count; |
||||
thread_buf_len &= ~(CUPRINTF_MAX_LEN-1); |
||||
|
||||
// We *must* have a thread buffer length able to fit at least two printfs (one header, one real) |
||||
if(thread_buf_len < (CUPRINTF_MAX_LEN * 2)) |
||||
return NULL; |
||||
|
||||
// Now address our section of the buffer. The first item is a header. |
||||
char *myPrintfBuffer = globalPrintfBuffer + (thread_buf_len * thread_index); |
||||
cuPrintfHeaderSM10 hdr = *(cuPrintfHeaderSM10 *)(void *)myPrintfBuffer; |
||||
if(hdr.magic != CUPRINTF_SM10_MAGIC) |
||||
{ |
||||
// If our header is not set up, initialise it |
||||
hdr.magic = CUPRINTF_SM10_MAGIC; |
||||
hdr.thread_index = thread_index; |
||||
hdr.thread_buf_len = thread_buf_len; |
||||
hdr.offset = 0; // Note we start at 0! We pre-increment below. |
||||
*(cuPrintfHeaderSM10 *)(void *)myPrintfBuffer = hdr; // Write back the header |
||||
|
||||
// For initial setup purposes, we might need to init thread0's header too |
||||
// (so that cudaPrintfDisplay() below will work). This is only run once. |
||||
cuPrintfHeaderSM10 *tophdr = (cuPrintfHeaderSM10 *)(void *)globalPrintfBuffer; |
||||
tophdr->thread_buf_len = thread_buf_len; |
||||
} |
||||
|
||||
// Adjust the offset by the right amount, and wrap it if need be |
||||
unsigned int offset = hdr.offset + CUPRINTF_MAX_LEN; |
||||
if(offset >= hdr.thread_buf_len) |
||||
offset = CUPRINTF_MAX_LEN; |
||||
|
||||
// Write back the new offset for next time and return a pointer to it |
||||
((cuPrintfHeaderSM10 *)(void *)myPrintfBuffer)->offset = offset; |
||||
return myPrintfBuffer + offset; |
||||
#else |
||||
// Much easier with an atomic operation! |
||||
size_t offset = atomicAdd((unsigned int *)&printfBufferPtr, CUPRINTF_MAX_LEN) - (size_t)globalPrintfBuffer; |
||||
offset %= printfBufferLength; |
||||
return globalPrintfBuffer + offset; |
||||
#endif |
||||
} |
||||
|
||||
|
||||
// |
||||
// writePrintfHeader |
||||
// |
||||
// Inserts the header for containing our UID, fmt position and |
||||
// block/thread number. We generate it dynamically to avoid |
||||
// issues arising from requiring pre-initialisation. |
||||
// |
||||
__device__ static void writePrintfHeader(char *ptr, char *fmtptr) |
||||
{ |
||||
if(ptr) |
||||
{ |
||||
cuPrintfHeader header; |
||||
header.magic = CUPRINTF_SM11_MAGIC; |
||||
header.fmtoffset = (unsigned short)(fmtptr - ptr); |
||||
header.blockid = blockIdx.x + gridDim.x*blockIdx.y; |
||||
header.threadid = threadIdx.x + blockDim.x*threadIdx.y + blockDim.x*blockDim.y*threadIdx.z; |
||||
*(cuPrintfHeader *)(void *)ptr = header; |
||||
} |
||||
} |
||||
|
||||
|
||||
// |
||||
// cuPrintfStrncpy |
||||
// |
||||
// This special strncpy outputs an aligned length value, followed by the |
||||
// string. It then zero-pads the rest of the string until a 64-aligned |
||||
// boundary. The length *includes* the padding. A pointer to the byte |
||||
// just after the \0 is returned. |
||||
// |
||||
// This function could overflow CUPRINTF_MAX_LEN characters in our buffer. |
||||
// To avoid it, we must count as we output and truncate where necessary. |
||||
// |
||||
__device__ static char *cuPrintfStrncpy(char *dest, const char *src, int n, char *end) |
||||
{ |
||||
// Initialisation and overflow check |
||||
if(!dest || !src || (dest >= end)) |
||||
return NULL; |
||||
|
||||
// Prepare to write the length specifier. We're guaranteed to have |
||||
// at least "CUPRINTF_ALIGN_SIZE" bytes left because we only write out in |
||||
// chunks that size, and CUPRINTF_MAX_LEN is aligned with CUPRINTF_ALIGN_SIZE. |
||||
int *lenptr = (int *)(void *)dest; |
||||
int len = 0; |
||||
dest += CUPRINTF_ALIGN_SIZE; |
||||
|
||||
// Now copy the string |
||||
while(n--) |
||||
{ |
||||
if(dest >= end) // Overflow check |
||||
break; |
||||
|
||||
len++; |
||||
*dest++ = *src; |
||||
if(*src++ == '\0') |
||||
break; |
||||
} |
||||
|
||||
// Now write out the padding bytes, and we have our length. |
||||
while((dest < end) && (((long)dest & (CUPRINTF_ALIGN_SIZE-1)) != 0)) |
||||
{ |
||||
len++; |
||||
*dest++ = 0; |
||||
} |
||||
*lenptr = len; |
||||
return (dest < end) ? dest : NULL; // Overflow means return NULL |
||||
} |
||||
|
||||
|
||||
// |
||||
// copyArg |
||||
// |
||||
// This copies a length specifier and then the argument out to the |
||||
// data buffer. Templates let the compiler figure all this out at |
||||
// compile-time, making life much simpler from the programming |
||||
// point of view. I'm assuimg all (const char *) is a string, and |
||||
// everything else is the variable it points at. I'd love to see |
||||
// a better way of doing it, but aside from parsing the format |
||||
// string I can't think of one. |
||||
// |
||||
// The length of the data type is inserted at the beginning (so that |
||||
// the display can distinguish between float and double), and the |
||||
// pointer to the end of the entry is returned. |
||||
// |
||||
__device__ static char *copyArg(char *ptr, const char *arg, char *end) |
||||
{ |
||||
// Initialisation check |
||||
if(!ptr || !arg) |
||||
return NULL; |
||||
|
||||
// strncpy does all our work. We just terminate. |
||||
if((ptr = cuPrintfStrncpy(ptr, arg, CUPRINTF_MAX_LEN, end)) != NULL) |
||||
*ptr = 0; |
||||
|
||||
return ptr; |
||||
} |
||||
|
||||
template <typename T> |
||||
__device__ static char *copyArg(char *ptr, T &arg, char *end) |
||||
{ |
||||
// Initisalisation and overflow check. Alignment rules mean that |
||||
// we're at least CUPRINTF_ALIGN_SIZE away from "end", so we only need |
||||
// to check that one offset. |
||||
if(!ptr || ((ptr+CUPRINTF_ALIGN_SIZE) >= end)) |
||||
return NULL; |
||||
|
||||
// Write the length and argument |
||||
*(int *)(void *)ptr = sizeof(arg); |
||||
ptr += CUPRINTF_ALIGN_SIZE; |
||||
*(T *)(void *)ptr = arg; |
||||
ptr += CUPRINTF_ALIGN_SIZE; |
||||
*ptr = 0; |
||||
|
||||
return ptr; |
||||
} |
||||
|
||||
|
||||
// |
||||
// cuPrintf |
||||
// |
||||
// Templated printf functions to handle multiple arguments. |
||||
// Note we return the total amount of data copied, not the number |
||||
// of characters output. But then again, who ever looks at the |
||||
// return from printf() anyway? |
||||
// |
||||
// The format is to grab a block of circular buffer space, the |
||||
// start of which will hold a header and a pointer to the format |
||||
// string. We then write in all the arguments, and finally the |
||||
// format string itself. This is to make it easy to prevent |
||||
// overflow of our buffer (we support up to 10 arguments, each of |
||||
// which can be 12 bytes in length - that means that only the |
||||
// format string (or a %s) can actually overflow; so the overflow |
||||
// check need only be in the strcpy function. |
||||
// |
||||
// The header is written at the very last because that's what |
||||
// makes it look like we're done. |
||||
// |
||||
// Errors, which are basically lack-of-initialisation, are ignored |
||||
// in the called functions because NULL pointers are passed around |
||||
// |
||||
|
||||
// All printf variants basically do the same thing, setting up the |
||||
// buffer, writing all arguments, then finalising the header. For |
||||
// clarity, we'll pack the code into some big macros. |
||||
#define CUPRINTF_PREAMBLE \ |
||||
char *start, *end, *bufptr, *fmtstart; \ |
||||
if((start = getNextPrintfBufPtr()) == NULL) return 0; \ |
||||
end = start + CUPRINTF_MAX_LEN; \ |
||||
bufptr = start + sizeof(cuPrintfHeader); |
||||
|
||||
// Posting an argument is easy |
||||
#define CUPRINTF_ARG(argname) \ |
||||
bufptr = copyArg(bufptr, argname, end); |
||||
|
||||
// After args are done, record start-of-fmt and write the fmt and header |
||||
#define CUPRINTF_POSTAMBLE \ |
||||
fmtstart = bufptr; \ |
||||
end = cuPrintfStrncpy(bufptr, fmt, CUPRINTF_MAX_LEN, end); \ |
||||
writePrintfHeader(start, end ? fmtstart : NULL); \ |
||||
return end ? (int)(end - start) : 0; |
||||
|
||||
__device__ int cuPrintf(const char *fmt) |
||||
{ |
||||
CUPRINTF_PREAMBLE; |
||||
|
||||
CUPRINTF_POSTAMBLE; |
||||
} |
||||
template <typename T1> __device__ int cuPrintf(const char *fmt, T1 arg1) |
||||
{ |
||||
CUPRINTF_PREAMBLE; |
||||
|
||||
CUPRINTF_ARG(arg1); |
||||
|
||||
CUPRINTF_POSTAMBLE; |
||||
} |
||||
template <typename T1, typename T2> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2) |
||||
{ |
||||
CUPRINTF_PREAMBLE; |
||||
|
||||
CUPRINTF_ARG(arg1); |
||||
CUPRINTF_ARG(arg2); |
||||
|
||||
CUPRINTF_POSTAMBLE; |
||||
} |
||||
template <typename T1, typename T2, typename T3> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3) |
||||
{ |
||||
CUPRINTF_PREAMBLE; |
||||
|
||||
CUPRINTF_ARG(arg1); |
||||
CUPRINTF_ARG(arg2); |
||||
CUPRINTF_ARG(arg3); |
||||
|
||||
CUPRINTF_POSTAMBLE; |
||||
} |
||||
template <typename T1, typename T2, typename T3, typename T4> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4) |
||||
{ |
||||
CUPRINTF_PREAMBLE; |
||||
|
||||
CUPRINTF_ARG(arg1); |
||||
CUPRINTF_ARG(arg2); |
||||
CUPRINTF_ARG(arg3); |
||||
CUPRINTF_ARG(arg4); |
||||
|
||||
CUPRINTF_POSTAMBLE; |
||||
} |
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5) |
||||
{ |
||||
CUPRINTF_PREAMBLE; |
||||
|
||||
CUPRINTF_ARG(arg1); |
||||
CUPRINTF_ARG(arg2); |
||||
CUPRINTF_ARG(arg3); |
||||
CUPRINTF_ARG(arg4); |
||||
CUPRINTF_ARG(arg5); |
||||
|
||||
CUPRINTF_POSTAMBLE; |
||||
} |
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6) |
||||
{ |
||||
CUPRINTF_PREAMBLE; |
||||
|
||||
CUPRINTF_ARG(arg1); |
||||
CUPRINTF_ARG(arg2); |
||||
CUPRINTF_ARG(arg3); |
||||
CUPRINTF_ARG(arg4); |
||||
CUPRINTF_ARG(arg5); |
||||
CUPRINTF_ARG(arg6); |
||||
CUPRINTF_POSTAMBLE; |
||||
} |
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7) |
||||
{ |
||||
CUPRINTF_PREAMBLE; |
||||
|
||||
CUPRINTF_ARG(arg1); |
||||
CUPRINTF_ARG(arg2); |
||||
CUPRINTF_ARG(arg3); |
||||
CUPRINTF_ARG(arg4); |
||||
CUPRINTF_ARG(arg5); |
||||
CUPRINTF_ARG(arg6); |
||||
CUPRINTF_ARG(arg7); |
||||
|
||||
CUPRINTF_POSTAMBLE; |
||||
} |
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8) |
||||
{ |
||||
CUPRINTF_PREAMBLE; |
||||
|
||||
CUPRINTF_ARG(arg1); |
||||
CUPRINTF_ARG(arg2); |
||||
CUPRINTF_ARG(arg3); |
||||
CUPRINTF_ARG(arg4); |
||||
CUPRINTF_ARG(arg5); |
||||
CUPRINTF_ARG(arg6); |
||||
CUPRINTF_ARG(arg7); |
||||
CUPRINTF_ARG(arg8); |
||||
|
||||
CUPRINTF_POSTAMBLE; |
||||
} |
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9) |
||||
{ |
||||
CUPRINTF_PREAMBLE; |
||||
|
||||
CUPRINTF_ARG(arg1); |
||||
CUPRINTF_ARG(arg2); |
||||
CUPRINTF_ARG(arg3); |
||||
CUPRINTF_ARG(arg4); |
||||
CUPRINTF_ARG(arg5); |
||||
CUPRINTF_ARG(arg6); |
||||
CUPRINTF_ARG(arg7); |
||||
CUPRINTF_ARG(arg8); |
||||
CUPRINTF_ARG(arg9); |
||||
|
||||
CUPRINTF_POSTAMBLE; |
||||
} |
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10) |
||||
{ |
||||
CUPRINTF_PREAMBLE; |
||||
|
||||
CUPRINTF_ARG(arg1); |
||||
CUPRINTF_ARG(arg2); |
||||
CUPRINTF_ARG(arg3); |
||||
CUPRINTF_ARG(arg4); |
||||
CUPRINTF_ARG(arg5); |
||||
CUPRINTF_ARG(arg6); |
||||
CUPRINTF_ARG(arg7); |
||||
CUPRINTF_ARG(arg8); |
||||
CUPRINTF_ARG(arg9); |
||||
CUPRINTF_ARG(arg10); |
||||
|
||||
CUPRINTF_POSTAMBLE; |
||||
} |
||||
#undef CUPRINTF_PREAMBLE |
||||
#undef CUPRINTF_ARG |
||||
#undef CUPRINTF_POSTAMBLE |
||||
|
||||
|
||||
// |
||||
// cuPrintfRestrict |
||||
// |
||||
// Called to restrict output to a given thread/block. |
||||
// We store the info in "restrictRules", which is set up at |
||||
// init time by the host. It's not the cleanest way to do this |
||||
// because it means restrictions will last between |
||||
// invocations, but given the output-pointer continuity, |
||||
// I feel this is reasonable. |
||||
// |
||||
__device__ void cuPrintfRestrict(int threadid, int blockid) |
||||
{ |
||||
int thread_count = blockDim.x * blockDim.y * blockDim.z; |
||||
if(((threadid < thread_count) && (threadid >= 0)) || (threadid == CUPRINTF_UNRESTRICTED)) |
||||
restrictRules.threadid = threadid; |
||||
|
||||
int block_count = gridDim.x * gridDim.y; |
||||
if(((blockid < block_count) && (blockid >= 0)) || (blockid == CUPRINTF_UNRESTRICTED)) |
||||
restrictRules.blockid = blockid; |
||||
} |
||||
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////// |
||||
// HOST SIDE |
||||
|
||||
#include <stdio.h> |
||||
static FILE *printf_fp; |
||||
|
||||
static char *printfbuf_start=NULL; |
||||
static char *printfbuf_device=NULL; |
||||
static int printfbuf_len=0; |
||||
|
||||
|
||||
// |
||||
// outputPrintfData |
||||
// |
||||
// Our own internal function, which takes a pointer to a data buffer |
||||
// and passes it through libc's printf for output. |
||||
// |
||||
// We receive the formate string and a pointer to where the data is |
||||
// held. We then run through and print it out. |
||||
// |
||||
// Returns 0 on failure, 1 on success |
||||
// |
||||
static int outputPrintfData(char *fmt, char *data) |
||||
{ |
||||
// Format string is prefixed by a length that we don't need |
||||
fmt += CUPRINTF_ALIGN_SIZE; |
||||
|
||||
// Now run through it, printing everything we can. We must |
||||
// run to every % character, extract only that, and use printf |
||||
// to format it. |
||||
char *p = strchr(fmt, '%'); |
||||
while(p != NULL) |
||||
{ |
||||
// Print up to the % character |
||||
*p = '\0'; |
||||
fputs(fmt, printf_fp); |
||||
*p = '%'; // Put back the % |
||||
|
||||
// Now handle the format specifier |
||||
char *format = p++; // Points to the '%' |
||||
p += strcspn(p, "%cdiouxXeEfgGaAnps"); |
||||
if(*p == '\0') // If no format specifier, print the whole thing |
||||
{ |
||||
fmt = format; |
||||
break; |
||||
} |
||||
|
||||
// Cut out the format bit and use printf to print it. It's prefixed |
||||
// by its length. |
||||
int arglen = *(int *)data; |
||||
if(arglen > CUPRINTF_MAX_LEN) |
||||
{ |
||||
fputs("Corrupt printf buffer data - aborting\n", printf_fp); |
||||
return 0; |
||||
} |
||||
|
||||
data += CUPRINTF_ALIGN_SIZE; |
||||
|
||||
char specifier = *p++; |
||||
char c = *p; // Store for later |
||||
*p = '\0'; |
||||
switch(specifier) |
||||
{ |
||||
// These all take integer arguments |
||||
case 'c': |
||||
case 'd': |
||||
case 'i': |
||||
case 'o': |
||||
case 'u': |
||||
case 'x': |
||||
case 'X': |
||||
case 'p': |
||||
fprintf(printf_fp, format, *((int *)data)); |
||||
break; |
||||
|
||||
// These all take double arguments |
||||
case 'e': |
||||
case 'E': |
||||
case 'f': |
||||
case 'g': |
||||
case 'G': |
||||
case 'a': |
||||
case 'A': |
||||
if(arglen == 4) // Float vs. Double thing |
||||
fprintf(printf_fp, format, *((float *)data)); |
||||
else |
||||
fprintf(printf_fp, format, *((double *)data)); |
||||
break; |
||||
|
||||
// Strings are handled in a special way |
||||
case 's': |
||||
fprintf(printf_fp, format, (char *)data); |
||||
break; |
||||
|
||||
// % is special |
||||
case '%': |
||||
fprintf(printf_fp, "%%"); |
||||
break; |
||||
|
||||
// Everything else is just printed out as-is |
||||
default: |
||||
fprintf(printf_fp, format); |
||||
break; |
||||
} |
||||
data += CUPRINTF_ALIGN_SIZE; // Move on to next argument |
||||
*p = c; // Restore what we removed |
||||
fmt = p; // Adjust fmt string to be past the specifier |
||||
p = strchr(fmt, '%'); // and get the next specifier |
||||
} |
||||
|
||||
// Print out the last of the string |
||||
fputs(fmt, printf_fp); |
||||
return 1; |
||||
} |
||||
|
||||
|
||||
// |
||||
// doPrintfDisplay |
||||
// |
||||
// This runs through the blocks of CUPRINTF_MAX_LEN-sized data, calling the |
||||
// print function above to display them. We've got this separate from |
||||
// cudaPrintfDisplay() below so we can handle the SM_10 architecture |
||||
// partitioning. |
||||
// |
||||
static int doPrintfDisplay(int headings, int clear, char *bufstart, char *bufend, char *bufptr, char *endptr) |
||||
{ |
||||
// Grab, piece-by-piece, each output element until we catch |
||||
// up with the circular buffer end pointer |
||||
int printf_count=0; |
||||
char printfbuf_local[CUPRINTF_MAX_LEN+1]; |
||||
printfbuf_local[CUPRINTF_MAX_LEN] = '\0'; |
||||
|
||||
while(bufptr != endptr) |
||||
{ |
||||
// Wrap ourselves at the end-of-buffer |
||||
if(bufptr == bufend) |
||||
bufptr = bufstart; |
||||
|
||||
// Adjust our start pointer to within the circular buffer and copy a block. |
||||
cudaMemcpy(printfbuf_local, bufptr, CUPRINTF_MAX_LEN, cudaMemcpyDeviceToHost); |
||||
|
||||
// If the magic number isn't valid, then this write hasn't gone through |
||||
// yet and we'll wait until it does (or we're past the end for non-async printfs). |
||||
cuPrintfHeader *hdr = (cuPrintfHeader *)printfbuf_local; |
||||
if((hdr->magic != CUPRINTF_SM11_MAGIC) || (hdr->fmtoffset >= CUPRINTF_MAX_LEN)) |
||||
{ |
||||
//fprintf(printf_fp, "Bad magic number in printf header\n"); |
||||
break; |
||||
} |
||||
|
||||
// Extract all the info and get this printf done |
||||
if(headings) |
||||
fprintf(printf_fp, "[%d, %d]: ", hdr->blockid, hdr->threadid); |
||||
if(hdr->fmtoffset == 0) |
||||
fprintf(printf_fp, "printf buffer overflow\n"); |
||||
else if(!outputPrintfData(printfbuf_local+hdr->fmtoffset, printfbuf_local+sizeof(cuPrintfHeader))) |
||||
break; |
||||
printf_count++; |
||||
|
||||
// Clear if asked |
||||
if(clear) |
||||
cudaMemset(bufptr, 0, CUPRINTF_MAX_LEN); |
||||
|
||||
// Now advance our start location, because we're done, and keep copying |
||||
bufptr += CUPRINTF_MAX_LEN; |
||||
} |
||||
|
||||
return printf_count; |
||||
} |
||||
|
||||
|
||||
// |
||||
// cudaPrintfInit |
||||
// |
||||
// Takes a buffer length to allocate, creates the memory on the device and |
||||
// returns a pointer to it for when a kernel is called. It's up to the caller |
||||
// to free it. |
||||
// |
||||
extern "C" cudaError_t cudaPrintfInit(size_t bufferLen) |
||||
{ |
||||
// Fix up bufferlen to be a multiple of CUPRINTF_MAX_LEN |
||||
bufferLen = (bufferLen < CUPRINTF_MAX_LEN) ? CUPRINTF_MAX_LEN : bufferLen; |
||||
if((bufferLen % CUPRINTF_MAX_LEN) > 0) |
||||
bufferLen += (CUPRINTF_MAX_LEN - (bufferLen % CUPRINTF_MAX_LEN)); |
||||
printfbuf_len = (int)bufferLen; |
||||
|
||||
// Allocate a print buffer on the device and zero it |
||||
if(cudaMalloc((void **)&printfbuf_device, printfbuf_len) != cudaSuccess) |
||||
return cudaErrorInitializationError; |
||||
cudaMemset(printfbuf_device, 0, printfbuf_len); |
||||
printfbuf_start = printfbuf_device; // Where we start reading from |
||||
|
||||
// No restrictions to begin with |
||||
cuPrintfRestriction restrict; |
||||
restrict.threadid = restrict.blockid = CUPRINTF_UNRESTRICTED; |
||||
cudaMemcpyToSymbol(restrictRules, &restrict, sizeof(restrict)); |
||||
|
||||
// Initialise the buffer and the respective lengths/pointers. |
||||
cudaMemcpyToSymbol(globalPrintfBuffer, &printfbuf_device, sizeof(char *)); |
||||
cudaMemcpyToSymbol(printfBufferPtr, &printfbuf_device, sizeof(char *)); |
||||
cudaMemcpyToSymbol(printfBufferLength, &printfbuf_len, sizeof(printfbuf_len)); |
||||
|
||||
return cudaSuccess; |
||||
} |
||||
|
||||
|
||||
// |
||||
// cudaPrintfEnd |
||||
// |
||||
// Frees up the memory which we allocated |
||||
// |
||||
extern "C" void cudaPrintfEnd() |
||||
{ |
||||
if(!printfbuf_start || !printfbuf_device) |
||||
return; |
||||
|
||||
cudaFree(printfbuf_device); |
||||
printfbuf_start = printfbuf_device = NULL; |
||||
} |
||||
|
||||
|
||||
// |
||||
// cudaPrintfDisplay |
||||
// |
||||
// Each call to this function dumps the entire current contents |
||||
// of the printf buffer to the pre-specified FILE pointer. The |
||||
// circular "start" pointer is advanced so that subsequent calls |
||||
// dumps only new stuff. |
||||
// |
||||
// In the case of async memory access (via streams), call this |
||||
// repeatedly to keep trying to empty the buffer. If it's a sync |
||||
// access, then the whole buffer should empty in one go. |
||||
// |
||||
// Arguments: |
||||
// outputFP - File descriptor to output to (NULL => stdout) |
||||
// showThreadID - If true, prints [block,thread] before each line |
||||
// |
||||
extern "C" cudaError_t cudaPrintfDisplay(void *outputFP, bool showThreadID) |
||||
{ |
||||
printf_fp = (FILE *)((outputFP == NULL) ? stdout : outputFP); |
||||
|
||||
// For now, we force "synchronous" mode which means we're not concurrent |
||||
// with kernel execution. This also means we don't need clearOnPrint. |
||||
// If you're patching it for async operation, here's where you want it. |
||||
bool sync_printfs = true; |
||||
bool clearOnPrint = false; |
||||
|
||||
// Initialisation check |
||||
if(!printfbuf_start || !printfbuf_device || !printf_fp) |
||||
return cudaErrorMissingConfiguration; |
||||
|
||||
// To determine which architecture we're using, we read the |
||||
// first short from the buffer - it'll be the magic number |
||||
// relating to the version. |
||||
unsigned short magic; |
||||
cudaMemcpy(&magic, printfbuf_device, sizeof(unsigned short), cudaMemcpyDeviceToHost); |
||||
|
||||
// For SM_10 architecture, we've split our buffer into one-per-thread. |
||||
// That means we must do each thread block separately. It'll require |
||||
// extra reading. We also, for now, don't support async printfs because |
||||
// that requires tracking one start pointer per thread. |
||||
if(magic == CUPRINTF_SM10_MAGIC) |
||||
{ |
||||
sync_printfs = true; |
||||
clearOnPrint = false; |
||||
int blocklen = 0; |
||||
char *blockptr = printfbuf_device; |
||||
while(blockptr < (printfbuf_device + printfbuf_len)) |
||||
{ |
||||
cuPrintfHeaderSM10 hdr; |
||||
cudaMemcpy(&hdr, blockptr, sizeof(hdr), cudaMemcpyDeviceToHost); |
||||
|
||||
// We get our block-size-step from the very first header |
||||
if(hdr.thread_buf_len != 0) |
||||
blocklen = hdr.thread_buf_len; |
||||
|
||||
// No magic number means no printfs from this thread |
||||
if(hdr.magic != CUPRINTF_SM10_MAGIC) |
||||
{ |
||||
if(blocklen == 0) |
||||
{ |
||||
fprintf(printf_fp, "No printf headers found at all!\n"); |
||||
break; // No valid headers! |
||||
} |
||||
blockptr += blocklen; |
||||
continue; |
||||
} |
||||
|
||||
// "offset" is non-zero then we can print the block contents |
||||
if(hdr.offset > 0) |
||||
{ |
||||
// For synchronous printfs, we must print from endptr->bufend, then from start->end |
||||
if(sync_printfs) |
||||
doPrintfDisplay(showThreadID, clearOnPrint, blockptr+CUPRINTF_MAX_LEN, blockptr+hdr.thread_buf_len, blockptr+hdr.offset+CUPRINTF_MAX_LEN, blockptr+hdr.thread_buf_len); |
||||
doPrintfDisplay(showThreadID, clearOnPrint, blockptr+CUPRINTF_MAX_LEN, blockptr+hdr.thread_buf_len, blockptr+CUPRINTF_MAX_LEN, blockptr+hdr.offset+CUPRINTF_MAX_LEN); |
||||
} |
||||
|
||||
// Move on to the next block and loop again |
||||
blockptr += hdr.thread_buf_len; |
||||
} |
||||
} |
||||
// For SM_11 and up, everything is a single buffer and it's simple |
||||
else if(magic == CUPRINTF_SM11_MAGIC) |
||||
{ |
||||
// Grab the current "end of circular buffer" pointer. |
||||
char *printfbuf_end = NULL; |
||||
cudaMemcpyFromSymbol(&printfbuf_end, printfBufferPtr, sizeof(char *)); |
||||
|
||||
// Adjust our starting and ending pointers to within the block |
||||
char *bufptr = ((printfbuf_start - printfbuf_device) % printfbuf_len) + printfbuf_device; |
||||
char *endptr = ((printfbuf_end - printfbuf_device) % printfbuf_len) + printfbuf_device; |
||||
|
||||
// For synchronous (i.e. after-kernel-exit) printf display, we have to handle circular |
||||
// buffer wrap carefully because we could miss those past "end". |
||||
if(sync_printfs) |
||||
doPrintfDisplay(showThreadID, clearOnPrint, printfbuf_device, printfbuf_device+printfbuf_len, endptr, printfbuf_device+printfbuf_len); |
||||
doPrintfDisplay(showThreadID, clearOnPrint, printfbuf_device, printfbuf_device+printfbuf_len, bufptr, endptr); |
||||
|
||||
printfbuf_start = printfbuf_end; |
||||
} |
||||
else |
||||
;//printf("Bad magic number in cuPrintf buffer header\n"); |
||||
|
||||
// If we were synchronous, then we must ensure that the memory is cleared on exit |
||||
// otherwise another kernel launch with a different grid size could conflict. |
||||
if(sync_printfs) |
||||
cudaMemset(printfbuf_device, 0, printfbuf_len); |
||||
|
||||
return cudaSuccess; |
||||
} |
||||
|
||||
// Cleanup |
||||
#undef CUPRINTF_MAX_LEN |
||||
#undef CUPRINTF_ALIGN_SIZE |
||||
#undef CUPRINTF_SM10_MAGIC |
||||
#undef CUPRINTF_SM11_MAGIC |
||||
|
||||
#endif |
||||
@ -1,162 +0,0 @@ |
||||
/* |
||||
Copyright 2009 NVIDIA Corporation. All rights reserved. |
||||
|
||||
NOTICE TO LICENSEE: |
||||
|
||||
This source code and/or documentation ("Licensed Deliverables") are subject |
||||
to NVIDIA intellectual property rights under U.S. and international Copyright |
||||
laws. |
||||
|
||||
These Licensed Deliverables contained herein is PROPRIETARY and CONFIDENTIAL |
||||
to NVIDIA and is being provided under the terms and conditions of a form of |
||||
NVIDIA software license agreement by and between NVIDIA and Licensee ("License |
||||
Agreement") or electronically accepted by Licensee. Notwithstanding any terms |
||||
or conditions to the contrary in the License Agreement, reproduction or |
||||
disclosure of the Licensed Deliverables to any third party without the express |
||||
written consent of NVIDIA is prohibited. |
||||
|
||||
NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE LICENSE AGREEMENT, |
||||
NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THESE LICENSED |
||||
DELIVERABLES FOR ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED |
||||
WARRANTY OF ANY KIND. NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE |
||||
LICENSED DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY, |
||||
NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE. NOTWITHSTANDING ANY |
||||
TERMS OR CONDITIONS TO THE CONTRARY IN THE LICENSE AGREEMENT, IN NO EVENT SHALL |
||||
NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, |
||||
OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER |
||||
IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
||||
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THESE LICENSED DELIVERABLES. |
||||
|
||||
U.S. Government End Users. These Licensed Deliverables are a "commercial item" |
||||
as that term is defined at 48 C.F.R. 2.101 (OCT 1995), consisting of |
||||
"commercial computer software" and "commercial computer software documentation" |
||||
as such terms are used in 48 C.F.R. 12.212 (SEPT 1995) and is provided to the |
||||
U.S. Government only as a commercial end item. Consistent with 48 C.F.R.12.212 |
||||
and 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all U.S. Government |
||||
End Users acquire the Licensed Deliverables with only those rights set forth |
||||
herein. |
||||
|
||||
Any use of the Licensed Deliverables in individual and commercial software must |
||||
include, in the user documentation and internal comments to the code, the above |
||||
Disclaimer and U.S. Government End Users Notice. |
||||
*/ |
||||
|
||||
#ifndef CUPRINTF_H |
||||
#define CUPRINTF_H |
||||
|
||||
/* |
||||
* This is the header file supporting cuPrintf.cu and defining both |
||||
* the host and device-side interfaces. See that file for some more |
||||
* explanation and sample use code. See also below for details of the |
||||
* host-side interfaces. |
||||
* |
||||
* Quick sample code: |
||||
* |
||||
#include "cuPrintf.cu" |
||||
|
||||
__global__ void testKernel(int val) |
||||
{ |
||||
cuPrintf("Value is: %d\n", val); |
||||
} |
||||
|
||||
int main() |
||||
{ |
||||
cudaPrintfInit(); |
||||
testKernel<<< 2, 3 >>>(10); |
||||
cudaPrintfDisplay(stdout, true); |
||||
cudaPrintfEnd(); |
||||
return 0; |
||||
} |
||||
*/ |
||||
|
||||
/////////////////////////////////////////////////////////////////////////////// |
||||
// DEVICE SIDE |
||||
// External function definitions for device-side code |
||||
|
||||
// Abuse of templates to simulate varargs |
||||
__device__ int cuPrintf(const char *fmt); |
||||
template <typename T1> __device__ int cuPrintf(const char *fmt, T1 arg1); |
||||
template <typename T1, typename T2> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2); |
||||
template <typename T1, typename T2, typename T3> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3); |
||||
template <typename T1, typename T2, typename T3, typename T4> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4); |
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5); |
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6); |
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7); |
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8); |
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9); |
||||
template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10> __device__ int cuPrintf(const char *fmt, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10); |
||||
|
||||
|
||||
// |
||||
// cuPrintfRestrict |
||||
// |
||||
// Called to restrict output to a given thread/block. Pass |
||||
// the constant CUPRINTF_UNRESTRICTED to unrestrict output |
||||
// for thread/block IDs. Note you can therefore allow |
||||
// "all printfs from block 3" or "printfs from thread 2 |
||||
// on all blocks", or "printfs only from block 1, thread 5". |
||||
// |
||||
// Arguments: |
||||
// threadid - Thread ID to allow printfs from |
||||
// blockid - Block ID to allow printfs from |
||||
// |
||||
// NOTE: Restrictions last between invocations of |
||||
// kernels unless cudaPrintfInit() is called again. |
||||
// |
||||
#define CUPRINTF_UNRESTRICTED -1 |
||||
__device__ void cuPrintfRestrict(int threadid, int blockid); |
||||
|
||||
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////// |
||||
// HOST SIDE |
||||
// External function definitions for host-side code |
||||
|
||||
// |
||||
// cudaPrintfInit |
||||
// |
||||
// Call this once to initialise the printf system. If the output |
||||
// file or buffer size needs to be changed, call cudaPrintfEnd() |
||||
// before re-calling cudaPrintfInit(). |
||||
// |
||||
// The default size for the buffer is 1 megabyte. For CUDA |
||||
// architecture 1.1 and above, the buffer is filled linearly and |
||||
// is completely used; however for architecture 1.0, the buffer |
||||
// is divided into as many segments are there are threads, even |
||||
// if some threads do not call cuPrintf(). |
||||
// |
||||
// Arguments: |
||||
// bufferLen - Length, in bytes, of total space to reserve |
||||
// (in device global memory) for output. |
||||
// |
||||
// Returns: |
||||
// cudaSuccess if all is well. |
||||
// |
||||
extern "C" cudaError_t cudaPrintfInit(size_t bufferLen=1048576); // 1-meg - that's enough for 4096 printfs by all threads put together |
||||
|
||||
// |
||||
// cudaPrintfEnd |
||||
// |
||||
// Cleans up all memories allocated by cudaPrintfInit(). |
||||
// Call this at exit, or before calling cudaPrintfInit() again. |
||||
// |
||||
extern "C" void cudaPrintfEnd(); |
||||
|
||||
// |
||||
// cudaPrintfDisplay |
||||
// |
||||
// Dumps the contents of the output buffer to the specified |
||||
// file pointer. If the output pointer is not specified, |
||||
// the default "stdout" is used. |
||||
// |
||||
// Arguments: |
||||
// outputFP - A file pointer to an output stream. |
||||
// showThreadID - If "true", output strings are prefixed |
||||
// by "[blockid, threadid] " at output. |
||||
// |
||||
// Returns: |
||||
// cudaSuccess if all is well. |
||||
// |
||||
extern "C" cudaError_t cudaPrintfDisplay(void *outputFP=NULL, bool showThreadID=false); |
||||
|
||||
#endif // CUPRINTF_H |
||||
@ -1,27 +0,0 @@ |
||||
#include "cuPrintf.cu" |
||||
#include <stdio.h> |
||||
|
||||
__global__ void device_greetings(void) |
||||
{ |
||||
cuPrintf("Hello, world from the device!\n"); |
||||
} |
||||
|
||||
int main(void) |
||||
{ |
||||
// greet from the host |
||||
printf("Hello, world from the host!\n"); |
||||
|
||||
// initialize cuPrintf |
||||
cudaPrintfInit(); |
||||
|
||||
// launch a kernel with a single thread to greet from the device |
||||
device_greetings<<<1,1>>>(); |
||||
|
||||
// display the device's greeting |
||||
cudaPrintfDisplay(); |
||||
|
||||
// clean up after cuPrintf |
||||
cudaPrintfEnd(); |
||||
|
||||
return 0; |
||||
} |
||||
@ -1,248 +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 FoundationUUU,either version 3 of the LicenseUUU,or |
||||
(at your option) any later version. |
||||
|
||||
cpp-ethereum is distributed in the hope that it will be usefulU, |
||||
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 notUUU,see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
/** @file nth_prime.h
|
||||
* @author Matthew Wampler-Doty <negacthulhu@gmail.com> |
||||
* @date 2015 |
||||
*/ |
||||
|
||||
// TODO: Update this after ~7 years
|
||||
|
||||
#pragma once |
||||
|
||||
#include <stdint.h> |
||||
//#include <Security/Security.h>
|
||||
#include "compiler.h" |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
#include <stdint.h> |
||||
|
||||
// 500 Epochs worth of tabulated DAG sizes (~3.5 Years)
|
||||
|
||||
// Generated with the following Mathematica Code:
|
||||
// GetDataSizes[n_] := Module[{
|
||||
// DAGSizeBytesInit = 2^30,
|
||||
// MixBytes = 128,
|
||||
// DAGGrowth = 113000000,
|
||||
// j = 0},
|
||||
// Reap[
|
||||
// While[j < n,
|
||||
// Module[{i =
|
||||
// Floor[(DAGSizeBytesInit + DAGGrowth * j) / MixBytes]},
|
||||
// While[! PrimeQ[i], i--];
|
||||
// Sow[i*MixBytes]; j++]]]][[2]][[1]]
|
||||
|
||||
static const size_t dag_sizes[] = { |
||||
1073739904U, 1186739584U, 1299741568U, 1412741248U, 1525741696U, |
||||
1638736768U, 1751741312U, 1864740736U, 1977740672U, 2090740864U, |
||||
2203740544U, 2316741248U, 2429739392U, 2542740352U, 2655741824U, |
||||
2768739712U, 2881740416U, 2994741632U, 3107740544U, 3220741504U, |
||||
3333738112U, 3446741632U, 3559741312U, 3672740224U, 3785740928U, |
||||
3898738304U, 4011741824U, 4124739712U, 4237735808U, 4350740864U, |
||||
4463741824U, 4576741504U, 4689741184U, 4802739328U, 4915741568U, |
||||
5028740224U, 5141740672U, 5254738304U, 5367741824U, 5480737664U, |
||||
5593738112U, 5706741632U, 5819740544U, 5932734592U, 6045739904U, |
||||
6158740096U, 6271740032U, 6384731776U, 6497732992U, 6610740352U, |
||||
6723741056U, 6836741504U, 6949740416U, 7062740096U, 7175741824U, |
||||
7288740224U, 7401741184U, 7514741632U, 7627741568U, 7740739712U, |
||||
7853739136U, 7966740352U, 8079741568U, 8192739712U, 8305738624U, |
||||
8418740864U, 8531740288U, 8644740736U, 8757735808U, 8870738816U, |
||||
8983739264U, 9096740992U, 9209740928U, 9322739584U, 9435741824U, |
||||
9548741504U, 9661739392U, 9774738304U, 9887741312U, 10000738688U, |
||||
10113739136U, 10226741632U, 10339739776U, 10452741248U, 10565740928U, |
||||
10678736512U, 10791734656U, 10904741248U, 11017738112U, 11130741632U, |
||||
11243741312U, 11356739456U, 11469740416U, 11582734976U, 11695739008U, |
||||
11808741248U, 11921734784U, 12034739072U, 12147741568U, 12260737408U, |
||||
12373741696U, 12486738304U, 12599740544U, 12712740224U, 12825741184U, |
||||
12938736256U, 13051741312U, 13164737408U, 13277738368U, 13390738048U, |
||||
13503741824U, 13616741504U, 13729737088U, 13842740096U, 13955741312U, |
||||
14068741504U, 14181740416U, 14294741632U, 14407739776U, 14520740224U, |
||||
14633740928U, 14746736512U, 14859741824U, 14972740736U, 15085740928U, |
||||
15198738304U, 15311732096U, 15424740736U, 15537739904U, 15650741632U, |
||||
15763741568U, 15876737152U, 15989741696U, 16102740608U, 16215741056U, |
||||
16328741248U, 16441740416U, 16554737792U, 16667740288U, 16780740992U, |
||||
16893738112U, 17006741632U, 17119739008U, 17232735616U, 17345739392U, |
||||
17458740352U, 17571736192U, 17684739712U, 17797739392U, 17910740096U, |
||||
18023741312U, 18136740736U, 18249738112U, 18362738816U, 18475735424U, |
||||
18588740224U, 18701738368U, 18814736768U, 18927737216U, 19040739968U, |
||||
19153739648U, 19266736768U, 19379737984U, 19492739456U, 19605738368U, |
||||
19718740352U, 19831741312U, 19944736384U, 20057741696U, 20170741376U, |
||||
20283741824U, 20396737408U, 20509741696U, 20622741376U, 20735739008U, |
||||
20848741504U, 20961740672U, 21074739328U, 21187740032U, 21300739456U, |
||||
21413741696U, 21526740608U, 21639741824U, 21752737408U, 21865741696U, |
||||
21978741376U, 22091741824U, 22204738432U, 22317740672U, 22430740096U, |
||||
22543736704U, 22656741248U, 22769739904U, 22882739584U, 22995740288U, |
||||
23108740736U, 23221740928U, 23334741376U, 23447737216U, 23560740992U, |
||||
23673741184U, 23786740864U, 23899737728U, 24012741248U, 24125734784U, |
||||
24238736512U, 24351741824U, 24464740736U, 24577737088U, 24690741632U, |
||||
24803739776U, 24916740736U, 25029740416U, 25142740864U, 25255741568U, |
||||
25368741248U, 25481740672U, 25594741376U, 25707741568U, 25820741504U, |
||||
25933730432U, 26046739072U, 26159741824U, 26272741504U, 26385740672U, |
||||
26498740096U, 26611741568U, 26724740992U, 26837739904U, 26950735232U, |
||||
27063738496U, 27176741248U, 27289741184U, 27402740864U, 27515740544U, |
||||
27628737152U, 27741740672U, 27854741632U, 27967740544U, 28080739712U, |
||||
28193738368U, 28306741376U, 28419737728U, 28532739968U, 28645739648U, |
||||
28758740096U, 28871741312U, 28984739456U, 29097740416U, 29210740864U, |
||||
29323741312U, 29436740224U, 29549741696U, 29662738304U, 29775741568U, |
||||
29888741504U, 30001740928U, 30114737024U, 30227735168U, 30340737664U, |
||||
30453738368U, 30566737024U, 30679733632U, 30792740224U, 30905740928U, |
||||
31018740352U, 31131740032U, 31244738944U, 31357737344U, 31470741376U, |
||||
31583740544U, 31696740224U, 31809738112U, 31922739328U, 32035737472U, |
||||
32148740992U, 32261741696U, 32374740352U, 32487741824U, 32600740736U, |
||||
32713739648U, 32826740608U, 32939729792U, 33052740992U, 33165740672U, |
||||
33278739584U, 33391741312U, 33504739712U, 33617740928U, 33730740608U, |
||||
33843738496U, 33956739968U, 34069741696U, 34182739328U, 34295741824U, |
||||
34408739968U, 34521740672U, 34634736512U, 34747741568U, 34860741248U, |
||||
34973739392U, 35086738304U, 35199741056U, 35312736896U, 35425741184U, |
||||
35538741376U, 35651740288U, 35764737152U, 35877741184U, 35990739584U, |
||||
36103740544U, 36216740992U, 36329739392U, 36442737536U, 36555741568U, |
||||
36668740736U, 36781741184U, 36894737024U, 37007741312U, 37120739456U, |
||||
37233741184U, 37346736256U, 37459736192U, 37572734336U, 37685739904U, |
||||
37798740352U, 37911737728U, 38024741504U, 38137739648U, 38250740608U, |
||||
38363741824U, 38476740992U, 38589741184U, 38702740096U, 38815741312U, |
||||
38928741248U, 39041738368U, 39154739584U, 39267741824U, 39380739712U, |
||||
39493735808U, 39606741632U, 39719741312U, 39832741504U, 39945739648U, |
||||
40058740352U, 40171740032U, 40284740992U, 40397740672U, 40510740352U, |
||||
40623740288U, 40736738176U, 40849737856U, 40962741376U, 41075739776U, |
||||
41188737664U, 41301735808U, 41414738048U, 41527741312U, 41640740992U, |
||||
41753739904U, 41866739072U, 41979738496U, 42092740736U, 42205739648U, |
||||
42318740608U, 42431741312U, 42544738688U, 42657741184U, 42770738048U, |
||||
42883741568U, 42996741248U, 43109740928U, 43222736512U, 43335741056U, |
||||
43448730496U, 43561740416U, 43674741632U, 43787740544U, 43900741504U, |
||||
44013739648U, 44126740864U, 44239740544U, 44352741248U, 44465738368U, |
||||
44578735232U, 44691739264U, 44804741504U, 44917741696U, 45030741376U, |
||||
45143741824U, 45256740992U, 45369739136U, 45482740096U, 45595739776U, |
||||
45708739712U, 45821740672U, 45934741376U, 46047741056U, 46160741248U, |
||||
46273737088U, 46386740864U, 46499739008U, 46612739968U, 46725735296U, |
||||
46838740864U, 46951741568U, 47064737152U, 47177741696U, 47290741376U, |
||||
47403738752U, 47516741248U, 47629739648U, 47742741632U, 47855737984U, |
||||
47968740224U, 48081738368U, 48194741632U, 48307739264U, 48420739712U, |
||||
48533739136U, 48646738304U, 48759741824U, 48872741504U, 48985739392U, |
||||
49098741376U, 49211741056U, 49324740992U, 49437738368U, 49550740864U, |
||||
49663735424U, 49776737408U, 49889740672U, 50002738816U, 50115738752U, |
||||
50228739712U, 50341741696U, 50454736768U, 50567738752U, 50680739968U, |
||||
50793736832U, 50906734976U, 51019741568U, 51132739456U, 51245741696U, |
||||
51358741376U, 51471741056U, 51584738944U, 51697734272U, 51810739072U, |
||||
51923736448U, 52036740736U, 52149741184U, 52262737024U, 52375738496U, |
||||
52488740992U, 52601739136U, 52714740352U, 52827736448U, 52940738176U, |
||||
53053741696U, 53166740864U, 53279741824U, 53392741504U, 53505739136U, |
||||
53618739584U, 53731741312U, 53844741248U, 53957741696U, 54070741376U, |
||||
54183740288U, 54296741504U, 54409741696U, 54522739072U, 54635737472U, |
||||
54748741504U, 54861736064U, 54974740096U, 55087741568U, 55200733568U, |
||||
55313741696U, 55426734464U, 55539741056U, 55652741504U, 55765741184U, |
||||
55878741376U, 55991730304U, 56104740992U, 56217740672U, 56330731648U, |
||||
56443737472U, 56556724352U, 56669740672U, 56782739072U, 56895740032U, |
||||
57008741248U, 57121741696U, 57234740096U, 57347741312U, 57460741504U |
||||
}; |
||||
|
||||
// 500 Epochs worth of tabulated DAG sizes (~3.5 Years)
|
||||
|
||||
// Generated with the following Mathematica Code:
|
||||
// GetCacheSizes[n_] := Module[{
|
||||
// DAGSizeBytesInit = 2^30,
|
||||
// MixBytes = 128,
|
||||
// DAGGrowth = 113000000,
|
||||
// HashBytes = 64,
|
||||
// DAGParents = 1024,
|
||||
// j = 0},
|
||||
// Reap[
|
||||
// While[j < n,
|
||||
// Module[{i = Floor[(DAGSizeBytesInit + DAGGrowth * j) / (DAGParents * HashBytes)]},
|
||||
// While[! PrimeQ[i], i--];
|
||||
// Sow[i*HashBytes]; j++]]]][[2]][[1]]
|
||||
|
||||
const size_t cache_sizes[] = { |
||||
1048384U, 1158208U, 1268416U, 1377856U, 1489856U, 1599296U, 1710656U, |
||||
1820608U, 1930816U, 2041024U, 2151872U, 2261696U, 2371904U, 2482624U, |
||||
2593216U, 2703296U, 2814016U, 2924224U, 3034816U, 3144896U, 3255488U, |
||||
3365312U, 3475904U, 3586624U, 3696064U, 3806272U, 3917504U, 4027456U, |
||||
4138304U, 4248512U, 4359104U, 4469312U, 4579264U, 4689728U, 4797376U, |
||||
4909888U, 5020096U, 5131328U, 5241664U, 5351744U, 5461312U, 5572544U, |
||||
5683264U, 5793472U, 5903552U, 6014144U, 6121664U, 6235072U, 6344896U, |
||||
6454592U, 6565952U, 6675904U, 6786112U, 6896704U, 7006784U, 7117888U, |
||||
7228096U, 7338304U, 7448768U, 7557952U, 7669184U, 7779776U, 7889216U, |
||||
8000192U, 8110912U, 8220736U, 8331712U, 8441536U, 8552384U, 8662592U, |
||||
8772928U, 8883136U, 8993728U, 9103168U, 9214528U, 9323968U, 9434816U, |
||||
9545152U, 9655616U, 9766336U, 9876544U, 9986624U, 10097344U, 10207424U, |
||||
10316864U, 10427968U, 10538432U, 10649152U, 10758976U, 10869568U, 10979776U, |
||||
11089472U, 11200832U, 11309632U, 11420608U, 11531584U, 11641792U, 11751104U, |
||||
11862976U, 11973184U, 12083264U, 12193856U, 12304064U, 12414656U, 12524608U, |
||||
12635072U, 12745792U, 12855616U, 12965824U, 13076416U, 13187008U, 13297216U, |
||||
13407808U, 13518016U, 13627072U, 13738688U, 13848256U, 13959488U, 14069696U, |
||||
14180288U, 14290624U, 14399552U, 14511424U, 14621504U, 14732096U, 14841664U, |
||||
14951744U, 15062336U, 15172672U, 15283264U, 15393088U, 15504448U, 15614272U, |
||||
15723712U, 15834944U, 15945152U, 16055744U, 16165696U, 16277056U, 16387136U, |
||||
16494784U, 16607936U, 16718272U, 16828736U, 16938176U, 17048384U, 17159872U, |
||||
17266624U, 17380544U, 17490496U, 17600192U, 17711296U, 17821376U, 17931968U, |
||||
18041152U, 18152896U, 18261952U, 18373568U, 18483392U, 18594112U, 18703936U, |
||||
18814912U, 18924992U, 19034944U, 19145408U, 19256128U, 19366208U, 19477184U, |
||||
19587136U, 19696576U, 19808192U, 19916992U, 20028352U, 20137664U, 20249024U, |
||||
20358848U, 20470336U, 20580544U, 20689472U, 20801344U, 20911424U, 21020096U, |
||||
21130688U, 21242176U, 21352384U, 21462208U, 21573824U, 21683392U, 21794624U, |
||||
21904448U, 22013632U, 22125248U, 22235968U, 22344512U, 22456768U, 22566848U, |
||||
22677056U, 22786496U, 22897984U, 23008064U, 23118272U, 23228992U, 23338816U, |
||||
23449408U, 23560256U, 23670464U, 23780672U, 23891264U, 24001216U, 24110656U, |
||||
24221888U, 24332608U, 24442688U, 24552512U, 24662464U, 24773696U, 24884032U, |
||||
24994496U, 25105216U, 25215296U, 25324864U, 25435712U, 25546432U, 25655744U, |
||||
25767232U, 25876672U, 25986368U, 26098112U, 26207936U, 26318912U, 26428736U, |
||||
26539712U, 26650048U, 26760256U, 26869184U, 26979776U, 27091136U, 27201728U, |
||||
27311552U, 27422272U, 27532352U, 27642304U, 27752896U, 27863744U, 27973952U, |
||||
28082752U, 28194752U, 28305344U, 28415168U, 28524992U, 28636352U, 28746304U, |
||||
28857152U, 28967104U, 29077184U, 29187904U, 29298496U, 29408576U, 29518912U, |
||||
29628992U, 29739968U, 29850176U, 29960512U, 30070336U, 30180544U, 30290752U, |
||||
30398912U, 30512192U, 30622784U, 30732992U, 30842176U, 30953536U, 31063744U, |
||||
31174336U, 31284544U, 31395136U, 31504448U, 31615552U, 31725632U, 31835072U, |
||||
31946176U, 32057024U, 32167232U, 32277568U, 32387008U, 32497984U, 32608832U, |
||||
32719168U, 32829376U, 32939584U, 33050048U, 33160768U, 33271232U, 33381184U, |
||||
33491648U, 33601856U, 33712576U, 33822016U, 33932992U, 34042816U, 34153024U, |
||||
34263104U, 34373824U, 34485056U, 34594624U, 34704832U, 34816064U, 34926272U, |
||||
35036224U, 35146816U, 35255104U, 35367104U, 35478208U, 35588416U, 35698496U, |
||||
35808832U, 35918656U, 36029888U, 36139456U, 36250688U, 36360512U, 36471104U, |
||||
36581696U, 36691136U, 36802112U, 36912448U, 37022912U, 37132864U, 37242944U, |
||||
37354048U, 37464512U, 37574848U, 37684928U, 37794752U, 37904704U, 38015552U, |
||||
38125888U, 38236864U, 38345792U, 38457152U, 38567744U, 38678336U, 38787776U, |
||||
38897216U, 39009088U, 39117632U, 39230144U, 39340352U, 39450304U, 39560384U, |
||||
39671488U, 39781312U, 39891392U, 40002112U, 40112704U, 40223168U, 40332608U, |
||||
40443968U, 40553792U, 40664768U, 40774208U, 40884416U, 40993984U, 41105984U, |
||||
41215424U, 41326528U, 41436992U, 41546048U, 41655872U, 41768128U, 41878336U, |
||||
41988928U, 42098752U, 42209344U, 42319168U, 42429248U, 42540352U, 42649792U, |
||||
42761024U, 42871616U, 42981824U, 43092032U, 43201856U, 43312832U, 43423552U, |
||||
43533632U, 43643584U, 43753792U, 43864384U, 43974976U, 44084032U, 44195392U, |
||||
44306368U, 44415296U, 44526016U, 44637248U, 44746816U, 44858048U, 44967872U, |
||||
45078848U, 45188288U, 45299264U, 45409216U, 45518272U, 45630272U, 45740224U, |
||||
45850432U, 45960896U, 46069696U, 46182208U, 46292416U, 46402624U, 46512064U, |
||||
46623296U, 46733888U, 46843712U, 46953664U, 47065024U, 47175104U, 47285696U, |
||||
47395904U, 47506496U, 47615296U, 47726912U, 47837632U, 47947712U, 48055232U, |
||||
48168128U, 48277952U, 48387392U, 48499648U, 48609472U, 48720064U, 48830272U, |
||||
48940096U, 49050944U, 49160896U, 49271744U, 49381568U, 49492288U, 49602752U, |
||||
49712576U, 49822016U, 49934272U, 50042816U, 50154304U, 50264128U, 50374336U, |
||||
50484416U, 50596288U, 50706752U, 50816704U, 50927168U, 51035456U, 51146944U, |
||||
51258176U, 51366976U, 51477824U, 51589568U, 51699776U, 51809728U, 51920576U, |
||||
52030016U, 52140736U, 52251328U, 52361152U, 52470592U, 52582592U, 52691776U, |
||||
52803136U, 52912576U, 53020736U, 53132224U, 53242688U, 53354816U, 53465536U, |
||||
53575232U, 53685568U, 53796544U, 53906752U, 54016832U, 54126656U, 54236992U, |
||||
54347456U, 54457408U, 54569024U, 54679232U, 54789184U, 54899776U, 55008832U, |
||||
55119296U, 55231168U, 55341248U, 55451584U, 55562048U, 55672256U, 55782208U, |
||||
55893184U, 56002112U, 56113216U |
||||
}; |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
@ -1,29 +0,0 @@ |
||||
{ |
||||
"targets": |
||||
[{ |
||||
"target_name": "ethash", |
||||
"sources": [ |
||||
'./ethash.cc', |
||||
'../libethash/ethash.h', |
||||
'../libethash/util.c', |
||||
'../libethash/util.h', |
||||
'../libethash/blum_blum_shub.h', |
||||
'../libethash/blum_blum_shub.c', |
||||
'../libethash/sha3.h', |
||||
'../libethash/sha3.c', |
||||
'../libethash/internal.h', |
||||
'../libethash/internal.c' |
||||
], |
||||
"include_dirs": [ |
||||
"../", |
||||
"<!(node -e \"require('nan')\")" |
||||
], |
||||
"cflags": [ |
||||
"-Wall", |
||||
"-Wno-maybe-uninitialized", |
||||
"-Wno-uninitialized", |
||||
"-Wno-unused-function", |
||||
"-Wextra" |
||||
] |
||||
}] |
||||
} |
||||
@ -1,587 +0,0 @@ |
||||
#include <nan.h> |
||||
#include <iostream> |
||||
#include <node.h> |
||||
#include <stdint.h> |
||||
#include <stdlib.h> |
||||
#include "../libethash/ethash.h" |
||||
|
||||
using namespace v8; |
||||
|
||||
class EthashValidator : public NanAsyncWorker { |
||||
public: |
||||
// Constructor
|
||||
EthashValidator(NanCallback *callback, const unsigned blocknumber, const unsigned char * seed) |
||||
: NanAsyncWorker(callback), blocknumber(blocknumber), seed(seed) {} |
||||
// Destructor
|
||||
~EthashValidator() { |
||||
free(this->cache); |
||||
free(this->params); |
||||
} |
||||
|
||||
// Executed inside the worker-thread.
|
||||
// It is not safe to access V8, or V8 data structures
|
||||
// here, so everything we need for input and output
|
||||
// should go on `this`.
|
||||
void Execute () { |
||||
|
||||
/* this->result = secp256k1_ecdsa_sign(this->msg, this->sig , &this->sig_len, this->pk, NULL, NULL); */ |
||||
} |
||||
|
||||
// Executed when the async work is complete
|
||||
// this function will be run inside the main event loop
|
||||
// so it is safe to use V8 again
|
||||
void HandleOKCallback () { |
||||
NanScope(); |
||||
Handle<Value> argv[] = { |
||||
NanNew<Number>(this->result) |
||||
}; |
||||
callback->Call(2, argv); |
||||
} |
||||
|
||||
protected: |
||||
const unsigned blocknumber;
|
||||
const unsigned char * seed; |
||||
ethash_params * params; |
||||
ethash_cache * cache; |
||||
bool result; |
||||
bool ready = 0; |
||||
}; |
||||
|
||||
/* class CompactSignWorker : public SignWorker { */ |
||||
/* public: */ |
||||
/* CompactSignWorker(NanCallback *callback, const unsigned char *msg, const unsigned char *pk ) */ |
||||
/* : SignWorker(callback, msg, pk){} */ |
||||
|
||||
/* void Execute () { */ |
||||
/* this->result = secp256k1_ecdsa_sign_compact(this->msg, this->sig , this->pk, NULL, NULL, &this->sig_len); */ |
||||
/* } */ |
||||
|
||||
/* void HandleOKCallback () { */ |
||||
/* NanScope(); */ |
||||
/* Handle<Value> argv[] = { */ |
||||
/* NanNew<Number>(this->result), */ |
||||
/* NanNewBufferHandle((char *)this->sig, 64), */ |
||||
/* NanNew<Number>(this->sig_len) */ |
||||
/* }; */ |
||||
/* callback->Call(3, argv); */ |
||||
/* } */ |
||||
/* }; */ |
||||
|
||||
/* class RecoverWorker : public NanAsyncWorker { */ |
||||
/* public: */ |
||||
/* // Constructor */ |
||||
/* RecoverWorker(NanCallback *callback, const unsigned char *msg, const unsigned char *sig, int compressed, int rec_id) */ |
||||
/* : NanAsyncWorker(callback), msg(msg), sig(sig), compressed(compressed), rec_id(rec_id) {} */ |
||||
/* // Destructor */ |
||||
/* ~RecoverWorker() {} */ |
||||
|
||||
/* void Execute () { */ |
||||
/* if(this->compressed == 1){ */ |
||||
/* this->pubkey = new unsigned char[33]; */
|
||||
/* }else{ */ |
||||
/* this->pubkey = new unsigned char[65]; */
|
||||
/* } */ |
||||
|
||||
/* this->result = secp256k1_ecdsa_recover_compact(this->msg, this->sig, this->pubkey, &this->pubkey_len, this->compressed, this->rec_id); */ |
||||
/* } */ |
||||
|
||||
/* void HandleOKCallback () { */ |
||||
/* NanScope(); */ |
||||
/* Handle<Value> argv[] = { */ |
||||
/* NanNew<Number>(this->result), */ |
||||
/* NanNewBufferHandle((char *)this->pubkey, this->pubkey_len) */ |
||||
/* }; */ |
||||
/* callback->Call(2, argv); */ |
||||
/* } */ |
||||
|
||||
/* protected: */ |
||||
/* const unsigned char * msg; */ |
||||
/* const unsigned char * sig; */
|
||||
/* int compressed; */ |
||||
/* int rec_id; */ |
||||
/* int result; */ |
||||
/* unsigned char * pubkey; */ |
||||
/* int pubkey_len; */ |
||||
/* }; */ |
||||
|
||||
/* class VerifyWorker : public NanAsyncWorker { */ |
||||
/* public: */ |
||||
/* // Constructor */ |
||||
/* VerifyWorker(NanCallback *callback, const unsigned char *msg, const unsigned char *sig, int sig_len, const unsigned char *pub_key, int pub_key_len) */ |
||||
/* : NanAsyncWorker(callback), msg(msg), sig(sig), sig_len(sig_len), pub_key(pub_key), pub_key_len(pub_key_len) {} */ |
||||
/* // Destructor */ |
||||
/* ~VerifyWorker() {} */ |
||||
|
||||
/* void Execute () { */ |
||||
/* this->result = secp256k1_ecdsa_verify(this->msg, this->sig, this->sig_len, this->pub_key, this->pub_key_len); */ |
||||
/* } */ |
||||
|
||||
/* void HandleOKCallback () { */ |
||||
/* NanScope(); */ |
||||
/* Handle<Value> argv[] = { */ |
||||
/* NanNew<Number>(this->result), */ |
||||
/* }; */ |
||||
/* callback->Call(1, argv); */ |
||||
/* } */ |
||||
|
||||
/* protected: */ |
||||
/* int result; */ |
||||
/* const unsigned char * msg; */ |
||||
/* const unsigned char * sig; */ |
||||
/* int sig_len; */
|
||||
/* const unsigned char * pub_key; */ |
||||
/* int pub_key_len; */ |
||||
/* }; */ |
||||
|
||||
/* NAN_METHOD(Verify){ */ |
||||
/* NanScope(); */ |
||||
|
||||
/* Local<Object> pub_buf = args[0].As<Object>(); */ |
||||
/* const unsigned char *pub_data = (unsigned char *) node::Buffer::Data(pub_buf); */ |
||||
/* int pub_len = node::Buffer::Length(args[0]); */ |
||||
|
||||
/* Local<Object> msg_buf = args[1].As<Object>(); */ |
||||
/* const unsigned char *msg_data = (unsigned char *) node::Buffer::Data(msg_buf); */ |
||||
|
||||
/* Local<Object> sig_buf = args[2].As<Object>(); */ |
||||
/* const unsigned char *sig_data = (unsigned char *) node::Buffer::Data(sig_buf); */ |
||||
/* int sig_len = node::Buffer::Length(args[2]); */ |
||||
|
||||
/* int result = secp256k1_ecdsa_verify(msg_data, sig_data, sig_len, pub_data, pub_len ); */
|
||||
|
||||
/* NanReturnValue(NanNew<Number>(result)); */ |
||||
/* } */ |
||||
|
||||
/* NAN_METHOD(Verify_Async){ */ |
||||
/* NanScope(); */ |
||||
|
||||
/* Local<Object> pub_buf = args[0].As<Object>(); */ |
||||
/* const unsigned char *pub_data = (unsigned char *) node::Buffer::Data(pub_buf); */ |
||||
/* int pub_len = node::Buffer::Length(args[0]); */ |
||||
|
||||
/* Local<Object> msg_buf = args[1].As<Object>(); */ |
||||
/* const unsigned char *msg_data = (unsigned char *) node::Buffer::Data(msg_buf); */ |
||||
|
||||
/* Local<Object> sig_buf = args[2].As<Object>(); */ |
||||
/* const unsigned char *sig_data = (unsigned char *) node::Buffer::Data(sig_buf); */ |
||||
/* int sig_len = node::Buffer::Length(args[2]); */ |
||||
|
||||
/* Local<Function> callback = args[3].As<Function>(); */ |
||||
/* NanCallback* nanCallback = new NanCallback(callback); */ |
||||
|
||||
/* VerifyWorker* worker = new VerifyWorker(nanCallback, msg_data, sig_data, sig_len, pub_data, pub_len); */ |
||||
/* NanAsyncQueueWorker(worker); */ |
||||
|
||||
/* NanReturnUndefined(); */ |
||||
/* } */ |
||||
|
||||
/* NAN_METHOD(Sign){ */ |
||||
/* NanScope(); */ |
||||
|
||||
/* //the first argument should be the private key as a buffer */ |
||||
/* Local<Object> pk_buf = args[0].As<Object>(); */ |
||||
/* const unsigned char *pk_data = (unsigned char *) node::Buffer::Data(pk_buf); */ |
||||
/* int sec_len = node::Buffer::Length(args[0]); */ |
||||
/* //the second argument is the message that we are signing */ |
||||
/* Local<Object> msg_buf = args[1].As<Object>(); */ |
||||
/* const unsigned char *msg_data = (unsigned char *) node::Buffer::Data(msg_buf); */ |
||||
|
||||
/* unsigned char sig[72]; */ |
||||
/* int sig_len = 72; */ |
||||
/* int msg_len = node::Buffer::Length(args[1]); */ |
||||
|
||||
/* if(sec_len != 32){ */ |
||||
/* return NanThrowError("the secret key needs tobe 32 bytes"); */ |
||||
/* } */ |
||||
|
||||
/* if(msg_len == 0){ */ |
||||
/* return NanThrowError("messgae cannot be null"); */
|
||||
/* } */ |
||||
|
||||
/* int result = secp256k1_ecdsa_sign(msg_data, sig , &sig_len, pk_data, NULL, NULL); */ |
||||
|
||||
/* if(result == 1){ */ |
||||
/* NanReturnValue(NanNewBufferHandle((char *)sig, sig_len)); */ |
||||
/* }else{ */ |
||||
/* return NanThrowError("nonce invalid, try another one"); */ |
||||
/* } */ |
||||
/* } */ |
||||
|
||||
/* NAN_METHOD(Sign_Async){ */ |
||||
|
||||
/* NanScope(); */ |
||||
/* //the first argument should be the private key as a buffer */ |
||||
/* Local<Object> sec_buf = args[0].As<Object>(); */ |
||||
/* const unsigned char *sec_data = (unsigned char *) node::Buffer::Data(sec_buf); */ |
||||
/* int sec_len = node::Buffer::Length(args[0]); */ |
||||
/* //the second argument is the message that we are signing */ |
||||
/* Local<Object> msg_buf = args[1].As<Object>(); */ |
||||
/* const unsigned char *msg_data = (unsigned char *) node::Buffer::Data(msg_buf); */ |
||||
|
||||
/* Local<Function> callback = args[2].As<Function>(); */ |
||||
/* NanCallback* nanCallback = new NanCallback(callback); */ |
||||
|
||||
/* int msg_len = node::Buffer::Length(args[1]); */ |
||||
|
||||
/* if(sec_len != 32){ */ |
||||
/* return NanThrowError("the secret key needs tobe 32 bytes"); */ |
||||
/* } */ |
||||
|
||||
/* if(msg_len == 0){ */ |
||||
/* return NanThrowError("messgae cannot be null"); */
|
||||
/* } */ |
||||
|
||||
/* SignWorker* worker = new SignWorker(nanCallback, msg_data, sec_data); */ |
||||
/* NanAsyncQueueWorker(worker); */ |
||||
|
||||
/* NanReturnUndefined(); */ |
||||
/* } */ |
||||
|
||||
/* NAN_METHOD(Sign_Compact){ */ |
||||
|
||||
/* NanScope(); */ |
||||
|
||||
/* Local<Object> seckey_buf = args[0].As<Object>(); */ |
||||
/* const unsigned char *seckey_data = (unsigned char *) node::Buffer::Data(seckey_buf); */ |
||||
/* int sec_len = node::Buffer::Length(args[0]); */ |
||||
|
||||
/* Local<Object> msg_buf = args[1].As<Object>(); */ |
||||
/* const unsigned char *msg_data = (unsigned char *) node::Buffer::Data(msg_buf); */ |
||||
/* int msg_len = node::Buffer::Length(args[1]); */ |
||||
|
||||
/* if(sec_len != 32){ */ |
||||
/* return NanThrowError("the secret key needs tobe 32 bytes"); */ |
||||
/* } */ |
||||
|
||||
/* if(msg_len == 0){ */ |
||||
/* return NanThrowError("messgae cannot be null"); */
|
||||
/* } */ |
||||
|
||||
/* unsigned char sig[64]; */ |
||||
/* int rec_id; */ |
||||
|
||||
/* //TODO: change the nonce */ |
||||
/* int valid_nonce = secp256k1_ecdsa_sign_compact(msg_data, sig, seckey_data, NULL, NULL, &rec_id ); */ |
||||
|
||||
/* Local<Array> array = NanNew<Array>(3); */ |
||||
/* array->Set(0, NanNew<Integer>(valid_nonce)); */ |
||||
/* array->Set(1, NanNew<Integer>(rec_id)); */ |
||||
/* array->Set(2, NanNewBufferHandle((char *)sig, 64)); */ |
||||
|
||||
/* NanReturnValue(array); */ |
||||
/* } */ |
||||
|
||||
/* NAN_METHOD(Sign_Compact_Async){ */ |
||||
/* NanScope(); */ |
||||
/* //the first argument should be the private key as a buffer */ |
||||
/* Local<Object> sec_buf = args[0].As<Object>(); */ |
||||
/* const unsigned char *sec_data = (unsigned char *) node::Buffer::Data(sec_buf); */ |
||||
/* int sec_len = node::Buffer::Length(args[0]); */ |
||||
|
||||
/* //the second argument is the message that we are signing */ |
||||
/* Local<Object> msg_buf = args[1].As<Object>(); */ |
||||
/* const unsigned char *msg_data = (unsigned char *) node::Buffer::Data(msg_buf); */ |
||||
|
||||
|
||||
/* Local<Function> callback = args[2].As<Function>(); */ |
||||
/* NanCallback* nanCallback = new NanCallback(callback); */ |
||||
|
||||
/* int msg_len = node::Buffer::Length(args[1]); */ |
||||
|
||||
/* if(sec_len != 32){ */ |
||||
/* return NanThrowError("the secret key needs tobe 32 bytes"); */ |
||||
/* } */ |
||||
|
||||
/* if(msg_len == 0){ */ |
||||
/* return NanThrowError("messgae cannot be null"); */
|
||||
/* } */ |
||||
|
||||
/* CompactSignWorker* worker = new CompactSignWorker(nanCallback, msg_data, sec_data); */
|
||||
/* NanAsyncQueueWorker(worker); */ |
||||
|
||||
/* NanReturnUndefined(); */ |
||||
/* } */ |
||||
|
||||
/* NAN_METHOD(Recover_Compact){ */ |
||||
|
||||
/* NanScope(); */ |
||||
|
||||
/* Local<Object> msg_buf = args[0].As<Object>(); */ |
||||
/* const unsigned char *msg = (unsigned char *) node::Buffer::Data(msg_buf); */ |
||||
/* int msg_len = node::Buffer::Length(args[0]); */ |
||||
|
||||
/* Local<Object> sig_buf = args[1].As<Object>(); */ |
||||
/* const unsigned char *sig = (unsigned char *) node::Buffer::Data(sig_buf); */ |
||||
|
||||
/* Local<Number> compressed = args[2].As<Number>(); */ |
||||
/* int int_compressed = compressed->IntegerValue(); */ |
||||
|
||||
/* Local<Number> rec_id = args[3].As<Number>(); */ |
||||
/* int int_rec_id = rec_id->IntegerValue(); */ |
||||
|
||||
/* if(msg_len == 0){ */ |
||||
/* return NanThrowError("messgae cannot be null"); */
|
||||
/* } */ |
||||
|
||||
/* unsigned char pubKey[65]; */
|
||||
|
||||
/* int pubKeyLen; */ |
||||
|
||||
/* int result = secp256k1_ecdsa_recover_compact(msg, sig, pubKey, &pubKeyLen, int_compressed, int_rec_id); */ |
||||
/* if(result == 1){ */ |
||||
/* NanReturnValue(NanNewBufferHandle((char *)pubKey, pubKeyLen)); */ |
||||
/* }else{ */ |
||||
|
||||
/* NanReturnValue(NanFalse()); */ |
||||
/* } */ |
||||
/* } */ |
||||
|
||||
/* NAN_METHOD(Recover_Compact_Async){ */ |
||||
|
||||
/* NanScope(); */ |
||||
|
||||
/* //the message */ |
||||
/* Local<Object> msg_buf = args[0].As<Object>(); */ |
||||
/* const unsigned char *msg = (unsigned char *) node::Buffer::Data(msg_buf); */ |
||||
/* int msg_len = node::Buffer::Length(args[0]); */ |
||||
|
||||
/* //the signature length */ |
||||
/* Local<Object> sig_buf = args[1].As<Object>(); */ |
||||
/* const unsigned char *sig = (unsigned char *) node::Buffer::Data(sig_buf); */ |
||||
/* //todo sig len needs tobe 64 */ |
||||
/* int sig_len = node::Buffer::Length(args[1]); */ |
||||
|
||||
/* //to compress or not? */ |
||||
/* Local<Number> compressed = args[2].As<Number>(); */ |
||||
/* int int_compressed = compressed->IntegerValue(); */ |
||||
|
||||
/* //the rec_id */ |
||||
/* Local<Number> rec_id = args[3].As<Number>(); */ |
||||
/* int int_rec_id = rec_id->IntegerValue(); */ |
||||
|
||||
/* //the callback */ |
||||
/* Local<Function> callback = args[4].As<Function>(); */ |
||||
/* NanCallback* nanCallback = new NanCallback(callback); */ |
||||
|
||||
/* if(sig_len != 64){ */ |
||||
/* return NanThrowError("the signature needs to be 64 bytes"); */ |
||||
/* } */ |
||||
|
||||
/* if(msg_len == 0){ */ |
||||
/* return NanThrowError("messgae cannot be null"); */
|
||||
/* } */ |
||||
|
||||
/* RecoverWorker* worker = new RecoverWorker(nanCallback, msg, sig, int_compressed, int_rec_id); */ |
||||
/* NanAsyncQueueWorker(worker); */ |
||||
|
||||
/* NanReturnUndefined(); */ |
||||
/* } */ |
||||
|
||||
/* NAN_METHOD(Seckey_Verify){ */ |
||||
/* NanScope(); */ |
||||
|
||||
/* const unsigned char *data = (const unsigned char*) node::Buffer::Data(args[0]); */ |
||||
/* int result = secp256k1_ec_seckey_verify(data); */
|
||||
/* NanReturnValue(NanNew<Number>(result)); */
|
||||
/* } */ |
||||
|
||||
/* NAN_METHOD(Pubkey_Verify){ */ |
||||
|
||||
/* NanScope(); */ |
||||
|
||||
/* Local<Object> pub_buf = args[0].As<Object>(); */ |
||||
/* const unsigned char *pub_key = (unsigned char *) node::Buffer::Data(pub_buf); */ |
||||
/* int pub_key_len = node::Buffer::Length(args[0]); */ |
||||
|
||||
/* int result = secp256k1_ec_pubkey_verify(pub_key, pub_key_len); */ |
||||
|
||||
/* NanReturnValue(NanNew<Number>(result)); */
|
||||
/* } */ |
||||
|
||||
/* NAN_METHOD(Pubkey_Create){ */ |
||||
/* NanScope(); */ |
||||
|
||||
/* Handle<Object> pk_buf = args[0].As<Object>(); */ |
||||
/* const unsigned char *pk_data = (unsigned char *) node::Buffer::Data(pk_buf); */ |
||||
/* int pk_len = node::Buffer::Length(args[0]); */ |
||||
|
||||
/* Local<Number> l_compact = args[1].As<Number>(); */ |
||||
/* int compact = l_compact->IntegerValue(); */ |
||||
/* int pubKeyLen; */ |
||||
|
||||
/* if(pk_len != 32){ */ |
||||
/* return NanThrowError("the secert key need to be 32 bytes"); */ |
||||
/* } */ |
||||
|
||||
/* unsigned char *pubKey; */ |
||||
/* if(compact == 1){ */ |
||||
/* pubKey = new unsigned char[33]; */
|
||||
/* }else{ */ |
||||
/* pubKey = new unsigned char[65]; */
|
||||
/* } */ |
||||
|
||||
/* int results = secp256k1_ec_pubkey_create(pubKey,&pubKeyLen, pk_data, compact ); */ |
||||
/* if(results == 0){ */ |
||||
/* return NanThrowError("secret was invalid, try again."); */ |
||||
/* }else{ */ |
||||
/* NanReturnValue(NanNewBufferHandle((char *)pubKey, pubKeyLen)); */ |
||||
/* } */ |
||||
/* } */ |
||||
|
||||
/* NAN_METHOD(Pubkey_Decompress){ */ |
||||
/* NanScope(); */ |
||||
|
||||
/* //the first argument should be the private key as a buffer */ |
||||
/* Local<Object> pk_buf = args[0].As<Object>(); */ |
||||
/* unsigned char *pk_data = (unsigned char *) node::Buffer::Data(pk_buf); */ |
||||
|
||||
/* int pk_len = node::Buffer::Length(args[0]); */ |
||||
|
||||
/* int results = secp256k1_ec_pubkey_decompress(pk_data, &pk_len); */ |
||||
|
||||
/* if(results == 0){ */ |
||||
/* return NanThrowError("invalid public key"); */ |
||||
/* }else{ */ |
||||
/* NanReturnValue(NanNewBufferHandle((char *)pk_data, pk_len)); */ |
||||
/* } */ |
||||
/* } */ |
||||
|
||||
|
||||
/* NAN_METHOD(Privkey_Import){ */ |
||||
/* NanScope(); */ |
||||
|
||||
/* //the first argument should be the private key as a buffer */ |
||||
/* Handle<Object> pk_buf = args[0].As<Object>(); */ |
||||
/* const unsigned char *pk_data = (unsigned char *) node::Buffer::Data(pk_buf); */ |
||||
|
||||
/* int pk_len = node::Buffer::Length(args[0]); */ |
||||
|
||||
/* unsigned char sec_key[32]; */ |
||||
/* int results = secp256k1_ec_privkey_import(sec_key, pk_data, pk_len); */ |
||||
|
||||
/* if(results == 0){ */ |
||||
/* return NanThrowError("invalid private key"); */ |
||||
/* }else{ */ |
||||
/* NanReturnValue(NanNewBufferHandle((char *)sec_key, 32)); */ |
||||
/* } */ |
||||
/* } */ |
||||
|
||||
/* NAN_METHOD(Privkey_Export){ */ |
||||
/* NanScope(); */ |
||||
|
||||
/* //the first argument should be the private key as a buffer */ |
||||
/* Handle<Object> sk_buf = args[0].As<Object>(); */ |
||||
/* const unsigned char *sk_data = (unsigned char *) node::Buffer::Data(sk_buf); */ |
||||
|
||||
/* Local<Number> l_compressed = args[1].As<Number>(); */ |
||||
/* int compressed = l_compressed->IntegerValue(); */ |
||||
|
||||
/* unsigned char *privKey; */ |
||||
/* int pk_len; */ |
||||
/* int results = secp256k1_ec_privkey_export(sk_data, privKey, &pk_len, compressed); */ |
||||
/* if(results == 0){ */ |
||||
/* return NanThrowError("invalid private key"); */ |
||||
/* }else{ */ |
||||
/* NanReturnValue(NanNewBufferHandle((char *)privKey, pk_len)); */ |
||||
/* } */ |
||||
/* } */ |
||||
|
||||
/* NAN_METHOD(Privkey_Tweak_Add){ */ |
||||
/* NanScope(); */ |
||||
|
||||
/* //the first argument should be the private key as a buffer */ |
||||
/* Handle<Object> sk_buf = args[0].As<Object>(); */ |
||||
/* unsigned char *sk = (unsigned char *) node::Buffer::Data(sk_buf); */ |
||||
|
||||
/* Handle<Object> tweak_buf = args[1].As<Object>(); */ |
||||
/* const unsigned char *tweak= (unsigned char *) node::Buffer::Data(tweak_buf); */ |
||||
|
||||
/* int results = secp256k1_ec_privkey_tweak_add(sk, tweak); */ |
||||
/* if(results == 0){ */ |
||||
/* return NanThrowError("invalid key"); */ |
||||
/* }else{ */ |
||||
/* NanReturnValue(NanNewBufferHandle((char *)sk, 32)); */ |
||||
/* } */ |
||||
/* } */ |
||||
|
||||
/* NAN_METHOD(Privkey_Tweak_Mul){ */ |
||||
/* NanScope(); */ |
||||
|
||||
/* //the first argument should be the private key as a buffer */ |
||||
/* Handle<Object> sk_buf = args[0].As<Object>(); */ |
||||
/* unsigned char *sk = (unsigned char *) node::Buffer::Data(sk_buf); */ |
||||
|
||||
/* Handle<Object> tweak_buf = args[1].As<Object>(); */ |
||||
/* const unsigned char *tweak= (unsigned char *) node::Buffer::Data(tweak_buf); */ |
||||
|
||||
/* int results = secp256k1_ec_privkey_tweak_mul(sk, tweak); */ |
||||
/* if(results == 0){ */ |
||||
/* return NanThrowError("invalid key"); */ |
||||
/* }else{ */ |
||||
/* NanReturnValue(NanNewBufferHandle((char *)sk, 32)); */ |
||||
/* } */ |
||||
/* } */ |
||||
|
||||
/* NAN_METHOD(Pubkey_Tweak_Add){ */ |
||||
/* NanScope(); */ |
||||
|
||||
/* //the first argument should be the private key as a buffer */ |
||||
/* Handle<Object> pk_buf = args[0].As<Object>(); */ |
||||
/* unsigned char *pk = (unsigned char *) node::Buffer::Data(pk_buf); */ |
||||
/* int pk_len = node::Buffer::Length(args[0]); */ |
||||
|
||||
/* Handle<Object> tweak_buf = args[1].As<Object>(); */ |
||||
/* const unsigned char *tweak= (unsigned char *) node::Buffer::Data(tweak_buf); */ |
||||
|
||||
/* int results = secp256k1_ec_pubkey_tweak_add(pk, pk_len, tweak); */ |
||||
/* if(results == 0){ */ |
||||
/* return NanThrowError("invalid key"); */ |
||||
/* }else{ */ |
||||
/* NanReturnValue(NanNewBufferHandle((char *)pk, pk_len)); */ |
||||
/* } */ |
||||
/* } */ |
||||
|
||||
/* NAN_METHOD(Pubkey_Tweak_Mul){ */ |
||||
/* NanScope(); */ |
||||
|
||||
/* //the first argument should be the private key as a buffer */ |
||||
/* Handle<Object> pk_buf = args[0].As<Object>(); */ |
||||
/* unsigned char *pk = (unsigned char *) node::Buffer::Data(pk_buf); */ |
||||
/* int pk_len = node::Buffer::Length(args[0]); */ |
||||
|
||||
/* Handle<Object> tweak_buf = args[1].As<Object>(); */ |
||||
/* const unsigned char *tweak= (unsigned char *) node::Buffer::Data(tweak_buf); */ |
||||
|
||||
/* int results = secp256k1_ec_pubkey_tweak_mul(pk, pk_len, tweak); */ |
||||
/* if(results == 0){ */ |
||||
/* return NanThrowError("invalid key"); */ |
||||
/* }else{ */ |
||||
/* NanReturnValue(NanNewBufferHandle((char *)pk, pk_len)); */ |
||||
/* } */ |
||||
/* } */ |
||||
|
||||
void Init(Handle<Object> exports) { |
||||
|
||||
/* secp256k1_start(SECP256K1_START_SIGN | SECP256K1_START_VERIFY); */ |
||||
/* exports->Set(NanNew("seckeyVerify"), NanNew<FunctionTemplate>(Seckey_Verify)->GetFunction()); */ |
||||
/* exports->Set(NanNew("sign"), NanNew<FunctionTemplate>(Sign)->GetFunction()); */ |
||||
/* exports->Set(NanNew("signAsync"), NanNew<FunctionTemplate>(Sign_Async)->GetFunction()); */ |
||||
/* exports->Set(NanNew("signCompact"), NanNew<FunctionTemplate>(Sign_Compact)->GetFunction()); */ |
||||
/* exports->Set(NanNew("signCompactAsync"), NanNew<FunctionTemplate>(Sign_Compact_Async)->GetFunction()); */ |
||||
/* exports->Set(NanNew("recoverCompact"), NanNew<FunctionTemplate>(Recover_Compact)->GetFunction()); */ |
||||
/* exports->Set(NanNew("recoverCompactAsync"), NanNew<FunctionTemplate>(Recover_Compact_Async)->GetFunction()); */ |
||||
/* exports->Set(NanNew("verify"), NanNew<FunctionTemplate>(Verify)->GetFunction()); */ |
||||
/* exports->Set(NanNew("verifyAsync"), NanNew<FunctionTemplate>(Verify_Async)->GetFunction()); */ |
||||
/* exports->Set(NanNew("secKeyVerify"), NanNew<FunctionTemplate>(Seckey_Verify)->GetFunction()); */ |
||||
/* exports->Set(NanNew("pubKeyVerify"), NanNew<FunctionTemplate>(Pubkey_Verify)->GetFunction()); */ |
||||
/* exports->Set(NanNew("pubKeyCreate"), NanNew<FunctionTemplate>(Pubkey_Create)->GetFunction()); */ |
||||
/* exports->Set(NanNew("pubKeyDecompress"), NanNew<FunctionTemplate>(Pubkey_Decompress)->GetFunction()); */ |
||||
/* exports->Set(NanNew("privKeyExport"), NanNew<FunctionTemplate>(Privkey_Export)->GetFunction()); */ |
||||
/* exports->Set(NanNew("privKeyImport"), NanNew<FunctionTemplate>(Privkey_Import)->GetFunction()); */ |
||||
/* exports->Set(NanNew("privKeyTweakAdd"), NanNew<FunctionTemplate>(Privkey_Tweak_Add)->GetFunction()); */ |
||||
/* exports->Set(NanNew("privKeyTweakMul"), NanNew<FunctionTemplate>(Privkey_Tweak_Mul)->GetFunction()); */ |
||||
/* exports->Set(NanNew("pubKeyTweakAdd"), NanNew<FunctionTemplate>(Privkey_Tweak_Add)->GetFunction()); */ |
||||
/* exports->Set(NanNew("pubKeyTweakMul"), NanNew<FunctionTemplate>(Privkey_Tweak_Mul)->GetFunction()); */ |
||||
} |
||||
|
||||
NODE_MODULE(secp256k1, Init) |
||||
@ -1,13 +0,0 @@ |
||||
{ |
||||
"name": "node-ethash", |
||||
"version": "1.0.0", |
||||
"description": "", |
||||
"main": "index.js", |
||||
"scripts": { |
||||
"test": "echo \"Error: no test specified\" && exit 1", |
||||
"install": "node-gyp rebuild" |
||||
}, |
||||
"author": "", |
||||
"license": "ISC", |
||||
"gypfile": true |
||||
} |
||||
@ -1,12 +0,0 @@ |
||||
# To Develop |
||||
`npm install -g node-gyp` |
||||
`npm install .` |
||||
|
||||
|
||||
# To rebuild |
||||
`node-gyp rebuild` |
||||
|
||||
|
||||
# notes |
||||
|
||||
nan is good https://github.com/rvagg/nan |
||||
@ -0,0 +1,2 @@ |
||||
pyethash.egg-info/ |
||||
*.so |
||||
@ -0,0 +1,3 @@ |
||||
import pyethash.core |
||||
core = pyethash.core |
||||
EPOCH_LENGTH = 30000 |
||||
@ -0,0 +1,21 @@ |
||||
#!/usr/bin/env python |
||||
from distutils.core import setup, Extension |
||||
|
||||
pyethash_core = Extension('pyethash.core', |
||||
sources = [ |
||||
'src/python/core.c', |
||||
'src/libethash/util.c', |
||||
'src/libethash/internal.c', |
||||
'src/libethash/sha3.c' |
||||
], |
||||
extra_compile_args = ["-std=gnu99"]) |
||||
|
||||
setup ( |
||||
name = 'pyethash', |
||||
author = "Matthew Wampler-Doty", |
||||
author_email = "matthew.wampler.doty@gmail.com", |
||||
license = 'GPL', |
||||
version = '1.0', |
||||
description = 'Python wrappers for ethash, the ethereum proof of work hashing function', |
||||
ext_modules = [pyethash_core], |
||||
) |
||||
15
Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/CMakeLists.txt
generated
vendored
15
Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/CMakeLists.txt
generated
vendored
@ -0,0 +1,15 @@ |
||||
set(LIBRARY ethash-cl) |
||||
set(CMAKE_BUILD_TYPE Release) |
||||
|
||||
include(bin2h.cmake) |
||||
bin2h(SOURCE_FILE ethash_cl_miner_kernel.cl VARIABLE_NAME ethash_cl_miner_kernel HEADER_FILE ${CMAKE_CURRENT_BINARY_DIR}/ethash_cl_miner_kernel.h) |
||||
|
||||
if (NOT OpenCL_FOUND) |
||||
find_package(OpenCL) |
||||
endif() |
||||
if (OpenCL_FOUND) |
||||
include_directories(${OpenCL_INCLUDE_DIRS} ${CMAKE_CURRENT_BINARY_DIR}) |
||||
include_directories(..) |
||||
add_library(${LIBRARY} ethash_cl_miner.cpp ethash_cl_miner.h) |
||||
TARGET_LINK_LIBRARIES(${LIBRARY} ${OpenCL_LIBRARIES} ethash) |
||||
endif() |
||||
@ -0,0 +1,87 @@ |
||||
# https://gist.github.com/sivachandran/3a0de157dccef822a230 |
||||
include(CMakeParseArguments) |
||||
|
||||
# Function to wrap a given string into multiple lines at the given column position. |
||||
# Parameters: |
||||
# VARIABLE - The name of the CMake variable holding the string. |
||||
# AT_COLUMN - The column position at which string will be wrapped. |
||||
function(WRAP_STRING) |
||||
set(oneValueArgs VARIABLE AT_COLUMN) |
||||
cmake_parse_arguments(WRAP_STRING "${options}" "${oneValueArgs}" "" ${ARGN}) |
||||
|
||||
string(LENGTH ${${WRAP_STRING_VARIABLE}} stringLength) |
||||
math(EXPR offset "0") |
||||
|
||||
while(stringLength GREATER 0) |
||||
|
||||
if(stringLength GREATER ${WRAP_STRING_AT_COLUMN}) |
||||
math(EXPR length "${WRAP_STRING_AT_COLUMN}") |
||||
else() |
||||
math(EXPR length "${stringLength}") |
||||
endif() |
||||
|
||||
string(SUBSTRING ${${WRAP_STRING_VARIABLE}} ${offset} ${length} line) |
||||
set(lines "${lines}\n${line}") |
||||
|
||||
math(EXPR stringLength "${stringLength} - ${length}") |
||||
math(EXPR offset "${offset} + ${length}") |
||||
endwhile() |
||||
|
||||
set(${WRAP_STRING_VARIABLE} "${lines}" PARENT_SCOPE) |
||||
endfunction() |
||||
|
||||
# Function to embed contents of a file as byte array in C/C++ header file(.h). The header file |
||||
# will contain a byte array and integer variable holding the size of the array. |
||||
# Parameters |
||||
# SOURCE_FILE - The path of source file whose contents will be embedded in the header file. |
||||
# VARIABLE_NAME - The name of the variable for the byte array. The string "_SIZE" will be append |
||||
# to this name and will be used a variable name for size variable. |
||||
# HEADER_FILE - The path of header file. |
||||
# APPEND - If specified appends to the header file instead of overwriting it |
||||
# NULL_TERMINATE - If specified a null byte(zero) will be append to the byte array. This will be |
||||
# useful if the source file is a text file and we want to use the file contents |
||||
# as string. But the size variable holds size of the byte array without this |
||||
# null byte. |
||||
# Usage: |
||||
# bin2h(SOURCE_FILE "Logo.png" HEADER_FILE "Logo.h" VARIABLE_NAME "LOGO_PNG") |
||||
function(BIN2H) |
||||
set(options APPEND NULL_TERMINATE) |
||||
set(oneValueArgs SOURCE_FILE VARIABLE_NAME HEADER_FILE) |
||||
cmake_parse_arguments(BIN2H "${options}" "${oneValueArgs}" "" ${ARGN}) |
||||
|
||||
# reads source file contents as hex string |
||||
file(READ ${BIN2H_SOURCE_FILE} hexString HEX) |
||||
string(LENGTH ${hexString} hexStringLength) |
||||
|
||||
# appends null byte if asked |
||||
if(BIN2H_NULL_TERMINATE) |
||||
set(hexString "${hexString}00") |
||||
endif() |
||||
|
||||
# wraps the hex string into multiple lines at column 32(i.e. 16 bytes per line) |
||||
wrap_string(VARIABLE hexString AT_COLUMN 32) |
||||
math(EXPR arraySize "${hexStringLength} / 2") |
||||
|
||||
# adds '0x' prefix and comma suffix before and after every byte respectively |
||||
string(REGEX REPLACE "([0-9a-f][0-9a-f])" "0x\\1, " arrayValues ${hexString}) |
||||
# removes trailing comma |
||||
string(REGEX REPLACE ", $" "" arrayValues ${arrayValues}) |
||||
|
||||
# converts the variable name into proper C identifier |
||||
# TODO: fix for legacy cmake |
||||
IF (${CMAKE_VERSION} GREATER 2.8.10) |
||||
string(MAKE_C_IDENTIFIER "${BIN2H_VARIABLE_NAME}" BIN2H_VARIABLE_NAME) |
||||
ENDIF() |
||||
string(TOUPPER "${BIN2H_VARIABLE_NAME}" BIN2H_VARIABLE_NAME) |
||||
|
||||
# declares byte array and the length variables |
||||
set(arrayDefinition "const unsigned char ${BIN2H_VARIABLE_NAME}[] = { ${arrayValues} };") |
||||
set(arraySizeDefinition "const size_t ${BIN2H_VARIABLE_NAME}_SIZE = ${arraySize};") |
||||
|
||||
set(declarations "${arrayDefinition}\n\n${arraySizeDefinition}\n\n") |
||||
if(BIN2H_APPEND) |
||||
file(APPEND ${BIN2H_HEADER_FILE} "${declarations}") |
||||
else() |
||||
file(WRITE ${BIN2H_HEADER_FILE} "${declarations}") |
||||
endif() |
||||
endfunction() |
||||
289
Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/ethash_cl_miner.cpp
generated
vendored
289
Godeps/_workspace/src/github.com/ethereum/ethash/src/libethash-cl/ethash_cl_miner.cpp
generated
vendored
@ -0,0 +1,289 @@ |
||||
/*
|
||||
This file is part of c-ethash. |
||||
|
||||
c-ethash is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU General Public License as published by |
||||
the Free Software Foundation, either version 3 of the License, or |
||||
(at your option) any later version. |
||||
|
||||
c-ethash is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU General Public License for more details. |
||||
|
||||
You should have received a copy of the GNU General Public License |
||||
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
/** @file ethash_cl_miner.cpp
|
||||
* @author Tim Hughes <tim@twistedfury.com> |
||||
* @date 2015 |
||||
*/ |
||||
|
||||
|
||||
#define _CRT_SECURE_NO_WARNINGS |
||||
|
||||
#include <assert.h> |
||||
#include <queue> |
||||
#include "ethash_cl_miner.h" |
||||
#include "ethash_cl_miner_kernel.h" |
||||
#include <libethash/util.h> |
||||
|
||||
#undef min |
||||
#undef max |
||||
|
||||
#define HASH_BYTES 32 |
||||
|
||||
static void add_definition(std::string& source, char const* id, unsigned value) |
||||
{ |
||||
char buf[256]; |
||||
sprintf(buf, "#define %s %uu\n", id, value); |
||||
source.insert(source.begin(), buf, buf + strlen(buf)); |
||||
} |
||||
|
||||
ethash_cl_miner::ethash_cl_miner() |
||||
{ |
||||
} |
||||
|
||||
bool ethash_cl_miner::init(ethash_params const& params, const uint8_t seed[32], unsigned workgroup_size) |
||||
{ |
||||
// store params
|
||||
m_params = params; |
||||
|
||||
// get all platforms
|
||||
std::vector<cl::Platform> platforms; |
||||
cl::Platform::get(&platforms); |
||||
if (platforms.empty()) |
||||
{ |
||||
debugf("No OpenCL platforms found.\n"); |
||||
return false; |
||||
} |
||||
|
||||
// use default platform
|
||||
debugf("Using platform: %s\n", platforms[0].getInfo<CL_PLATFORM_NAME>().c_str()); |
||||
|
||||
// get GPU device of the default platform
|
||||
std::vector<cl::Device> devices; |
||||
platforms[0].getDevices(CL_DEVICE_TYPE_ALL, &devices); |
||||
if (devices.empty()) |
||||
{ |
||||
debugf("No OpenCL devices found.\n"); |
||||
return false; |
||||
} |
||||
|
||||
// use default device
|
||||
cl::Device& device = devices[0]; |
||||
debugf("Using device: %s\n", device.getInfo<CL_DEVICE_NAME>().c_str()); |
||||
|
||||
// create context
|
||||
m_context = cl::Context({device}); |
||||
m_queue = cl::CommandQueue(m_context, device); |
||||
|
||||
// use requested workgroup size, but we require multiple of 8
|
||||
m_workgroup_size = ((workgroup_size + 7) / 8) * 8; |
||||
|
||||
// patch source code
|
||||
std::string code(ETHASH_CL_MINER_KERNEL, ETHASH_CL_MINER_KERNEL + ETHASH_CL_MINER_KERNEL_SIZE); |
||||
add_definition(code, "GROUP_SIZE", m_workgroup_size); |
||||
add_definition(code, "DAG_SIZE", (unsigned)(params.full_size / MIX_BYTES)); |
||||
add_definition(code, "ACCESSES", ACCESSES); |
||||
add_definition(code, "MAX_OUTPUTS", c_max_search_results); |
||||
//debugf("%s", code.c_str());
|
||||
|
||||
// create miner OpenCL program
|
||||
cl::Program::Sources sources; |
||||
sources.push_back({code.c_str(), code.size()}); |
||||
|
||||
cl::Program program(m_context, sources); |
||||
try |
||||
{ |
||||
program.build({device}); |
||||
} |
||||
catch (cl::Error err) |
||||
{ |
||||
debugf("%s\n", program.getBuildInfo<CL_PROGRAM_BUILD_LOG>(device).c_str()); |
||||
return false; |
||||
} |
||||
m_hash_kernel = cl::Kernel(program, "ethash_hash"); |
||||
m_search_kernel = cl::Kernel(program, "ethash_search"); |
||||
|
||||
// create buffer for dag
|
||||
m_dag = cl::Buffer(m_context, CL_MEM_READ_ONLY, params.full_size); |
||||
|
||||
// create buffer for header
|
||||
m_header = cl::Buffer(m_context, CL_MEM_READ_ONLY, 32); |
||||
|
||||
// compute dag on CPU
|
||||
{ |
||||
void* cache_mem = malloc(params.cache_size + 63); |
||||
ethash_cache cache; |
||||
cache.mem = (void*)(((uintptr_t)cache_mem + 63) & ~63); |
||||
ethash_mkcache(&cache, ¶ms, seed); |
||||
|
||||
// if this throws then it's because we probably need to subdivide the dag uploads for compatibility
|
||||
void* dag_ptr = m_queue.enqueueMapBuffer(m_dag, true, CL_MAP_WRITE_INVALIDATE_REGION, 0, params.full_size); |
||||
ethash_compute_full_data(dag_ptr, ¶ms, &cache); |
||||
m_queue.enqueueUnmapMemObject(m_dag, dag_ptr); |
||||
|
||||
free(cache_mem); |
||||
} |
||||
|
||||
// create mining buffers
|
||||
for (unsigned i = 0; i != c_num_buffers; ++i) |
||||
{ |
||||
m_hash_buf[i] = cl::Buffer(m_context, CL_MEM_WRITE_ONLY | CL_MEM_HOST_READ_ONLY, 32*c_hash_batch_size); |
||||
m_search_buf[i] = cl::Buffer(m_context, CL_MEM_WRITE_ONLY, (c_max_search_results + 1) * sizeof(uint32_t)); |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
void ethash_cl_miner::hash(uint8_t* ret, uint8_t const* header, uint64_t nonce, unsigned count) |
||||
{ |
||||
struct pending_batch |
||||
{ |
||||
unsigned base; |
||||
unsigned count; |
||||
unsigned buf; |
||||
}; |
||||
std::queue<pending_batch> pending; |
||||
|
||||
// update header constant buffer
|
||||
m_queue.enqueueWriteBuffer(m_header, true, 0, 32, header); |
||||
|
||||
/*
|
||||
__kernel void ethash_combined_hash( |
||||
__global hash32_t* g_hashes, |
||||
__constant hash32_t const* g_header, |
||||
__global hash128_t const* g_dag, |
||||
ulong start_nonce, |
||||
uint isolate |
||||
) |
||||
*/ |
||||
m_hash_kernel.setArg(1, m_header); |
||||
m_hash_kernel.setArg(2, m_dag); |
||||
m_hash_kernel.setArg(3, nonce); |
||||
m_hash_kernel.setArg(4, ~0u); // have to pass this to stop the compile unrolling the loop
|
||||
|
||||
unsigned buf = 0; |
||||
for (unsigned i = 0; i < count || !pending.empty(); ) |
||||
{ |
||||
// how many this batch
|
||||
if (i < count) |
||||
{ |
||||
unsigned const this_count = std::min(count - i, c_hash_batch_size); |
||||
unsigned const batch_count = std::max(this_count, m_workgroup_size); |
||||
|
||||
// supply output hash buffer to kernel
|
||||
m_hash_kernel.setArg(0, m_hash_buf[buf]); |
||||
|
||||
// execute it!
|
||||
clock_t start_time = clock(); |
||||
m_queue.enqueueNDRangeKernel( |
||||
m_hash_kernel, |
||||
cl::NullRange, |
||||
cl::NDRange(batch_count), |
||||
cl::NDRange(m_workgroup_size) |
||||
); |
||||
m_queue.flush(); |
||||
|
||||
pending.push({i, this_count, buf}); |
||||
i += this_count; |
||||
buf = (buf + 1) % c_num_buffers; |
||||
} |
||||
|
||||
// read results
|
||||
if (i == count || pending.size() == c_num_buffers) |
||||
{ |
||||
pending_batch const& batch = pending.front(); |
||||
|
||||
// could use pinned host pointer instead, but this path isn't that important.
|
||||
uint8_t* hashes = (uint8_t*)m_queue.enqueueMapBuffer(m_hash_buf[batch.buf], true, CL_MAP_READ, 0, batch.count * HASH_BYTES); |
||||
memcpy(ret + batch.base*HASH_BYTES, hashes, batch.count*HASH_BYTES); |
||||
m_queue.enqueueUnmapMemObject(m_hash_buf[batch.buf], hashes); |
||||
|
||||
pending.pop(); |
||||
} |
||||
} |
||||
} |
||||
|
||||
|
||||
void ethash_cl_miner::search(uint8_t const* header, uint64_t target, search_hook& hook) |
||||
{ |
||||
struct pending_batch |
||||
{ |
||||
uint64_t start_nonce; |
||||
unsigned buf; |
||||
}; |
||||
std::queue<pending_batch> pending; |
||||
|
||||
static uint32_t const c_zero = 0; |
||||
|
||||
// update header constant buffer
|
||||
m_queue.enqueueWriteBuffer(m_header, false, 0, 32, header); |
||||
for (unsigned i = 0; i != c_num_buffers; ++i) |
||||
{ |
||||
m_queue.enqueueWriteBuffer(m_search_buf[i], false, 0, 4, &c_zero); |
||||
} |
||||
cl::Event pre_return_event; |
||||
m_queue.enqueueBarrierWithWaitList(NULL, &pre_return_event); |
||||
|
||||
/*
|
||||
__kernel void ethash_combined_search( |
||||
__global hash32_t* g_hashes, // 0
|
||||
__constant hash32_t const* g_header, // 1
|
||||
__global hash128_t const* g_dag, // 2
|
||||
ulong start_nonce, // 3
|
||||
ulong target, // 4
|
||||
uint isolate // 5
|
||||
) |
||||
*/ |
||||
m_search_kernel.setArg(1, m_header); |
||||
m_search_kernel.setArg(2, m_dag); |
||||
|
||||
// pass these to stop the compiler unrolling the loops
|
||||
m_search_kernel.setArg(4, target); |
||||
m_search_kernel.setArg(5, ~0u); |
||||
|
||||
|
||||
unsigned buf = 0; |
||||
for (uint64_t start_nonce = 0; ; start_nonce += c_search_batch_size) |
||||
{ |
||||
// supply output buffer to kernel
|
||||
m_search_kernel.setArg(0, m_search_buf[buf]); |
||||
m_search_kernel.setArg(3, start_nonce); |
||||
|
||||
// execute it!
|
||||
m_queue.enqueueNDRangeKernel(m_search_kernel, cl::NullRange, c_search_batch_size, m_workgroup_size); |
||||
|
||||
pending.push({start_nonce, buf}); |
||||
buf = (buf + 1) % c_num_buffers; |
||||
|
||||
// read results
|
||||
if (pending.size() == c_num_buffers) |
||||
{ |
||||
pending_batch const& batch = pending.front(); |
||||
|
||||
// could use pinned host pointer instead
|
||||
uint32_t* results = (uint32_t*)m_queue.enqueueMapBuffer(m_search_buf[batch.buf], true, CL_MAP_READ, 0, (1+c_max_search_results) * sizeof(uint32_t)); |
||||
unsigned num_found = std::min(results[0], c_max_search_results); |
||||
|
||||
uint64_t nonces[c_max_search_results]; |
||||
for (unsigned i = 0; i != num_found; ++i) |
||||
{ |
||||
nonces[i] = batch.start_nonce + results[i+1]; |
||||
} |
||||
|
||||
m_queue.enqueueUnmapMemObject(m_search_buf[batch.buf], results); |
||||
|
||||
bool exit = num_found && hook.found(nonces, num_found); |
||||
exit |= hook.searched(batch.start_nonce, c_search_batch_size); // always report searched before exit
|
||||
if (exit) |
||||
break; |
||||
|
||||
pending.pop(); |
||||
} |
||||
} |
||||
|
||||
// not safe to return until this is ready
|
||||
pre_return_event.wait(); |
||||
} |
||||
|
||||
@ -0,0 +1,779 @@ |
||||
/*
|
||||
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 FoundationUUU,either version 3 of the LicenseUUU,or |
||||
(at your option) any later version. |
||||
|
||||
cpp-ethereum is distributed in the hope that it will be usefulU, |
||||
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 notUUU,see <http://www.gnu.org/licenses/>.
|
||||
*/ |
||||
|
||||
/** @file data_sizes.h
|
||||
* @author Matthew Wampler-Doty <negacthulhu@gmail.com> |
||||
* @date 2015 |
||||
*/ |
||||
|
||||
// TODO: Update this after ~3.5 years
|
||||
|
||||
#pragma once |
||||
|
||||
#include <stdint.h> |
||||
#include "compiler.h" |
||||
|
||||
#ifdef __cplusplus |
||||
extern "C" { |
||||
#endif |
||||
|
||||
#include <stdint.h> |
||||
|
||||
// 2048 Epochs worth of tabulated DAG sizes
|
||||
|
||||
// Generated with the following Mathematica Code:
|
||||
|
||||
// GetDataSizes[n_] := Module[{
|
||||
// DataSetSizeBytesInit = 2^30,
|
||||
// MixBytes = 128,
|
||||
// DataSetGrowth = 2^23,
|
||||
// j = 0},
|
||||
// Reap[
|
||||
// While[j < n,
|
||||
// Module[{i =
|
||||
// Floor[(DataSetSizeBytesInit + DataSetGrowth * j) / MixBytes]},
|
||||
// While[! PrimeQ[i], i--];
|
||||
// Sow[i*MixBytes]; j++]]]][[2]][[1]]
|
||||
|
||||
static const size_t dag_sizes[] = { |
||||
1073739904U, 1082130304U, 1090514816U, 1098906752U, 1107293056U, |
||||
1115684224U, 1124070016U, 1132461952U, 1140849536U, 1149232768U, |
||||
1157627776U, 1166013824U, 1174404736U, 1182786944U, 1191180416U, |
||||
1199568512U, 1207958912U, 1216345216U, 1224732032U, 1233124736U, |
||||
1241513344U, 1249902464U, 1258290304U, 1266673792U, 1275067264U, |
||||
1283453312U, 1291844992U, 1300234112U, 1308619904U, 1317010048U, |
||||
1325397376U, 1333787776U, 1342176128U, 1350561664U, 1358954368U, |
||||
1367339392U, 1375731584U, 1384118144U, 1392507008U, 1400897408U, |
||||
1409284736U, 1417673344U, 1426062464U, 1434451072U, 1442839168U, |
||||
1451229056U, 1459615616U, 1468006016U, 1476394112U, 1484782976U, |
||||
1493171584U, 1501559168U, 1509948032U, 1518337664U, 1526726528U, |
||||
1535114624U, 1543503488U, 1551892096U, 1560278656U, 1568669056U, |
||||
1577056384U, 1585446272U, 1593831296U, 1602219392U, 1610610304U, |
||||
1619000192U, 1627386752U, 1635773824U, 1644164224U, 1652555648U, |
||||
1660943488U, 1669332608U, 1677721216U, 1686109312U, 1694497664U, |
||||
1702886272U, 1711274624U, 1719661184U, 1728047744U, 1736434816U, |
||||
1744829056U, 1753218944U, 1761606272U, 1769995904U, 1778382464U, |
||||
1786772864U, 1795157888U, 1803550592U, 1811937664U, 1820327552U, |
||||
1828711552U, 1837102976U, 1845488768U, 1853879936U, 1862269312U, |
||||
1870656896U, 1879048064U, 1887431552U, 1895825024U, 1904212096U, |
||||
1912601216U, 1920988544U, 1929379456U, 1937765504U, 1946156672U, |
||||
1954543232U, 1962932096U, 1971321728U, 1979707264U, 1988093056U, |
||||
1996487552U, 2004874624U, 2013262208U, 2021653888U, 2030039936U, |
||||
2038430848U, 2046819968U, 2055208576U, 2063596672U, 2071981952U, |
||||
2080373632U, 2088762752U, 2097149056U, 2105539712U, 2113928576U, |
||||
2122315136U, 2130700672U, 2139092608U, 2147483264U, 2155872128U, |
||||
2164257664U, 2172642176U, 2181035392U, 2189426048U, 2197814912U, |
||||
2206203008U, 2214587264U, 2222979712U, 2231367808U, 2239758208U, |
||||
2248145024U, 2256527744U, 2264922752U, 2273312128U, 2281701248U, |
||||
2290086272U, 2298476672U, 2306867072U, 2315251072U, 2323639168U, |
||||
2332032128U, 2340420224U, 2348808064U, 2357196416U, 2365580416U, |
||||
2373966976U, 2382363008U, 2390748544U, 2399139968U, 2407530368U, |
||||
2415918976U, 2424307328U, 2432695424U, 2441084288U, 2449472384U, |
||||
2457861248U, 2466247808U, 2474637184U, 2483026816U, 2491414144U, |
||||
2499803776U, 2508191872U, 2516582272U, 2524970368U, 2533359232U, |
||||
2541743488U, 2550134144U, 2558525056U, 2566913408U, 2575301504U, |
||||
2583686528U, 2592073856U, 2600467328U, 2608856192U, 2617240448U, |
||||
2625631616U, 2634022016U, 2642407552U, 2650796416U, 2659188352U, |
||||
2667574912U, 2675965312U, 2684352896U, 2692738688U, 2701130624U, |
||||
2709518464U, 2717907328U, 2726293376U, 2734685056U, 2743073152U, |
||||
2751462016U, 2759851648U, 2768232832U, 2776625536U, 2785017728U, |
||||
2793401984U, 2801794432U, 2810182016U, 2818571648U, 2826959488U, |
||||
2835349376U, 2843734144U, 2852121472U, 2860514432U, 2868900992U, |
||||
2877286784U, 2885676928U, 2894069632U, 2902451584U, 2910843008U, |
||||
2919234688U, 2927622784U, 2936011648U, 2944400768U, 2952789376U, |
||||
2961177728U, 2969565568U, 2977951616U, 2986338944U, 2994731392U, |
||||
3003120256U, 3011508352U, 3019895936U, 3028287104U, 3036675968U, |
||||
3045063808U, 3053452928U, 3061837696U, 3070228352U, 3078615424U, |
||||
3087003776U, 3095394944U, 3103782272U, 3112173184U, 3120562048U, |
||||
3128944768U, 3137339264U, 3145725056U, 3154109312U, 3162505088U, |
||||
3170893184U, 3179280256U, 3187669376U, 3196056704U, 3204445568U, |
||||
3212836736U, 3221224064U, 3229612928U, 3238002304U, 3246391168U, |
||||
3254778496U, 3263165824U, 3271556224U, 3279944576U, 3288332416U, |
||||
3296719232U, 3305110912U, 3313500032U, 3321887104U, 3330273152U, |
||||
3338658944U, 3347053184U, 3355440512U, 3363827072U, 3372220288U, |
||||
3380608384U, 3388997504U, 3397384576U, 3405774208U, 3414163072U, |
||||
3422551936U, 3430937984U, 3439328384U, 3447714176U, 3456104576U, |
||||
3464493952U, 3472883584U, 3481268864U, 3489655168U, 3498048896U, |
||||
3506434432U, 3514826368U, 3523213952U, 3531603584U, 3539987072U, |
||||
3548380288U, 3556763264U, 3565157248U, 3573545344U, 3581934464U, |
||||
3590324096U, 3598712704U, 3607098752U, 3615488384U, 3623877248U, |
||||
3632265856U, 3640646528U, 3649043584U, 3657430144U, 3665821568U, |
||||
3674207872U, 3682597504U, 3690984832U, 3699367808U, 3707764352U, |
||||
3716152448U, 3724541056U, 3732925568U, 3741318016U, 3749706368U, |
||||
3758091136U, 3766481536U, 3774872704U, 3783260032U, 3791650432U, |
||||
3800036224U, 3808427648U, 3816815488U, 3825204608U, 3833592704U, |
||||
3841981568U, 3850370432U, 3858755968U, 3867147904U, 3875536256U, |
||||
3883920512U, 3892313728U, 3900702592U, 3909087872U, 3917478784U, |
||||
3925868416U, 3934256512U, 3942645376U, 3951032192U, 3959422336U, |
||||
3967809152U, 3976200064U, 3984588416U, 3992974976U, 4001363584U, |
||||
4009751168U, 4018141312U, 4026530432U, 4034911616U, 4043308928U, |
||||
4051695488U, 4060084352U, 4068472448U, 4076862848U, 4085249408U, |
||||
4093640576U, 4102028416U, 4110413696U, 4118805632U, 4127194496U, |
||||
4135583104U, 4143971968U, 4152360832U, 4160746112U, 4169135744U, |
||||
4177525888U, 4185912704U, 4194303616U, 4202691968U, 4211076736U, |
||||
4219463552U, 4227855488U, 4236246656U, 4244633728U, 4253022848U, |
||||
4261412224U, 4269799808U, 4278184832U, 4286578048U, 4294962304U, |
||||
4303349632U, 4311743104U, 4320130432U, 4328521088U, 4336909184U, |
||||
4345295488U, 4353687424U, 4362073472U, 4370458496U, 4378852736U, |
||||
4387238528U, 4395630208U, 4404019072U, 4412407424U, 4420790656U, |
||||
4429182848U, 4437571456U, 4445962112U, 4454344064U, 4462738048U, |
||||
4471119232U, 4479516544U, 4487904128U, 4496289664U, 4504682368U, |
||||
4513068416U, 4521459584U, 4529846144U, 4538232704U, 4546619776U, |
||||
4555010176U, 4563402112U, 4571790208U, 4580174464U, 4588567936U, |
||||
4596957056U, 4605344896U, 4613734016U, 4622119808U, 4630511488U, |
||||
4638898816U, 4647287936U, 4655675264U, 4664065664U, 4672451968U, |
||||
4680842624U, 4689231488U, 4697620352U, 4706007424U, 4714397056U, |
||||
4722786176U, 4731173248U, 4739562368U, 4747951744U, 4756340608U, |
||||
4764727936U, 4773114496U, 4781504384U, 4789894784U, 4798283648U, |
||||
4806667648U, 4815059584U, 4823449472U, 4831835776U, 4840226176U, |
||||
4848612224U, 4857003392U, 4865391488U, 4873780096U, 4882169728U, |
||||
4890557312U, 4898946944U, 4907333248U, 4915722368U, 4924110976U, |
||||
4932499328U, 4940889728U, 4949276032U, 4957666432U, 4966054784U, |
||||
4974438016U, 4982831488U, 4991221376U, 4999607168U, 5007998848U, |
||||
5016386432U, 5024763776U, 5033164672U, 5041544576U, 5049941888U, |
||||
5058329728U, 5066717056U, 5075107456U, 5083494272U, 5091883904U, |
||||
5100273536U, 5108662144U, 5117048192U, 5125436032U, 5133827456U, |
||||
5142215296U, 5150605184U, 5158993024U, 5167382144U, 5175769472U, |
||||
5184157568U, 5192543872U, 5200936064U, 5209324928U, 5217711232U, |
||||
5226102656U, 5234490496U, 5242877312U, 5251263872U, 5259654016U, |
||||
5268040832U, 5276434304U, 5284819328U, 5293209728U, 5301598592U, |
||||
5309986688U, 5318374784U, 5326764416U, 5335151488U, 5343542144U, |
||||
5351929472U, 5360319872U, 5368706944U, 5377096576U, 5385484928U, |
||||
5393871232U, 5402263424U, 5410650496U, 5419040384U, 5427426944U, |
||||
5435816576U, 5444205952U, 5452594816U, 5460981376U, 5469367936U, |
||||
5477760896U, 5486148736U, 5494536832U, 5502925952U, 5511315328U, |
||||
5519703424U, 5528089984U, 5536481152U, 5544869504U, 5553256064U, |
||||
5561645696U, 5570032768U, 5578423936U, 5586811264U, 5595193216U, |
||||
5603585408U, 5611972736U, 5620366208U, 5628750464U, 5637143936U, |
||||
5645528192U, 5653921408U, 5662310272U, 5670694784U, 5679082624U, |
||||
5687474048U, 5695864448U, 5704251008U, 5712641408U, 5721030272U, |
||||
5729416832U, 5737806208U, 5746194304U, 5754583936U, 5762969984U, |
||||
5771358592U, 5779748224U, 5788137856U, 5796527488U, 5804911232U, |
||||
5813300608U, 5821692544U, 5830082176U, 5838468992U, 5846855552U, |
||||
5855247488U, 5863636096U, 5872024448U, 5880411008U, 5888799872U, |
||||
5897186432U, 5905576832U, 5913966976U, 5922352768U, 5930744704U, |
||||
5939132288U, 5947522432U, 5955911296U, 5964299392U, 5972688256U, |
||||
5981074304U, 5989465472U, 5997851008U, 6006241408U, 6014627968U, |
||||
6023015552U, 6031408256U, 6039796096U, 6048185216U, 6056574848U, |
||||
6064963456U, 6073351808U, 6081736064U, 6090128768U, 6098517632U, |
||||
6106906496U, 6115289216U, 6123680896U, 6132070016U, 6140459648U, |
||||
6148849024U, 6157237376U, 6165624704U, 6174009728U, 6182403712U, |
||||
6190792064U, 6199176064U, 6207569792U, 6215952256U, 6224345216U, |
||||
6232732544U, 6241124224U, 6249510272U, 6257899136U, 6266287744U, |
||||
6274676864U, 6283065728U, 6291454336U, 6299843456U, 6308232064U, |
||||
6316620928U, 6325006208U, 6333395584U, 6341784704U, 6350174848U, |
||||
6358562176U, 6366951296U, 6375337856U, 6383729536U, 6392119168U, |
||||
6400504192U, 6408895616U, 6417283456U, 6425673344U, 6434059136U, |
||||
6442444672U, 6450837376U, 6459223424U, 6467613056U, 6476004224U, |
||||
6484393088U, 6492781952U, 6501170048U, 6509555072U, 6517947008U, |
||||
6526336384U, 6534725504U, 6543112832U, 6551500672U, 6559888768U, |
||||
6568278656U, 6576662912U, 6585055616U, 6593443456U, 6601834112U, |
||||
6610219648U, 6618610304U, 6626999168U, 6635385472U, 6643777408U, |
||||
6652164224U, 6660552832U, 6668941952U, 6677330048U, 6685719424U, |
||||
6694107776U, 6702493568U, 6710882176U, 6719274112U, 6727662976U, |
||||
6736052096U, 6744437632U, 6752825984U, 6761213824U, 6769604224U, |
||||
6777993856U, 6786383488U, 6794770816U, 6803158144U, 6811549312U, |
||||
6819937664U, 6828326528U, 6836706176U, 6845101696U, 6853491328U, |
||||
6861880448U, 6870269312U, 6878655104U, 6887046272U, 6895433344U, |
||||
6903822208U, 6912212864U, 6920596864U, 6928988288U, 6937377152U, |
||||
6945764992U, 6954149248U, 6962544256U, 6970928768U, 6979317376U, |
||||
6987709312U, 6996093824U, 7004487296U, 7012875392U, 7021258624U, |
||||
7029652352U, 7038038912U, 7046427776U, 7054818944U, 7063207808U, |
||||
7071595136U, 7079980928U, 7088372608U, 7096759424U, 7105149824U, |
||||
7113536896U, 7121928064U, 7130315392U, 7138699648U, 7147092352U, |
||||
7155479168U, 7163865728U, 7172249984U, 7180648064U, 7189036672U, |
||||
7197424768U, 7205810816U, 7214196608U, 7222589824U, 7230975104U, |
||||
7239367552U, 7247755904U, 7256145536U, 7264533376U, 7272921472U, |
||||
7281308032U, 7289694848U, 7298088832U, 7306471808U, 7314864512U, |
||||
7323253888U, 7331643008U, 7340029568U, 7348419712U, 7356808832U, |
||||
7365196672U, 7373585792U, 7381973888U, 7390362752U, 7398750592U, |
||||
7407138944U, 7415528576U, 7423915648U, 7432302208U, 7440690304U, |
||||
7449080192U, 7457472128U, 7465860992U, 7474249088U, 7482635648U, |
||||
7491023744U, 7499412608U, 7507803008U, 7516192384U, 7524579968U, |
||||
7532967296U, 7541358464U, 7549745792U, 7558134656U, 7566524032U, |
||||
7574912896U, 7583300992U, 7591690112U, 7600075136U, 7608466816U, |
||||
7616854912U, 7625244544U, 7633629824U, 7642020992U, 7650410368U, |
||||
7658794112U, 7667187328U, 7675574912U, 7683961984U, 7692349568U, |
||||
7700739712U, 7709130368U, 7717519232U, 7725905536U, 7734295424U, |
||||
7742683264U, 7751069056U, 7759457408U, 7767849088U, 7776238208U, |
||||
7784626816U, 7793014912U, 7801405312U, 7809792128U, 7818179968U, |
||||
7826571136U, 7834957184U, 7843347328U, 7851732352U, 7860124544U, |
||||
7868512384U, 7876902016U, 7885287808U, 7893679744U, 7902067072U, |
||||
7910455936U, 7918844288U, 7927230848U, 7935622784U, 7944009344U, |
||||
7952400256U, 7960786048U, 7969176704U, 7977565312U, 7985953408U, |
||||
7994339968U, 8002730368U, 8011119488U, 8019508096U, 8027896192U, |
||||
8036285056U, 8044674688U, 8053062272U, 8061448832U, 8069838464U, |
||||
8078227328U, 8086616704U, 8095006592U, 8103393664U, 8111783552U, |
||||
8120171392U, 8128560256U, 8136949376U, 8145336704U, 8153726848U, |
||||
8162114944U, 8170503296U, 8178891904U, 8187280768U, 8195669632U, |
||||
8204058496U, 8212444544U, 8220834176U, 8229222272U, 8237612672U, |
||||
8246000768U, 8254389376U, 8262775168U, 8271167104U, 8279553664U, |
||||
8287944064U, 8296333184U, 8304715136U, 8313108352U, 8321497984U, |
||||
8329885568U, 8338274432U, 8346663296U, 8355052928U, 8363441536U, |
||||
8371828352U, 8380217984U, 8388606592U, 8396996224U, 8405384576U, |
||||
8413772672U, 8422161536U, 8430549376U, 8438939008U, 8447326592U, |
||||
8455715456U, 8464104832U, 8472492928U, 8480882048U, 8489270656U, |
||||
8497659776U, 8506045312U, 8514434944U, 8522823808U, 8531208832U, |
||||
8539602304U, 8547990656U, 8556378752U, 8564768384U, 8573154176U, |
||||
8581542784U, 8589933952U, 8598322816U, 8606705024U, 8615099264U, |
||||
8623487872U, 8631876992U, 8640264064U, 8648653952U, 8657040256U, |
||||
8665430656U, 8673820544U, 8682209152U, 8690592128U, 8698977152U, |
||||
8707374464U, 8715763328U, 8724151424U, 8732540032U, 8740928384U, |
||||
8749315712U, 8757704576U, 8766089344U, 8774480768U, 8782871936U, |
||||
8791260032U, 8799645824U, 8808034432U, 8816426368U, 8824812928U, |
||||
8833199488U, 8841591424U, 8849976448U, 8858366336U, 8866757248U, |
||||
8875147136U, 8883532928U, 8891923328U, 8900306816U, 8908700288U, |
||||
8917088384U, 8925478784U, 8933867392U, 8942250368U, 8950644608U, |
||||
8959032704U, 8967420544U, 8975809664U, 8984197504U, 8992584064U, |
||||
9000976256U, 9009362048U, 9017752448U, 9026141312U, 9034530688U, |
||||
9042917504U, 9051307904U, 9059694208U, 9068084864U, 9076471424U, |
||||
9084861824U, 9093250688U, 9101638528U, 9110027648U, 9118416512U, |
||||
9126803584U, 9135188096U, 9143581312U, 9151969664U, 9160356224U, |
||||
9168747136U, 9177134464U, 9185525632U, 9193910144U, 9202302848U, |
||||
9210690688U, 9219079552U, 9227465344U, 9235854464U, 9244244864U, |
||||
9252633472U, 9261021824U, 9269411456U, 9277799296U, 9286188928U, |
||||
9294574208U, 9302965888U, 9311351936U, 9319740032U, 9328131968U, |
||||
9336516736U, 9344907392U, 9353296768U, 9361685888U, 9370074752U, |
||||
9378463616U, 9386849408U, 9395239808U, 9403629184U, 9412016512U, |
||||
9420405376U, 9428795008U, 9437181568U, 9445570688U, 9453960832U, |
||||
9462346624U, 9470738048U, 9479121536U, 9487515008U, 9495903616U, |
||||
9504289664U, 9512678528U, 9521067904U, 9529456256U, 9537843584U, |
||||
9546233728U, 9554621312U, 9563011456U, 9571398784U, 9579788672U, |
||||
9588178304U, 9596567168U, 9604954496U, 9613343104U, 9621732992U, |
||||
9630121856U, 9638508416U, 9646898816U, 9655283584U, 9663675776U, |
||||
9672061312U, 9680449664U, 9688840064U, 9697230464U, 9705617536U, |
||||
9714003584U, 9722393984U, 9730772608U, 9739172224U, 9747561088U, |
||||
9755945344U, 9764338816U, 9772726144U, 9781116544U, 9789503872U, |
||||
9797892992U, 9806282624U, 9814670464U, 9823056512U, 9831439232U, |
||||
9839833984U, 9848224384U, 9856613504U, 9865000576U, 9873391232U, |
||||
9881772416U, 9890162816U, 9898556288U, 9906940544U, 9915333248U, |
||||
9923721088U, 9932108672U, 9940496512U, 9948888448U, 9957276544U, |
||||
9965666176U, 9974048384U, 9982441088U, 9990830464U, 9999219584U, |
||||
10007602816U, 10015996544U, 10024385152U, 10032774016U, 10041163648U, |
||||
10049548928U, 10057940096U, 10066329472U, 10074717824U, 10083105152U, |
||||
10091495296U, 10099878784U, 10108272256U, 10116660608U, 10125049216U, |
||||
10133437312U, 10141825664U, 10150213504U, 10158601088U, 10166991232U, |
||||
10175378816U, 10183766144U, 10192157312U, 10200545408U, 10208935552U, |
||||
10217322112U, 10225712768U, 10234099328U, 10242489472U, 10250876032U, |
||||
10259264896U, 10267656064U, 10276042624U, 10284429184U, 10292820352U, |
||||
10301209472U, 10309598848U, 10317987712U, 10326375296U, 10334763392U, |
||||
10343153536U, 10351541632U, 10359930752U, 10368318592U, 10376707456U, |
||||
10385096576U, 10393484672U, 10401867136U, 10410262144U, 10418647424U, |
||||
10427039104U, 10435425664U, 10443810176U, 10452203648U, 10460589952U, |
||||
10468982144U, 10477369472U, 10485759104U, 10494147712U, 10502533504U, |
||||
10510923392U, 10519313536U, 10527702656U, 10536091264U, 10544478592U, |
||||
10552867712U, 10561255808U, 10569642368U, 10578032768U, 10586423168U, |
||||
10594805632U, 10603200128U, 10611588992U, 10619976064U, 10628361344U, |
||||
10636754048U, 10645143424U, 10653531776U, 10661920384U, 10670307968U, |
||||
10678696832U, 10687086464U, 10695475072U, 10703863168U, 10712246144U, |
||||
10720639616U, 10729026688U, 10737414784U, 10745806208U, 10754190976U, |
||||
10762581376U, 10770971264U, 10779356288U, 10787747456U, 10796135552U, |
||||
10804525184U, 10812915584U, 10821301888U, 10829692288U, 10838078336U, |
||||
10846469248U, 10854858368U, 10863247232U, 10871631488U, 10880023424U, |
||||
10888412032U, 10896799616U, 10905188992U, 10913574016U, 10921964672U, |
||||
10930352768U, 10938742912U, 10947132544U, 10955518592U, 10963909504U, |
||||
10972298368U, 10980687488U, 10989074816U, 10997462912U, 11005851776U, |
||||
11014241152U, 11022627712U, 11031017344U, 11039403904U, 11047793024U, |
||||
11056184704U, 11064570752U, 11072960896U, 11081343872U, 11089737856U, |
||||
11098128256U, 11106514816U, 11114904448U, 11123293568U, 11131680128U, |
||||
11140065152U, 11148458368U, 11156845696U, 11165236864U, 11173624192U, |
||||
11182013824U, 11190402688U, 11198790784U, 11207179136U, 11215568768U, |
||||
11223957376U, 11232345728U, 11240734592U, 11249122688U, 11257511296U, |
||||
11265899648U, 11274285952U, 11282675584U, 11291065472U, 11299452544U, |
||||
11307842432U, 11316231296U, 11324616832U, 11333009024U, 11341395584U, |
||||
11349782656U, 11358172288U, 11366560384U, 11374950016U, 11383339648U, |
||||
11391721856U, 11400117376U, 11408504192U, 11416893568U, 11425283456U, |
||||
11433671552U, 11442061184U, 11450444672U, 11458837888U, 11467226752U, |
||||
11475611776U, 11484003968U, 11492392064U, 11500780672U, 11509169024U, |
||||
11517550976U, 11525944448U, 11534335616U, 11542724224U, 11551111808U, |
||||
11559500672U, 11567890304U, 11576277376U, 11584667008U, 11593056128U, |
||||
11601443456U, 11609830016U, 11618221952U, 11626607488U, 11634995072U, |
||||
11643387776U, 11651775104U, 11660161664U, 11668552576U, 11676940928U, |
||||
11685330304U, 11693718656U, 11702106496U, 11710496128U, 11718882688U, |
||||
11727273088U, 11735660416U, 11744050048U, 11752437376U, 11760824704U, |
||||
11769216128U, 11777604736U, 11785991296U, 11794381952U, 11802770048U, |
||||
11811157888U, 11819548544U, 11827932544U, 11836324736U, 11844713344U, |
||||
11853100928U, 11861486464U, 11869879936U, 11878268032U, 11886656896U, |
||||
11895044992U, 11903433088U, 11911822976U, 11920210816U, 11928600448U, |
||||
11936987264U, 11945375872U, 11953761152U, 11962151296U, 11970543488U, |
||||
11978928512U, 11987320448U, 11995708288U, 12004095104U, 12012486272U, |
||||
12020875136U, 12029255552U, 12037652096U, 12046039168U, 12054429568U, |
||||
12062813824U, 12071206528U, 12079594624U, 12087983744U, 12096371072U, |
||||
12104759936U, 12113147264U, 12121534592U, 12129924992U, 12138314624U, |
||||
12146703232U, 12155091584U, 12163481216U, 12171864704U, 12180255872U, |
||||
12188643968U, 12197034112U, 12205424512U, 12213811328U, 12222199424U, |
||||
12230590336U, 12238977664U, 12247365248U, 12255755392U, 12264143488U, |
||||
12272531584U, 12280920448U, 12289309568U, 12297694592U, 12306086528U, |
||||
12314475392U, 12322865024U, 12331253632U, 12339640448U, 12348029312U, |
||||
12356418944U, 12364805248U, 12373196672U, 12381580928U, 12389969024U, |
||||
12398357632U, 12406750592U, 12415138432U, 12423527552U, 12431916416U, |
||||
12440304512U, 12448692352U, 12457081216U, 12465467776U, 12473859968U, |
||||
12482245504U, 12490636672U, 12499025536U, 12507411584U, 12515801728U, |
||||
12524190592U, 12532577152U, 12540966272U, 12549354368U, 12557743232U, |
||||
12566129536U, 12574523264U, 12582911872U, 12591299456U, 12599688064U, |
||||
12608074624U, 12616463488U, 12624845696U, 12633239936U, 12641631616U, |
||||
12650019968U, 12658407296U, 12666795136U, 12675183232U, 12683574656U, |
||||
12691960192U, 12700350592U, 12708740224U, 12717128576U, 12725515904U, |
||||
12733906816U, 12742295168U, 12750680192U, 12759071872U, 12767460736U, |
||||
12775848832U, 12784236928U, 12792626816U, 12801014656U, 12809404288U, |
||||
12817789312U, 12826181504U, 12834568832U, 12842954624U, 12851345792U, |
||||
12859732352U, 12868122496U, 12876512128U, 12884901248U, 12893289088U, |
||||
12901672832U, 12910067584U, 12918455168U, 12926842496U, 12935232896U, |
||||
12943620736U, 12952009856U, 12960396928U, 12968786816U, 12977176192U, |
||||
12985563776U, 12993951104U, 13002341504U, 13010730368U, 13019115392U, |
||||
13027506304U, 13035895168U, 13044272512U, 13052673152U, 13061062528U, |
||||
13069446272U, 13077838976U, 13086227072U, 13094613632U, 13103000192U, |
||||
13111393664U, 13119782528U, 13128157568U, 13136559232U, 13144945024U, |
||||
13153329536U, 13161724288U, 13170111872U, 13178502784U, 13186884736U, |
||||
13195279744U, 13203667072U, 13212057472U, 13220445824U, 13228832128U, |
||||
13237221248U, 13245610624U, 13254000512U, 13262388352U, 13270777472U, |
||||
13279166336U, 13287553408U, 13295943296U, 13304331904U, 13312719488U, |
||||
13321108096U, 13329494656U, 13337885824U, 13346274944U, 13354663808U, |
||||
13363051136U, 13371439232U, 13379825024U, 13388210816U, 13396605056U, |
||||
13404995456U, 13413380224U, 13421771392U, 13430159744U, 13438546048U, |
||||
13446937216U, 13455326848U, 13463708288U, 13472103808U, 13480492672U, |
||||
13488875648U, 13497269888U, 13505657728U, 13514045312U, 13522435712U, |
||||
13530824576U, 13539210112U, 13547599232U, 13555989376U, 13564379008U, |
||||
13572766336U, 13581154432U, 13589544832U, 13597932928U, 13606320512U, |
||||
13614710656U, 13623097472U, 13631477632U, 13639874944U, 13648264064U, |
||||
13656652928U, 13665041792U, 13673430656U, 13681818496U, 13690207616U, |
||||
13698595712U, 13706982272U, 13715373184U, 13723762048U, 13732150144U, |
||||
13740536704U, 13748926592U, 13757316224U, 13765700992U, 13774090112U, |
||||
13782477952U, 13790869376U, 13799259008U, 13807647872U, 13816036736U, |
||||
13824425344U, 13832814208U, 13841202304U, 13849591424U, 13857978752U, |
||||
13866368896U, 13874754688U, 13883145344U, 13891533184U, 13899919232U, |
||||
13908311168U, 13916692096U, 13925085056U, 13933473152U, 13941866368U, |
||||
13950253696U, 13958643584U, 13967032192U, 13975417216U, 13983807616U, |
||||
13992197504U, 14000582272U, 14008973696U, 14017363072U, 14025752192U, |
||||
14034137984U, 14042528384U, 14050918016U, 14059301504U, 14067691648U, |
||||
14076083584U, 14084470144U, 14092852352U, 14101249664U, 14109635968U, |
||||
14118024832U, 14126407552U, 14134804352U, 14143188608U, 14151577984U, |
||||
14159968384U, 14168357248U, 14176741504U, 14185127296U, 14193521024U, |
||||
14201911424U, 14210301824U, 14218685056U, 14227067264U, 14235467392U, |
||||
14243855488U, 14252243072U, 14260630144U, 14269021568U, 14277409408U, |
||||
14285799296U, 14294187904U, 14302571392U, 14310961792U, 14319353728U, |
||||
14327738752U, 14336130944U, 14344518784U, 14352906368U, 14361296512U, |
||||
14369685376U, 14378071424U, 14386462592U, 14394848128U, 14403230848U, |
||||
14411627392U, 14420013952U, 14428402304U, 14436793472U, 14445181568U, |
||||
14453569664U, 14461959808U, 14470347904U, 14478737024U, 14487122816U, |
||||
14495511424U, 14503901824U, 14512291712U, 14520677504U, 14529064832U, |
||||
14537456768U, 14545845632U, 14554234496U, 14562618496U, 14571011456U, |
||||
14579398784U, 14587789184U, 14596172672U, 14604564608U, 14612953984U, |
||||
14621341312U, 14629724288U, 14638120832U, 14646503296U, 14654897536U, |
||||
14663284864U, 14671675264U, 14680061056U, 14688447616U, 14696835968U, |
||||
14705228416U, 14713616768U, 14722003328U, 14730392192U, 14738784128U, |
||||
14747172736U, 14755561088U, 14763947648U, 14772336512U, 14780725376U, |
||||
14789110144U, 14797499776U, 14805892736U, 14814276992U, 14822670208U, |
||||
14831056256U, 14839444352U, 14847836032U, 14856222848U, 14864612992U, |
||||
14872997504U, 14881388672U, 14889775744U, 14898165376U, 14906553472U, |
||||
14914944896U, 14923329664U, 14931721856U, 14940109696U, 14948497024U, |
||||
14956887424U, 14965276544U, 14973663616U, 14982053248U, 14990439808U, |
||||
14998830976U, 15007216768U, 15015605888U, 15023995264U, 15032385152U, |
||||
15040768384U, 15049154944U, 15057549184U, 15065939072U, 15074328448U, |
||||
15082715008U, 15091104128U, 15099493504U, 15107879296U, 15116269184U, |
||||
15124659584U, 15133042304U, 15141431936U, 15149824384U, 15158214272U, |
||||
15166602368U, 15174991232U, 15183378304U, 15191760512U, 15200154496U, |
||||
15208542592U, 15216931712U, 15225323392U, 15233708416U, 15242098048U, |
||||
15250489216U, 15258875264U, 15267265408U, 15275654528U, 15284043136U, |
||||
15292431488U, 15300819584U, 15309208192U, 15317596544U, 15325986176U, |
||||
15334374784U, 15342763648U, 15351151744U, 15359540608U, 15367929728U, |
||||
15376318336U, 15384706432U, 15393092992U, 15401481856U, 15409869952U, |
||||
15418258816U, 15426649984U, 15435037568U, 15443425664U, 15451815296U, |
||||
15460203392U, 15468589184U, 15476979328U, 15485369216U, 15493755776U, |
||||
15502146944U, 15510534272U, 15518924416U, 15527311232U, 15535699072U, |
||||
15544089472U, 15552478336U, 15560866688U, 15569254528U, 15577642624U, |
||||
15586031488U, 15594419072U, 15602809472U, 15611199104U, 15619586432U, |
||||
15627975296U, 15636364928U, 15644753792U, 15653141888U, 15661529216U, |
||||
15669918848U, 15678305152U, 15686696576U, 15695083136U, 15703474048U, |
||||
15711861632U, 15720251264U, 15728636288U, 15737027456U, 15745417088U, |
||||
15753804928U, 15762194048U, 15770582656U, 15778971008U, 15787358336U, |
||||
15795747712U, 15804132224U, 15812523392U, 15820909696U, 15829300096U, |
||||
15837691264U, 15846071936U, 15854466944U, 15862855808U, 15871244672U, |
||||
15879634816U, 15888020608U, 15896409728U, 15904799104U, 15913185152U, |
||||
15921577088U, 15929966464U, 15938354816U, 15946743424U, 15955129472U, |
||||
15963519872U, 15971907968U, 15980296064U, 15988684928U, 15997073024U, |
||||
16005460864U, 16013851264U, 16022241152U, 16030629248U, 16039012736U, |
||||
16047406976U, 16055794816U, 16064181376U, 16072571264U, 16080957824U, |
||||
16089346688U, 16097737856U, 16106125184U, 16114514816U, 16122904192U, |
||||
16131292544U, 16139678848U, 16148066944U, 16156453504U, 16164839552U, |
||||
16173236096U, 16181623424U, 16190012032U, 16198401152U, 16206790528U, |
||||
16215177344U, 16223567744U, 16231956352U, 16240344704U, 16248731008U, |
||||
16257117824U, 16265504384U, 16273898624U, 16282281856U, 16290668672U, |
||||
16299064192U, 16307449216U, 16315842176U, 16324230016U, 16332613504U, |
||||
16341006464U, 16349394304U, 16357783168U, 16366172288U, 16374561664U, |
||||
16382951296U, 16391337856U, 16399726208U, 16408116352U, 16416505472U, |
||||
16424892032U, 16433282176U, 16441668224U, 16450058624U, 16458448768U, |
||||
16466836864U, 16475224448U, 16483613056U, 16492001408U, 16500391808U, |
||||
16508779648U, 16517166976U, 16525555328U, 16533944192U, 16542330752U, |
||||
16550719616U, 16559110528U, 16567497088U, 16575888512U, 16584274816U, |
||||
16592665472U, 16601051008U, 16609442944U, 16617832064U, 16626218624U, |
||||
16634607488U, 16642996096U, 16651385728U, 16659773824U, 16668163712U, |
||||
16676552576U, 16684938112U, 16693328768U, 16701718144U, 16710095488U, |
||||
16718492288U, 16726883968U, 16735272832U, 16743661184U, 16752049792U, |
||||
16760436608U, 16768827008U, 16777214336U, 16785599104U, 16793992832U, |
||||
16802381696U, 16810768768U, 16819151744U, 16827542656U, 16835934848U, |
||||
16844323712U, 16852711552U, 16861101952U, 16869489536U, 16877876864U, |
||||
16886265728U, 16894653056U, 16903044736U, 16911431296U, 16919821696U, |
||||
16928207488U, 16936592768U, 16944987776U, 16953375616U, 16961763968U, |
||||
16970152832U, 16978540928U, 16986929536U, 16995319168U, 17003704448U, |
||||
17012096896U, 17020481152U, 17028870784U, 17037262208U, 17045649536U, |
||||
17054039936U, 17062426496U, 17070814336U, 17079205504U, 17087592064U, |
||||
17095978112U, 17104369024U, 17112759424U, 17121147776U, 17129536384U, |
||||
17137926016U, 17146314368U, 17154700928U, 17163089792U, 17171480192U, |
||||
17179864192U, 17188256896U, 17196644992U, 17205033856U, 17213423488U, |
||||
17221811072U, 17230198912U, 17238588032U, 17246976896U, 17255360384U, |
||||
17263754624U, 17272143232U, 17280530048U, 17288918912U, 17297309312U, |
||||
17305696384U, 17314085504U, 17322475136U, 17330863744U, 17339252096U, |
||||
17347640192U, 17356026496U, 17364413824U, 17372796544U, 17381190016U, |
||||
17389583488U, 17397972608U, 17406360704U, 17414748544U, 17423135872U, |
||||
17431527296U, 17439915904U, 17448303232U, 17456691584U, 17465081728U, |
||||
17473468288U, 17481857408U, 17490247552U, 17498635904U, 17507022464U, |
||||
17515409024U, 17523801728U, 17532189824U, 17540577664U, 17548966016U, |
||||
17557353344U, 17565741184U, 17574131584U, 17582519168U, 17590907008U, |
||||
17599296128U, 17607687808U, 17616076672U, 17624455808U, 17632852352U, |
||||
17641238656U, 17649630848U, 17658018944U, 17666403968U, 17674794112U, |
||||
17683178368U, 17691573376U, 17699962496U, 17708350592U, 17716739968U, |
||||
17725126528U, 17733517184U, 17741898112U, 17750293888U, 17758673024U, |
||||
17767070336U, 17775458432U, 17783848832U, 17792236928U, 17800625536U, |
||||
17809012352U, 17817402752U, 17825785984U, 17834178944U, 17842563968U, |
||||
17850955648U, 17859344512U, 17867732864U, 17876119424U, 17884511872U, |
||||
17892900224U, 17901287296U, 17909677696U, 17918058112U, 17926451072U, |
||||
17934843776U, 17943230848U, 17951609216U, 17960008576U, 17968397696U, |
||||
17976784256U, 17985175424U, 17993564032U, 18001952128U, 18010339712U, |
||||
18018728576U, 18027116672U, 18035503232U, 18043894144U, 18052283264U, |
||||
18060672128U, 18069056384U, 18077449856U, 18085837184U, 18094225792U, |
||||
18102613376U, 18111004544U, 18119388544U, 18127781248U, 18136170368U, |
||||
18144558976U, 18152947328U, 18161336192U, 18169724288U, 18178108544U, |
||||
18186498944U, 18194886784U, 18203275648U, 18211666048U, 18220048768U, |
||||
18228444544U, 18236833408U, 18245220736U |
||||
}; |
||||
|
||||
|
||||
// Generated with the following Mathematica Code:
|
||||
|
||||
// GetCacheSizes[n_] := Module[{
|
||||
// DataSetSizeBytesInit = 2^30,
|
||||
// MixBytes = 128,
|
||||
// DataSetGrowth = 2^23,
|
||||
// HashBytes = 64,
|
||||
// CacheMultiplier = 1024,
|
||||
// j = 0},
|
||||
// Reap[
|
||||
// While[j < n,
|
||||
// Module[{i = Floor[(DataSetSizeBytesInit + DataSetGrowth * j) / (CacheMultiplier * HashBytes)]},
|
||||
// While[! PrimeQ[i], i--];
|
||||
// Sow[i*HashBytes]; j++]]]][[2]][[1]]
|
||||
|
||||
const size_t cache_sizes[] = { |
||||
1048384U, 1055552U, 1064512U, 1072832U, 1080896U, 1089344U, 1096768U, |
||||
1104448U, 1113664U, 1121216U, 1130176U, 1138624U, 1146304U, 1155008U, |
||||
1162816U, 1171264U, 1179328U, 1187392U, 1195456U, 1203392U, 1210816U, |
||||
1220416U, 1227712U, 1236416U, 1244608U, 1253312U, 1261376U, 1268416U, |
||||
1277632U, 1285696U, 1294016U, 1302208U, 1310656U, 1318336U, 1326784U, |
||||
1334848U, 1342912U, 1350848U, 1359808U, 1366208U, 1376192U, 1383488U, |
||||
1392448U, 1400384U, 1408832U, 1416512U, 1425344U, 1433408U, 1440704U, |
||||
1449664U, 1458112U, 1466048U, 1474496U, 1482688U, 1490752U, 1498688U, |
||||
1507136U, 1515328U, 1523264U, 1531456U, 1539904U, 1547584U, 1556288U, |
||||
1564352U, 1572544U, 1580608U, 1588544U, 1596992U, 1605568U, 1612096U, |
||||
1621952U, 1630144U, 1637696U, 1645888U, 1654336U, 1662784U, 1671104U, |
||||
1679168U, 1686848U, 1695296U, 1702208U, 1711168U, 1720256U, 1727552U, |
||||
1736128U, 1744576U, 1751488U, 1760576U, 1769408U, 1777472U, 1785664U, |
||||
1793984U, 1801664U, 1810112U, 1818304U, 1826624U, 1834816U, 1842752U, |
||||
1851328U, 1858112U, 1867456U, 1875904U, 1883968U, 1892288U, 1899712U, |
||||
1908416U, 1916608U, 1924544U, 1932992U, 1940672U, 1948736U, 1956928U, |
||||
1965632U, 1973824U, 1982144U, 1989824U, 1998784U, 2006848U, 2014784U, |
||||
2022848U, 2031424U, 2038976U, 2047424U, 2055616U, 2064064U, 2072384U, |
||||
2080448U, 2088512U, 2095936U, 2104768U, 2113472U, 2121664U, 2127808U, |
||||
2137792U, 2146112U, 2153408U, 2162624U, 2170304U, 2178496U, 2186944U, |
||||
2195392U, 2203456U, 2211136U, 2219968U, 2227648U, 2236096U, 2244416U, |
||||
2250944U, 2260928U, 2268736U, 2276672U, 2283328U, 2293696U, 2301632U, |
||||
2309312U, 2317888U, 2325952U, 2334656U, 2342848U, 2350144U, 2358848U, |
||||
2366656U, 2375488U, 2383552U, 2391616U, 2400064U, 2407616U, 2415808U, |
||||
2424256U, 2432704U, 2439616U, 2448704U, 2457152U, 2464064U, 2473792U, |
||||
2482112U, 2489792U, 2497472U, 2506432U, 2514752U, 2522816U, 2531264U, |
||||
2539456U, 2547136U, 2555456U, 2564032U, 2572096U, 2578496U, 2587712U, |
||||
2595776U, 2604736U, 2613056U, 2620736U, 2629184U, 2637632U, 2645824U, |
||||
2653888U, 2662208U, 2670016U, 2678464U, 2686912U, 2694464U, 2703296U, |
||||
2710976U, 2719424U, 2727104U, 2736064U, 2743232U, 2752192U, 2760512U, |
||||
2768704U, 2777024U, 2785088U, 2792512U, 2800576U, 2809024U, 2817856U, |
||||
2826176U, 2833984U, 2840896U, 2850752U, 2858048U, 2867008U, 2875328U, |
||||
2883392U, 2891584U, 2899648U, 2908096U, 2915648U, 2924224U, 2932672U, |
||||
2940736U, 2948672U, 2956736U, 2964928U, 2973248U, 2981824U, 2988992U, |
||||
2997184U, 3005248U, 3013952U, 3022144U, 3030592U, 3037376U, 3046976U, |
||||
3055552U, 3063616U, 3070784U, 3079744U, 3087808U, 3096512U, 3103808U, |
||||
3111872U, 3121088U, 3128896U, 3137216U, 3144896U, 3153856U, 3161152U, |
||||
3169984U, 3178432U, 3186496U, 3194816U, 3203008U, 3210176U, 3218624U, |
||||
3227072U, 3235264U, 3243712U, 3250496U, 3259456U, 3268544U, 3276736U, |
||||
3283648U, 3292736U, 3301184U, 3308224U, 3317696U, 3324736U, 3333184U, |
||||
3342272U, 3348544U, 3357248U, 3365312U, 3374912U, 3383104U, 3390784U, |
||||
3399488U, 3407296U, 3414976U, 3424192U, 3432256U, 3440576U, 3448768U, |
||||
3456832U, 3464896U, 3473216U, 3480128U, 3489344U, 3497408U, 3505856U, |
||||
3514048U, 3521344U, 3530432U, 3538624U, 3546304U, 3555008U, 3563072U, |
||||
3571648U, 3579712U, 3587392U, 3595456U, 3603904U, 3612352U, 3620416U, |
||||
3628864U, 3636928U, 3645248U, 3652928U, 3660992U, 3669184U, 3677888U, |
||||
3685952U, 3694528U, 3702592U, 3710528U, 3719104U, 3727168U, 3735488U, |
||||
3742784U, 3751232U, 3759424U, 3765184U, 3775808U, 3783872U, 3792832U, |
||||
3800768U, 3808832U, 3816256U, 3825344U, 3832768U, 3841856U, 3849536U, |
||||
3857344U, 3866432U, 3874496U, 3882304U, 3890752U, 3899072U, 3907264U, |
||||
3914816U, 3923008U, 3930688U, 3939904U, 3947968U, 3956416U, 3964736U, |
||||
3972544U, 3981248U, 3988928U, 3997376U, 4005824U, 4012864U, 4020928U, |
||||
4030144U, 4038592U, 4045504U, 4054592U, 4063168U, 4071104U, 4079552U, |
||||
4087232U, 4095808U, 4103872U, 4111168U, 4120384U, 4127936U, 4136512U, |
||||
4144832U, 4153024U, 4160704U, 4169408U, 4177216U, 4186048U, 4193344U, |
||||
4202048U, 4210496U, 4217536U, 4227008U, 4235072U, 4243264U, 4251584U, |
||||
4259392U, 4267712U, 4275776U, 4284352U, 4291904U, 4300096U, 4307648U, |
||||
4316992U, 4325056U, 4333376U, 4341056U, 4349888U, 4357568U, 4366016U, |
||||
4374464U, 4382528U, 4390208U, 4398656U, 4407232U, 4413632U, 4423616U, |
||||
4431808U, 4439744U, 4447936U, 4455872U, 4463296U, 4472128U, 4480576U, |
||||
4489024U, 4497344U, 4505152U, 4512448U, 4520896U, 4530112U, 4537664U, |
||||
4546496U, 4554688U, 4562752U, 4570816U, 4579264U, 4586944U, 4595648U, |
||||
4603712U, 4611392U, 4619072U, 4628032U, 4635584U, 4643776U, 4652864U, |
||||
4660672U, 4669376U, 4677056U, 4684096U, 4693184U, 4702144U, 4710208U, |
||||
4718528U, 4726336U, 4734272U, 4742464U, 4750784U, 4759232U, 4767296U, |
||||
4775872U, 4783808U, 4791872U, 4797376U, 4808512U, 4816192U, 4825024U, |
||||
4832704U, 4841024U, 4849472U, 4856512U, 4865984U, 4874176U, 4882112U, |
||||
4889792U, 4898752U, 4906688U, 4913984U, 4922816U, 4931008U, 4938944U, |
||||
4946624U, 4955584U, 4964032U, 4972096U, 4980032U, 4988864U, 4997056U, |
||||
5004992U, 5012288U, 5020096U, 5029312U, 5037632U, 5045696U, 5052224U, |
||||
5062592U, 5070784U, 5078848U, 5086784U, 5095232U, 5100736U, 5111488U, |
||||
5119936U, 5127104U, 5136064U, 5143616U, 5151424U, 5160256U, 5168704U, |
||||
5175232U, 5185472U, 5192384U, 5199296U, 5209664U, 5218112U, 5225536U, |
||||
5233472U, 5242816U, 5250496U, 5258944U, 5267264U, 5274944U, 5283776U, |
||||
5290048U, 5300032U, 5308096U, 5316544U, 5323328U, 5331904U, 5340736U, |
||||
5349056U, 5356864U, 5365312U, 5372096U, 5381696U, 5390272U, 5398336U, |
||||
5405888U, 5413696U, 5422784U, 5430976U, 5439424U, 5446976U, 5455808U, |
||||
5463616U, 5471168U, 5480128U, 5488064U, 5494592U, 5504704U, 5513152U, |
||||
5521216U, 5529536U, 5536576U, 5544256U, 5554112U, 5559616U, 5570368U, |
||||
5577664U, 5586752U, 5594944U, 5603008U, 5611456U, 5619392U, 5627584U, |
||||
5634368U, 5643328U, 5651264U, 5659328U, 5667008U, 5675584U, 5684416U, |
||||
5692864U, 5701568U, 5709632U, 5717056U, 5725376U, 5734336U, 5740096U, |
||||
5750336U, 5758912U, 5766848U, 5775296U, 5782976U, 5790784U, 5799616U, |
||||
5807936U, 5815232U, 5823808U, 5832256U, 5840192U, 5848768U, 5856832U, |
||||
5864896U, 5873344U, 5879872U, 5888576U, 5897792U, 5905216U, 5914432U, |
||||
5920448U, 5930944U, 5938624U, 5947328U, 5955392U, 5963456U, 5971648U, |
||||
5979328U, 5988032U, 5995712U, 6003904U, 6012736U, 6021056U, 6029248U, |
||||
6037184U, 6045632U, 6053312U, 6061376U, 6070208U, 6077504U, 6086464U, |
||||
6094784U, 6101696U, 6110912U, 6118592U, 6127168U, 6135616U, 6143296U, |
||||
6150208U, 6158912U, 6168128U, 6175808U, 6182464U, 6192832U, 6201152U, |
||||
6209344U, 6217664U, 6224576U, 6233408U, 6241472U, 6249664U, 6258496U, |
||||
6266816U, 6275008U, 6281152U, 6291136U, 6299456U, 6306752U, 6314816U, |
||||
6323776U, 6332096U, 6339392U, 6348224U, 6356288U, 6364096U, 6373184U, |
||||
6381376U, 6389696U, 6397504U, 6404416U, 6413632U, 6421952U, 6430016U, |
||||
6437824U, 6446912U, 6454592U, 6463168U, 6471616U, 6478144U, 6487232U, |
||||
6496192U, 6504128U, 6511936U, 6520256U, 6528832U, 6536896U, 6544576U, |
||||
6553408U, 6561472U, 6569792U, 6577216U, 6586304U, 6592448U, 6601024U, |
||||
6610624U, 6619072U, 6627136U, 6634816U, 6643264U, 6650816U, 6659776U, |
||||
6667712U, 6675904U, 6682688U, 6691904U, 6700864U, 6709184U, 6717376U, |
||||
6724544U, 6733504U, 6741824U, 6749888U, 6756032U, 6766528U, 6773056U, |
||||
6782912U, 6790976U, 6798016U, 6807488U, 6815168U, 6823744U, 6832064U, |
||||
6840128U, 6847552U, 6855872U, 6864064U, 6872128U, 6880576U, 6889408U, |
||||
6897472U, 6905792U, 6913472U, 6920896U, 6930368U, 6938432U, 6946624U, |
||||
6953536U, 6963136U, 6971072U, 6979136U, 6986944U, 6995392U, 7003712U, |
||||
7012288U, 7019072U, 7028416U, 7036352U, 7044416U, 7051712U, 7060672U, |
||||
7069376U, 7077568U, 7085504U, 7092544U, 7102016U, 7110592U, 7118656U, |
||||
7126208U, 7135168U, 7143104U, 7150912U, 7159744U, 7167808U, 7175744U, |
||||
7184192U, 7191232U, 7200448U, 7207744U, 7216576U, 7224128U, 7233472U, |
||||
7241536U, 7249856U, 7256512U, 7264832U, 7274048U, 7282112U, 7290176U, |
||||
7298752U, 7306688U, 7315136U, 7322816U, 7331392U, 7339456U, 7347776U, |
||||
7356224U, 7364288U, 7371712U, 7380928U, 7387456U, 7396544U, 7404352U, |
||||
7413568U, 7421632U, 7429696U, 7436864U, 7446464U, 7454144U, 7461952U, |
||||
7470784U, 7478336U, 7487296U, 7495616U, 7503424U, 7511872U, 7520192U, |
||||
7527616U, 7536448U, 7544512U, 7551424U, 7560128U, 7568576U, 7577536U, |
||||
7583552U, 7592512U, 7600448U, 7610048U, 7618496U, 7626176U, 7634752U, |
||||
7642816U, 7651264U, 7659328U, 7667008U, 7675456U, 7683136U, 7691584U, |
||||
7700416U, 7707584U, 7716416U, 7724224U, 7733056U, 7740608U, 7749184U, |
||||
7756096U, 7765952U, 7774016U, 7781824U, 7790528U, 7798592U, 7805888U, |
||||
7814336U, 7822784U, 7831232U, 7839296U, 7847104U, 7855552U, 7863616U, |
||||
7872448U, 7880128U, 7888576U, 7896256U, 7905088U, 7912768U, 7920448U, |
||||
7928768U, 7937344U, 7945792U, 7953728U, 7959488U, 7970752U, 7978816U, |
||||
7987136U, 7994816U, 8003392U, 8011712U, 8019904U, 8027456U, 8035264U, |
||||
8044352U, 8052544U, 8060224U, 8069056U, 8076736U, 8084672U, 8093504U, |
||||
8101312U, 8110016U, 8117696U, 8125888U, 8134592U, 8142016U, 8149952U, |
||||
8159168U, 8166976U, 8175296U, 8183488U, 8191808U, 8199616U, 8207296U, |
||||
8216128U, 8224576U, 8232256U, 8241088U, 8248256U, 8257472U, 8264128U, |
||||
8273728U, 8281792U, 8290112U, 8297152U, 8305216U, 8314816U, 8322752U, |
||||
8330944U, 8339392U, 8347072U, 8355392U, 8363968U, 8371904U, 8379328U, |
||||
8388544U, 8394944U, 8404544U, 8412736U, 8421184U, 8429504U, 8437696U, |
||||
8445376U, 8452544U, 8460736U, 8470208U, 8478016U, 8486848U, 8494144U, |
||||
8503232U, 8511296U, 8519488U, 8527424U, 8534464U, 8543936U, 8552384U, |
||||
8558912U, 8568128U, 8575936U, 8584256U, 8593216U, 8601536U, 8608832U, |
||||
8616896U, 8625728U, 8634176U, 8641856U, 8649664U, 8658112U, 8666176U, |
||||
8674112U, 8682944U, 8691136U, 8699456U, 8707648U, 8716096U, 8724416U, |
||||
8732608U, 8740672U, 8748352U, 8756032U, 8764864U, 8773568U, 8781376U, |
||||
8789824U, 8796992U, 8806208U, 8814272U, 8822336U, 8830912U, 8838848U, |
||||
8847296U, 8854336U, 8863552U, 8871488U, 8879296U, 8887616U, 8894528U, |
||||
8904512U, 8911424U, 8920768U, 8928704U, 8936128U, 8944576U, 8953664U, |
||||
8960576U, 8970176U, 8977984U, 8986304U, 8994112U, 9002432U, 9011008U, |
||||
9018176U, 9026624U, 9035584U, 9043904U, 9052096U, 9059264U, 9068096U, |
||||
9075904U, 9084224U, 9092288U, 9100352U, 9108928U, 9116992U, 9125824U, |
||||
9133504U, 9141824U, 9150272U, 9157952U, 9164608U, 9174848U, 9182912U, |
||||
9190976U, 9199552U, 9205312U, 9215936U, 9222592U, 9232192U, 9240512U, |
||||
9248704U, 9256256U, 9264832U, 9272896U, 9281344U, 9288896U, 9297088U, |
||||
9305536U, 9313984U, 9322304U, 9329728U, 9337792U, 9346112U, 9355072U, |
||||
9363136U, 9371072U, 9378752U, 9387712U, 9395648U, 9404224U, 9411008U, |
||||
9420608U, 9428416U, 9436864U, 9445312U, 9453376U, 9460928U, 9468736U, |
||||
9477824U, 9485248U, 9493696U, 9502144U, 9509056U, 9518528U, 9527104U, |
||||
9535424U, 9543616U, 9551296U, 9559744U, 9568192U, 9576256U, 9584576U, |
||||
9591872U, 9600704U, 9608384U, 9615808U, 9624512U, 9633472U, 9641536U, |
||||
9649856U, 9658048U, 9665728U, 9674432U, 9682496U, 9691072U, 9699136U, |
||||
9707072U, 9715136U, 9722176U, 9732032U, 9740096U, 9747904U, 9756352U, |
||||
9764288U, 9771584U, 9780544U, 9789376U, 9796928U, 9804224U, 9813952U, |
||||
9822016U, 9829696U, 9838016U, 9845824U, 9852992U, 9863104U, 9870656U, |
||||
9878464U, 9887552U, 9895744U, 9903808U, 9912128U, 9920192U, 9927616U, |
||||
9936064U, 9944768U, 9952576U, 9960128U, 9969472U, 9977152U, 9985216U, |
||||
9994048U, 10001216U, 10007744U, 10018496U, 10026944U, 10035136U, 10042432U, |
||||
10051264U, 10059584U, 10067648U, 10075712U, 10083904U, 10091456U, 10100672U, |
||||
10108864U, 10116928U, 10124864U, 10133056U, 10140736U, 10149824U, 10156736U, |
||||
10165952U, 10173376U, 10182208U, 10190528U, 10198336U, 10206272U, 10213696U, |
||||
10223296U, 10231744U, 10238656U, 10247488U, 10256192U, 10263872U, 10272448U, |
||||
10280896U, 10288448U, 10296512U, 10305088U, 10313536U, 10321088U, 10330048U, |
||||
10337984U, 10346176U, 10354112U, 10362304U, 10369088U, 10377152U, 10386752U, |
||||
10394816U, 10403648U, 10411712U, 10418624U, 10427968U, 10436032U, 10444736U, |
||||
10452928U, 10459712U, 10468672U, 10476608U, 10484416U, 10491328U, 10501952U, |
||||
10509376U, 10517824U, 10526528U, 10534336U, 10542656U, 10549696U, 10559168U, |
||||
10566592U, 10575808U, 10583488U, 10590656U, 10599488U, 10607936U, 10616768U, |
||||
10624832U, 10630336U, 10640576U, 10649536U, 10655168U, 10665152U, 10674112U, |
||||
10682176U, 10690496U, 10698176U, 10705216U, 10715072U, 10722752U, 10731328U, |
||||
10739264U, 10746688U, 10754752U, 10761664U, 10770752U, 10779712U, 10787776U, |
||||
10796608U, 10803392U, 10812352U, 10821056U, 10828736U, 10837952U, 10846144U, |
||||
10853824U, 10861376U, 10869952U, 10877248U, 10887104U, 10895296U, 10903232U, |
||||
10910912U, 10918976U, 10927936U, 10935872U, 10944448U, 10952384U, 10960832U, |
||||
10968512U, 10977088U, 10985024U, 10992832U, 11000896U, 11009984U, 11018048U, |
||||
11026112U, 11034304U, 11042624U, 11050432U, 11058368U, 11064512U, 11075392U, |
||||
11083712U, 11091776U, 11099584U, 11107904U, 11115968U, 11124416U, 11131712U, |
||||
11141056U, 11148608U, 11157184U, 11165248U, 11173312U, 11180992U, 11189056U, |
||||
11197376U, 11206592U, 11214656U, 11222336U, 11230784U, 11238464U, 11246528U, |
||||
11254976U, 11263552U, 11271872U, 11279552U, 11288512U, 11296576U, 11304256U, |
||||
11312192U, 11320768U, 11329216U, 11336384U, 11345216U, 11352512U, 11362112U, |
||||
11369408U, 11378624U, 11386688U, 11394496U, 11402816U, 11411264U, 11418688U, |
||||
11427776U, 11435584U, 11444032U, 11452096U, 11459648U, 11467072U, 11476928U, |
||||
11484992U, 11493184U, 11500352U, 11509312U, 11517248U, 11524928U, 11534144U, |
||||
11542208U, 11550272U, 11556416U, 11566784U, 11574208U, 11581376U, 11589568U, |
||||
11599552U, 11607104U, 11616064U, 11623616U, 11632576U, 11639872U, 11648704U, |
||||
11657024U, 11664704U, 11672896U, 11681216U, 11689792U, 11697856U, 11705536U, |
||||
11714368U, 11722688U, 11730496U, 11737408U, 11745728U, 11754304U, 11763008U, |
||||
11770816U, 11779648U, 11788096U, 11795776U, 11804608U, 11812544U, 11820992U, |
||||
11829184U, 11837248U, 11844928U, 11852096U, 11860928U, 11869888U, 11878336U, |
||||
11886272U, 11894336U, 11902144U, 11910848U, 11919296U, 11925952U, 11934784U, |
||||
11943616U, 11951552U, 11960128U, 11968192U, 11976512U, 11983168U, 11992768U, |
||||
12000832U, 12008896U, 12016832U, 12025408U, 12033856U, 12042176U, 12049984U, |
||||
12058048U, 12066112U, 12073792U, 12082624U, 12091328U, 12098752U, 12106816U, |
||||
12115904U, 12124096U, 12131776U, 12140224U, 12148672U, 12156736U, 12164032U, |
||||
12173248U, 12181184U, 12186176U, 12197824U, 12205888U, 12213952U, 12218944U, |
||||
12230336U, 12238784U, 12246592U, 12254272U, 12262336U, 12269888U, 12279104U, |
||||
12287936U, 12295744U, 12304064U, 12312512U, 12319936U, 12328768U, 12337088U, |
||||
12344896U, 12352832U, 12361408U, 12368704U, 12377152U, 12384832U, 12394432U, |
||||
12402496U, 12409024U, 12417728U, 12426688U, 12433216U, 12443584U, 12450752U, |
||||
12459968U, 12468032U, 12475712U, 12484544U, 12492608U, 12500416U, 12508352U, |
||||
12517184U, 12525376U, 12532288U, 12541888U, 12549568U, 12556864U, 12565568U, |
||||
12574528U, 12582208U, 12590528U, 12598592U, 12607424U, 12615488U, 12623552U, |
||||
12631744U, 12638656U, 12647744U, 12656576U, 12664768U, 12672832U, 12680896U, |
||||
12688576U, 12697408U, 12704192U, 12713408U, 12721216U, 12729664U, 12738496U, |
||||
12745792U, 12754496U, 12762688U, 12769472U, 12779456U, 12787648U, 12795712U, |
||||
12804032U, 12812224U, 12819008U, 12828352U, 12836672U, 12844736U, 12851648U, |
||||
12859456U, 12868672U, 12877504U, 12885568U, 12892864U, 12902336U, 12909376U, |
||||
12918208U, 12926656U, 12934976U, 12942784U, 12951104U, 12959552U, 12967744U, |
||||
12976064U, 12984256U, 12991936U, 12999488U, 13007936U, 13016768U, 13021504U, |
||||
13033024U, 13041472U, 13049408U, 13057472U, 13065664U, 13072064U, 13081408U, |
||||
13089344U, 13098688U, 13107008U, 13115072U, 13122752U, 13130944U, 13139648U, |
||||
13147712U, 13155776U, 13162432U, 13172672U, 13180864U, 13188928U, 13196992U, |
||||
13203392U, 13213504U, 13219264U, 13228736U, 13236928U, 13244992U, 13253056U, |
||||
13262528U, 13269952U, 13278784U, 13285952U, 13295552U, 13303616U, 13311808U, |
||||
13319744U, 13328192U, 13336256U, 13344704U, 13352384U, 13360576U, 13369024U, |
||||
13377344U, 13385408U, 13393216U, 13401664U, 13410112U, 13418176U, 13426496U, |
||||
13434688U, 13442368U, 13451072U, 13459136U, 13466944U, 13475648U, 13482944U, |
||||
13491904U, 13500352U, 13508288U, 13516736U, 13524416U, 13532224U, 13541312U, |
||||
13549504U, 13556288U, 13564736U, 13573184U, 13581376U, 13587008U, 13598656U, |
||||
13605952U, 13612864U, 13622464U, 13631168U, 13639616U, 13647808U, 13655104U, |
||||
13663424U, 13671872U, 13680064U, 13688768U, 13696576U, 13705024U, 13712576U, |
||||
13721536U, 13729216U, 13737664U, 13746112U, 13753024U, 13759552U, 13770304U, |
||||
13777856U, 13786688U, 13793984U, 13802176U, 13811264U, 13819328U, 13827904U, |
||||
13835456U, 13844416U, 13851584U, 13860544U, 13868992U, 13877056U, 13884608U, |
||||
13893184U, 13901248U, 13909696U, 13917632U, 13925056U, 13934528U, 13942336U, |
||||
13950784U, 13959104U, 13966912U, 13975232U, 13982656U, 13991872U, 13999936U, |
||||
14007872U, 14016064U, 14024512U, 14032064U, 14040896U, 14049088U, 14057408U, |
||||
14065088U, 14072896U, 14081344U, 14089664U, 14097856U, 14106304U, 14114752U, |
||||
14122688U, 14130752U, 14138816U, 14147008U, 14155072U, 14163904U, 14170432U, |
||||
14180288U, 14187328U, 14196032U, 14204864U, 14212672U, 14220736U, 14229056U, |
||||
14237504U, 14245568U, 14253632U, 14261824U, 14269888U, 14278592U, 14286656U, |
||||
14293696U, 14302784U, 14309696U, 14317504U, 14326336U, 14335936U, 14343232U, |
||||
14352064U, 14359232U, 14368064U, 14376512U, 14384576U, 14393024U, 14401472U, |
||||
14409536U, 14416832U, 14424512U, 14433856U, 14440768U, 14449984U, 14458816U, |
||||
14465728U, 14474816U, 14482112U, 14491328U, 14499392U, 14506816U, 14516032U, |
||||
14524352U, 14531392U, 14540224U, 14547392U, 14556992U, 14565184U, 14573248U, |
||||
14580928U, 14588864U, 14596928U, 14606272U, 14613824U, 14622656U, 14630464U, |
||||
14638912U, 14646976U, 14655296U, 14661952U, 14671808U, 14679872U, 14687936U, |
||||
14696384U, 14704576U, 14710336U, 14720192U, 14729152U, 14736448U, 14745152U, |
||||
14752448U, 14761792U, 14769856U, 14777024U, 14785984U, 14792384U, 14802752U, |
||||
14810816U, 14819264U, 14827328U, 14835136U, 14843072U, 14851264U, 14860096U, |
||||
14867648U, 14876096U, 14884544U, 14892736U, 14900672U, 14907968U, 14917312U, |
||||
14924864U, 14933824U, 14939968U, 14950336U, 14957632U, 14966464U, 14974912U, |
||||
14982592U, 14991296U, 14999104U, 15006272U, 15015232U, 15023936U, 15031616U, |
||||
15040448U, 15047488U, 15055552U, 15063616U, 15073216U, 15079744U, 15088064U, |
||||
15097664U, 15105344U, 15113792U, 15122368U, 15130048U, 15137728U, 15146176U, |
||||
15154112U, 15162688U, 15171392U, 15179456U, 15187264U, 15194176U, 15204032U, |
||||
15212224U, 15220544U, 15227456U, 15237056U, 15245248U, 15253184U, 15261632U, |
||||
15269824U, 15277376U, 15285824U, 15293888U, 15301568U, 15310784U, 15318848U, |
||||
15325504U, 15335104U, 15343168U, 15350848U, 15359936U, 15367232U, 15373376U, |
||||
15384256U, 15392576U, 15400384U, 15408832U, 15417152U, 15424832U, 15433024U, |
||||
15441344U, 15449152U, 15457088U, 15466432U, 15474112U, 15482816U, 15488576U, |
||||
15499072U, 15505856U, 15514816U, 15523264U, 15531584U, 15540032U, 15547328U, |
||||
15553984U, 15564608U, 15571904U, 15579968U, 15589312U, 15597376U, 15605696U, |
||||
15612992U, 15621824U, 15630016U, 15638464U, 15646144U, 15654592U, 15662912U, |
||||
15671104U, 15677248U, 15686848U, 15693376U, 15701696U, 15712064U, 15720256U, |
||||
15728576U, 15736384U, 15744704U, 15752512U, 15761344U, 15769024U, 15777728U, |
||||
15785152U, 15793984U, 15802048U, 15809984U, 15817024U, 15825856U, 15834944U, |
||||
15843008U, 15849664U, 15859136U, 15866432U, 15876032U, 15884096U, 15892288U, |
||||
15900608U, 15908416U, 15916864U, 15924928U, 15930176U, 15941056U, 15949504U, |
||||
15957824U, 15965632U, 15973952U, 15982528U, 15990592U, 15998272U, 16006976U, |
||||
16012736U, 16023104U, 16031296U, 16039616U, 16048064U, 16055744U, 16064192U, |
||||
16071488U, 16080832U, 16088768U, 16097216U, 16104896U, 16112704U, 16121792U, |
||||
16129856U, 16138048U, 16146112U, 16154176U, 16162624U, 16170688U, 16177856U, |
||||
16186816U, 16195136U, 16202176U, 16211648U, 16220096U, 16228288U, 16235584U, |
||||
16244672U, 16252864U, 16260544U, 16269248U, 16277056U, 16285504U, 16291648U, |
||||
16301632U, 16309312U, 16318144U, 16326208U, 16333888U, 16342336U, 16351168U, |
||||
16359232U, 16367552U, 16375616U, 16383296U, 16391744U, 16398016U, 16407616U, |
||||
16415936U, 16424896U, 16432448U, 16440896U, 16449088U, 16457024U, 16465472U, |
||||
16474048U, 16481216U, 16490048U, 16498624U, 16505792U, 16513984U, 16523072U, |
||||
16531136U, 16538944U, 16547264U, 16555328U, 16563776U, 16570816U, 16578112U, |
||||
16587712U, 16596544U, 16604992U, 16613312U, 16620608U, 16629568U, 16637888U, |
||||
16645696U, 16653632U, 16661696U, 16669888U, 16677568U, 16686272U, 16695232U, |
||||
16703168U, 16710464U, 16719424U, 16726592U, 16733888U, 16744384U, 16752448U, |
||||
16760768U, 16768448U, 16776896U, 16785344U, 16793536U, 16801216U, 16809664U, |
||||
16818112U, 16826176U, 16833472U, 16842688U, 16850752U, 16859072U, 16866368U, |
||||
16875328U, 16883392U, 16891712U, 16899776U, 16907456U, 16915264U, 16924352U, |
||||
16931776U, 16940608U, 16949056U, 16957376U, 16965056U, 16973248U, 16981696U, |
||||
16990144U, 16997056U, 17005888U, 17014208U, 17021504U, 17031104U, 17039296U, |
||||
17046976U, 17055424U, 17062592U, 17070016U, 17079488U, 17087936U, 17096512U, |
||||
17104576U, 17113024U, 17121088U, 17129408U, 17136832U, 17145664U, 17152832U, |
||||
17161792U, 17170112U, 17177792U, 17186368U, 17194304U, 17202496U, 17211328U, |
||||
17218624U, 17227712U, 17233984U, 17243584U, 17251904U, 17259712U, 17266624U, |
||||
17276608U, 17284672U, 17292224U, 17301056U, 17309632U, 17317568U, 17326016U, |
||||
17333824U, 17342272U, 17350208U, 17358784U, 17366848U, 17374912U, 17382592U, |
||||
17390656U, 17399488U, 17406784U, 17413952U, 17423936U, 17432512U, 17440448U, |
||||
17447744U, 17456704U, 17464768U, 17472064U, 17481536U, 17489344U, 17495488U, |
||||
17505728U, 17513792U, 17522368U, 17530816U, 17538112U, 17546944U, 17555264U, |
||||
17563072U, 17569856U, 17579456U, 17587904U, 17596352U, 17603776U, 17611712U, |
||||
17620672U, 17628992U, 17637184U, 17645504U, 17653568U, 17661632U, 17669824U, |
||||
17677376U, 17686208U, 17693888U, 17702336U, 17710144U, 17718208U, 17726528U, |
||||
17734336U, 17743808U, 17751872U, 17759936U, 17766592U, 17776448U, 17784512U, |
||||
17791936U, 17801152U, 17809216U, 17817152U |
||||
}; |
||||
|
||||
#ifdef __cplusplus |
||||
} |
||||
#endif |
||||
@ -0,0 +1,64 @@ |
||||
#include <Python.h> |
||||
#include <alloca.h> |
||||
#include <stdint.h> |
||||
#include "../libethash/ethash.h" |
||||
|
||||
static PyObject* |
||||
get_cache_size(PyObject* self, PyObject* args) |
||||
{ |
||||
unsigned long block_number; |
||||
if (!PyArg_ParseTuple(args, "k", &block_number)) |
||||
return 0; |
||||
return Py_BuildValue("i", ethash_get_cachesize(block_number)); |
||||
} |
||||
|
||||
static PyObject* |
||||
get_full_size(PyObject* self, PyObject* args) |
||||
{ |
||||
unsigned long block_number; |
||||
if (!PyArg_ParseTuple(args, "k", &block_number)) |
||||
return 0; |
||||
return Py_BuildValue("i", ethash_get_datasize(block_number)); |
||||
} |
||||
|
||||
|
||||
static PyObject* |
||||
mkcache(PyObject* self, PyObject* args) |
||||
{ |
||||
char * seed; |
||||
unsigned long cache_size; |
||||
int seed_len; |
||||
|
||||
if (!PyArg_ParseTuple(args, "ks#", &cache_size, &seed, &seed_len)) |
||||
return 0; |
||||
|
||||
if (seed_len != 32) |
||||
{ |
||||
PyErr_SetString(PyExc_ValueError, |
||||
"Seed must be 32 bytes long"); |
||||
return 0; |
||||
} |
||||
|
||||
printf("cache size: %lu\n", cache_size); |
||||
ethash_params params; |
||||
params.cache_size = (size_t) cache_size; |
||||
ethash_cache cache; |
||||
cache.mem = alloca(cache_size); |
||||
ethash_mkcache(&cache, ¶ms, (uint8_t *) seed); |
||||
return PyString_FromStringAndSize(cache.mem, cache_size); |
||||
} |
||||
|
||||
|
||||
static PyMethodDef CoreMethods[] = |
||||
{ |
||||
{"get_cache_size", get_cache_size, METH_VARARGS, "Get the cache size for a given block number"}, |
||||
{"get_full_size", get_full_size, METH_VARARGS, "Get the full size for a given block number"}, |
||||
{"mkcache", mkcache, METH_VARARGS, "Makes the cache for given parameters and seed hash"}, |
||||
{NULL, NULL, 0, NULL} |
||||
}; |
||||
|
||||
PyMODINIT_FUNC |
||||
initcore(void) |
||||
{ |
||||
(void) Py_InitModule("core", CoreMethods); |
||||
} |
||||
@ -0,0 +1,19 @@ |
||||
#!/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 )" |
||||
|
||||
rm -rf $TEST_DIR/build |
||||
mkdir -p $TEST_DIR/build |
||||
cd $TEST_DIR/build ; |
||||
cmake ../../.. > /dev/null |
||||
make Test |
||||
./test/c/Test |
||||
@ -1,54 +0,0 @@ |
||||
package ethashTest |
||||
|
||||
import ( |
||||
"bytes" |
||||
"crypto/rand" |
||||
"log" |
||||
"math/big" |
||||
"testing" |
||||
|
||||
"github.com/ethereum/ethash" |
||||
"github.com/ethereum/go-ethereum/core" |
||||
"github.com/ethereum/go-ethereum/ethdb" |
||||
) |
||||
|
||||
func TestEthash(t *testing.T) { |
||||
seedHash := make([]byte, 32) |
||||
_, err := rand.Read(seedHash) |
||||
if err != nil { |
||||
panic(err) |
||||
} |
||||
|
||||
db, err := ethdb.NewMemDatabase() |
||||
if err != nil { |
||||
panic(err) |
||||
} |
||||
|
||||
blockProcessor, err := core.NewCanonical(5, db) |
||||
if err != nil { |
||||
panic(err) |
||||
} |
||||
|
||||
log.Println("Block Number: ", blockProcessor.ChainManager().CurrentBlock().Number()) |
||||
|
||||
e := ethash.New(blockProcessor.ChainManager()) |
||||
|
||||
miningHash := make([]byte, 32) |
||||
if _, err := rand.Read(miningHash); err != nil { |
||||
panic(err) |
||||
} |
||||
diff := big.NewInt(10000) |
||||
log.Println("difficulty", diff) |
||||
|
||||
nonce := uint64(0) |
||||
|
||||
ghash_full := e.FullHash(nonce, miningHash) |
||||
log.Printf("ethash full (on nonce): %x %x\n", ghash_full, nonce) |
||||
|
||||
ghash_light := e.LightHash(nonce, miningHash) |
||||
log.Printf("ethash light (on nonce): %x %x\n", ghash_light, nonce) |
||||
|
||||
if bytes.Compare(ghash_full, ghash_light) != 0 { |
||||
t.Errorf("full: %x, light: %x", ghash_full, ghash_light) |
||||
} |
||||
} |
||||
@ -0,0 +1 @@ |
||||
python-virtual-env/ |
||||
@ -0,0 +1,2 @@ |
||||
pyethereum==0.7.522 |
||||
nose==1.3.4 |
||||
@ -0,0 +1,19 @@ |
||||
#!/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 )" |
||||
|
||||
[ -d $TEST_DIR/python-virtual-env ] || virtualenv --system-site-packages $TEST_DIR/python-virtual-env |
||||
source $TEST_DIR/python-virtual-env/bin/activate |
||||
pip install -r $TEST_DIR/requirements.txt > /dev/null |
||||
pip install -e $TEST_DIR/../.. > /dev/null |
||||
cd $TEST_DIR |
||||
nosetests --with-doctest -v |
||||
@ -0,0 +1,45 @@ |
||||
import pyethash |
||||
from random import randint |
||||
|
||||
def test_get_cache_size_not_None(): |
||||
for _ in range(100): |
||||
block_num = randint(0,12456789) |
||||
out = pyethash.core.get_cache_size(block_num) |
||||
assert out != None |
||||
|
||||
def test_get_full_size_not_None(): |
||||
for _ in range(100): |
||||
block_num = randint(0,12456789) |
||||
out = pyethash.core.get_full_size(block_num) |
||||
assert out != None |
||||
|
||||
def test_get_cache_size_based_on_EPOCH(): |
||||
for _ in range(100): |
||||
block_num = randint(0,12456789) |
||||
out1 = pyethash.core.get_cache_size(block_num) |
||||
out2 = pyethash.core.get_cache_size((block_num // pyethash.EPOCH_LENGTH) * pyethash.EPOCH_LENGTH) |
||||
assert out1 == out2 |
||||
|
||||
def test_get_full_size_based_on_EPOCH(): |
||||
for _ in range(100): |
||||
block_num = randint(0,12456789) |
||||
out1 = pyethash.core.get_full_size(block_num) |
||||
out2 = pyethash.core.get_full_size((block_num // pyethash.EPOCH_LENGTH) * pyethash.EPOCH_LENGTH) |
||||
assert out1 == out2 |
||||
|
||||
#def test_get_params_based_on_EPOCH(): |
||||
# block_num = 123456 |
||||
# out1 = pyethash.core.get_params(block_num) |
||||
# out2 = pyethash.core.get_params((block_num // pyethash.EPOCH_LENGTH) * pyethash.EPOCH_LENGTH) |
||||
# assert out1["DAG Size"] == out2["DAG Size"] |
||||
# assert out1["Cache Size"] == out2["Cache Size"] |
||||
# |
||||
#def test_get_params_returns_different_values_based_on_different_block_input(): |
||||
# out1 = pyethash.core.get_params(123456) |
||||
# out2 = pyethash.core.get_params(12345) |
||||
# assert out1["DAG Size"] != out2["DAG Size"] |
||||
# assert out1["Cache Size"] != out2["Cache Size"] |
||||
# |
||||
#def test_get_cache_smoke_test(): |
||||
# params = pyethash.core.get_params(123456) |
||||
# assert pyethash.core.mkcache(params, "~~~~") != None |
||||
@ -0,0 +1,26 @@ |
||||
#!/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 |
||||
node test.js |
||||
|
||||
echo -e "\n################# Testing C ##################" |
||||
$TEST_DIR/c/test.sh |
||||
|
||||
echo -e "\n################# Testing Python ##################" |
||||
$TEST_DIR/python/test.sh |
||||
|
||||
#echo "################# Testing Go ##################" |
||||
#$TEST_DIR/go/test.sh |
||||
Loading…
Reference in new issue