diff --git a/CMakeLists.txt b/CMakeLists.txt index e1dd51ca..d2fb5262 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -21,6 +21,7 @@ set(HEADERS src/Options.h src/Summary.h src/version.h + src/workers/DoubleWorker.h src/workers/Handle.h src/workers/SingleWorker.h src/workers/Telemetry.h @@ -52,6 +53,7 @@ set(SOURCES src/net/Url.cpp src/Options.cpp src/Summary.cpp + src/workers/DoubleWorker.cpp src/workers/Handle.cpp src/workers/SingleWorker.cpp src/workers/Telemetry.cpp @@ -113,7 +115,7 @@ if (CMAKE_CXX_COMPILER_ID MATCHES GNU) add_definitions(/D_GNU_SOURCE) - #set(CMAKE_C_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -gdwarf-2") + set(CMAKE_C_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -gdwarf-2") elseif (CMAKE_CXX_COMPILER_ID MATCHES MSVC) diff --git a/src/App.cpp b/src/App.cpp index 06e512b6..a92883c1 100644 --- a/src/App.cpp +++ b/src/App.cpp @@ -82,7 +82,7 @@ int App::exec() Mem::allocate(m_options->algo(), m_options->threads(), m_options->doubleHash()); Summary::print(); - Workers::start(m_options->threads(), m_options->affinity(), m_options->nicehash()); + Workers::start(m_options->affinity(), m_options->nicehash()); m_network->connect(); diff --git a/src/Mem.h b/src/Mem.h index 89635e33..4198d8a2 100644 --- a/src/Mem.h +++ b/src/Mem.h @@ -48,9 +48,11 @@ public: static void *calloc(size_t num, size_t size); static void release(); + static inline bool isDoubleHash() { return m_doubleHash; } static inline bool isHugepagesAvailable() { return m_flags & HugepagesAvailable; } static inline bool isHugepagesEnabled() { return m_flags & HugepagesEnabled; } static inline int flags() { return m_flags; } + static inline int threads() { return m_threads; } private: static bool m_doubleHash; diff --git a/src/crypto/CryptoNight.cpp b/src/crypto/CryptoNight.cpp index e19e66ca..a463c9f9 100644 --- a/src/crypto/CryptoNight.cpp +++ b/src/crypto/CryptoNight.cpp @@ -38,38 +38,38 @@ static void cryptonight_av1_aesni(const void *input, size_t size, void *output, } -static void cryptonight_av2_aesni_double(const void *input, size_t size, void *output, struct cryptonight_ctx *ctx) { +static void cryptonight_av2_aesni_double(const void *input, size_t size, void *output, cryptonight_ctx *ctx) { cryptonight_double_hash<0x80000, MEMORY, 0x1FFFF0, false>(input, size, output, ctx); } -static void cryptonight_av3_softaes(const void *input, size_t size, void *output, struct cryptonight_ctx *ctx) { +static void cryptonight_av3_softaes(const void *input, size_t size, void *output, cryptonight_ctx *ctx) { cryptonight_hash<0x80000, MEMORY, 0x1FFFF0, true>(input, size, output, ctx); } -static void cryptonight_av4_softaes_double(const void *input, size_t size, void *output, struct cryptonight_ctx *ctx) { +static void cryptonight_av4_softaes_double(const void *input, size_t size, void *output, cryptonight_ctx *ctx) { cryptonight_double_hash<0x80000, MEMORY, 0x1FFFF0, true>(input, size, output, ctx); } #ifndef XMRIG_NO_AEON -static void cryptonight_lite_av1_aesni(const void *input, size_t size, void *output, struct cryptonight_ctx *ctx) { +static void cryptonight_lite_av1_aesni(const void *input, size_t size, void *output, cryptonight_ctx *ctx) { cryptonight_hash<0x40000, MEMORY_LITE, 0xFFFF0, false>(input, size, output, ctx); } -static void cryptonight_lite_av2_aesni_double(const void *input, size_t size, void *output, struct cryptonight_ctx *ctx) { +static void cryptonight_lite_av2_aesni_double(const void *input, size_t size, void *output, cryptonight_ctx *ctx) { cryptonight_double_hash<0x40000, MEMORY_LITE, 0xFFFF0, false>(input, size, output, ctx); } -static void cryptonight_lite_av3_softaes(const void *input, size_t size, void *output, struct cryptonight_ctx *ctx) { +static void cryptonight_lite_av3_softaes(const void *input, size_t size, void *output, cryptonight_ctx *ctx) { cryptonight_hash<0x40000, MEMORY_LITE, 0xFFFF0, true>(input, size, output, ctx); } -static void cryptonight_lite_av4_softaes_double(const void *input, size_t size, void *output, struct cryptonight_ctx *ctx) { +static void cryptonight_lite_av4_softaes_double(const void *input, size_t size, void *output, cryptonight_ctx *ctx) { cryptonight_double_hash<0x40000, MEMORY_LITE, 0xFFFF0, true>(input, size, output, ctx); } @@ -119,6 +119,12 @@ bool CryptoNight::init(int algo, int variant) } +void CryptoNight::hash(const uint8_t *input, size_t size, uint8_t *output, cryptonight_ctx *ctx) +{ + cryptonight_hash_ctx(input, size, output, ctx); +} + + bool CryptoNight::selfTest(int algo) { if (cryptonight_hash_ctx == nullptr) { return false; diff --git a/src/crypto/CryptoNight.h b/src/crypto/CryptoNight.h index 2ed5dfb2..29412730 100644 --- a/src/crypto/CryptoNight.h +++ b/src/crypto/CryptoNight.h @@ -51,6 +51,7 @@ class CryptoNight public: static bool hash(const Job &job, JobResult &result, cryptonight_ctx *ctx); static bool init(int algo, int variant); + static void hash(const uint8_t *input, size_t size, uint8_t *output, cryptonight_ctx *ctx); private: static bool selfTest(int algo); diff --git a/src/net/Job.h b/src/net/Job.h index 9848f128..262465fc 100644 --- a/src/net/Job.h +++ b/src/net/Job.h @@ -50,8 +50,9 @@ public: inline void setPoolId(int poolId) { m_poolId = poolId; } static bool fromHex(const char* in, unsigned int len, unsigned char* out); - static void toHex(const unsigned char* in, unsigned int len, char* out); + static inline uint32_t *nonce(uint8_t *blob) { return reinterpret_cast(blob + 39); } static inline uint64_t toDiff(uint64_t target) { return 0xFFFFFFFFFFFFFFFFULL / target; } + static void toHex(const unsigned char* in, unsigned int len, char* out); private: int m_poolId; diff --git a/src/net/JobResult.h b/src/net/JobResult.h index ba067cdc..55ebdbd2 100644 --- a/src/net/JobResult.h +++ b/src/net/JobResult.h @@ -31,6 +31,13 @@ class JobResult { public: + inline JobResult() : poolId(0), nonce(0) {} + inline JobResult(int poolId, const char *jobId, uint32_t nonce, const uint8_t *result) : poolId(poolId), nonce(nonce) + { + memcpy(this->jobId, jobId, sizeof(this->jobId)); + memcpy(this->result, result, sizeof(this->result)); + } + char jobId[64]; int poolId; uint32_t nonce; diff --git a/src/workers/DoubleWorker.cpp b/src/workers/DoubleWorker.cpp new file mode 100644 index 00000000..f7a56dbf --- /dev/null +++ b/src/workers/DoubleWorker.cpp @@ -0,0 +1,97 @@ +/* XMRig + * Copyright 2010 Jeff Garzik + * Copyright 2012-2014 pooler + * Copyright 2014 Lucas Jones + * Copyright 2014-2016 Wolf9466 + * Copyright 2016 Jay D Dee + * Copyright 2016-2017 XMRig + * + * + * This program 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. + * + * This program 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 this program. If not, see . + */ + + +#include + + +#include "crypto/CryptoNight.h" +#include "workers/DoubleWorker.h" +#include "workers/Workers.h" + + +DoubleWorker::DoubleWorker(Handle *handle) + : Worker(handle), + m_nonce1(0), + m_nonce2(0) +{ +} + + +void DoubleWorker::start() +{ + while (true) { + if (Workers::isPaused()) { + do { + std::this_thread::sleep_for(std::chrono::milliseconds(200)); + } + while (Workers::isPaused()); + + consumeJob(); + } + + while (!Workers::isOutdated(m_sequence)) { + if ((m_count & 0xF) == 0) { + storeStats(); + } + + m_count += 2; + *Job::nonce(m_blob) = ++m_nonce1; + *Job::nonce(m_blob + m_job.size()) = ++m_nonce2; + + CryptoNight::hash(m_blob, m_job.size(), m_hash, m_ctx); + + if (*reinterpret_cast(m_hash + 24) < m_job.target()) { + Workers::submit(JobResult(m_job.poolId(), m_job.id(), m_nonce1, m_hash)); + } + + if (*reinterpret_cast(m_hash + 32 + 24) < m_job.target()) { + Workers::submit(JobResult(m_job.poolId(), m_job.id(), m_nonce2, m_hash + 32)); + } + + std::this_thread::yield(); + } + + consumeJob(); + } +} + + + +void DoubleWorker::consumeJob() +{ + m_job = Workers::job(); + m_sequence = Workers::sequence(); + + memcpy(m_blob, m_job.blob(), m_job.size()); + memcpy(m_blob + m_job.size(), m_job.blob(), m_job.size()); + + if (m_nicehash) { + m_nonce1 = (*Job::nonce(m_blob) & 0xff000000U) + (0xffffffU / (m_threads * 2) * m_id); + m_nonce2 = (*Job::nonce(m_blob + m_job.size()) & 0xff000000U) + (0xffffffU / (m_threads * 2) * (m_id + m_threads)); + } + else { + m_nonce1 = 0xffffffffU / (m_threads * 2) * m_id; + m_nonce2 = 0xffffffffU / (m_threads * 2) * (m_id + m_threads); + } +} diff --git a/src/workers/DoubleWorker.h b/src/workers/DoubleWorker.h new file mode 100644 index 00000000..d062dac0 --- /dev/null +++ b/src/workers/DoubleWorker.h @@ -0,0 +1,55 @@ +/* XMRig + * Copyright 2010 Jeff Garzik + * Copyright 2012-2014 pooler + * Copyright 2014 Lucas Jones + * Copyright 2014-2016 Wolf9466 + * Copyright 2016 Jay D Dee + * Copyright 2016-2017 XMRig + * + * + * This program 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. + * + * This program 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 this program. If not, see . + */ + +#ifndef __DOUBLEWORKER_H__ +#define __DOUBLEWORKER_H__ + + +#include "align.h" +#include "net/Job.h" +#include "net/JobResult.h" +#include "workers/Worker.h" + + +class Handle; + + +class DoubleWorker : public Worker +{ +public: + DoubleWorker(Handle *handle); + + void start() override; + +private: + void consumeJob(); + + Job m_job; + uint32_t m_nonce1; + uint32_t m_nonce2; + uint8_t m_hash[64]; + uint8_t m_blob[84 * 2]; +}; + + +#endif /* __SINGLEWORKER_H__ */ diff --git a/src/workers/SingleWorker.cpp b/src/workers/SingleWorker.cpp index 3969e883..9c56b7d8 100644 --- a/src/workers/SingleWorker.cpp +++ b/src/workers/SingleWorker.cpp @@ -60,7 +60,7 @@ void SingleWorker::start() Workers::submit(m_result); } -// sched_yield(); + std::this_thread::yield(); } consumeJob(); diff --git a/src/workers/Worker.cpp b/src/workers/Worker.cpp index 5478bcf7..1cede65f 100644 --- a/src/workers/Worker.cpp +++ b/src/workers/Worker.cpp @@ -40,8 +40,6 @@ Worker::Worker(Handle *handle) : m_count(0), m_sequence(0) { - handle->setWorker(this); - if (Cpu::threads() > 1 && handle->affinity() != -1L) { Cpu::setAffinity(m_id, handle->affinity()); } diff --git a/src/workers/Workers.cpp b/src/workers/Workers.cpp index b3673445..27453fdb 100644 --- a/src/workers/Workers.cpp +++ b/src/workers/Workers.cpp @@ -26,6 +26,8 @@ #include "Console.h" #include "interfaces/IJobResultListener.h" +#include "Mem.h" +#include "workers/DoubleWorker.h" #include "workers/Handle.h" #include "workers/SingleWorker.h" #include "workers/Telemetry.h" @@ -67,8 +69,9 @@ void Workers::setJob(const Job &job) } -void Workers::start(int threads, int64_t affinity, bool nicehash) +void Workers::start(int64_t affinity, bool nicehash) { + const int threads = Mem::threads(); m_telemetry = new Telemetry(threads); uv_mutex_init(&m_mutex); @@ -103,8 +106,14 @@ void Workers::submit(const JobResult &result) void Workers::onReady(void *arg) { auto handle = static_cast(arg); - IWorker *worker = new SingleWorker(handle); - worker->start(); + if (Mem::isDoubleHash()) { + handle->setWorker(new DoubleWorker(handle)); + } + else { + handle->setWorker(new SingleWorker(handle)); + } + + handle->worker()->start(); } diff --git a/src/workers/Workers.h b/src/workers/Workers.h index 5e398109..6cf17de4 100644 --- a/src/workers/Workers.h +++ b/src/workers/Workers.h @@ -44,7 +44,7 @@ class Workers public: static Job job(); static void setJob(const Job &job); - static void start(int threads, int64_t affinity, bool nicehash); + static void start(int64_t affinity, bool nicehash); static void submit(const JobResult &result); static inline bool isOutdated(uint64_t sequence) { return m_sequence.load(std::memory_order_relaxed) != sequence; }