diff --git a/.travis.yml b/.travis.yml
index c97fdb993..61c3cc6ac 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -12,7 +12,7 @@ matrix:
cache:
ccache: true
install:
- - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sudo add-apt-repository -y ppa:ethereum/ethereum; sudo apt-get update; sudo apt-get install -y --no-install-recommends --allow-unauthenticated libjson-rpc-cpp-dev libjsoncpp-dev libboost-all-dev libcurl4-openssl-dev libmicrohttpd-dev mesa-common-dev ocl-icd-libopencl1 opencl-headers; fi
+ - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sudo add-apt-repository -y ppa:ethereum/ethereum; sudo apt-get update; sudo apt-get install -y --no-install-recommends --allow-unauthenticated libjson-rpc-cpp-dev libjsoncpp-dev libcurl4-openssl-dev libmicrohttpd-dev mesa-common-dev ocl-icd-libopencl1 opencl-headers; fi
- if [ "$TRAVIS_OS_NAME" = "osx" ]; then brew install libjson-rpc-cpp jsoncpp; fi
script:
- cmake -DETHASHCUDA=Off -DETHSTRATUM=On -DETHASHCL=On -H. -Bbuild
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 78b423a73..230dc5217 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,10 +1,25 @@
-# cmake global
cmake_minimum_required(VERSION 3.0)
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
+
+if (NOT DEFINED CMAKE_TOOLCHAIN_FILE)
+ # The default toolchain file configures compilers and build environment.
+ # This configuration is also used by hunter to build dependencies.
+ # CMake will cache this value, not need to explictly specify CACHE param.
+ set(CMAKE_TOOLCHAIN_FILE ${CMAKE_SOURCE_DIR}/cmake/toolchain.cmake)
+endif()
+
+include(HunterGate)
+HunterGate(
+ URL "https://github.com/ruslo/hunter/archive/v0.18.44.tar.gz"
+ SHA1 "a78f0b377b8e53c038f12fc18b0c02564c4534c8"
+)
+
set(GENOIL_VERSION "1.1.7")
cmake_policy(SET CMP0042 OLD) # fix MACOSX_RPATH
cmake_policy(SET CMP0048 NEW) # allow VERSION argument in project()
-project(ethereum VERSION 0.9.41)
+
+project(ethminer VERSION 0.9.41)
# link_directories interprate relative paths with respect to CMAKE_CURRENT_SOURCE_DIR
cmake_policy(SET CMP0015 NEW)
@@ -16,8 +31,6 @@ cmake_policy(SET CMP0020 NEW)
# 3.1 and above
cmake_policy(SET CMP0054 NEW)
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
-
######################################################################################################
# note: The value "default" which provides the defaults is just a fake value
@@ -125,6 +138,9 @@ if ("x${TARGET_PLATFORM}" STREQUAL "x")
set(TARGET_PLATFORM ${CMAKE_SYSTEM_NAME})
endif ()
+hunter_add_package(Boost COMPONENTS system)
+find_package(Boost CONFIG REQUIRED COMPONENTS system)
+
include(EthDependencies)
configureProject()
diff --git a/cmake/EthCompilerSettings.cmake b/cmake/EthCompilerSettings.cmake
index 0a368aa75..7c2e35df3 100644
--- a/cmake/EthCompilerSettings.cmake
+++ b/cmake/EthCompilerSettings.cmake
@@ -3,7 +3,7 @@
# C++11 check and activation
if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
- set(CMAKE_CXX_FLAGS "-std=c++11 -Wall -Wno-unknown-pragmas -Wextra -Wno-error=parentheses -pedantic${CMAKE_CXX_FLAGS}")
+ set(CMAKE_CXX_FLAGS "-Wall -Wno-unknown-pragmas -Wextra -Wno-error=parentheses -pedantic${CMAKE_CXX_FLAGS}")
set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g -DETH_DEBUG")
set(CMAKE_CXX_FLAGS_MINSIZEREL "-Os -DNDEBUG -DETH_RELEASE")
set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG -DETH_RELEASE")
@@ -17,15 +17,14 @@ if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU")
elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
- set(CMAKE_CXX_FLAGS "-std=c++11 -Wall -Wno-unknown-pragmas -Wextra")
+ set(CMAKE_CXX_FLAGS "-Wall -Wno-unknown-pragmas -Wextra")
set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g -DETH_DEBUG")
- set(CMAKE_CXX_FLAGS_DEBUGSAN "-O1 -g -fsanitize=address,integer,undefined -fsanitize-blacklist=${CMAKE_SOURCE_DIR}/sanitizer-blacklist.txt -fno-omit-frame-pointer -DETH_DEBUG")
set(CMAKE_CXX_FLAGS_MINSIZEREL "-Os -DNDEBUG -DETH_RELEASE")
set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG -DETH_RELEASE")
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "-O2 -g -DETH_RELEASE")
if ("${CMAKE_SYSTEM_NAME}" MATCHES "Linux")
- set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libstdc++ -fcolor-diagnostics -Qunused-arguments -DBOOST_ASIO_HAS_CLANG_LIBCXX")
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libstdc++ -fcolor-diagnostics -Qunused-arguments")
endif()
elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
diff --git a/cmake/EthDependencies.cmake b/cmake/EthDependencies.cmake
index 3d919fbc8..359f836f8 100644
--- a/cmake/EthDependencies.cmake
+++ b/cmake/EthDependencies.cmake
@@ -19,23 +19,6 @@ include_directories(${ETH_GENERATED_DIR})
# custom cmake scripts
set(ETH_SCRIPTS_DIR ${CMAKE_CURRENT_LIST_DIR}/scripts)
-# Qt5 requires opengl
-# TODO use proper version of windows SDK (32 vs 64)
-# TODO make it possible to use older versions of windows SDK (7.0+ should also work)
-# TODO it windows SDK is NOT FOUND, throw ERROR
-# from https://github.com/rpavlik/cmake-modules/blob/master/FindWindowsSDK.cmake
-if (WIN32)
- find_package(WINDOWSSDK REQUIRED)
- message(" - WindowsSDK dirs: ${WINDOWSSDK_DIRS}")
- set (CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH} ${WINDOWSSDK_DIRS})
-endif()
-
-# homebrew installs qts in opt
-if (APPLE)
- set (CMAKE_PREFIX_PATH "/usr/local/opt/qt5" ${CMAKE_PREFIX_PATH})
- set (CMAKE_PREFIX_PATH "/usr/local/opt/v8-315" ${CMAKE_PREFIX_PATH})
-endif()
-
find_program(CTEST_COMMAND ctest)
message(STATUS "ctest path: ${CTEST_COMMAND}")
@@ -72,32 +55,6 @@ endif()
find_program(ETH_JSON_RPC_STUB jsonrpcstub)
message(" - jsonrpcstub location : ${ETH_JSON_RPC_STUB}")
-# use multithreaded boost libraries, with -mt suffix
-set(Boost_USE_MULTITHREADED ON)
-
-if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
-
-# TODO hanlde other msvc versions or it will fail find them
- set(Boost_COMPILER -vc120)
-# use static boost libraries *.lib
- set(Boost_USE_STATIC_LIBS ON)
-
-elseif (APPLE)
-
-# use static boost libraries *.a
- set(Boost_USE_STATIC_LIBS ON)
-
-elseif (UNIX)
-# use dynamic boost libraries .dll
- set(Boost_USE_STATIC_LIBS OFF)
-
-endif()
-
-find_package(Boost 1.54.0 REQUIRED COMPONENTS thread date_time system regex chrono filesystem unit_test_framework program_options random)
-
-message(" - boost header: ${Boost_INCLUDE_DIRS}")
-message(" - boost lib : ${Boost_LIBRARIES}")
-
if (APPLE)
link_directories(/usr/local/lib)
include_directories(/usr/local/include)
diff --git a/cmake/HunterGate.cmake b/cmake/HunterGate.cmake
new file mode 100644
index 000000000..e3a6dad2c
--- /dev/null
+++ b/cmake/HunterGate.cmake
@@ -0,0 +1,528 @@
+# Copyright (c) 2013-2017, Ruslan Baratov
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+# list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# This is a gate file to Hunter package manager.
+# Include this file using `include` command and add package you need, example:
+#
+# cmake_minimum_required(VERSION 3.0)
+#
+# include("cmake/HunterGate.cmake")
+# HunterGate(
+# URL "https://github.com/path/to/hunter/archive.tar.gz"
+# SHA1 "798501e983f14b28b10cda16afa4de69eee1da1d"
+# )
+#
+# project(MyProject)
+#
+# hunter_add_package(Foo)
+# hunter_add_package(Boo COMPONENTS Bar Baz)
+#
+# Projects:
+# * https://github.com/hunter-packages/gate/
+# * https://github.com/ruslo/hunter
+
+option(HUNTER_ENABLED "Enable Hunter package manager support" ON)
+if(HUNTER_ENABLED)
+ if(CMAKE_VERSION VERSION_LESS "3.0")
+ message(FATAL_ERROR "At least CMake version 3.0 required for hunter dependency management."
+ " Update CMake or set HUNTER_ENABLED to OFF.")
+ endif()
+endif()
+
+include(CMakeParseArguments) # cmake_parse_arguments
+
+option(HUNTER_STATUS_PRINT "Print working status" ON)
+option(HUNTER_STATUS_DEBUG "Print a lot info" OFF)
+
+set(HUNTER_WIKI "https://github.com/ruslo/hunter/wiki")
+
+function(hunter_gate_status_print)
+ foreach(print_message ${ARGV})
+ if(HUNTER_STATUS_PRINT OR HUNTER_STATUS_DEBUG)
+ message(STATUS "[hunter] ${print_message}")
+ endif()
+ endforeach()
+endfunction()
+
+function(hunter_gate_status_debug)
+ foreach(print_message ${ARGV})
+ if(HUNTER_STATUS_DEBUG)
+ string(TIMESTAMP timestamp)
+ message(STATUS "[hunter *** DEBUG *** ${timestamp}] ${print_message}")
+ endif()
+ endforeach()
+endfunction()
+
+function(hunter_gate_wiki wiki_page)
+ message("------------------------------ WIKI -------------------------------")
+ message(" ${HUNTER_WIKI}/${wiki_page}")
+ message("-------------------------------------------------------------------")
+ message("")
+ message(FATAL_ERROR "")
+endfunction()
+
+function(hunter_gate_internal_error)
+ message("")
+ foreach(print_message ${ARGV})
+ message("[hunter ** INTERNAL **] ${print_message}")
+ endforeach()
+ message("[hunter ** INTERNAL **] [Directory:${CMAKE_CURRENT_LIST_DIR}]")
+ message("")
+ hunter_gate_wiki("error.internal")
+endfunction()
+
+function(hunter_gate_fatal_error)
+ cmake_parse_arguments(hunter "" "WIKI" "" "${ARGV}")
+ string(COMPARE EQUAL "${hunter_WIKI}" "" have_no_wiki)
+ if(have_no_wiki)
+ hunter_gate_internal_error("Expected wiki")
+ endif()
+ message("")
+ foreach(x ${hunter_UNPARSED_ARGUMENTS})
+ message("[hunter ** FATAL ERROR **] ${x}")
+ endforeach()
+ message("[hunter ** FATAL ERROR **] [Directory:${CMAKE_CURRENT_LIST_DIR}]")
+ message("")
+ hunter_gate_wiki("${hunter_WIKI}")
+endfunction()
+
+function(hunter_gate_user_error)
+ hunter_gate_fatal_error(${ARGV} WIKI "error.incorrect.input.data")
+endfunction()
+
+function(hunter_gate_self root version sha1 result)
+ string(COMPARE EQUAL "${root}" "" is_bad)
+ if(is_bad)
+ hunter_gate_internal_error("root is empty")
+ endif()
+
+ string(COMPARE EQUAL "${version}" "" is_bad)
+ if(is_bad)
+ hunter_gate_internal_error("version is empty")
+ endif()
+
+ string(COMPARE EQUAL "${sha1}" "" is_bad)
+ if(is_bad)
+ hunter_gate_internal_error("sha1 is empty")
+ endif()
+
+ string(SUBSTRING "${sha1}" 0 7 archive_id)
+
+ if(EXISTS "${root}/cmake/Hunter")
+ set(hunter_self "${root}")
+ else()
+ set(
+ hunter_self
+ "${root}/_Base/Download/Hunter/${version}/${archive_id}/Unpacked"
+ )
+ endif()
+
+ set("${result}" "${hunter_self}" PARENT_SCOPE)
+endfunction()
+
+# Set HUNTER_GATE_ROOT cmake variable to suitable value.
+function(hunter_gate_detect_root)
+ # Check CMake variable
+ string(COMPARE NOTEQUAL "${HUNTER_ROOT}" "" not_empty)
+ if(not_empty)
+ set(HUNTER_GATE_ROOT "${HUNTER_ROOT}" PARENT_SCOPE)
+ hunter_gate_status_debug("HUNTER_ROOT detected by cmake variable")
+ return()
+ endif()
+
+ # Check environment variable
+ string(COMPARE NOTEQUAL "$ENV{HUNTER_ROOT}" "" not_empty)
+ if(not_empty)
+ set(HUNTER_GATE_ROOT "$ENV{HUNTER_ROOT}" PARENT_SCOPE)
+ hunter_gate_status_debug("HUNTER_ROOT detected by environment variable")
+ return()
+ endif()
+
+ # Check HOME environment variable
+ string(COMPARE NOTEQUAL "$ENV{HOME}" "" result)
+ if(result)
+ set(HUNTER_GATE_ROOT "$ENV{HOME}/.hunter" PARENT_SCOPE)
+ hunter_gate_status_debug("HUNTER_ROOT set using HOME environment variable")
+ return()
+ endif()
+
+ # Check SYSTEMDRIVE and USERPROFILE environment variable (windows only)
+ if(WIN32)
+ string(COMPARE NOTEQUAL "$ENV{SYSTEMDRIVE}" "" result)
+ if(result)
+ set(HUNTER_GATE_ROOT "$ENV{SYSTEMDRIVE}/.hunter" PARENT_SCOPE)
+ hunter_gate_status_debug(
+ "HUNTER_ROOT set using SYSTEMDRIVE environment variable"
+ )
+ return()
+ endif()
+
+ string(COMPARE NOTEQUAL "$ENV{USERPROFILE}" "" result)
+ if(result)
+ set(HUNTER_GATE_ROOT "$ENV{USERPROFILE}/.hunter" PARENT_SCOPE)
+ hunter_gate_status_debug(
+ "HUNTER_ROOT set using USERPROFILE environment variable"
+ )
+ return()
+ endif()
+ endif()
+
+ hunter_gate_fatal_error(
+ "Can't detect HUNTER_ROOT"
+ WIKI "error.detect.hunter.root"
+ )
+endfunction()
+
+macro(hunter_gate_lock dir)
+ if(NOT HUNTER_SKIP_LOCK)
+ if("${CMAKE_VERSION}" VERSION_LESS "3.2")
+ hunter_gate_fatal_error(
+ "Can't lock, upgrade to CMake 3.2 or use HUNTER_SKIP_LOCK"
+ WIKI "error.can.not.lock"
+ )
+ endif()
+ hunter_gate_status_debug("Locking directory: ${dir}")
+ file(LOCK "${dir}" DIRECTORY GUARD FUNCTION)
+ hunter_gate_status_debug("Lock done")
+ endif()
+endmacro()
+
+function(hunter_gate_download dir)
+ string(
+ COMPARE
+ NOTEQUAL
+ "$ENV{HUNTER_DISABLE_AUTOINSTALL}"
+ ""
+ disable_autoinstall
+ )
+ if(disable_autoinstall AND NOT HUNTER_RUN_INSTALL)
+ hunter_gate_fatal_error(
+ "Hunter not found in '${dir}'"
+ "Set HUNTER_RUN_INSTALL=ON to auto-install it from '${HUNTER_GATE_URL}'"
+ "Settings:"
+ " HUNTER_ROOT: ${HUNTER_GATE_ROOT}"
+ " HUNTER_SHA1: ${HUNTER_GATE_SHA1}"
+ WIKI "error.run.install"
+ )
+ endif()
+ string(COMPARE EQUAL "${dir}" "" is_bad)
+ if(is_bad)
+ hunter_gate_internal_error("Empty 'dir' argument")
+ endif()
+
+ string(COMPARE EQUAL "${HUNTER_GATE_SHA1}" "" is_bad)
+ if(is_bad)
+ hunter_gate_internal_error("HUNTER_GATE_SHA1 empty")
+ endif()
+
+ string(COMPARE EQUAL "${HUNTER_GATE_URL}" "" is_bad)
+ if(is_bad)
+ hunter_gate_internal_error("HUNTER_GATE_URL empty")
+ endif()
+
+ set(done_location "${dir}/DONE")
+ set(sha1_location "${dir}/SHA1")
+
+ set(build_dir "${dir}/Build")
+ set(cmakelists "${dir}/CMakeLists.txt")
+
+ hunter_gate_lock("${dir}")
+ if(EXISTS "${done_location}")
+ # while waiting for lock other instance can do all the job
+ hunter_gate_status_debug("File '${done_location}' found, skip install")
+ return()
+ endif()
+
+ file(REMOVE_RECURSE "${build_dir}")
+ file(REMOVE_RECURSE "${cmakelists}")
+
+ file(MAKE_DIRECTORY "${build_dir}") # check directory permissions
+
+ # Disabling languages speeds up a little bit, reduces noise in the output
+ # and avoids path too long windows error
+ file(
+ WRITE
+ "${cmakelists}"
+ "cmake_minimum_required(VERSION 3.0)\n"
+ "project(HunterDownload LANGUAGES NONE)\n"
+ "include(ExternalProject)\n"
+ "ExternalProject_Add(\n"
+ " Hunter\n"
+ " URL\n"
+ " \"${HUNTER_GATE_URL}\"\n"
+ " URL_HASH\n"
+ " SHA1=${HUNTER_GATE_SHA1}\n"
+ " DOWNLOAD_DIR\n"
+ " \"${dir}\"\n"
+ " SOURCE_DIR\n"
+ " \"${dir}/Unpacked\"\n"
+ " CONFIGURE_COMMAND\n"
+ " \"\"\n"
+ " BUILD_COMMAND\n"
+ " \"\"\n"
+ " INSTALL_COMMAND\n"
+ " \"\"\n"
+ ")\n"
+ )
+
+ if(HUNTER_STATUS_DEBUG)
+ set(logging_params "")
+ else()
+ set(logging_params OUTPUT_QUIET)
+ endif()
+
+ hunter_gate_status_debug("Run generate")
+
+ # Need to add toolchain file too.
+ # Otherwise on Visual Studio + MDD this will fail with error:
+ # "Could not find an appropriate version of the Windows 10 SDK installed on this machine"
+ if(EXISTS "${CMAKE_TOOLCHAIN_FILE}")
+ set(toolchain_arg "-DCMAKE_TOOLCHAIN_FILE=${CMAKE_TOOLCHAIN_FILE}")
+ else()
+ # 'toolchain_arg' can't be empty
+ set(toolchain_arg "-DCMAKE_TOOLCHAIN_FILE=")
+ endif()
+
+ string(COMPARE EQUAL "${CMAKE_MAKE_PROGRAM}" "" no_make)
+ if(no_make)
+ set(make_arg "")
+ else()
+ # Test case: remove Ninja from PATH but set it via CMAKE_MAKE_PROGRAM
+ set(make_arg "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}")
+ endif()
+
+ execute_process(
+ COMMAND
+ "${CMAKE_COMMAND}"
+ "-H${dir}"
+ "-B${build_dir}"
+ "-G${CMAKE_GENERATOR}"
+ "${toolchain_arg}"
+ ${make_arg}
+ WORKING_DIRECTORY "${dir}"
+ RESULT_VARIABLE download_result
+ ${logging_params}
+ )
+
+ if(NOT download_result EQUAL 0)
+ hunter_gate_internal_error("Configure project failed")
+ endif()
+
+ hunter_gate_status_print(
+ "Initializing Hunter workspace (${HUNTER_GATE_SHA1})"
+ " ${HUNTER_GATE_URL}"
+ " -> ${dir}"
+ )
+ execute_process(
+ COMMAND "${CMAKE_COMMAND}" --build "${build_dir}"
+ WORKING_DIRECTORY "${dir}"
+ RESULT_VARIABLE download_result
+ ${logging_params}
+ )
+
+ if(NOT download_result EQUAL 0)
+ hunter_gate_internal_error("Build project failed")
+ endif()
+
+ file(REMOVE_RECURSE "${build_dir}")
+ file(REMOVE_RECURSE "${cmakelists}")
+
+ file(WRITE "${sha1_location}" "${HUNTER_GATE_SHA1}")
+ file(WRITE "${done_location}" "DONE")
+
+ hunter_gate_status_debug("Finished")
+endfunction()
+
+# Must be a macro so master file 'cmake/Hunter' can
+# apply all variables easily just by 'include' command
+# (otherwise PARENT_SCOPE magic needed)
+macro(HunterGate)
+ if(HUNTER_GATE_DONE)
+ # variable HUNTER_GATE_DONE set explicitly for external project
+ # (see `hunter_download`)
+ set_property(GLOBAL PROPERTY HUNTER_GATE_DONE YES)
+ endif()
+
+ # First HunterGate command will init Hunter, others will be ignored
+ get_property(_hunter_gate_done GLOBAL PROPERTY HUNTER_GATE_DONE SET)
+
+ if(NOT HUNTER_ENABLED)
+ # Empty function to avoid error "unknown function"
+ function(hunter_add_package)
+ endfunction()
+ elseif(_hunter_gate_done)
+ hunter_gate_status_debug("Secondary HunterGate (use old settings)")
+ hunter_gate_self(
+ "${HUNTER_CACHED_ROOT}"
+ "${HUNTER_VERSION}"
+ "${HUNTER_SHA1}"
+ _hunter_self
+ )
+ include("${_hunter_self}/cmake/Hunter")
+ else()
+ set(HUNTER_GATE_LOCATION "${CMAKE_CURRENT_LIST_DIR}")
+
+ string(COMPARE NOTEQUAL "${PROJECT_NAME}" "" _have_project_name)
+ if(_have_project_name)
+ hunter_gate_fatal_error(
+ "Please set HunterGate *before* 'project' command. "
+ "Detected project: ${PROJECT_NAME}"
+ WIKI "error.huntergate.before.project"
+ )
+ endif()
+
+ cmake_parse_arguments(
+ HUNTER_GATE "LOCAL" "URL;SHA1;GLOBAL;FILEPATH" "" ${ARGV}
+ )
+
+ string(COMPARE EQUAL "${HUNTER_GATE_SHA1}" "" _empty_sha1)
+ string(COMPARE EQUAL "${HUNTER_GATE_URL}" "" _empty_url)
+ string(
+ COMPARE
+ NOTEQUAL
+ "${HUNTER_GATE_UNPARSED_ARGUMENTS}"
+ ""
+ _have_unparsed
+ )
+ string(COMPARE NOTEQUAL "${HUNTER_GATE_GLOBAL}" "" _have_global)
+ string(COMPARE NOTEQUAL "${HUNTER_GATE_FILEPATH}" "" _have_filepath)
+
+ if(_have_unparsed)
+ hunter_gate_user_error(
+ "HunterGate unparsed arguments: ${HUNTER_GATE_UNPARSED_ARGUMENTS}"
+ )
+ endif()
+ if(_empty_sha1)
+ hunter_gate_user_error("SHA1 suboption of HunterGate is mandatory")
+ endif()
+ if(_empty_url)
+ hunter_gate_user_error("URL suboption of HunterGate is mandatory")
+ endif()
+ if(_have_global)
+ if(HUNTER_GATE_LOCAL)
+ hunter_gate_user_error("Unexpected LOCAL (already has GLOBAL)")
+ endif()
+ if(_have_filepath)
+ hunter_gate_user_error("Unexpected FILEPATH (already has GLOBAL)")
+ endif()
+ endif()
+ if(HUNTER_GATE_LOCAL)
+ if(_have_global)
+ hunter_gate_user_error("Unexpected GLOBAL (already has LOCAL)")
+ endif()
+ if(_have_filepath)
+ hunter_gate_user_error("Unexpected FILEPATH (already has LOCAL)")
+ endif()
+ endif()
+ if(_have_filepath)
+ if(_have_global)
+ hunter_gate_user_error("Unexpected GLOBAL (already has FILEPATH)")
+ endif()
+ if(HUNTER_GATE_LOCAL)
+ hunter_gate_user_error("Unexpected LOCAL (already has FILEPATH)")
+ endif()
+ endif()
+
+ hunter_gate_detect_root() # set HUNTER_GATE_ROOT
+
+ # Beautify path, fix probable problems with windows path slashes
+ get_filename_component(
+ HUNTER_GATE_ROOT "${HUNTER_GATE_ROOT}" ABSOLUTE
+ )
+ hunter_gate_status_debug("HUNTER_ROOT: ${HUNTER_GATE_ROOT}")
+ if(NOT HUNTER_ALLOW_SPACES_IN_PATH)
+ string(FIND "${HUNTER_GATE_ROOT}" " " _contain_spaces)
+ if(NOT _contain_spaces EQUAL -1)
+ hunter_gate_fatal_error(
+ "HUNTER_ROOT (${HUNTER_GATE_ROOT}) contains spaces."
+ "Set HUNTER_ALLOW_SPACES_IN_PATH=ON to skip this error"
+ "(Use at your own risk!)"
+ WIKI "error.spaces.in.hunter.root"
+ )
+ endif()
+ endif()
+
+ string(
+ REGEX
+ MATCH
+ "[0-9]+\\.[0-9]+\\.[0-9]+[-_a-z0-9]*"
+ HUNTER_GATE_VERSION
+ "${HUNTER_GATE_URL}"
+ )
+ string(COMPARE EQUAL "${HUNTER_GATE_VERSION}" "" _is_empty)
+ if(_is_empty)
+ set(HUNTER_GATE_VERSION "unknown")
+ endif()
+
+ hunter_gate_self(
+ "${HUNTER_GATE_ROOT}"
+ "${HUNTER_GATE_VERSION}"
+ "${HUNTER_GATE_SHA1}"
+ _hunter_self
+ )
+
+ set(_master_location "${_hunter_self}/cmake/Hunter")
+ if(EXISTS "${HUNTER_GATE_ROOT}/cmake/Hunter")
+ # Hunter downloaded manually (e.g. by 'git clone')
+ set(_unused "xxxxxxxxxx")
+ set(HUNTER_GATE_SHA1 "${_unused}")
+ set(HUNTER_GATE_VERSION "${_unused}")
+ else()
+ get_filename_component(_archive_id_location "${_hunter_self}/.." ABSOLUTE)
+ set(_done_location "${_archive_id_location}/DONE")
+ set(_sha1_location "${_archive_id_location}/SHA1")
+
+ # Check Hunter already downloaded by HunterGate
+ if(NOT EXISTS "${_done_location}")
+ hunter_gate_download("${_archive_id_location}")
+ endif()
+
+ if(NOT EXISTS "${_done_location}")
+ hunter_gate_internal_error("hunter_gate_download failed")
+ endif()
+
+ if(NOT EXISTS "${_sha1_location}")
+ hunter_gate_internal_error("${_sha1_location} not found")
+ endif()
+ file(READ "${_sha1_location}" _sha1_value)
+ string(COMPARE EQUAL "${_sha1_value}" "${HUNTER_GATE_SHA1}" _is_equal)
+ if(NOT _is_equal)
+ hunter_gate_internal_error(
+ "Short SHA1 collision:"
+ " ${_sha1_value} (from ${_sha1_location})"
+ " ${HUNTER_GATE_SHA1} (HunterGate)"
+ )
+ endif()
+ if(NOT EXISTS "${_master_location}")
+ hunter_gate_user_error(
+ "Master file not found:"
+ " ${_master_location}"
+ "try to update Hunter/HunterGate"
+ )
+ endif()
+ endif()
+ include("${_master_location}")
+ set_property(GLOBAL PROPERTY HUNTER_GATE_DONE YES)
+ endif()
+endmacro()
\ No newline at end of file
diff --git a/cmake/scripts/runtest.cmake b/cmake/scripts/runtest.cmake
deleted file mode 100644
index 15f7409ef..000000000
--- a/cmake/scripts/runtest.cmake
+++ /dev/null
@@ -1,15 +0,0 @@
-# Should be used to run ctest
-#
-# example usage:
-# cmake -DETH_TEST_NAME=TestInterfaceStub -DCTEST_COMMAND=/path/to/ctest -P scripts/runtest.cmake
-
-if (NOT CTEST_COMMAND)
- message(FATAL_ERROR "ctest could not be found!")
-endif()
-
-# verbosity is off, cause BOOST_MESSAGE is not thread safe and output is a trash
-# see https://codecrafter.wordpress.com/2012/11/01/c-unit-test-framework-adapter-part-3/
-#
-# output might not be usefull cause of thread safety issue
-execute_process(COMMAND ${CTEST_COMMAND} --force-new-ctest-process -C Debug --output-on-failure -j 4 -R "${ETH_TEST_NAME}[.].*")
-
diff --git a/cmake/toolchain.cmake b/cmake/toolchain.cmake
new file mode 100644
index 000000000..0ae619724
--- /dev/null
+++ b/cmake/toolchain.cmake
@@ -0,0 +1,3 @@
+set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
+set(CMAKE_CXX_EXTENSIONS Off)
diff --git a/ethminer/CMakeLists.txt b/ethminer/CMakeLists.txt
index 7f8aad61c..28daf9064 100644
--- a/ethminer/CMakeLists.txt
+++ b/ethminer/CMakeLists.txt
@@ -4,7 +4,6 @@ set(CMAKE_AUTOMOC OFF)
aux_source_directory(. SRC_LIST)
include_directories(BEFORE ..)
-include_directories(${Boost_INCLUDE_DIRS})
if (JSONRPC)
include_directories(BEFORE ${JSONCPP_INCLUDE_DIRS})
diff --git a/ethminer/MinerAux.h b/ethminer/MinerAux.h
index 366d0f680..50f100cb2 100644
--- a/ethminer/MinerAux.h
+++ b/ethminer/MinerAux.h
@@ -800,7 +800,7 @@ private:
else if (_m == MinerType::CUDA)
f.start("cuda", false);
EthashProofOfWork::WorkPackage current, previous;
- boost::mutex x_current;
+ std::mutex x_current;
EthashAux::FullType dag;
while (m_running)
try
diff --git a/libdevcore/CMakeLists.txt b/libdevcore/CMakeLists.txt
index f62e474de..3fb79cbea 100644
--- a/libdevcore/CMakeLists.txt
+++ b/libdevcore/CMakeLists.txt
@@ -4,7 +4,6 @@ aux_source_directory(. SOURCES)
include_directories(BEFORE ${JSONCPP_INCLUDE_DIRS})
include_directories(BEFORE ..)
-include_directories(${Boost_INCLUDE_DIRS})
set(EXECUTABLE devcore)
@@ -12,24 +11,14 @@ file(GLOB HEADERS "*.h")
add_library(devcore ${SOURCES} ${HEADERS})
-target_link_libraries(devcore ${Boost_THREAD_LIBRARIES})
-target_link_libraries(devcore ${Boost_RANDOM_LIBRARIES})
-target_link_libraries(devcore ${Boost_FILESYSTEM_LIBRARIES})
-target_link_libraries(devcore ${Boost_SYSTEM_LIBRARIES})
-target_link_libraries(devcore ${JSONCPP_LIBRARIES})
-
-# transitive dependencies for windows executables
-if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
- target_link_libraries(${EXECUTABLE} ${Boost_CHRONO_LIBRARIES})
- target_link_libraries(${EXECUTABLE} ${Boost_DATE_TIME_LIBRARIES})
-endif()
+target_link_libraries(devcore PUBLIC ${JSONCPP_LIBRARIES} Boost::boost)
if (APPLE)
find_package(Threads REQUIRED)
- target_link_libraries(${EXECUTABLE} ${CMAKE_THREAD_LIBS_INIT})
+ target_link_libraries(${EXECUTABLE} PRIVATE ${CMAKE_THREAD_LIBS_INIT})
elseif (UNIX)
find_package(Threads REQUIRED)
- target_link_libraries(${EXECUTABLE} ${CMAKE_THREAD_LIBS_INIT})
+ target_link_libraries(${EXECUTABLE} PRIVATE ${CMAKE_THREAD_LIBS_INIT})
endif()
install( TARGETS ${EXECUTABLE} RUNTIME DESTINATION bin ARCHIVE DESTINATION lib LIBRARY DESTINATION lib )
diff --git a/libdevcore/Common.h b/libdevcore/Common.h
index f78ce690e..dba0531de 100644
--- a/libdevcore/Common.h
+++ b/libdevcore/Common.h
@@ -41,18 +41,8 @@
#include <functional>
#include <string>
#include <chrono>
-#include <boost/current_function.hpp>
#include <boost/functional/hash.hpp>
-#pragma warning(push)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#include <boost/version.hpp>
-#if (BOOST_VERSION == 105800)
- #include "boost_multiprecision_number_compare_bug_workaround.hpp"
-#endif
#include <boost/multiprecision/cpp_int.hpp>
-#pragma warning(pop)
-#pragma GCC diagnostic pop
#include "vector_ref.h"
// CryptoPP defines byte in the global namespace, so must we.
diff --git a/libdevcore/FixedHash.cpp b/libdevcore/FixedHash.cpp
index 420e2bb16..167f99a1a 100644
--- a/libdevcore/FixedHash.cpp
+++ b/libdevcore/FixedHash.cpp
@@ -20,31 +20,9 @@
*/
#include "FixedHash.h"
-#include <ctime>
#include <boost/algorithm/string.hpp>
using namespace std;
using namespace dev;
-boost::random_device dev::s_fixedHashEngine;
-
-h128 dev::fromUUID(std::string const& _uuid)
-{
- try
- {
- return h128(boost::replace_all_copy(_uuid, "-", ""));
- }
- catch (...)
- {
- return h128();
- }
-}
-
-std::string dev::toUUID(h128 const& _uuid)
-{
- std::string ret = toHex(_uuid.ref());
- for (unsigned i: {20, 16, 12, 8})
- ret.insert(ret.begin() + i, '-');
- return ret;
-}
-
+std::random_device dev::s_fixedHashEngine;
\ No newline at end of file
diff --git a/libdevcore/FixedHash.h b/libdevcore/FixedHash.h
index 8beb3bec7..c09d54759 100644
--- a/libdevcore/FixedHash.h
+++ b/libdevcore/FixedHash.h
@@ -26,8 +26,7 @@
#include <array>
#include <cstdint>
#include <algorithm>
-#include <boost/random/random_device.hpp>
-#include <boost/random/uniform_int_distribution.hpp>
+#include <random>
#include "CommonData.h"
namespace dev
@@ -37,7 +36,7 @@ namespace dev
template <unsigned N> struct StaticLog2 { enum { result = 1 + StaticLog2<N/2>::result }; };
template <> struct StaticLog2<1> { enum { result = 0 }; };
-extern boost::random_device s_fixedHashEngine;
+extern std::random_device s_fixedHashEngine;
/// Fixed-size raw-byte array container type, with an API optimised for storing hashes.
/// Transparently converts to/from the corresponding arithmetic type; this will
@@ -154,7 +153,7 @@ public:
void randomize(Engine& _eng)
{
for (auto& i: m_data)
- i = (uint8_t)boost::random::uniform_int_distribution<uint16_t>(0, 255)(_eng);
+ i = (uint8_t)std::uniform_int_distribution<uint16_t>(0, 255)(_eng);
}
/// @returns a random valued object.
@@ -291,7 +290,6 @@ public:
bytesConstRef ref() const { return FixedHash<T>::ref(); }
byte const* data() const { return FixedHash<T>::data(); }
- static SecureFixedHash<T> random() { SecureFixedHash<T> ret; ret.randomize(s_fixedHashEngine); return ret; }
using FixedHash<T>::firstBitSet;
void clear() { ref().cleanse(); }
diff --git a/libdevcore/Guards.h b/libdevcore/Guards.h
index 817bfb30e..2f1509b9a 100644
--- a/libdevcore/Guards.h
+++ b/libdevcore/Guards.h
@@ -24,27 +24,16 @@
#include <mutex>
#include <condition_variable>
#include <atomic>
-#pragma warning(push)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#include <boost/thread.hpp>
-#pragma warning(pop)
-#pragma GCC diagnostic pop
namespace dev
{
using Mutex = std::mutex;
using RecursiveMutex = std::recursive_mutex;
-using SharedMutex = boost::shared_mutex;
using Guard = std::lock_guard<std::mutex>;
using UniqueGuard = std::unique_lock<std::mutex>;
using RecursiveGuard = std::lock_guard<std::recursive_mutex>;
-using ReadGuard = boost::shared_lock<boost::shared_mutex>;
-using UpgradableGuard = boost::upgrade_lock<boost::shared_mutex>;
-using UpgradeGuard = boost::upgrade_to_unique_lock<boost::shared_mutex>;
-using WriteGuard = boost::unique_lock<boost::shared_mutex>;
template <class GuardType, class MutexType>
struct GenericGuardBool: GuardType
@@ -52,22 +41,6 @@ struct GenericGuardBool: GuardType
GenericGuardBool(MutexType& _m): GuardType(_m) {}
bool b = true;
};
-template <class MutexType>
-struct GenericUnguardBool
-{
- GenericUnguardBool(MutexType& _m): m(_m) { m.unlock(); }
- ~GenericUnguardBool() { m.lock(); }
- bool b = true;
- MutexType& m;
-};
-template <class MutexType>
-struct GenericUnguardSharedBool
-{
- GenericUnguardSharedBool(MutexType& _m): m(_m) { m.unlock_shared(); }
- ~GenericUnguardSharedBool() { m.lock_shared(); }
- bool b = true;
- MutexType& m;
-};
/** @brief Simple lock that waits for release without making context switch */
class SpinLock
@@ -143,7 +116,5 @@ private:
#define DEV_GUARDED(MUTEX) \
for (GenericGuardBool<Guard, Mutex> __eth_l(MUTEX); __eth_l.b; __eth_l.b = false)
-#define DEV_READ_GUARDED(MUTEX) \
- for (GenericGuardBool<ReadGuard, SharedMutex> __eth_l(MUTEX); __eth_l.b; __eth_l.b = false)
}
diff --git a/libdevcore/Log.cpp b/libdevcore/Log.cpp
index 615556e80..0d52e24de 100644
--- a/libdevcore/Log.cpp
+++ b/libdevcore/Log.cpp
@@ -82,7 +82,7 @@ LogOutputStreamBase::LogOutputStreamBase(char const* _id, std::type_info const*
{
Guard l(x_logOverride);
auto it = s_logOverride.find(_info);
- if ((it != s_logOverride.end() && it->second == true) || (it == s_logOverride.end() && (int)_v <= g_logVerbosity))
+ if ((it != s_logOverride.end() && it->second) || (it == s_logOverride.end() && (int)_v <= g_logVerbosity))
{
time_t rawTime = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
char buf[24];
@@ -104,10 +104,14 @@ void LogOutputStreamBase::append(boost::asio::ip::basic_endpoint<boost::asio::ip
/// Associate a name with each thread for nice logging.
struct ThreadLocalLogName
{
- ThreadLocalLogName(std::string const& _name) { m_name.reset(new string(_name)); }
- boost::thread_specific_ptr<std::string> m_name;
+ ThreadLocalLogName(char const* _name) { name = _name; }
+ thread_local static char const* name;
};
+thread_local char const* ThreadLocalLogName::name;
+
+thread_local static std::vector<std::string> logContexts;
+
/// Associate a name with each thread for nice logging.
struct ThreadLocalLogContext
{
@@ -115,26 +119,21 @@ struct ThreadLocalLogContext
void push(std::string const& _name)
{
- if (!m_contexts.get())
- m_contexts.reset(new vector<string>);
- m_contexts->push_back(_name);
+ logContexts.push_back(_name);
}
void pop()
{
- m_contexts->pop_back();
+ logContexts.pop_back();
}
string join(string const& _prior)
{
string ret;
- if (m_contexts.get())
- for (auto const& i: *m_contexts)
- ret += _prior + i;
+ for (auto const& i: logContexts)
+ ret += _prior + i;
return ret;
}
-
- boost::thread_specific_ptr<std::vector<std::string>> m_contexts;
};
ThreadLocalLogContext g_logThreadContext;
diff --git a/libdevcore/Log.h b/libdevcore/Log.h
index 2dc547dd7..92e9493f1 100644
--- a/libdevcore/Log.h
+++ b/libdevcore/Log.h
@@ -25,12 +25,6 @@
#include <ctime>
#include <chrono>
-#pragma warning(push)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-parameter"
-#include <boost/thread.hpp>
-#pragma warning(pop)
-#pragma GCC diagnostic pop
#include "vector_ref.h"
#include "Common.h"
#include "CommonData.h"
diff --git a/libdevcore/Worker.h b/libdevcore/Worker.h
index 23c90ab78..4301639e4 100644
--- a/libdevcore/Worker.h
+++ b/libdevcore/Worker.h
@@ -24,6 +24,7 @@
#include <string>
#include <thread>
#include <atomic>
+#include <cassert>
#include "Guards.h"
namespace dev
diff --git a/libdevcore/boost_multiprecision_number_compare_bug_workaround.hpp b/libdevcore/boost_multiprecision_number_compare_bug_workaround.hpp
deleted file mode 100644
index dae591dfb..000000000
--- a/libdevcore/boost_multiprecision_number_compare_bug_workaround.hpp
+++ /dev/null
@@ -1,520 +0,0 @@
-
-// This is a copy of boost/multiprecision/detail/number_compare.hpp from boost 1.59 to replace buggy version from 1.58.
-
-#ifdef BOOST_MP_COMPARE_HPP
-#error This bug workaround header must be included before original boost/multiprecision/detail/number_compare.hpp
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// Copyright 2012 John Maddock. Distributed under the Boost
-// Software License, Version 1.0. (See accompanying file
-// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_MP_COMPARE_HPP
-#define BOOST_MP_COMPARE_HPP
-
-// A copy of boost/multiprecision/traits/is_backend.hpp
-#ifndef BOOST_MP_IS_BACKEND_HPP
-#define BOOST_MP_IS_BACKEND_HPP
-
-#include <boost/mpl/has_xxx.hpp>
-#include <boost/type_traits/conditional.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/multiprecision/detail/number_base.hpp>
-#include <boost/multiprecision/detail/generic_interconvert.hpp>
-
-namespace boost{ namespace multiprecision{ namespace detail{
-
- BOOST_MPL_HAS_XXX_TRAIT_DEF(signed_types)
- BOOST_MPL_HAS_XXX_TRAIT_DEF(unsigned_types)
- BOOST_MPL_HAS_XXX_TRAIT_DEF(float_types)
-
- template <class T>
- struct is_backend
- {
- static const bool value = has_signed_types<T>::value && has_unsigned_types<T>::value && has_float_types<T>::value;
- };
-
- template <class Backend>
- struct other_backend
- {
- typedef typename boost::conditional<
- boost::is_same<number<Backend>, number<Backend, et_on> >::value,
- number<Backend, et_off>, number<Backend, et_on> >::type type;
- };
-
- template <class B, class V>
- struct number_from_backend
- {
- typedef typename boost::conditional <
- boost::is_convertible<V, number<B> >::value,
- number<B>,
- typename other_backend<B>::type > ::type type;
- };
-
- template <bool b, class T, class U>
- struct is_first_backend_imp{ static const bool value = false; };
- template <class T, class U>
- struct is_first_backend_imp<true, T, U>{ static const bool value = is_convertible<U, number<T, et_on> >::value || is_convertible<U, number<T, et_off> >::value; };
-
- template <class T, class U>
- struct is_first_backend : is_first_backend_imp<is_backend<T>::value, T, U> {};
-
- template <bool b, class T, class U>
- struct is_second_backend_imp{ static const bool value = false; };
- template <class T, class U>
- struct is_second_backend_imp<true, T, U>{ static const bool value = is_convertible<T, number<U> >::value || is_convertible<T, number<U, et_off> >::value; };
-
- template <class T, class U>
- struct is_second_backend : is_second_backend_imp<is_backend<U>::value, T, U> {};
-
-}
-}
-}
-
-#endif // BOOST_MP_IS_BACKEND_HPP
-
-//
-// Comparison operators for number.
-//
-
-namespace boost{ namespace multiprecision{
-
-namespace default_ops{
-
-template <class B>
-inline bool eval_eq(const B& a, const B& b)
-{
- return a.compare(b) == 0;
-}
-template <class T, class U>
-inline typename enable_if_c<boost::multiprecision::detail::is_first_backend<T, U>::value, bool>::type eval_eq(const T& a, const U& b)
-{
- typename boost::multiprecision::detail::number_from_backend<T, U>::type t(b);
- return eval_eq(a, t.backend());
-}
-template <class T, class U>
-inline typename enable_if_c<boost::multiprecision::detail::is_second_backend<T, U>::value, bool>::type eval_eq(const T& a, const U& b)
-{
- typename boost::multiprecision::detail::number_from_backend<U, T>::type t(a);
- return eval_eq(t.backend(), b);
-}
-
-template <class B>
-inline bool eval_lt(const B& a, const B& b)
-{
- return a.compare(b) < 0;
-}
-template <class T, class U>
-inline typename enable_if_c<boost::multiprecision::detail::is_first_backend<T, U>::value, bool>::type eval_lt(const T& a, const U& b)
-{
- typename boost::multiprecision::detail::number_from_backend<T, U>::type t(b);
- return eval_lt(a, t.backend());
-}
-template <class T, class U>
-inline typename enable_if_c<boost::multiprecision::detail::is_second_backend<T, U>::value, bool>::type eval_lt(const T& a, const U& b)
-{
- typename boost::multiprecision::detail::number_from_backend<U, T>::type t(a);
- return eval_lt(t.backend(), b);
-}
-
-template <class B>
-inline bool eval_gt(const B& a, const B& b)
-{
- return a.compare(b) > 0;
-}
-template <class T, class U>
-inline typename enable_if_c<boost::multiprecision::detail::is_first_backend<T, U>::value, bool>::type eval_gt(const T& a, const U& b)
-{
- typename boost::multiprecision::detail::number_from_backend<T, U>::type t(b);
- return eval_gt(a, t.backend());
-}
-template <class T, class U>
-inline typename enable_if_c<boost::multiprecision::detail::is_second_backend<T, U>::value, bool>::type eval_gt(const T& a, const U& b)
-{
- typename boost::multiprecision::detail::number_from_backend<U, T>::type t(a);
- return eval_gt(t.backend(), b);
-}
-
-} // namespace default_ops
-
-namespace detail{
-
-template <class Num, class Val>
-struct is_valid_mixed_compare : public mpl::false_ {};
-
-template <class B, expression_template_option ET, class Val>
-struct is_valid_mixed_compare<number<B, ET>, Val> : public is_convertible<Val, number<B, ET> > {};
-
-template <class B, expression_template_option ET>
-struct is_valid_mixed_compare<number<B, ET>, number<B, ET> > : public mpl::false_ {};
-
-template <class B, expression_template_option ET, class tag, class Arg1, class Arg2, class Arg3, class Arg4>
-struct is_valid_mixed_compare<number<B, ET>, expression<tag, Arg1, Arg2, Arg3, Arg4> >
- : public mpl::bool_<is_convertible<expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::value> {};
-
-template <class tag, class Arg1, class Arg2, class Arg3, class Arg4, class B, expression_template_option ET>
-struct is_valid_mixed_compare<expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >
- : public mpl::bool_<is_convertible<expression<tag, Arg1, Arg2, Arg3, Arg4>, number<B, ET> >::value> {};
-
-template <class Backend, expression_template_option ExpressionTemplates>
-inline BOOST_CONSTEXPR typename boost::enable_if_c<number_category<Backend>::value != number_kind_floating_point, bool>::type is_unordered_value(const number<Backend, ExpressionTemplates>&)
-{
- return false;
-}
-template <class Backend, expression_template_option ExpressionTemplates>
-inline BOOST_CONSTEXPR typename boost::enable_if_c<number_category<Backend>::value == number_kind_floating_point, bool>::type is_unordered_value(const number<Backend, ExpressionTemplates>& a)
-{
- using default_ops::eval_fpclassify;
- return eval_fpclassify(a.backend()) == FP_NAN;
-}
-
-template <class Arithmetic>
-inline BOOST_CONSTEXPR typename boost::enable_if_c<number_category<Arithmetic>::value != number_kind_floating_point, bool>::type is_unordered_value(const Arithmetic&)
-{
- return false;
-}
-template <class Arithmetic>
-inline BOOST_CONSTEXPR typename boost::enable_if_c<number_category<Arithmetic>::value == number_kind_floating_point, bool>::type is_unordered_value(const Arithmetic& a)
-{
- return (boost::math::isnan)(a);
-}
-
-template <class T, class U>
-inline BOOST_CONSTEXPR bool is_unordered_comparison(const T& a, const U& b)
-{
- return is_unordered_value(a) || is_unordered_value(b);
-}
-
-}
-
-template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
-inline bool operator == (const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
-{
- using default_ops::eval_eq;
- if(detail::is_unordered_comparison(a, b)) return false;
- return eval_eq(a.backend(), b.backend());
-}
-template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
- operator == (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
-{
- using default_ops::eval_eq;
- if(detail::is_unordered_comparison(a, b)) return false;
- return eval_eq(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
-}
-template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
- operator == (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
-{
- using default_ops::eval_eq;
- if(detail::is_unordered_comparison(a, b)) return false;
- return eval_eq(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
-}
-template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
- operator == (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
-{
- typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
- using default_ops::eval_eq;
- result_type t(b);
- if(detail::is_unordered_comparison(a, t)) return false;
- return eval_eq(t.backend(), result_type::canonical_value(a));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
- operator == (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
-{
- typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
- using default_ops::eval_eq;
- result_type t(a);
- if(detail::is_unordered_comparison(t, b)) return false;
- return eval_eq(t.backend(), result_type::canonical_value(b));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
- operator == (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
-{
- using default_ops::eval_eq;
- typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
- typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
- if(detail::is_unordered_comparison(t, t2)) return false;
- return eval_eq(t.backend(), t2.backend());
-}
-
-template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
-inline bool operator != (const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
-{
- using default_ops::eval_eq;
- if(detail::is_unordered_comparison(a, b)) return true;
- return !eval_eq(a.backend(), b.backend());
-}
-template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
- operator != (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
-{
- using default_ops::eval_eq;
- if(detail::is_unordered_comparison(a, b)) return true;
- return !eval_eq(a.backend(), number<Backend, et_on>::canonical_value(b));
-}
-template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
- operator != (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
-{
- using default_ops::eval_eq;
- if(detail::is_unordered_comparison(a, b)) return true;
- return !eval_eq(b.backend(), number<Backend, et_on>::canonical_value(a));
-}
-template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
- operator != (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
-{
- typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
- using default_ops::eval_eq;
- result_type t(b);
- if(detail::is_unordered_comparison(a, t)) return true;
- return !eval_eq(t.backend(), result_type::canonical_value(a));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
- operator != (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
-{
- typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
- using default_ops::eval_eq;
- result_type t(a);
- if(detail::is_unordered_comparison(t, b)) return true;
- return !eval_eq(t.backend(), result_type::canonical_value(b));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
- operator != (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
-{
- using default_ops::eval_eq;
- typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
- typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
- if(detail::is_unordered_comparison(t, t2)) return true;
- return !eval_eq(t.backend(), t2.backend());
-}
-
-template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
-inline bool operator < (const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
-{
- using default_ops::eval_lt;
- if(detail::is_unordered_comparison(a, b)) return false;
- return eval_lt(a.backend(), b.backend());
-}
-template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
- operator < (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
-{
- using default_ops::eval_lt;
- if(detail::is_unordered_comparison(a, b)) return false;
- return eval_lt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
-}
-template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
- operator < (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
-{
- using default_ops::eval_gt;
- if(detail::is_unordered_comparison(a, b)) return false;
- return eval_gt(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
-}
-template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
- operator < (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
-{
- typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
- using default_ops::eval_gt;
- result_type t(b);
- if(detail::is_unordered_comparison(a, t)) return false;
- return eval_gt(t.backend(), result_type::canonical_value(a));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
- operator < (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
-{
- typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
- using default_ops::eval_lt;
- result_type t(a);
- if(detail::is_unordered_comparison(t, b)) return false;
- return eval_lt(t.backend(), result_type::canonical_value(b));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
- operator < (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
-{
- using default_ops::eval_lt;
- typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
- typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
- if(detail::is_unordered_comparison(t, t2)) return false;
- return eval_lt(t.backend(), t2.backend());
-}
-
-template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
-inline bool operator > (const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
-{
- using default_ops::eval_gt;
- if(detail::is_unordered_comparison(a, b)) return false;
- return eval_gt(a.backend(), b.backend());
-}
-template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
- operator > (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
-{
- using default_ops::eval_gt;
- if(detail::is_unordered_comparison(a, b)) return false;
- return eval_gt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
-}
-template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
- operator > (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
-{
- using default_ops::eval_lt;
- if(detail::is_unordered_comparison(a, b)) return false;
- return eval_lt(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
-}
-template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
- operator > (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
-{
- typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
- using default_ops::eval_lt;
- result_type t(b);
- if(detail::is_unordered_comparison(a, t)) return false;
- return a > t;
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
- operator > (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
-{
- typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
- using default_ops::eval_gt;
- result_type t(a);
- if(detail::is_unordered_comparison(t, b)) return false;
- return t > b;
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
- operator > (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
-{
- using default_ops::eval_gt;
- typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
- typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
- if(detail::is_unordered_comparison(t, t2)) return false;
- return t > t2;
-}
-
-template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
-inline bool operator <= (const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
-{
- using default_ops::eval_gt;
- if(detail::is_unordered_comparison(a, b)) return false;
- return !eval_gt(a.backend(), b.backend());
-}
-template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
- operator <= (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
-{
- using default_ops::eval_gt;
- if(detail::is_unordered_comparison(a, b)) return false;
- return !eval_gt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
-}
-template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
- operator <= (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
-{
- using default_ops::eval_lt;
- if(detail::is_unordered_comparison(a, b)) return false;
- return !eval_lt(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
-}
-template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
- operator <= (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
-{
- typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
- using default_ops::eval_lt;
- if(detail::is_unordered_value(a) || detail::is_unordered_value(b))
- return false;
- result_type t(b);
- if(detail::is_unordered_comparison(a, t)) return false;
- return !eval_lt(t.backend(), result_type::canonical_value(a));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
- operator <= (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
-{
- typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
- using default_ops::eval_gt;
- result_type t(a);
- if(detail::is_unordered_comparison(t, b)) return false;
- return !eval_gt(t.backend(), result_type::canonical_value(b));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
- operator <= (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
-{
- using default_ops::eval_gt;
- typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
- typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
- if(detail::is_unordered_comparison(t, t2)) return false;
- return !eval_gt(t.backend(), t2.backend());
-}
-
-template <class Backend, expression_template_option ExpressionTemplates, class Backend2, expression_template_option ExpressionTemplates2>
-inline bool operator >= (const number<Backend, ExpressionTemplates>& a, const number<Backend2, ExpressionTemplates2>& b)
-{
- using default_ops::eval_lt;
- if(detail::is_unordered_comparison(a, b)) return false;
- return !eval_lt(a.backend(), b.backend());
-}
-template <class Backend, expression_template_option ExpressionTemplates, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
- operator >= (const number<Backend, ExpressionTemplates>& a, const Arithmetic& b)
-{
- using default_ops::eval_lt;
- if(detail::is_unordered_comparison(a, b)) return false;
- return !eval_lt(a.backend(), number<Backend, ExpressionTemplates>::canonical_value(b));
-}
-template <class Arithmetic, class Backend, expression_template_option ExpressionTemplates>
-inline typename enable_if_c<detail::is_valid_mixed_compare<number<Backend, ExpressionTemplates>, Arithmetic>::value, bool>::type
- operator >= (const Arithmetic& a, const number<Backend, ExpressionTemplates>& b)
-{
- using default_ops::eval_gt;
- if(detail::is_unordered_comparison(a, b)) return false;
- return !eval_gt(b.backend(), number<Backend, ExpressionTemplates>::canonical_value(a));
-}
-template <class Arithmetic, class Tag, class A1, class A2, class A3, class A4>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
- operator >= (const Arithmetic& a, const detail::expression<Tag, A1, A2, A3, A4>& b)
-{
- typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
- using default_ops::eval_gt;
- result_type t(b);
- if(detail::is_unordered_comparison(a, t)) return false;
- return !eval_gt(t.backend(), result_type::canonical_value(a));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Arithmetic>
-inline typename enable_if_c<detail::is_valid_mixed_compare<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, Arithmetic>::value, bool>::type
- operator >= (const detail::expression<Tag, A1, A2, A3, A4>& a, const Arithmetic& b)
-{
- typedef typename detail::expression<Tag, A1, A2, A3, A4>::result_type result_type;
- using default_ops::eval_lt;
- result_type t(a);
- if(detail::is_unordered_comparison(t, b)) return false;
- return !eval_lt(t.backend(), result_type::canonical_value(b));
-}
-template <class Tag, class A1, class A2, class A3, class A4, class Tagb, class A1b, class A2b, class A3b, class A4b>
-inline typename enable_if<is_same<typename detail::expression<Tag, A1, A2, A3, A4>::result_type, typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type>, bool>::type
- operator >= (const detail::expression<Tag, A1, A2, A3, A4>& a, const detail::expression<Tagb, A1b, A2b, A3b, A4b>& b)
-{
- using default_ops::eval_lt;
- typename detail::expression<Tag, A1, A2, A3, A4>::result_type t(a);
- typename detail::expression<Tagb, A1b, A2b, A3b, A4b>::result_type t2(b);
- if(detail::is_unordered_comparison(t, t2)) return false;
- return !eval_lt(t.backend(), t2.backend());
-}
-
-
-}} // namespaces
-
-#endif // BOOST_MP_COMPARE_HPP
diff --git a/libethash-cl/CMakeLists.txt b/libethash-cl/CMakeLists.txt
index cc2d5f2da..9af84f9a4 100644
--- a/libethash-cl/CMakeLists.txt
+++ b/libethash-cl/CMakeLists.txt
@@ -20,7 +20,6 @@ file(GLOB OUR_HEADERS "*.h")
set(HEADERS ${OUR_HEADERS} ${CMAKE_CURRENT_BINARY_DIR}/ethash_cl_miner_kernel.h)
include_directories(${CMAKE_CURRENT_BINARY_DIR})
-include_directories(${Boost_INCLUDE_DIRS})
include_directories(..)
add_library(${EXECUTABLE} ${SRC_LIST} ${HEADERS})
target_include_directories(${EXECUTABLE} PUBLIC SYSTEM ${OpenCL_INCLUDE_DIR})
diff --git a/libethcore/CMakeLists.txt b/libethcore/CMakeLists.txt
index fb5f52b60..6adb99551 100644
--- a/libethcore/CMakeLists.txt
+++ b/libethcore/CMakeLists.txt
@@ -1,17 +1,14 @@
-cmake_policy(SET CMP0015 NEW)
-
file(GLOB SOURCES "*.cpp")
file(GLOB HEADERS "*.h")
include_directories(BEFORE ..)
-include_directories(${Boost_INCLUDE_DIRS})
if (ETHASHCUDA)
include_directories(${CUDA_INCLUDE_DIRS})
endif ()
add_library(ethcore ${SOURCES} ${HEADERS})
-target_link_libraries(ethcore ethash pthread)
+target_link_libraries(ethcore ethash devcore pthread)
if (ETHASHCL)
target_link_libraries(ethcore ethash-cl)
diff --git a/libethcore/EthashAux.cpp b/libethcore/EthashAux.cpp
index 1362e4fcc..88e80dc5b 100644
--- a/libethcore/EthashAux.cpp
+++ b/libethcore/EthashAux.cpp
@@ -44,15 +44,12 @@ const char* DAGChannel::name() { return EthGreen "DAG"; }
EthashAux* dev::eth::EthashAux::s_this = nullptr;
char dev::eth::EthashAux::s_dagDirName[256] = "";
-dev::eth::DAGEraseMode dev::eth::EthashAux::s_dagEraseMode = DAGEraseMode::None;
const unsigned EthashProofOfWork::defaultLocalWorkSize = 64;
const unsigned EthashProofOfWork::defaultGlobalWorkSizeMultiplier = 4096; // * CL_DEFAULT_LOCAL_WORK_SIZE
const unsigned EthashProofOfWork::defaultMSPerBatch = 0;
const EthashProofOfWork::WorkPackage EthashProofOfWork::NullWorkPackage = EthashProofOfWork::WorkPackage();
-//unsigned EthashProofOfWork::s_dagLoadMode = 0;
-
EthashAux::~EthashAux()
{
}
@@ -64,82 +61,11 @@ EthashAux* EthashAux::get()
return s_this;
}
-uint64_t EthashAux::cacheSize(BlockInfo const& _header)
-{
- return ethash_get_cachesize((uint64_t)_header.number());
-}
-
-uint64_t EthashAux::dataSize(uint64_t _blockNumber)
-{
- return ethash_get_datasize(_blockNumber);
-}
-
-
-void EthashAux::setDAGDirName(const char * custom_dir_name)
-{
- char strbuf[256];
- if (strcmp(custom_dir_name, "") != 0)
- strcpy(strbuf, custom_dir_name);
- else
- ethash_get_default_dirname(strbuf, 256);
-
- strcpy(s_dagDirName, strbuf);
-}
-
char * EthashAux::dagDirName()
{
return s_dagDirName;
}
-void EthashAux::setDAGEraseMode(DAGEraseMode mode)
-{
- s_dagEraseMode = mode;
-}
-
-void EthashAux::eraseDAGs()
-{
- if (s_dagEraseMode == DAGEraseMode::None) return;
-
- path p(s_dagDirName);
-
- if (!is_directory(p))
- {
- cnote << "Can't clean up DAG directory:" << s_dagDirName << "does not exist (yet).";
- return;
- }
-
- vector<path> files;
-
- directory_iterator end_itr;
-
- for (directory_iterator itr(p); itr != end_itr; ++itr)
- {
- if (is_regular_file(itr->path())) {
- files.push_back(itr->path());
- }
- }
-
- std::sort(files.begin(), files.end(),
- [](const path& p1, const path& p2)
- {
- return file_size(p1) < file_size(p2);
- });
-
- size_t dagcount = files.size();
- size_t dagcounter = 0;
- for (std::vector<path>::const_iterator path = files.begin(); path != files.end(); ++path)
- {
- if (s_dagEraseMode == DAGEraseMode::Bench && path->filename() == "full-R23-0000000000000000") {}
- else if ((s_dagEraseMode == DAGEraseMode::Old || s_dagEraseMode == DAGEraseMode::Bench) && dagcount - dagcounter <= 2) {}
- else
- {
- cnote << "Deleting DAG file " << path->string();
- remove(*path);
- }
- dagcounter++;
- }
-}
-
h256 EthashAux::seedHash(unsigned _number)
{
unsigned epoch = _number / ETHASH_EPOCH_LENGTH;
@@ -185,18 +111,11 @@ uint64_t EthashAux::number(h256 const& _seedHash)
return epoch * ETHASH_EPOCH_LENGTH;
}
-void EthashAux::killCache(h256 const& _s)
-{
- WriteGuard l(x_lights);
- m_lights.erase(_s);
-}
-
EthashAux::LightType EthashAux::light(h256 const& _seedHash)
{
- UpgradableGuard l(get()->x_lights);
+ Guard l(get()->x_lights);
if (get()->m_lights.count(_seedHash))
return get()->m_lights.at(_seedHash);
- UpgradeGuard l2(l);
return (get()->m_lights[_seedHash] = make_shared<LightAllocation>(_seedHash));
}
@@ -255,20 +174,15 @@ EthashAux::FullType EthashAux::full(h256 const& _seedHash, bool _createIfMissing
DEV_GUARDED(get()->x_fulls)
if ((ret = get()->m_fulls[_seedHash].lock()))
- {
- get()->m_lastUsedFull = ret;
return ret;
- }
if (_createIfMissing || computeFull(_seedHash, false) == 100)
{
s_dagCallback = _f;
-// cnote << "Loading from libethash...";
ret = make_shared<FullAllocation>(l->light, dagCallbackShim);
-// cnote << "Done loading.";
DEV_GUARDED(get()->x_fulls)
- get()->m_fulls[_seedHash] = get()->m_lastUsedFull = ret;
+ get()->m_fulls[_seedHash] = ret;
}
return ret;
@@ -286,7 +200,6 @@ unsigned EthashAux::computeFull(h256 const& _seedHash, bool _createIfMissing)
if (FullType ret = get()->m_fulls[_seedHash].lock())
{
- get()->m_lastUsedFull = ret;
return 100;
}
@@ -297,7 +210,6 @@ unsigned EthashAux::computeFull(h256 const& _seedHash, bool _createIfMissing)
get()->m_fullGenerator = unique_ptr<thread>(new thread([=](){
cnote << "Loading full DAG of seedhash: " << _seedHash;
get()->full(_seedHash, true, [](unsigned p){ get()->m_fullProgress = p; return 0; });
- eraseDAGs();
cnote << "Full DAG loaded";
get()->m_fullProgress = 0;
get()->m_generatingFullNumber = NotGenerating;
diff --git a/libethcore/EthashAux.h b/libethcore/EthashAux.h
index b729fc638..e41c6f130 100644
--- a/libethcore/EthashAux.h
+++ b/libethcore/EthashAux.h
@@ -65,7 +65,7 @@ struct EthashProofOfWork
h256 headerHash; ///< When h256() means "pause until notified a new work package is available".
h256 seedHash;
- uint64_t startNonce = 0;
+ uint64_t startNonce = 0;
int exSizeBits = -1;
};
@@ -120,14 +120,8 @@ public:
static h256 seedHash(unsigned _number);
static uint64_t number(h256 const& _seedHash);
- static uint64_t cacheSize(BlockInfo const& _header);
- static uint64_t dataSize(uint64_t _blockNumber);
- static void setDAGDirName(const char * custom_dir_name);
static char * dagDirName();
- static void setDAGEraseMode(DAGEraseMode mode);
- static void eraseDAGs();
-
static LightType light(h256 const& _seedHash);
static const uint64_t NotGenerating = (uint64_t)-1;
@@ -145,21 +139,14 @@ public:
private:
EthashAux() {}
- /// Kicks off generation of DAG for @a _blocknumber and blocks until ready; @returns result.
-
- void killCache(h256 const& _s);
-
static EthashAux* s_this;
static char s_dagDirName[256];
- static DAGEraseMode s_dagEraseMode;
- SharedMutex x_lights;
+ Mutex x_lights;
std::unordered_map<h256, std::shared_ptr<LightAllocation>> m_lights;
Mutex x_fulls;
- std::condition_variable m_fullsChanged;
std::unordered_map<h256, std::weak_ptr<FullAllocation>> m_fulls;
- FullType m_lastUsedFull;
std::unique_ptr<std::thread> m_fullGenerator;
uint64_t m_generatingFullNumber = NotGenerating;
unsigned m_fullProgress;
@@ -167,8 +154,6 @@ private:
Mutex x_epochs;
std::unordered_map<h256, unsigned> m_epochs;
h256s m_seedHashes;
-
-
};
}
diff --git a/libethcore/Farm.h b/libethcore/Farm.h
index 084a63422..087a4e99f 100644
--- a/libethcore/Farm.h
+++ b/libethcore/Farm.h
@@ -66,7 +66,7 @@ public:
*/
void setWork(WorkPackage const& _wp)
{
- WriteGuard l(x_minerWork);
+ Guard l(x_minerWork);
if (_wp.headerHash == m_work.headerHash && _wp.startNonce == m_work.startNonce)
return;
m_work = _wp;
@@ -82,7 +82,7 @@ public:
*/
bool start(std::string const& _sealer, bool mixed)
{
- WriteGuard l(x_minerWork);
+ Guard l(x_minerWork);
if (!m_miners.empty() && m_lastSealer == _sealer)
return true;
if (!m_sealers.count(_sealer))
@@ -119,7 +119,7 @@ public:
*/
void stop()
{
- WriteGuard l(x_minerWork);
+ Guard l(x_minerWork);
m_miners.clear();
m_work.reset();
m_isMining = false;
@@ -139,11 +139,11 @@ public:
WorkingProgress p;
p.ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - m_lastStart).count();
{
- ReadGuard l2(x_minerWork);
+ Guard l2(x_minerWork);
for (auto const& i: m_miners)
p.hashes += i->hashCount();
}
- ReadGuard l(x_progress);
+ Guard l(x_progress);
m_progress = p;
return m_progress;
}
@@ -153,7 +153,7 @@ public:
*/
void resetMiningProgress()
{
- DEV_READ_GUARDED(x_minerWork)
+ DEV_GUARDED(x_minerWork)
for (auto const& i: m_miners)
i->resetHashCount();
resetTimer();
@@ -198,7 +198,7 @@ public:
*/
void onSolutionFound(SolutionFound const& _handler) { m_onSolutionFound = _handler; }
- WorkPackage work() const { ReadGuard l(x_minerWork); return m_work; }
+ WorkPackage work() const { Guard l(x_minerWork); return m_work; }
private:
/**
@@ -229,13 +229,13 @@ private:
m_lastStart = std::chrono::steady_clock::now();
}
- mutable SharedMutex x_minerWork;
+ mutable Mutex x_minerWork;
std::vector<std::shared_ptr<Miner>> m_miners;
WorkPackage m_work;
std::atomic<bool> m_isMining = {false};
- mutable SharedMutex x_progress;
+ mutable Mutex x_progress;
mutable WorkingProgress m_progress;
std::chrono::steady_clock::time_point m_lastStart;
@@ -244,7 +244,6 @@ private:
std::map<std::string, SealerDescriptor> m_sealers;
std::string m_lastSealer;
- mutable SharedMutex x_solutionStats;
mutable SolutionStats m_solutionStats;
};
diff --git a/libstratum/CMakeLists.txt b/libstratum/CMakeLists.txt
index 349b6dbd1..7edafed44 100644
--- a/libstratum/CMakeLists.txt
+++ b/libstratum/CMakeLists.txt
@@ -1,15 +1,11 @@
-set(EXECUTABLE ethstratum)
-
-aux_source_directory(. SRC_LIST)
-
include_directories(..)
-include_directories(${Boost_INCLUDE_DIRS})
include_directories(${JSONCPP_INCLUDE_DIRS})
-file(GLOB HEADERS "*.h")
-
-add_library(${EXECUTABLE} ${SRC_LIST} ${HEADERS})
-target_link_libraries(${EXECUTABLE} ${Boost_SYSTEM_LIBRARY} ${Boost_THREAD_LIBRARY} ${Boost_REGEX_LIBRARY} pthread)
+set(SOURCES
+ EthStratumClient.h EthStratumClient.cpp
+ EthStratumClientV2.h EthStratumClientV2.cpp
+)
-install( TARGETS ${EXECUTABLE} RUNTIME DESTINATION bin ARCHIVE DESTINATION lib LIBRARY DESTINATION lib )
-install( FILES ${HEADERS} DESTINATION include/${EXECUTABLE} )
+add_library(ethstratum ${SOURCES})
+target_link_libraries(ethstratum PUBLIC Boost::system)
+target_include_directories(ethstratum PUBLIC SYSTEM ${JSONCPP_INCLUDE_DIRS})
diff --git a/libstratum/EthStratumClient.cpp b/libstratum/EthStratumClient.cpp
index c657ea0d6..be692986d 100644
--- a/libstratum/EthStratumClient.cpp
+++ b/libstratum/EthStratumClient.cpp
@@ -54,7 +54,8 @@ EthStratumClient::EthStratumClient(GenericFarm<EthashProofOfWork> * f, MinerType
EthStratumClient::~EthStratumClient()
{
-
+ m_io_service.stop();
+ m_serviceThread.join();
}
void EthStratumClient::setFailover(string const & host, string const & port)
@@ -72,18 +73,16 @@ void EthStratumClient::setFailover(string const & host, string const & port, str
void EthStratumClient::connect()
{
-
tcp::resolver r(m_io_service);
tcp::resolver::query q(p_active->host, p_active->port);
r.async_resolve(q, boost::bind(&EthStratumClient::resolve_handler,
- this, boost::asio::placeholders::error,
- boost::asio::placeholders::iterator));
-
+ this, boost::asio::placeholders::error,
+ boost::asio::placeholders::iterator));
+
cnote << "Connecting to stratum server " << p_active->host + ":" + p_active->port;
- boost::thread t(boost::bind(&boost::asio::io_service::run, &m_io_service));
-
+ m_serviceThread = std::thread{boost::bind(&boost::asio::io_service::run, &m_io_service)};
}
#define BOOST_ASIO_ENABLE_CANCELIO
@@ -147,8 +146,8 @@ void EthStratumClient::resolve_handler(const boost::system::error_code& ec, tcp:
if (!ec)
{
async_connect(m_socket, i, boost::bind(&EthStratumClient::connect_handler,
- this, boost::asio::placeholders::error,
- boost::asio::placeholders::iterator));
+ this, boost::asio::placeholders::error,
+ boost::asio::placeholders::iterator));
}
else
{
@@ -267,7 +266,6 @@ void EthStratumClient::readResponse(const boost::system::error_code& ec, std::si
if (reader.parse(response.c_str(), responseObject))
{
processReponse(responseObject);
- m_response = response;
}
else
{
@@ -301,7 +299,7 @@ void EthStratumClient::processExtranonce(std::string& enonce)
void EthStratumClient::processReponse(Json::Value& responseObject)
{
- Json::Value error = responseObject.get("error", new Json::Value);
+ Json::Value error = responseObject.get("error", {});
if (error.isArray())
{
string msg = error.get(1, "Unknown error").asString();
diff --git a/libstratum/EthStratumClient.h b/libstratum/EthStratumClient.h
index 6feb1ad67..6b4e49bae 100644
--- a/libstratum/EthStratumClient.h
+++ b/libstratum/EthStratumClient.h
@@ -65,12 +65,11 @@ private:
int m_waitState = MINER_WAIT_STATE_WORK;
- boost::mutex x_pending;
+ std::mutex x_pending;
int m_pending;
- string m_response;
GenericFarm<EthashProofOfWork> * p_farm;
- boost::mutex x_current;
+ std::mutex x_current;
EthashProofOfWork::WorkPackage m_current;
EthashProofOfWork::WorkPackage m_previous;
@@ -78,8 +77,8 @@ private:
string m_job;
string m_previousJob;
- EthashAux::FullType m_dag;
+ std::thread m_serviceThread; ///< The IO service thread.
boost::asio::io_service m_io_service;
tcp::socket m_socket;